From 20a9892123eb24accfee7eb97b99c2092b5ceca0 Mon Sep 17 00:00:00 2001
From: Mike Hearn <mike@r3cev.com>
Date: Fri, 22 Sep 2017 15:22:40 +0200
Subject: [PATCH 001/185] RPC: Report failures during deserialisation of method
 arguments to the client as an exception.

---
 .../main/kotlin/net/corda/nodeapi/RPCApi.kt   | 31 +++++++++++++++----
 .../node/services/messaging/RPCServer.kt      | 26 +++++++++++++---
 2 files changed, 47 insertions(+), 10 deletions(-)

diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt b/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt
index 8fc01b0e7d..7abeae27ad 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt
@@ -128,15 +128,26 @@ object RPCApi {
         }
 
         companion object {
+
             fun fromClientMessage(context: SerializationContext, message: ClientMessage): ClientToServer {
                 val tag = Tag.values()[message.getIntProperty(TAG_FIELD_NAME)]
                 return when (tag) {
-                    RPCApi.ClientToServer.Tag.RPC_REQUEST -> RpcRequest(
-                            clientAddress = MessageUtil.getJMSReplyTo(message),
-                            id = RpcRequestId(message.getLongProperty(RPC_ID_FIELD_NAME)),
-                            methodName = message.getStringProperty(METHOD_NAME_FIELD_NAME),
-                            arguments = message.getBodyAsByteArray().deserialize(context = context)
-                    )
+                    RPCApi.ClientToServer.Tag.RPC_REQUEST -> {
+                        val partialReq = RpcRequest(
+                                clientAddress = MessageUtil.getJMSReplyTo(message),
+                                id = RpcRequestId(message.getLongProperty(RPC_ID_FIELD_NAME)),
+                                methodName = message.getStringProperty(METHOD_NAME_FIELD_NAME),
+                                arguments = emptyList()
+                        )
+                        // Deserialisation of the arguments can fail, but we'd like to return a response mapped to
+                        // this specific RPC, so we throw the partial request with ID and method name.
+                        try {
+                            val arguments = message.getBodyAsByteArray().deserialize<List<Any?>>(context = context)
+                            return partialReq.copy(arguments = arguments)
+                        } catch (t: Throwable) {
+                            throw ArgumentDeserialisationException(t, partialReq)
+                        }
+                    }
                     RPCApi.ClientToServer.Tag.OBSERVABLES_CLOSED -> {
                         val ids = ArrayList<ObservableId>()
                         val buffer = message.bodyBuffer
@@ -149,6 +160,7 @@ object RPCApi {
                 }
             }
         }
+
     }
 
     /**
@@ -215,6 +227,13 @@ object RPCApi {
             }
         }
     }
+
+    /**
+     * Thrown when the arguments passed to an RPC couldn't be deserialised by the server. This will
+     * typically indicate a missing application on the server side, or different versions between
+     * client and server.
+     */
+    class ArgumentDeserialisationException(cause: Throwable, val reqWithNoArguments: ClientToServer.RpcRequest) : RPCException("Failed to deserialise RPC arguments: version or app skew between client and server?", cause)
 }
 
 data class ArtemisProducer(
diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt b/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
index b4c61c2574..a36cc675e7 100644
--- a/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
+++ b/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
@@ -260,13 +260,31 @@ class RPCServer(
 
     private fun clientArtemisMessageHandler(artemisMessage: ClientMessage) {
         lifeCycle.requireState(State.STARTED)
-        val clientToServer = RPCApi.ClientToServer.fromClientMessage(RPC_SERVER_CONTEXT, artemisMessage)
+
+        // Attempt de-serialisation of the RPC request message, in such a way that we can route the error back to
+        // the RPC that was being tried if it fails in a method/rpc specific way.
+        val clientToServerTry = Try.on { RPCApi.ClientToServer.fromClientMessage(RPC_SERVER_CONTEXT, artemisMessage) }
+        val clientToServer = try {
+            clientToServerTry.getOrThrow()
+        } catch (e: RPCApi.ArgumentDeserialisationException) {
+            // The exception itself has a more informative error message, and this could be caused by buggy apps, so
+            // let's just log it as a warning instead of an error. Relay the failure to the client so they can see it.
+            log.warn("Inbound RPC failed", e)
+            sendReply(e.reqWithNoArguments.id, e.reqWithNoArguments.clientAddress, Try.Failure(e.cause!!))
+            return
+        } catch (e: Exception) {
+            // This path indicates something more fundamental went wrong, like a missing message header.
+            log.error("Failed to parse an inbound RPC: version skew between client and server?", e)
+            return
+        } finally {
+            artemisMessage.acknowledge()
+        }
+
+        // Now try dispatching the request itself.
         log.debug { "-> RPC -> $clientToServer" }
         when (clientToServer) {
             is RPCApi.ClientToServer.RpcRequest -> {
-                val rpcContext = RpcContext(
-                        currentUser = getUser(artemisMessage)
-                )
+                val rpcContext = RpcContext(currentUser = getUser(artemisMessage))
                 rpcExecutor!!.submit {
                     val result = invokeRpc(rpcContext, clientToServer.methodName, clientToServer.arguments)
                     sendReply(clientToServer.id, clientToServer.clientAddress, result)

From 9d115a2111dbcfa2f11e9689c2912a33ba213a6b Mon Sep 17 00:00:00 2001
From: Andras Slemmer <andras.slemmer@r3cev.com>
Date: Tue, 26 Sep 2017 10:53:07 +0100
Subject: [PATCH 002/185] Delay RPC arguments deserialisation to allow routing
 of errors

---
 .../net/corda/client/rpc/RPCStabilityTests.kt |  5 ++-
 .../rpc/internal/RPCClientProxyHandler.kt     |  6 ++-
 .../java/net/corda/docs/FlowCookbookJava.java |  1 -
 .../main/kotlin/net/corda/nodeapi/RPCApi.kt   | 41 +++++-------------
 .../node/services/messaging/RPCServer.kt      | 43 ++++++++-----------
 5 files changed, 36 insertions(+), 60 deletions(-)

diff --git a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/RPCStabilityTests.kt b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/RPCStabilityTests.kt
index 4433ba03be..2e83e1f08a 100644
--- a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/RPCStabilityTests.kt
+++ b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/RPCStabilityTests.kt
@@ -7,6 +7,7 @@ import net.corda.core.internal.concurrent.fork
 import net.corda.core.internal.concurrent.transpose
 import net.corda.core.messaging.RPCOps
 import net.corda.core.serialization.SerializationDefaults
+import net.corda.core.serialization.serialize
 import net.corda.core.utilities.*
 import net.corda.node.services.messaging.RPCServerConfiguration
 import net.corda.nodeapi.RPCApi
@@ -315,9 +316,9 @@ class RPCStabilityTests {
                     clientAddress = SimpleString(myQueue),
                     id = RPCApi.RpcRequestId(random63BitValue()),
                     methodName = SlowConsumerRPCOps::streamAtInterval.name,
-                    arguments = listOf(10.millis, 123456)
+                    serialisedArguments = listOf(10.millis, 123456).serialize(context = SerializationDefaults.RPC_SERVER_CONTEXT).bytes
             )
-            request.writeToClientMessage(SerializationDefaults.RPC_SERVER_CONTEXT, message)
+            request.writeToClientMessage(message)
             producer.send(message)
             session.commit()
 
diff --git a/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClientProxyHandler.kt b/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClientProxyHandler.kt
index 10e901eb70..a777a0c96a 100644
--- a/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClientProxyHandler.kt
+++ b/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClientProxyHandler.kt
@@ -19,6 +19,7 @@ import net.corda.core.internal.LifeCycle
 import net.corda.core.internal.ThreadBox
 import net.corda.core.messaging.RPCOps
 import net.corda.core.serialization.SerializationContext
+import net.corda.core.serialization.serialize
 import net.corda.core.utilities.Try
 import net.corda.core.utilities.debug
 import net.corda.core.utilities.getOrThrow
@@ -208,11 +209,12 @@ class RPCClientProxyHandler(
         val rpcId = RPCApi.RpcRequestId(random63BitValue())
         callSiteMap?.set(rpcId.toLong, Throwable("<Call site of root RPC '${method.name}'>"))
         try {
-            val request = RPCApi.ClientToServer.RpcRequest(clientAddress, rpcId, method.name, arguments?.toList() ?: emptyList())
+            val serialisedArguments = (arguments?.toList() ?: emptyList()).serialize(context = serializationContextWithObservableContext)
+            val request = RPCApi.ClientToServer.RpcRequest(clientAddress, rpcId, method.name, serialisedArguments.bytes)
             val replyFuture = SettableFuture.create<Any>()
             sessionAndProducerPool.run {
                 val message = it.session.createMessage(false)
-                request.writeToClientMessage(serializationContextWithObservableContext, message)
+                request.writeToClientMessage(message)
 
                 log.debug {
                     val argumentsString = arguments?.joinToString() ?: ""
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
index 6619fb47b9..370e69cbb9 100644
--- a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
+++ b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
@@ -548,7 +548,6 @@ public class FlowCookbookJava {
                 // DOCSTART 37
                 twiceSignedTx.checkSignaturesAreValid();
                 // DOCEND 37
-
             } catch (GeneralSecurityException e) {
                 // Handle this as required.
             }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt b/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt
index 7abeae27ad..d2de3777f6 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt
@@ -97,20 +97,20 @@ object RPCApi {
          * @param clientAddress return address to contact the client at.
          * @param id a unique ID for the request, which the server will use to identify its response with.
          * @param methodName name of the method (procedure) to be called.
-         * @param arguments arguments to pass to the method, if any.
+         * @param serialisedArguments Serialised arguments to pass to the method, if any.
          */
         data class RpcRequest(
                 val clientAddress: SimpleString,
                 val id: RpcRequestId,
                 val methodName: String,
-                val arguments: List<Any?>
+                val serialisedArguments: ByteArray
         ) : ClientToServer() {
-            fun writeToClientMessage(context: SerializationContext, message: ClientMessage) {
+            fun writeToClientMessage(message: ClientMessage) {
                 MessageUtil.setJMSReplyTo(message, clientAddress)
                 message.putIntProperty(TAG_FIELD_NAME, Tag.RPC_REQUEST.ordinal)
                 message.putLongProperty(RPC_ID_FIELD_NAME, id.toLong)
                 message.putStringProperty(METHOD_NAME_FIELD_NAME, methodName)
-                message.bodyBuffer.writeBytes(arguments.serialize(context = context).bytes)
+                message.bodyBuffer.writeBytes(serialisedArguments)
             }
         }
 
@@ -128,26 +128,15 @@ object RPCApi {
         }
 
         companion object {
-
-            fun fromClientMessage(context: SerializationContext, message: ClientMessage): ClientToServer {
+            fun fromClientMessage(message: ClientMessage): ClientToServer {
                 val tag = Tag.values()[message.getIntProperty(TAG_FIELD_NAME)]
                 return when (tag) {
-                    RPCApi.ClientToServer.Tag.RPC_REQUEST -> {
-                        val partialReq = RpcRequest(
-                                clientAddress = MessageUtil.getJMSReplyTo(message),
-                                id = RpcRequestId(message.getLongProperty(RPC_ID_FIELD_NAME)),
-                                methodName = message.getStringProperty(METHOD_NAME_FIELD_NAME),
-                                arguments = emptyList()
-                        )
-                        // Deserialisation of the arguments can fail, but we'd like to return a response mapped to
-                        // this specific RPC, so we throw the partial request with ID and method name.
-                        try {
-                            val arguments = message.getBodyAsByteArray().deserialize<List<Any?>>(context = context)
-                            return partialReq.copy(arguments = arguments)
-                        } catch (t: Throwable) {
-                            throw ArgumentDeserialisationException(t, partialReq)
-                        }
-                    }
+                    RPCApi.ClientToServer.Tag.RPC_REQUEST -> RpcRequest(
+                            clientAddress = MessageUtil.getJMSReplyTo(message),
+                            id = RpcRequestId(message.getLongProperty(RPC_ID_FIELD_NAME)),
+                            methodName = message.getStringProperty(METHOD_NAME_FIELD_NAME),
+                            serialisedArguments = message.getBodyAsByteArray()
+                    )
                     RPCApi.ClientToServer.Tag.OBSERVABLES_CLOSED -> {
                         val ids = ArrayList<ObservableId>()
                         val buffer = message.bodyBuffer
@@ -160,7 +149,6 @@ object RPCApi {
                 }
             }
         }
-
     }
 
     /**
@@ -227,13 +215,6 @@ object RPCApi {
             }
         }
     }
-
-    /**
-     * Thrown when the arguments passed to an RPC couldn't be deserialised by the server. This will
-     * typically indicate a missing application on the server side, or different versions between
-     * client and server.
-     */
-    class ArgumentDeserialisationException(cause: Throwable, val reqWithNoArguments: ClientToServer.RpcRequest) : RPCException("Failed to deserialise RPC arguments: version or app skew between client and server?", cause)
 }
 
 data class ArtemisProducer(
diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt b/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
index a36cc675e7..70761cfc4e 100644
--- a/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
+++ b/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
@@ -19,6 +19,7 @@ import net.corda.core.internal.LifeCycle
 import net.corda.core.messaging.RPCOps
 import net.corda.core.serialization.SerializationContext
 import net.corda.core.serialization.SerializationDefaults.RPC_SERVER_CONTEXT
+import net.corda.core.serialization.deserialize
 import net.corda.core.utilities.Try
 import net.corda.core.utilities.debug
 import net.corda.core.utilities.loggerFor
@@ -260,34 +261,26 @@ class RPCServer(
 
     private fun clientArtemisMessageHandler(artemisMessage: ClientMessage) {
         lifeCycle.requireState(State.STARTED)
-
-        // Attempt de-serialisation of the RPC request message, in such a way that we can route the error back to
-        // the RPC that was being tried if it fails in a method/rpc specific way.
-        val clientToServerTry = Try.on { RPCApi.ClientToServer.fromClientMessage(RPC_SERVER_CONTEXT, artemisMessage) }
-        val clientToServer = try {
-            clientToServerTry.getOrThrow()
-        } catch (e: RPCApi.ArgumentDeserialisationException) {
-            // The exception itself has a more informative error message, and this could be caused by buggy apps, so
-            // let's just log it as a warning instead of an error. Relay the failure to the client so they can see it.
-            log.warn("Inbound RPC failed", e)
-            sendReply(e.reqWithNoArguments.id, e.reqWithNoArguments.clientAddress, Try.Failure(e.cause!!))
-            return
-        } catch (e: Exception) {
-            // This path indicates something more fundamental went wrong, like a missing message header.
-            log.error("Failed to parse an inbound RPC: version skew between client and server?", e)
-            return
-        } finally {
-            artemisMessage.acknowledge()
-        }
-
-        // Now try dispatching the request itself.
+        val clientToServer = RPCApi.ClientToServer.fromClientMessage(artemisMessage)
         log.debug { "-> RPC -> $clientToServer" }
         when (clientToServer) {
             is RPCApi.ClientToServer.RpcRequest -> {
-                val rpcContext = RpcContext(currentUser = getUser(artemisMessage))
-                rpcExecutor!!.submit {
-                    val result = invokeRpc(rpcContext, clientToServer.methodName, clientToServer.arguments)
-                    sendReply(clientToServer.id, clientToServer.clientAddress, result)
+                val arguments = Try.on {
+                    clientToServer.serialisedArguments.deserialize<List<Any?>>(context = RPC_SERVER_CONTEXT)
+                }
+                when (arguments) {
+                    is Try.Success -> {
+                        val rpcContext = RpcContext(currentUser = getUser(artemisMessage))
+                        rpcExecutor!!.submit {
+                            val result = invokeRpc(rpcContext, clientToServer.methodName, arguments.value)
+                            sendReply(clientToServer.id, clientToServer.clientAddress, result)
+                        }
+                    }
+                    is Try.Failure -> {
+                        // We failed to deserialise the arguments, route back the error
+                        log.warn("Inbound RPC failed", arguments.exception)
+                        sendReply(clientToServer.id, clientToServer.clientAddress, arguments)
+                    }
                 }
             }
             is RPCApi.ClientToServer.ObservablesClosed -> {

From 24ff7efd5f991a434f85413f1aa1f8c539be5e79 Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Tue, 26 Sep 2017 17:15:11 +0100
Subject: [PATCH 003/185] Cordapps now have a name field (#1645)

* Cordapps now have a name field.
---
 core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt         | 2 ++
 .../main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt | 3 +++
 docs/source/changelog.rst                                      | 2 ++
 node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt    | 1 +
 4 files changed, 8 insertions(+)

diff --git a/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt b/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
index ff9426ec90..2df896cbbe 100644
--- a/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
+++ b/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
@@ -13,6 +13,7 @@ import java.net.URL
  *
  * This will only need to be constructed manually for certain kinds of tests.
  *
+ * @property name Cordapp name - derived from the base name of the Cordapp JAR (therefore may not be unique)
  * @property contractClassNames List of contracts
  * @property initiatedFlows List of initiatable flow classes
  * @property rpcFlows List of RPC initiable flows classes
@@ -22,6 +23,7 @@ import java.net.URL
  * @property jarPath The path to the JAR for this CorDapp
  */
 interface Cordapp {
+    val name: String
     val contractClassNames: List<String>
     val initiatedFlows: List<Class<out FlowLogic<*>>>
     val rpcFlows: List<Class<out FlowLogic<*>>>
diff --git a/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt b/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
index 4f7aecd6fe..38a5a0ecf4 100644
--- a/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
@@ -5,6 +5,7 @@ import net.corda.core.flows.FlowLogic
 import net.corda.core.node.CordaPluginRegistry
 import net.corda.core.schemas.MappedSchema
 import net.corda.core.serialization.SerializeAsToken
+import java.io.File
 import java.net.URL
 
 data class CordappImpl(
@@ -15,6 +16,8 @@ data class CordappImpl(
         override val plugins: List<CordaPluginRegistry>,
         override val customSchemas: Set<MappedSchema>,
         override val jarPath: URL) : Cordapp {
+    override val name: String = File(jarPath.toURI()).name.removeSuffix(".jar")
+
     /**
      * An exhaustive list of all classes relevant to the node within this CorDapp
      *
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index 194a00deee..af1374367b 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -7,6 +7,8 @@ from the previous milestone release.
 UNRELEASED
 ----------
 
+* ``Cordapp`` now has a name field for identifying CorDapps and all CorDapp names are printed to console at startup.
+
 Release 1.0
 -----------
 
diff --git a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
index 6fb990d27e..0b645a2c48 100644
--- a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
@@ -263,6 +263,7 @@ open class NodeStartup(val args: Array<String>) {
         node.configuration.extraAdvertisedServiceIds.let {
             if (it.isNotEmpty()) Node.printBasicNodeInfo("Providing network services", it.joinToString())
         }
+        Node.printBasicNodeInfo("Loaded CorDapps", node.cordappProvider.cordapps.map { it.name }.joinToString())
         val plugins = node.pluginRegistries
                 .map { it.javaClass.name }
                 .filterNot { it.startsWith("net.corda.node.") || it.startsWith("net.corda.core.") || it.startsWith("net.corda.nodeapi.") }

From aff4d35ccbbbc73ca1556660ee3390d72fbd4711 Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Tue, 26 Sep 2017 18:22:35 +0100
Subject: [PATCH 004/185] Enforce JSON serialized key format (#1606)

Move Jackson public key encode/decode support away from Kryo serialization format for compactness and to DER format encoded as base64 for compatibility with other systems.
---
 .../corda/client/jackson/JacksonSupport.kt    | 67 +++++++------------
 .../client/jackson/JacksonSupportTest.kt      | 30 +++++++--
 .../net/corda/irs/simulation/trade.json       |  6 +-
 3 files changed, 54 insertions(+), 49 deletions(-)

diff --git a/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt b/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt
index a9935f12fc..4fcd8415b4 100644
--- a/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt
+++ b/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt
@@ -28,8 +28,9 @@ import net.corda.core.transactions.NotaryChangeWireTransaction
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.WireTransaction
 import net.corda.core.utilities.OpaqueBytes
-import net.corda.core.utilities.parsePublicKeyBase58
-import net.corda.core.utilities.toBase58String
+import net.corda.core.utilities.base58ToByteArray
+import net.corda.core.utilities.base64ToByteArray
+import net.corda.core.utilities.toBase64
 import net.i2p.crypto.eddsa.EdDSAPublicKey
 import java.math.BigDecimal
 import java.security.PublicKey
@@ -83,13 +84,9 @@ object JacksonSupport {
             addDeserializer(SecureHash::class.java, SecureHashDeserializer())
             addDeserializer(SecureHash.SHA256::class.java, SecureHashDeserializer())
 
-            // For ed25519 pubkeys
-            addSerializer(EdDSAPublicKey::class.java, PublicKeySerializer)
-            addDeserializer(EdDSAPublicKey::class.java, PublicKeyDeserializer)
-
-            // For composite keys
-            addSerializer(CompositeKey::class.java, CompositeKeySerializer)
-            addDeserializer(CompositeKey::class.java, CompositeKeyDeserializer)
+            // Public key types
+            addSerializer(PublicKey::class.java, PublicKeySerializer)
+            addDeserializer(PublicKey::class.java, PublicKeyDeserializer)
 
             // For NodeInfo
             // TODO this tunnels the Kryo representation as a Base58 encoded string. Replace when RPC supports this.
@@ -158,7 +155,7 @@ object JacksonSupport {
 
     object AnonymousPartySerializer : JsonSerializer<AnonymousParty>() {
         override fun serialize(obj: AnonymousParty, generator: JsonGenerator, provider: SerializerProvider) {
-            generator.writeString(obj.owningKey.toBase58String())
+            PublicKeySerializer.serialize(obj.owningKey, generator, provider)
         }
     }
 
@@ -168,8 +165,7 @@ object JacksonSupport {
                 parser.nextToken()
             }
 
-            // TODO this needs to use some industry identifier(s) instead of these keys
-            val key = parsePublicKeyBase58(parser.text)
+            val key = PublicKeyDeserializer.deserialize(parser, context)
             return AnonymousParty(key)
         }
     }
@@ -187,19 +183,24 @@ object JacksonSupport {
             }
 
             val mapper = parser.codec as PartyObjectMapper
-            // TODO: We should probably have a better specified way of identifying X.500 names vs keys
-            // Base58 keys never include an equals character, while X.500 names always will, so we use that to determine
-            // how to parse the content
-            return if (parser.text.contains("=")) {
+            // The comma character is invalid in base64, and required as a separator for X.500 names. As Corda
+            // X.500 names all involve at least three attributes (organisation, locality, country), they must
+            // include a comma. As such we can use it as a distinguisher between the two types.
+            return if (parser.text.contains(",")) {
                 val principal = CordaX500Name.parse(parser.text)
                 mapper.wellKnownPartyFromX500Name(principal) ?: throw JsonParseException(parser, "Could not find a Party with name $principal")
             } else {
                 val nameMatches = mapper.partiesFromName(parser.text)
                 if (nameMatches.isEmpty()) {
+                    val derBytes = try {
+                        parser.text.base64ToByteArray()
+                    } catch (e: AddressFormatException) {
+                        throw JsonParseException(parser, "Could not find a matching party for '${parser.text}' and is not a base64 encoded public key: " + e.message)
+                    }
                     val key = try {
-                        parsePublicKeyBase58(parser.text)
+                        Crypto.decodePublicKey(derBytes)
                     } catch (e: Exception) {
-                        throw JsonParseException(parser, "Could not find a matching party for '${parser.text}' and is not a base58 encoded public key")
+                        throw JsonParseException(parser, "Could not find a matching party for '${parser.text}' and is not a valid public key: " + e.message)
                     }
                     mapper.partyFromKey(key) ?: throw JsonParseException(parser, "Could not find a Party with key ${key.toStringShort()}")
                 } else if (nameMatches.size == 1) {
@@ -273,39 +274,23 @@ object JacksonSupport {
         }
     }
 
-    object PublicKeySerializer : JsonSerializer<EdDSAPublicKey>() {
-        override fun serialize(obj: EdDSAPublicKey, generator: JsonGenerator, provider: SerializerProvider) {
-            check(obj.params == Crypto.EDDSA_ED25519_SHA512.algSpec)
-            generator.writeString(obj.toBase58String())
+    object PublicKeySerializer : JsonSerializer<PublicKey>() {
+        override fun serialize(obj: PublicKey, generator: JsonGenerator, provider: SerializerProvider) {
+            generator.writeString(obj.encoded.toBase64())
         }
     }
 
-    object PublicKeyDeserializer : JsonDeserializer<EdDSAPublicKey>() {
-        override fun deserialize(parser: JsonParser, context: DeserializationContext): EdDSAPublicKey {
+    object PublicKeyDeserializer : JsonDeserializer<PublicKey>() {
+        override fun deserialize(parser: JsonParser, context: DeserializationContext): PublicKey {
             return try {
-                parsePublicKeyBase58(parser.text) as EdDSAPublicKey
+                val derBytes = parser.text.base64ToByteArray()
+                Crypto.decodePublicKey(derBytes)
             } catch (e: Exception) {
                 throw JsonParseException(parser, "Invalid public key ${parser.text}: ${e.message}")
             }
         }
     }
 
-    object CompositeKeySerializer : JsonSerializer<CompositeKey>() {
-        override fun serialize(obj: CompositeKey, generator: JsonGenerator, provider: SerializerProvider) {
-            generator.writeString(obj.toBase58String())
-        }
-    }
-
-    object CompositeKeyDeserializer : JsonDeserializer<CompositeKey>() {
-        override fun deserialize(parser: JsonParser, context: DeserializationContext): CompositeKey {
-            return try {
-                parsePublicKeyBase58(parser.text) as CompositeKey
-            } catch (e: Exception) {
-                throw JsonParseException(parser, "Invalid composite key ${parser.text}: ${e.message}")
-            }
-        }
-    }
-
     object AmountSerializer : JsonSerializer<Amount<*>>() {
         override fun serialize(value: Amount<*>, gen: JsonGenerator, serializers: SerializerProvider) {
             gen.writeString(value.toString())
diff --git a/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt b/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt
index 961e2978ac..6f057b2ff5 100644
--- a/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt
+++ b/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt
@@ -14,15 +14,16 @@ import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.MINI_CORP
 import net.corda.testing.TestDependencyInjectionBase
 import net.corda.testing.contracts.DummyContract
-import net.i2p.crypto.eddsa.EdDSAPublicKey
 import org.junit.Before
 import org.junit.Test
+import java.math.BigInteger
+import java.security.PublicKey
 import java.util.*
-import kotlin.reflect.jvm.jvmName
 import kotlin.test.assertEquals
 
 class JacksonSupportTest : TestDependencyInjectionBase() {
     companion object {
+        private val SEED = BigInteger.valueOf(20170922L)
         val mapper = JacksonSupport.createNonRpcMapper()
     }
 
@@ -37,15 +38,34 @@ class JacksonSupportTest : TestDependencyInjectionBase() {
     }
 
     @Test
-    fun publicKeySerializingWorks() {
-        val publicKey = generateKeyPair().public
+    fun `should serialize Composite keys`() {
+        val expected = "\"MIHAMBUGE2mtoq+J1bjir/ONk6yd5pab0FoDgaYAMIGiAgECMIGcMDIDLQAwKjAFBgMrZXADIQAgIX1QlJRgaLlD0ttLlJF5kNqT/7P7QwCvrWc9+/248gIBATAyAy0AMCowBQYDK2VwAyEAqS0JPGlzdviBZjB9FaNY+w6cVs3/CQ2A5EimE9Lyng4CAQEwMgMtADAqMAUGAytlcAMhALq4GG0gBQZIlaKE6ucooZsuoKUbH4MtGSmA6cwj136+AgEB\""
+        val innerKeys = (1..3).map { i ->
+            Crypto.deriveKeyPairFromEntropy(Crypto.EDDSA_ED25519_SHA512, SEED.plus(BigInteger.valueOf(i.toLong()))).public
+        }
+        // Build a 2 of 3 composite key
+        val publicKey = CompositeKey.Builder().let {
+            innerKeys.forEach { key -> it.addKey(key, 1) }
+            it.build(2)
+        }
         val serialized = mapper.writeValueAsString(publicKey)
-        val parsedKey = mapper.readValue(serialized, EdDSAPublicKey::class.java)
+        assertEquals(expected, serialized)
+        val parsedKey = mapper.readValue(serialized, PublicKey::class.java)
         assertEquals(publicKey, parsedKey)
     }
 
     private class Dummy(val notional: Amount<Currency>)
 
+    @Test
+    fun `should serialize EdDSA keys`() {
+        val expected = "\"MCowBQYDK2VwAyEACFTgLk1NOqYXAfxLoR7ctSbZcl9KMXu58Mq31Kv1Dwk=\""
+        val publicKey = Crypto.deriveKeyPairFromEntropy(Crypto.EDDSA_ED25519_SHA512, SEED).public
+        val serialized = mapper.writeValueAsString(publicKey)
+        assertEquals(expected, serialized)
+        val parsedKey = mapper.readValue(serialized, PublicKey::class.java)
+        assertEquals(publicKey, parsedKey)
+    }
+
     @Test
     fun readAmount() {
         val oldJson = """
diff --git a/samples/irs-demo/src/main/resources/net/corda/irs/simulation/trade.json b/samples/irs-demo/src/main/resources/net/corda/irs/simulation/trade.json
index 81bd5a4162..dc4a5be379 100644
--- a/samples/irs-demo/src/main/resources/net/corda/irs/simulation/trade.json
+++ b/samples/irs-demo/src/main/resources/net/corda/irs/simulation/trade.json
@@ -1,6 +1,6 @@
 {
   "fixedLeg": {
-    "fixedRatePayer": "8Kqd4oWdx4KQGHGR7xcgpFf9JmP6HiXqTf85NpSgdSu431EGEhujA6ePaFD",
+    "fixedRatePayer": "MCowBQYDK2VwAyEAzswVB9wd3XKVlRwpCIjwla25BE0bc9aW5t8GXWg71Pw=",
     "notional": "$25000000",
     "paymentFrequency": "SemiAnnual",
     "effectiveDate": "2016-03-11",
@@ -22,7 +22,7 @@
     "interestPeriodAdjustment": "Adjusted"
   },
   "floatingLeg": {
-    "floatingRatePayer": "8Kqd4oWdx4KQGHGJSFTX4kdZukmHohBRN3gvPekticL4eHTdmbJTVZNZJUj",
+    "floatingRatePayer": "MCowBQYDK2VwAyEAa3nFfmoJUjkoLASBjpYRLz8DpAAbqXpWTCOFKj8epfw=",
     "notional": {
       "quantity": 2500000000,
       "token": "USD"
@@ -71,7 +71,7 @@
     "notificationTime": "2:00pm London",
     "resolutionTime": "2:00pm London time on the first LocalBusiness Day following the date on which the notice is given ",
     "interestRate": {
-      "oracle": "Rates Service Provider",
+      "oracle": "C=ES,L=Madrid,O=Rates Service Provider",
       "tenor": {
         "name": "6M"
       },

From 8a842d1d531460e465631b350397842d2621f23c Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Wed, 27 Sep 2017 09:19:25 +0100
Subject: [PATCH 005/185] CORDA-540: Ensure that covariance of type is handled
 correctly when serializing with AMQP (#1631)

---
 .../amqp/DeserializationInput.kt              |  16 ++-
 .../serialization/amqp/SerializationHelper.kt |   2 +
 .../serialization/amqp/SerializerFactory.kt   |   2 +
 .../amqp/ListsSerializationJavaTest.java      | 134 ++++++++++++++++++
 .../serialization/ListsSerializationTest.kt   |  18 +++
 5 files changed, 169 insertions(+), 3 deletions(-)
 create mode 100644 node-api/src/test/java/net/corda/nodeapi/internal/serialization/amqp/ListsSerializationJavaTest.java

diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt
index 7522844db0..af7fcb3f81 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt
@@ -11,6 +11,8 @@ import org.apache.qpid.proton.codec.Data
 import java.io.NotSerializableException
 import java.lang.reflect.ParameterizedType
 import java.lang.reflect.Type
+import java.lang.reflect.TypeVariable
+import java.lang.reflect.WildcardType
 import java.nio.ByteBuffer
 
 data class ObjectAndEnvelope<out T>(val obj: T, val envelope: Envelope)
@@ -142,10 +144,18 @@ class DeserializationInput(internal val serializerFactory: SerializerFactory) {
             }
 
     /**
-     * TODO: Currently performs rather basic checks aimed in particular at [java.util.List<Command<?>>] and
-     * [java.lang.Class<? extends net.corda.core.contracts.Contract>]
+     * Currently performs checks aimed at:
+     *  * [java.util.List<Command<?>>] and [java.lang.Class<? extends net.corda.core.contracts.Contract>]
+     *  * [T : Parent] and [Parent]
+     *  * [? extends Parent] and [Parent]
+     *
      * In the future tighter control might be needed
      */
     private fun Type.materiallyEquivalentTo(that: Type): Boolean =
-            asClass() == that.asClass() && that is ParameterizedType
+        when(that) {
+            is ParameterizedType -> asClass() == that.asClass()
+            is TypeVariable<*> -> isSubClassOf(that.bounds.first())
+            is WildcardType -> isSubClassOf(that.upperBounds.first())
+            else -> false
+        }
 }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
index 2cc91ecb88..45df43799e 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
@@ -189,6 +189,8 @@ internal fun Type.asClass(): Class<*>? {
         this is Class<*> -> this
         this is ParameterizedType -> this.rawType.asClass()
         this is GenericArrayType -> this.genericComponentType.asClass()?.arrayClass()
+        this is TypeVariable<*> -> this.bounds.first().asClass()
+        this is WildcardType -> this.upperBounds.first().asClass()
         else -> null
     }
 }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
index e7a59f8d5c..0077285e77 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
@@ -105,6 +105,8 @@ class SerializerFactory(val whitelist: ClassWhitelist, cl: ClassLoader) {
                     val declaredComponent = declaredType.genericComponentType
                     inferTypeVariables(actualClass?.componentType, declaredComponent.asClass()!!, declaredComponent)?.asArray()
                 }
+                is TypeVariable<*> -> actualClass
+                is WildcardType -> actualClass
                 else -> null
             }
 
diff --git a/node-api/src/test/java/net/corda/nodeapi/internal/serialization/amqp/ListsSerializationJavaTest.java b/node-api/src/test/java/net/corda/nodeapi/internal/serialization/amqp/ListsSerializationJavaTest.java
new file mode 100644
index 0000000000..bcd1d1f1f7
--- /dev/null
+++ b/node-api/src/test/java/net/corda/nodeapi/internal/serialization/amqp/ListsSerializationJavaTest.java
@@ -0,0 +1,134 @@
+package net.corda.nodeapi.internal.serialization.amqp;
+
+import net.corda.core.serialization.CordaSerializable;
+import net.corda.core.serialization.SerializedBytes;
+import net.corda.nodeapi.internal.serialization.AllWhitelist;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ListsSerializationJavaTest {
+
+    @CordaSerializable
+    interface Parent {}
+
+    public static class Child implements Parent {
+        private final int value;
+
+        Child(int value) {
+            this.value = value;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            Child child = (Child) o;
+
+            return value == child.value;
+        }
+
+        @Override
+        public int hashCode() {
+            return value;
+        }
+
+        // Needed to show that there is a property called "value"
+        @SuppressWarnings("unused")
+        public int getValue() {
+            return value;
+        }
+    }
+
+    @CordaSerializable
+    public static class CovariantContainer<T extends Parent> {
+        private final List<T> content;
+
+        CovariantContainer(List<T> content) {
+            this.content = content;
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            CovariantContainer<T> that = (CovariantContainer<T>) o;
+
+            return content != null ? content.equals(that.content) : that.content == null;
+        }
+
+        @Override
+        public int hashCode() {
+            return content != null ? content.hashCode() : 0;
+        }
+
+        // Needed to show that there is a property called "content"
+        @SuppressWarnings("unused")
+        public List<T> getContent() {
+            return content;
+        }
+    }
+
+    @CordaSerializable
+    public static class CovariantContainer2 {
+        private final List<? extends Parent> content;
+
+        CovariantContainer2(List<? extends Parent> content) {
+            this.content = content;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            CovariantContainer2 that = (CovariantContainer2) o;
+
+            return content != null ? content.equals(that.content) : that.content == null;
+        }
+
+        @Override
+        public int hashCode() {
+            return content != null ? content.hashCode() : 0;
+        }
+
+        // Needed to show that there is a property called "content"
+        @SuppressWarnings("unused")
+        public List<? extends Parent> getContent() {
+            return content;
+        }
+    }
+
+    @Test
+    public void checkCovariance() throws Exception {
+        List<Child> payload = new ArrayList<>();
+        payload.add(new Child(1));
+        payload.add(new Child(2));
+        CovariantContainer<Child> container = new CovariantContainer<>(payload);
+        assertEqualAfterRoundTripSerialization(container, CovariantContainer.class);
+    }
+
+    @Test
+    public void checkCovariance2() throws Exception {
+        List<Child> payload = new ArrayList<>();
+        payload.add(new Child(1));
+        payload.add(new Child(2));
+        CovariantContainer2 container = new CovariantContainer2(payload);
+        assertEqualAfterRoundTripSerialization(container, CovariantContainer2.class);
+    }
+
+    // Have to have own version as Kotlin inline functions cannot be easily called from Java
+    private static<T> void assertEqualAfterRoundTripSerialization(T container, Class<T> clazz) throws Exception {
+        SerializerFactory factory1 = new SerializerFactory(AllWhitelist.INSTANCE, ClassLoader.getSystemClassLoader());
+        SerializationOutput ser = new SerializationOutput(factory1);
+        SerializedBytes<Object> bytes = ser.serialize(container);
+        DeserializationInput des = new DeserializationInput(factory1);
+        T deserialized = des.deserialize(bytes, clazz);
+        Assert.assertEquals(container, deserialized);
+    }
+}
\ No newline at end of file
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
index 07780c9fd1..176f7468a0 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
@@ -68,6 +68,24 @@ class ListsSerializationTest : TestDependencyInjectionBase() {
         Assertions.assertThatThrownBy { wrongPayloadType.serialize() }
                 .isInstanceOf(NotSerializableException::class.java).hasMessageContaining("Cannot derive collection type for declaredType")
     }
+
+    @CordaSerializable
+    interface Parent
+
+    data class Child(val value: Int) : Parent
+
+    @CordaSerializable
+    data class CovariantContainer<out T: Parent>(val payload: List<T>)
+
+    @Test
+    fun `check covariance`() {
+        val payload = ArrayList<Child>()
+        payload.add(Child(1))
+        payload.add(Child(2))
+        val container = CovariantContainer(payload)
+        assertEqualAfterRoundTripSerialization(container)
+    }
+
 }
 
 internal inline fun<reified T : Any> assertEqualAfterRoundTripSerialization(obj: T) {

From d3e1a8e1c03d39bb16ff3d484542aaa6c6b60370 Mon Sep 17 00:00:00 2001
From: Mike Hearn <mike@r3.com>
Date: Tue, 26 Sep 2017 17:17:58 +0200
Subject: [PATCH 006/185] Minor: improve javadocs in NodeInfo

---
 .../kotlin/net/corda/core/node/NodeInfo.kt    | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt b/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
index 4abfca9b92..0022d556ef 100644
--- a/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
+++ b/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
@@ -6,21 +6,34 @@ import net.corda.core.serialization.CordaSerializable
 import net.corda.core.utilities.NetworkHostAndPort
 
 /**
- * Info about a network node that acts on behalf of some form of contract party.
- * @param legalIdentitiesAndCerts is a non-empty list, where the first identity is assumed to be the default identity of the node.
+ * Information about a network node that acts on behalf of some party. NodeInfos can be found via the network map
+ * cache, accessible from a [net.corda.core.node.services.NetworkMapCache].
+ *
+ * @property addresses An ordered list of IP addresses/hostnames where the node can be contacted.
+ * @property legalIdentitiesAndCerts A non-empty list, where the first identity is assumed to be the default identity of the node.
+ * @property platformVersion An integer representing the set of protocol features the node supports. See the docsite
+ *           for information on how the platform is versioned.
+ * @property serial An arbitrary number incremented each time the NodeInfo is changed. This is analogous to the same
+ *           concept in DNS.
  */
-// TODO We currently don't support multi-IP/multi-identity nodes, we only left slots in the data structures.
 @CordaSerializable
 data class NodeInfo(val addresses: List<NetworkHostAndPort>,
                     val legalIdentitiesAndCerts: List<PartyAndCertificate>,
                     val platformVersion: Int,
                     val serial: Long
 ) {
+    // TODO We currently don't support multi-IP/multi-identity nodes, we only left slots in the data structures.
     init {
         require(legalIdentitiesAndCerts.isNotEmpty()) { "Node should have at least one legal identity" }
     }
 
     @Transient private var _legalIdentities: List<Party>? = null
+
+    /**
+     * An ordered list of legal identities supported by this node. The node will always have at least one, so if you
+     * are porting code from earlier versions of Corda that expected a single party per node, just use the first item
+     * in the returned list.
+     */
     val legalIdentities: List<Party> get() {
         return _legalIdentities ?: legalIdentitiesAndCerts.map { it.party }.also { _legalIdentities = it }
     }

From e49da94418193e6464a72d1a13b1ede2b6ad26c5 Mon Sep 17 00:00:00 2001
From: Mike Hearn <mike@r3.com>
Date: Tue, 26 Sep 2017 18:12:03 +0200
Subject: [PATCH 007/185] Minor: use package descriptions in Kotlin build of
 api docs too, not just javadocs.

---
 docs/build.gradle | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/build.gradle b/docs/build.gradle
index daefe91e23..6112f63647 100644
--- a/docs/build.gradle
+++ b/docs/build.gradle
@@ -10,6 +10,7 @@ dokka {
     outputDirectory = file("${rootProject.rootDir}/docs/build/html/api/kotlin")
     processConfigurations = ['compile']
     sourceDirs = files('../core/src/main/kotlin', '../client/jfx/src/main/kotlin', '../client/mock/src/main/kotlin', '../client/rpc/src/main/kotlin', '../node-api/src/main/kotlin', '../finance/src/main/kotlin', '../client/jackson/src/main/kotlin', '../testing/node-driver/src/main/kotlin', '../testing/test-utils/src/main/kotlin')
+    includes = ['packages.md']
     jdkVersion = 8
 
     externalDocumentationLink {

From c79d14cb6eba963a92758906bce650a4ff34a367 Mon Sep 17 00:00:00 2001
From: Mike Hearn <mike@r3.com>
Date: Tue, 26 Sep 2017 18:13:22 +0200
Subject: [PATCH 008/185] RPC: make RPCConnection non-internal, as it's a core
 API. Move docs around so they're on public API not internal API.

---
 .../client/rpc/CordaRPCJavaClientTest.java    |  3 +-
 .../net/corda/client/rpc/CordaRPCClient.kt    | 73 +++++++++++++++----
 .../net/corda/client/rpc/RPCConnection.kt     | 38 ++++++++++
 .../corda/client/rpc/internal/RPCClient.kt    | 56 +-------------
 4 files changed, 99 insertions(+), 71 deletions(-)
 create mode 100644 client/rpc/src/main/kotlin/net/corda/client/rpc/RPCConnection.kt

diff --git a/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java b/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
index 90e4b8faca..1a6ce172cd 100644
--- a/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
+++ b/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
@@ -1,6 +1,5 @@
 package net.corda.client.rpc;
 
-import net.corda.client.rpc.internal.RPCClient;
 import net.corda.core.concurrent.CordaFuture;
 import net.corda.core.contracts.Amount;
 import net.corda.core.messaging.CordaRPCOps;
@@ -42,7 +41,7 @@ public class CordaRPCJavaClientTest extends NodeBasedTest {
 
     private StartedNode<Node> node;
     private CordaRPCClient client;
-    private RPCClient.RPCConnection<CordaRPCOps> connection = null;
+    private RPCConnection<CordaRPCOps> connection = null;
     private CordaRPCOps rpcProxy;
 
     private void login(String username, String password) {
diff --git a/client/rpc/src/main/kotlin/net/corda/client/rpc/CordaRPCClient.kt b/client/rpc/src/main/kotlin/net/corda/client/rpc/CordaRPCClient.kt
index e5ac356d76..635db3afea 100644
--- a/client/rpc/src/main/kotlin/net/corda/client/rpc/CordaRPCClient.kt
+++ b/client/rpc/src/main/kotlin/net/corda/client/rpc/CordaRPCClient.kt
@@ -10,31 +10,62 @@ import net.corda.nodeapi.ConnectionDirection
 import net.corda.nodeapi.internal.serialization.KRYO_RPC_CLIENT_CONTEXT
 import java.time.Duration
 
-/** @see RPCClient.RPCConnection */
-class CordaRPCConnection internal constructor(
-        connection: RPCClient.RPCConnection<CordaRPCOps>
-) : RPCClient.RPCConnection<CordaRPCOps> by connection
+/**
+ * This class is essentially just a wrapper for an RPCConnection<CordaRPCOps> and can be treated identically.
+ *
+ * @see RPCConnection
+ */
+class CordaRPCConnection internal constructor(connection: RPCConnection<CordaRPCOps>) : RPCConnection<CordaRPCOps> by connection
 
-/** @see RPCClientConfiguration */
-data class CordaRPCClientConfiguration(
-        val connectionMaxRetryInterval: Duration
-) {
+/**
+ * Can be used to configure the RPC client connection.
+ *
+ * @property connectionMaxRetryInterval How much time to wait between connection retries if the server goes down. This
+ *           time will be reached via exponential backoff.
+ */
+data class CordaRPCClientConfiguration(val connectionMaxRetryInterval: Duration) {
     internal fun toRpcClientConfiguration(): RPCClientConfiguration {
         return RPCClientConfiguration.default.copy(
                 connectionMaxRetryInterval = connectionMaxRetryInterval
         )
     }
+
     companion object {
+        /**
+         * Returns the default configuration we recommend you use.
+         */
         @JvmStatic
-        val default = CordaRPCClientConfiguration(
-                connectionMaxRetryInterval = RPCClientConfiguration.default.connectionMaxRetryInterval
-        )
+        val default = CordaRPCClientConfiguration(connectionMaxRetryInterval = RPCClientConfiguration.default.connectionMaxRetryInterval)
     }
 }
 
-/** @see RPCClient */
-//TODO Add SSL support
-class CordaRPCClient(
+/**
+ * An RPC client connects to the specified server and allows you to make calls to the server that perform various
+ * useful tasks. Please see the Client RPC section of docs.corda.net to learn more about how this API works. A brief
+ * description is provided here.
+ *
+ * Calling [start] returns an [RPCConnection] containing a proxy that lets you invoke RPCs on the server. Calls on
+ * it block, and if the server throws an exception then it will be rethrown on the client. Proxies are thread safe and
+ * may be used to invoke multiple RPCs in parallel.
+ *
+ * RPC sends and receives are logged on the net.corda.rpc logger.
+ *
+ * The [CordaRPCOps] defines what client RPCs are available. If an RPC returns an [rx.Observable] anywhere in the object
+ * graph returned then the server-side observable is transparently forwarded to the client side here.
+ * *You are expected to use it*. The server will begin sending messages immediately that will be buffered on the
+ * client, you are expected to drain by subscribing to the returned observer. You can opt-out of this by simply
+ * calling the [net.corda.client.rpc.notUsed] method on it.
+ *
+ * You don't have to explicitly close the observable if you actually subscribe to it: it will close itself and free up
+ * the server-side resources either when the client or JVM itself is shutdown, or when there are no more subscribers to
+ * it. Once all the subscribers to a returned observable are unsubscribed or the observable completes successfully or
+ * with an error, the observable is closed and you can't then re-subscribe again: you'll have to re-request a fresh
+ * observable with another RPC.
+ *
+ * @param hostAndPort The network address to connect to.
+ * @param configuration An optional configuration used to tweak client behaviour.
+ */
+class CordaRPCClient @JvmOverloads constructor(
         hostAndPort: NetworkHostAndPort,
         configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.default,
         initialiseSerialization: Boolean = true
@@ -54,10 +85,24 @@ class CordaRPCClient(
             KRYO_RPC_CLIENT_CONTEXT
     )
 
+    /**
+     * Logs in to the target server and returns an active connection. The returned connection is a [java.io.Closeable]
+     * and can be used with a try-with-resources statement. If you don't use that, you should use the
+     * [RPCConnection.notifyServerAndClose] or [RPCConnection.forceClose] methods to dispose of the connection object
+     * when done.
+     *
+     * @param username The username to authenticate with.
+     * @param password The password to authenticate with.
+     * @throws RPCException if the server version is too low or if the server isn't reachable within a reasonable timeout.
+     */
     fun start(username: String, password: String): CordaRPCConnection {
         return CordaRPCConnection(rpcClient.start(CordaRPCOps::class.java, username, password))
     }
 
+    /**
+     * A helper for Kotlin users that simply closes the connection after the block has executed. Be careful not to
+     * over-use this, as setting up and closing connections takes time.
+     */
     inline fun <A> use(username: String, password: String, block: (CordaRPCConnection) -> A): A {
         return start(username, password).use(block)
     }
diff --git a/client/rpc/src/main/kotlin/net/corda/client/rpc/RPCConnection.kt b/client/rpc/src/main/kotlin/net/corda/client/rpc/RPCConnection.kt
new file mode 100644
index 0000000000..ae53adee53
--- /dev/null
+++ b/client/rpc/src/main/kotlin/net/corda/client/rpc/RPCConnection.kt
@@ -0,0 +1,38 @@
+package net.corda.client.rpc
+
+import net.corda.core.messaging.RPCOps
+import java.io.Closeable
+
+/**
+ * Holds a [proxy] object implementing [I] that forwards requests to the RPC server. The server version can be queried
+ * via this interface.
+ *
+ * [Closeable.close] may be used to shut down the connection and release associated resources. It is an
+ * alias for [notifyServerAndClose].
+ */
+interface RPCConnection<out I : RPCOps> : Closeable {
+    /**
+     * Holds a synthetic class that automatically forwards method calls to the server, and returns the response.
+     */
+    val proxy: I
+
+    /** The RPC protocol version reported by the server. */
+    val serverProtocolVersion: Int
+
+    /**
+     * Closes this client gracefully by sending a notification to the server, so it can immediately clean up resources.
+     * If the server is not available this method may block for a short period until it's clear the server is not
+     * coming back.
+     */
+    fun notifyServerAndClose()
+
+    /**
+     * Closes this client without notifying the server.
+     *
+     * The server will eventually clear out the RPC message queue and disconnect subscribed observers,
+     * but this may take longer than desired, so to conserve resources you should normally use [notifyServerAndClose].
+     * This method is helpful when the node may be shutting down or have already shut down and you don't want to
+     * block waiting for it to come back, which typically happens in integration tests and demos rather than production.
+     */
+    fun forceClose()
+}
\ No newline at end of file
diff --git a/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClient.kt b/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClient.kt
index f0fc941668..d4716f947f 100644
--- a/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClient.kt
+++ b/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClient.kt
@@ -1,5 +1,6 @@
 package net.corda.client.rpc.internal
 
+import net.corda.client.rpc.RPCConnection
 import net.corda.client.rpc.RPCException
 import net.corda.core.crypto.random63BitValue
 import net.corda.core.internal.logElapsedTime
@@ -17,7 +18,6 @@ import net.corda.nodeapi.config.SSLConfiguration
 import org.apache.activemq.artemis.api.core.SimpleString
 import org.apache.activemq.artemis.api.core.TransportConfiguration
 import org.apache.activemq.artemis.api.core.client.ActiveMQClient
-import java.io.Closeable
 import java.lang.reflect.Proxy
 import java.time.Duration
 
@@ -79,12 +79,6 @@ data class RPCClientConfiguration(
     }
 }
 
-/**
- * An RPC client that may be used to create connections to an RPC server.
- *
- * @param transport The Artemis transport to use to connect to the server.
- * @param rpcConfiguration Configuration used to tweak client behaviour.
- */
 class RPCClient<I : RPCOps>(
         val transport: TransportConfiguration,
         val rpcConfiguration: RPCClientConfiguration = RPCClientConfiguration.default,
@@ -101,54 +95,6 @@ class RPCClient<I : RPCOps>(
         private val log = loggerFor<RPCClient<*>>()
     }
 
-    /**
-     * Holds a proxy object implementing [I] that forwards requests to the RPC server.
-     *
-     * [Closeable.close] may be used to shut down the connection and release associated resources.
-     */
-    interface RPCConnection<out I : RPCOps> : Closeable {
-        val proxy: I
-        /** The RPC protocol version reported by the server */
-        val serverProtocolVersion: Int
-
-        /**
-         * Closes this client without notifying the server.
-         * The server will eventually clear out the RPC message queue and disconnect subscribed observers,
-         * but this may take longer than desired, so to conserve resources you should normally use [notifyServerAndClose].
-         * This method is helpful when the node may be shutting down or
-         * have already shut down and you don't want to block waiting for it to come back.
-         */
-        fun forceClose()
-
-        /**
-         * Closes this client gracefully by sending a notification to the server, so it can immediately clean up resources.
-         * If the server is not available this method may block for a short period until it's clear the server is not coming back.
-         */
-        fun notifyServerAndClose()
-    }
-
-    /**
-     * Returns an [RPCConnection] containing a proxy that lets you invoke RPCs on the server. Calls on it block, and if
-     * the server throws an exception then it will be rethrown on the client. Proxies are thread safe and may be used to
-     * invoke multiple RPCs in parallel.
-     *
-     * RPC sends and receives are logged on the net.corda.rpc logger.
-     *
-     * The [RPCOps] defines what client RPCs are available. If an RPC returns an [Observable] anywhere in the object
-     * graph returned then the server-side observable is transparently forwarded to the client side here.
-     * *You are expected to use it*. The server will begin sending messages immediately that will be buffered on the
-     * client, you are expected to drain by subscribing to the returned observer. You can opt-out of this by simply
-     * calling the [net.corda.client.rpc.notUsed] method on it. You don't have to explicitly close the observable if you actually
-     * subscribe to it: it will close itself and free up the server-side resources either when the client or JVM itself
-     * is shutdown, or when there are no more subscribers to it. Once all the subscribers to a returned observable are
-     * unsubscribed or the observable completes successfully or with an error, the observable is closed and you can't
-     * then re-subscribe again: you'll have to re-request a fresh observable with another RPC.
-     *
-     * @param rpcOpsClass The [Class] of the RPC interface.
-     * @param username The username to authenticate with.
-     * @param password The password to authenticate with.
-     * @throws RPCException if the server version is too low or if the server isn't reachable within the given time.
-     */
     fun start(
             rpcOpsClass: Class<I>,
             username: String,

From 7a082a659877b89759414504f5992de583983131 Mon Sep 17 00:00:00 2001
From: Mike Hearn <mike@r3.com>
Date: Tue, 26 Sep 2017 18:20:58 +0200
Subject: [PATCH 009/185] Add an IntelliJ scope that covers the currently
 supported Corda API.

This is useful when used in combination with the "Highlight public
declarations with missing KDoc" inspection.
---
 .idea/scopes/Corda_API.xml | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 .idea/scopes/Corda_API.xml

diff --git a/.idea/scopes/Corda_API.xml b/.idea/scopes/Corda_API.xml
new file mode 100644
index 0000000000..fa137ebcf0
--- /dev/null
+++ b/.idea/scopes/Corda_API.xml
@@ -0,0 +1,3 @@
+<component name="DependencyValidationManager">
+  <scope name="Corda API" pattern="src[core_main]:*..*&amp;&amp;!src[core_main]:net.corda.core.internal..*||src[rpc_main]:net.corda.client.rpc.*||src[jackson_main]:net.corda.client.jackson.*" />
+</component>
\ No newline at end of file

From b75c9f9254cefee0c28bfe66eae87186a86ae0f5 Mon Sep 17 00:00:00 2001
From: Mike Hearn <mike@r3.com>
Date: Tue, 26 Sep 2017 18:32:05 +0200
Subject: [PATCH 010/185] Ironic: upgrade the version of the Gradle plugin that
 checks for upgraded versions of things.

It had broken due being incompatible with the new versions of Gradle
itself.
---
 build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index f32dfbe9f7..0466b24455 100644
--- a/build.gradle
+++ b/build.gradle
@@ -59,7 +59,7 @@ buildscript {
         classpath "net.corda.plugins:publish-utils:$gradle_plugins_version"
         classpath "net.corda.plugins:quasar-utils:$gradle_plugins_version"
         classpath "net.corda.plugins:cordformation:$gradle_plugins_version"
-        classpath 'com.github.ben-manes:gradle-versions-plugin:0.13.0'
+        classpath 'com.github.ben-manes:gradle-versions-plugin:0.15.0'
         classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version"
         classpath "org.jetbrains.dokka:dokka-gradle-plugin:${dokka_version}"
         classpath "org.ajoberstar:grgit:1.1.0"

From 6686b054a25a793c674aa0872af483b86e1ed521 Mon Sep 17 00:00:00 2001
From: Mike Hearn <mike@r3.com>
Date: Tue, 26 Sep 2017 18:38:03 +0200
Subject: [PATCH 011/185] Docs: flesh out javadocs on ServiceHub

---
 .../kotlin/net/corda/core/node/ServiceHub.kt  | 65 ++++++++++++++++---
 .../core/node/services/VaultQueryService.kt   |  4 +-
 .../corda/core/node/services/VaultService.kt  |  1 -
 3 files changed, 60 insertions(+), 10 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt b/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
index cf484b6b24..99960d04ca 100644
--- a/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
+++ b/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
@@ -6,6 +6,7 @@ import net.corda.core.crypto.Crypto
 import net.corda.core.crypto.SignableData
 import net.corda.core.crypto.SignatureMetadata
 import net.corda.core.crypto.TransactionSignature
+import net.corda.core.flows.ContractUpgradeFlow
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.AnonymousParty
 import net.corda.core.identity.Party
@@ -22,10 +23,13 @@ import java.time.Clock
 /**
  * Subset of node services that are used for loading transactions from the wire into fully resolved, looked up
  * forms ready for verification.
- *
- * @see ServiceHub
  */
 interface ServicesForResolution {
+    /**
+     * An identity service maintains a directory of parties by their associated distinguished name/public keys and thus
+     * supports lookup of a party given its key, or name. The service also manages the certificates linking confidential
+     * identities back to the well known identity (i.e. the identity in the network map) of a party.
+     */
     val identityService: IdentityService
 
     /** Provides access to storage of arbitrary JAR files (which may contain only data, no code). */
@@ -44,17 +48,42 @@ interface ServicesForResolution {
 }
 
 /**
- * A service hub simply vends references to the other services a node has. Some of those services may be missing or
- * mocked out. This class is useful to pass to chunks of pluggable code that might have need of many different kinds of
- * functionality and you don't want to hard-code which types in the interface.
+ * A service hub is the starting point for most operations you can do inside the node. You are provided with one
+ * when a class annotated with [CordaService] is constructed, and you have access to one inside flows. Most RPCs
+ * simply forward to the services found here after some access checking.
  *
- * Any services exposed to flows (public view) need to implement [SerializeAsToken] or similar to avoid their internal
- * state from being serialized in checkpoints.
+ * The APIs are organised roughly by category, with a few very important top level APIs available on the ServiceHub
+ * itself. Inside a flow, it's safe to keep a reference to services found here on the stack: checkpointing will do the
+ * right thing (it won't try to serialise the internals of the service).
+ *
+ * In unit test environments, some of those services may be missing or mocked out.
  */
 interface ServiceHub : ServicesForResolution {
+    // NOTE: Any services exposed to flows (public view) need to implement [SerializeAsToken] or similar to avoid
+    // their internal state from being serialized in checkpoints.
+
+    /**
+     * The vault service lets you observe, soft lock and add notes to states that involve you or are relevant to your
+     * node in some way.
+     */
     val vaultService: VaultService
+    /** The vault query service lets you select and track states that correspond to various criteria. */
     val vaultQueryService: VaultQueryService
+    /**
+     * The key management service is responsible for storing and using private keys to sign things. An
+     * implementation of this may, for example, call out to a hardware security module that enforces various
+     * auditing and frequency-of-use requirements.
+     *
+     * You don't normally need to use this directly. If you have a [TransactionBuilder] and wish to sign it to
+     * get a [SignedTransaction], look at [signInitialTransaction].
+     */
     val keyManagementService: KeyManagementService
+    /**
+     * The [ContractUpgradeService] is responsible for securely upgrading contract state objects according to
+     * a specified and mutually agreed (amongst participants) contract version.
+     *
+     * @see ContractUpgradeFlow to understand the workflow associated with contract upgrades.
+     */
     val contractUpgradeService: ContractUpgradeService
 
     /**
@@ -64,9 +93,26 @@ interface ServiceHub : ServicesForResolution {
      */
     val validatedTransactions: TransactionStorage
 
+    /**
+     * A network map contains lists of nodes on the network along with information about their identity keys, services
+     * they provide and host names or IP addresses where they can be connected to. The cache wraps around a map fetched
+     * from an authoritative service, and adds easy lookup of the data stored within it. Generally it would be initialised
+     * with a specified network map service, which it fetches data from and then subscribes to updates of.
+     */
     val networkMapCache: NetworkMapCache
+
+    /**
+     * Provides verification service. The implementation may be a simple in-memory verify() call or perhaps an IPC/RPC.
+     */
     val transactionVerifierService: TransactionVerifierService
+
+    /**
+     * A [Clock] representing the node's current time. This should be used in preference to directly accessing the
+     * clock so the current time can be controlled during unit testing.
+     */
     val clock: Clock
+
+    /** The [NodeInfo] object corresponding to our own entry in the network map. */
     val myInfo: NodeInfo
 
     /**
@@ -268,9 +314,12 @@ interface ServiceHub : ServicesForResolution {
     /**
      * Exposes a JDBC connection (session) object using the currently configured database.
      * Applications can use this to execute arbitrary SQL queries (native, direct, prepared, callable)
-     * against its Node database tables (including custom contract tables defined by extending [Queryable]).
+     * against its Node database tables (including custom contract tables defined by extending
+     * [net.corda.core.schemas.QueryableState]).
+     *
      * When used within a flow, this session automatically forms part of the enclosing flow transaction boundary,
      * and thus queryable data will include everything committed as of the last checkpoint.
+     *
      * @throws IllegalStateException if called outside of a transaction.
      * @return A new [Connection]
      */
diff --git a/core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt b/core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt
index 2cfacd51f5..deace9212f 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt
@@ -7,8 +7,10 @@ import net.corda.core.node.services.vault.PageSpecification
 import net.corda.core.node.services.vault.QueryCriteria
 import net.corda.core.node.services.vault.Sort
 
+/**
+ * The vault query service lets you select and track states that correspond to various criteria.
+ */
 interface VaultQueryService {
-
     // DOCSTART VaultQueryAPI
     /**
      * Generic vault query function which takes a [QueryCriteria] object to define filters,
diff --git a/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt b/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt
index 754bbd69fd..a2353a7b99 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt
@@ -149,7 +149,6 @@ class Vault<out T : ContractState>(val states: Iterable<StateAndRef<T>>) {
  * Note that transactions we've seen are held by the storage service, not the vault.
  */
 interface VaultService {
-
     /**
      * Prefer the use of [updates] unless you know why you want to use this instead.
      *

From df453bdaa874f32b01e3bf1246b715645a40885b Mon Sep 17 00:00:00 2001
From: Mike Hearn <mike@r3.com>
Date: Tue, 26 Sep 2017 18:56:08 +0200
Subject: [PATCH 012/185] Docs: add @suppress to a few things that were
 polluting the Dokka docs.

---
 core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt  | 3 ++-
 core/src/main/kotlin/net/corda/core/node/ServiceHub.kt         | 3 ++-
 .../net/corda/core/node/services/TransactionVerifierService.kt | 1 +
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
index cbb80eb2ae..0ef6a73f84 100644
--- a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
@@ -235,11 +235,12 @@ fun <T> Class<T>.castIfPossible(obj: Any): T? = if (isInstance(obj)) cast(obj) e
 fun <T> Class<*>.staticField(name: String): DeclaredField<T> = DeclaredField(this, name, null)
 /** Returns a [DeclaredField] wrapper around the declared (possibly non-public) static field of the receiver [KClass]. */
 fun <T> KClass<*>.staticField(name: String): DeclaredField<T> = DeclaredField(java, name, null)
-/** Returns a [DeclaredField] wrapper around the declared (possibly non-public) instance field of the receiver object. */
+/** @suppress Returns a [DeclaredField] wrapper around the declared (possibly non-public) instance field of the receiver object. */
 fun <T> Any.declaredField(name: String): DeclaredField<T> = DeclaredField(javaClass, name, this)
 /**
  * Returns a [DeclaredField] wrapper around the (possibly non-public) instance field of the receiver object, but declared
  * in its superclass [clazz].
+ * @suppress
  */
 fun <T> Any.declaredField(clazz: KClass<*>, name: String): DeclaredField<T> = DeclaredField(clazz.java, name, this)
 
diff --git a/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt b/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
index 99960d04ca..f4c0f205cd 100644
--- a/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
+++ b/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
@@ -102,7 +102,8 @@ interface ServiceHub : ServicesForResolution {
     val networkMapCache: NetworkMapCache
 
     /**
-     * Provides verification service. The implementation may be a simple in-memory verify() call or perhaps an IPC/RPC.
+     * INTERNAL. DO NOT USE.
+     * @suppress
      */
     val transactionVerifierService: TransactionVerifierService
 
diff --git a/core/src/main/kotlin/net/corda/core/node/services/TransactionVerifierService.kt b/core/src/main/kotlin/net/corda/core/node/services/TransactionVerifierService.kt
index 99f40a0492..8cc5c7af65 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/TransactionVerifierService.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/TransactionVerifierService.kt
@@ -5,6 +5,7 @@ import net.corda.core.transactions.LedgerTransaction
 
 /**
  * Provides verification service. The implementation may be a simple in-memory verify() call or perhaps an IPC/RPC.
+ * @suppress
  */
 interface TransactionVerifierService {
     /**

From 1b349214ff3836b8d2c4ce2f7a654cceb553802c Mon Sep 17 00:00:00 2001
From: Mike Hearn <mike@r3.com>
Date: Wed, 27 Sep 2017 11:46:16 +0200
Subject: [PATCH 013/185] Docs: mention RPC access in NodeInfo javadoc

---
 core/src/main/kotlin/net/corda/core/node/NodeInfo.kt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt b/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
index 0022d556ef..d5ef1df776 100644
--- a/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
+++ b/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
@@ -7,7 +7,8 @@ import net.corda.core.utilities.NetworkHostAndPort
 
 /**
  * Information about a network node that acts on behalf of some party. NodeInfos can be found via the network map
- * cache, accessible from a [net.corda.core.node.services.NetworkMapCache].
+ * cache, accessible from a [net.corda.core.node.services.NetworkMapCache]. They are also available via RPC
+ * using the [net.corda.core.messaging.CordaRPCOps.networkMapSnapshot] method.
  *
  * @property addresses An ordered list of IP addresses/hostnames where the node can be contacted.
  * @property legalIdentitiesAndCerts A non-empty list, where the first identity is assumed to be the default identity of the node.

From c6c4c13bee3fe7794901a02ff312ba4c6a597034 Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Wed, 27 Sep 2017 11:32:10 +0100
Subject: [PATCH 014/185] Declare this internal message string as "const".
 (#1674)

---
 .../main/kotlin/net/corda/core/concurrent/ConcurrencyUtils.kt   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/kotlin/net/corda/core/concurrent/ConcurrencyUtils.kt b/core/src/main/kotlin/net/corda/core/concurrent/ConcurrencyUtils.kt
index 548521a2e8..dedc468904 100644
--- a/core/src/main/kotlin/net/corda/core/concurrent/ConcurrencyUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/concurrent/ConcurrencyUtils.kt
@@ -28,7 +28,7 @@ fun <V, W> firstOf(vararg futures: CordaFuture<out V>, handler: (CordaFuture<out
 
 private val defaultLog = LoggerFactory.getLogger("net.corda.core.concurrent")
 @VisibleForTesting
-internal val shortCircuitedTaskFailedMessage = "Short-circuited task failed:"
+internal const val shortCircuitedTaskFailedMessage = "Short-circuited task failed:"
 
 internal fun <V, W> firstOf(futures: Array<out CordaFuture<out V>>, log: Logger, handler: (CordaFuture<out V>) -> W): CordaFuture<W> {
     val resultFuture = openFuture<W>()

From 762b2a5123208e61d2398895177fdbb757733b9e Mon Sep 17 00:00:00 2001
From: Andras Slemmer <andras.slemmer@r3cev.com>
Date: Wed, 27 Sep 2017 10:40:16 +0100
Subject: [PATCH 015/185] More memory to attachment demo test nodes

---
 .../attachmentdemo/AttachmentDemoTest.kt      |  9 ++--
 .../corda/attachmentdemo/AttachmentDemo.kt    |  1 +
 .../kotlin/net/corda/testing/driver/Driver.kt | 50 +++++++++++--------
 .../corda/testing/driver/ProcessUtilities.kt  | 12 +++--
 4 files changed, 43 insertions(+), 29 deletions(-)

diff --git a/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt b/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt
index eaccdee089..3f3458997b 100644
--- a/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt
+++ b/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt
@@ -8,6 +8,7 @@ import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.DUMMY_BANK_A
 import net.corda.testing.DUMMY_BANK_B
 import net.corda.testing.DUMMY_NOTARY
+import net.corda.testing.driver.PortAllocation
 import net.corda.testing.driver.driver
 import org.junit.Test
 import java.util.concurrent.CompletableFuture.supplyAsync
@@ -16,11 +17,11 @@ class AttachmentDemoTest {
     // run with a 10,000,000 bytes in-memory zip file. In practice, a slightly bigger file will be used (~10,002,000 bytes).
     @Test fun `attachment demo using a 10MB zip file`() {
         val numOfExpectedBytes = 10_000_000
-        driver(dsl = {
+        driver(isDebug = true, portAllocation = PortAllocation.Incremental(20000)) {
             val demoUser = listOf(User("demo", "demo", setOf(startFlowPermission<AttachmentDemoFlow>())))
             val (nodeA, nodeB) = listOf(
-                    startNode(providedName = DUMMY_BANK_A.name, rpcUsers = demoUser),
-                    startNode(providedName = DUMMY_BANK_B.name, rpcUsers = demoUser),
+                    startNode(providedName = DUMMY_BANK_A.name, rpcUsers = demoUser, maximumHeapSize = "1g"),
+                    startNode(providedName = DUMMY_BANK_B.name, rpcUsers = demoUser, maximumHeapSize = "1g"),
                     startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type))))
                     .map { it.getOrThrow() }
             startWebserver(nodeB).getOrThrow()
@@ -39,6 +40,6 @@ class AttachmentDemoTest {
 
             senderThread.getOrThrow()
             recipientThread.getOrThrow()
-        }, isDebug = true)
+        }
     }
 }
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 8eba73075f..833d1bec1c 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
@@ -93,6 +93,7 @@ private fun sender(rpc: CordaRPCOps, inputStream: InputStream, hash: SecureHash.
     // Make sure we have the file in storage
     if (!rpc.attachmentExists(hash)) {
         inputStream.use {
+            val avail = inputStream.available()
             val id = rpc.uploadAttachment(it)
             require(hash == id) { "Id was '$id' instead of '$hash'" }
         }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
index c65f5ffcea..c7ad45cdf0 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
@@ -94,7 +94,8 @@ interface DriverDSLExposedInterface : CordformContext {
             rpcUsers: List<User> = defaultParameters.rpcUsers,
             verifierType: VerifierType = defaultParameters.verifierType,
             customOverrides: Map<String, Any?> = defaultParameters.customOverrides,
-            startInSameProcess: Boolean? = defaultParameters.startInSameProcess): CordaFuture<NodeHandle>
+            startInSameProcess: Boolean? = defaultParameters.startInSameProcess,
+            maximumHeapSize: String = defaultParameters.maximumHeapSize): CordaFuture<NodeHandle>
 
     /**
      * Helper function for starting a [node] with custom parameters from Java.
@@ -109,7 +110,8 @@ interface DriverDSLExposedInterface : CordformContext {
 
     fun startNodes(
             nodes: List<CordformNode>,
-            startInSameProcess: Boolean? = null
+            startInSameProcess: Boolean? = null,
+            maximumHeapSize: String = "200m"
     ): List<CordaFuture<NodeHandle>>
 
     /**
@@ -137,7 +139,7 @@ interface DriverDSLExposedInterface : CordformContext {
      *
      * @param handle The handle for the node that this webserver connects to via RPC.
      */
-    fun startWebserver(handle: NodeHandle): CordaFuture<WebserverHandle>
+    fun startWebserver(handle: NodeHandle, maximumHeapSize: String = "200m"): CordaFuture<WebserverHandle>
 
     /**
      * Starts a network map service node. Note that only a single one should ever be running, so you will probably want
@@ -145,7 +147,7 @@ interface DriverDSLExposedInterface : CordformContext {
      * @param startInProcess Determines if the node should be started inside this process. If null the Driver-level
      *     value will be used.
      */
-    fun startDedicatedNetworkMapService(startInProcess: Boolean? = null): CordaFuture<NodeHandle>
+    fun startDedicatedNetworkMapService(startInProcess: Boolean? = null, maximumHeapSize: String = "200m"): CordaFuture<NodeHandle>
 
     fun waitForAllNodesToFinish()
 
@@ -250,7 +252,7 @@ sealed class PortAllocation {
 }
 
 /**
- * Helper builder for configuring a [node] from Java.
+ * Helper builder for configuring a [Node] from Java.
  */
 data class NodeParameters(
         val providedName: CordaX500Name? = null,
@@ -258,7 +260,8 @@ data class NodeParameters(
         val rpcUsers: List<User> = emptyList(),
         val verifierType: VerifierType = VerifierType.InMemory,
         val customOverrides: Map<String, Any?> = emptyMap(),
-        val startInSameProcess: Boolean? = null
+        val startInSameProcess: Boolean? = null,
+        val maximumHeapSize: String = "200m"
 ) {
     fun setProvidedName(providedName: CordaX500Name?) = copy(providedName = providedName)
     fun setAdvertisedServices(advertisedServices: Set<ServiceInfo>) = copy(advertisedServices = advertisedServices)
@@ -266,6 +269,7 @@ data class NodeParameters(
     fun setVerifierType(verifierType: VerifierType) = copy(verifierType = verifierType)
     fun setCustomerOverrides(customOverrides: Map<String, Any?>) = copy(customOverrides = customOverrides)
     fun setStartInSameProcess(startInSameProcess: Boolean?) = copy(startInSameProcess = startInSameProcess)
+    fun setMaximumHeapSize(maximumHeapSize: String) = copy(maximumHeapSize = maximumHeapSize)
 }
 
 /**
@@ -674,7 +678,8 @@ class DriverDSL(
             rpcUsers: List<User>,
             verifierType: VerifierType,
             customOverrides: Map<String, Any?>,
-            startInSameProcess: Boolean?
+            startInSameProcess: Boolean?,
+            maximumHeapSize: String
     ): CordaFuture<NodeHandle> {
         val p2pAddress = portAllocation.nextHostAndPort()
         val rpcAddress = portAllocation.nextHostAndPort()
@@ -700,10 +705,10 @@ class DriverDSL(
                         "verifierType" to verifierType.name
                 ) + customOverrides
         )
-        return startNodeInternal(config, webAddress, startInSameProcess)
+        return startNodeInternal(config, webAddress, startInSameProcess, maximumHeapSize)
     }
 
-    override fun startNodes(nodes: List<CordformNode>, startInSameProcess: Boolean?): List<CordaFuture<NodeHandle>> {
+    override fun startNodes(nodes: List<CordformNode>, startInSameProcess: Boolean?, maximumHeapSize: String): List<CordaFuture<NodeHandle>> {
         val networkMapServiceConfigLookup = networkMapServiceConfigLookup(nodes)
         return nodes.map { node ->
             portAllocation.nextHostAndPort() // rpcAddress
@@ -720,7 +725,7 @@ class DriverDSL(
                             "notaryClusterAddresses" to node.notaryClusterAddresses
                     )
             )
-            startNodeInternal(config, webAddress, startInSameProcess)
+            startNodeInternal(config, webAddress, startInSameProcess, maximumHeapSize)
         }
     }
 
@@ -781,9 +786,9 @@ class DriverDSL(
         throw IllegalStateException("Webserver at ${handle.webAddress} has died")
     }
 
-    override fun startWebserver(handle: NodeHandle): CordaFuture<WebserverHandle> {
+    override fun startWebserver(handle: NodeHandle, maximumHeapSize: String): CordaFuture<WebserverHandle> {
         val debugPort = if (isDebug) debugPortAllocation.nextPort() else null
-        val processFuture = DriverDSL.startWebserver(executorService, handle, debugPort)
+        val processFuture = DriverDSL.startWebserver(executorService, handle, debugPort, maximumHeapSize)
         registerProcess(processFuture)
         return processFuture.map { queryWebserver(handle, it) }
     }
@@ -806,7 +811,7 @@ class DriverDSL(
 
     override fun baseDirectory(nodeName: String): Path = baseDirectory(CordaX500Name.parse(nodeName))
 
-    override fun startDedicatedNetworkMapService(startInProcess: Boolean?): CordaFuture<NodeHandle> {
+    override fun startDedicatedNetworkMapService(startInProcess: Boolean?, maximumHeapSize: String): CordaFuture<NodeHandle> {
         val webAddress = portAllocation.nextHostAndPort()
         val networkMapLegalName = networkMapStartStrategy.legalName
         val config = ConfigHelper.loadConfig(
@@ -822,10 +827,10 @@ class DriverDSL(
                         "extraAdvertisedServiceIds" to listOf(ServiceInfo(NetworkMapService.type).toString())
                 )
         )
-        return startNodeInternal(config, webAddress, startInProcess)
+        return startNodeInternal(config, webAddress, startInProcess, maximumHeapSize)
     }
 
-    private fun startNodeInternal(config: Config, webAddress: NetworkHostAndPort, startInProcess: Boolean?): CordaFuture<NodeHandle> {
+    private fun startNodeInternal(config: Config, webAddress: NetworkHostAndPort, startInProcess: Boolean?, maximumHeapSize: String): CordaFuture<NodeHandle> {
         val nodeConfiguration = config.parseAs<FullNodeConfiguration>()
         if (startInProcess ?: startNodesInProcess) {
             val nodeAndThreadFuture = startInProcessNode(executorService, nodeConfiguration, config)
@@ -846,7 +851,7 @@ class DriverDSL(
             }
         } else {
             val debugPort = if (isDebug) debugPortAllocation.nextPort() else null
-            val processFuture = startOutOfProcessNode(executorService, nodeConfiguration, config, quasarJarPath, debugPort, systemProperties, packagesToScanString.joinToString(","))
+            val processFuture = startOutOfProcessNode(executorService, nodeConfiguration, config, quasarJarPath, debugPort, systemProperties, packagesToScanString.joinToString(","), maximumHeapSize)
             registerProcess(processFuture)
             return processFuture.flatMap { process ->
                 val processDeathFuture = poll(executorService, "process death") {
@@ -910,7 +915,8 @@ class DriverDSL(
                 quasarJarPath: String,
                 debugPort: Int?,
                 overriddenSystemProperties: Map<String, String>,
-                packagesToScanString: String
+                packagesToScanString: String,
+                maximumHeapSize: String
         ): CordaFuture<Process> {
             val processFuture = executorService.fork {
                 log.info("Starting out-of-process Node ${nodeConf.myLegalName.organisation}")
@@ -939,7 +945,8 @@ class DriverDSL(
                         jdwpPort = debugPort,
                         extraJvmArguments = extraJvmArguments,
                         errorLogPath = nodeConf.baseDirectory / NodeStartup.LOGS_DIRECTORY_NAME / "error.log",
-                        workingDirectory = nodeConf.baseDirectory
+                        workingDirectory = nodeConf.baseDirectory,
+                        maximumHeapSize = maximumHeapSize
                 )
             }
             return processFuture.flatMap { process ->
@@ -950,7 +957,8 @@ class DriverDSL(
         private fun startWebserver(
                 executorService: ScheduledExecutorService,
                 handle: NodeHandle,
-                debugPort: Int?
+                debugPort: Int?,
+                maximumHeapSize: String
         ): CordaFuture<Process> {
             return executorService.fork {
                 val className = "net.corda.webserver.WebServer"
@@ -962,7 +970,9 @@ class DriverDSL(
                                 "-Dname=node-${handle.configuration.p2pAddress}-webserver",
                                 "-Djava.io.tmpdir=${System.getProperty("java.io.tmpdir")}" // Inherit from parent process
                         ),
-                        errorLogPath = Paths.get("error.$className.log")
+                        errorLogPath = Paths.get("error.$className.log"),
+                        workingDirectory = null,
+                        maximumHeapSize = maximumHeapSize
                 )
             }.flatMap { process -> addressMustBeBoundFuture(executorService, handle.webAddress, process).map { process } }
         }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/ProcessUtilities.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/ProcessUtilities.kt
index c020d830a1..d0a5c6492d 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/ProcessUtilities.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/ProcessUtilities.kt
@@ -10,7 +10,7 @@ object ProcessUtilities {
             arguments: List<String>,
             jdwpPort: Int? = null
     ): Process {
-        return startJavaProcessImpl(C::class.java.name, arguments, defaultClassPath, jdwpPort, emptyList(), null, null)
+        return startJavaProcessImpl(C::class.java.name, arguments, defaultClassPath, jdwpPort, emptyList(), null, null, null)
     }
 
     fun startCordaProcess(
@@ -19,11 +19,12 @@ object ProcessUtilities {
             jdwpPort: Int?,
             extraJvmArguments: List<String>,
             errorLogPath: Path?,
-            workingDirectory: Path? = null
+            workingDirectory: Path?,
+            maximumHeapSize: String
     ): Process {
         // FIXME: Instead of hacking our classpath, use the correct classpath for className.
         val classpath = defaultClassPath.split(pathSeparator).filter { !(it / "log4j2-test.xml").exists() }.joinToString(pathSeparator)
-        return startJavaProcessImpl(className, arguments, classpath, jdwpPort, extraJvmArguments, errorLogPath, workingDirectory)
+        return startJavaProcessImpl(className, arguments, classpath, jdwpPort, extraJvmArguments, errorLogPath, workingDirectory, maximumHeapSize)
     }
 
     fun startJavaProcessImpl(
@@ -33,12 +34,13 @@ object ProcessUtilities {
             jdwpPort: Int?,
             extraJvmArguments: List<String>,
             errorLogPath: Path?,
-            workingDirectory: Path?
+            workingDirectory: Path?,
+            maximumHeapSize: String?
     ): Process {
         val command = mutableListOf<String>().apply {
             add((System.getProperty("java.home") / "bin" / "java").toString())
             (jdwpPort != null) && add("-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=$jdwpPort")
-            add("-Xmx200m")
+            if (maximumHeapSize != null) add("-Xmx$maximumHeapSize")
             add("-XX:+UseG1GC")
             addAll(extraJvmArguments)
             add("-cp")

From c8739e83a9908ee1e42485ce8a5813cd699b7777 Mon Sep 17 00:00:00 2001
From: Maksymilian Pawlak <120831+m4ksio@users.noreply.github.com>
Date: Tue, 26 Sep 2017 16:43:32 +0100
Subject: [PATCH 016/185] IRS Fixes to bring UI closer to declared financial
 types

---
 .../net/corda/finance/contracts/FinanceTypes.kt   |  2 +-
 .../main/resources/irsweb/view/create-deal.html   | 15 ++++++---------
 2 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt b/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
index 2a1c02a11e..b79c9d01a6 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
@@ -160,7 +160,7 @@ enum class DayCountBasisDay {
 enum class DayCountBasisYear {
     // Ditto above comment for years.
     Y360,
-    Y365F, Y365L, Y365Q, Y366, YActual, YActualA, Y365B, Y365, YISMA, YICMA, Y252;
+    Y365F, Y365L, Y365Q, Y366, YActual, YActualA, Y365B, Y365, YISMA, YISDA, YICMA, Y252;
 
     override fun toString(): String {
         return super.toString().drop(1)
diff --git a/samples/irs-demo/src/main/resources/irsweb/view/create-deal.html b/samples/irs-demo/src/main/resources/irsweb/view/create-deal.html
index 7ea4e8d3b9..53ea8d4c8e 100644
--- a/samples/irs-demo/src/main/resources/irsweb/view/create-deal.html
+++ b/samples/irs-demo/src/main/resources/irsweb/view/create-deal.html
@@ -64,10 +64,9 @@
                     <label>Roll Convention</label>
                     <select class="ui selection" ng-model="deal.fixedLeg.rollConvention">
                         <option value="Following">Following</option>
-                        <option value="Preceding">Preceding</option>
+                        <option value="Previous">Previous</option>
                         <option value="ModifiedFollowing">Modified following</option>
-                        <option value="ModifiedFollowingBimonthly">Modified following bimonthly</option>
-                        <option value="EndOfMonth">End of month</option>
+                        <option value="ModifiedPrevious">Modified previous</option>
                     </select>
                 </div>
                 <div class="field">
@@ -120,20 +119,18 @@
                     <label>Roll Convention</label>
                     <select class="ui selection" ng-model="deal.floatingLeg.rollConvention">
                         <option value="Following">Following</option>
-                        <option value="Preceding">Preceding</option>
+                        <option value="Previous">Previous</option>
                         <option value="ModifiedFollowing">Modified following</option>
-                        <option value="ModifiedFollowingBimonthly">Modified following bimonthly</option>
-                        <option value="EndOfMonth">End of month</option>
+                        <option value="ModifiedPrevious">Modified previous</option>
                     </select>
                 </div>
                 <div class="field">
                     <label>Fixing Roll Convention</label>
                     <select class="ui selection" ng-model="deal.floatingLeg.fixingRollConvention">
                         <option value="Following">Following</option>
-                        <option value="Preceding">Preceding</option>
+                        <option value="Previous">Previous</option>
                         <option value="ModifiedFollowing">Modified following</option>
-                        <option value="ModifiedFollowingBimonthly">Modified following bimonthly</option>
-                        <option value="EndOfMonth">End of month</option>
+                        <option value="ModifiedPrevious">Modified previous</option>
                     </select>
                 </div>
                 <div class="field">

From 9874e1ff341dc45130c6f5c648a67756f8225cef Mon Sep 17 00:00:00 2001
From: Andrzej Cichocki <andrzej.cichocki@r3.com>
Date: Wed, 27 Sep 2017 12:58:48 +0100
Subject: [PATCH 017/185] uncheckedCast crusade (#1667)

---
 .../corda/client/jackson/JacksonSupport.kt    |  4 ++--
 .../client/jfx/model/ContractStateModel.kt    |  4 ++--
 .../net/corda/client/jfx/model/Models.kt      |  5 ++--
 .../client/jfx/utils/ObservableUtilities.kt   | 13 ++++-------
 .../kotlin/net/corda/client/mock/Generator.kt | 11 ++++-----
 .../corda/client/rpc/internal/RPCClient.kt    |  6 ++---
 .../net/corda/core/contracts/ContractsDSL.kt  |  3 ++-
 .../net/corda/core/crypto/SignedData.kt       |  4 ++--
 .../corda/core/flows/ContractUpgradeFlow.kt   |  4 ++--
 .../net/corda/core/internal/FetchDataFlow.kt  |  3 +--
 .../net/corda/core/internal/InternalUtils.kt  |  7 +++---
 .../node/services/vault/QueryCriteriaUtils.kt |  4 ++--
 .../core/transactions/BaseTransaction.kt      |  7 +++---
 .../core/transactions/LedgerTransaction.kt    | 10 ++++----
 .../net/corda/core/utilities/KotlinUtils.kt   |  4 ++--
 .../kotlin/net/corda/core/utilities/Try.kt    | 12 ++++------
 .../contracts/universal/UniversalContract.kt  | 23 +++++++++----------
 .../corda/finance/contracts/GetBalances.kt    |  1 -
 .../finance/contracts/asset/CashTests.kt      |  3 ---
 .../corda/nodeapi/config/ConfigUtilities.kt   | 11 ++++-----
 .../nodeapi/internal/serialization/Kryo.kt    | 15 +++++-------
 .../serialization/SerializationScheme.kt      |  6 ++---
 .../amqp/CollectionSerializer.kt              |  4 ++--
 .../serialization/amqp/CustomSerializer.kt    | 21 ++++++++---------
 .../serialization/amqp/MapSerializer.kt       |  7 +++---
 .../internal/serialization/amqp/Schema.kt     | 13 ++++-------
 .../serialization/amqp/SerializerFactory.kt   |  4 ++--
 .../amqp/custom/EnumSetSerializer.kt          |  8 +++----
 .../serialization/carpenter/ClassCarpenter.kt | 13 ++++-------
 .../carpenter/ClassCarpenterTest.kt           | 17 +++++---------
 .../net/corda/node/internal/AbstractNode.kt   |  7 +++---
 .../node/services/api/ServiceHubInternal.kt   |  4 ++--
 .../messaging/ArtemisMessagingServer.kt       |  8 +++----
 .../node/services/messaging/Messaging.kt      |  4 ++--
 .../statemachine/FlowStateMachineImpl.kt      | 13 ++++-------
 .../statemachine/StateMachineManager.kt       |  7 ++----
 .../node/services/transactions/PathManager.kt |  4 ++--
 .../vault/HibernateQueryCriteriaParser.kt     | 10 ++++----
 .../services/vault/HibernateVaultQueryImpl.kt | 12 ++++------
 .../net/corda/node/shell/InteractiveShell.kt  |  7 ++----
 .../kotlin/net/corda/irs/flows/FixingFlow.kt  |  6 ++---
 .../corda/netmap/simulation/IRSSimulation.kt  |  4 ++--
 .../kotlin/net/corda/testing/RPCDriver.kt     |  4 ++--
 .../kotlin/net/corda/testing/CoreTestUtils.kt |  2 +-
 .../main/kotlin/net/corda/testing/Expect.kt   |  9 ++++----
 .../net/corda/testing/FlowStackSnapshot.kt    |  6 ++---
 .../main/kotlin/net/corda/testing/Measure.kt  | 21 ++++++++---------
 .../main/kotlin/net/corda/testing/TestDSL.kt  |  8 +++----
 .../kotlin/net/corda/demobench/model/User.kt  |  4 ++--
 .../net/corda/explorer/model/SettingsModel.kt | 12 +++++-----
 .../corda/webserver/converters/Converters.kt  |  4 ++--
 51 files changed, 172 insertions(+), 231 deletions(-)

diff --git a/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt b/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt
index 4fcd8415b4..809dbc45a9 100644
--- a/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt
+++ b/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt
@@ -17,6 +17,7 @@ import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.AnonymousParty
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.CordaRPCOps
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.services.IdentityService
@@ -266,8 +267,7 @@ object JacksonSupport {
                 parser.nextToken()
             }
             try {
-                @Suppress("UNCHECKED_CAST")
-                return SecureHash.parse(parser.text) as T
+                return uncheckedCast(SecureHash.parse(parser.text))
             } catch (e: Exception) {
                 throw JsonParseException(parser, "Invalid hash ${parser.text}: ${e.message}")
             }
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/ContractStateModel.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/ContractStateModel.kt
index 6a81eb0dc9..e62f531dcf 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/ContractStateModel.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/ContractStateModel.kt
@@ -6,6 +6,7 @@ import net.corda.client.jfx.utils.fold
 import net.corda.client.jfx.utils.map
 import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.StateAndRef
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.node.services.Vault
 import net.corda.finance.contracts.asset.Cash
 import rx.Observable
@@ -37,10 +38,9 @@ class ContractStateModel {
     companion object {
         private fun Collection<StateAndRef<ContractState>>.filterCashStateAndRefs(): List<StateAndRef<Cash.State>> {
             return this.map { stateAndRef ->
-                @Suppress("UNCHECKED_CAST")
                 if (stateAndRef.state.data is Cash.State) {
                     // Kotlin doesn't unify here for some reason
-                    stateAndRef as StateAndRef<Cash.State>
+                    uncheckedCast(stateAndRef)
                 } else {
                     null
                 }
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/Models.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/Models.kt
index 71a6b66733..feb3548ed2 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/Models.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/Models.kt
@@ -4,6 +4,7 @@ import javafx.beans.property.ObjectProperty
 import javafx.beans.value.ObservableValue
 import javafx.beans.value.WritableValue
 import javafx.collections.ObservableList
+import net.corda.core.internal.uncheckedCast
 import org.reactfx.EventSink
 import org.reactfx.EventStream
 import rx.Observable
@@ -78,9 +79,7 @@ object Models {
         if (model.javaClass != klass.java) {
             throw IllegalStateException("Model stored as ${klass.qualifiedName} has type ${model.javaClass}")
         }
-
-        @Suppress("UNCHECKED_CAST")
-        return model as M
+        return uncheckedCast(model)
     }
 
     inline fun <reified M : Any> get(origin: KClass<*>): M = get(M::class, origin)
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableUtilities.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableUtilities.kt
index 10ae4aeff6..89366935fa 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableUtilities.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableUtilities.kt
@@ -14,6 +14,7 @@ import javafx.collections.ObservableMap
 import javafx.collections.transformation.FilteredList
 import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.StateAndRef
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.DataFeed
 import net.corda.core.node.services.Vault
 import org.fxmisc.easybind.EasyBind
@@ -92,8 +93,7 @@ fun <A, B> ObservableValue<out A>.bind(function: (A) -> ObservableValue<B>): Obs
  * propagate variance constraints and type inference fails.
  */
 fun <A, B> ObservableValue<out A>.bindOut(function: (A) -> ObservableValue<out B>): ObservableValue<out B> =
-        @Suppress("UNCHECKED_CAST")
-        EasyBind.monadic(this).flatMap(function as (A) -> ObservableValue<B>)
+        EasyBind.monadic(this).flatMap(uncheckedCast(function))
 
 /**
  * enum class FilterCriterion { HEIGHT, NAME }
@@ -105,8 +105,7 @@ fun <A, B> ObservableValue<out A>.bindOut(function: (A) -> ObservableValue<out B
  */
 fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A> {
     // We cast here to enforce variance, FilteredList should be covariant
-    @Suppress("UNCHECKED_CAST")
-    return FilteredList<A>(this as ObservableList<A>).apply {
+    return FilteredList<A>(uncheckedCast(this)).apply {
         predicateProperty().bind(predicate.map { predicateFunction ->
             Predicate<A> { predicateFunction(it) }
         })
@@ -120,13 +119,11 @@ fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>)
  */
 fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A> {
     //TODO This is a tactical work round for an issue with SAM conversion (https://youtrack.jetbrains.com/issue/ALL-1552) so that the M10 explorer works.
-    @Suppress("UNCHECKED_CAST")
-    return (this as ObservableList<A?>).filtered(object : Predicate<A?> {
+    return uncheckedCast(uncheckedCast<Any, ObservableList<A?>>(this).filtered(object : Predicate<A?> {
         override fun test(t: A?): Boolean {
             return t != null
-
         }
-    }) as ObservableList<A>
+    }))
 }
 
 /**
diff --git a/client/mock/src/main/kotlin/net/corda/client/mock/Generator.kt b/client/mock/src/main/kotlin/net/corda/client/mock/Generator.kt
index 3993383a1a..e01c39d6f9 100644
--- a/client/mock/src/main/kotlin/net/corda/client/mock/Generator.kt
+++ b/client/mock/src/main/kotlin/net/corda/client/mock/Generator.kt
@@ -1,6 +1,7 @@
 package net.corda.client.mock
 
 import net.corda.client.mock.Generator.Companion.choice
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.utilities.Try
 import java.util.*
 
@@ -115,14 +116,13 @@ class Generator<out A>(val generate: (SplittableRandom) -> Try<A>) {
 
         fun <A> frequency(vararg generators: Pair<Double, Generator<A>>) = frequency(generators.toList())
 
-        fun <A> sequence(generators: List<Generator<A>>) = Generator {
+        fun <A> sequence(generators: List<Generator<A>>) = Generator<List<A>> {
             val result = mutableListOf<A>()
             for (generator in generators) {
                 val element = generator.generate(it)
-                @Suppress("UNCHECKED_CAST")
                 when (element) {
                     is Try.Success -> result.add(element.value)
-                    is Try.Failure -> return@Generator element as Try<List<A>>
+                    is Try.Failure -> return@Generator uncheckedCast(element)
                 }
             }
             Try.Success(result)
@@ -175,7 +175,7 @@ class Generator<out A>(val generate: (SplittableRandom) -> Try<A>) {
         }
 
 
-        fun <A> replicatePoisson(meanSize: Double, generator: Generator<A>, atLeastOne: Boolean = false) = Generator {
+        fun <A> replicatePoisson(meanSize: Double, generator: Generator<A>, atLeastOne: Boolean = false) = Generator<List<A>> {
             val chance = (meanSize - 1) / meanSize
             val result = mutableListOf<A>()
             var finish = false
@@ -191,8 +191,7 @@ class Generator<out A>(val generate: (SplittableRandom) -> Try<A>) {
                     }
                 }
                 if (res is Try.Failure) {
-                    @Suppress("UNCHECKED_CAST")
-                    return@Generator res as Try<List<A>>
+                    return@Generator uncheckedCast(res)
                 }
             }
             Try.Success(result)
diff --git a/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClient.kt b/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClient.kt
index d4716f947f..773c511da9 100644
--- a/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClient.kt
+++ b/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClient.kt
@@ -4,6 +4,7 @@ import net.corda.client.rpc.RPCConnection
 import net.corda.client.rpc.RPCException
 import net.corda.core.crypto.random63BitValue
 import net.corda.core.internal.logElapsedTime
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.RPCOps
 import net.corda.core.serialization.SerializationContext
 import net.corda.core.serialization.SerializationDefaults
@@ -114,10 +115,7 @@ class RPCClient<I : RPCOps>(
             val proxyHandler = RPCClientProxyHandler(rpcConfiguration, username, password, serverLocator, clientAddress, rpcOpsClass, serializationContext)
             try {
                 proxyHandler.start()
-
-                @Suppress("UNCHECKED_CAST")
-                val ops = Proxy.newProxyInstance(rpcOpsClass.classLoader, arrayOf(rpcOpsClass), proxyHandler) as I
-
+                val ops: I = uncheckedCast(Proxy.newProxyInstance(rpcOpsClass.classLoader, arrayOf(rpcOpsClass), proxyHandler))
                 val serverProtocolVersion = ops.protocolVersion
                 if (serverProtocolVersion < rpcConfiguration.minimumServerProtocolVersion) {
                     throw RPCException("Requested minimum protocol version (${rpcConfiguration.minimumServerProtocolVersion}) is higher" +
diff --git a/core/src/main/kotlin/net/corda/core/contracts/ContractsDSL.kt b/core/src/main/kotlin/net/corda/core/contracts/ContractsDSL.kt
index 51036f8dfe..d43ae5c001 100644
--- a/core/src/main/kotlin/net/corda/core/contracts/ContractsDSL.kt
+++ b/core/src/main/kotlin/net/corda/core/contracts/ContractsDSL.kt
@@ -4,6 +4,7 @@ package net.corda.core.contracts
 
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.Party
+import net.corda.core.internal.uncheckedCast
 import java.security.PublicKey
 import java.util.*
 
@@ -58,7 +59,7 @@ inline fun <reified T : CommandData> Collection<CommandWithParties<CommandData>>
 
 /** Ensures that a transaction has only one command that is of the given type, otherwise throws an exception. */
 fun <C : CommandData> Collection<CommandWithParties<CommandData>>.requireSingleCommand(klass: Class<C>) =
-        mapNotNull { @Suppress("UNCHECKED_CAST") if (klass.isInstance(it.value)) it as CommandWithParties<C> else null }.single()
+        mapNotNull { if (klass.isInstance(it.value)) uncheckedCast<CommandWithParties<CommandData>, CommandWithParties<C>>(it) else null }.single()
 
 /**
  * Simple functionality for verifying a move command. Verifies that each input has a signature from its owning key.
diff --git a/core/src/main/kotlin/net/corda/core/crypto/SignedData.kt b/core/src/main/kotlin/net/corda/core/crypto/SignedData.kt
index 472a8a1024..bc39699f55 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/SignedData.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/SignedData.kt
@@ -1,5 +1,6 @@
 package net.corda.core.crypto
 
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.serialization.SerializedBytes
 import net.corda.core.serialization.deserialize
@@ -23,8 +24,7 @@ open class SignedData<T : Any>(val raw: SerializedBytes<T>, val sig: DigitalSign
     @Throws(SignatureException::class)
     fun verified(): T {
         sig.by.verify(raw.bytes, sig)
-        @Suppress("UNCHECKED_CAST")
-        val data = raw.deserialize<Any>() as T
+        val data: T = uncheckedCast(raw.deserialize<Any>())
         verifyData(data)
         return data
     }
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 0612d5d9aa..c3ee51a861 100644
--- a/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt
@@ -3,6 +3,7 @@ package net.corda.core.flows
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.contracts.*
 import net.corda.core.internal.ContractUpgradeUtils
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.transactions.LedgerTransaction
 import net.corda.core.transactions.TransactionBuilder
 import java.security.PublicKey
@@ -30,8 +31,7 @@ object ContractUpgradeFlow {
         val command = commandData.value
         val participantKeys: Set<PublicKey> = input.data.participants.map { it.owningKey }.toSet()
         val keysThatSigned: Set<PublicKey> = commandData.signers.toSet()
-        @Suppress("UNCHECKED_CAST")
-        val upgradedContract = javaClass.classLoader.loadClass(command.upgradedContractClass).newInstance() as UpgradedContract<ContractState, *>
+        val upgradedContract: UpgradedContract<ContractState, *> = uncheckedCast(javaClass.classLoader.loadClass(command.upgradedContractClass).newInstance())
         requireThat {
             "The signing keys include all participant keys" using keysThatSigned.containsAll(participantKeys)
             "Inputs state reference the legacy contract" using (input.contract == upgradedContract.legacyContract)
diff --git a/core/src/main/kotlin/net/corda/core/internal/FetchDataFlow.kt b/core/src/main/kotlin/net/corda/core/internal/FetchDataFlow.kt
index 0789c535ba..28b44dfa4e 100644
--- a/core/src/main/kotlin/net/corda/core/internal/FetchDataFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/FetchDataFlow.kt
@@ -114,8 +114,7 @@ sealed class FetchDataFlow<T : NamedByHash, in W : Any>(
 
     protected abstract fun load(txid: SecureHash): T?
 
-    @Suppress("UNCHECKED_CAST")
-    protected open fun convert(wire: W): T = wire as T
+    protected open fun convert(wire: W): T = uncheckedCast(wire)
 
     private fun validateFetchResponse(maybeItems: UntrustworthyData<ArrayList<W>>,
                                       requests: List<SecureHash>): List<T> {
diff --git a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
index 0ef6a73f84..5d3eafdca1 100644
--- a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
@@ -226,8 +226,8 @@ private fun IntProgression.toSpliterator(): Spliterator.OfInt {
 
 fun IntProgression.stream(parallel: Boolean = false): IntStream = StreamSupport.intStream(toSpliterator(), parallel)
 
-@Suppress("UNCHECKED_CAST") // When toArray has filled in the array, the component type is no longer T? but T (that may itself be nullable).
-inline fun <reified T> Stream<out T>.toTypedArray() = toArray { size -> arrayOfNulls<T>(size) } as Array<T>
+// When toArray has filled in the array, the component type is no longer T? but T (that may itself be nullable):
+inline fun <reified T> Stream<out T>.toTypedArray(): Array<T> = uncheckedCast(toArray { size -> arrayOfNulls<T>(size) })
 
 fun <T> Class<T>.castIfPossible(obj: Any): T? = if (isInstance(obj)) cast(obj) else null
 
@@ -256,8 +256,7 @@ fun <T: Any> KClass<T>.objectOrNewInstance(): T {
 class DeclaredField<T>(clazz: Class<*>, name: String, private val receiver: Any?) {
     private val javaField = clazz.getDeclaredField(name).apply { isAccessible = true }
     var value: T
-        @Suppress("UNCHECKED_CAST")
-        get() = javaField.get(receiver) as T
+        get() = uncheckedCast<Any?, T>(javaField.get(receiver))
         set(value) = javaField.set(receiver, value)
 }
 
diff --git a/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteriaUtils.kt b/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteriaUtils.kt
index 811bc1ee2e..1ee9ab89d4 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteriaUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteriaUtils.kt
@@ -2,6 +2,7 @@
 
 package net.corda.core.node.services.vault
 
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.schemas.PersistentState
 import net.corda.core.serialization.CordaSerializable
 import java.lang.reflect.Field
@@ -88,8 +89,7 @@ fun <O, R> resolveEnclosingObjectFromExpression(expression: CriteriaExpression<O
     }
 }
 
-@Suppress("UNCHECKED_CAST")
-fun <O, C> resolveEnclosingObjectFromColumn(column: Column<O, C>): Class<O> = column.declaringClass as Class<O>
+fun <O, C> resolveEnclosingObjectFromColumn(column: Column<O, C>): Class<O> = uncheckedCast(column.declaringClass)
 fun <O, C> getColumnName(column: Column<O, C>): String = column.name
 
 /**
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 da0d98dbe7..3ff6773082 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/BaseTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/BaseTransaction.kt
@@ -4,6 +4,7 @@ import net.corda.core.contracts.*
 import net.corda.core.identity.Party
 import net.corda.core.internal.indexOfOrThrow
 import net.corda.core.internal.castIfPossible
+import net.corda.core.internal.uncheckedCast
 import java.util.function.Predicate
 
 /**
@@ -40,8 +41,7 @@ abstract class BaseTransaction : NamedByHash {
     /**
      * Returns a [StateAndRef] for the given output index.
      */
-    @Suppress("UNCHECKED_CAST")
-    fun <T : ContractState> outRef(index: Int): StateAndRef<T> = StateAndRef(outputs[index] as TransactionState<T>, StateRef(id, index))
+    fun <T : ContractState> outRef(index: Int): StateAndRef<T> = StateAndRef(uncheckedCast(outputs[index]), StateRef(id, index))
 
     /**
      * Returns a [StateAndRef] for the requested output state, or throws [IllegalArgumentException] if not found.
@@ -111,8 +111,7 @@ abstract class BaseTransaction : NamedByHash {
      */
     fun <T : ContractState> outRefsOfType(clazz: Class<T>): List<StateAndRef<T>> {
         return outputs.mapIndexedNotNull { index, state ->
-            @Suppress("UNCHECKED_CAST")
-            clazz.castIfPossible(state.data)?.let { StateAndRef(state as TransactionState<T>, StateRef(id, index)) }
+            clazz.castIfPossible(state.data)?.let { StateAndRef<T>(uncheckedCast(state), StateRef(id, index)) }
         }
     }
 
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 4fa5778071..f54d02e5fc 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt
@@ -4,6 +4,7 @@ import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
 import net.corda.core.identity.Party
 import net.corda.core.internal.castIfPossible
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.CordaSerializable
 import java.util.*
 import java.util.function.Predicate
@@ -52,8 +53,7 @@ data class LedgerTransaction(
      * @param index The index into the inputs.
      * @return The [StateAndRef]
      */
-    @Suppress("UNCHECKED_CAST")
-    fun <T : ContractState> inRef(index: Int): StateAndRef<T> = inputs[index] as StateAndRef<T>
+    fun <T : ContractState> inRef(index: Int): StateAndRef<T> = uncheckedCast(inputs[index])
 
     /**
      * Verifies this transaction and runs contract code. At this stage it is assumed that signatures have already been verified.
@@ -230,8 +230,7 @@ data class LedgerTransaction(
      * @return the possibly empty list of inputs [StateAndRef] matching the clazz restriction.
      */
     fun <T : ContractState> inRefsOfType(clazz: Class<T>): List<StateAndRef<T>> {
-        @Suppress("UNCHECKED_CAST")
-        return inputs.mapNotNull { if (clazz.isInstance(it.state.data)) it as StateAndRef<T> else null }
+        return inputs.mapNotNull { if (clazz.isInstance(it.state.data)) uncheckedCast<StateAndRef<ContractState>, StateAndRef<T>>(it) else null }
     }
 
     inline fun <reified T : ContractState> inRefsOfType(): List<StateAndRef<T>> = inRefsOfType(T::class.java)
@@ -307,8 +306,7 @@ data class LedgerTransaction(
      * @param index the position of the item in the commands.
      * @return The Command at the requested index
      */
-    @Suppress("UNCHECKED_CAST")
-    fun <T : CommandData> getCommand(index: Int): Command<T> = Command(commands[index].value as T, commands[index].signers)
+    fun <T : CommandData> getCommand(index: Int): Command<T> = Command(uncheckedCast(commands[index].value), commands[index].signers)
 
     /**
      * Helper to simplify getting all [Command] items with a [CommandData] of a particular class, interface, or base class.
diff --git a/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt b/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt
index a726dbf7fb..b12ea8353d 100644
--- a/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt
@@ -1,6 +1,7 @@
 package net.corda.core.utilities
 
 import net.corda.core.internal.concurrent.get
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.CordaSerializable
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -101,14 +102,13 @@ private class TransientProperty<out T> internal constructor(private val initiali
     @Transient private var initialised = false
     @Transient private var value: T? = null
 
-    @Suppress("UNCHECKED_CAST")
     @Synchronized
     override operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
         if (!initialised) {
             value = initialiser()
             initialised = true
         }
-        return value as T
+        return uncheckedCast(value)
     }
 }
 
diff --git a/core/src/main/kotlin/net/corda/core/utilities/Try.kt b/core/src/main/kotlin/net/corda/core/utilities/Try.kt
index 4ff2224ade..cfe471c1b1 100644
--- a/core/src/main/kotlin/net/corda/core/utilities/Try.kt
+++ b/core/src/main/kotlin/net/corda/core/utilities/Try.kt
@@ -1,5 +1,6 @@
 package net.corda.core.utilities
 
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.utilities.Try.Failure
 import net.corda.core.utilities.Try.Success
@@ -35,30 +36,27 @@ sealed class Try<out A> {
     abstract fun getOrThrow(): A
 
     /** Maps the given function to the value from this [Success], or returns `this` if this is a [Failure]. */
-    @Suppress("UNCHECKED_CAST")
     inline fun <B> map(function: (A) -> B): Try<B> = when (this) {
         is Success -> Success(function(value))
-        is Failure -> this as Try<B>
+        is Failure -> uncheckedCast(this)
     }
 
     /** Returns the given function applied to the value from this [Success], or returns `this` if this is a [Failure]. */
-    @Suppress("UNCHECKED_CAST")
     inline fun <B> flatMap(function: (A) -> Try<B>): Try<B> = when (this) {
         is Success -> function(value)
-        is Failure -> this as Try<B>
+        is Failure -> uncheckedCast(this)
     }
 
     /**
      * Maps the given function to the values from this [Success] and [other], or returns `this` if this is a [Failure]
      * or [other] if [other] is a [Failure].
      */
-    @Suppress("UNCHECKED_CAST")
     inline fun <B, C> combine(other: Try<B>, function: (A, B) -> C): Try<C> = when (this) {
         is Success -> when (other) {
             is Success -> Success(function(value, other.value))
-            is Failure -> other as Try<C>
+            is Failure -> uncheckedCast(other)
         }
-        is Failure -> this as Try<C>
+        is Failure -> uncheckedCast(this)
     }
 
     data class Success<out A>(val value: A) : Try<A>() {
diff --git a/experimental/src/main/kotlin/net/corda/finance/contracts/universal/UniversalContract.kt b/experimental/src/main/kotlin/net/corda/finance/contracts/universal/UniversalContract.kt
index 6f12d53844..7abb5ed97d 100644
--- a/experimental/src/main/kotlin/net/corda/finance/contracts/universal/UniversalContract.kt
+++ b/experimental/src/main/kotlin/net/corda/finance/contracts/universal/UniversalContract.kt
@@ -3,6 +3,7 @@ package net.corda.finance.contracts.universal
 import net.corda.core.contracts.*
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.Party
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.transactions.LedgerTransaction
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.finance.contracts.BusinessCalendar
@@ -124,19 +125,18 @@ class UniversalContract : Contract {
         }
     }
 
-    @Suppress("UNCHECKED_CAST")
     fun <T> replaceStartEnd(p: Perceivable<T>, start: Instant, end: Instant): Perceivable<T> =
             when (p) {
                 is Const -> p
-                is TimePerceivable -> TimePerceivable(p.cmp, replaceStartEnd(p.instant, start, end)) as Perceivable<T>
-                is EndDate -> const(end) as Perceivable<T>
-                is StartDate -> const(start) as Perceivable<T>
+                is TimePerceivable -> uncheckedCast(TimePerceivable(p.cmp, replaceStartEnd(p.instant, start, end)))
+                is EndDate -> uncheckedCast(const(end))
+                is StartDate -> uncheckedCast(const(start))
                 is UnaryPlus -> UnaryPlus(replaceStartEnd(p.arg, start, end))
                 is PerceivableOperation -> PerceivableOperation<T>(replaceStartEnd(p.left, start, end), p.op, replaceStartEnd(p.right, start, end))
-                is Interest -> Interest(replaceStartEnd(p.amount, start, end), p.dayCountConvention, replaceStartEnd(p.interest, start, end), replaceStartEnd(p.start, start, end), replaceStartEnd(p.end, start, end)) as Perceivable<T>
-                is Fixing -> Fixing(p.source, replaceStartEnd(p.date, start, end), p.tenor) as Perceivable<T>
-                is PerceivableAnd -> (replaceStartEnd(p.left, start, end) and replaceStartEnd(p.right, start, end)) as Perceivable<T>
-                is PerceivableOr -> (replaceStartEnd(p.left, start, end) or replaceStartEnd(p.right, start, end)) as Perceivable<T>
+                is Interest -> uncheckedCast(Interest(replaceStartEnd(p.amount, start, end), p.dayCountConvention, replaceStartEnd(p.interest, start, end), replaceStartEnd(p.start, start, end), replaceStartEnd(p.end, start, end)))
+                is Fixing -> uncheckedCast(Fixing(p.source, replaceStartEnd(p.date, start, end), p.tenor))
+                is PerceivableAnd -> uncheckedCast(replaceStartEnd(p.left, start, end) and replaceStartEnd(p.right, start, end))
+                is PerceivableOr -> uncheckedCast(replaceStartEnd(p.left, start, end) or replaceStartEnd(p.right, start, end))
                 is ActorPerceivable -> p
                 else -> throw NotImplementedError("replaceStartEnd " + p.javaClass.name)
             }
@@ -276,7 +276,6 @@ class UniversalContract : Contract {
         }
     }
 
-    @Suppress("UNCHECKED_CAST")
     fun <T> replaceFixing(tx: LedgerTransaction, perceivable: Perceivable<T>,
                           fixings: Map<FixOf, BigDecimal>, unusedFixings: MutableSet<FixOf>): Perceivable<T> =
             when (perceivable) {
@@ -284,14 +283,14 @@ class UniversalContract : Contract {
                 is UnaryPlus -> UnaryPlus(replaceFixing(tx, perceivable.arg, fixings, unusedFixings))
                 is PerceivableOperation -> PerceivableOperation(replaceFixing(tx, perceivable.left, fixings, unusedFixings),
                         perceivable.op, replaceFixing(tx, perceivable.right, fixings, unusedFixings))
-                is Interest -> Interest(replaceFixing(tx, perceivable.amount, fixings, unusedFixings),
+                is Interest -> uncheckedCast(Interest(replaceFixing(tx, perceivable.amount, fixings, unusedFixings),
                         perceivable.dayCountConvention, replaceFixing(tx, perceivable.interest, fixings, unusedFixings),
-                        perceivable.start, perceivable.end) as Perceivable<T>
+                        perceivable.start, perceivable.end))
                 is Fixing -> {
                     val dt = eval(tx, perceivable.date)
                     if (dt != null && fixings.containsKey(FixOf(perceivable.source, dt.toLocalDate(), perceivable.tenor))) {
                         unusedFixings.remove(FixOf(perceivable.source, dt.toLocalDate(), perceivable.tenor))
-                        Const(fixings[FixOf(perceivable.source, dt.toLocalDate(), perceivable.tenor)]!!) as Perceivable<T>
+                        uncheckedCast(Const(fixings[FixOf(perceivable.source, dt.toLocalDate(), perceivable.tenor)]!!))
                     } else perceivable
                 }
                 else -> throw NotImplementedError("replaceFixing - " + perceivable.javaClass.name)
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/GetBalances.kt b/finance/src/main/kotlin/net/corda/finance/contracts/GetBalances.kt
index 7f6c84010d..2e28208a6f 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/GetBalances.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/GetBalances.kt
@@ -39,7 +39,6 @@ private fun rowsToAmount(currency: Currency, rows: Vault.Page<FungibleAsset<*>>)
     } else {
         require(rows.otherResults.size == 2)
         require(rows.otherResults[1] == currency.currencyCode)
-        @Suppress("UNCHECKED_CAST")
         val quantity = rows.otherResults[0] as Long
         Amount(quantity, currency)
     }
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
index 770e0ae5a2..b9b7bd7091 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
@@ -594,7 +594,6 @@ class CashTests : TestDependencyInjectionBase() {
                 makeSpend(100.DOLLARS, THEIR_IDENTITY_1)
             }
         database.transaction {
-            @Suppress("UNCHECKED_CAST")
             val vaultState = vaultStatesUnconsumed.elementAt(0)
             assertEquals(vaultState.ref, wtx.inputs[0])
             assertEquals(vaultState.state.data.copy(owner = THEIR_IDENTITY_1), wtx.getOutput(0))
@@ -622,7 +621,6 @@ class CashTests : TestDependencyInjectionBase() {
                 makeSpend(10.DOLLARS, THEIR_IDENTITY_1)
             }
         database.transaction {
-            @Suppress("UNCHECKED_CAST")
             val vaultState = vaultStatesUnconsumed.elementAt(0)
             val changeAmount = 90.DOLLARS `issued by` defaultIssuer
             val likelyChangeState = wtx.outputs.map(TransactionState<*>::data).filter { state ->
@@ -649,7 +647,6 @@ class CashTests : TestDependencyInjectionBase() {
                 makeSpend(500.DOLLARS, THEIR_IDENTITY_1)
             }
         database.transaction {
-            @Suppress("UNCHECKED_CAST")
             val vaultState0 = vaultStatesUnconsumed.elementAt(0)
             val vaultState1 = vaultStatesUnconsumed.elementAt(1)
             assertEquals(vaultState0.ref, wtx.inputs[0])
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt b/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
index 052a361267..1463229b13 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
@@ -5,6 +5,7 @@ import com.typesafe.config.Config
 import com.typesafe.config.ConfigUtil
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.noneOrSingle
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.utilities.NetworkHostAndPort
 import org.slf4j.LoggerFactory
 import java.net.Proxy
@@ -25,7 +26,7 @@ import kotlin.reflect.jvm.jvmErasure
 annotation class OldConfig(val value: String)
 
 // TODO Move other config parsing to use parseAs and remove this
-operator fun <T> Config.getValue(receiver: Any, metadata: KProperty<*>): T {
+operator fun <T : Any> Config.getValue(receiver: Any, metadata: KProperty<*>): T {
     return getValueInternal(metadata.name, metadata.returnType)
 }
 
@@ -52,9 +53,8 @@ fun Config.toProperties(): Properties {
             { it.value.unwrapped().toString() })
 }
 
-@Suppress("UNCHECKED_CAST")
-private fun <T> Config.getValueInternal(path: String, type: KType): T {
-    return (if (type.arguments.isEmpty()) getSingleValue(path, type) else getCollectionValue(path, type)) as T
+private fun <T : Any> Config.getValueInternal(path: String, type: KType): T {
+    return uncheckedCast(if (type.arguments.isEmpty()) getSingleValue(path, type) else getCollectionValue(path, type))
 }
 
 private fun Config.getSingleValue(path: String, type: KType): Any? {
@@ -122,8 +122,7 @@ private fun Config.defaultToOldPath(property: KProperty<*>): String {
     return property.name
 }
 
-@Suppress("UNCHECKED_CAST")
-private fun parseEnum(enumType: Class<*>, name: String): Enum<*> = enumBridge(enumType as Class<Proxy.Type>, name) // Any enum will do
+private fun parseEnum(enumType: Class<*>, name: String): Enum<*> = enumBridge<Proxy.Type>(uncheckedCast(enumType), name) // Any enum will do
 
 private fun <T : Enum<T>> enumBridge(clazz: Class<T>, name: String): T = java.lang.Enum.valueOf(clazz, name)
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
index 06f73a4a95..06820db6c2 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
@@ -14,6 +14,7 @@ import net.corda.core.crypto.CompositeKey
 import net.corda.core.crypto.Crypto
 import net.corda.core.crypto.TransactionSignature
 import net.corda.core.identity.Party
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.SerializationContext
 import net.corda.core.serialization.SerializeAsTokenContext
 import net.corda.core.serialization.SerializedBytes
@@ -245,9 +246,8 @@ object WireTransactionSerializer : Serializer<WireTransaction>() {
         kryo.writeClassAndObject(output, obj.privacySalt)
     }
 
-    @Suppress("UNCHECKED_CAST")
     override fun read(kryo: Kryo, input: Input, type: Class<WireTransaction>): WireTransaction {
-        val componentGroups = kryo.readClassAndObject(input) as List<ComponentGroup>
+        val componentGroups: List<ComponentGroup> = uncheckedCast(kryo.readClassAndObject(input))
         val privacySalt = kryo.readClassAndObject(input) as PrivacySalt
         return WireTransaction(componentGroups, privacySalt)
     }
@@ -261,9 +261,8 @@ object NotaryChangeWireTransactionSerializer : Serializer<NotaryChangeWireTransa
         kryo.writeClassAndObject(output, obj.newNotary)
     }
 
-    @Suppress("UNCHECKED_CAST")
     override fun read(kryo: Kryo, input: Input, type: Class<NotaryChangeWireTransaction>): NotaryChangeWireTransaction {
-        val inputs = kryo.readClassAndObject(input) as List<StateRef>
+        val inputs: List<StateRef> = uncheckedCast(kryo.readClassAndObject(input))
         val notary = kryo.readClassAndObject(input) as Party
         val newNotary = kryo.readClassAndObject(input) as Party
 
@@ -278,11 +277,10 @@ object SignedTransactionSerializer : Serializer<SignedTransaction>() {
         kryo.writeClassAndObject(output, obj.sigs)
     }
 
-    @Suppress("UNCHECKED_CAST")
     override fun read(kryo: Kryo, input: Input, type: Class<SignedTransaction>): SignedTransaction {
         return SignedTransaction(
-                kryo.readClassAndObject(input) as SerializedBytes<CoreTransaction>,
-                kryo.readClassAndObject(input) as List<TransactionSignature>
+                uncheckedCast<Any?, SerializedBytes<CoreTransaction>>(kryo.readClassAndObject(input)),
+                uncheckedCast<Any?, List<TransactionSignature>>(kryo.readClassAndObject(input))
         )
     }
 }
@@ -600,8 +598,7 @@ class ThrowableSerializer<T>(kryo: Kryo, type: Class<T>) : Serializer<Throwable>
         }
     }
 
-    @Suppress("UNCHECKED_CAST")
-    private val delegate: Serializer<Throwable> = ReflectionSerializerFactory.makeSerializer(kryo, FieldSerializer::class.java, type) as Serializer<Throwable>
+    private val delegate: Serializer<Throwable> = uncheckedCast(ReflectionSerializerFactory.makeSerializer(kryo, FieldSerializer::class.java, type))
 
     override fun write(kryo: Kryo, output: Output, throwable: Throwable) {
         delegate.write(kryo, output, throwable)
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
index 299b77ae84..648d6e5817 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
@@ -14,6 +14,7 @@ import com.google.common.cache.CacheBuilder
 import net.corda.core.contracts.Attachment
 import net.corda.core.crypto.SecureHash
 import net.corda.core.internal.LazyPool
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.*
 import net.corda.core.utilities.ByteSequence
 import net.corda.core.utilities.OpaqueBytes
@@ -204,11 +205,10 @@ abstract class AbstractKryoSerializationScheme : SerializationScheme {
         Input(byteSequence.bytes, byteSequence.offset + headerSize, byteSequence.size - headerSize).use { input ->
             return pool.run { kryo ->
                 withContext(kryo, context) {
-                    @Suppress("UNCHECKED_CAST")
                     if (context.objectReferencesEnabled) {
-                        kryo.readClassAndObject(input) as T
+                        uncheckedCast(kryo.readClassAndObject(input))
                     } else {
-                        kryo.withoutReferences { kryo.readClassAndObject(input) as T }
+                        kryo.withoutReferences { uncheckedCast<Any?, T>(kryo.readClassAndObject(input)) }
                     }
                 }
             }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CollectionSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CollectionSerializer.kt
index 615cea26af..43a0234f95 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CollectionSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CollectionSerializer.kt
@@ -1,5 +1,6 @@
 package net.corda.nodeapi.internal.serialization.amqp
 
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.utilities.NonEmptySet
 import org.apache.qpid.proton.amqp.Symbol
 import org.apache.qpid.proton.codec.Data
@@ -36,8 +37,7 @@ class CollectionSerializer(val declaredType: ParameterizedType, factory: Seriali
         fun deriveParameterizedType(declaredType: Type, declaredClass: Class<*>, actualClass: Class<*>?): ParameterizedType {
             if(supportedTypes.containsKey(declaredClass)) {
                 // Simple case - it is already known to be a collection.
-                @Suppress("UNCHECKED_CAST")
-                return deriveParametrizedType(declaredType, declaredClass as Class<out Collection<*>>)
+                return deriveParametrizedType(declaredType, uncheckedCast(declaredClass))
             }
             else if (actualClass != null && Collection::class.java.isAssignableFrom(actualClass)) {
                 // Declared class is not collection, but [actualClass] is - represent it accordingly.
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CustomSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CustomSerializer.kt
index 7188a99b50..242f829511 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CustomSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CustomSerializer.kt
@@ -1,5 +1,6 @@
 package net.corda.nodeapi.internal.serialization.amqp
 
+import net.corda.core.internal.uncheckedCast
 import net.corda.nodeapi.internal.serialization.amqp.SerializerFactory.Companion.nameForType
 import org.apache.qpid.proton.amqp.Symbol
 import org.apache.qpid.proton.codec.Data
@@ -9,7 +10,7 @@ import java.lang.reflect.Type
  * Base class for serializers of core platform types that do not conform to the usual serialization rules and thus
  * cannot be automatically serialized.
  */
-abstract class CustomSerializer<T> : AMQPSerializer<T> {
+abstract class CustomSerializer<T : Any> : AMQPSerializer<T> {
     /**
      * This is a collection of custom serializers that this custom serializer depends on.  e.g. for proxy objects
      * that refer to other custom types etc.
@@ -36,8 +37,7 @@ abstract class CustomSerializer<T> : AMQPSerializer<T> {
 
     override fun writeObject(obj: Any, data: Data, type: Type, output: SerializationOutput) {
         data.withDescribed(descriptor) {
-            @Suppress("UNCHECKED_CAST")
-            writeDescribedObject(obj as T, data, type, output)
+            writeDescribedObject(uncheckedCast(obj), data, type, output)
         }
     }
 
@@ -49,7 +49,7 @@ abstract class CustomSerializer<T> : AMQPSerializer<T> {
      * subclass in the schema, so that we can distinguish between subclasses.
      */
     // TODO: should this be a custom serializer at all, or should it just be a plain AMQPSerializer?
-    class SubClass<T>(protected val clazz: Class<*>, protected val superClassSerializer: CustomSerializer<T>) : CustomSerializer<T>() {
+    class SubClass<T : Any>(protected val clazz: Class<*>, protected val superClassSerializer: CustomSerializer<T>) : CustomSerializer<T>() {
         // TODO: should this be empty or contain the schema of the super?
         override val schemaForDocumentation = Schema(emptyList())
 
@@ -76,7 +76,7 @@ abstract class CustomSerializer<T> : AMQPSerializer<T> {
      * Additional base features for a custom serializer for a particular class [withInheritance] is false
      * or super class / interfaces [withInheritance] is true
      */
-    abstract class CustomSerializerImp<T>(protected val clazz: Class<T>, protected val withInheritance: Boolean) : CustomSerializer<T>() {
+    abstract class CustomSerializerImp<T : Any>(protected val clazz: Class<T>, protected val withInheritance: Boolean) : CustomSerializer<T>() {
         override val type: Type get() = clazz
         override val typeDescriptor = Symbol.valueOf("$DESCRIPTOR_DOMAIN:${nameForType(clazz)}")
         override fun writeClassInfo(output: SerializationOutput) {}
@@ -87,12 +87,12 @@ abstract class CustomSerializer<T> : AMQPSerializer<T> {
     /**
      * Additional base features for a custom serializer for a particular class, that excludes subclasses.
      */
-    abstract class Is<T>(clazz: Class<T>) : CustomSerializerImp<T>(clazz, false)
+    abstract class Is<T : Any>(clazz: Class<T>) : CustomSerializerImp<T>(clazz, false)
 
     /**
      * Additional base features for a custom serializer for all implementations of a particular interface or super class.
      */
-    abstract class Implements<T>(clazz: Class<T>) : CustomSerializerImp<T>(clazz, true)
+    abstract class Implements<T : Any>(clazz: Class<T>) : CustomSerializerImp<T>(clazz, true)
 
     /**
      * Additional base features over and above [Implements] or [Is] custom serializer for when the serialized form should be
@@ -101,7 +101,7 @@ abstract class CustomSerializer<T> : AMQPSerializer<T> {
      * The proxy class must use only types which are either native AMQP or other types for which there are pre-registered
      * custom serializers.
      */
-    abstract class Proxy<T, P>(clazz: Class<T>,
+    abstract class Proxy<T : Any, P : Any>(clazz: Class<T>,
                                protected val proxyClass: Class<P>,
                                protected val factory: SerializerFactory,
                                withInheritance: Boolean = true) : CustomSerializerImp<T>(clazz, withInheritance) {
@@ -134,8 +134,7 @@ abstract class CustomSerializer<T> : AMQPSerializer<T> {
         }
 
         override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): T {
-            @Suppress("UNCHECKED_CAST")
-            val proxy = proxySerializer.readObject(obj, schema, input) as P
+            val proxy: P = uncheckedCast(proxySerializer.readObject(obj, schema, input))
             return fromProxy(proxy)
         }
     }
@@ -151,7 +150,7 @@ abstract class CustomSerializer<T> : AMQPSerializer<T> {
      * @param make A lambda for constructing an instance, that defaults to calling a constructor that expects a string.
      * @param unmake A lambda that extracts the string value for an instance, that defaults to the [toString] method.
      */
-    abstract class ToString<T>(clazz: Class<T>, withInheritance: Boolean = false,
+    abstract class ToString<T : Any>(clazz: Class<T>, withInheritance: Boolean = false,
                                private val maker: (String) -> T = clazz.getConstructor(String::class.java).let {
                                    `constructor` ->
                                    { string -> `constructor`.newInstance(string) }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/MapSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/MapSerializer.kt
index b343e96469..1fa710d59a 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/MapSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/MapSerializer.kt
@@ -1,5 +1,6 @@
 package net.corda.nodeapi.internal.serialization.amqp
 
+import net.corda.core.internal.uncheckedCast
 import org.apache.qpid.proton.amqp.Symbol
 import org.apache.qpid.proton.codec.Data
 import java.io.NotSerializableException
@@ -31,8 +32,7 @@ class MapSerializer(private val declaredType: ParameterizedType, factory: Serial
                 LinkedHashMap::class.java to { map -> LinkedHashMap(map) },
                 TreeMap::class.java to { map -> TreeMap(map) },
                 EnumMap::class.java to { map ->
-                    @Suppress("UNCHECKED_CAST")
-                    EnumMap(map as Map<EnumJustUsedForCasting, Any>)
+                    EnumMap(uncheckedCast<Map<*, *>, Map<EnumJustUsedForCasting, Any>>(map))
                 }
         ))
 
@@ -44,8 +44,7 @@ class MapSerializer(private val declaredType: ParameterizedType, factory: Serial
             declaredClass.checkSupportedMapType()
             if(supportedTypes.containsKey(declaredClass)) {
                 // Simple case - it is already known to be a map.
-                @Suppress("UNCHECKED_CAST")
-                return deriveParametrizedType(declaredType, declaredClass as Class<out Map<*, *>>)
+                return deriveParametrizedType(declaredType, uncheckedCast(declaredClass))
             }
             else if (actualClass != null && Map::class.java.isAssignableFrom(actualClass)) {
                 // Declared class is not map, but [actualClass] is - represent it accordingly.
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/Schema.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/Schema.kt
index 4ec6bb32cf..adb0c44f0c 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/Schema.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/Schema.kt
@@ -2,6 +2,7 @@ package net.corda.nodeapi.internal.serialization.amqp
 
 import com.google.common.hash.Hasher
 import com.google.common.hash.Hashing
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.loggerFor
 import net.corda.core.utilities.toBase64
@@ -94,8 +95,7 @@ data class Schema(val types: List<TypeNotation>) : DescribedType {
 
         override fun newInstance(described: Any?): Schema {
             val list = described as? List<*> ?: throw IllegalStateException("Was expecting a list")
-            @Suppress("UNCHECKED_CAST")
-            return Schema(list[0] as List<TypeNotation>)
+            return Schema(uncheckedCast(list[0]))
         }
     }
 
@@ -162,8 +162,7 @@ data class Field(val name: String, val type: String, val requires: List<String>,
 
         override fun newInstance(described: Any?): Field {
             val list = described as? List<*> ?: throw IllegalStateException("Was expecting a list")
-            @Suppress("UNCHECKED_CAST")
-            return Field(list[0] as String, list[1] as String, list[2] as List<String>, list[3] as? String, list[4] as? String, list[5] as Boolean, list[6] as Boolean)
+            return Field(list[0] as String, list[1] as String, uncheckedCast(list[2]), list[3] as? String, list[4] as? String, list[5] as Boolean, list[6] as Boolean)
         }
     }
 
@@ -223,8 +222,7 @@ data class CompositeType(override val name: String, override val label: String?,
 
         override fun newInstance(described: Any?): CompositeType {
             val list = described as? List<*> ?: throw IllegalStateException("Was expecting a list")
-            @Suppress("UNCHECKED_CAST")
-            return CompositeType(list[0] as String, list[1] as? String, list[2] as List<String>, list[3] as Descriptor, list[4] as List<Field>)
+            return CompositeType(list[0] as String, list[1] as? String, uncheckedCast(list[2]), list[3] as Descriptor, uncheckedCast(list[4]))
         }
     }
 
@@ -273,8 +271,7 @@ data class RestrictedType(override val name: String,
 
         override fun newInstance(described: Any?): RestrictedType {
             val list = described as? List<*> ?: throw IllegalStateException("Was expecting a list")
-            @Suppress("UNCHECKED_CAST")
-            return RestrictedType(list[0] as String, list[1] as? String, list[2] as List<String>, list[3] as String, list[4] as Descriptor, list[5] as List<Choice>)
+            return RestrictedType(list[0] as String, list[1] as? String, uncheckedCast(list[2]), list[3] as String, list[4] as Descriptor, uncheckedCast(list[5]))
         }
     }
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
index 0077285e77..fe05093168 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
@@ -2,6 +2,7 @@ package net.corda.nodeapi.internal.serialization.amqp
 
 import com.google.common.primitives.Primitives
 import com.google.common.reflect.TypeResolver
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.ClassWhitelist
 import net.corda.core.serialization.CordaSerializable
 import net.corda.nodeapi.internal.serialization.carpenter.*
@@ -262,8 +263,7 @@ class SerializerFactory(val whitelist: ClassWhitelist, cl: ClassLoader) {
                     return customSerializer
                 } else {
                     // Make a subclass serializer for the subclass and return that...
-                    @Suppress("UNCHECKED_CAST")
-                    return CustomSerializer.SubClass(clazz, customSerializer as CustomSerializer<Any>)
+                    return CustomSerializer.SubClass(clazz, uncheckedCast(customSerializer))
                 }
             }
         }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/EnumSetSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/EnumSetSerializer.kt
index 29527d21dd..5f86857ffe 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/EnumSetSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/EnumSetSerializer.kt
@@ -1,11 +1,11 @@
 package net.corda.nodeapi.internal.serialization.amqp.custom
 
+import net.corda.core.internal.uncheckedCast
 import net.corda.nodeapi.internal.serialization.amqp.CustomSerializer
 import net.corda.nodeapi.internal.serialization.amqp.MapSerializer
 import net.corda.nodeapi.internal.serialization.amqp.SerializerFactory
 import java.util.*
 
-@Suppress("UNCHECKED_CAST")
 /**
  * A serializer that writes out an [EnumSet] as a type, plus list of instances in the set.
  */
@@ -16,7 +16,7 @@ class EnumSetSerializer(factory: SerializerFactory) : CustomSerializer.Proxy<Enu
 
     private fun elementType(set: EnumSet<*>): Class<*> {
         return if (set.isEmpty()) {
-            EnumSet.complementOf(set as EnumSet<MapSerializer.EnumJustUsedForCasting>).first().javaClass
+            EnumSet.complementOf(uncheckedCast<EnumSet<*>, EnumSet<MapSerializer.EnumJustUsedForCasting>>(set)).first().javaClass
         } else {
             set.first().javaClass
         }
@@ -24,9 +24,9 @@ class EnumSetSerializer(factory: SerializerFactory) : CustomSerializer.Proxy<Enu
 
     override fun fromProxy(proxy: EnumSetProxy): EnumSet<*> {
         return if (proxy.elements.isEmpty()) {
-            EnumSet.noneOf(proxy.clazz as Class<MapSerializer.EnumJustUsedForCasting>)
+            EnumSet.noneOf(uncheckedCast<Class<*>, Class<MapSerializer.EnumJustUsedForCasting>>(proxy.clazz))
         } else {
-            EnumSet.copyOf(proxy.elements as List<MapSerializer.EnumJustUsedForCasting>)
+            EnumSet.copyOf(uncheckedCast<List<Any>, List<MapSerializer.EnumJustUsedForCasting>>(proxy.elements))
         }
     }
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt
index d47bc1bf52..9f727e09c7 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt
@@ -237,10 +237,9 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
     }
 
     private fun ClassWriter.generateGetters(schema: Schema) {
-        @Suppress("UNCHECKED_CAST")
-        for ((name, type) in (schema.fields as Map<String, ClassField>)) {
+        for ((name, type) in schema.fields) {
             visitMethod(ACC_PUBLIC, "get" + name.capitalize(), "()" + type.descriptor, null, null).apply {
-                type.addNullabilityAnnotation(this)
+                (type as ClassField).addNullabilityAnnotation(this)
                 visitCode()
                 visitVarInsn(ALOAD, 0)  // Load 'this'
                 visitFieldInsn(GETFIELD, schema.jvmName, name, type.descriptor)
@@ -258,8 +257,7 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
     }
 
     private fun ClassWriter.generateAbstractGetters(schema: Schema) {
-        @Suppress("UNCHECKED_CAST")
-        for ((name, field) in (schema.fields as Map<String, ClassField>)) {
+        for ((name, field) in schema.fields) {
             val opcodes = ACC_ABSTRACT + ACC_PUBLIC
             // abstract method doesn't have any implementation so just end
             visitMethod(opcodes, "get" + name.capitalize(), "()${field.descriptor}", null, null).visitEnd()
@@ -363,9 +361,8 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
 
             // Assign the fields from parameters.
             var slot = 1 + superclassFields.size
-            @Suppress("UNCHECKED_CAST")
-            for ((name, field) in (schema.fields as Map<String, ClassField>)) {
-                field.nullTest(this, slot)
+            for ((name, field) in schema.fields) {
+                (field as ClassField).nullTest(this, slot)
 
                 visitVarInsn(ALOAD, 0)  // Load 'this' onto the stack
                 slot += load(slot, field)  // Load the contents of the parameter onto the stack.
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterTest.kt
index 913ea207c1..0c1c610c5a 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterTest.kt
@@ -1,5 +1,6 @@
 package net.corda.nodeapi.internal.serialization.carpenter
 
+import net.corda.core.internal.uncheckedCast
 import net.corda.nodeapi.internal.serialization.AllWhitelist
 import org.junit.Test
 import java.beans.Introspector
@@ -323,7 +324,6 @@ class ClassCarpenterTest {
     }
 
     @Test
-    @Suppress("UNCHECKED_CAST")
     fun `int array`() {
         val className = "iEnjoyPotato"
         val schema = ClassSchema(
@@ -356,7 +356,6 @@ class ClassCarpenterTest {
     }
 
     @Test
-    @Suppress("UNCHECKED_CAST")
     fun `integer array`() {
         val className = "iEnjoyFlan"
         val schema = ClassSchema(
@@ -366,16 +365,15 @@ class ClassCarpenterTest {
         val clazz = cc.build(schema)
 
         val i = clazz.constructors[0].newInstance(arrayOf(1, 2, 3)) as SimpleFieldAccess
-        val arr = clazz.getMethod("getA").invoke(i)
+        val arr: Array<Int> = uncheckedCast(clazz.getMethod("getA").invoke(i))
 
-        assertEquals(1, (arr as Array<Int>)[0])
+        assertEquals(1, arr[0])
         assertEquals(2, arr[1])
         assertEquals(3, arr[2])
         assertEquals("$className{a=[1, 2, 3]}", i.toString())
     }
 
     @Test
-    @Suppress("UNCHECKED_CAST")
     fun `int array with ints`() {
         val className = "iEnjoyCrumble"
         val schema = ClassSchema(
@@ -395,7 +393,6 @@ class ClassCarpenterTest {
     }
 
     @Test
-    @Suppress("UNCHECKED_CAST")
     fun `multiple int arrays`() {
         val className = "iEnjoyJam"
         val schema = ClassSchema(
@@ -417,7 +414,6 @@ class ClassCarpenterTest {
     }
 
     @Test
-    @Suppress("UNCHECKED_CAST")
     fun `string array`() {
         val className = "iEnjoyToast"
         val schema = ClassSchema(
@@ -427,7 +423,7 @@ class ClassCarpenterTest {
         val clazz = cc.build(schema)
 
         val i = clazz.constructors[0].newInstance(arrayOf("toast", "butter", "jam"))
-        val arr = clazz.getMethod("getA").invoke(i) as Array<String>
+        val arr: Array<String> = uncheckedCast(clazz.getMethod("getA").invoke(i))
 
         assertEquals("toast", arr[0])
         assertEquals("butter", arr[1])
@@ -435,7 +431,6 @@ class ClassCarpenterTest {
     }
 
     @Test
-    @Suppress("UNCHECKED_CAST")
     fun `string arrays`() {
         val className = "iEnjoyToast"
         val schema = ClassSchema(
@@ -452,8 +447,8 @@ class ClassCarpenterTest {
                 "and on the side",
                 arrayOf("some pickles", "some fries"))
 
-        val arr1 = clazz.getMethod("getA").invoke(i) as Array<String>
-        val arr2 = clazz.getMethod("getC").invoke(i) as Array<String>
+        val arr1: Array<String> = uncheckedCast(clazz.getMethod("getA").invoke(i))
+        val arr2: Array<String> = uncheckedCast(clazz.getMethod("getC").invoke(i))
 
         assertEquals("bread", arr1[0])
         assertEquals("spread", arr1[1])
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 0c6b9cec56..50e9ac4866 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -18,6 +18,7 @@ import net.corda.core.internal.concurrent.doneFuture
 import net.corda.core.internal.concurrent.flatMap
 import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.internal.toX509CertHolder
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.CordaRPCOps
 import net.corda.core.messaging.RPCOps
 import net.corda.core.messaging.SingleMessageRecipient
@@ -322,11 +323,9 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
             } else {
                 log.warn(deprecatedFlowConstructorMessage(initiatedFlow))
             }
-            @Suppress("UNCHECKED_CAST")
-            { flowSession: FlowSession -> partyCtor.newInstance(flowSession.counterparty) as F }
+            { flowSession: FlowSession -> uncheckedCast(partyCtor.newInstance(flowSession.counterparty)) }
         } else {
-            @Suppress("UNCHECKED_CAST")
-            { flowSession: FlowSession -> flowSessionCtor.newInstance(flowSession) as F }
+            { flowSession: FlowSession -> uncheckedCast(flowSessionCtor.newInstance(flowSession)) }
         }
         val initiatingFlow = initiatedFlow.requireAnnotation<InitiatedBy>().value.java
         val (version, classWithAnnotation) = initiatingFlow.flowVersionAndInitiatingClass
diff --git a/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt b/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
index 1e2625ffb4..5492f24c1d 100644
--- a/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
+++ b/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
@@ -8,6 +8,7 @@ import net.corda.core.flows.StateMachineRunId
 import net.corda.core.identity.Party
 import net.corda.core.internal.FlowStateMachine
 import net.corda.core.internal.VisibleForTesting
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.DataFeed
 import net.corda.core.messaging.SingleMessageRecipient
 import net.corda.core.messaging.StateMachineTransactionMapping
@@ -132,8 +133,7 @@ interface ServiceHubInternal : ServiceHub {
             flowInitiator: FlowInitiator,
             vararg args: Any?): FlowStateMachineImpl<T> {
         val logicRef = FlowLogicRefFactoryImpl.createForRPC(logicType, *args)
-        @Suppress("UNCHECKED_CAST")
-        val logic = FlowLogicRefFactoryImpl.toFlowLogic(logicRef) as FlowLogic<T>
+        val logic: FlowLogic<T> = uncheckedCast(FlowLogicRefFactoryImpl.toFlowLogic(logicRef))
         return startFlow(logic, flowInitiator, ourIdentity = null)
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt b/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt
index 784776820c..32c866da19 100644
--- a/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt
+++ b/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt
@@ -11,6 +11,7 @@ import net.corda.core.internal.ThreadBox
 import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.internal.div
 import net.corda.core.internal.noneOrSingle
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.services.NetworkMapCache
 import net.corda.core.node.services.NetworkMapCache.MapChange
@@ -56,7 +57,6 @@ import java.math.BigInteger
 import java.security.KeyStore
 import java.security.KeyStoreException
 import java.security.Principal
-import java.security.cert.X509Certificate
 import java.util.*
 import java.util.concurrent.Executor
 import java.util.concurrent.ScheduledExecutorService
@@ -478,8 +478,7 @@ private class VerifyingNettyConnector(configuration: MutableMap<String, Any>,
     override fun createConnection(): Connection? {
         val connection = super.createConnection() as? NettyConnection
         if (sslEnabled && connection != null) {
-            @Suppress("UNCHECKED_CAST")
-            val expectedLegalNames = (configuration[ArtemisTcpTransport.VERIFY_PEER_LEGAL_NAME] ?: emptySet<CordaX500Name>()) as Set<CordaX500Name>
+            val expectedLegalNames: Set<CordaX500Name> = uncheckedCast(configuration[ArtemisTcpTransport.VERIFY_PEER_LEGAL_NAME] ?: emptySet<CordaX500Name>())
             try {
                 val session = connection.channel
                         .pipeline()
@@ -608,12 +607,11 @@ class NodeLoginModule : LoginModule {
     private lateinit var verifierCertCheck: CertificateChainCheckPolicy.Check
     private val principals = ArrayList<Principal>()
 
-    @Suppress("UNCHECKED_CAST")
     override fun initialize(subject: Subject, callbackHandler: CallbackHandler, sharedState: Map<String, *>, options: Map<String, *>) {
         this.subject = subject
         this.callbackHandler = callbackHandler
         userService = options[RPCUserService::class.java.name] as RPCUserService
-        val certChainChecks = options[CERT_CHAIN_CHECKS_OPTION_NAME] as Map<String, CertificateChainCheckPolicy.Check>
+        val certChainChecks: Map<String, CertificateChainCheckPolicy.Check> = uncheckedCast(options[CERT_CHAIN_CHECKS_OPTION_NAME])
         peerCertCheck = certChainChecks[PEER_ROLE]!!
         nodeCertCheck = certChainChecks[NODE_ROLE]!!
         verifierCertCheck = certChainChecks[VERIFIER_ROLE]!!
diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/Messaging.kt b/node/src/main/kotlin/net/corda/node/services/messaging/Messaging.kt
index 062919084e..b05dc10c02 100644
--- a/node/src/main/kotlin/net/corda/node/services/messaging/Messaging.kt
+++ b/node/src/main/kotlin/net/corda/node/services/messaging/Messaging.kt
@@ -4,6 +4,7 @@ import com.google.common.util.concurrent.ListenableFuture
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.concurrent.openFuture
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.MessageRecipients
 import net.corda.core.messaging.SingleMessageRecipient
 import net.corda.core.node.services.PartyInfo
@@ -161,8 +162,7 @@ fun <M : Any> MessagingService.onNext(topic: String, sessionId: Long): CordaFutu
     val messageFuture = openFuture<M>()
     runOnNextMessage(topic, sessionId) { message ->
         messageFuture.capture {
-            @Suppress("UNCHECKED_CAST")
-            message.data.deserialize<Any>() as M
+            uncheckedCast(message.data.deserialize<Any>())
         }
     }
     return messageFuture
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
index 1556ef31c3..b3103f979e 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
@@ -12,12 +12,9 @@ import net.corda.core.crypto.random63BitValue
 import net.corda.core.flows.*
 import net.corda.core.identity.Party
 import net.corda.core.identity.PartyAndCertificate
-import net.corda.core.internal.FlowStateMachine
-import net.corda.core.internal.abbreviate
+import net.corda.core.internal.*
 import net.corda.core.internal.concurrent.OpenFuture
 import net.corda.core.internal.concurrent.openFuture
-import net.corda.core.internal.isRegularFile
-import net.corda.core.internal.staticField
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.utilities.*
 import net.corda.node.services.api.FlowAppAuditEvent
@@ -281,7 +278,7 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
     }
 
     // TODO Dummy implementation of access to application specific audit logging
-    override fun recordAuditEvent(eventType: String, comment: String, extraAuditData: Map<String, String>): Unit {
+    override fun recordAuditEvent(eventType: String, comment: String, extraAuditData: Map<String, String>) {
         val flowAuditEvent = FlowAppAuditEvent(
                 serviceHub.clock.instant(),
                 flowInitiator,
@@ -430,8 +427,7 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
         val session = receiveRequest.session
         val receiveType = receiveRequest.receiveType
         if (receiveType.isInstance(message)) {
-            @Suppress("UNCHECKED_CAST")
-            return this as ReceivedSessionMessage<M>
+            return uncheckedCast(this)
         } else if (message is SessionEnd) {
             openSessions.values.remove(session)
             if (message is ErrorSessionEnd) {
@@ -519,7 +515,6 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
     }
 }
 
-@Suppress("UNCHECKED_CAST")
 val Class<out FlowLogic<*>>.flowVersionAndInitiatingClass: Pair<Int, Class<out FlowLogic<*>>> get() {
     var current: Class<*> = this
     var found: Pair<Int, Class<out FlowLogic<*>>>? = null
@@ -528,7 +523,7 @@ val Class<out FlowLogic<*>>.flowVersionAndInitiatingClass: Pair<Int, Class<out F
         if (annotation != null) {
             if (found != null) throw IllegalArgumentException("${InitiatingFlow::class.java.name} can only be annotated once")
             require(annotation.version > 0) { "Flow versions have to be greater or equal to 1" }
-            found = annotation.version to (current as Class<out FlowLogic<*>>)
+            found = annotation.version to uncheckedCast(current)
         }
         current = current.superclass
             ?: return found
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
index dc2a8342cb..2382614752 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
@@ -14,9 +14,7 @@ import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.random63BitValue
 import net.corda.core.flows.*
 import net.corda.core.identity.Party
-import net.corda.core.internal.ThreadBox
-import net.corda.core.internal.bufferUntilSubscribed
-import net.corda.core.internal.castIfPossible
+import net.corda.core.internal.*
 import net.corda.core.messaging.DataFeed
 import net.corda.core.serialization.SerializationDefaults.CHECKPOINT_CONTEXT
 import net.corda.core.serialization.SerializationDefaults.SERIALIZATION_FACTORY
@@ -149,10 +147,9 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
 
     /** Returns a list of all state machines executing the given flow logic at the top level (subflows do not count) */
     fun <P : FlowLogic<T>, T> findStateMachines(flowClass: Class<P>): List<Pair<P, CordaFuture<T>>> {
-        @Suppress("UNCHECKED_CAST")
         return mutex.locked {
             stateMachines.keys.mapNotNull {
-                flowClass.castIfPossible(it.logic)?.let { it to (it.stateMachine as FlowStateMachineImpl<T>).resultFuture }
+                flowClass.castIfPossible(it.logic)?.let { it to uncheckedCast<FlowStateMachine<*>, FlowStateMachineImpl<T>>(it.stateMachine).resultFuture }
             }
         }
     }
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/PathManager.kt b/node/src/main/kotlin/net/corda/node/services/transactions/PathManager.kt
index 7a031540f9..20e69d5aae 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/PathManager.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/PathManager.kt
@@ -1,5 +1,6 @@
 package net.corda.node.services.transactions
 
+import net.corda.core.internal.uncheckedCast
 import net.corda.nodeapi.internal.addShutdownHook
 import java.io.Closeable
 import java.nio.file.Path
@@ -31,8 +32,7 @@ open class PathManager<T : PathManager<T>>(path: Path) : Closeable {
 
     fun handle(): T {
         handleCounter.incrementAndGet()
-        @Suppress("UNCHECKED_CAST")
-        return this as T
+        return uncheckedCast(this)
     }
 
     override fun close() {
diff --git a/node/src/main/kotlin/net/corda/node/services/vault/HibernateQueryCriteriaParser.kt b/node/src/main/kotlin/net/corda/node/services/vault/HibernateQueryCriteriaParser.kt
index 575d1cbfc9..30c32220f7 100644
--- a/node/src/main/kotlin/net/corda/node/services/vault/HibernateQueryCriteriaParser.kt
+++ b/node/src/main/kotlin/net/corda/node/services/vault/HibernateQueryCriteriaParser.kt
@@ -3,6 +3,7 @@ package net.corda.node.services.vault
 import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.StateRef
 import net.corda.core.identity.AbstractParty
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.node.services.Vault
 import net.corda.core.node.services.VaultQueryException
 import net.corda.core.node.services.vault.*
@@ -111,8 +112,7 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
                 }
             }
             is ColumnPredicate.BinaryComparison -> {
-                @Suppress("UNCHECKED_CAST")
-                val literal = columnPredicate.rightLiteral as Comparable<Any?>?
+                val literal: Comparable<Any?>? = uncheckedCast(columnPredicate.rightLiteral)
                 @Suppress("UNCHECKED_CAST")
                 column as Path<Comparable<Any?>?>
                 when (columnPredicate.operator) {
@@ -139,10 +139,8 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
             is ColumnPredicate.Between -> {
                 @Suppress("UNCHECKED_CAST")
                 column as Path<Comparable<Any?>?>
-                @Suppress("UNCHECKED_CAST")
-                val fromLiteral = columnPredicate.rightFromLiteral as Comparable<Any?>?
-                @Suppress("UNCHECKED_CAST")
-                val toLiteral = columnPredicate.rightToLiteral as Comparable<Any?>?
+                val fromLiteral: Comparable<Any?>? = uncheckedCast(columnPredicate.rightFromLiteral)
+                val toLiteral: Comparable<Any?>? = uncheckedCast(columnPredicate.rightToLiteral)
                 criteriaBuilder.between(column, fromLiteral, toLiteral)
             }
             is ColumnPredicate.NullExpression -> {
diff --git a/node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt b/node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt
index 27afbc2040..3501c2db34 100644
--- a/node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt
@@ -7,6 +7,7 @@ import net.corda.core.contracts.TransactionState
 import net.corda.core.crypto.SecureHash
 import net.corda.core.internal.ThreadBox
 import net.corda.core.internal.bufferUntilSubscribed
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.DataFeed
 import net.corda.core.node.services.Vault
 import net.corda.core.node.services.VaultQueryException
@@ -153,8 +154,7 @@ class HibernateVaultQueryImpl(val hibernateConfig: HibernateConfiguration,
     override fun <T : ContractState> _trackBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
         return mutex.locked {
             val snapshotResults = _queryBy(criteria, paging, sorting, contractStateType)
-            @Suppress("UNCHECKED_CAST")
-            val updates = vault.updatesPublisher.bufferUntilSubscribed().filter { it.containsType(contractStateType, snapshotResults.stateTypes) } as Observable<Vault.Update<T>>
+            val updates: Observable<Vault.Update<T>> = uncheckedCast(vault.updatesPublisher.bufferUntilSubscribed().filter { it.containsType(contractStateType, snapshotResults.stateTypes) })
             DataFeed(snapshotResults, updates)
         }
     }
@@ -180,8 +180,7 @@ class HibernateVaultQueryImpl(val hibernateConfig: HibernateConfiguration,
 
             val contractInterfaceToConcreteTypes = mutableMapOf<String, MutableSet<String>>()
             distinctTypes.forEach { type ->
-                @Suppress("UNCHECKED_CAST")
-                val concreteType = Class.forName(type) as Class<ContractState>
+                val concreteType: Class<ContractState> = uncheckedCast(Class.forName(type))
                 val contractInterfaces = deriveContractInterfaces(concreteType)
                 contractInterfaces.map {
                     val contractInterface = contractInterfaceToConcreteTypes.getOrPut(it.name, { mutableSetOf() })
@@ -196,9 +195,8 @@ class HibernateVaultQueryImpl(val hibernateConfig: HibernateConfiguration,
         val myInterfaces: MutableSet<Class<T>> = mutableSetOf()
         clazz.interfaces.forEach {
             if (!it.equals(ContractState::class.java)) {
-                @Suppress("UNCHECKED_CAST")
-                myInterfaces.add(it as Class<T>)
-                myInterfaces.addAll(deriveContractInterfaces(it))
+                myInterfaces.add(uncheckedCast(it))
+                myInterfaces.addAll(deriveContractInterfaces(uncheckedCast(it)))
             }
         }
         return myInterfaces
diff --git a/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt b/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt
index 668236515a..35e695d78e 100644
--- a/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt
+++ b/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt
@@ -233,8 +233,7 @@ object InteractiveShell {
             return
         }
 
-        @Suppress("UNCHECKED_CAST")
-        val clazz = matches.single() as Class<FlowLogic<*>>
+        val clazz: Class<FlowLogic<*>> = uncheckedCast(matches.single())
         try {
             // TODO Flow invocation should use startFlowDynamic.
             val fsm = runFlowFromString({ node.services.startFlow(it, FlowInitiator.Shell) }, inputData, clazz)
@@ -434,8 +433,6 @@ object InteractiveShell {
         }
     }
 
-    // Kotlin bug: USELESS_CAST warning is generated below but the IDE won't let us remove it.
-    @Suppress("USELESS_CAST", "UNCHECKED_CAST")
     private fun maybeFollow(response: Any?, printerFun: (Any?) -> String, toStream: PrintWriter): OpenFuture<Unit>? {
         // Match on a couple of common patterns for "important" observables. It's tough to do this in a generic
         // way because observables can be embedded anywhere in the object graph, and can emit other arbitrary
@@ -454,7 +451,7 @@ object InteractiveShell {
         } ?: return null
 
         val subscriber = PrintingSubscriber(printerFun, toStream)
-        (observable as Observable<Any>).subscribe(subscriber)
+        uncheckedCast(observable).subscribe(subscriber)
         return subscriber.future
     }
 
diff --git a/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/FixingFlow.kt b/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/FixingFlow.kt
index e7d1074362..f2cb795f36 100644
--- a/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/FixingFlow.kt
+++ b/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/FixingFlow.kt
@@ -5,7 +5,7 @@ import net.corda.core.contracts.*
 import net.corda.core.crypto.TransactionSignature
 import net.corda.core.flows.*
 import net.corda.core.identity.Party
-import net.corda.core.node.NodeInfo
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.TransactionBuilder
@@ -46,7 +46,6 @@ object FixingFlow {
 
         @Suspendable
         override fun assembleSharedTX(handshake: TwoPartyDealFlow.Handshake<FixingSession>): Triple<TransactionBuilder, List<PublicKey>, List<TransactionSignature>> {
-            @Suppress("UNCHECKED_CAST")
             val fixOf = deal.nextFixingOf()!!
 
             // TODO Do we need/want to substitute in new public keys for the Parties?
@@ -91,9 +90,8 @@ object FixingFlow {
     class Floater(override val otherSideSession: FlowSession,
                   override val payload: FixingSession,
                   override val progressTracker: ProgressTracker = TwoPartyDealFlow.Primary.tracker()) : TwoPartyDealFlow.Primary() {
-        @Suppress("UNCHECKED_CAST")
         private val dealToFix: StateAndRef<FixableDealState> by transient {
-            val state = serviceHub.loadState(payload.ref) as TransactionState<FixableDealState>
+            val state: TransactionState<FixableDealState> = uncheckedCast(serviceHub.loadState(payload.ref))
             StateAndRef(state, payload.ref)
         }
 
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt
index 4642412d9b..687ccbe857 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt
@@ -11,6 +11,7 @@ import net.corda.core.flows.InitiatedBy
 import net.corda.core.flows.InitiatingFlow
 import net.corda.core.identity.Party
 import net.corda.core.internal.FlowStateMachine
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.node.services.queryBy
 import net.corda.core.toFuture
 import net.corda.core.transactions.SignedTransaction
@@ -155,9 +156,8 @@ class IRSSimulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, laten
 
         val acceptDealFlows: Observable<AcceptDealFlow> = node2.internals.registerInitiatedFlow(AcceptDealFlow::class.java)
 
-        @Suppress("UNCHECKED_CAST")
         val acceptorTxFuture = acceptDealFlows.toFuture().toCompletableFuture().thenCompose {
-            (it.stateMachine as FlowStateMachine<SignedTransaction>).resultFuture.toCompletableFuture()
+            uncheckedCast<FlowStateMachine<*>, FlowStateMachine<SignedTransaction>>(it.stateMachine).resultFuture.toCompletableFuture()
         }
 
         showProgressFor(listOf(node1, node2))
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/RPCDriver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/RPCDriver.kt
index 8bb2bd9a0c..4aff94842f 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/RPCDriver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/RPCDriver.kt
@@ -10,6 +10,7 @@ import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.concurrent.fork
 import net.corda.core.internal.concurrent.map
 import net.corda.core.internal.div
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.RPCOps
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.node.services.RPCUserService
@@ -507,8 +508,7 @@ class RandomRpcUser {
         @JvmStatic
         fun main(args: Array<String>) {
             require(args.size == 4)
-            @Suppress("UNCHECKED_CAST")
-            val rpcClass = Class.forName(args[0]) as Class<RPCOps>
+            val rpcClass: Class<RPCOps> = uncheckedCast(Class.forName(args[0]))
             val hostAndPort = NetworkHostAndPort.parse(args[1])
             val username = args[2]
             val password = args[3]
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
index 5a55586924..bedda6486b 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
@@ -1,4 +1,4 @@
-@file:Suppress("UNUSED_PARAMETER", "UNCHECKED_CAST")
+@file:Suppress("UNUSED_PARAMETER")
 @file:JvmName("CoreTestUtils")
 
 package net.corda.testing
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/Expect.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/Expect.kt
index 1128186c67..0db4754f4c 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/Expect.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/Expect.kt
@@ -1,6 +1,7 @@
 package net.corda.testing
 
 import com.google.common.util.concurrent.SettableFuture
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.utilities.getOrThrow
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -213,9 +214,8 @@ private sealed class ExpectComposeState<E : Any> {
     class Single<E : Any, T : E>(val single: ExpectCompose.Single<E, T>) : ExpectComposeState<E>() {
         override fun nextState(event: E): Pair<() -> Unit, ExpectComposeState<E>>? =
                 if (single.expect.clazz.isAssignableFrom(event.javaClass)) {
-                    @Suppress("UNCHECKED_CAST")
-                    val coercedEvent = event as T
-                    if (single.expect.match(event)) {
+                    val coercedEvent: T = uncheckedCast(event)
+                    if (single.expect.match(coercedEvent)) {
                         Pair({ single.expect.expectClosure(coercedEvent) }, Finished())
                     } else {
                         null
@@ -285,8 +285,7 @@ private sealed class ExpectComposeState<E : Any> {
                 is ExpectCompose.Single<E, *> -> {
                     // This coercion should not be needed but kotlin can't reason about existential type variables(T)
                     // so here we're coercing T into E (even though T is invariant).
-                    @Suppress("UNCHECKED_CAST")
-                    Single(expectCompose as ExpectCompose.Single<E, E>)
+                    Single(uncheckedCast(expectCompose))
                 }
                 is ExpectCompose.Sequential -> {
                     if (expectCompose.sequence.size > 0) {
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt
index 94eb3a7a12..d51d5e7fe5 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt
@@ -16,6 +16,7 @@ import net.corda.core.internal.div
 import net.corda.core.internal.write
 import net.corda.core.serialization.SerializeAsToken
 import net.corda.client.jackson.JacksonSupport
+import net.corda.core.internal.uncheckedCast
 import net.corda.node.services.statemachine.FlowStackSnapshotFactory
 import java.nio.file.Path
 import java.time.Instant
@@ -134,11 +135,10 @@ class FlowStackSnapshotFactoryImpl : FlowStackSnapshotFactory {
 
 }
 
-private inline fun <reified R, A> R.getField(name: String): A {
+private inline fun <reified R, A : Any> R.getField(name: String): A {
     val field = R::class.java.getDeclaredField(name)
     field.isAccessible = true
-    @Suppress("UNCHECKED_CAST")
-    return field.get(this) as A
+    return uncheckedCast(field.get(this))
 }
 
 private fun getFiberStack(fiber: Fiber<*>): Stack {
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/Measure.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/Measure.kt
index d3a6f9f65d..102cc0f413 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/Measure.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/Measure.kt
@@ -1,5 +1,6 @@
 package net.corda.testing
 
+import net.corda.core.internal.uncheckedCast
 import kotlin.reflect.KCallable
 import kotlin.reflect.jvm.reflect
 
@@ -9,18 +10,14 @@ import kotlin.reflect.jvm.reflect
  * different combinations of parameters.
  */
 
-@Suppress("UNCHECKED_CAST")
-fun <A, R> measure(a: Iterable<A>, f: (A) -> R) =
-        measure(listOf(a), f.reflect()!!) { (f as ((Any?)->R))(it[0]) }
-@Suppress("UNCHECKED_CAST")
-fun <A, B, R> measure(a: Iterable<A>, b: Iterable<B>, f: (A, B) -> R) =
-        measure(listOf(a, b), f.reflect()!!) { (f as ((Any?,Any?)->R))(it[0], it[1]) }
-@Suppress("UNCHECKED_CAST")
-fun <A, B, C, R> measure(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>, f: (A, B, C) -> R) =
-        measure(listOf(a, b, c), f.reflect()!!) { (f as ((Any?,Any?,Any?)->R))(it[0], it[1], it[2]) }
-@Suppress("UNCHECKED_CAST")
-fun <A, B, C, D, R> measure(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>, d: Iterable<D>, f: (A, B, C, D) -> R) =
-        measure(listOf(a, b, c, d), f.reflect()!!) { (f as ((Any?,Any?,Any?,Any?)->R))(it[0], it[1], it[2], it[3]) }
+fun <A : Any, R> measure(a: Iterable<A>, f: (A) -> R) =
+        measure(listOf(a), f.reflect()!!) { f(uncheckedCast(it[0])) }
+fun <A : Any, B : Any, R> measure(a: Iterable<A>, b: Iterable<B>, f: (A, B) -> R) =
+        measure(listOf(a, b), f.reflect()!!) { f(uncheckedCast(it[0]), uncheckedCast(it[1])) }
+fun <A : Any, B : Any, C : Any, R> measure(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>, f: (A, B, C) -> R) =
+        measure(listOf(a, b, c), f.reflect()!!) { f(uncheckedCast(it[0]), uncheckedCast(it[1]), uncheckedCast(it[2])) }
+fun <A : Any, B : Any, C : Any, D : Any, R> measure(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>, d: Iterable<D>, f: (A, B, C, D) -> R) =
+        measure(listOf(a, b, c, d), f.reflect()!!) { f(uncheckedCast(it[0]), uncheckedCast(it[1]), uncheckedCast(it[2]), uncheckedCast(it[3])) }
 
 private fun <R> measure(paramIterables: List<Iterable<Any?>>, kCallable: KCallable<R>, call: (Array<Any?>) -> R): Iterable<MeasureResult<R>> {
     val kParameters = kCallable.parameters
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
index 84d0512a05..6db7662380 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
@@ -5,6 +5,7 @@ import net.corda.core.cordapp.CordappProvider
 import net.corda.core.crypto.*
 import net.corda.core.crypto.NullKeys.NULL_SIGNATURE
 import net.corda.core.identity.Party
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.node.ServiceHub
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.TransactionBuilder
@@ -188,8 +189,8 @@ data class TestLedgerDSLInterpreter private constructor(
                         nonVerifiedTransactionWithLocations[stateRef.txhash] ?:
                         throw TransactionResolutionException(stateRef.txhash)
         val output = transactionWithLocation.transaction.outputs[stateRef.index]
-        return if (S::class.java.isAssignableFrom(output.data.javaClass)) @Suppress("UNCHECKED_CAST") {
-            output as TransactionState<S>
+        return if (S::class.java.isAssignableFrom(output.data.javaClass)) {
+            uncheckedCast(output)
         } else {
             throw TypeMismatch(requested = S::class.java, actual = output.data.javaClass)
         }
@@ -313,8 +314,7 @@ data class TestLedgerDSLInterpreter private constructor(
         } else if (!clazz.isAssignableFrom(stateAndRef.state.data.javaClass)) {
             throw TypeMismatch(requested = clazz, actual = stateAndRef.state.data.javaClass)
         } else {
-            @Suppress("UNCHECKED_CAST")
-            return stateAndRef as StateAndRef<S>
+            return uncheckedCast(stateAndRef)
         }
     }
 
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/User.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/User.kt
index aadbeb7e06..c55f3bc5d3 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/User.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/User.kt
@@ -2,14 +2,14 @@
 
 package net.corda.demobench.model
 
+import net.corda.core.internal.uncheckedCast
 import net.corda.nodeapi.User
 import java.util.*
 
-@Suppress("UNCHECKED_CAST")
 fun toUser(map: Map<String, Any>) = User(
         map.getOrElse("username", { "none" }) as String,
         map.getOrElse("password", { "none" }) as String,
-        LinkedHashSet<String>(map.getOrElse("permissions", { emptyList<String>() }) as Collection<String>)
+        LinkedHashSet(uncheckedCast<Any, Collection<String>>(map.getOrElse("permissions", { emptyList<String>() })))
 )
 
 fun user(name: String) = User(name, "letmein", setOf("ALL"))
diff --git a/tools/explorer/src/main/kotlin/net/corda/explorer/model/SettingsModel.kt b/tools/explorer/src/main/kotlin/net/corda/explorer/model/SettingsModel.kt
index 5df84b94fd..19bba7b639 100644
--- a/tools/explorer/src/main/kotlin/net/corda/explorer/model/SettingsModel.kt
+++ b/tools/explorer/src/main/kotlin/net/corda/explorer/model/SettingsModel.kt
@@ -7,6 +7,7 @@ import javafx.beans.property.SimpleObjectProperty
 import net.corda.core.internal.createDirectories
 import net.corda.core.internal.div
 import net.corda.core.internal.exists
+import net.corda.core.internal.uncheckedCast
 import tornadofx.*
 import java.nio.file.Files
 import java.nio.file.Path
@@ -52,14 +53,13 @@ class SettingsModel(path: Path = Paths.get("conf")) : Component(), Observable {
     // Save all changes in memory to properties file.
     fun commit() = Files.newOutputStream(path).use { config.store(it, "") }
 
-    @Suppress("UNCHECKED_CAST")
     private operator fun <T> Properties.getValue(receiver: Any, metadata: KProperty<*>): T {
         return when (metadata.returnType.javaType) {
-            String::class.java -> string(metadata.name, "") as T
-            Int::class.java -> string(metadata.name, "0").toInt() as T
-            Boolean::class.java -> boolean(metadata.name) as T
-            Currency::class.java -> Currency.getInstance(string(metadata.name, "USD")) as T
-            Path::class.java -> Paths.get(string(metadata.name, "")).toAbsolutePath() as T
+            String::class.java -> uncheckedCast(string(metadata.name, ""))
+            Int::class.java -> uncheckedCast(string(metadata.name, "0").toInt())
+            Boolean::class.java -> uncheckedCast(boolean(metadata.name))
+            Currency::class.java -> uncheckedCast(Currency.getInstance(string(metadata.name, "USD")))
+            Path::class.java -> uncheckedCast(Paths.get(string(metadata.name, "")).toAbsolutePath())
             else -> throw IllegalArgumentException("Unsupported type ${metadata.returnType}")
         }
     }
diff --git a/webserver/src/main/kotlin/net/corda/webserver/converters/Converters.kt b/webserver/src/main/kotlin/net/corda/webserver/converters/Converters.kt
index ca47c80173..f0e20a037e 100644
--- a/webserver/src/main/kotlin/net/corda/webserver/converters/Converters.kt
+++ b/webserver/src/main/kotlin/net/corda/webserver/converters/Converters.kt
@@ -1,6 +1,7 @@
 package net.corda.webserver.converters
 
 import net.corda.core.identity.CordaX500Name
+import net.corda.core.internal.uncheckedCast
 import java.lang.reflect.Type
 import javax.ws.rs.ext.ParamConverter
 import javax.ws.rs.ext.ParamConverterProvider
@@ -15,8 +16,7 @@ object CordaX500NameConverter : ParamConverter<CordaX500Name> {
 object CordaConverterProvider : ParamConverterProvider {
     override fun <T : Any> getConverter(rawType: Class<T>, genericType: Type?, annotations: Array<out Annotation>?): ParamConverter<T>? {
         if (rawType == CordaX500Name::class.java) {
-            @Suppress("UNCHECKED_CAST")
-            return CordaX500NameConverter as ParamConverter<T>
+            return uncheckedCast(CordaX500NameConverter)
         }
         return null
     }

From d1891faa4d0f6a5149b5d6e88380d4bed9cf5a17 Mon Sep 17 00:00:00 2001
From: mkit <michal.kit@evrythng.com>
Date: Wed, 27 Sep 2017 13:17:55 +0100
Subject: [PATCH 018/185] FlowSnapshot serialization error (#1671)

* Converting SubList to list due to the Kryo lack of support

* Adding test

* Addressing review comments
---
 .../corda/testing/FlowStackSnapshotTest.kt    | 55 +++++++++++++++++--
 .../net/corda/testing/FlowStackSnapshot.kt    |  3 +-
 2 files changed, 53 insertions(+), 5 deletions(-)

diff --git a/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt b/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
index 0aa4bec5e4..33d682f2b4 100644
--- a/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
+++ b/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
@@ -2,23 +2,25 @@ package net.corda.testing
 
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.client.jackson.JacksonSupport
-import net.corda.core.flows.FlowLogic
-import net.corda.core.flows.FlowStackSnapshot
-import net.corda.core.flows.StartableByRPC
-import net.corda.core.flows.StateMachineRunId
+import net.corda.core.flows.*
 import net.corda.core.internal.div
 import net.corda.core.internal.list
 import net.corda.core.internal.read
 import net.corda.core.messaging.startFlow
 import net.corda.core.serialization.CordaSerializable
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
+import net.corda.node.services.network.NetworkMapService
+import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.User
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.driver.driver
+import net.corda.testing.node.MockNetwork
 import org.junit.Ignore
 import org.junit.Test
 import java.nio.file.Path
 import java.time.LocalDate
 import kotlin.test.assertEquals
+import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
 @CordaSerializable
@@ -178,6 +180,31 @@ class MultiplePersistingSideEffectFlow(val persistCallCount: Int) : FlowLogic<St
     }
 }
 
+/**
+ * Flow that tests whether the serialization works correctly.
+ */
+@StartableByRPC
+@InitiatingFlow
+class FlowStackSnapshotSerializationTestingFlow : FlowLogic<Unit>() {
+
+    @Suspendable
+    override fun call() {
+        val flowStackSnapshot = flowStackSnapshot()
+        val mySession = initiateFlow(ourIdentity)
+        mySession.sendAndReceive<String>("Ping")
+    }
+}
+
+@InitiatedBy(FlowStackSnapshotSerializationTestingFlow::class)
+class DummyFlow(private val otherSideSession: FlowSession) : FlowLogic<Unit>() {
+
+    @Suspendable
+    override fun call() {
+        val message = otherSideSession.receive<String>()
+        otherSideSession.send("$message Pong")
+    }
+}
+
 fun readFlowStackSnapshotFromDir(baseDir: Path, flowId: StateMachineRunId): FlowStackSnapshot {
     val snapshotFile = flowSnapshotDir(baseDir, flowId) / "flowStackSnapshot.json"
     return snapshotFile.read {
@@ -263,6 +290,26 @@ class FlowStackSnapshotTest {
         }
     }
 
+    @Test
+    fun `flowStackSnapshot object is serializable`() {
+        val mockNet = MockNetwork(threadPerNode = true)
+        val notaryService = ServiceInfo(ValidatingNotaryService.type)
+        val notaryNode = mockNet.createNode(
+                legalName = DUMMY_NOTARY.name,
+                overrideServices = mapOf(notaryService to DUMMY_NOTARY_KEY),
+                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), notaryService))
+        val node = mockNet.createPartyNode(notaryNode.network.myAddress)
+        node.internals.registerInitiatedFlow(DummyFlow::class.java)
+        node.services.startFlow(FlowStackSnapshotSerializationTestingFlow()).resultFuture.get()
+        val thrown = try {
+            mockNet.stopNodes()
+            null
+        } catch (exception: Exception) {
+            exception
+        }
+        assertNull(thrown)
+    }
+
     @Test
     fun `persistFlowStackSnapshot stack traces are aligned with stack objects`() {
         driver(startNodesInProcess = true) {
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt
index d51d5e7fe5..d79568d693 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt
@@ -55,7 +55,8 @@ class FlowStackSnapshotFactoryImpl : FlowStackSnapshotFactory {
         val objectStack = getObjectStack(stack).toList()
         val frameOffsets = getFrameOffsets(stack)
         val frameObjects = frameOffsets.map { (frameOffset, frameSize) ->
-            objectStack.subList(frameOffset + 1, frameOffset + frameSize + 1)
+            // We need to convert the sublist to a list due to the Kryo lack of support when serializing
+            objectStack.subList(frameOffset + 1, frameOffset + frameSize + 1).toList()
         }
         // We drop the first element as it is corda internal call irrelevant from the perspective of a CordApp developer
         val relevantStackTrace = removeConstructorStackTraceElements(stackTrace).drop(1)

From 241f8435551ec11a40f91f80e3520d669d386921 Mon Sep 17 00:00:00 2001
From: josecoll <jose.coll@r3cev.com>
Date: Wed, 27 Sep 2017 13:33:23 +0100
Subject: [PATCH 019/185] Unification of VaultQuery And VaultService APIs (into
 single VaultService interface) to simplify node bootstrapping and usability.
 (#1677)

---
 .../corda/core/node/CordaPluginRegistry.kt    |   6 -
 .../kotlin/net/corda/core/node/ServiceHub.kt  |   5 +-
 .../core/node/services/VaultQueryService.kt   | 142 -----------
 .../corda/core/node/services/VaultService.kt  | 137 ++++++++++-
 .../core/flows/ContractUpgradeFlowTest.kt     |   4 +-
 docs/source/api-vault-query.rst               |   4 +-
 .../java/net/corda/docs/FlowCookbookJava.java |   2 +-
 .../kotlin/net/corda/docs/FlowCookbook.kt     |   2 +-
 .../docs/WorkflowTransactionBuildTutorial.kt  |   2 +-
 .../WorkflowTransactionBuildTutorialTest.kt   |   2 +-
 .../source/tutorial-building-transactions.rst |   4 +-
 .../corda/finance/contracts/GetBalances.kt    |   4 +-
 .../net/corda/finance/flows/CashExitFlow.kt   |   2 +-
 .../finance/contracts/asset/CashTests.kt      |   2 +-
 .../finance/flows/CashPaymentFlowTests.kt     |  10 +-
 .../net/corda/node/internal/AbstractNode.kt   |  13 +-
 .../corda/node/internal/CordaRPCOpsImpl.kt    |   4 +-
 .../services/vault/HibernateVaultQueryImpl.kt | 204 ----------------
 .../node/services/vault/NodeVaultService.kt   | 187 +++++++++++++-
 .../services/vault/VaultQueryJavaTests.java   |  95 +++----
 .../net/corda/node/CordaRPCOpsImplTest.kt     |   2 +-
 .../events/NodeSchedulerServiceTest.kt        |   2 +-
 .../services/events/ScheduledFlowTests.kt     |  14 +-
 .../persistence/DBTransactionStorageTests.kt  |   2 +-
 .../statemachine/FlowFrameworkTests.kt        |   4 +-
 .../services/vault/NodeVaultServiceTest.kt    | 112 ++++-----
 .../node/services/vault/VaultQueryTests.kt    | 231 +++++++++---------
 .../node/services/vault/VaultWithCashTest.kt  |  56 ++---
 .../corda/netmap/simulation/IRSSimulation.kt  |   2 +-
 .../kotlin/net/corda/vega/flows/SimmFlow.kt   |  12 +-
 .../net/corda/vega/flows/SimmRevaluation.kt   |   2 +-
 .../net/corda/traderdemo/flow/SellerFlow.kt   |   2 +-
 .../node/testing/MockServiceHubInternal.kt    |   3 -
 .../net/corda/testing/node/MockServices.kt    |   6 +-
 34 files changed, 589 insertions(+), 692 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/node/CordaPluginRegistry.kt b/core/src/main/kotlin/net/corda/core/node/CordaPluginRegistry.kt
index a74d36d3de..600f548a80 100644
--- a/core/src/main/kotlin/net/corda/core/node/CordaPluginRegistry.kt
+++ b/core/src/main/kotlin/net/corda/core/node/CordaPluginRegistry.kt
@@ -1,12 +1,6 @@
 package net.corda.core.node
 
-import net.corda.core.contracts.ContractState
-import net.corda.core.messaging.CordaRPCOps
-import net.corda.core.node.services.VaultQueryService
-import net.corda.core.schemas.MappedSchema
-import net.corda.core.schemas.QueryableState
 import net.corda.core.serialization.SerializationCustomization
-import java.util.function.Function
 
 /**
  * Implement this interface on a class advertised in a META-INF/services/net.corda.core.node.CordaPluginRegistry file
diff --git a/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt b/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
index f4c0f205cd..5d23e76dab 100644
--- a/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
+++ b/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
@@ -64,11 +64,10 @@ interface ServiceHub : ServicesForResolution {
 
     /**
      * The vault service lets you observe, soft lock and add notes to states that involve you or are relevant to your
-     * node in some way.
+     * node in some way. Additionally you may query and track states that correspond to various criteria.
      */
     val vaultService: VaultService
-    /** The vault query service lets you select and track states that correspond to various criteria. */
-    val vaultQueryService: VaultQueryService
+
     /**
      * The key management service is responsible for storing and using private keys to sign things. An
      * implementation of this may, for example, call out to a hardware security module that enforces various
diff --git a/core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt b/core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt
index deace9212f..e69de29bb2 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt
@@ -1,142 +0,0 @@
-package net.corda.core.node.services
-
-import net.corda.core.contracts.ContractState
-import net.corda.core.flows.FlowException
-import net.corda.core.messaging.DataFeed
-import net.corda.core.node.services.vault.PageSpecification
-import net.corda.core.node.services.vault.QueryCriteria
-import net.corda.core.node.services.vault.Sort
-
-/**
- * The vault query service lets you select and track states that correspond to various criteria.
- */
-interface VaultQueryService {
-    // DOCSTART VaultQueryAPI
-    /**
-     * Generic vault query function which takes a [QueryCriteria] object to define filters,
-     * optional [PageSpecification] and optional [Sort] modification criteria (default unsorted),
-     * and returns a [Vault.Page] object containing the following:
-     *  1. states as a List of <StateAndRef> (page number and size defined by [PageSpecification])
-     *  2. states metadata as a List of [Vault.StateMetadata] held in the Vault States table.
-     *  3. total number of results available if [PageSpecification] supplied (otherwise returns -1)
-     *  4. status types used in this query: UNCONSUMED, CONSUMED, ALL
-     *  5. other results (aggregate functions with/without using value groups)
-     *
-     * @throws VaultQueryException if the query cannot be executed for any reason
-     *        (missing criteria or parsing error, paging errors, unsupported query, underlying database error)
-     *
-     * Notes
-     *   If no [PageSpecification] is provided, a maximum of [DEFAULT_PAGE_SIZE] results will be returned.
-     *   API users must specify a [PageSpecification] if they are expecting more than [DEFAULT_PAGE_SIZE] results,
-     *   otherwise a [VaultQueryException] will be thrown alerting to this condition.
-     *   It is the responsibility of the API user to request further pages and/or specify a more suitable [PageSpecification].
-     */
-    @Throws(VaultQueryException::class)
-    fun <T : ContractState> _queryBy(criteria: QueryCriteria,
-                                     paging: PageSpecification,
-                                     sorting: Sort,
-                                     contractStateType: Class<out T>): Vault.Page<T>
-
-    /**
-     * Generic vault query function which takes a [QueryCriteria] object to define filters,
-     * optional [PageSpecification] and optional [Sort] modification criteria (default unsorted),
-     * and returns a [Vault.PageAndUpdates] object containing
-     * 1) a snapshot as a [Vault.Page] (described previously in [queryBy])
-     * 2) an [Observable] of [Vault.Update]
-     *
-     * @throws VaultQueryException if the query cannot be executed for any reason
-     *
-     * Notes: the snapshot part of the query adheres to the same behaviour as the [queryBy] function.
-     *        the [QueryCriteria] applies to both snapshot and deltas (streaming updates).
-     */
-    @Throws(VaultQueryException::class)
-    fun <T : ContractState> _trackBy(criteria: QueryCriteria,
-                                     paging: PageSpecification,
-                                     sorting: Sort,
-                                     contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>>
-    // DOCEND VaultQueryAPI
-
-    // Note: cannot apply @JvmOverloads to interfaces nor interface implementations
-    // Java Helpers
-    fun <T : ContractState> queryBy(contractStateType: Class<out T>): Vault.Page<T> {
-        return _queryBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), contractStateType)
-    }
-
-    fun <T : ContractState> queryBy(contractStateType: Class<out T>, criteria: QueryCriteria): Vault.Page<T> {
-        return _queryBy(criteria, PageSpecification(), Sort(emptySet()), contractStateType)
-    }
-
-    fun <T : ContractState> queryBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification): Vault.Page<T> {
-        return _queryBy(criteria, paging, Sort(emptySet()), contractStateType)
-    }
-
-    fun <T : ContractState> queryBy(contractStateType: Class<out T>, criteria: QueryCriteria, sorting: Sort): Vault.Page<T> {
-        return _queryBy(criteria, PageSpecification(), sorting, contractStateType)
-    }
-
-    fun <T : ContractState> queryBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification, sorting: Sort): Vault.Page<T> {
-        return _queryBy(criteria, paging, sorting, contractStateType)
-    }
-
-    fun <T : ContractState> trackBy(contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
-        return _trackBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), contractStateType)
-    }
-
-    fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria): DataFeed<Vault.Page<T>, Vault.Update<T>> {
-        return _trackBy(criteria, PageSpecification(), Sort(emptySet()), contractStateType)
-    }
-
-    fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification): DataFeed<Vault.Page<T>, Vault.Update<T>> {
-        return _trackBy(criteria, paging, Sort(emptySet()), contractStateType)
-    }
-
-    fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> {
-        return _trackBy(criteria, PageSpecification(), sorting, contractStateType)
-    }
-
-    fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> {
-        return _trackBy(criteria, paging, sorting, contractStateType)
-    }
-}
-
-inline fun <reified T : ContractState> VaultQueryService.queryBy(): Vault.Page<T> {
-    return _queryBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), T::class.java)
-}
-
-inline fun <reified T : ContractState> VaultQueryService.queryBy(criteria: QueryCriteria): Vault.Page<T> {
-    return _queryBy(criteria, PageSpecification(), Sort(emptySet()), T::class.java)
-}
-
-inline fun <reified T : ContractState> VaultQueryService.queryBy(criteria: QueryCriteria, paging: PageSpecification): Vault.Page<T> {
-    return _queryBy(criteria, paging, Sort(emptySet()), T::class.java)
-}
-
-inline fun <reified T : ContractState> VaultQueryService.queryBy(criteria: QueryCriteria, sorting: Sort): Vault.Page<T> {
-    return _queryBy(criteria, PageSpecification(), sorting, T::class.java)
-}
-
-inline fun <reified T : ContractState> VaultQueryService.queryBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort): Vault.Page<T> {
-    return _queryBy(criteria, paging, sorting, T::class.java)
-}
-
-inline fun <reified T : ContractState> VaultQueryService.trackBy(): DataFeed<Vault.Page<T>, Vault.Update<T>> {
-    return _trackBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), T::class.java)
-}
-
-inline fun <reified T : ContractState> VaultQueryService.trackBy(criteria: QueryCriteria): DataFeed<Vault.Page<T>, Vault.Update<T>> {
-    return _trackBy(criteria, PageSpecification(), Sort(emptySet()), T::class.java)
-}
-
-inline fun <reified T : ContractState> VaultQueryService.trackBy(criteria: QueryCriteria, paging: PageSpecification): DataFeed<Vault.Page<T>, Vault.Update<T>> {
-    return _trackBy(criteria, paging, Sort(emptySet()), T::class.java)
-}
-
-inline fun <reified T : ContractState> VaultQueryService.trackBy(criteria: QueryCriteria, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> {
-    return _trackBy(criteria, PageSpecification(), sorting, T::class.java)
-}
-
-inline fun <reified T : ContractState> VaultQueryService.trackBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> {
-    return _trackBy(criteria, paging, sorting, T::class.java)
-}
-
-class VaultQueryException(description: String) : FlowException(description)
\ No newline at end of file
diff --git a/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt b/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt
index a2353a7b99..a16243a7db 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt
@@ -6,7 +6,10 @@ import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
 import net.corda.core.flows.FlowException
 import net.corda.core.identity.AbstractParty
+import net.corda.core.messaging.DataFeed
+import net.corda.core.node.services.vault.PageSpecification
 import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.node.services.vault.Sort
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.toFuture
 import net.corda.core.utilities.NonEmptySet
@@ -166,11 +169,6 @@ interface VaultService {
      */
     val updates: Observable<Vault.Update<ContractState>>
 
-    /**
-     * Enable creation of observables of updates.
-     */
-    val updatesPublisher: PublishSubject<Vault.Update<ContractState>>
-
     /**
      * Provide a [CordaFuture] for when a [StateRef] is consumed, which can be very useful in building tests.
      */
@@ -221,7 +219,7 @@ interface VaultService {
     // DOCEND SoftLockAPI
 
     /**
-     * Helper function to combine using [VaultQueryService] calls to determine spendable states and soft locking them.
+     * Helper function to determine spendable states and soft locking them.
      * Currently performance will be worse than for the hand optimised version in `Cash.unconsumedCashStatesForSpending`
      * However, this is fully generic and can operate with custom [FungibleAsset] states.
      * @param lockId The [FlowLogic.runId.uuid] of the current flow used to soft lock the states.
@@ -241,8 +239,135 @@ interface VaultService {
                                                                          amount: Amount<U>,
                                                                          contractStateType: Class<out T>): List<StateAndRef<T>>
 
+    // DOCSTART VaultQueryAPI
+    /**
+     * Generic vault query function which takes a [QueryCriteria] object to define filters,
+     * optional [PageSpecification] and optional [Sort] modification criteria (default unsorted),
+     * and returns a [Vault.Page] object containing the following:
+     *  1. states as a List of <StateAndRef> (page number and size defined by [PageSpecification])
+     *  2. states metadata as a List of [Vault.StateMetadata] held in the Vault States table.
+     *  3. total number of results available if [PageSpecification] supplied (otherwise returns -1)
+     *  4. status types used in this query: UNCONSUMED, CONSUMED, ALL
+     *  5. other results (aggregate functions with/without using value groups)
+     *
+     * @throws VaultQueryException if the query cannot be executed for any reason
+     *        (missing criteria or parsing error, paging errors, unsupported query, underlying database error)
+     *
+     * Notes
+     *   If no [PageSpecification] is provided, a maximum of [DEFAULT_PAGE_SIZE] results will be returned.
+     *   API users must specify a [PageSpecification] if they are expecting more than [DEFAULT_PAGE_SIZE] results,
+     *   otherwise a [VaultQueryException] will be thrown alerting to this condition.
+     *   It is the responsibility of the API user to request further pages and/or specify a more suitable [PageSpecification].
+     */
+    @Throws(VaultQueryException::class)
+    fun <T : ContractState> _queryBy(criteria: QueryCriteria,
+                                     paging: PageSpecification,
+                                     sorting: Sort,
+                                     contractStateType: Class<out T>): Vault.Page<T>
+
+    /**
+     * Generic vault query function which takes a [QueryCriteria] object to define filters,
+     * optional [PageSpecification] and optional [Sort] modification criteria (default unsorted),
+     * and returns a [Vault.PageAndUpdates] object containing
+     * 1) a snapshot as a [Vault.Page] (described previously in [queryBy])
+     * 2) an [Observable] of [Vault.Update]
+     *
+     * @throws VaultQueryException if the query cannot be executed for any reason
+     *
+     * Notes: the snapshot part of the query adheres to the same behaviour as the [queryBy] function.
+     *        the [QueryCriteria] applies to both snapshot and deltas (streaming updates).
+     */
+    @Throws(VaultQueryException::class)
+    fun <T : ContractState> _trackBy(criteria: QueryCriteria,
+                                     paging: PageSpecification,
+                                     sorting: Sort,
+                                     contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>>
+    // DOCEND VaultQueryAPI
+
+    // Note: cannot apply @JvmOverloads to interfaces nor interface implementations
+    // Java Helpers
+    fun <T : ContractState> queryBy(contractStateType: Class<out T>): Vault.Page<T> {
+        return _queryBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), contractStateType)
+    }
+
+    fun <T : ContractState> queryBy(contractStateType: Class<out T>, criteria: QueryCriteria): Vault.Page<T> {
+        return _queryBy(criteria, PageSpecification(), Sort(emptySet()), contractStateType)
+    }
+
+    fun <T : ContractState> queryBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification): Vault.Page<T> {
+        return _queryBy(criteria, paging, Sort(emptySet()), contractStateType)
+    }
+
+    fun <T : ContractState> queryBy(contractStateType: Class<out T>, criteria: QueryCriteria, sorting: Sort): Vault.Page<T> {
+        return _queryBy(criteria, PageSpecification(), sorting, contractStateType)
+    }
+
+    fun <T : ContractState> queryBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification, sorting: Sort): Vault.Page<T> {
+        return _queryBy(criteria, paging, sorting, contractStateType)
+    }
+
+    fun <T : ContractState> trackBy(contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+        return _trackBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), contractStateType)
+    }
+
+    fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+        return _trackBy(criteria, PageSpecification(), Sort(emptySet()), contractStateType)
+    }
+
+    fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+        return _trackBy(criteria, paging, Sort(emptySet()), contractStateType)
+    }
+
+    fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+        return _trackBy(criteria, PageSpecification(), sorting, contractStateType)
+    }
+
+    fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+        return _trackBy(criteria, paging, sorting, contractStateType)
+    }
 }
 
+inline fun <reified T : ContractState> VaultService.queryBy(): Vault.Page<T> {
+    return _queryBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), T::class.java)
+}
+
+inline fun <reified T : ContractState> VaultService.queryBy(criteria: QueryCriteria): Vault.Page<T> {
+    return _queryBy(criteria, PageSpecification(), Sort(emptySet()), T::class.java)
+}
+
+inline fun <reified T : ContractState> VaultService.queryBy(criteria: QueryCriteria, paging: PageSpecification): Vault.Page<T> {
+    return _queryBy(criteria, paging, Sort(emptySet()), T::class.java)
+}
+
+inline fun <reified T : ContractState> VaultService.queryBy(criteria: QueryCriteria, sorting: Sort): Vault.Page<T> {
+    return _queryBy(criteria, PageSpecification(), sorting, T::class.java)
+}
+
+inline fun <reified T : ContractState> VaultService.queryBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort): Vault.Page<T> {
+    return _queryBy(criteria, paging, sorting, T::class.java)
+}
+
+inline fun <reified T : ContractState> VaultService.trackBy(): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+    return _trackBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), T::class.java)
+}
+
+inline fun <reified T : ContractState> VaultService.trackBy(criteria: QueryCriteria): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+    return _trackBy(criteria, PageSpecification(), Sort(emptySet()), T::class.java)
+}
+
+inline fun <reified T : ContractState> VaultService.trackBy(criteria: QueryCriteria, paging: PageSpecification): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+    return _trackBy(criteria, paging, Sort(emptySet()), T::class.java)
+}
+
+inline fun <reified T : ContractState> VaultService.trackBy(criteria: QueryCriteria, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+    return _trackBy(criteria, PageSpecification(), sorting, T::class.java)
+}
+
+inline fun <reified T : ContractState> VaultService.trackBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+    return _trackBy(criteria, paging, sorting, T::class.java)
+}
+
+class VaultQueryException(description: String) : FlowException(description)
 
 class StatesNotAvailableException(override val message: String?, override val cause: Throwable? = null) : FlowException(message, cause) {
     override fun toString() = "Soft locking error: $message"
diff --git a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
index 4ef934798b..aeca91feb4 100644
--- a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
@@ -219,14 +219,14 @@ class ContractUpgradeFlowTest {
         val stx = result.getOrThrow().stx
         val anonymisedRecipient = result.get().recipient!!
         val stateAndRef = stx.tx.outRef<Cash.State>(0)
-        val baseState = a.database.transaction { a.services.vaultQueryService.queryBy<ContractState>().states.single() }
+        val baseState = a.database.transaction { a.services.vaultService.queryBy<ContractState>().states.single() }
         assertTrue(baseState.state.data is Cash.State, "Contract state is old version.")
         // Starts contract upgrade flow.
         val upgradeResult = a.services.startFlow(ContractUpgradeFlow.Initiate(stateAndRef, CashV2::class.java)).resultFuture
         mockNet.runNetwork()
         upgradeResult.getOrThrow()
         // Get contract state from the vault.
-        val firstState = a.database.transaction { a.services.vaultQueryService.queryBy<ContractState>().states.single() }
+        val firstState = a.database.transaction { a.services.vaultService.queryBy<ContractState>().states.single() }
         assertTrue(firstState.state.data is CashV2.State, "Contract state is upgraded to the new version.")
         assertEquals(Amount(1000000, USD).`issued by`(chosenIdentity.ref(1)), (firstState.state.data as CashV2.State).amount, "Upgraded cash contain the correct amount.")
         assertEquals<Collection<AbstractParty>>(listOf(anonymisedRecipient), (firstState.state.data as CashV2.State).owners, "Upgraded cash belongs to the right owner.")
diff --git a/docs/source/api-vault-query.rst b/docs/source/api-vault-query.rst
index 9f19f1087a..0b9944948d 100644
--- a/docs/source/api-vault-query.rst
+++ b/docs/source/api-vault-query.rst
@@ -10,9 +10,9 @@ Corda provides a number of flexible query mechanisms for accessing the Vault:
 - custom JPA_/JPQL_ queries
 - custom 3rd party Data Access frameworks such as `Spring Data <http://projects.spring.io/spring-data>`_
 
-The majority of query requirements can be satisfied by using the Vault Query API, which is exposed via the ``VaultQueryService`` for use directly by flows:
+The majority of query requirements can be satisfied by using the Vault Query API, which is exposed via the ``VaultService`` for use directly by flows:
 
-.. literalinclude:: ../../core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt
+.. literalinclude:: ../../core/src/main/kotlin/net/corda/core/node/services/VaultService.kt
     :language: kotlin
     :start-after: DOCSTART VaultQueryAPI
     :end-before: DOCEND VaultQueryAPI
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
index bfa1b329d4..3777536aae 100644
--- a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
+++ b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
@@ -223,7 +223,7 @@ public class FlowCookbookJava {
             // For example, we would extract any unconsumed ``DummyState``s
             // from our vault as follows:
             VaultQueryCriteria criteria = new VaultQueryCriteria(Vault.StateStatus.UNCONSUMED);
-            Page<DummyState> results = getServiceHub().getVaultQueryService().queryBy(DummyState.class, criteria);
+            Page<DummyState> results = getServiceHub().getVaultService().queryBy(DummyState.class, criteria);
             List<StateAndRef<DummyState>> dummyStates = results.getStates();
 
             // For a full list of the available ways of extracting states from
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 3e720145bf..4b0864d714 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
@@ -206,7 +206,7 @@ object FlowCookbook {
             // For example, we would extract any unconsumed ``DummyState``s
             // from our vault as follows:
             val criteria: VaultQueryCriteria = VaultQueryCriteria() // default is UNCONSUMED
-            val results: Page<DummyState> = serviceHub.vaultQueryService.queryBy<DummyState>(criteria)
+            val results: Page<DummyState> = serviceHub.vaultService.queryBy<DummyState>(criteria)
             val dummyStates: List<StateAndRef<DummyState>> = results.states
 
             // For a full list of the available ways of extracting states from
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 2532577f9a..9b31523586 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
@@ -129,7 +129,7 @@ class SubmitCompletionFlow(private val ref: StateRef, private val verdict: Workf
     override fun call(): StateAndRef<TradeApprovalContract.State> {
         // DOCSTART 1
         val criteria = VaultQueryCriteria(stateRefs = listOf(ref))
-        val latestRecord = serviceHub.vaultQueryService.queryBy<TradeApprovalContract.State>(criteria).states.single()
+        val latestRecord = serviceHub.vaultService.queryBy<TradeApprovalContract.State>(criteria).states.single()
         // DOCEND 1
 
         // Check the protocol hasn't already been run
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
index d625c1483e..831e8db3fb 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
@@ -27,7 +27,7 @@ class WorkflowTransactionBuildTutorialTest {
 
     // Helper method to locate the latest Vault version of a LinearState
     private inline fun <reified T : LinearState> ServiceHub.latest(ref: UniqueIdentifier): StateAndRef<T> {
-        val linearHeads = vaultQueryService.queryBy<T>(QueryCriteria.LinearStateQueryCriteria(uuid = listOf(ref.id)))
+        val linearHeads = vaultService.queryBy<T>(QueryCriteria.LinearStateQueryCriteria(uuid = listOf(ref.id)))
         return linearHeads.states.single()
     }
 
diff --git a/docs/source/tutorial-building-transactions.rst b/docs/source/tutorial-building-transactions.rst
index 18734ca89f..b8c25bf04a 100644
--- a/docs/source/tutorial-building-transactions.rst
+++ b/docs/source/tutorial-building-transactions.rst
@@ -87,7 +87,7 @@ One of the first steps to forming a transaction is gathering the set of
 input references. This process will clearly vary according to the nature
 of the business process being captured by the smart contract and the
 parameterised details of the request. However, it will generally involve
-searching the Vault via the ``VaultQueryService`` interface on the
+searching the Vault via the ``VaultService`` interface on the
 ``ServiceHub`` to locate the input states.
 
 To give a few more specific details consider two simplified real world
@@ -161,7 +161,7 @@ in the right workflow state over the RPC interface. The RPC will then
 initiate the relevant flow using ``StateRef``, or ``linearId`` values as
 parameters to the flow to identify the states being operated upon. Thus
 code to gather the latest input state for a given ``StateRef`` would use
-the ``VaultQueryService`` as follows:
+the ``VaultService`` as follows:
 
 .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/WorkflowTransactionBuildTutorial.kt
     :language: kotlin
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/GetBalances.kt b/finance/src/main/kotlin/net/corda/finance/contracts/GetBalances.kt
index 2e28208a6f..d96b5b5c09 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/GetBalances.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/GetBalances.kt
@@ -59,7 +59,7 @@ fun CordaRPCOps.getCashBalance(currency: Currency): Amount<Currency> {
 }
 
 fun ServiceHub.getCashBalance(currency: Currency): Amount<Currency> {
-    val results = this.vaultQueryService.queryBy<FungibleAsset<*>>(generateCashSumCriteria(currency))
+    val results = this.vaultService.queryBy<FungibleAsset<*>>(generateCashSumCriteria(currency))
     return rowsToAmount(currency, results)
 }
 
@@ -69,7 +69,7 @@ fun CordaRPCOps.getCashBalances(): Map<Currency, Amount<Currency>> {
 }
 
 fun ServiceHub.getCashBalances(): Map<Currency, Amount<Currency>> {
-    val sums = this.vaultQueryService.queryBy<FungibleAsset<*>>(generateCashSumsCriteria()).otherResults
+    val sums = this.vaultService.queryBy<FungibleAsset<*>>(generateCashSumsCriteria()).otherResults
     return rowsToBalances(sums)
 }
 
diff --git a/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt b/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt
index 763f0d4cff..f0084fb169 100644
--- a/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt
+++ b/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt
@@ -59,7 +59,7 @@ class CashExitFlow(private val amount: Amount<Currency>,
         }
 
         // Work out who the owners of the burnt states were (specify page size so we don't silently drop any if > DEFAULT_PAGE_SIZE)
-        val inputStates = serviceHub.vaultQueryService.queryBy<Cash.State>(VaultQueryCriteria(stateRefs = builder.inputStates()),
+        val inputStates = serviceHub.vaultService.queryBy<Cash.State>(VaultQueryCriteria(stateRefs = builder.inputStates()),
                                                                            PageSpecification(pageNumber = DEFAULT_PAGE_NUM, pageSize = builder.inputStates().size)).states
 
         // TODO: Is it safe to drop participants we don't know how to contact? Does not knowing how to contact them
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
index b9b7bd7091..f30507ec3f 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
@@ -71,7 +71,7 @@ class CashTests : TestDependencyInjectionBase() {
                     ownedBy = OUR_IDENTITY_1, issuedBy = MINI_CORP.ref(1), issuerServices = miniCorpServices)
         }
         database.transaction {
-            vaultStatesUnconsumed = miniCorpServices.vaultQueryService.queryBy<Cash.State>().states
+            vaultStatesUnconsumed = miniCorpServices.vaultService.queryBy<Cash.State>().states
         }
         resetTestSerialization()
     }
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
index 5fe62e9d3c..5a26f1196f 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
@@ -10,14 +10,10 @@ import net.corda.finance.DOLLARS
 import net.corda.finance.`issued by`
 import net.corda.finance.contracts.asset.Cash
 import net.corda.node.internal.StartedNode
-import net.corda.testing.chooseIdentity
-import net.corda.testing.expect
-import net.corda.testing.expectEvents
-import net.corda.testing.getDefaultNotary
+import net.corda.testing.*
 import net.corda.testing.node.InMemoryMessagingNetwork.ServicePeerAllocationStrategy.RoundRobin
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
-import net.corda.testing.setCordappPackages
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -61,8 +57,8 @@ class CashPaymentFlowTests {
         bankOfCordaNode.database.transaction {
             // Register for vault updates
             val criteria = QueryCriteria.VaultQueryCriteria(status = Vault.StateStatus.ALL)
-            val (_, vaultUpdatesBoc) = bankOfCordaNode.services.vaultQueryService.trackBy<Cash.State>(criteria)
-            val (_, vaultUpdatesBankClient) = notaryNode.services.vaultQueryService.trackBy<Cash.State>(criteria)
+            val (_, vaultUpdatesBoc) = bankOfCordaNode.services.vaultService.trackBy<Cash.State>(criteria)
+            val (_, vaultUpdatesBankClient) = notaryNode.services.vaultService.trackBy<Cash.State>(criteria)
 
             val future = bankOfCordaNode.services.startFlow(CashPaymentFlow(expectedPayment,
                     payTo)).resultFuture
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 50e9ac4866..6ba72a75d6 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -35,8 +35,8 @@ import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.debug
 import net.corda.node.internal.classloading.requireAnnotation
 import net.corda.node.internal.cordapp.CordappLoader
-import net.corda.node.services.ContractUpgradeHandler
 import net.corda.node.internal.cordapp.CordappProviderImpl
+import net.corda.node.services.ContractUpgradeHandler
 import net.corda.node.services.FinalityHandler
 import net.corda.node.services.NotaryChangeHandler
 import net.corda.node.services.api.*
@@ -63,7 +63,6 @@ import net.corda.node.services.statemachine.appName
 import net.corda.node.services.statemachine.flowVersionAndInitiatingClass
 import net.corda.node.services.transactions.*
 import net.corda.node.services.upgrade.ContractUpgradeServiceImpl
-import net.corda.node.services.vault.HibernateVaultQueryImpl
 import net.corda.node.services.vault.NodeVaultService
 import net.corda.node.services.vault.VaultSoftLockManager
 import net.corda.node.utilities.*
@@ -83,11 +82,9 @@ import java.security.cert.CertificateFactory
 import java.security.cert.X509Certificate
 import java.sql.Connection
 import java.time.Clock
-import java.util.*
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.TimeUnit.SECONDS
-import kotlin.collections.ArrayList
 import kotlin.collections.set
 import kotlin.reflect.KClass
 import net.corda.core.crypto.generateKeyPair as cryptoGenerateKeyPair
@@ -389,7 +386,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         network = makeMessagingService(legalIdentity)
         info = makeInfo(legalIdentity)
 
-        val tokenizableServices = mutableListOf(attachments, network, services.vaultService, services.vaultQueryService,
+        val tokenizableServices = mutableListOf(attachments, network, services.vaultService,
                 services.keyManagementService, services.identityService, platformClock, services.schedulerService,
                 services.auditService, services.monitoringService, services.networkMapCache, services.schemaService,
                 services.transactionVerifierService, services.validatedTransactions, services.contractUpgradeService,
@@ -692,11 +689,9 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         override val transactionVerifierService by lazy { makeTransactionVerifierService() }
         override val schemaService by lazy { NodeSchemaService() }
         override val networkMapCache by lazy { PersistentNetworkMapCache(this) }
-        override val vaultService by lazy { NodeVaultService(this) }
+        override val vaultService by lazy { NodeVaultService(this, database.hibernateConfig) }
         override val contractUpgradeService by lazy { ContractUpgradeServiceImpl() }
-        override val vaultQueryService by lazy {
-            HibernateVaultQueryImpl(database.hibernateConfig, vaultService)
-        }
+
         // Place the long term identity key in the KMS. Eventually, this is likely going to be separated again because
         // the KMS is meant for derived temporary keys used in transactions, and we're not supposed to sign things with
         // the identity key. But the infrastructure to make that easy isn't here yet.
diff --git a/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt b/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt
index ae8afce323..c902e8964a 100644
--- a/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt
@@ -56,7 +56,7 @@ class CordaRPCOpsImpl(
                                                   sorting: Sort,
                                                   contractStateType: Class<out T>): Vault.Page<T> {
         return database.transaction {
-            services.vaultQueryService._queryBy(criteria, paging, sorting, contractStateType)
+            services.vaultService._queryBy(criteria, paging, sorting, contractStateType)
         }
     }
 
@@ -66,7 +66,7 @@ class CordaRPCOpsImpl(
                                                   sorting: Sort,
                                                   contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
         return database.transaction {
-            services.vaultQueryService._trackBy(criteria, paging, sorting, contractStateType)
+            services.vaultService._trackBy(criteria, paging, sorting, contractStateType)
         }
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt b/node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt
index 3501c2db34..e69de29bb2 100644
--- a/node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt
@@ -1,204 +0,0 @@
-package net.corda.node.services.vault
-
-import net.corda.core.contracts.ContractState
-import net.corda.core.contracts.StateAndRef
-import net.corda.core.contracts.StateRef
-import net.corda.core.contracts.TransactionState
-import net.corda.core.crypto.SecureHash
-import net.corda.core.internal.ThreadBox
-import net.corda.core.internal.bufferUntilSubscribed
-import net.corda.core.internal.uncheckedCast
-import net.corda.core.messaging.DataFeed
-import net.corda.core.node.services.Vault
-import net.corda.core.node.services.VaultQueryException
-import net.corda.core.node.services.VaultQueryService
-import net.corda.core.node.services.VaultService
-import net.corda.core.node.services.vault.*
-import net.corda.core.node.services.vault.QueryCriteria.VaultCustomQueryCriteria
-import net.corda.core.serialization.SerializationDefaults.STORAGE_CONTEXT
-import net.corda.core.serialization.SingletonSerializeAsToken
-import net.corda.core.serialization.deserialize
-import net.corda.core.utilities.debug
-import net.corda.core.utilities.loggerFor
-import net.corda.core.utilities.trace
-import net.corda.node.services.persistence.HibernateConfiguration
-import net.corda.node.utilities.DatabaseTransactionManager
-import org.hibernate.Session
-import rx.Observable
-import java.lang.Exception
-import java.util.*
-import javax.persistence.Tuple
-
-class HibernateVaultQueryImpl(val hibernateConfig: HibernateConfiguration,
-                              val vault: VaultService) : SingletonSerializeAsToken(), VaultQueryService {
-    companion object {
-        val log = loggerFor<HibernateVaultQueryImpl>()
-    }
-
-    private var sessionFactory = hibernateConfig.sessionFactoryForRegisteredSchemas()
-    private var criteriaBuilder = sessionFactory.criteriaBuilder
-
-    /**
-     * Maintain a list of contract state interfaces to concrete types stored in the vault
-     * for usage in generic queries of type queryBy<LinearState> or queryBy<FungibleState<*>>
-     */
-    private val contractStateTypeMappings = bootstrapContractStateTypes()
-
-    init {
-        vault.rawUpdates.subscribe { update ->
-            update.produced.forEach {
-                val concreteType = it.state.data.javaClass
-                log.trace { "State update of type: $concreteType" }
-                val seen = contractStateTypeMappings.any { it.value.contains(concreteType.name) }
-                if (!seen) {
-                    val contractInterfaces = deriveContractInterfaces(concreteType)
-                    contractInterfaces.map {
-                        val contractInterface = contractStateTypeMappings.getOrPut(it.name, { mutableSetOf() })
-                        contractInterface.add(concreteType.name)
-                    }
-                }
-            }
-        }
-    }
-
-    @Throws(VaultQueryException::class)
-    override fun <T : ContractState> _queryBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): Vault.Page<T> {
-        log.info("Vault Query for contract type: $contractStateType, criteria: $criteria, pagination: $paging, sorting: $sorting")
-
-        // refresh to include any schemas registered after initial VQ service initialisation
-        sessionFactory = hibernateConfig.sessionFactoryForRegisteredSchemas()
-        criteriaBuilder = sessionFactory.criteriaBuilder
-
-        // calculate total results where a page specification has been defined
-        var totalStates = -1L
-        if (!paging.isDefault) {
-            val count = builder { VaultSchemaV1.VaultStates::recordedTime.count() }
-            val countCriteria = VaultCustomQueryCriteria(count, Vault.StateStatus.ALL)
-            val results = queryBy(contractStateType, criteria.and(countCriteria))
-            totalStates = results.otherResults[0] as Long
-        }
-
-        val session = getSession()
-
-        session.use {
-            val criteriaQuery = criteriaBuilder.createQuery(Tuple::class.java)
-            val queryRootVaultStates = criteriaQuery.from(VaultSchemaV1.VaultStates::class.java)
-
-            // TODO: revisit (use single instance of parser for all queries)
-            val criteriaParser = HibernateQueryCriteriaParser(contractStateType, contractStateTypeMappings, criteriaBuilder, criteriaQuery, queryRootVaultStates)
-
-            try {
-                // parse criteria and build where predicates
-                criteriaParser.parse(criteria, sorting)
-
-                // prepare query for execution
-                val query = session.createQuery(criteriaQuery)
-
-                // pagination checks
-                if (!paging.isDefault) {
-                    // pagination
-                    if (paging.pageNumber < DEFAULT_PAGE_NUM) throw VaultQueryException("Page specification: invalid page number ${paging.pageNumber} [page numbers start from $DEFAULT_PAGE_NUM]")
-                    if (paging.pageSize < 1) throw VaultQueryException("Page specification: invalid page size ${paging.pageSize} [must be a value between 1 and $MAX_PAGE_SIZE]")
-                }
-
-                query.firstResult = (paging.pageNumber - 1) * paging.pageSize
-                query.maxResults = paging.pageSize + 1  // detection too many results
-
-                // execution
-                val results = query.resultList
-
-                // final pagination check (fail-fast on too many results when no pagination specified)
-                if (paging.isDefault && results.size > DEFAULT_PAGE_SIZE)
-                    throw VaultQueryException("Please specify a `PageSpecification` as there are more results [${results.size}] than the default page size [$DEFAULT_PAGE_SIZE]")
-
-                val statesAndRefs: MutableList<StateAndRef<T>> = mutableListOf()
-                val statesMeta: MutableList<Vault.StateMetadata> = mutableListOf()
-                val otherResults: MutableList<Any> = mutableListOf()
-
-                results.asSequence()
-                        .forEachIndexed { index, result ->
-                            if (result[0] is VaultSchemaV1.VaultStates) {
-                                if (!paging.isDefault && index == paging.pageSize) // skip last result if paged
-                                    return@forEachIndexed
-                                val vaultState = result[0] as VaultSchemaV1.VaultStates
-                                val stateRef = StateRef(SecureHash.parse(vaultState.stateRef!!.txId!!), vaultState.stateRef!!.index!!)
-                                val state = vaultState.contractState.deserialize<TransactionState<T>>(context = STORAGE_CONTEXT)
-                                statesMeta.add(Vault.StateMetadata(stateRef,
-                                                                   vaultState.contractStateClassName,
-                                                                   vaultState.recordedTime,
-                                                                   vaultState.consumedTime,
-                                                                   vaultState.stateStatus,
-                                                                   vaultState.notary,
-                                                                   vaultState.lockId,
-                                                                   vaultState.lockUpdateTime))
-                                statesAndRefs.add(StateAndRef(state, stateRef))
-                            }
-                            else {
-                                // TODO: improve typing of returned other results
-                                log.debug { "OtherResults: ${Arrays.toString(result.toArray())}" }
-                                otherResults.addAll(result.toArray().asList())
-                            }
-                        }
-
-                return Vault.Page(states = statesAndRefs, statesMetadata = statesMeta, stateTypes = criteriaParser.stateTypes, totalStatesAvailable = totalStates, otherResults = otherResults)
-            } catch (e: Exception) {
-                log.error(e.message)
-                throw e.cause ?: e
-            }
-        }
-    }
-
-    private val mutex = ThreadBox({ vault.updatesPublisher })
-
-    @Throws(VaultQueryException::class)
-    override fun <T : ContractState> _trackBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
-        return mutex.locked {
-            val snapshotResults = _queryBy(criteria, paging, sorting, contractStateType)
-            val updates: Observable<Vault.Update<T>> = uncheckedCast(vault.updatesPublisher.bufferUntilSubscribed().filter { it.containsType(contractStateType, snapshotResults.stateTypes) })
-            DataFeed(snapshotResults, updates)
-        }
-    }
-
-    private fun getSession(): Session {
-        return sessionFactory.withOptions().
-                connection(DatabaseTransactionManager.current().connection).
-                openSession()
-    }
-
-    /**
-     * Derive list from existing vault states and then incrementally update using vault observables
-     */
-    fun bootstrapContractStateTypes(): MutableMap<String, MutableSet<String>> {
-        val criteria = criteriaBuilder.createQuery(String::class.java)
-        val vaultStates = criteria.from(VaultSchemaV1.VaultStates::class.java)
-        criteria.select(vaultStates.get("contractStateClassName")).distinct(true)
-        val session = getSession()
-        session.use {
-            val query = session.createQuery(criteria)
-            val results = query.resultList
-            val distinctTypes = results.map { it }
-
-            val contractInterfaceToConcreteTypes = mutableMapOf<String, MutableSet<String>>()
-            distinctTypes.forEach { type ->
-                val concreteType: Class<ContractState> = uncheckedCast(Class.forName(type))
-                val contractInterfaces = deriveContractInterfaces(concreteType)
-                contractInterfaces.map {
-                    val contractInterface = contractInterfaceToConcreteTypes.getOrPut(it.name, { mutableSetOf() })
-                    contractInterface.add(concreteType.name)
-                }
-            }
-            return contractInterfaceToConcreteTypes
-        }
-    }
-
-    private fun <T : ContractState> deriveContractInterfaces(clazz: Class<T>): Set<Class<T>> {
-        val myInterfaces: MutableSet<Class<T>> = mutableSetOf()
-        clazz.interfaces.forEach {
-            if (!it.equals(ContractState::class.java)) {
-                myInterfaces.add(uncheckedCast(it))
-                myInterfaces.addAll(deriveContractInterfaces(uncheckedCast(it)))
-            }
-        }
-        return myInterfaces
-    }
-}
\ No newline at end of file
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 196dca299f..15796f15eb 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
@@ -6,14 +6,15 @@ import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
 import net.corda.core.internal.ThreadBox
 import net.corda.core.internal.VisibleForTesting
+import net.corda.core.internal.bufferUntilSubscribed
 import net.corda.core.internal.tee
+import net.corda.core.messaging.DataFeed
 import net.corda.core.node.ServiceHub
 import net.corda.core.node.services.StatesNotAvailableException
 import net.corda.core.node.services.Vault
+import net.corda.core.node.services.VaultQueryException
 import net.corda.core.node.services.VaultService
-import net.corda.core.node.services.vault.QueryCriteria
-import net.corda.core.node.services.vault.Sort
-import net.corda.core.node.services.vault.SortAttribute
+import net.corda.core.node.services.vault.*
 import net.corda.core.schemas.PersistentStateRef
 import net.corda.core.serialization.SerializationDefaults.STORAGE_CONTEXT
 import net.corda.core.serialization.SingletonSerializeAsToken
@@ -23,15 +24,18 @@ import net.corda.core.transactions.CoreTransaction
 import net.corda.core.transactions.NotaryChangeWireTransaction
 import net.corda.core.transactions.WireTransaction
 import net.corda.core.utilities.*
+import net.corda.node.services.persistence.HibernateConfiguration
 import net.corda.node.services.statemachine.FlowStateMachineImpl
 import net.corda.node.utilities.DatabaseTransactionManager
 import net.corda.node.utilities.bufferUntilDatabaseCommit
 import net.corda.node.utilities.wrapWithDatabaseTransaction
+import org.hibernate.Session
 import rx.Observable
 import rx.subjects.PublishSubject
 import java.security.PublicKey
 import java.time.Instant
 import java.util.*
+import javax.persistence.Tuple
 
 /**
  * Currently, the node vault service is a very simple RDBMS backed implementation.  It will change significantly when
@@ -43,7 +47,7 @@ import java.util.*
  * TODO: keep an audit trail with time stamps of previously unconsumed states "as of" a particular point in time.
  * TODO: have transaction storage do some caching.
  */
-class NodeVaultService(private val services: ServiceHub) : SingletonSerializeAsToken(), VaultService {
+class NodeVaultService(private val services: ServiceHub, private val hibernateConfig: HibernateConfiguration) : SingletonSerializeAsToken(), VaultService {
 
     private companion object {
         val log = loggerFor<NodeVaultService>()
@@ -102,9 +106,6 @@ class NodeVaultService(private val services: ServiceHub) : SingletonSerializeAsT
     override val updates: Observable<Vault.Update<ContractState>>
         get() = mutex.locked { _updatesInDbTx }
 
-    override val updatesPublisher: PublishSubject<Vault.Update<ContractState>>
-        get() = mutex.locked { _updatesPublisher }
-
     /**
      * Splits the provided [txns] into batches of [WireTransaction] and [NotaryChangeWireTransaction].
      * This is required because the batches get aggregated into single updates, and we want to be able to
@@ -347,7 +348,7 @@ class NodeVaultService(private val services: ServiceHub) : SingletonSerializeAsT
         val enrichedCriteria = QueryCriteria.VaultQueryCriteria(
                 contractStateTypes = setOf(contractStateType),
                 softLockingCondition = QueryCriteria.SoftLockingCondition(QueryCriteria.SoftLockingType.UNLOCKED_AND_SPECIFIED, listOf(lockId)))
-        val results = services.vaultQueryService.queryBy(contractStateType, enrichedCriteria.and(eligibleStatesQuery), sorter)
+        val results = queryBy(contractStateType, enrichedCriteria.and(eligibleStatesQuery), sorter)
 
         var claimedAmount = 0L
         val claimedStates = mutableListOf<StateAndRef<T>>()
@@ -368,8 +369,6 @@ class NodeVaultService(private val services: ServiceHub) : SingletonSerializeAsT
         return claimedStates
     }
 
-
-
     @VisibleForTesting
     internal fun isRelevant(state: ContractState, myKeys: Set<PublicKey>): Boolean {
         val keysToCheck = when (state) {
@@ -378,4 +377,172 @@ class NodeVaultService(private val services: ServiceHub) : SingletonSerializeAsT
         }
         return keysToCheck.any { it in myKeys }
     }
+
+    private var sessionFactory = hibernateConfig.sessionFactoryForRegisteredSchemas()
+    private var criteriaBuilder = sessionFactory.criteriaBuilder
+
+    /**
+     * Maintain a list of contract state interfaces to concrete types stored in the vault
+     * for usage in generic queries of type queryBy<LinearState> or queryBy<FungibleState<*>>
+     */
+    private val contractStateTypeMappings = bootstrapContractStateTypes()
+
+    init {
+        rawUpdates.subscribe { update ->
+            update.produced.forEach {
+                val concreteType = it.state.data.javaClass
+                log.trace { "State update of type: $concreteType" }
+                val seen = contractStateTypeMappings.any { it.value.contains(concreteType.name) }
+                if (!seen) {
+                    val contractInterfaces = deriveContractInterfaces(concreteType)
+                    contractInterfaces.map {
+                        val contractInterface = contractStateTypeMappings.getOrPut(it.name, { mutableSetOf() })
+                        contractInterface.add(concreteType.name)
+                    }
+                }
+            }
+        }
+    }
+
+    @Throws(VaultQueryException::class)
+    override fun <T : ContractState> _queryBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): Vault.Page<T> {
+        log.info("Vault Query for contract type: $contractStateType, criteria: $criteria, pagination: $paging, sorting: $sorting")
+
+        // refresh to include any schemas registered after initial VQ service initialisation
+        sessionFactory = hibernateConfig.sessionFactoryForRegisteredSchemas()
+        criteriaBuilder = sessionFactory.criteriaBuilder
+
+        // calculate total results where a page specification has been defined
+        var totalStates = -1L
+        if (!paging.isDefault) {
+            val count = builder { VaultSchemaV1.VaultStates::recordedTime.count() }
+            val countCriteria = QueryCriteria.VaultCustomQueryCriteria(count, Vault.StateStatus.ALL)
+            val results = queryBy(contractStateType, criteria.and(countCriteria))
+            totalStates = results.otherResults[0] as Long
+        }
+
+        val session = getSession()
+
+        session.use {
+            val criteriaQuery = criteriaBuilder.createQuery(Tuple::class.java)
+            val queryRootVaultStates = criteriaQuery.from(VaultSchemaV1.VaultStates::class.java)
+
+            // TODO: revisit (use single instance of parser for all queries)
+            val criteriaParser = HibernateQueryCriteriaParser(contractStateType, contractStateTypeMappings, criteriaBuilder, criteriaQuery, queryRootVaultStates)
+
+            try {
+                // parse criteria and build where predicates
+                criteriaParser.parse(criteria, sorting)
+
+                // prepare query for execution
+                val query = session.createQuery(criteriaQuery)
+
+                // pagination checks
+                if (!paging.isDefault) {
+                    // pagination
+                    if (paging.pageNumber < DEFAULT_PAGE_NUM) throw VaultQueryException("Page specification: invalid page number ${paging.pageNumber} [page numbers start from ${DEFAULT_PAGE_NUM}]")
+                    if (paging.pageSize < 1) throw VaultQueryException("Page specification: invalid page size ${paging.pageSize} [must be a value between 1 and ${MAX_PAGE_SIZE}]")
+                }
+
+                query.firstResult = (paging.pageNumber - 1) * paging.pageSize
+                query.maxResults = paging.pageSize + 1  // detection too many results
+
+                // execution
+                val results = query.resultList
+
+                // final pagination check (fail-fast on too many results when no pagination specified)
+                if (paging.isDefault && results.size > DEFAULT_PAGE_SIZE)
+                    throw VaultQueryException("Please specify a `PageSpecification` as there are more results [${results.size}] than the default page size [${DEFAULT_PAGE_SIZE}]")
+
+                val statesAndRefs: MutableList<StateAndRef<T>> = mutableListOf()
+                val statesMeta: MutableList<Vault.StateMetadata> = mutableListOf()
+                val otherResults: MutableList<Any> = mutableListOf()
+
+                results.asSequence()
+                        .forEachIndexed { index, result ->
+                            if (result[0] is VaultSchemaV1.VaultStates) {
+                                if (!paging.isDefault && index == paging.pageSize) // skip last result if paged
+                                    return@forEachIndexed
+                                val vaultState = result[0] as VaultSchemaV1.VaultStates
+                                val stateRef = StateRef(SecureHash.parse(vaultState.stateRef!!.txId!!), vaultState.stateRef!!.index!!)
+                                val state = vaultState.contractState.deserialize<TransactionState<T>>(context = STORAGE_CONTEXT)
+                                statesMeta.add(Vault.StateMetadata(stateRef,
+                                        vaultState.contractStateClassName,
+                                        vaultState.recordedTime,
+                                        vaultState.consumedTime,
+                                        vaultState.stateStatus,
+                                        vaultState.notary,
+                                        vaultState.lockId,
+                                        vaultState.lockUpdateTime))
+                                statesAndRefs.add(StateAndRef(state, stateRef))
+                            }
+                            else {
+                                // TODO: improve typing of returned other results
+                                log.debug { "OtherResults: ${Arrays.toString(result.toArray())}" }
+                                otherResults.addAll(result.toArray().asList())
+                            }
+                        }
+
+                return Vault.Page(states = statesAndRefs, statesMetadata = statesMeta, stateTypes = criteriaParser.stateTypes, totalStatesAvailable = totalStates, otherResults = otherResults)
+            } catch (e: java.lang.Exception) {
+                log.error(e.message)
+                throw e.cause ?: e
+            }
+        }
+    }
+
+    @Throws(VaultQueryException::class)
+    override fun <T : ContractState> _trackBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+        return mutex.locked {
+            val snapshotResults = _queryBy(criteria, paging, sorting, contractStateType)
+            @Suppress("UNCHECKED_CAST")
+            val updates = _updatesPublisher.bufferUntilSubscribed().filter { it.containsType(contractStateType, snapshotResults.stateTypes) } as Observable<Vault.Update<T>>
+            DataFeed(snapshotResults, updates)
+        }
+    }
+
+    private fun getSession(): Session {
+        return sessionFactory.withOptions().
+                connection(DatabaseTransactionManager.current().connection).
+                openSession()
+    }
+
+    /**
+     * Derive list from existing vault states and then incrementally update using vault observables
+     */
+    private fun bootstrapContractStateTypes(): MutableMap<String, MutableSet<String>> {
+        val criteria = criteriaBuilder.createQuery(String::class.java)
+        val vaultStates = criteria.from(VaultSchemaV1.VaultStates::class.java)
+        criteria.select(vaultStates.get("contractStateClassName")).distinct(true)
+        val session = getSession()
+        session.use {
+            val query = session.createQuery(criteria)
+            val results = query.resultList
+            val distinctTypes = results.map { it }
+
+            val contractInterfaceToConcreteTypes = mutableMapOf<String, MutableSet<String>>()
+            distinctTypes.forEach { type ->
+                @Suppress("UNCHECKED_CAST")
+                val concreteType = Class.forName(type) as Class<ContractState>
+                val contractInterfaces = deriveContractInterfaces(concreteType)
+                contractInterfaces.map {
+                    val contractInterface = contractInterfaceToConcreteTypes.getOrPut(it.name, { mutableSetOf() })
+                    contractInterface.add(concreteType.name)
+                }
+            }
+            return contractInterfaceToConcreteTypes
+        }
+    }
+
+    private fun <T : ContractState> deriveContractInterfaces(clazz: Class<T>): Set<Class<T>> {
+        val myInterfaces: MutableSet<Class<T>> = mutableSetOf()
+        clazz.interfaces.forEach {
+            if (!it.equals(ContractState::class.java)) {
+                @Suppress("UNCHECKED_CAST")
+                myInterfaces.add(it as Class<T>)
+                myInterfaces.addAll(deriveContractInterfaces(it))
+            }
+        }
+        return myInterfaces
+    }
 }
diff --git a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
index f963189d1f..6a38dde99a 100644
--- a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
+++ b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
@@ -1,63 +1,44 @@
 package net.corda.node.services.vault;
 
-import com.google.common.collect.ImmutableSet;
-import kotlin.Pair;
-import kotlin.Triple;
+import com.google.common.collect.*;
+import kotlin.*;
 import net.corda.core.contracts.*;
-import net.corda.core.identity.AbstractParty;
-import net.corda.core.messaging.DataFeed;
-import net.corda.core.node.services.IdentityService;
-import net.corda.core.node.services.Vault;
-import net.corda.core.node.services.VaultQueryException;
-import net.corda.core.node.services.VaultQueryService;
+import net.corda.core.identity.*;
+import net.corda.core.messaging.*;
+import net.corda.core.node.services.*;
 import net.corda.core.node.services.vault.*;
-import net.corda.core.node.services.vault.QueryCriteria.LinearStateQueryCriteria;
-import net.corda.core.node.services.vault.QueryCriteria.VaultCustomQueryCriteria;
-import net.corda.core.node.services.vault.QueryCriteria.VaultQueryCriteria;
-import net.corda.core.schemas.MappedSchema;
-import net.corda.core.utilities.EncodingUtils;
-import net.corda.core.utilities.OpaqueBytes;
-import net.corda.finance.contracts.DealState;
-import net.corda.finance.contracts.asset.Cash;
-import net.corda.finance.contracts.asset.CashUtilities;
-import net.corda.finance.schemas.CashSchemaV1;
-import net.corda.node.utilities.CordaPersistence;
-import net.corda.node.utilities.DatabaseTransaction;
-import net.corda.testing.TestConstants;
-import net.corda.testing.TestDependencyInjectionBase;
-import net.corda.testing.contracts.DummyLinearContract;
-import net.corda.testing.contracts.VaultFiller;
-import net.corda.testing.node.MockServices;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import net.corda.core.node.services.vault.QueryCriteria.*;
+import net.corda.core.schemas.*;
+import net.corda.core.utilities.*;
+import net.corda.finance.contracts.*;
+import net.corda.finance.contracts.asset.*;
+import net.corda.finance.schemas.*;
+import net.corda.node.utilities.*;
+import net.corda.testing.*;
+import net.corda.testing.contracts.*;
+import net.corda.testing.node.*;
+import org.junit.*;
 import rx.Observable;
 
-import java.io.IOException;
-import java.lang.reflect.Field;
-import java.security.KeyPair;
+import java.io.*;
+import java.lang.reflect.*;
+import java.security.*;
 import java.util.*;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
+import java.util.stream.*;
 
-import static net.corda.core.node.services.vault.QueryCriteriaUtils.DEFAULT_PAGE_NUM;
-import static net.corda.core.node.services.vault.QueryCriteriaUtils.MAX_PAGE_SIZE;
-import static net.corda.core.utilities.ByteArrays.toHexString;
-import static net.corda.finance.contracts.asset.CashUtilities.getDUMMY_CASH_ISSUER;
-import static net.corda.finance.contracts.asset.CashUtilities.getDUMMY_CASH_ISSUER_KEY;
+import static net.corda.core.node.services.vault.QueryCriteriaUtils.*;
+import static net.corda.core.utilities.ByteArrays.*;
+import static net.corda.finance.contracts.asset.CashUtilities.*;
 import static net.corda.testing.CoreTestUtils.*;
-import static net.corda.testing.TestConstants.getDUMMY_NOTARY;
-import static net.corda.testing.TestConstants.getDUMMY_NOTARY_KEY;
-import static net.corda.testing.node.MockServices.makeTestDatabaseAndMockServices;
-import static net.corda.testing.node.MockServices.makeTestIdentityService;
-import static org.assertj.core.api.Assertions.assertThat;
+import static net.corda.testing.TestConstants.*;
+import static net.corda.testing.node.MockServices.*;
+import static org.assertj.core.api.Assertions.*;
 
 public class VaultQueryJavaTests extends TestDependencyInjectionBase {
 
     private MockServices services;
     private MockServices issuerServices;
-    private VaultQueryService vaultQuerySvc;
+    private VaultService vaultService;
     private CordaPersistence database;
 
     @Before
@@ -73,7 +54,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
         issuerServices = new MockServices(getDUMMY_CASH_ISSUER_KEY(), getBOC_KEY());
         database = databaseAndServices.getFirst();
         services = databaseAndServices.getSecond();
-        vaultQuerySvc = services.getVaultQueryService();
+        vaultService = services.getVaultService();
     }
 
     @After
@@ -98,7 +79,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
         });
         database.transaction(tx -> {
             // DOCSTART VaultJavaQueryExample0
-            Vault.Page<LinearState> results = vaultQuerySvc.queryBy(LinearState.class);
+            Vault.Page<LinearState> results = vaultService.queryBy(LinearState.class);
             // DOCEND VaultJavaQueryExample0
 
             assertThat(results.getStates()).hasSize(3);
@@ -121,7 +102,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
             SortAttribute.Standard sortAttribute = new SortAttribute.Standard(Sort.CommonStateAttribute.STATE_REF_TXN_ID);
             Sort sorting = new Sort(Collections.singletonList(new Sort.SortColumn(sortAttribute, Sort.Direction.ASC)));
             VaultQueryCriteria criteria = new VaultQueryCriteria(Vault.StateStatus.UNCONSUMED, null, stateRefs);
-            Vault.Page<DummyLinearContract.State> results = vaultQuerySvc.queryBy(DummyLinearContract.State.class, criteria, sorting);
+            Vault.Page<DummyLinearContract.State> results = vaultService.queryBy(DummyLinearContract.State.class, criteria, sorting);
 
             assertThat(results.getStates()).hasSize(2);
 
@@ -156,7 +137,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
         database.transaction(tx -> {
             // DOCSTART VaultJavaQueryExample1
             VaultQueryCriteria criteria = new VaultQueryCriteria(Vault.StateStatus.CONSUMED);
-            Vault.Page<Cash.State> results = vaultQuerySvc.queryBy(Cash.State.class, criteria);
+            Vault.Page<Cash.State> results = vaultService.queryBy(Cash.State.class, criteria);
             // DOCEND VaultJavaQueryExample1
 
             assertThat(results.getStates()).hasSize(3);
@@ -202,7 +183,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
             PageSpecification pageSpec = new PageSpecification(DEFAULT_PAGE_NUM, MAX_PAGE_SIZE);
             Sort.SortColumn sortByUid = new Sort.SortColumn(new SortAttribute.Standard(Sort.LinearStateAttribute.UUID), Sort.Direction.DESC);
             Sort sorting = new Sort(ImmutableSet.of(sortByUid));
-            Vault.Page<LinearState> results = vaultQuerySvc.queryBy(LinearState.class, compositeCriteria2, pageSpec, sorting);
+            Vault.Page<LinearState> results = vaultService.queryBy(LinearState.class, compositeCriteria2, pageSpec, sorting);
             // DOCEND VaultJavaQueryExample2
 
             assertThat(results.getStates()).hasSize(4);
@@ -243,7 +224,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
 
 
                 QueryCriteria criteria = generalCriteria.and(customCriteria1).and(customCriteria2);
-                Vault.Page<ContractState> results = vaultQuerySvc.queryBy(Cash.State.class, criteria);
+                Vault.Page<ContractState> results = vaultService.queryBy(Cash.State.class, criteria);
                 // DOCEND VaultJavaQueryExample3
 
                 assertThat(results.getStates()).hasSize(2);
@@ -279,7 +260,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
             Set<Class<ContractState>> contractStateTypes = new HashSet(Collections.singletonList(Cash.State.class));
 
             VaultQueryCriteria criteria = new VaultQueryCriteria(Vault.StateStatus.UNCONSUMED, contractStateTypes);
-            DataFeed<Vault.Page<ContractState>, Vault.Update<ContractState>> results = vaultQuerySvc.trackBy(ContractState.class, criteria);
+            DataFeed<Vault.Page<ContractState>, Vault.Update<ContractState>> results = vaultService.trackBy(ContractState.class, criteria);
 
             Vault.Page<ContractState> snapshot = results.getSnapshot();
             Observable<Vault.Update<ContractState>> updates = results.getUpdates();
@@ -318,7 +299,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
             PageSpecification pageSpec = new PageSpecification(DEFAULT_PAGE_NUM, MAX_PAGE_SIZE);
             Sort.SortColumn sortByUid = new Sort.SortColumn(new SortAttribute.Standard(Sort.LinearStateAttribute.UUID), Sort.Direction.DESC);
             Sort sorting = new Sort(ImmutableSet.of(sortByUid));
-            DataFeed<Vault.Page<ContractState>, Vault.Update<ContractState>> results = vaultQuerySvc.trackBy(ContractState.class, compositeCriteria, pageSpec, sorting);
+            DataFeed<Vault.Page<ContractState>, Vault.Update<ContractState>> results = vaultService.trackBy(ContractState.class, compositeCriteria, pageSpec, sorting);
 
             Vault.Page<ContractState> snapshot = results.getSnapshot();
             // DOCEND VaultJavaQueryExample5
@@ -364,7 +345,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
                 QueryCriteria avgCriteria = new VaultCustomQueryCriteria(Builder.avg(pennies));
 
                 QueryCriteria criteria = sumCriteria.and(countCriteria).and(maxCriteria).and(minCriteria).and(avgCriteria);
-                Vault.Page<Cash.State> results = vaultQuerySvc.queryBy(Cash.State.class, criteria);
+                Vault.Page<Cash.State> results = vaultService.queryBy(Cash.State.class, criteria);
                 // DOCEND VaultJavaQueryExample21
 
                 assertThat(results.getOtherResults()).hasSize(5);
@@ -413,7 +394,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
                 QueryCriteria avgCriteria = new VaultCustomQueryCriteria(Builder.avg(pennies, Collections.singletonList(currency)));
 
                 QueryCriteria criteria = sumCriteria.and(countCriteria).and(maxCriteria).and(minCriteria).and(avgCriteria);
-                Vault.Page<Cash.State> results = vaultQuerySvc.queryBy(Cash.State.class, criteria);
+                Vault.Page<Cash.State> results = vaultService.queryBy(Cash.State.class, criteria);
                 // DOCEND VaultJavaQueryExample22
 
                 assertThat(results.getOtherResults()).hasSize(27);
@@ -480,7 +461,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
 
                 QueryCriteria sumCriteria = new VaultCustomQueryCriteria(Builder.sum(pennies, Arrays.asList(issuerParty, currency), Sort.Direction.DESC));
 
-                Vault.Page<Cash.State> results = vaultQuerySvc.queryBy(Cash.State.class, sumCriteria);
+                Vault.Page<Cash.State> results = vaultService.queryBy(Cash.State.class, sumCriteria);
                 // DOCEND VaultJavaQueryExample23
 
                 assertThat(results.getOtherResults()).hasSize(12);
diff --git a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
index f713bf0f5e..ecd2e604d0 100644
--- a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
+++ b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
@@ -100,7 +100,7 @@ class CordaRPCOpsImplTest {
 
         // Check the monitoring service wallet is empty
         aliceNode.database.transaction {
-            assertFalse(aliceNode.services.vaultQueryService.queryBy<ContractState>().totalStatesAvailable > 0)
+            assertFalse(aliceNode.services.vaultService.queryBy<ContractState>().totalStatesAvailable > 0)
         }
 
         // Tell the monitoring service node to issue some cash
diff --git a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
index 33202b4874..0b7466dddf 100644
--- a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
@@ -96,7 +96,7 @@ class NodeSchedulerServiceTest : SingletonSerializeAsToken() {
                     overrideClock = testClock,
                     keyManagement = kms,
                     network = mockMessagingService), TestReference {
-                override val vaultService: VaultService = NodeVaultService(this)
+                override val vaultService: VaultService = NodeVaultService(this, database.hibernateConfig)
                 override val testReference = this@NodeSchedulerServiceTest
                 override val cordappProvider: CordappProviderImpl = CordappProviderImpl(CordappLoader.createWithTestPackages()).start(attachments)
             }
diff --git a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
index bfd6557377..072fd74a05 100644
--- a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
@@ -5,7 +5,7 @@ import net.corda.core.concurrent.CordaFuture
 import net.corda.core.contracts.*
 import net.corda.core.flows.*
 import net.corda.core.identity.Party
-import net.corda.core.node.services.VaultQueryService
+import net.corda.core.node.services.VaultService
 import net.corda.core.node.services.queryBy
 import net.corda.core.node.services.vault.DEFAULT_PAGE_NUM
 import net.corda.core.node.services.vault.PageSpecification
@@ -128,10 +128,10 @@ class ScheduledFlowTests {
         nodeA.services.startFlow(InsertInitialStateFlow(nodeB.info.chooseIdentity()))
         mockNet.waitQuiescent()
         val stateFromA = nodeA.database.transaction {
-            nodeA.services.vaultQueryService.queryBy<ScheduledState>().states.single()
+            nodeA.services.vaultService.queryBy<ScheduledState>().states.single()
         }
         val stateFromB = nodeB.database.transaction {
-            nodeB.services.vaultQueryService.queryBy<ScheduledState>().states.single()
+            nodeB.services.vaultService.queryBy<ScheduledState>().states.single()
         }
         assertEquals(1, countScheduledFlows)
         assertEquals("Must be same copy on both nodes", stateFromA, stateFromB)
@@ -153,10 +153,10 @@ class ScheduledFlowTests {
 
         // Convert the states into maps to make error reporting easier
         val statesFromA: List<StateAndRef<ScheduledState>> = nodeA.database.transaction {
-            queryStatesWithPaging(nodeA.services.vaultQueryService)
+            queryStatesWithPaging(nodeA.services.vaultService)
         }
         val statesFromB: List<StateAndRef<ScheduledState>> = nodeB.database.transaction {
-            queryStatesWithPaging(nodeB.services.vaultQueryService)
+            queryStatesWithPaging(nodeB.services.vaultService)
         }
         assertEquals("Expect all states to be present",2 * N, statesFromA.count())
         statesFromA.forEach { ref ->
@@ -179,13 +179,13 @@ class ScheduledFlowTests {
      *
      * @return states ordered by the transaction ID.
      */
-    private fun queryStatesWithPaging(vaultQueryService: VaultQueryService): List<StateAndRef<ScheduledState>> {
+    private fun queryStatesWithPaging(vaultService: VaultService): List<StateAndRef<ScheduledState>> {
         // DOCSTART VaultQueryExamplePaging
         var pageNumber = DEFAULT_PAGE_NUM
         val states = mutableListOf<StateAndRef<ScheduledState>>()
         do {
             val pageSpec = PageSpecification(pageSize = PAGE_SIZE, pageNumber = pageNumber)
-            val results = vaultQueryService.queryBy<ScheduledState>(VaultQueryCriteria(), pageSpec, SORTING)
+            val results = vaultService.queryBy<ScheduledState>(VaultQueryCriteria(), pageSpec, SORTING)
             states.addAll(results.states)
             pageNumber++
         } while ((pageSpec.pageSize * (pageNumber)) <= results.totalStatesAvailable)
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
index ec6a134f13..4ea017461d 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
@@ -51,7 +51,7 @@ class DBTransactionStorageTests : TestDependencyInjectionBase() {
 
             services = object : MockServices(BOB_KEY) {
                 override val vaultService: VaultService get() {
-                    val vaultService = NodeVaultService(this)
+                    val vaultService = NodeVaultService(this, database.hibernateConfig)
                     hibernatePersister = HibernateObserver(vaultService.rawUpdates, database.hibernateConfig)
                     return vaultService
                 }
diff --git a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
index 43869643f7..a08230d9ff 100644
--- a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
@@ -1024,9 +1024,9 @@ class FlowFrameworkTests {
         override fun call(): List<StateAndRef<ContractState>> {
             val otherPartySession = initiateFlow(otherParty)
             otherPartySession.send(stx)
-            // hold onto reference here to force checkpoint of vaultQueryService and thus
+            // hold onto reference here to force checkpoint of vaultService and thus
             // prove it is registered as a tokenizableService in the node
-            val vaultQuerySvc = serviceHub.vaultQueryService
+            val vaultQuerySvc = serviceHub.vaultService
             waitForLedgerCommit(stx.id)
             return vaultQuerySvc.queryBy<ContractState>().states
         }
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
index b5c9dc19d7..2880435862 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
@@ -47,8 +47,7 @@ import kotlin.test.assertTrue
 class NodeVaultServiceTest : TestDependencyInjectionBase() {
     lateinit var services: MockServices
     lateinit var issuerServices: MockServices
-    val vaultSvc: VaultService get() = services.vaultService
-    val vaultQuery: VaultQueryService get() = services.vaultQueryService
+    val vaultService: VaultService get() = services.vaultService
     lateinit var database: CordaPersistence
 
     @Before
@@ -94,11 +93,10 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 3, 3, Random(0L))
         }
         database.transaction {
-            val w1 = vaultQuery.queryBy<Cash.State>().states
+            val w1 = vaultService.queryBy<Cash.State>().states
             assertThat(w1).hasSize(3)
 
-            val originalVault = vaultSvc
-            val originalVaultQuery = vaultQuery
+            val originalVault = vaultService
             val services2 = object : MockServices() {
                 override val vaultService: NodeVaultService get() = originalVault as NodeVaultService
                 override fun recordTransactions(notifyVault: Boolean, txs: Iterable<SignedTransaction>) {
@@ -107,11 +105,9 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
                         vaultService.notify(stx.tx)
                     }
                 }
-
-                override val vaultQueryService: VaultQueryService get() = originalVaultQuery
             }
 
-            val w2 = services2.vaultQueryService.queryBy<Cash.State>().states
+            val w2 = services2.vaultService.queryBy<Cash.State>().states
             assertThat(w2).hasSize(3)
         }
     }
@@ -122,10 +118,10 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 3, 3, Random(0L))
         }
         database.transaction {
-            val w1 = vaultQuery.queryBy<Cash.State>().states
+            val w1 = vaultService.queryBy<Cash.State>().states
             assertThat(w1).hasSize(3)
 
-            val states = vaultQuery.queryBy<Cash.State>(VaultQueryCriteria(stateRefs = listOf(w1[1].ref, w1[2].ref))).states
+            val states = vaultService.queryBy<Cash.State>(VaultQueryCriteria(stateRefs = listOf(w1[1].ref, w1[2].ref))).states
             assertThat(states).hasSize(2)
         }
     }
@@ -137,34 +133,34 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
         }
         database.transaction {
 
-            val unconsumedStates = vaultQuery.queryBy<Cash.State>().states
+            val unconsumedStates = vaultService.queryBy<Cash.State>().states
             assertThat(unconsumedStates).hasSize(3)
 
             val stateRefsToSoftLock = NonEmptySet.of(unconsumedStates[1].ref, unconsumedStates[2].ref)
 
             // soft lock two of the three states
             val softLockId = UUID.randomUUID()
-            vaultSvc.softLockReserve(softLockId, stateRefsToSoftLock)
+            vaultService.softLockReserve(softLockId, stateRefsToSoftLock)
 
             // all softlocked states
             val criteriaLocked = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.LOCKED_ONLY))
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaLocked).states).hasSize(2)
+            assertThat(vaultService.queryBy<Cash.State>(criteriaLocked).states).hasSize(2)
             // my softlocked states
             val criteriaByLockId = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.SPECIFIED, listOf(softLockId)))
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaByLockId).states).hasSize(2)
+            assertThat(vaultService.queryBy<Cash.State>(criteriaByLockId).states).hasSize(2)
 
             // excluding softlocked states
-            val unlockedStates1 = vaultQuery.queryBy<Cash.State>(VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_ONLY))).states
+            val unlockedStates1 = vaultService.queryBy<Cash.State>(VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_ONLY))).states
             assertThat(unlockedStates1).hasSize(1)
 
             // soft lock release one of the states explicitly
-            vaultSvc.softLockRelease(softLockId, NonEmptySet.of(unconsumedStates[1].ref))
-            val unlockedStates2 = vaultQuery.queryBy<Cash.State>(VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_ONLY))).states
+            vaultService.softLockRelease(softLockId, NonEmptySet.of(unconsumedStates[1].ref))
+            val unlockedStates2 = vaultService.queryBy<Cash.State>(VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_ONLY))).states
             assertThat(unlockedStates2).hasSize(2)
 
             // soft lock release the rest by id
-            vaultSvc.softLockRelease(softLockId)
-            val unlockedStates = vaultQuery.queryBy<Cash.State>(VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_ONLY))).states
+            vaultService.softLockRelease(softLockId)
+            val unlockedStates = vaultService.queryBy<Cash.State>(VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_ONLY))).states
             assertThat(unlockedStates).hasSize(3)
 
             // should be back to original states
@@ -195,8 +191,8 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
         backgroundExecutor.submit {
             try {
                 database.transaction {
-                    vaultSvc.softLockReserve(softLockId1, stateRefsToSoftLock)
-                    assertThat(vaultQuery.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(3)
+                    vaultService.softLockReserve(softLockId1, stateRefsToSoftLock)
+                    assertThat(vaultService.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(3)
                 }
                 println("SOFT LOCK STATES #1 succeeded")
             } catch(e: Throwable) {
@@ -211,8 +207,8 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
             try {
                 Thread.sleep(100)   // let 1st thread soft lock them 1st
                 database.transaction {
-                    vaultSvc.softLockReserve(softLockId2, stateRefsToSoftLock)
-                    assertThat(vaultQuery.queryBy<Cash.State>(criteriaByLockId2).states).hasSize(3)
+                    vaultService.softLockReserve(softLockId2, stateRefsToSoftLock)
+                    assertThat(vaultService.queryBy<Cash.State>(criteriaByLockId2).states).hasSize(3)
                 }
                 println("SOFT LOCK STATES #2 succeeded")
             } catch(e: Throwable) {
@@ -224,10 +220,10 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
         countDown.await()
         database.transaction {
-            val lockStatesId1 = vaultQuery.queryBy<Cash.State>(criteriaByLockId1).states
+            val lockStatesId1 = vaultService.queryBy<Cash.State>(criteriaByLockId1).states
             println("SOFT LOCK #1 final states: $lockStatesId1")
             assertThat(lockStatesId1.size).isIn(0, 3)
-            val lockStatesId2 = vaultQuery.queryBy<Cash.State>(criteriaByLockId2).states
+            val lockStatesId2 = vaultService.queryBy<Cash.State>(criteriaByLockId2).states
             println("SOFT LOCK #2 final states: $lockStatesId2")
             assertThat(lockStatesId2.size).isIn(0, 3)
         }
@@ -248,15 +244,15 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
         // lock 1st state with LockId1
         database.transaction {
-            vaultSvc.softLockReserve(softLockId1, NonEmptySet.of(stateRefsToSoftLock.first()))
+            vaultService.softLockReserve(softLockId1, NonEmptySet.of(stateRefsToSoftLock.first()))
             val criteriaByLockId1 = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.SPECIFIED, listOf(softLockId1)))
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(1)
+            assertThat(vaultService.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(1)
         }
 
         // attempt to lock all 3 states with LockId2
         database.transaction {
             assertThatExceptionOfType(StatesNotAvailableException::class.java).isThrownBy(
-                    { vaultSvc.softLockReserve(softLockId2, stateRefsToSoftLock.toNonEmptySet()) }
+                    { vaultService.softLockReserve(softLockId2, stateRefsToSoftLock.toNonEmptySet()) }
             ).withMessageContaining("only 2 rows available").withNoCause()
         }
     }
@@ -276,14 +272,14 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
         // lock states with LockId1
         database.transaction {
-            vaultSvc.softLockReserve(softLockId1, stateRefsToSoftLock)
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(3)
+            vaultService.softLockReserve(softLockId1, stateRefsToSoftLock)
+            assertThat(vaultService.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(3)
         }
 
         // attempt to relock same states with LockId1
         database.transaction {
-            vaultSvc.softLockReserve(softLockId1, stateRefsToSoftLock)
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(3)
+            vaultService.softLockReserve(softLockId1, stateRefsToSoftLock)
+            assertThat(vaultService.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(3)
         }
     }
 
@@ -303,14 +299,14 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
         // lock states with LockId1
         database.transaction {
-            vaultSvc.softLockReserve(softLockId1, NonEmptySet.of(stateRefsToSoftLock.first()))
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(1)
+            vaultService.softLockReserve(softLockId1, NonEmptySet.of(stateRefsToSoftLock.first()))
+            assertThat(vaultService.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(1)
         }
 
         // attempt to lock all states with LockId1 (including previously already locked one)
         database.transaction {
-            vaultSvc.softLockReserve(softLockId1, stateRefsToSoftLock.toNonEmptySet())
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(3)
+            vaultService.softLockReserve(softLockId1, stateRefsToSoftLock.toNonEmptySet())
+            assertThat(vaultService.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(3)
         }
     }
 
@@ -321,15 +317,15 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
         }
         database.transaction {
 
-            val unconsumedStates = vaultQuery.queryBy<Cash.State>().states
+            val unconsumedStates = vaultService.queryBy<Cash.State>().states
             assertThat(unconsumedStates).hasSize(1)
 
-            val spendableStatesUSD = vaultSvc.unconsumedCashStatesForSpending(100.DOLLARS)
+            val spendableStatesUSD = vaultService.unconsumedCashStatesForSpending(100.DOLLARS)
             spendableStatesUSD.forEach(::println)
             assertThat(spendableStatesUSD).hasSize(1)
             assertThat(spendableStatesUSD[0].state.data.amount.quantity).isEqualTo(100L * 100)
             val criteriaLocked = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.LOCKED_ONLY))
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaLocked).states).hasSize(1)
+            assertThat(vaultService.queryBy<Cash.State>(criteriaLocked).states).hasSize(1)
         }
     }
 
@@ -340,7 +336,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 1, 1, Random(0L), issuedBy = (BOC.ref(1)))
         }
         database.transaction {
-            val spendableStatesUSD = vaultSvc.unconsumedCashStatesForSpending(200.DOLLARS,
+            val spendableStatesUSD = vaultService.unconsumedCashStatesForSpending(200.DOLLARS,
                     onlyFromIssuerParties = setOf(DUMMY_CASH_ISSUER.party, BOC))
             spendableStatesUSD.forEach(::println)
             assertThat(spendableStatesUSD).hasSize(2)
@@ -359,10 +355,10 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 1, 1, Random(0L), issuedBy = (BOC.ref(3)), ref = OpaqueBytes.of(3))
         }
         database.transaction {
-            val unconsumedStates = vaultQuery.queryBy<Cash.State>().states
+            val unconsumedStates = vaultService.queryBy<Cash.State>().states
             assertThat(unconsumedStates).hasSize(4)
 
-            val spendableStatesUSD = vaultSvc.unconsumedCashStatesForSpending(200.DOLLARS,
+            val spendableStatesUSD = vaultService.unconsumedCashStatesForSpending(200.DOLLARS,
                     onlyFromIssuerParties = setOf(BOC), withIssuerRefs = setOf(OpaqueBytes.of(1), OpaqueBytes.of(2)))
             assertThat(spendableStatesUSD).hasSize(2)
             assertThat(spendableStatesUSD[0].state.data.amount.token.issuer.party).isEqualTo(BOC)
@@ -378,14 +374,14 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 1, 1, Random(0L))
         }
         database.transaction {
-            val unconsumedStates = vaultQuery.queryBy<Cash.State>().states
+            val unconsumedStates = vaultService.queryBy<Cash.State>().states
             assertThat(unconsumedStates).hasSize(1)
 
-            val spendableStatesUSD = vaultSvc.unconsumedCashStatesForSpending(110.DOLLARS)
+            val spendableStatesUSD = vaultService.unconsumedCashStatesForSpending(110.DOLLARS)
             spendableStatesUSD.forEach(::println)
             assertThat(spendableStatesUSD).hasSize(0)
             val criteriaLocked = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.LOCKED_ONLY))
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaLocked).states).hasSize(0)
+            assertThat(vaultService.queryBy<Cash.State>(criteriaLocked).states).hasSize(0)
         }
     }
 
@@ -395,15 +391,15 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 2, 2, Random(0L))
         }
         database.transaction {
-            val unconsumedStates = vaultQuery.queryBy<Cash.State>().states
+            val unconsumedStates = vaultService.queryBy<Cash.State>().states
             assertThat(unconsumedStates).hasSize(2)
 
-            val spendableStatesUSD = vaultSvc.unconsumedCashStatesForSpending(1.DOLLARS)
+            val spendableStatesUSD = vaultService.unconsumedCashStatesForSpending(1.DOLLARS)
             spendableStatesUSD.forEach(::println)
             assertThat(spendableStatesUSD).hasSize(1)
             assertThat(spendableStatesUSD[0].state.data.amount.quantity).isGreaterThanOrEqualTo(100L)
             val criteriaLocked = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.LOCKED_ONLY))
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaLocked).states).hasSize(1)
+            assertThat(vaultService.queryBy<Cash.State>(criteriaLocked).states).hasSize(1)
         }
     }
 
@@ -416,18 +412,18 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
         }
         database.transaction {
             var unlockedStates = 30
-            val allStates = vaultQuery.queryBy<Cash.State>().states
+            val allStates = vaultService.queryBy<Cash.State>().states
             assertThat(allStates).hasSize(unlockedStates)
 
             var lockedCount = 0
             for (i in 1..5) {
                 val lockId = UUID.randomUUID()
-                val spendableStatesUSD = vaultSvc.unconsumedCashStatesForSpending(20.DOLLARS, lockId = lockId)
+                val spendableStatesUSD = vaultService.unconsumedCashStatesForSpending(20.DOLLARS, lockId = lockId)
                 spendableStatesUSD.forEach(::println)
                 assertThat(spendableStatesUSD.size <= unlockedStates)
                 unlockedStates -= spendableStatesUSD.size
                 val criteriaLocked = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.SPECIFIED, listOf(lockId)))
-                val lockedStates = vaultQuery.queryBy<Cash.State>(criteriaLocked).states
+                val lockedStates = vaultService.queryBy<Cash.State>(criteriaLocked).states
                 if (spendableStatesUSD.isNotEmpty()) {
                     assertEquals(spendableStatesUSD.size, lockedStates.size)
                     val lockedTotal = lockedStates.map { it.state.data }.sumCash()
@@ -438,7 +434,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
                 }
             }
             val criteriaLocked = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.LOCKED_ONLY))
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaLocked).states).hasSize(lockedCount)
+            assertThat(vaultService.queryBy<Cash.State>(criteriaLocked).states).hasSize(lockedCount)
         }
     }
 
@@ -457,10 +453,10 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
             services.recordTransactions(usefulTX)
 
-            vaultSvc.addNoteToTransaction(usefulTX.id, "USD Sample Note 1")
-            vaultSvc.addNoteToTransaction(usefulTX.id, "USD Sample Note 2")
-            vaultSvc.addNoteToTransaction(usefulTX.id, "USD Sample Note 3")
-            assertEquals(3, vaultSvc.getTransactionNotes(usefulTX.id).count())
+            vaultService.addNoteToTransaction(usefulTX.id, "USD Sample Note 1")
+            vaultService.addNoteToTransaction(usefulTX.id, "USD Sample Note 2")
+            vaultService.addNoteToTransaction(usefulTX.id, "USD Sample Note 3")
+            assertEquals(3, vaultService.getTransactionNotes(usefulTX.id).count())
 
             // Issue more Money (GBP)
             val anotherBuilder = TransactionBuilder(null).apply {
@@ -470,8 +466,8 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
             services.recordTransactions(anotherTX)
 
-            vaultSvc.addNoteToTransaction(anotherTX.id, "GBP Sample Note 1")
-            assertEquals(1, vaultSvc.getTransactionNotes(anotherTX.id).count())
+            vaultService.addNoteToTransaction(anotherTX.id, "GBP Sample Note 1")
+            assertEquals(1, vaultService.getTransactionNotes(anotherTX.id).count())
         }
     }
 
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
index b6aabe44c6..74c799fc57 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
@@ -48,8 +48,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
 
     private lateinit var services: MockServices
     private lateinit var notaryServices: MockServices
-    private val vaultSvc: VaultService get() = services.vaultService
-    private val vaultQuerySvc: VaultQueryService get() = services.vaultQueryService
+    private val vaultService: VaultService get() = services.vaultService
     private val identitySvc: IdentityService = makeTestIdentityService()
     private lateinit var database: CordaPersistence
 
@@ -146,7 +145,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             // DOCSTART VaultQueryExample1
-            val result = vaultQuerySvc.queryBy<ContractState>()
+            val result = vaultService.queryBy<ContractState>()
 
             /**
              * Query result returns a [Vault.Page] which contains:
@@ -173,7 +172,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val criteria = VaultQueryCriteria() // default is UNCONSUMED
-            val result = vaultQuerySvc.queryBy<ContractState>(criteria)
+            val result = vaultService.queryBy<ContractState>(criteria)
 
             assertThat(result.states).hasSize(16)
             assertThat(result.statesMetadata).hasSize(16)
@@ -191,7 +190,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         val paging = PageSpecification(DEFAULT_PAGE_NUM, 10)
         database.transaction {
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
-            val resultsBeforeConsume = vaultQuerySvc.queryBy<ContractState>(criteria, paging)
+            val resultsBeforeConsume = vaultService.queryBy<ContractState>(criteria, paging)
             assertThat(resultsBeforeConsume.states).hasSize(4)
             assertThat(resultsBeforeConsume.totalStatesAvailable).isEqualTo(4)
         }
@@ -200,7 +199,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val consumedCriteria = VaultQueryCriteria(status = Vault.StateStatus.UNCONSUMED)
-            val resultsAfterConsume = vaultQuerySvc.queryBy<ContractState>(consumedCriteria, paging)
+            val resultsAfterConsume = vaultService.queryBy<ContractState>(consumedCriteria, paging)
             assertThat(resultsAfterConsume.states).hasSize(1)
             assertThat(resultsAfterConsume.totalStatesAvailable).isEqualTo(1)
         }
@@ -214,7 +213,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             services.fillWithSomeTestDeals(listOf("123", "456", "789"))
         }
         database.transaction {
-            val result = vaultQuerySvc.queryBy<Cash.State>()
+            val result = vaultService.queryBy<Cash.State>()
 
             assertThat(result.states).hasSize(3)
             assertThat(result.statesMetadata).hasSize(3)
@@ -230,7 +229,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val criteria = VaultQueryCriteria() // default is UNCONSUMED
-            val result = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val result = vaultService.queryBy<Cash.State>(criteria)
 
             assertThat(result.states).hasSize(3)
             assertThat(result.statesMetadata).hasSize(3)
@@ -254,7 +253,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val sortAttribute = SortAttribute.Standard(Sort.CommonStateAttribute.STATE_REF)
             val criteria = VaultQueryCriteria()
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria, Sort(setOf(Sort.SortColumn(sortAttribute, Sort.Direction.ASC))))
+            val results = vaultService.queryBy<Cash.State>(criteria, Sort(setOf(Sort.SortColumn(sortAttribute, Sort.Direction.ASC))))
 
             // default StateRef sort is by index then txnId:
             // order by
@@ -285,7 +284,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val sortBy = Sort(setOf(Sort.SortColumn(sortAttributeTxnId, Sort.Direction.ASC),
                     Sort.SortColumn(sortAttributeIndex, Sort.Direction.ASC)))
             val criteria = VaultQueryCriteria()
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria, sortBy)
+            val results = vaultService.queryBy<Cash.State>(criteria, sortBy)
 
             results.statesMetadata.forEach {
                 println(" ${it.ref}")
@@ -309,7 +308,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             // DOCSTART VaultQueryExample2
             val sortAttribute = SortAttribute.Standard(Sort.CommonStateAttribute.STATE_REF_TXN_ID)
             val criteria = VaultQueryCriteria(stateRefs = listOf(stateRefs.first(), stateRefs.last()))
-            val results = vaultQuerySvc.queryBy<DummyLinearContract.State>(criteria, Sort(setOf(Sort.SortColumn(sortAttribute, Sort.Direction.ASC))))
+            val results = vaultService.queryBy<DummyLinearContract.State>(criteria, Sort(setOf(Sort.SortColumn(sortAttribute, Sort.Direction.ASC))))
             // DOCEND VaultQueryExample2
 
             assertThat(results.states).hasSize(2)
@@ -331,7 +330,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             // default State.Status is UNCONSUMED
             // DOCSTART VaultQueryExample3
             val criteria = VaultQueryCriteria(contractStateTypes = setOf(Cash.State::class.java, DealState::class.java))
-            val results = vaultQuerySvc.queryBy<ContractState>(criteria)
+            val results = vaultService.queryBy<ContractState>(criteria)
             // DOCEND VaultQueryExample3
             assertThat(results.states).hasSize(6)
         }
@@ -351,7 +350,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
-            val results = vaultQuerySvc.queryBy<ContractState>(criteria)
+            val results = vaultService.queryBy<ContractState>(criteria)
             assertThat(results.states).hasSize(5)
         }
     }
@@ -367,7 +366,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         val paging = PageSpecification(DEFAULT_PAGE_NUM, 10)
         database.transaction {
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
-            val resultsBeforeConsume = vaultQuerySvc.queryBy<ContractState>(criteria, paging)
+            val resultsBeforeConsume = vaultService.queryBy<ContractState>(criteria, paging)
             assertThat(resultsBeforeConsume.states).hasSize(4)
             assertThat(resultsBeforeConsume.totalStatesAvailable).isEqualTo(4)
         }
@@ -376,7 +375,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val consumedCriteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
-            val resultsAfterConsume = vaultQuerySvc.queryBy<ContractState>(consumedCriteria, paging)
+            val resultsAfterConsume = vaultService.queryBy<ContractState>(consumedCriteria, paging)
             assertThat(resultsAfterConsume.states).hasSize(3)
             assertThat(resultsAfterConsume.totalStatesAvailable).isEqualTo(3)
         }
@@ -396,7 +395,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
-            val results = vaultQuerySvc.queryBy<ContractState>(criteria)
+            val results = vaultService.queryBy<ContractState>(criteria)
             assertThat(results.states).hasSize(17)
         }
     }
@@ -409,7 +408,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
         val paging = PageSpecification(DEFAULT_PAGE_NUM, 10)
         database.transaction {
-            val resultsBeforeConsume = vaultQuerySvc.queryBy<ContractState>(criteria, paging)
+            val resultsBeforeConsume = vaultService.queryBy<ContractState>(criteria, paging)
             assertThat(resultsBeforeConsume.states).hasSize(1)
             assertThat(resultsBeforeConsume.totalStatesAvailable).isEqualTo(1)
         }
@@ -417,7 +416,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             services.consumeCash(50.DOLLARS, notary = DUMMY_NOTARY)    // consumed 100 (spent), produced 50 (change)
         }
         database.transaction {
-            val resultsAfterConsume = vaultQuerySvc.queryBy<ContractState>(criteria, paging)
+            val resultsAfterConsume = vaultService.queryBy<ContractState>(criteria, paging)
             assertThat(resultsAfterConsume.states).hasSize(2)
             assertThat(resultsAfterConsume.totalStatesAvailable).isEqualTo(2)
         }
@@ -433,7 +432,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             // DOCSTART VaultQueryExample4
             val criteria = VaultQueryCriteria(notary = listOf(CASH_NOTARY))
-            val results = vaultQuerySvc.queryBy<ContractState>(criteria)
+            val results = vaultService.queryBy<ContractState>(criteria)
             // DOCEND VaultQueryExample4
             assertThat(results.states).hasSize(3)
         }
@@ -450,7 +449,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val criteria = LinearStateQueryCriteria(participants = listOf(BIG_CORP))
-            val results = vaultQuerySvc.queryBy<ContractState>(criteria)
+            val results = vaultService.queryBy<ContractState>(criteria)
             assertThat(results.states).hasSize(3)
         }
     }
@@ -467,7 +466,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             // DOCSTART VaultQueryExample5
             val criteria = LinearStateQueryCriteria(participants = listOf(BIG_CORP, MINI_CORP))
-            val results = vaultQuerySvc.queryBy<ContractState>(criteria)
+            val results = vaultService.queryBy<ContractState>(criteria)
             // DOCEND VaultQueryExample5
 
             assertThat(results.states).hasSize(3)
@@ -479,44 +478,44 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         val (lockId1, lockId2) =
                 database.transaction {
                     val issuedStates = services.fillWithSomeTestCash(100.DOLLARS, notaryServices, CASH_NOTARY, 10, 10, Random(0L)).states.toList()
-                    vaultSvc.softLockReserve(UUID.randomUUID(), NonEmptySet.of(issuedStates[1].ref, issuedStates[2].ref, issuedStates[3].ref))
+                    vaultService.softLockReserve(UUID.randomUUID(), NonEmptySet.of(issuedStates[1].ref, issuedStates[2].ref, issuedStates[3].ref))
                     val lockId1 = UUID.randomUUID()
-                    vaultSvc.softLockReserve(lockId1, NonEmptySet.of(issuedStates[4].ref, issuedStates[5].ref))
+                    vaultService.softLockReserve(lockId1, NonEmptySet.of(issuedStates[4].ref, issuedStates[5].ref))
                     val lockId2 = UUID.randomUUID()
-                    vaultSvc.softLockReserve(lockId2, NonEmptySet.of(issuedStates[6].ref))
+                    vaultService.softLockReserve(lockId2, NonEmptySet.of(issuedStates[6].ref))
                     Pair(lockId1, lockId2)
                 }
         database.transaction {
             // excluding soft locked states
             val criteriaExclusive = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_ONLY))
-            val resultsExclusive = vaultQuerySvc.queryBy<ContractState>(criteriaExclusive)
+            val resultsExclusive = vaultService.queryBy<ContractState>(criteriaExclusive)
             assertThat(resultsExclusive.states).hasSize(4)
 
             // only soft locked states
             val criteriaLockedOnly = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.LOCKED_ONLY))
-            val resultsLockedOnly = vaultQuerySvc.queryBy<ContractState>(criteriaLockedOnly)
+            val resultsLockedOnly = vaultService.queryBy<ContractState>(criteriaLockedOnly)
             assertThat(resultsLockedOnly.states).hasSize(6)
 
             // soft locked states by single lock id
             val criteriaByLockId = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.SPECIFIED, listOf(lockId1)))
-            val resultsByLockId = vaultQuerySvc.queryBy<ContractState>(criteriaByLockId)
+            val resultsByLockId = vaultService.queryBy<ContractState>(criteriaByLockId)
             assertThat(resultsByLockId.states).hasSize(2)
 
             // soft locked states by multiple lock ids
             val criteriaByLockIds = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.SPECIFIED, listOf(lockId1, lockId2)))
-            val resultsByLockIds = vaultQuerySvc.queryBy<ContractState>(criteriaByLockIds)
+            val resultsByLockIds = vaultService.queryBy<ContractState>(criteriaByLockIds)
             assertThat(resultsByLockIds.states).hasSize(3)
 
             // unlocked and locked by `lockId2`
             val criteriaUnlockedAndByLockId = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_AND_SPECIFIED, listOf(lockId2)))
-            val resultsUnlockedAndByLockIds = vaultQuerySvc.queryBy<ContractState>(criteriaUnlockedAndByLockId)
+            val resultsUnlockedAndByLockIds = vaultService.queryBy<ContractState>(criteriaUnlockedAndByLockId)
             assertThat(resultsUnlockedAndByLockIds.states).hasSize(5)
 
             // missing lockId
             expectedEx.expect(IllegalArgumentException::class.java)
             expectedEx.expectMessage("Must specify one or more lockIds")
             val criteriaMissingLockId = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_AND_SPECIFIED))
-            vaultQuerySvc.queryBy<ContractState>(criteriaMissingLockId)
+            vaultService.queryBy<ContractState>(criteriaMissingLockId)
         }
     }
 
@@ -530,7 +529,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::currency.equal(GBP.currencyCode) }
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(1)
         }
     }
@@ -545,7 +544,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::currency.notEqual(GBP.currencyCode) }
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(2)
         }
     }
@@ -560,7 +559,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::pennies.greaterThan(1000L) }
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(1)
         }
     }
@@ -575,7 +574,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::pennies.greaterThanOrEqual(1000L) }
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(2)
         }
     }
@@ -590,7 +589,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::pennies.lessThan(1000L) }
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(1)
         }
     }
@@ -605,7 +604,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::pennies.lessThanOrEqual(1000L) }
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(2)
         }
     }
@@ -620,7 +619,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::pennies.between(500L, 1500L) }
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(1)
         }
     }
@@ -636,7 +635,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val currencies = listOf(CHF.currencyCode, GBP.currencyCode)
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::currency.`in`(currencies) }
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(2)
         }
     }
@@ -652,7 +651,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val currencies = listOf(CHF.currencyCode, GBP.currencyCode)
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::currency.notIn(currencies) }
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(1)
         }
     }
@@ -667,7 +666,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::currency.like("%BP") }  // GPB
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(1)
         }
     }
@@ -682,7 +681,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::currency.notLike("%BP") }  // GPB
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(2)
         }
     }
@@ -697,7 +696,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::issuerParty.isNull() }
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(0)
         }
     }
@@ -712,7 +711,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val logicalExpression = builder { CashSchemaV1.PersistentCashState::issuerParty.notNull() }
             val criteria = VaultCustomQueryCriteria(logicalExpression)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(3)
         }
     }
@@ -743,7 +742,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val avg = builder { CashSchemaV1.PersistentCashState::pennies.avg() }
             val avgCriteria = VaultCustomQueryCriteria(avg)
 
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>(sumCriteria
+            val results = vaultService.queryBy<FungibleAsset<*>>(sumCriteria
                     .and(countCriteria)
                     .and(maxCriteria)
                     .and(minCriteria)
@@ -782,7 +781,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val avg = builder { CashSchemaV1.PersistentCashState::pennies.avg(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency)) }
             val avgCriteria = VaultCustomQueryCriteria(avg)
 
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>(sumCriteria
+            val results = vaultService.queryBy<FungibleAsset<*>>(sumCriteria
                     .and(maxCriteria)
                     .and(minCriteria)
                     .and(avgCriteria))
@@ -837,7 +836,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
                         orderBy = Sort.Direction.DESC)
             }
 
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>(VaultCustomQueryCriteria(sum))
+            val results = vaultService.queryBy<FungibleAsset<*>>(VaultCustomQueryCriteria(sum))
             // DOCEND VaultQueryExample23
 
             assertThat(results.otherResults).hasSize(12)
@@ -871,15 +870,15 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             // count fungible assets
             val count = builder { VaultSchemaV1.VaultStates::recordedTime.count() }
             val countCriteria = QueryCriteria.VaultCustomQueryCriteria(count)
-            val fungibleStateCount = vaultQuerySvc.queryBy<FungibleAsset<*>>(countCriteria).otherResults.single() as Long
+            val fungibleStateCount = vaultService.queryBy<FungibleAsset<*>>(countCriteria).otherResults.single() as Long
             assertThat(fungibleStateCount).isEqualTo(10L)
 
             // count linear states
-            val linearStateCount = vaultQuerySvc.queryBy<LinearState>(countCriteria).otherResults.single() as Long
+            val linearStateCount = vaultService.queryBy<LinearState>(countCriteria).otherResults.single() as Long
             assertThat(linearStateCount).isEqualTo(9L)
 
             // count deal states
-            val dealStateCount = vaultQuerySvc.queryBy<DealState>(countCriteria).otherResults.single() as Long
+            val dealStateCount = vaultService.queryBy<DealState>(countCriteria).otherResults.single() as Long
             assertThat(dealStateCount).isEqualTo(3L)
         }
     }
@@ -900,15 +899,15 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             // count fungible assets
             val countCriteria = QueryCriteria.VaultCustomQueryCriteria(count, Vault.StateStatus.ALL)
-            val fungibleStateCount = vaultQuerySvc.queryBy<FungibleAsset<*>>(countCriteria).otherResults.single() as Long
+            val fungibleStateCount = vaultService.queryBy<FungibleAsset<*>>(countCriteria).otherResults.single() as Long
             assertThat(fungibleStateCount).isEqualTo(10L)
 
             // count linear states
-            val linearStateCount = vaultQuerySvc.queryBy<LinearState>(countCriteria).otherResults.single() as Long
+            val linearStateCount = vaultService.queryBy<LinearState>(countCriteria).otherResults.single() as Long
             assertThat(linearStateCount).isEqualTo(9L)
 
             // count deal states
-            val dealStateCount = vaultQuerySvc.queryBy<DealState>(countCriteria).otherResults.single() as Long
+            val dealStateCount = vaultService.queryBy<DealState>(countCriteria).otherResults.single() as Long
             assertThat(dealStateCount).isEqualTo(3L)
         }
         val cashUpdates =
@@ -924,30 +923,30 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             // count fungible assets
             val countCriteriaUnconsumed = QueryCriteria.VaultCustomQueryCriteria(count, Vault.StateStatus.UNCONSUMED)
-            val fungibleStateCountUnconsumed = vaultQuerySvc.queryBy<FungibleAsset<*>>(countCriteriaUnconsumed).otherResults.single() as Long
+            val fungibleStateCountUnconsumed = vaultService.queryBy<FungibleAsset<*>>(countCriteriaUnconsumed).otherResults.single() as Long
             assertThat(fungibleStateCountUnconsumed.toInt()).isEqualTo(10 - cashUpdates.consumed.size + cashUpdates.produced.size)
 
             // count linear states
-            val linearStateCountUnconsumed = vaultQuerySvc.queryBy<LinearState>(countCriteriaUnconsumed).otherResults.single() as Long
+            val linearStateCountUnconsumed = vaultService.queryBy<LinearState>(countCriteriaUnconsumed).otherResults.single() as Long
             assertThat(linearStateCountUnconsumed).isEqualTo(5L)
 
             // count deal states
-            val dealStateCountUnconsumed = vaultQuerySvc.queryBy<DealState>(countCriteriaUnconsumed).otherResults.single() as Long
+            val dealStateCountUnconsumed = vaultService.queryBy<DealState>(countCriteriaUnconsumed).otherResults.single() as Long
             assertThat(dealStateCountUnconsumed).isEqualTo(2L)
 
             // CONSUMED states
 
             // count fungible assets
             val countCriteriaConsumed = QueryCriteria.VaultCustomQueryCriteria(count, Vault.StateStatus.CONSUMED)
-            val fungibleStateCountConsumed = vaultQuerySvc.queryBy<FungibleAsset<*>>(countCriteriaConsumed).otherResults.single() as Long
+            val fungibleStateCountConsumed = vaultService.queryBy<FungibleAsset<*>>(countCriteriaConsumed).otherResults.single() as Long
             assertThat(fungibleStateCountConsumed.toInt()).isEqualTo(cashUpdates.consumed.size)
 
             // count linear states
-            val linearStateCountConsumed = vaultQuerySvc.queryBy<LinearState>(countCriteriaConsumed).otherResults.single() as Long
+            val linearStateCountConsumed = vaultService.queryBy<LinearState>(countCriteriaConsumed).otherResults.single() as Long
             assertThat(linearStateCountConsumed).isEqualTo(4L)
 
             // count deal states
-            val dealStateCountConsumed = vaultQuerySvc.queryBy<DealState>(countCriteriaConsumed).otherResults.single() as Long
+            val dealStateCountConsumed = vaultService.queryBy<DealState>(countCriteriaConsumed).otherResults.single() as Long
             assertThat(dealStateCountConsumed).isEqualTo(1L)
         }
     }
@@ -967,7 +966,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
                     QueryCriteria.TimeInstantType.RECORDED,
                     ColumnPredicate.Between(start, end))
             val criteria = VaultQueryCriteria(timeCondition = recordedBetweenExpression)
-            val results = vaultQuerySvc.queryBy<ContractState>(criteria)
+            val results = vaultService.queryBy<ContractState>(criteria)
             // DOCEND VaultQueryExample6
             assertThat(results.states).hasSize(3)
 
@@ -976,7 +975,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val recordedBetweenExpressionFuture = TimeCondition(
                     QueryCriteria.TimeInstantType.RECORDED, ColumnPredicate.Between(startFuture, end))
             val criteriaFuture = VaultQueryCriteria(timeCondition = recordedBetweenExpressionFuture)
-            assertThat(vaultQuerySvc.queryBy<ContractState>(criteriaFuture).states).isEmpty()
+            assertThat(vaultService.queryBy<ContractState>(criteriaFuture).states).isEmpty()
         }
     }
 
@@ -996,7 +995,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
                     QueryCriteria.TimeInstantType.CONSUMED, ColumnPredicate.BinaryComparison(BinaryComparisonOperator.GREATER_THAN_OR_EQUAL, asOfDateTime))
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED,
                     timeCondition = consumedAfterExpression)
-            val results = vaultQuerySvc.queryBy<ContractState>(criteria)
+            val results = vaultService.queryBy<ContractState>(criteria)
 
             assertThat(results.states).hasSize(3)
         }
@@ -1012,7 +1011,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             // DOCSTART VaultQueryExample7
             val pagingSpec = PageSpecification(DEFAULT_PAGE_NUM, 10)
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
-            val results = vaultQuerySvc.queryBy<ContractState>(criteria, paging = pagingSpec)
+            val results = vaultService.queryBy<ContractState>(criteria, paging = pagingSpec)
             // DOCEND VaultQueryExample7
             assertThat(results.states).hasSize(10)
             assertThat(results.totalStatesAvailable).isEqualTo(100)
@@ -1031,7 +1030,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val pagingSpec = PageSpecification(10, 10)
 
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
-            val results = vaultQuerySvc.queryBy<ContractState>(criteria, paging = pagingSpec)
+            val results = vaultService.queryBy<ContractState>(criteria, paging = pagingSpec)
             assertThat(results.states).hasSize(5) // should retrieve states 90..94
             assertThat(results.totalStatesAvailable).isEqualTo(95)
         }
@@ -1050,7 +1049,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val pagingSpec = PageSpecification(0, 10)
 
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
-            vaultQuerySvc.queryBy<ContractState>(criteria, paging = pagingSpec)
+            vaultService.queryBy<ContractState>(criteria, paging = pagingSpec)
         }
     }
 
@@ -1067,7 +1066,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             @Suppress("EXPECTED_CONDITION")
             val pagingSpec = PageSpecification(DEFAULT_PAGE_NUM, @Suppress("INTEGER_OVERFLOW")MAX_PAGE_SIZE + 1)  // overflow = -2147483648
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
-            vaultQuerySvc.queryBy<ContractState>(criteria, paging = pagingSpec)
+            vaultService.queryBy<ContractState>(criteria, paging = pagingSpec)
         }
     }
 
@@ -1082,7 +1081,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
-            vaultQuerySvc.queryBy<ContractState>(criteria)
+            vaultService.queryBy<ContractState>(criteria)
         }
     }
 
@@ -1098,7 +1097,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val sortCol2 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.STATE_STATUS), Sort.Direction.ASC)
             val sortCol3 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.CONSUMED_TIME), Sort.Direction.DESC)
             val sorting = Sort(setOf(sortCol1, sortCol2, sortCol3))
-            val result = vaultQuerySvc.queryBy<ContractState>(VaultQueryCriteria(status = Vault.StateStatus.ALL), sorting = sorting)
+            val result = vaultService.queryBy<ContractState>(VaultQueryCriteria(status = Vault.StateStatus.ALL), sorting = sorting)
 
             val states = result.states
             val metadata = result.statesMetadata
@@ -1123,7 +1122,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             services.fillWithSomeTestLinearStates(10)
         }
         database.transaction {
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>()
+            val results = vaultService.queryBy<FungibleAsset<*>>()
             assertThat(results.states).hasSize(4)
         }
     }
@@ -1142,7 +1141,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>(criteria)
+            val results = vaultService.queryBy<FungibleAsset<*>>(criteria)
             assertThat(results.states).hasSize(2)
         }
     }
@@ -1154,7 +1153,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             services.fillWithSomeTestLinearStates(10)
         }
         database.transaction {
-            val results = vaultQuerySvc.queryBy<Cash.State>()
+            val results = vaultService.queryBy<Cash.State>()
             assertThat(results.states).hasSize(3)
         }
     }
@@ -1169,7 +1168,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         // should now have x2 CONSUMED + x2 UNCONSUMED (one spent + one change)
         database.transaction {
-            val results = vaultQuerySvc.queryBy<Cash.State>(FungibleAssetQueryCriteria())
+            val results = vaultService.queryBy<Cash.State>(FungibleAssetQueryCriteria())
             assertThat(results.statesMetadata).hasSize(2)
             assertThat(results.states).hasSize(2)
         }
@@ -1192,7 +1191,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
-            val results = vaultQuerySvc.queryBy<Cash.State>(criteria)
+            val results = vaultService.queryBy<Cash.State>(criteria)
             assertThat(results.states).hasSize(2)
         }
     }
@@ -1205,7 +1204,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             services.fillWithSomeTestDeals(listOf("123", "456", "789"))
         }
         database.transaction {
-            val results = vaultQuerySvc.queryBy<LinearState>()
+            val results = vaultService.queryBy<LinearState>()
             assertThat(results.states).hasSize(13)
         }
     }
@@ -1224,7 +1223,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
-            val results = vaultQuerySvc.queryBy<LinearState>(criteria)
+            val results = vaultService.queryBy<LinearState>(criteria)
             assertThat(results.states).hasSize(3)
         }
     }
@@ -1241,7 +1240,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             // DOCSTART VaultQueryExample8
             val linearIds = issuedStates.states.map { it.state.data.linearId }.toList()
             val criteria = LinearStateQueryCriteria(linearId = listOf(linearIds.first(), linearIds.last()))
-            val results = vaultQuerySvc.queryBy<LinearState>(criteria)
+            val results = vaultService.queryBy<LinearState>(criteria)
             // DOCEND VaultQueryExample8
             assertThat(results.states).hasSize(2)
         }
@@ -1259,7 +1258,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val linearIds = listOf(linearState1.states.first().state.data.linearId, linearState3.states.first().state.data.linearId)
             val criteria = LinearStateQueryCriteria(linearId = linearIds)
-            val results = vaultQuerySvc.queryBy<LinearState>(criteria)
+            val results = vaultService.queryBy<LinearState>(criteria)
             assertThat(results.states).hasSize(2)
         }
     }
@@ -1276,7 +1275,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val externalIds = listOf(linearState1.states.first().state.data.linearId.externalId!!, linearState3.states.first().state.data.linearId.externalId!!)
             val criteria = LinearStateQueryCriteria(externalId = externalIds)
-            val results = vaultQuerySvc.queryBy<LinearState>(criteria)
+            val results = vaultService.queryBy<LinearState>(criteria)
             assertThat(results.states).hasSize(2)
         }
     }
@@ -1297,7 +1296,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             // DOCSTART VaultQueryExample9
             val linearStateCriteria = LinearStateQueryCriteria(linearId = listOf(linearId), status = Vault.StateStatus.ALL)
             val vaultCriteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
-            val results = vaultQuerySvc.queryBy<LinearState>(linearStateCriteria and vaultCriteria)
+            val results = vaultService.queryBy<LinearState>(linearStateCriteria and vaultCriteria)
             // DOCEND VaultQueryExample9
             assertThat(results.states).hasSize(4)
         }
@@ -1320,7 +1319,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val vaultCriteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
             val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.UUID), Sort.Direction.DESC)))
 
-            val results = vaultQuerySvc.queryBy<LinearState>(linearStateCriteria.and(vaultCriteria), sorting = sorting)
+            val results = vaultService.queryBy<LinearState>(linearStateCriteria.and(vaultCriteria), sorting = sorting)
             results.states.forEach { println("${it.state.data.linearId.id}") }
             assertThat(results.states).hasSize(8)
         }
@@ -1337,7 +1336,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val vaultCriteria = VaultQueryCriteria()
             val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.EXTERNAL_ID), Sort.Direction.DESC)))
 
-            val results = vaultQuerySvc.queryBy<DummyLinearContract.State>((vaultCriteria), sorting = sorting)
+            val results = vaultService.queryBy<DummyLinearContract.State>((vaultCriteria), sorting = sorting)
             results.states.forEach { println(it.state.data.linearString) }
             assertThat(results.states).hasSize(6)
         }
@@ -1358,7 +1357,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
 
             val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.EXTERNAL_ID), Sort.Direction.DESC)))
 
-            val results = vaultQuerySvc.queryBy<LinearState>(compositeCriteria, sorting = sorting)
+            val results = vaultService.queryBy<LinearState>(compositeCriteria, sorting = sorting)
             assertThat(results.statesMetadata).hasSize(4)
             assertThat(results.states).hasSize(4)
         }
@@ -1375,7 +1374,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val vaultCriteria = VaultQueryCriteria()
             val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Custom(DummyLinearStateSchemaV1.PersistentDummyLinearState::class.java, "linearString"), Sort.Direction.DESC)))
 
-            val results = vaultQuerySvc.queryBy<DummyLinearContract.State>((vaultCriteria), sorting = sorting)
+            val results = vaultService.queryBy<DummyLinearContract.State>((vaultCriteria), sorting = sorting)
             results.states.forEach { println(it.state.data.linearString) }
             assertThat(results.states).hasSize(6)
         }
@@ -1397,7 +1396,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val linearStateCriteria = LinearStateQueryCriteria(linearId = txns.states.map { it.state.data.linearId }, status = Vault.StateStatus.CONSUMED)
             val vaultCriteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
             val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.UUID), Sort.Direction.DESC)))
-            val results = vaultQuerySvc.queryBy<LinearState>(linearStateCriteria.and(vaultCriteria), sorting = sorting)
+            val results = vaultService.queryBy<LinearState>(linearStateCriteria.and(vaultCriteria), sorting = sorting)
             assertThat(results.states).hasSize(3)
         }
     }
@@ -1411,7 +1410,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             services.fillWithSomeTestDeals(listOf("123", "456", "789"))
         }
         database.transaction {
-            val results = vaultQuerySvc.queryBy<DealState>()
+            val results = vaultService.queryBy<DealState>()
             assertThat(results.states).hasSize(3)
         }
     }
@@ -1424,7 +1423,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             // DOCSTART VaultQueryExample10
             val criteria = LinearStateQueryCriteria(externalId = listOf("456", "789"))
-            val results = vaultQuerySvc.queryBy<DealState>(criteria)
+            val results = vaultService.queryBy<DealState>(criteria)
             // DOCEND VaultQueryExample10
 
             assertThat(results.states).hasSize(2)
@@ -1439,11 +1438,11 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             services.fillWithSomeTestDeals(listOf("123", "789"))
         }
         database.transaction {
-            val all = vaultQuerySvc.queryBy<DealState>()
+            val all = vaultService.queryBy<DealState>()
             all.states.forEach { println(it.state) }
 
             val criteria = LinearStateQueryCriteria(externalId = listOf("456"))
-            val results = vaultQuerySvc.queryBy<DealState>(criteria)
+            val results = vaultService.queryBy<DealState>(criteria)
             assertThat(results.states).hasSize(1)
         }
     }
@@ -1459,7 +1458,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             // DOCSTART VaultQueryExample11
             val criteria = LinearStateQueryCriteria(participants = parties)
-            val results = vaultQuerySvc.queryBy<DealState>(criteria)
+            val results = vaultService.queryBy<DealState>(criteria)
             // DOCEND VaultQueryExample11
 
             assertThat(results.states).hasSize(1)
@@ -1481,7 +1480,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val criteria = FungibleAssetQueryCriteria(issuer = listOf(BOC),
                     issuerRef = listOf(BOC.ref(1).reference, BOC.ref(2).reference))
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>(criteria)
+            val results = vaultService.queryBy<FungibleAsset<*>>(criteria)
             assertThat(results.states).hasSize(2)
         }
     }
@@ -1509,7 +1508,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val criteria = FungibleAssetQueryCriteria(issuer = listOf(gbpCashIssuer.party, usdCashIssuer.party))
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>(criteria)
+            val results = vaultService.queryBy<FungibleAsset<*>>(criteria)
             assertThat(results.states).hasSize(2)
         }
     }
@@ -1523,7 +1522,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val criteria = FungibleAssetQueryCriteria(owner = listOf(MEGA_CORP))
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>(criteria)
+            val results = vaultService.queryBy<FungibleAsset<*>>(criteria)
             assertThat(results.states).hasSize(1)   // can only be 1 owner of a node (MEGA_CORP in this MockServices setup)
         }
     }
@@ -1540,7 +1539,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             // DOCSTART VaultQueryExample5.2
             val criteria = FungibleAssetQueryCriteria(owner = listOf(MEGA_CORP, BOC))
-            val results = vaultQuerySvc.queryBy<ContractState>(criteria)
+            val results = vaultService.queryBy<ContractState>(criteria)
             // DOCEND VaultQueryExample5.2
 
             assertThat(results.states).hasSize(2)   // can only be 1 owner of a node (MEGA_CORP in this MockServices setup)
@@ -1560,7 +1559,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             // DOCSTART VaultQueryExample12
             val ccyIndex = builder { CashSchemaV1.PersistentCashState::currency.equal(USD.currencyCode) }
             val criteria = VaultCustomQueryCriteria(ccyIndex)
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>(criteria)
+            val results = vaultService.queryBy<FungibleAsset<*>>(criteria)
             // DOCEND VaultQueryExample12
 
             assertThat(results.states).hasSize(3)
@@ -1580,7 +1579,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val ccyIndex = builder { CashSchemaV1.PersistentCashState::currency.equal(USD.currencyCode) }
             val ccyCriteria = VaultCustomQueryCriteria(ccyIndex)
 
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>(sumCriteria.and(ccyCriteria))
+            val results = vaultService.queryBy<FungibleAsset<*>>(sumCriteria.and(ccyCriteria))
 
             assertThat(results.otherResults).hasSize(2)
             assertThat(results.otherResults[0]).isEqualTo(30000L)
@@ -1601,7 +1600,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             val ccyIndex = builder { CashSchemaV1.PersistentCashState::pennies.sum(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency)) }
             val criteria = VaultCustomQueryCriteria(ccyIndex)
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>(criteria)
+            val results = vaultService.queryBy<FungibleAsset<*>>(criteria)
 
             assertThat(results.otherResults).hasSize(6)
             assertThat(results.otherResults[0]).isEqualTo(110000L)
@@ -1624,7 +1623,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             // DOCSTART VaultQueryExample13
             val fungibleAssetCriteria = FungibleAssetQueryCriteria(quantity = builder { greaterThan(2500L) })
-            val results = vaultQuerySvc.queryBy<Cash.State>(fungibleAssetCriteria)
+            val results = vaultService.queryBy<Cash.State>(fungibleAssetCriteria)
             // DOCEND VaultQueryExample13
 
             assertThat(results.states).hasSize(4)  // POUNDS, SWISS_FRANCS
@@ -1642,7 +1641,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         database.transaction {
             // DOCSTART VaultQueryExample14
             val criteria = FungibleAssetQueryCriteria(issuer = listOf(BOC))
-            val results = vaultQuerySvc.queryBy<FungibleAsset<*>>(criteria)
+            val results = vaultService.queryBy<FungibleAsset<*>>(criteria)
             // DOCEND VaultQueryExample14
 
             assertThat(results.states).hasSize(1)
@@ -1661,7 +1660,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val ccyIndex = builder { CashSchemaV1.PersistentCashState::currency.equal(GBP.currencyCode) }
             val customCriteria = VaultCustomQueryCriteria(ccyIndex)
             val fungibleAssetCriteria = FungibleAssetQueryCriteria(quantity = builder { greaterThan(5000L) })
-            val results = vaultQuerySvc.queryBy<Cash.State>(fungibleAssetCriteria.and(customCriteria))
+            val results = vaultService.queryBy<Cash.State>(fungibleAssetCriteria.and(customCriteria))
 
             assertThat(results.states).hasSize(1)   // POUNDS > 50
         }
@@ -1700,7 +1699,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val ccyIndex = builder { CommercialPaperSchemaV1.PersistentCommercialPaperState::currency.equal(USD.currencyCode) }
             val criteria1 = QueryCriteria.VaultCustomQueryCriteria(ccyIndex)
 
-            val result = vaultQuerySvc.queryBy<CommercialPaper.State>(criteria1)
+            val result = vaultService.queryBy<CommercialPaper.State>(criteria1)
 
             Assertions.assertThat(result.states).hasSize(1)
             Assertions.assertThat(result.statesMetadata).hasSize(1)
@@ -1746,7 +1745,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
                 val criteria2 = QueryCriteria.VaultCustomQueryCriteria(maturityIndex)
                 val criteria3 = QueryCriteria.VaultCustomQueryCriteria(faceValueIndex)
 
-                vaultQuerySvc.queryBy<CommercialPaper.State>(criteria1.and(criteria3).and(criteria2))
+                vaultService.queryBy<CommercialPaper.State>(criteria1.and(criteria3).and(criteria2))
             }
             Assertions.assertThat(result.states).hasSize(1)
             Assertions.assertThat(result.statesMetadata).hasSize(1)
@@ -1766,7 +1765,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val criteria = VaultCustomQueryCriteria(logicalExpression)
 
             assertThatThrownBy {
-                vaultQuerySvc.queryBy<Cash.State>(criteria)
+                vaultService.queryBy<Cash.State>(criteria)
             }.isInstanceOf(VaultQueryException::class.java).hasMessageContaining("Please register the entity")
         }
     }
@@ -1794,7 +1793,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
                 val customCriteria2 = VaultCustomQueryCriteria(quantityIndex)
 
                 val criteria = generalCriteria.and(customCriteria1.and(customCriteria2))
-                vaultQuerySvc.queryBy<Cash.State>(criteria)
+                vaultService.queryBy<Cash.State>(criteria)
             }
             // DOCEND VaultQueryExample20
 
@@ -1819,7 +1818,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val recordedBetweenExpression = TimeCondition(TimeInstantType.RECORDED, builder { between(start, end) })
             val basicCriteria = VaultQueryCriteria(timeCondition = recordedBetweenExpression)
 
-            val results = vaultQuerySvc.queryBy<LinearState>(basicCriteria)
+            val results = vaultService.queryBy<LinearState>(basicCriteria)
 
             assertThat(results.states).hasSize(1)
         }
@@ -1837,7 +1836,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val externalIdCondition = builder { VaultSchemaV1.VaultLinearStates::externalId.equal("TEST2") }
             val externalIdCustomCriteria = VaultCustomQueryCriteria(externalIdCondition)
 
-            val results = vaultQuerySvc.queryBy<LinearState>(externalIdCustomCriteria)
+            val results = vaultService.queryBy<LinearState>(externalIdCustomCriteria)
 
             assertThat(results.states).hasSize(1)
         }
@@ -1866,7 +1865,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
                 val basicCriteria = VaultQueryCriteria(timeCondition = recordedBetweenExpression)
 
                 val criteria = basicCriteria.and(customCriteria)
-                vaultQuerySvc.queryBy<LinearState>(criteria)
+                vaultService.queryBy<LinearState>(criteria)
             }
 
             assertThat(results.states).hasSize(1)
@@ -1894,7 +1893,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
                 val uuidCustomCriteria = VaultCustomQueryCriteria(uuidCondition)
 
                 val criteria = externalIdCustomCriteria or uuidCustomCriteria
-                vaultQuerySvc.queryBy<LinearState>(criteria)
+                vaultService.queryBy<LinearState>(criteria)
             }
             assertThat(results.statesMetadata).hasSize(2)
             assertThat(results.states).hasSize(2)
@@ -1911,7 +1910,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val linearStateCriteria = LinearStateQueryCriteria(participants = listOf(ALICE))
-            val results = vaultQuerySvc.queryBy<LinearState>(linearStateCriteria)
+            val results = vaultService.queryBy<LinearState>(linearStateCriteria)
 
             assertThat(results.states).hasSize(1)
             assertThat(results.states[0].state.data.linearId.externalId).isEqualTo("TEST1")
@@ -1931,7 +1930,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             val linearStateCriteria = LinearStateQueryCriteria(participants = listOf(ALICE, BOB, CHARLIE))
-            val results = vaultQuerySvc.queryBy<LinearState>(linearStateCriteria)
+            val results = vaultService.queryBy<LinearState>(linearStateCriteria)
 
             assertThat(results.states).hasSize(1)
             assertThat(results.states[0].state.data.linearId.externalId).isEqualTo("TEST1")
@@ -1952,7 +1951,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
                 val externalIdCondition = VaultSchemaV1.VaultLinearStates::externalId.isNull()
                 val externalIdCustomCriteria = VaultCustomQueryCriteria(externalIdCondition)
 
-                vaultQuerySvc.queryBy<LinearState>(externalIdCustomCriteria)
+                vaultService.queryBy<LinearState>(externalIdCustomCriteria)
             }
             assertThat(results.states).hasSize(1)
         }
@@ -1972,7 +1971,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
                 val externalIdCondition = VaultSchemaV1.VaultLinearStates::externalId.notNull()
                 val externalIdCustomCriteria = VaultCustomQueryCriteria(externalIdCondition)
 
-                vaultQuerySvc.queryBy<LinearState>(externalIdCustomCriteria)
+                vaultService.queryBy<LinearState>(externalIdCustomCriteria)
             }
             assertThat(results.states).hasSize(2)
         }
@@ -2001,7 +2000,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
             val sorter = Sort(setOf(Sort.SortColumn(sortAttribute, Sort.Direction.ASC)))
 
             // Execute query
-            val results = services.vaultQueryService.queryBy<FungibleAsset<*>>(baseCriteria and enrichedCriteria, sorter).states
+            val results = services.vaultService.queryBy<FungibleAsset<*>>(baseCriteria and enrichedCriteria, sorter).states
             assertThat(results).hasSize(4)
         }
     }
@@ -2015,7 +2014,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         val updates =
                 database.transaction {
                     // DOCSTART VaultQueryExample15
-                    vaultQuerySvc.trackBy<Cash.State>().updates     // UNCONSUMED default
+                    vaultService.trackBy<Cash.State>().updates     // UNCONSUMED default
                     // DOCEND VaultQueryExample15
                 }
         val (linearStates, dealStates) =
@@ -2057,7 +2056,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         val updates =
                 database.transaction {
                     val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
-                    vaultQuerySvc.trackBy<Cash.State>(criteria).updates
+                    vaultService.trackBy<Cash.State>(criteria).updates
                 }
         val (linearStates, dealStates) =
                 database.transaction {
@@ -2103,7 +2102,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         val updates =
                 database.transaction {
                     val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
-                    vaultQuerySvc.trackBy<Cash.State>(criteria).updates
+                    vaultService.trackBy<Cash.State>(criteria).updates
                 }
         val (linearStates, dealStates) =
                 database.transaction {
@@ -2158,7 +2157,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         val updates =
                 database.transaction {
                     // DOCSTART VaultQueryExample16
-                    val (snapshot, updates) = vaultQuerySvc.trackBy<LinearState>()
+                    val (snapshot, updates) = vaultService.trackBy<LinearState>()
                     // DOCEND VaultQueryExample16
                     assertThat(snapshot.states).hasSize(0)
                     updates
@@ -2207,7 +2206,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         val updates =
                 database.transaction {
                     // DOCSTART VaultQueryExample17
-                    val (snapshot, updates) = vaultQuerySvc.trackBy<DealState>()
+                    val (snapshot, updates) = vaultService.trackBy<DealState>()
                     // DOCEND VaultQueryExample17
                     assertThat(snapshot.states).hasSize(0)
                     updates
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
index 9c969f0950..a1450132a5 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
@@ -1,11 +1,10 @@
-package net.corda.node.services.vault
+package net.corda.node.services.vaultService
 
 import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.LinearState
 import net.corda.core.contracts.UniqueIdentifier
 import net.corda.core.identity.AnonymousParty
 import net.corda.core.node.services.Vault
-import net.corda.core.node.services.VaultQueryService
 import net.corda.core.node.services.VaultService
 import net.corda.core.node.services.queryBy
 import net.corda.core.node.services.vault.QueryCriteria
@@ -37,8 +36,7 @@ import kotlin.test.assertEquals
 class VaultWithCashTest : TestDependencyInjectionBase() {
     lateinit var services: MockServices
     lateinit var issuerServices: MockServices
-    val vault: VaultService get() = services.vaultService
-    val vaultQuery: VaultQueryService get() = services.vaultQueryService
+    val vaultService: VaultService get() = services.vaultService
     lateinit var database: CordaPersistence
     lateinit var notaryServices: MockServices
 
@@ -69,7 +67,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 3, 3, Random(0L), issuedBy = DUMMY_CASH_ISSUER)
         }
         database.transaction {
-            val w = vaultQuery.queryBy<Cash.State>().states
+            val w = vaultService.queryBy<Cash.State>().states
             assertEquals(3, w.size)
 
             val state = w[0].state.data
@@ -141,8 +139,8 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
             println("Cash balance: ${services.getCashBalance(USD)}")
         }
         database.transaction {
-            assertThat(vaultQuery.queryBy<Cash.State>().states).hasSize(10)
-            assertThat(vaultQuery.queryBy<Cash.State>(criteriaLocked).states).hasSize(0)
+            assertThat(vaultService.queryBy<Cash.State>().states).hasSize(10)
+            assertThat(vaultService.queryBy<Cash.State>(criteriaLocked).states).hasSize(0)
         }
 
         val backgroundExecutor = Executors.newFixedThreadPool(2)
@@ -157,9 +155,9 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
                     val ptxn1 = notaryServices.signInitialTransaction(txn1Builder)
                     val txn1 = services.addSignature(ptxn1, freshKey)
                     println("txn1: ${txn1.id} spent ${((txn1.tx.outputs[0].data) as Cash.State).amount}")
-                    val unconsumedStates1 = vaultQuery.queryBy<Cash.State>()
-                    val consumedStates1 = vaultQuery.queryBy<Cash.State>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED))
-                    val lockedStates1 = vaultQuery.queryBy<Cash.State>(criteriaLocked).states
+                    val unconsumedStates1 = vaultService.queryBy<Cash.State>()
+                    val consumedStates1 = vaultService.queryBy<Cash.State>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED))
+                    val lockedStates1 = vaultService.queryBy<Cash.State>(criteriaLocked).states
                     println("""txn1 states:
                                 UNCONSUMED: ${unconsumedStates1.totalStatesAvailable} : $unconsumedStates1,
                                 CONSUMED: ${consumedStates1.totalStatesAvailable} : $consumedStates1,
@@ -167,9 +165,9 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
                     """)
                     services.recordTransactions(txn1)
                     println("txn1: Cash balance: ${services.getCashBalance(USD)}")
-                    val unconsumedStates2 = vaultQuery.queryBy<Cash.State>()
-                    val consumedStates2 = vaultQuery.queryBy<Cash.State>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED))
-                    val lockedStates2 = vaultQuery.queryBy<Cash.State>(criteriaLocked).states
+                    val unconsumedStates2 = vaultService.queryBy<Cash.State>()
+                    val consumedStates2 = vaultService.queryBy<Cash.State>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED))
+                    val lockedStates2 = vaultService.queryBy<Cash.State>(criteriaLocked).states
                     println("""txn1 states:
                                 UNCONSUMED: ${unconsumedStates2.totalStatesAvailable} : $unconsumedStates2,
                                 CONSUMED: ${consumedStates2.totalStatesAvailable} : $consumedStates2,
@@ -193,9 +191,9 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
                     val ptxn2 = notaryServices.signInitialTransaction(txn2Builder)
                     val txn2 = services.addSignature(ptxn2, freshKey)
                     println("txn2: ${txn2.id} spent ${((txn2.tx.outputs[0].data) as Cash.State).amount}")
-                    val unconsumedStates1 = vaultQuery.queryBy<Cash.State>()
-                    val consumedStates1 = vaultQuery.queryBy<Cash.State>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED))
-                    val lockedStates1 = vaultQuery.queryBy<Cash.State>(criteriaLocked).states
+                    val unconsumedStates1 = vaultService.queryBy<Cash.State>()
+                    val consumedStates1 = vaultService.queryBy<Cash.State>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED))
+                    val lockedStates1 = vaultService.queryBy<Cash.State>(criteriaLocked).states
                     println("""txn2 states:
                                 UNCONSUMED: ${unconsumedStates1.totalStatesAvailable} : $unconsumedStates1,
                                 CONSUMED: ${consumedStates1.totalStatesAvailable} : $consumedStates1,
@@ -203,9 +201,9 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
                     """)
                     services.recordTransactions(txn2)
                     println("txn2: Cash balance: ${services.getCashBalance(USD)}")
-                    val unconsumedStates2 = vaultQuery.queryBy<Cash.State>()
-                    val consumedStates2 = vaultQuery.queryBy<Cash.State>()
-                    val lockedStates2 = vaultQuery.queryBy<Cash.State>(criteriaLocked).states
+                    val unconsumedStates2 = vaultService.queryBy<Cash.State>()
+                    val consumedStates2 = vaultService.queryBy<Cash.State>()
+                    val lockedStates2 = vaultService.queryBy<Cash.State>(criteriaLocked).states
                     println("""txn2 states:
                                 UNCONSUMED: ${unconsumedStates2.totalStatesAvailable} : $unconsumedStates2,
                                 CONSUMED: ${consumedStates2.totalStatesAvailable} : $consumedStates2,
@@ -269,7 +267,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
                 dummyIssue
             }
         database.transaction {
-            assertThat(vaultQuery.queryBy<DummyLinearContract.State>().states).hasSize(1)
+            assertThat(vaultService.queryBy<DummyLinearContract.State>().states).hasSize(1)
 
             // Move the same state
             val dummyMoveBuilder = TransactionBuilder(notary = DUMMY_NOTARY)
@@ -284,7 +282,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
             services.recordTransactions(dummyMove)
         }
         database.transaction {
-            assertThat(vaultQuery.queryBy<DummyLinearContract.State>().states).hasSize(1)
+            assertThat(vaultService.queryBy<DummyLinearContract.State>().states).hasSize(1)
         }
     }
 
@@ -298,14 +296,14 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestCash(100.POUNDS, issuerServices, DUMMY_NOTARY, 1, 1, Random(0L))
         }
         database.transaction {
-            val cash = vaultQuery.queryBy<Cash.State>().states
+            val cash = vaultService.queryBy<Cash.State>().states
             cash.forEach { println(it.state.data.amount) }
         }
         database.transaction {
             services.fillWithSomeTestDeals(listOf("123", "456", "789"))
         }
         database.transaction {
-            val deals = vaultQuery.queryBy<DummyDealContract.State>().states
+            val deals = vaultService.queryBy<DummyDealContract.State>().states
             deals.forEach { println(it.state.data.linearId.externalId!!) }
         }
 
@@ -318,10 +316,10 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
             services.recordTransactions(spendTX)
         }
         database.transaction {
-            val consumedStates = vaultQuery.queryBy<ContractState>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)).states
+            val consumedStates = vaultService.queryBy<ContractState>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)).states
             assertEquals(3, consumedStates.count())
 
-            val unconsumedStates = vaultQuery.queryBy<ContractState>().states
+            val unconsumedStates = vaultService.queryBy<ContractState>().states
             assertEquals(7, unconsumedStates.count())
         }
     }
@@ -336,13 +334,13 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
         }
         val deals =
             database.transaction {
-                vaultQuery.queryBy<DummyDealContract.State>().states
+                vaultService.queryBy<DummyDealContract.State>().states
             }
         database.transaction {
             services.fillWithSomeTestLinearStates(3)
         }
         database.transaction {
-            val linearStates = vaultQuery.queryBy<DummyLinearContract.State>().states
+            val linearStates = vaultService.queryBy<DummyLinearContract.State>().states
             linearStates.forEach { println(it.state.data.linearId) }
 
             // Create a txn consuming different contract types
@@ -359,10 +357,10 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
             services.recordTransactions(dummyMove)
         }
         database.transaction {
-            val consumedStates = vaultQuery.queryBy<ContractState>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)).states
+            val consumedStates = vaultService.queryBy<ContractState>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)).states
             assertEquals(2, consumedStates.count())
 
-            val unconsumedStates = vaultQuery.queryBy<ContractState>().states
+            val unconsumedStates = vaultService.queryBy<ContractState>().states
             assertEquals(6, unconsumedStates.count())
         }
     }
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt
index 687ccbe857..af7aae480e 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt
@@ -97,7 +97,7 @@ class IRSSimulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, laten
 
         val swaps =
                 node1.database.transaction {
-                    node1.services.vaultQueryService.queryBy<InterestRateSwap.State>().states
+                    node1.services.vaultService.queryBy<InterestRateSwap.State>().states
                 }
         val theDealRef: StateAndRef<InterestRateSwap.State> = swaps.single()
 
diff --git a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmFlow.kt b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmFlow.kt
index 56c7001682..eb1198a881 100644
--- a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmFlow.kt
+++ b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmFlow.kt
@@ -80,7 +80,7 @@ object SimmFlow {
             notary = serviceHub.networkMapCache.notaryIdentities.first() // TODO We should pass the notary as a parameter to the flow, not leave it to random choice.
 
             val criteria = LinearStateQueryCriteria(participants = listOf(otherParty))
-            val trades = serviceHub.vaultQueryService.queryBy<IRSState>(criteria).states
+            val trades = serviceHub.vaultService.queryBy<IRSState>(criteria).states
 
             val portfolio = Portfolio(trades, valuationDate)
             otherPartySession = initiateFlow(otherParty)
@@ -89,7 +89,7 @@ object SimmFlow {
             } else {
                 updatePortfolio(portfolio, existing)
             }
-            val portfolioStateRef = serviceHub.vaultQueryService.queryBy<PortfolioState>(criteria).states.first()
+            val portfolioStateRef = serviceHub.vaultService.queryBy<PortfolioState>(criteria).states.first()
 
             val state = updateValuation(portfolioStateRef)
             logger.info("SimmFlow done")
@@ -126,7 +126,7 @@ object SimmFlow {
         private fun updateValuation(stateRef: StateAndRef<PortfolioState>): RevisionedState<PortfolioState.Update> {
             logger.info("Agreeing valuations")
             val state = stateRef.state.data
-            val portfolio = serviceHub.vaultQueryService.queryBy<IRSState>(VaultQueryCriteria(stateRefs = state.portfolio)).states.toPortfolio()
+            val portfolio = serviceHub.vaultService.queryBy<IRSState>(VaultQueryCriteria(stateRefs = state.portfolio)).states.toPortfolio()
 
             val valuer = serviceHub.identityService.wellKnownPartyFromAnonymous(state.valuer)
             require(valuer != null) { "Valuer party must be known to this node" }
@@ -211,7 +211,7 @@ object SimmFlow {
         @Suspendable
         override fun call() {
             val criteria = LinearStateQueryCriteria(participants = listOf(replyToSession.counterparty))
-            val trades = serviceHub.vaultQueryService.queryBy<IRSState>(criteria).states
+            val trades = serviceHub.vaultService.queryBy<IRSState>(criteria).states
             val portfolio = Portfolio(trades)
             logger.info("SimmFlow receiver started")
             offer = replyToSession.receive<OfferMessage>().unwrap { it }
@@ -220,7 +220,7 @@ object SimmFlow {
             } else {
                 updatePortfolio(portfolio)
             }
-            val portfolioStateRef = serviceHub.vaultQueryService.queryBy<PortfolioState>(criteria).states.first()
+            val portfolioStateRef = serviceHub.vaultService.queryBy<PortfolioState>(criteria).states.first()
             updateValuation(portfolioStateRef)
         }
 
@@ -327,7 +327,7 @@ object SimmFlow {
 
         @Suspendable
         private fun updateValuation(stateRef: StateAndRef<PortfolioState>) {
-            val portfolio = serviceHub.vaultQueryService.queryBy<IRSState>(VaultQueryCriteria(stateRefs = stateRef.state.data.portfolio)).states.toPortfolio()
+            val portfolio = serviceHub.vaultService.queryBy<IRSState>(VaultQueryCriteria(stateRefs = stateRef.state.data.portfolio)).states.toPortfolio()
             val valuer = serviceHub.identityService.wellKnownPartyFromAnonymous(stateRef.state.data.valuer) ?: throw IllegalStateException("Unknown valuer party ${stateRef.state.data.valuer}")
             val valuation = agreeValuation(portfolio, offer.valuationDate, valuer)
             subFlow(object : StateRevisionFlow.Receiver<PortfolioState.Update>(replyToSession) {
diff --git a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmRevaluation.kt b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmRevaluation.kt
index 8f607163ef..599e9d4345 100644
--- a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmRevaluation.kt
+++ b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmRevaluation.kt
@@ -20,7 +20,7 @@ object SimmRevaluation {
     class Initiator(private val curStateRef: StateRef, private val valuationDate: LocalDate) : FlowLogic<Unit>() {
         @Suspendable
         override fun call() {
-            val stateAndRef = serviceHub.vaultQueryService.queryBy<PortfolioState>(VaultQueryCriteria(stateRefs = listOf(curStateRef))).states.single()
+            val stateAndRef = serviceHub.vaultService.queryBy<PortfolioState>(VaultQueryCriteria(stateRefs = listOf(curStateRef))).states.single()
             val curState = stateAndRef.state.data
             if (ourIdentity == curState.participants[0]) {
                 val otherParty = serviceHub.identityService.wellKnownPartyFromAnonymous(curState.participants[1])
diff --git a/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/flow/SellerFlow.kt b/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/flow/SellerFlow.kt
index 890885227f..2a08170192 100644
--- a/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/flow/SellerFlow.kt
+++ b/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/flow/SellerFlow.kt
@@ -40,7 +40,7 @@ class SellerFlow(private val otherParty: Party,
         progressTracker.currentStep = SELF_ISSUING
 
         val cpOwner = serviceHub.keyManagementService.freshKeyAndCert(ourIdentityAndCert, false)
-        val commercialPaper = serviceHub.vaultQueryService.queryBy(CommercialPaper.State::class.java).states.first()
+        val commercialPaper = serviceHub.vaultService.queryBy(CommercialPaper.State::class.java).states.first()
 
         progressTracker.currentStep = TRADING
 
diff --git a/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt b/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt
index b29cd52654..e3e54de6d4 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt
@@ -35,7 +35,6 @@ open class MockServiceHubInternal(
         override val database: CordaPersistence,
         override val configuration: NodeConfiguration,
         val customVault: VaultService? = null,
-        val customVaultQuery: VaultQueryService? = null,
         val keyManagement: KeyManagementService? = null,
         val network: MessagingService? = null,
         val identity: IdentityService? = MOCK_IDENTITY_SERVICE,
@@ -50,8 +49,6 @@ open class MockServiceHubInternal(
         val customTransactionVerifierService: TransactionVerifierService? = InMemoryTransactionVerifierService(2),
         override val cordappProvider: CordappProvider = CordappProviderImpl(CordappLoader.createDefault(Paths.get("."))).start(attachments)
 ) : ServiceHubInternal {
-    override val vaultQueryService: VaultQueryService
-        get() = customVaultQuery ?: throw UnsupportedOperationException()
     override val transactionVerifierService: TransactionVerifierService
         get() = customTransactionVerifierService ?: throw UnsupportedOperationException()
     override val vaultService: VaultService
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
index 73dc1f883d..7338a6c68f 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
@@ -24,7 +24,6 @@ import net.corda.node.services.persistence.InMemoryStateMachineRecordedTransacti
 import net.corda.node.services.schema.HibernateObserver
 import net.corda.node.services.schema.NodeSchemaService
 import net.corda.node.services.transactions.InMemoryTransactionVerifierService
-import net.corda.node.services.vault.HibernateVaultQueryImpl
 import net.corda.node.services.vault.NodeVaultService
 import net.corda.node.utilities.CordaPersistence
 import net.corda.node.utilities.configureDatabase
@@ -117,8 +116,6 @@ open class MockServices(cordappPackages: List<String> = emptyList(), vararg val
                         (vaultService as NodeVaultService).notifyAll(txs.map { it.tx })
                     }
 
-                    override val vaultQueryService: VaultQueryService = HibernateVaultQueryImpl(database.hibernateConfig, vaultService)
-
                     override fun jdbcSession(): Connection = database.createSession()
                 }
             }
@@ -149,7 +146,6 @@ open class MockServices(cordappPackages: List<String> = emptyList(), vararg val
 
     override val vaultService: VaultService get() = throw UnsupportedOperationException()
     override val contractUpgradeService: ContractUpgradeService get() = throw UnsupportedOperationException()
-    override val vaultQueryService: VaultQueryService get() = throw UnsupportedOperationException()
     override val networkMapCache: NetworkMapCache get() = throw UnsupportedOperationException()
     override val clock: Clock get() = Clock.systemUTC()
     override val myInfo: NodeInfo get() {
@@ -163,7 +159,7 @@ open class MockServices(cordappPackages: List<String> = emptyList(), vararg val
     lateinit var hibernatePersister: HibernateObserver
 
     fun makeVaultService(hibernateConfig: HibernateConfiguration = HibernateConfiguration( { NodeSchemaService() }, makeTestDatabaseProperties(), { identityService })): VaultService {
-        val vaultService = NodeVaultService(this)
+        val vaultService = NodeVaultService(this, hibernateConfig)
         hibernatePersister = HibernateObserver(vaultService.rawUpdates, hibernateConfig)
         return vaultService
     }

From 7a55855afbaf91c2548dd32b50a1279b20ca7aea Mon Sep 17 00:00:00 2001
From: Andrius Dagys <andrius.dagys@r3.com>
Date: Tue, 26 Sep 2017 19:25:29 +0100
Subject: [PATCH 020/185] Fix validating notary flow to handle notary change
 transactions properly. Add a notary change test for checking longer chains
 involving both regular and notary change transactions.

---
 .../net/corda/docs/CustomNotaryTutorial.kt    |  22 ++--
 .../transactions/ValidatingNotaryFlow.kt      |  26 +++--
 .../corda/node/services/NotaryChangeTests.kt  | 102 ++++++++++++------
 3 files changed, 101 insertions(+), 49 deletions(-)

diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
index 3f56cb0a56..bf1e504bf3 100644
--- a/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
@@ -1,13 +1,14 @@
 package net.corda.docs
 
 import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.contracts.TimeWindow
 import net.corda.core.contracts.TransactionVerificationException
 import net.corda.core.flows.*
 import net.corda.core.node.ServiceHub
 import net.corda.core.node.services.CordaService
 import net.corda.core.node.services.TimeWindowChecker
 import net.corda.core.node.services.TrustedAuthorityNotaryService
-import net.corda.core.transactions.SignedTransaction
+import net.corda.core.transactions.TransactionWithSignatures
 import net.corda.node.services.transactions.PersistentUniquenessProvider
 import java.security.PublicKey
 import java.security.SignatureException
@@ -35,10 +36,17 @@ class MyValidatingNotaryFlow(otherSide: FlowSession, service: MyCustomValidating
     override fun receiveAndVerifyTx(): TransactionParts {
         try {
             val stx = subFlow(ReceiveTransactionFlow(otherSideSession, checkSufficientSignatures = false))
-            checkNotary(stx.notary)
-            checkSignatures(stx)
-            val wtx = stx.tx
-            return TransactionParts(wtx.id, wtx.inputs, wtx.timeWindow, wtx.notary)
+            val notary = stx.notary
+            checkNotary(notary)
+            var timeWindow: TimeWindow? = null
+            val transactionWithSignatures = if (stx.isNotaryChangeTransaction()) {
+                stx.resolveNotaryChangeTransaction(serviceHub)
+            } else {
+                timeWindow = stx.tx.timeWindow
+                stx
+            }
+            checkSignatures(transactionWithSignatures)
+            return TransactionParts(stx.id, stx.inputs, timeWindow, notary!!)
         } catch (e: Exception) {
             throw when (e) {
                 is TransactionVerificationException,
@@ -48,9 +56,9 @@ class MyValidatingNotaryFlow(otherSide: FlowSession, service: MyCustomValidating
         }
     }
 
-    private fun checkSignatures(stx: SignedTransaction) {
+    private fun checkSignatures(tx: TransactionWithSignatures) {
         try {
-            stx.verifySignaturesExcept(service.notaryIdentityKey)
+            tx.verifySignaturesExcept(service.notaryIdentityKey)
         } catch (e: SignatureException) {
             throw NotaryException(NotaryError.TransactionInvalid(e))
         }
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryFlow.kt b/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryFlow.kt
index cf871f7f0f..2cee47aa89 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryFlow.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryFlow.kt
@@ -1,10 +1,11 @@
 package net.corda.node.services.transactions
 
 import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.contracts.TimeWindow
 import net.corda.core.contracts.TransactionVerificationException
 import net.corda.core.flows.*
 import net.corda.core.node.services.TrustedAuthorityNotaryService
-import net.corda.core.transactions.SignedTransaction
+import net.corda.core.transactions.TransactionWithSignatures
 import java.security.SignatureException
 
 /**
@@ -15,9 +16,8 @@ import java.security.SignatureException
  */
 class ValidatingNotaryFlow(otherSideSession: FlowSession, service: TrustedAuthorityNotaryService) : NotaryFlow.Service(otherSideSession, service) {
     /**
-     * The received transaction is checked for contract-validity, which requires fully resolving it into a
-     * [TransactionForVerification], for which the caller also has to to reveal the whole transaction
-     * dependency chain.
+     * Fully resolves the received transaction and its dependencies, runs contract verification logic and checks that
+     * the transaction in question has all required signatures apart from the notary's.
      */
     @Suspendable
     override fun receiveAndVerifyTx(): TransactionParts {
@@ -25,9 +25,15 @@ class ValidatingNotaryFlow(otherSideSession: FlowSession, service: TrustedAuthor
             val stx = subFlow(ReceiveTransactionFlow(otherSideSession, checkSufficientSignatures = false))
             val notary = stx.notary
             checkNotary(notary)
-            checkSignatures(stx)
-            val wtx = stx.tx
-            return TransactionParts(wtx.id, wtx.inputs, wtx.timeWindow, notary!!)
+            var timeWindow: TimeWindow? = null
+            val transactionWithSignatures = if (stx.isNotaryChangeTransaction()) {
+                stx.resolveNotaryChangeTransaction(serviceHub)
+            } else {
+                timeWindow = stx.tx.timeWindow
+                stx
+            }
+            checkSignatures(transactionWithSignatures)
+            return TransactionParts(stx.id, stx.inputs, timeWindow, notary!!)
         } catch (e: Exception) {
             throw when (e) {
                 is TransactionVerificationException,
@@ -37,10 +43,10 @@ class ValidatingNotaryFlow(otherSideSession: FlowSession, service: TrustedAuthor
         }
     }
 
-    private fun checkSignatures(stx: SignedTransaction) {
+    private fun checkSignatures(tx: TransactionWithSignatures) {
         try {
-            stx.verifySignaturesExcept(service.notaryIdentityKey)
-        } catch(e: SignatureException) {
+            tx.verifySignaturesExcept(service.notaryIdentityKey)
+        } catch (e: SignatureException) {
             throw NotaryException(NotaryError.TransactionInvalid(e))
         }
     }
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 ea0106a076..024445b343 100644
--- a/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
@@ -3,6 +3,7 @@ package net.corda.node.services
 import net.corda.core.contracts.*
 import net.corda.core.crypto.generateKeyPair
 import net.corda.core.flows.NotaryChangeFlow
+import net.corda.core.flows.NotaryFlow
 import net.corda.core.flows.StateReplacementException
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
@@ -12,7 +13,7 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.seconds
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.network.NetworkMapService
-import net.corda.node.services.transactions.SimpleNotaryService
+import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
@@ -32,8 +33,8 @@ class NotaryChangeTests {
     lateinit var newNotaryNode: StartedNode<MockNetwork.MockNode>
     lateinit var clientNodeA: StartedNode<MockNetwork.MockNode>
     lateinit var clientNodeB: StartedNode<MockNetwork.MockNode>
-    lateinit var notaryNewId: Party
-    lateinit var notaryOldId: Party
+    lateinit var newNotaryParty: Party
+    lateinit var oldNotaryParty: Party
 
     @Before
     fun setUp() {
@@ -41,15 +42,15 @@ class NotaryChangeTests {
         mockNet = MockNetwork()
         oldNotaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
-                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(SimpleNotaryService.type)))
+                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(ValidatingNotaryService.type)))
         clientNodeA = mockNet.createNode(networkMapAddress = oldNotaryNode.network.myAddress)
         clientNodeB = mockNet.createNode(networkMapAddress = oldNotaryNode.network.myAddress)
-        newNotaryNode = mockNet.createNode(networkMapAddress = oldNotaryNode.network.myAddress, advertisedServices = ServiceInfo(SimpleNotaryService.type))
+        newNotaryNode = mockNet.createNode(networkMapAddress = oldNotaryNode.network.myAddress, advertisedServices = ServiceInfo(ValidatingNotaryService.type))
         mockNet.registerIdentities()
         mockNet.runNetwork() // Clear network map registration messages
         oldNotaryNode.internals.ensureRegistered()
-        notaryNewId = newNotaryNode.info.legalIdentities[1]
-        notaryOldId = oldNotaryNode.info.legalIdentities[1]
+        newNotaryParty = newNotaryNode.info.legalIdentities[1]
+        oldNotaryParty = oldNotaryNode.info.legalIdentities[1]
     }
 
     @After
@@ -60,21 +61,16 @@ class NotaryChangeTests {
 
     @Test
     fun `should change notary for a state with single participant`() {
-        val state = issueState(clientNodeA, oldNotaryNode, notaryOldId)
-        val newNotary = notaryNewId
-        val flow = NotaryChangeFlow(state, newNotary)
-        val future = clientNodeA.services.startFlow(flow)
-
-        mockNet.runNetwork()
-
-        val newState = future.resultFuture.getOrThrow()
-        assertEquals(newState.state.notary, newNotary)
+        val state = issueState(clientNodeA, oldNotaryParty)
+        assertEquals(state.state.notary, oldNotaryParty)
+        val newState = changeNotary(state, clientNodeA, newNotaryParty)
+        assertEquals(newState.state.notary, newNotaryParty)
     }
 
     @Test
     fun `should change notary for a state with multiple participants`() {
-        val state = issueMultiPartyState(clientNodeA, clientNodeB, oldNotaryNode, notaryOldId)
-        val newNotary = notaryNewId
+        val state = issueMultiPartyState(clientNodeA, clientNodeB, oldNotaryNode, oldNotaryParty)
+        val newNotary = newNotaryParty
         val flow = NotaryChangeFlow(state, newNotary)
         val future = clientNodeA.services.startFlow(flow)
 
@@ -89,7 +85,7 @@ class NotaryChangeTests {
 
     @Test
     fun `should throw when a participant refuses to change Notary`() {
-        val state = issueMultiPartyState(clientNodeA, clientNodeB, oldNotaryNode, notaryOldId)
+        val state = issueMultiPartyState(clientNodeA, clientNodeB, oldNotaryNode, oldNotaryParty)
         val newEvilNotary = getTestPartyAndCertificate(CordaX500Name(organisation = "Evil R3", locality = "London", country = "GB"), generateKeyPair().public)
         val flow = NotaryChangeFlow(state, newEvilNotary.party)
         val future = clientNodeA.services.startFlow(flow)
@@ -103,10 +99,10 @@ class NotaryChangeTests {
 
     @Test
     fun `should not break encumbrance links`() {
-        val issueTx = issueEncumberedState(clientNodeA, notaryOldId)
+        val issueTx = issueEncumberedState(clientNodeA, oldNotaryParty)
 
         val state = StateAndRef(issueTx.outputs.first(), StateRef(issueTx.id, 0))
-        val newNotary = notaryNewId
+        val newNotary = newNotaryParty
         val flow = NotaryChangeFlow(state, newNotary)
         val future = clientNodeA.services.startFlow(flow)
         mockNet.runNetwork()
@@ -135,6 +131,47 @@ class NotaryChangeTests {
         }
     }
 
+    @Test
+    fun `notary change and regular transactions are properly handled during resolution in longer chains`() {
+        val issued = issueState(clientNodeA, oldNotaryParty)
+        val moved = moveState(issued, clientNodeA, clientNodeB)
+
+        // We don't to tx resolution when moving state to another node, so need to add the issue transaction manually
+        // to node B. The resolution process is tested later during notarisation.
+        clientNodeB.services.recordTransactions(clientNodeA.services.validatedTransactions.getTransaction(issued.ref.txhash)!!)
+
+        val changedNotary = changeNotary(moved, clientNodeB, newNotaryParty)
+        val movedBack = moveState(changedNotary, clientNodeB, clientNodeA)
+        val changedNotaryBack = changeNotary(movedBack, clientNodeA, oldNotaryParty)
+
+        assertEquals(issued.state, changedNotaryBack.state)
+    }
+
+    private fun changeNotary(movedState: StateAndRef<DummyContract.SingleOwnerState>, node: StartedNode<*>, newNotary: Party): StateAndRef<DummyContract.SingleOwnerState> {
+        val flow = NotaryChangeFlow(movedState, newNotary)
+        val future = node.services.startFlow(flow)
+        mockNet.runNetwork()
+
+        return future.resultFuture.getOrThrow()
+    }
+
+    private fun moveState(state: StateAndRef<DummyContract.SingleOwnerState>, fromNode: StartedNode<*>, toNode: StartedNode<*>): StateAndRef<DummyContract.SingleOwnerState> {
+        val tx = DummyContract.move(state, toNode.info.chooseIdentity())
+        val stx = fromNode.services.signInitialTransaction(tx)
+
+        val notaryFlow = NotaryFlow.Client(stx)
+        val future = fromNode.services.startFlow(notaryFlow)
+        mockNet.runNetwork()
+
+        val notarySignature = future.resultFuture.getOrThrow()
+        val finalTransaction = stx + notarySignature
+
+        fromNode.services.recordTransactions(finalTransaction)
+        toNode.services.recordTransactions(finalTransaction)
+
+        return finalTransaction.tx.outRef(0)
+    }
+
     private fun issueEncumberedState(node: StartedNode<*>, notaryIdentity: Party): WireTransaction {
         val owner = node.info.chooseIdentity().ref(0)
         val stateA = DummyContract.SingleOwnerState(Random().nextInt(), owner.party)
@@ -161,30 +198,31 @@ class NotaryChangeTests {
     //       - The transaction type is not a notary change transaction at all.
 }
 
-fun issueState(node: StartedNode<*>, notaryNode: StartedNode<*>, notaryIdentity: Party): StateAndRef<*> {
+fun issueState(node: StartedNode<*>, notaryIdentity: Party): StateAndRef<DummyContract.SingleOwnerState> {
     val tx = DummyContract.generateInitial(Random().nextInt(), notaryIdentity, node.info.chooseIdentity().ref(0))
-    val signedByNode = node.services.signInitialTransaction(tx)
-    val stx = notaryNode.services.addSignature(signedByNode, notaryIdentity.owningKey)
+    val stx = node.services.signInitialTransaction(tx)
     node.services.recordTransactions(stx)
-    return StateAndRef(tx.outputStates().first(), StateRef(stx.id, 0))
+    return stx.tx.outRef(0)
 }
 
 fun issueMultiPartyState(nodeA: StartedNode<*>, nodeB: StartedNode<*>, notaryNode: StartedNode<*>, notaryIdentity: Party): StateAndRef<DummyContract.MultiOwnerState> {
-    val state = TransactionState(DummyContract.MultiOwnerState(0,
-            listOf(nodeA.info.chooseIdentity(), nodeB.info.chooseIdentity())), DummyContract.PROGRAM_ID, notaryIdentity)
-    val tx = TransactionBuilder(notary = notaryIdentity).withItems(state, dummyCommand())
+    val participants = listOf(nodeA.info.chooseIdentity(), nodeB.info.chooseIdentity())
+    val state = TransactionState(
+            DummyContract.MultiOwnerState(0, participants),
+            DummyContract.PROGRAM_ID, notaryIdentity)
+    val tx = TransactionBuilder(notary = notaryIdentity).withItems(state, dummyCommand(participants.first().owningKey))
     val signedByA = nodeA.services.signInitialTransaction(tx)
     val signedByAB = nodeB.services.addSignature(signedByA)
     val stx = notaryNode.services.addSignature(signedByAB, notaryIdentity.owningKey)
     nodeA.services.recordTransactions(stx)
     nodeB.services.recordTransactions(stx)
-    return StateAndRef(state, StateRef(stx.id, 0))
+    return stx.tx.outRef(0)
 }
 
-fun issueInvalidState(node: StartedNode<*>, notary: Party): StateAndRef<*> {
+fun issueInvalidState(node: StartedNode<*>, notary: Party): StateAndRef<DummyContract.SingleOwnerState> {
     val tx = DummyContract.generateInitial(Random().nextInt(), notary, node.info.chooseIdentity().ref(0))
     tx.setTimeWindow(Instant.now(), 30.seconds)
     val stx = node.services.signInitialTransaction(tx)
     node.services.recordTransactions(stx)
-    return StateAndRef(tx.outputStates().first(), StateRef(stx.id, 0))
-}
+    return stx.tx.outRef(0)
+}
\ No newline at end of file

From 0ce0baa235e868604148f40065ae1fcf6e27329b Mon Sep 17 00:00:00 2001
From: Shams Asari <shams.asari@r3.com>
Date: Wed, 27 Sep 2017 14:12:44 +0100
Subject: [PATCH 021/185] Removed initialiseSerialization param from
 CordaRPCClient, mirroring change in 1.0 branch

---
 .../net/corda/client/jfx/NodeMonitorModelTest.kt    |  6 +++---
 .../net/corda/client/jfx/model/NodeMonitorModel.kt  |  7 +++----
 .../corda/client/rpc/CordaRPCJavaClientTest.java    | 13 +++++++------
 .../net/corda/client/rpc/CordaRPCClientTest.kt      |  4 ++--
 .../kotlin/net/corda/client/rpc/CordaRPCClient.kt   | 13 ++++---------
 .../rpc/internal/KryoClientSerializationScheme.kt   | 13 ++++++++++---
 .../net/corda/services/messaging/MQSecurityTest.kt  |  2 +-
 .../kotlin/net/corda/irs/IRSDemoTest.kt             |  2 +-
 .../kotlin/net/corda/traderdemo/TraderDemoTest.kt   |  8 +++-----
 .../main/kotlin/net/corda/testing/driver/Driver.kt  |  4 ++--
 .../net/corda/testing/SerializationTestHelpers.kt   |  6 +++---
 11 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt b/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt
index bf5140fc36..ea0c88189c 100644
--- a/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt
+++ b/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt
@@ -27,9 +27,9 @@ import net.corda.finance.flows.CashExitFlow
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.User
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.driver.driver
 import net.corda.testing.node.DriverBasedTest
@@ -71,7 +71,7 @@ class NodeMonitorModelTest : DriverBasedTest() {
         vaultUpdates = monitor.vaultUpdates.bufferUntilSubscribed()
         networkMapUpdates = monitor.networkMap.bufferUntilSubscribed()
 
-        monitor.register(aliceNodeHandle.configuration.rpcAddress!!, cashUser.username, cashUser.password, initialiseSerialization = false)
+        monitor.register(aliceNodeHandle.configuration.rpcAddress!!, cashUser.username, cashUser.password)
         rpc = monitor.proxyObservable.value!!
         notaryParty = notaryHandle.nodeInfo.legalIdentities[1]
 
@@ -79,7 +79,7 @@ class NodeMonitorModelTest : DriverBasedTest() {
         bobNode = bobNodeHandle.nodeInfo
         val monitorBob = NodeMonitorModel()
         stateMachineUpdatesBob = monitorBob.stateMachineUpdates.bufferUntilSubscribed()
-        monitorBob.register(bobNodeHandle.configuration.rpcAddress!!, cashUser.username, cashUser.password, initialiseSerialization = false)
+        monitorBob.register(bobNodeHandle.configuration.rpcAddress!!, cashUser.username, cashUser.password)
         rpcBob = monitorBob.proxyObservable.value!!
         runTest()
     }
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt
index 3cde49536e..9bece5edcc 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt
@@ -55,13 +55,12 @@ class NodeMonitorModel {
      * Register for updates to/from a given vault.
      * TODO provide an unsubscribe mechanism
      */
-    fun register(nodeHostAndPort: NetworkHostAndPort, username: String, password: String, initialiseSerialization: Boolean = true) {
+    fun register(nodeHostAndPort: NetworkHostAndPort, username: String, password: String) {
         val client = CordaRPCClient(
                 hostAndPort = nodeHostAndPort,
-                configuration = CordaRPCClientConfiguration.default.copy(
+                configuration = CordaRPCClientConfiguration.DEFAULT.copy(
                         connectionMaxRetryInterval = 10.seconds
-                ),
-                initialiseSerialization = initialiseSerialization
+                )
         )
         val connection = client.start(username, password)
         val proxy = connection.proxy
diff --git a/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java b/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
index 1a6ce172cd..1862324c4f 100644
--- a/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
+++ b/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
@@ -8,12 +8,12 @@ import net.corda.core.utilities.OpaqueBytes;
 import net.corda.finance.flows.AbstractCashFlow;
 import net.corda.finance.flows.CashIssueFlow;
 import net.corda.finance.flows.CashPaymentFlow;
-import net.corda.finance.schemas.*;
+import net.corda.finance.schemas.CashSchemaV1;
 import net.corda.node.internal.Node;
 import net.corda.node.internal.StartedNode;
 import net.corda.node.services.transactions.ValidatingNotaryService;
-import net.corda.nodeapi.internal.ServiceInfo;
 import net.corda.nodeapi.User;
+import net.corda.nodeapi.internal.ServiceInfo;
 import net.corda.testing.CoreTestUtils;
 import net.corda.testing.node.NodeBasedTest;
 import org.junit.After;
@@ -24,14 +24,15 @@ import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.ExecutionException;
 
-import static java.util.Collections.*;
+import static java.util.Collections.emptyMap;
+import static java.util.Collections.singletonList;
 import static java.util.Objects.requireNonNull;
 import static kotlin.test.AssertionsKt.assertEquals;
-import static net.corda.client.rpc.CordaRPCClientConfiguration.getDefault;
 import static net.corda.finance.Currencies.DOLLARS;
 import static net.corda.finance.contracts.GetBalances.getCashBalance;
 import static net.corda.node.services.FlowPermissions.startFlowPermission;
-import static net.corda.testing.CoreTestUtils.*;
+import static net.corda.testing.CoreTestUtils.setCordappPackages;
+import static net.corda.testing.CoreTestUtils.unsetCordappPackages;
 import static net.corda.testing.TestConstants.getALICE;
 
 public class CordaRPCJavaClientTest extends NodeBasedTest {
@@ -56,7 +57,7 @@ public class CordaRPCJavaClientTest extends NodeBasedTest {
         CordaFuture<StartedNode<Node>> nodeFuture = startNode(getALICE().getName(), 1, services, singletonList(rpcUser), emptyMap());
         node = nodeFuture.get();
         node.getInternals().registerCustomSchemas(Collections.singleton(CashSchemaV1.INSTANCE));
-        client = new CordaRPCClient(requireNonNull(node.getInternals().getConfiguration().getRpcAddress()), getDefault(), false);
+        client = new CordaRPCClient(requireNonNull(node.getInternals().getConfiguration().getRpcAddress()));
     }
 
     @After
diff --git a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
index b4c10fa808..32284a970f 100644
--- a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
+++ b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
@@ -19,9 +19,9 @@ import net.corda.finance.schemas.CashSchemaV1
 import net.corda.node.internal.Node
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.User
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.ALICE
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.NodeBasedTest
@@ -54,7 +54,7 @@ class CordaRPCClientTest : NodeBasedTest() {
         setCordappPackages("net.corda.finance.contracts")
         node = startNode(ALICE.name, rpcUsers = listOf(rpcUser), advertisedServices = setOf(ServiceInfo(ValidatingNotaryService.type))).getOrThrow()
         node.internals.registerCustomSchemas(setOf(CashSchemaV1))
-        client = CordaRPCClient(node.internals.configuration.rpcAddress!!, initialiseSerialization = false)
+        client = CordaRPCClient(node.internals.configuration.rpcAddress!!)
     }
 
     @After
diff --git a/client/rpc/src/main/kotlin/net/corda/client/rpc/CordaRPCClient.kt b/client/rpc/src/main/kotlin/net/corda/client/rpc/CordaRPCClient.kt
index 635db3afea..2def3fbf20 100644
--- a/client/rpc/src/main/kotlin/net/corda/client/rpc/CordaRPCClient.kt
+++ b/client/rpc/src/main/kotlin/net/corda/client/rpc/CordaRPCClient.kt
@@ -34,8 +34,8 @@ data class CordaRPCClientConfiguration(val connectionMaxRetryInterval: Duration)
         /**
          * Returns the default configuration we recommend you use.
          */
-        @JvmStatic
-        val default = CordaRPCClientConfiguration(connectionMaxRetryInterval = RPCClientConfiguration.default.connectionMaxRetryInterval)
+        @JvmField
+        val DEFAULT = CordaRPCClientConfiguration(connectionMaxRetryInterval = RPCClientConfiguration.default.connectionMaxRetryInterval)
     }
 }
 
@@ -67,16 +67,11 @@ data class CordaRPCClientConfiguration(val connectionMaxRetryInterval: Duration)
  */
 class CordaRPCClient @JvmOverloads constructor(
         hostAndPort: NetworkHostAndPort,
-        configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.default,
-        initialiseSerialization: Boolean = true
+        configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT
 ) {
     init {
-        // Init serialization.  It's plausible there are multiple clients in a single JVM, so be tolerant of
-        // others having registered first.
         // TODO: allow clients to have serialization factory etc injected and align with RPC protocol version?
-        if (initialiseSerialization) {
-            KryoClientSerializationScheme.initialiseSerialization()
-        }
+        KryoClientSerializationScheme.initialiseSerialization()
     }
 
     private val rpcClient = RPCClient<CordaRPCOps>(
diff --git a/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/KryoClientSerializationScheme.kt b/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/KryoClientSerializationScheme.kt
index 66ddb33b1d..2275cd0d3f 100644
--- a/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/KryoClientSerializationScheme.kt
+++ b/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/KryoClientSerializationScheme.kt
@@ -5,6 +5,7 @@ import net.corda.core.serialization.SerializationContext
 import net.corda.core.serialization.SerializationDefaults
 import net.corda.core.utilities.ByteSequence
 import net.corda.nodeapi.internal.serialization.*
+import java.util.concurrent.atomic.AtomicBoolean
 
 class KryoClientSerializationScheme : AbstractKryoSerializationScheme() {
     override fun canDeserializeVersion(byteSequence: ByteSequence, target: SerializationContext.UseCase): Boolean {
@@ -23,7 +24,9 @@ class KryoClientSerializationScheme : AbstractKryoSerializationScheme() {
     override fun rpcServerKryoPool(context: SerializationContext): KryoPool = throw UnsupportedOperationException()
 
     companion object {
+        val isInitialised = AtomicBoolean(false)
         fun initialiseSerialization() {
+            if (!isInitialised.compareAndSet(false, true)) return
             try {
                 SerializationDefaults.SERIALIZATION_FACTORY = SerializationFactoryImpl().apply {
                     registerScheme(KryoClientSerializationScheme())
@@ -31,10 +34,14 @@ class KryoClientSerializationScheme : AbstractKryoSerializationScheme() {
                 }
                 SerializationDefaults.P2P_CONTEXT = KRYO_P2P_CONTEXT
                 SerializationDefaults.RPC_CLIENT_CONTEXT = KRYO_RPC_CLIENT_CONTEXT
-            } catch(e: IllegalStateException) {
+            } catch (e: IllegalStateException) {
                 // Check that it's registered as we expect
-                check(SerializationDefaults.SERIALIZATION_FACTORY is SerializationFactoryImpl) { "RPC client encountered conflicting configuration of serialization subsystem." }
-                check((SerializationDefaults.SERIALIZATION_FACTORY as SerializationFactoryImpl).alreadyRegisteredSchemes.any { it is KryoClientSerializationScheme }) { "RPC client encountered conflicting configuration of serialization subsystem." }
+                val factory = SerializationDefaults.SERIALIZATION_FACTORY
+                val checkedFactory = factory as? SerializationFactoryImpl
+                        ?: throw IllegalStateException("RPC client encountered conflicting configuration of serialization subsystem: $factory")
+                check(checkedFactory.alreadyRegisteredSchemes.any { it is KryoClientSerializationScheme }) {
+                    "RPC client encountered conflicting configuration of serialization subsystem."
+                }
             }
         }
     }
diff --git a/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt b/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt
index af332fcf21..d6aaeb10a7 100644
--- a/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt
@@ -154,7 +154,7 @@ abstract class MQSecurityTest : NodeBasedTest() {
     }
 
     fun loginToRPC(target: NetworkHostAndPort, rpcUser: User): CordaRPCOps {
-        return CordaRPCClient(target, initialiseSerialization = false).start(rpcUser.username, rpcUser.password).proxy
+        return CordaRPCClient(target).start(rpcUser.username, rpcUser.password).proxy
     }
 
     fun loginToRPCAndGetClientQueue(): String {
diff --git a/samples/irs-demo/src/integration-test/kotlin/net/corda/irs/IRSDemoTest.kt b/samples/irs-demo/src/integration-test/kotlin/net/corda/irs/IRSDemoTest.kt
index bc72cc65d7..4d3c92b7dc 100644
--- a/samples/irs-demo/src/integration-test/kotlin/net/corda/irs/IRSDemoTest.kt
+++ b/samples/irs-demo/src/integration-test/kotlin/net/corda/irs/IRSDemoTest.kt
@@ -98,7 +98,7 @@ class IRSDemoTest : IntegrationTestCategory {
     }
 
     private fun getFixingDateObservable(config: FullNodeConfiguration): Observable<LocalDate?> {
-        val client = CordaRPCClient(config.rpcAddress!!, initialiseSerialization = false)
+        val client = CordaRPCClient(config.rpcAddress!!)
         val proxy = client.start("user", "password").proxy
         val vaultUpdates = proxy.vaultTrackBy<InterestRateSwap.State>().updates
 
diff --git a/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt b/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
index 2625e43280..93034badfe 100644
--- a/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
+++ b/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
@@ -10,13 +10,11 @@ import net.corda.finance.schemas.CashSchemaV1
 import net.corda.finance.schemas.CommercialPaperSchemaV1
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
 import net.corda.node.services.transactions.SimpleNotaryService
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.nodeapi.User
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.driver.poll
 import net.corda.testing.node.NodeBasedTest
-import net.corda.testing.setCordappPackages
-import net.corda.testing.unsetCordappPackages
 import net.corda.traderdemo.flow.BuyerFlow
 import net.corda.traderdemo.flow.CommercialPaperIssueFlow
 import net.corda.traderdemo.flow.SellerFlow
@@ -56,11 +54,11 @@ class TraderDemoTest : NodeBasedTest() {
         nodeB.internals.registerCustomSchemas(setOf(CashSchemaV1, CommercialPaperSchemaV1))
 
         val (nodeARpc, nodeBRpc) = listOf(nodeA, nodeB).map {
-            val client = CordaRPCClient(it.internals.configuration.rpcAddress!!, initialiseSerialization = false)
+            val client = CordaRPCClient(it.internals.configuration.rpcAddress!!)
             client.start(demoUser.username, demoUser.password).proxy
         }
         val nodeBankRpc = let {
-            val client = CordaRPCClient(bankNode.internals.configuration.rpcAddress!!, initialiseSerialization = false)
+            val client = CordaRPCClient(bankNode.internals.configuration.rpcAddress!!)
             client.start(bankUser.username, bankUser.password).proxy
         }
 
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
index 3366440b6e..c279e0aa4d 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
@@ -221,7 +221,7 @@ sealed class NodeHandle {
         }
     }
 
-    fun rpcClientToNode(): CordaRPCClient = CordaRPCClient(configuration.rpcAddress!!, initialiseSerialization = false)
+    fun rpcClientToNode(): CordaRPCClient = CordaRPCClient(configuration.rpcAddress!!)
 
     /**
      * Stops the referenced node.
@@ -635,7 +635,7 @@ class DriverDSL(
 
     private fun establishRpc(config: FullNodeConfiguration, processDeathFuture: CordaFuture<out Process>): CordaFuture<CordaRPCOps> {
         val rpcAddress = config.rpcAddress!!
-        val client = CordaRPCClient(rpcAddress, initialiseSerialization = false)
+        val client = CordaRPCClient(rpcAddress)
         val connectionFuture = poll(executorService, "RPC connection") {
             try {
                 client.start(config.rpcUsers[0].username, config.rpcUsers[0].password)
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt
index 5da78a32af..73884f6cab 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt
@@ -17,11 +17,11 @@ inline fun <T> withTestSerialization(block: () -> T): T {
 }
 
 fun initialiseTestSerialization() {
+    // Stop the CordaRPCClient from trying to setup the defaults as we're about to do it now
+    KryoClientSerializationScheme.isInitialised.set(true)
     // Check that everything is configured for testing with mutable delegating instances.
     try {
-        check(SerializationDefaults.SERIALIZATION_FACTORY is TestSerializationFactory) {
-            "Found non-test serialization configuration: ${SerializationDefaults.SERIALIZATION_FACTORY}"
-        }
+        check(SerializationDefaults.SERIALIZATION_FACTORY is TestSerializationFactory)
     } catch(e: IllegalStateException) {
         SerializationDefaults.SERIALIZATION_FACTORY = TestSerializationFactory()
     }

From 0c910640bbfad73e1ec190db869f891124e3b7d9 Mon Sep 17 00:00:00 2001
From: Rick Parker <rick.parker@r3.com>
Date: Wed, 27 Sep 2017 15:14:39 +0100
Subject: [PATCH 022/185] Misc documentation fixes (#1690)

---
 docs/source/tut-two-party-flow.rst | 27 ++++++------
 docs/source/tutorial-test-dsl.rst  | 68 +++++++++++++++---------------
 docs/source/writing-cordapps.rst   |  2 +-
 3 files changed, 50 insertions(+), 47 deletions(-)

diff --git a/docs/source/tut-two-party-flow.rst b/docs/source/tut-two-party-flow.rst
index 441bd43c3b..9837f600c8 100644
--- a/docs/source/tut-two-party-flow.rst
+++ b/docs/source/tut-two-party-flow.rst
@@ -41,7 +41,8 @@ In ``IOUFlow.java``/``IOUFlow.kt``, update ``IOUFlow.call`` as follows:
         val signedTx = serviceHub.signInitialTransaction(txBuilder)
 
         // Obtaining the counterparty's signature
-        val fullySignedTx = subFlow(CollectSignaturesFlow(signedTx, CollectSignaturesFlow.tracker()))
+        val otherSession = initiateFlow(otherParty)
+        val fullySignedTx = subFlow(CollectSignaturesFlow(signedTx, setOf(otherSession), CollectSignaturesFlow.tracker()))
 
         // Finalising the transaction.
         subFlow(FinalityFlow(fullySignedTx))
@@ -52,6 +53,7 @@ In ``IOUFlow.java``/``IOUFlow.kt``, update ``IOUFlow.call`` as follows:
 
         import com.google.common.collect.ImmutableList;
         import java.security.PublicKey;
+        import java.util.Collections;
         import java.util.List;
 
         ...
@@ -69,7 +71,8 @@ In ``IOUFlow.java``/``IOUFlow.kt``, update ``IOUFlow.call`` as follows:
         final SignedTransaction signedTx = getServiceHub().signInitialTransaction(txBuilder);
 
         // Obtaining the counterparty's signature
-        final SignedTransaction fullySignedTx = subFlow(new CollectSignaturesFlow(signedTx, CollectSignaturesFlow.Companion.tracker()));
+        final FlowSession otherSession = initiateFlow(otherParty)
+        final SignedTransaction fullySignedTx = subFlow(new CollectSignaturesFlow(signedTx, Collections.singleton(otherSession), CollectSignaturesFlow.Companion.tracker()));
 
         // Finalising the transaction.
         subFlow(new FinalityFlow(fullySignedTx));
@@ -98,10 +101,10 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
         ...
 
         @InitiatedBy(IOUFlow::class)
-        class IOUFlowResponder(val otherParty: Party) : FlowLogic<Unit>() {
+        class IOUFlowResponder(val otherPartySession: FlowSession) : FlowLogic<Unit>() {
             @Suspendable
             override fun call() {
-                val signTransactionFlow = object : SignTransactionFlow(otherParty, SignTransactionFlow.tracker()) {
+                val signTransactionFlow = object : SignTransactionFlow(otherPartySession, SignTransactionFlow.tracker()) {
                     override fun checkTransaction(stx: SignedTransaction) = requireThat {
                         val output = stx.tx.outputs.single().data
                         "This must be an IOU transaction." using (output is IOUState)
@@ -123,9 +126,9 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
         import net.corda.core.contracts.ContractState;
         import net.corda.core.flows.FlowException;
         import net.corda.core.flows.FlowLogic;
+        import net.corda.core.flows.FlowSession;
         import net.corda.core.flows.InitiatedBy;
         import net.corda.core.flows.SignTransactionFlow;
-        import net.corda.core.identity.Party;
         import net.corda.core.transactions.SignedTransaction;
         import net.corda.core.utilities.ProgressTracker;
 
@@ -133,18 +136,18 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
 
         @InitiatedBy(IOUFlow.class)
         public class IOUFlowResponder extends FlowLogic<Void> {
-            private final Party otherParty;
+            private final FlowSession otherPartySession;
 
-            public IOUFlowResponder(Party otherParty) {
-                this.otherParty = otherParty;
+            public IOUFlowResponder(FlowSession otherPartySession) {
+                this.otherPartySession = otherPartySession;
             }
 
             @Suspendable
             @Override
             public Void call() throws FlowException {
-                class signTxFlow extends SignTransactionFlow {
-                    private signTxFlow(Party otherParty, ProgressTracker progressTracker) {
-                        super(otherParty, progressTracker);
+                class SignTxFlow extends SignTransactionFlow {
+                    private signTxFlow(FlowSession otherPartySession, ProgressTracker progressTracker) {
+                        super(otherPartySession, progressTracker);
                     }
 
                     @Override
@@ -159,7 +162,7 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
                     }
                 }
 
-                subFlow(new signTxFlow(otherParty, SignTransactionFlow.Companion.tracker()));
+                subFlow(new SignTxFlow(otherPartySession, SignTransactionFlow.Companion.tracker()));
 
                 return null;
             }
diff --git a/docs/source/tutorial-test-dsl.rst b/docs/source/tutorial-test-dsl.rst
index 51aa2789c8..2eb870c781 100644
--- a/docs/source/tutorial-test-dsl.rst
+++ b/docs/source/tutorial-test-dsl.rst
@@ -249,7 +249,7 @@ We can continue to build the transaction until it ``verifies``:
                     input(inState)
                     command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
                     this `fails with` "the state is propagated"
-                    output("alice's paper") { inState `owned by` ALICE_PUBKEY }
+                    output(CommercialPaper.CP_PROGRAM_ID, "alice's paper") { inState `owned by` ALICE_PUBKEY }
                     this.verifies()
                 }
             }
@@ -265,7 +265,7 @@ We can continue to build the transaction until it ``verifies``:
                     tx.input(inState);
                     tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
                     tx.failsWith("the state is propagated");
-                    tx.output("alice's paper", inState.withOwner(getALICE_PUBKEY()));
+                    tx.output(CommercialPaper.CP_PROGRAM_ID, "alice's paper", inState.withOwner(getALICE_PUBKEY()));
                     return tx.verifies();
                 });
                 return Unit.INSTANCE;
@@ -289,7 +289,7 @@ What should we do if we wanted to test what happens when the wrong party signs t
         fun `simple issuance with tweak`() {
             ledger {
                 transaction {
-                    output("paper") { getPaper() } // Some CP is issued onto the ledger by MegaCorp.
+                    output(CommercialPaper.CP_PROGRAM_ID, "paper") { getPaper() } // Some CP is issued onto the ledger by MegaCorp.
                     tweak {
                         command(DUMMY_PUBKEY_1) { CommercialPaper.Commands.Issue() }
                         timestamp(TEST_TX_TIME)
@@ -308,7 +308,7 @@ What should we do if we wanted to test what happens when the wrong party signs t
         public void simpleIssuanceWithTweak() {
             ledger(l -> {
                 l.transaction(tx -> {
-                    tx.output("paper", getPaper()); // Some CP is issued onto the ledger by MegaCorp.
+                    tx.output(CommercialPaper.CP_PROGRAM_ID, "paper", getPaper()); // Some CP is issued onto the ledger by MegaCorp.
                     tx.tweak(tw -> {
                         tw.command(getDUMMY_PUBKEY_1(), new JavaCommercialPaper.Commands.Issue());
                         tw.timestamp(getTEST_TX_TIME());
@@ -337,7 +337,7 @@ ledger with a single transaction:
         @Test
         fun `simple issuance with tweak and top level transaction`() {
             transaction {
-                output("paper") { getPaper() } // Some CP is issued onto the ledger by MegaCorp.
+                output(CommercialPaper.CP_PROGRAM_ID, "paper") { getPaper() } // Some CP is issued onto the ledger by MegaCorp.
                 tweak {
                     command(DUMMY_PUBKEY_1) { CommercialPaper.Commands.Issue() }
                     timestamp(TEST_TX_TIME)
@@ -354,7 +354,7 @@ ledger with a single transaction:
         @Test
         public void simpleIssuanceWithTweakTopLevelTx() {
             transaction(tx -> {
-                tx.output("paper", getPaper()); // Some CP is issued onto the ledger by MegaCorp.
+                tx.output(CommercialPaper.CP_PROGRAM_ID, "paper", getPaper()); // Some CP is issued onto the ledger by MegaCorp.
                 tx.tweak(tw -> {
                     tw.command(getDUMMY_PUBKEY_1(), new JavaCommercialPaper.Commands.Issue());
                     tw.timestamp(getTEST_TX_TIME());
@@ -381,12 +381,12 @@ Now that we know how to define a single transaction, let's look at how to define
 
             ledger {
                 unverifiedTransaction {
-                    output("alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE_PUBKEY)
+                    output(Cash.CP_PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE_PUBKEY)
                 }
 
                 // Some CP is issued onto the ledger by MegaCorp.
                 transaction("Issuance") {
-                    output("paper") { getPaper() }
+                    output(CommercialPaper.CP_PROGRAM_ID, "paper") { getPaper() }
                     command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
                     timestamp(TEST_TX_TIME)
                     this.verifies()
@@ -396,8 +396,8 @@ Now that we know how to define a single transaction, let's look at how to define
                 transaction("Trade") {
                     input("paper")
                     input("alice's $900")
-                    output("borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP_PUBKEY }
-                    output("alice's paper") { "paper".output<ICommercialPaperState>() `owned by` ALICE_PUBKEY }
+                    output(Cash.CP_PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP_PUBKEY }
+                    output(CommercialPaper.CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>() `owned by` ALICE_PUBKEY }
                     command(ALICE_PUBKEY) { Cash.Commands.Move() }
                     command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
                     this.verifies()
@@ -412,14 +412,14 @@ Now that we know how to define a single transaction, let's look at how to define
             PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
             ledger(l -> {
                 l.unverifiedTransaction(tx -> {
-                            tx.output("alice's $900",
+                            tx.output(Cash.CP_PROGRAM_ID, "alice's $900",
                                     new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE_PUBKEY(), null));
                             return Unit.INSTANCE;
                         });
 
                 // Some CP is issued onto the ledger by MegaCorp.
                 l.transaction("Issuance", tx -> {
-                    tx.output("paper", getPaper());
+                    tx.output(CommercialPaper.CP_PROGRAM_ID, "paper", getPaper());
                     tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
                     tx.timestamp(getTEST_TX_TIME());
                     return tx.verifies();
@@ -428,9 +428,9 @@ Now that we know how to define a single transaction, let's look at how to define
                 l.transaction("Trade", tx -> {
                     tx.input("paper");
                     tx.input("alice's $900");
-                    tx.output("borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP_PUBKEY(), null));
+                    tx.output(Cash.CP_PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP_PUBKEY(), null));
                     JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
-                    tx.output("alice's paper", inputPaper.withOwner(getALICE_PUBKEY()));
+                    tx.output(CommercialPaper.CP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE_PUBKEY()));
                     tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
                     tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
                     return tx.verifies();
@@ -462,12 +462,12 @@ To do so let's create a simple example that uses the same input twice:
             val issuer = MEGA_CORP.ref(123)
             ledger {
                 unverifiedTransaction {
-                    output("alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE_PUBKEY)
+                    output(Cash.CP_PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE_PUBKEY)
                 }
 
                 // Some CP is issued onto the ledger by MegaCorp.
                 transaction("Issuance") {
-                    output("paper") { getPaper() }
+                    output(CommercialPaper.CP_PROGRAM_ID, "paper") { getPaper() }
                     command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
                     timestamp(TEST_TX_TIME)
                     this.verifies()
@@ -476,8 +476,8 @@ To do so let's create a simple example that uses the same input twice:
                 transaction("Trade") {
                     input("paper")
                     input("alice's $900")
-                    output("borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP_PUBKEY }
-                    output("alice's paper") { "paper".output<ICommercialPaperState>() `owned by` ALICE_PUBKEY }
+                    output(Cash.CP_PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP_PUBKEY }
+                    output(CommercialPaper.CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>() `owned by` ALICE_PUBKEY }
                     command(ALICE_PUBKEY) { Cash.Commands.Move() }
                     command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
                     this.verifies()
@@ -486,7 +486,7 @@ To do so let's create a simple example that uses the same input twice:
                 transaction {
                     input("paper")
                     // We moved a paper to another pubkey.
-                    output("bob's paper") { "paper".output<ICommercialPaperState>() `owned by` BOB_PUBKEY }
+                    output(CommercialPaper.CP_PROGRAM_ID, "bob's paper") { "paper".output<ICommercialPaperState>() `owned by` BOB_PUBKEY }
                     command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
                     this.verifies()
                 }
@@ -502,14 +502,14 @@ To do so let's create a simple example that uses the same input twice:
             PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
             ledger(l -> {
                 l.unverifiedTransaction(tx -> {
-                    tx.output("alice's $900",
+                    tx.output(Cash.CP_PROGRAM_ID, "alice's $900",
                             new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE_PUBKEY(), null));
                     return Unit.INSTANCE;
                 });
 
                 // Some CP is issued onto the ledger by MegaCorp.
                 l.transaction("Issuance", tx -> {
-                    tx.output("paper", getPaper());
+                    tx.output(CommercialPaper.CP_PROGRAM_ID, "paper", getPaper());
                     tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
                     tx.timestamp(getTEST_TX_TIME());
                     return tx.verifies();
@@ -518,9 +518,9 @@ To do so let's create a simple example that uses the same input twice:
                 l.transaction("Trade", tx -> {
                     tx.input("paper");
                     tx.input("alice's $900");
-                    tx.output("borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP_PUBKEY(), null));
+                    tx.output(Cash.CP_PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP_PUBKEY(), null));
                     JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
-                    tx.output("alice's paper", inputPaper.withOwner(getALICE_PUBKEY()));
+                    tx.output(CommercialPaper.CP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE_PUBKEY()));
                     tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
                     tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
                     return tx.verifies();
@@ -530,7 +530,7 @@ To do so let's create a simple example that uses the same input twice:
                     tx.input("paper");
                     JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
                     // We moved a paper to other pubkey.
-                    tx.output("bob's paper", inputPaper.withOwner(getBOB_PUBKEY()));
+                    tx.output(CommercialPaper.CP_PROGRAM_ID, "bob's paper", inputPaper.withOwner(getBOB_PUBKEY()));
                     tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
                     return tx.verifies();
                 });
@@ -551,12 +551,12 @@ verification (``this.fails()`` at the end). As in previous examples we can use `
             val issuer = MEGA_CORP.ref(123)
             ledger {
                 unverifiedTransaction {
-                    output("alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE_PUBKEY)
+                    output(Cash.CP_PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE_PUBKEY)
                 }
 
                 // Some CP is issued onto the ledger by MegaCorp.
                 transaction("Issuance") {
-                    output("paper") { getPaper() }
+                    output(CommercialPaper.CP_PROGRAM_ID, "paper") { getPaper() }
                     command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
                     timestamp(TEST_TX_TIME)
                     this.verifies()
@@ -565,8 +565,8 @@ verification (``this.fails()`` at the end). As in previous examples we can use `
                 transaction("Trade") {
                     input("paper")
                     input("alice's $900")
-                    output("borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP_PUBKEY }
-                    output("alice's paper") { "paper".output<ICommercialPaperState>() `owned by` ALICE_PUBKEY }
+                    output(Cash.CP_PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP_PUBKEY }
+                    output(CommercialPaper.CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>() `owned by` ALICE_PUBKEY }
                     command(ALICE_PUBKEY) { Cash.Commands.Move() }
                     command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
                     this.verifies()
@@ -576,7 +576,7 @@ verification (``this.fails()`` at the end). As in previous examples we can use `
                     transaction {
                         input("paper")
                         // We moved a paper to another pubkey.
-                        output("bob's paper") { "paper".output<ICommercialPaperState>() `owned by` BOB_PUBKEY }
+                        output(CommercialPaper.CP_PROGRAM_ID, "bob's paper") { "paper".output<ICommercialPaperState>() `owned by` BOB_PUBKEY }
                         command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
                         this.verifies()
                     }
@@ -594,14 +594,14 @@ verification (``this.fails()`` at the end). As in previous examples we can use `
             PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
             ledger(l -> {
                 l.unverifiedTransaction(tx -> {
-                    tx.output("alice's $900",
+                    tx.output(Cash.CP_PROGRAM_ID, "alice's $900",
                             new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE_PUBKEY(), null));
                     return Unit.INSTANCE;
                 });
 
                 // Some CP is issued onto the ledger by MegaCorp.
                 l.transaction("Issuance", tx -> {
-                    tx.output("paper", getPaper());
+                    tx.output(CommercialPaper.CP_PROGRAM_ID, "paper", getPaper());
                     tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
                     tx.timestamp(getTEST_TX_TIME());
                     return tx.verifies();
@@ -610,9 +610,9 @@ verification (``this.fails()`` at the end). As in previous examples we can use `
                 l.transaction("Trade", tx -> {
                     tx.input("paper");
                     tx.input("alice's $900");
-                    tx.output("borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP_PUBKEY(), null));
+                    tx.output(Cash.CP_PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP_PUBKEY(), null));
                     JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
-                    tx.output("alice's paper", inputPaper.withOwner(getALICE_PUBKEY()));
+                    tx.output(CommercialPaper.CP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE_PUBKEY()));
                     tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
                     tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
                     return tx.verifies();
@@ -623,7 +623,7 @@ verification (``this.fails()`` at the end). As in previous examples we can use `
                         tx.input("paper");
                         JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
                         // We moved a paper to another pubkey.
-                        tx.output("bob's paper", inputPaper.withOwner(getBOB_PUBKEY()));
+                        tx.output(CommercialPaper.CP_PROGRAM_ID, "bob's paper", inputPaper.withOwner(getBOB_PUBKEY()));
                         tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
                         return tx.verifies();
                     });
diff --git a/docs/source/writing-cordapps.rst b/docs/source/writing-cordapps.rst
index 13c14f314e..9200cb8fe5 100644
--- a/docs/source/writing-cordapps.rst
+++ b/docs/source/writing-cordapps.rst
@@ -64,7 +64,7 @@ Defining plugins
 ----------------
 Your CorDapp may need to define two types of plugins:
 
-* ``CordaPluginRegistry`` subclasses, which define additional serializable classes and vault schemas
+* ``CordaPluginRegistry`` subclasses, which define additional serializable classes
 * ``WebServerPluginRegistry`` subclasses, which define the APIs and static web content served by your CorDapp
 
 The fully-qualified class path of each ``CordaPluginRegistry`` subclass must then be added to the

From 39160de0a36d4dd91d85692f5692dd0b830c9176 Mon Sep 17 00:00:00 2001
From: Rick Parker <rick.parker@r3.com>
Date: Wed, 27 Sep 2017 15:15:34 +0100
Subject: [PATCH 023/185] BIGINT fix for H2 coin selection. (#1659)

---
 .../src/main/kotlin/net/corda/finance/Currencies.kt | 13 ++++++++++++-
 .../asset/cash/selection/CashSelectionH2Impl.kt     |  2 +-
 .../main/kotlin/net/corda/traderdemo/TraderDemo.kt  |  6 +++---
 3 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/finance/src/main/kotlin/net/corda/finance/Currencies.kt b/finance/src/main/kotlin/net/corda/finance/Currencies.kt
index 5e1b997aed..906e01d8af 100644
--- a/finance/src/main/kotlin/net/corda/finance/Currencies.kt
+++ b/finance/src/main/kotlin/net/corda/finance/Currencies.kt
@@ -15,17 +15,28 @@ import java.util.*
 @JvmField val JPY: Currency = Currency.getInstance("JPY")
 @JvmField val RUB: Currency = Currency.getInstance("RUB")
 
-fun <T : Any> AMOUNT(amount: Int, token: T): Amount<T> = Amount.fromDecimal(BigDecimal.valueOf(amount.toLong()), token)
+fun <T : Any> AMOUNT(amount: Int, token: T): Amount<T> = AMOUNT(amount.toLong(), token)
+fun <T : Any> AMOUNT(amount: Long, token: T): Amount<T> = Amount.fromDecimal(BigDecimal.valueOf(amount), token)
 fun <T : Any> AMOUNT(amount: Double, token: T): Amount<T> = Amount.fromDecimal(BigDecimal.valueOf(amount), token)
 fun DOLLARS(amount: Int): Amount<Currency> = AMOUNT(amount, USD)
+fun DOLLARS(amount: Long): Amount<Currency> = AMOUNT(amount, USD)
 fun DOLLARS(amount: Double): Amount<Currency> = AMOUNT(amount, USD)
 fun POUNDS(amount: Int): Amount<Currency> = AMOUNT(amount, GBP)
+fun POUNDS(amount: Long): Amount<Currency> = AMOUNT(amount, GBP)
+fun POUNDS(amount: Double): Amount<Currency> = AMOUNT(amount, GBP)
 fun SWISS_FRANCS(amount: Int): Amount<Currency> = AMOUNT(amount, CHF)
+fun SWISS_FRANCS(amount: Long): Amount<Currency> = AMOUNT(amount, CHF)
+fun SWISS_FRANCS(amount: Double): Amount<Currency> = AMOUNT(amount, CHF)
 
 val Int.DOLLARS: Amount<Currency> get() = DOLLARS(this)
+val Long.DOLLARS: Amount<Currency> get() = DOLLARS(this)
 val Double.DOLLARS: Amount<Currency> get() = DOLLARS(this)
 val Int.POUNDS: Amount<Currency> get() = POUNDS(this)
+val Long.POUNDS: Amount<Currency> get() = POUNDS(this)
+val Double.POUNDS: Amount<Currency> get() = POUNDS(this)
 val Int.SWISS_FRANCS: Amount<Currency> get() = SWISS_FRANCS(this)
+val Long.SWISS_FRANCS: Amount<Currency> get() = SWISS_FRANCS(this)
+val Double.SWISS_FRANCS: Amount<Currency> get() = SWISS_FRANCS(this)
 
 infix fun Currency.`issued by`(deposit: PartyAndReference) = issuedBy(deposit)
 infix fun Amount<Currency>.`issued by`(deposit: PartyAndReference) = issuedBy(deposit)
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
index fb3a84371b..7c18981857 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
@@ -77,7 +77,7 @@ class CashSelectionH2Impl : CashSelection {
             spendLock.withLock {
                 val statement = services.jdbcSession().createStatement()
                 try {
-                    statement.execute("CALL SET(@t, 0);")
+                    statement.execute("CALL SET(@t, CAST(0 AS BIGINT));")
 
                     // we select spendable states irrespective of lock but prioritised by unlocked ones (Eg. null)
                     // the softLockReserve update will detect whether we try to lock states locked by others
diff --git a/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/TraderDemo.kt b/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/TraderDemo.kt
index 689d3b4e52..43c82f5565 100644
--- a/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/TraderDemo.kt
+++ b/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/TraderDemo.kt
@@ -44,17 +44,17 @@ private class TraderDemo {
         }
 
         // What happens next depends on the role. The buyer sits around waiting for a trade to start. The seller role
-        // will contact the buyer and actually make something happen.
+        // will contact the buyer and actually make something happen.  We intentionally use large amounts here.
         val role = options.valueOf(roleArg)!!
         if (role == Role.BANK) {
             val bankHost = NetworkHostAndPort("localhost", bankRpcPort)
             CordaRPCClient(bankHost).use("demo", "demo") {
-                TraderDemoClientApi(it.proxy).runIssuer(1100.DOLLARS, buyerName, sellerName)
+                TraderDemoClientApi(it.proxy).runIssuer(1_100_000_000_000.DOLLARS, buyerName, sellerName)
             }
         } else {
             val sellerHost = NetworkHostAndPort("localhost", sellerRpcPort)
             CordaRPCClient(sellerHost).use("demo", "demo") {
-                TraderDemoClientApi(it.proxy).runSeller(1000.DOLLARS, buyerName)
+                TraderDemoClientApi(it.proxy).runSeller(1_000_000_000_000.DOLLARS, buyerName)
             }
         }
     }

From 512de2690d9fd177cb1f3de79f01a35a91988374 Mon Sep 17 00:00:00 2001
From: josecoll <jose.coll@r3cev.com>
Date: Wed, 27 Sep 2017 15:29:00 +0100
Subject: [PATCH 024/185] Added changelog entry. (#1691)

---
 docs/source/changelog.rst | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index af1374367b..2f01167fb3 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -12,6 +12,9 @@ UNRELEASED
 Release 1.0
 -----------
 
+* Unification of VaultQuery And VaultService APIs
+  Developers now only need to work with a single Vault Service API for all needs.
+
 * Java 8 lambdas now work property with Kryo during check-pointing.
 
 * String constants have been marked as ``const`` type in Kotlin, eliminating cases where functions of the form

From 72cff032e67285e30d5d148d19c2881eb6ebbaf0 Mon Sep 17 00:00:00 2001
From: Andras Slemmer <0slemi0@gmail.com>
Date: Wed, 27 Sep 2017 15:33:09 +0100
Subject: [PATCH 025/185] FlowSession docs (#1660)

---
 .../net/corda/core/flows/FlowSession.kt       |  17 +-
 docs/source/api-flows.rst                     | 155 +++++++++++++++---
 .../java/net/corda/docs/FlowCookbookJava.java |   7 +
 .../kotlin/net/corda/docs/FlowCookbook.kt     |  14 +-
 docs/source/flow-state-machines.rst           |  14 +-
 5 files changed, 171 insertions(+), 36 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt b/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
index 9c2e5425d6..74bd247a78 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
@@ -5,7 +5,18 @@ import net.corda.core.identity.Party
 import net.corda.core.utilities.UntrustworthyData
 
 /**
- * To port existing flows:
+ *
+ * A [FlowSession] is a handle on a communication sequence between two flows. It is used to send and receive messages
+ *   between flows.
+ *
+ * There are two ways of obtaining such a session:
+ *
+ * 1.  Calling [FlowLogic.initiateFlow]. This will create a [FlowSession] object on which the first send/receive
+ *   operation will attempt to kick off a corresponding [InitiatedBy] flow on the counterparty's node.
+ * 2.  As constructor parameter to [InitiatedBy] flows. This session is the one corresponding to the initiating flow and
+ *   may be used for replies.
+ *
+ * To port flows using the old Party-based API:
  *
  * Look for [Deprecated] usages of send/receive/sendAndReceive/getFlowInfo.
  *
@@ -31,6 +42,10 @@ import net.corda.core.utilities.UntrustworthyData
  *     otherSideSession.send(something)
  */
 abstract class FlowSession {
+    /**
+     * The [Party] on the other side of this session. In the case of a session created by [FlowLogic.initiateFlow]
+     *   [counterparty] is the same Party as the one passed to that function.
+     */
     abstract val counterparty: Party
 
     /**
diff --git a/docs/source/api-flows.rst b/docs/source/api-flows.rst
index 4c1ef7fd2b..99cddf74b2 100644
--- a/docs/source/api-flows.rst
+++ b/docs/source/api-flows.rst
@@ -113,9 +113,8 @@ subclass's constructor can take any number of arguments of any type. The generic
 
 FlowLogic annotations
 ---------------------
-Any flow that you wish to start either directly via RPC or as a subflow must be annotated with the
-``@InitiatingFlow`` annotation. Additionally, if you wish to start the flow via RPC, you must annotate it with the
-``@StartableByRPC`` annotation:
+Any flow from which you want to initiate other flows must be annotated with the ``@InitiatingFlow`` annotation.
+Additionally, if you wish to start the flow via RPC, you must annotate it with the ``@StartableByRPC`` annotation:
 
 .. container:: codeset
 
@@ -139,7 +138,7 @@ Meanwhile, any flow that responds to a message from another flow must be annotat
    .. sourcecode:: kotlin
 
         @InitiatedBy(Initiator::class)
-        class Responder(val otherParty: Party) : FlowLogic<Unit>() { }
+        class Responder(val otherSideSession: FlowSession) : FlowLogic<Unit>() { }
 
    .. sourcecode:: java
 
@@ -270,18 +269,50 @@ Finally, we can use the map to identify nodes providing a specific service (e.g.
 
 Communication between parties
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-``FlowLogic`` instances communicate using three functions:
 
-* ``send(otherParty: Party, payload: Any)``
-    * Sends the ``payload`` object to the ``otherParty``
-* ``receive(receiveType: Class<R>, otherParty: Party)``
-    * Receives an object of type ``receiveType`` from the ``otherParty``
-* ``sendAndReceive(receiveType: Class<R>, otherParty: Party, payload: Any)``
-    * Sends the ``payload`` object to the ``otherParty``, and receives an object of type ``receiveType`` back
+In order to create a communication session between your initiator flow and the receiver flow you must call
+``initiateFlow(party: Party): FlowSession``
+
+``FlowSession`` instances in turn provide three functions:
+
+* ``send(payload: Any)``
+    * Sends the ``payload`` object
+* ``receive(receiveType: Class<R>): R``
+    * Receives an object of type ``receiveType``
+* ``sendAndReceive(receiveType: Class<R>, payload: Any): R``
+    * Sends the ``payload`` object and receives an object of type ``receiveType`` back
+
+
+InitiateFlow
+~~~~~~~~~~~~
+
+``initiateFlow`` creates a communication session with the passed in ``Party``.
+
+
+.. container:: codeset
+
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
+        :language: kotlin
+        :start-after: DOCSTART initiateFlow
+        :end-before: DOCEND initiateFlow
+        :dedent: 12
+
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
+        :language: java
+        :start-after: DOCSTART initiateFlow
+        :end-before: DOCEND initiateFlow
+        :dedent: 12
+
+Note that at the time of call to this function no actual communication is done, this is deferred to the first
+send/receive, at which point the counterparty will either:
+
+1. Ignore the message if they are not registered to respond to messages from this flow.
+2. Start the flow they have registered to respond to this flow.
 
 Send
 ~~~~
-We can send arbitrary data to a counterparty:
+
+Once we have a ``FlowSession`` object we can send arbitrary data to a counterparty:
 
 .. container:: codeset
 
@@ -297,12 +328,7 @@ We can send arbitrary data to a counterparty:
         :end-before: DOCEND 4
         :dedent: 12
 
-If this is the first ``send``, the counterparty will either:
-
-1. Ignore the message if they are not registered to respond to messages from this flow.
-2. Start the flow they have registered to respond to this flow, and run the flow until the first call to ``receive``,
-   at which point they process the message. In other words, we are assuming that the counterparty is registered to
-   respond to this flow, and has a corresponding ``receive`` call.
+The flow on the other side must eventually reach a corresponding ``receive`` call to get this message.
 
 Receive
 ~~~~~~~
@@ -351,6 +377,11 @@ as it likes, and each party can invoke a different response flow:
         :end-before: DOCEND 6
         :dedent: 12
 
+.. warning:: If you initiate several counter flows from the same ``@InitiatingFlow`` flow then on the receiving side you
+   must be prepared to be initiated by any of the corresponding ``initiateFlow()`` calls! A good way of handling this
+   ambiguity is to send as a first message a "role" message to the initiated flow, indicating which part of the
+   initiating flow the rest of the counter-flow should conform to.
+
 SendAndReceive
 ~~~~~~~~~~~~~~
 We can also use a single call to send data to a counterparty and wait to receive data of a specific type back. The
@@ -395,19 +426,91 @@ Our side of the flow must mirror these calls. We could do this as follows:
         :end-before: DOCEND 8
         :dedent: 12
 
+Porting from the old Party-based API
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Before ``FlowSession`` s were introduced the send/receive API looked a bit different. They were functions on
+``FlowLogic`` and took the address ``Party`` as argument. The platform internally maintained a mapping from ``Party`` to
+session, hiding sessions from the user completely.
+
+However we realised that this could introduce subtle bugs and security issues where sends meant for different sessions
+may end up in the same session if the target ``Party`` happens to be the same.
+
+Therefore the session concept is now exposed through ``FlowSession`` which disambiguates which communication sequence a
+message is intended for.
+
+In the old API the first ``send`` or ``receive`` to a ``Party`` was the one kicking off the counterflow. This is now
+explicit in the ``initiateFlow`` function call. To port existing code:
+
+.. container:: codeset
+
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
+        :language: kotlin
+        :start-after: DOCSTART FlowSession porting
+        :end-before: DOCEND FlowSession porting
+        :dedent: 12
+
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
+        :language: java
+        :start-after: DOCSTART FlowSession porting
+        :end-before: DOCEND FlowSession porting
+        :dedent: 12
+
+
 Subflows
 --------
+
+Subflows are pieces of reusable flows that may be run by calling ``FlowLogic.subFlow``.
+
+Inlined subflows
+^^^^^^^^^^^^^^^^
+
+Inlined subflows inherit their calling flow's type when initiating a new session with a counterparty. For example say
+we have flow A calling an inlined subflow B, which in turn initiates a session with a party. The FlowLogic type used to
+determine which counterflow should be kicked off will be A, not B. Note that this means that the other side of this
+session must therefore be called explicitly in the kicked off flow as well.
+
+An example of such a flow is ``CollectSignaturesFlow``. It has a counter-flow ``SignTransactionFlow`` that isn't
+annotated with ``InitiatedBy``. This is because both of these flows are inlined, the kick-off relationship will be
+defined by the parent flows calling ``CollectSignaturesFlow`` and ``SignTransactionFlow``.
+
+In the code inlined subflows appear as regular ``FlowLogic`` instances, `without` either of the ``@InitiatingFlow`` or
+``@InitiatedBy`` annotation.
+
+.. note:: Inlined flows aren't versioned, they inherit their parent flow's version.
+
+Initiating subflows
+^^^^^^^^^^^^^^^^^^^
+
+Initiating subflows are ones annotated with the ``@InitiatingFlow`` annotation. When such a flow initiates a session its
+type will be used to determine which ``@InitiatedBy`` flow to kick off on the counterparty.
+
+An example is the ``@InitiatingFlow InitiatorFlow``/``@InitiatedBy ResponderFlow`` flow pair in the ``FlowCookbook``.
+
+.. note:: Initiating flows are versioned separately from their parents.
+
+Core initiating subflows
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Corda-provided initiating subflows are a little different to standard ones as they are versioned together with the
+platform, and their initiated counterflows are registered explicitly, so there is no need for the ``InitiatedBy``
+annotation.
+
+An example is the ``FinalityFlow``/``FinalityHandler`` flow pair.
+
+Built-in subflows
+^^^^^^^^^^^^^^^^^
+
 Corda provides a number of built-in flows that should be used for handling common tasks. The most important are:
 
-* ``CollectSignaturesFlow``, which should be used to collect a transaction's required signatures
-* ``FinalityFlow``, which should be used to notarise and record a transaction
-* ``SendTransactionFlow``, which should be used to send a signed transaction if it needed to be resolved on the other side.
-* ``ReceiveTransactionFlow``, which should be used receive a signed transaction
-* ``ContractUpgradeFlow``, which should be used to change a state's contract
-* ``NotaryChangeFlow``, which should be used to change a state's notary
+* ``CollectSignaturesFlow`` (inlined), which should be used to collect a transaction's required signatures
+* ``FinalityFlow`` (initiating), which should be used to notarise and record a transaction
+* ``SendTransactionFlow`` (inlined), which should be used to send a signed transaction if it needed to be resolved on the other side.
+* ``ReceiveTransactionFlow`` (inlined), which should be used receive a signed transaction
+* ``ContractUpgradeFlow`` (initiating), which should be used to change a state's contract
+* ``NotaryChangeFlow`` (initiating), which should be used to change a state's notary
 
-These flows are designed to be used as building blocks in your own flows. You invoke them by calling
-``FlowLogic.subFlow`` from within your flow's ``call`` method. Let's look at three very common examples.
+Let's look at three very common examples.
 
 FinalityFlow
 ^^^^^^^^^^^^
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
index 7d72d528ce..8d92b01786 100644
--- a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
+++ b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
@@ -567,6 +567,13 @@ public class FlowCookbookJava {
             SignedTransaction notarisedTx2 = subFlow(new FinalityFlow(fullySignedTx, additionalParties, FINALISATION.childProgressTracker()));
             // DOCEND 10
 
+            // DOCSTART FlowSession porting
+            send(regulator, new Object()); // Old API
+            // becomes
+            FlowSession session = initiateFlow(regulator);
+            session.send(new Object());
+            // DOCEND FlowSession porting
+
             return null;
         }
     }
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 4b0864d714..6fb9df18b2 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
@@ -121,6 +121,10 @@ object FlowCookbook {
                     throw IllegalArgumentException("Couldn't find counterparty with key: $dummyPubKey in identity service")
             // DOCEND 2
 
+            // DOCSTART initiateFlow
+            val counterpartySession = initiateFlow(counterparty)
+            // DOCEND initiateFlow
+
             /**-----------------------------
              * SENDING AND RECEIVING DATA *
             -----------------------------**/
@@ -137,7 +141,6 @@ object FlowCookbook {
             // registered to respond to this flow, and has a corresponding
             // ``receive`` call.
             // DOCSTART 4
-            val counterpartySession = initiateFlow(counterparty)
             counterpartySession.send(Any())
             // DOCEND 4
 
@@ -496,7 +499,7 @@ object FlowCookbook {
             // other required signers using ``CollectSignaturesFlow``.
             // The responder flow will need to call ``SignTransactionFlow``.
             // DOCSTART 15
-            val fullySignedTx: SignedTransaction = subFlow(CollectSignaturesFlow(twiceSignedTx, emptySet(), SIGS_GATHERING.childProgressTracker()))
+            val fullySignedTx: SignedTransaction = subFlow(CollectSignaturesFlow(twiceSignedTx, setOf(counterpartySession, regulatorSession), SIGS_GATHERING.childProgressTracker()))
             // DOCEND 15
 
             /**-----------------------
@@ -540,6 +543,13 @@ object FlowCookbook {
             val additionalParties: Set<Party> = setOf(regulator)
             val notarisedTx2: SignedTransaction = subFlow(FinalityFlow(fullySignedTx, additionalParties, FINALISATION.childProgressTracker()))
             // DOCEND 10
+
+            // DOCSTART FlowSession porting
+            send(regulator, Any()) // Old API
+            // becomes
+            val session = initiateFlow(regulator)
+            session.send(Any())
+            // DOCEND FlowSession porting
         }
     }
 
diff --git a/docs/source/flow-state-machines.rst b/docs/source/flow-state-machines.rst
index 2ca3b56759..a125c6c221 100644
--- a/docs/source/flow-state-machines.rst
+++ b/docs/source/flow-state-machines.rst
@@ -297,13 +297,13 @@ time, and perhaps communicating with the same counterparty node but for differen
 way to segregate communication channels so that concurrent conversations between flows on the same set of nodes do
 not interfere with each other.
 
-To achieve this the flow framework initiates a new flow session each time a flow starts communicating with a ``Party``
-for the first time. A session is simply a pair of IDs, one for each side, to allow the node to route received messages to
-the correct flow. If the other side accepts the session request then subsequent sends and receives to that same ``Party``
-will use the same session. A session ends when either flow ends, whether as expected or pre-maturely. If a flow ends
-pre-maturely then the other side will be notified of that and they will also end, as the whole point of flows is a known
-sequence of message transfers. Flows end pre-maturely due to exceptions, and as described above, if that exception is
-``FlowException`` or a sub-type then it will propagate to the other side. Any other exception will not propagate.
+To achieve this in order to communicate with a counterparty one needs to first initiate such a session with a ``Party``
+using ``initiateFlow``, which returns a ``FlowSession`` object, identifying this communication. Subsequently the first
+actual communication will kick off a counter-flow on the other side, receiving a "reply" session object. A session ends
+when either flow ends, whether as expected or pre-maturely. If a flow ends pre-maturely then the other side will be
+notified of that and they will also end, as the whole point of flows is a known sequence of message transfers. Flows end
+pre-maturely due to exceptions, and as described above, if that exception is ``FlowException`` or a sub-type then it
+will propagate to the other side. Any other exception will not propagate.
 
 Taking a step back, we mentioned that the other side has to accept the session request for there to be a communication
 channel. A node accepts a session request if it has registered the flow type (the fully-qualified class name) that is

From c8fc1b624b7d34f38bc305a0af6e0078960a15d8 Mon Sep 17 00:00:00 2001
From: Konstantinos Chalkias <konstantinos.chalkias@r3.com>
Date: Wed, 27 Sep 2017 15:51:44 +0100
Subject: [PATCH 026/185] Updating docs w.r.t. new FilteredTransaction and
 TransactionSignature (#1678)

---
 docs/source/oracles.rst                       |  4 +--
 .../source/tutorial-building-transactions.rst |  2 +-
 docs/source/tutorial-tear-offs.rst            | 28 +++++++++++--------
 3 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/docs/source/oracles.rst b/docs/source/oracles.rst
index c8c6de060a..177da9a320 100644
--- a/docs/source/oracles.rst
+++ b/docs/source/oracles.rst
@@ -112,13 +112,13 @@ Here is an extract from the ``NodeInterestRates.Oracle`` class and supporting ty
    class Oracle {
        fun query(queries: List<FixOf>, deadline: Instant): List<Fix>
 
-       fun sign(ftx: FilteredTransaction, txId: SecureHash): DigitalSignature.WithKey
+       fun sign(ftx: FilteredTransaction, txId: SecureHash): TransactionSignature
    }
 
 Because the fix contains a timestamp (the ``forDay`` field), that identifies the version of the data being requested,
 there can be an arbitrary delay between a fix being requested via ``query`` and the signature being requested via ``sign``
 as the Oracle can know which, potentially historical, value it is being asked to sign for.  This is an important
-technique for continously varying data.
+technique for continuously varying data.
 
 The ``query`` method takes a deadline, which is a point in time the requester is willing to wait until for the necessary
 data to be available.  Not every oracle will need this.  This can be useful where data is expected to be available on a
diff --git a/docs/source/tutorial-building-transactions.rst b/docs/source/tutorial-building-transactions.rst
index b8c25bf04a..3a7586dbb9 100644
--- a/docs/source/tutorial-building-transactions.rst
+++ b/docs/source/tutorial-building-transactions.rst
@@ -67,7 +67,7 @@ different ``SignedTransaction``. For instance in a foreign exchange
 scenario we shouldn't send a ``SignedTransaction`` with only our sell
 side populated as that could be used to take the money without the
 expected return of the other currency. Also, it is best practice for
-flows to receive back the ``DigitalSignature.WithKey`` of other parties
+flows to receive back the ``TransactionSignature`` of other parties
 rather than a full ``SignedTransaction`` objects, because otherwise we
 have to separately check that this is still the same
 ``SignedTransaction`` and not a malicious substitute.
diff --git a/docs/source/tutorial-tear-offs.rst b/docs/source/tutorial-tear-offs.rst
index 5187aaac42..12a1ec8512 100644
--- a/docs/source/tutorial-tear-offs.rst
+++ b/docs/source/tutorial-tear-offs.rst
@@ -36,16 +36,18 @@ IRSDemo example. Then we can construct ``FilteredTransaction``:
 In the Oracle example this step takes place in ``RatesFixFlow`` by overriding ``filtering`` function, see:
 :ref:`filtering_ref`.
 
-``FilteredTransaction`` holds ``filteredLeaves`` (data that we wanted to reveal) and Merkle branch for them.
+Both ``WireTransaction`` and ``FilteredTransaction`` inherit from ``TraversableTransaction``, so access to the
+transaction components is exactly the same. Note that unlike ``WireTransaction``,
+``FilteredTransaction`` only holds data that we wanted to reveal (after filtering).
 
 .. container:: codeset
 
    .. sourcecode:: kotlin
 
-        // Direct accsess to included commands, inputs, outputs, attachments etc.
-        val cmds: List<Command> = ftx.filteredLeaves.commands
-        val ins: List<StateRef> = ftx.filteredLeaves.inputs
-        val timeWindow: TimeWindow? = ftx.filteredLeaves.timeWindow
+        // Direct access to included commands, inputs, outputs, attachments etc.
+        val cmds: List<Command> = ftx.commands
+        val ins: List<StateRef> = ftx.inputs
+        val timeWindow: TimeWindow? = ftx.timeWindow
         ...
 
 .. literalinclude:: ../../samples/irs-demo/src/main/kotlin/net/corda/irs/api/NodeInterestRates.kt
@@ -54,8 +56,8 @@ In the Oracle example this step takes place in ``RatesFixFlow`` by overriding ``
     :end-before: DOCEND 1
 
 Above code snippet is taken from ``NodeInterestRates.kt`` file and implements a signing part of an Oracle. You can
-check only leaves using ``leaves.checkWithFun { check(it) }`` and then verify obtained ``FilteredTransaction`` to see
-if data from ``PartialMerkleTree`` belongs to ``WireTransaction`` with provided ``id``. All you need is the root hash
+check only leaves using ``ftx.checkWithFun { check(it) }`` and then verify obtained ``FilteredTransaction`` to see
+if its data belongs to ``WireTransaction`` with provided ``id``. All you need is the root hash
 of the full transaction:
 
 .. container:: codeset
@@ -74,7 +76,11 @@ Or combine the two steps together:
 
         ftx.verifyWithFunction(merkleRoot, ::check)
 
-.. note:: The way the ``FilteredTransaction`` is constructed ensures that after signing of the root hash it's impossible to add or remove
-    leaves. However, it can happen that having transaction with multiple commands one party reveals only subset of them to the Oracle.
-    As signing is done now over the Merkle root hash, the service signs all commands of given type, even though it didn't see
-    all of them. This issue will be handled after implementing partial signatures.
+.. note:: The way the ``FilteredTransaction`` is constructed ensures that after signing of the root hash it's impossible
+to add or remove components (leaves). However, it can happen that having transaction with multiple commands one party
+reveals only subset of them to the Oracle. As signing is done now over the Merkle root hash, the service signs all
+commands of given type, even though it didn't see all of them. In the case however where all of the commands should be
+visible to an Oracle, one can type ``ftx.checkAllComponentsVisible(COMMANDS_GROUP)`` before invoking ``ftx.verify``.
+``checkAllComponentsVisible`` is using a sophisticated underlying partial Merkle tree check to guarantee that all of
+the components of a particular group that existed in the original ``WireTransaction`` are included in the received
+``FilteredTransaction``.

From 5ed755d3fe3a6efc6f6ed93b6effedd04422d8ec Mon Sep 17 00:00:00 2001
From: Katelyn Baker <katelyn.baker@r3.com>
Date: Wed, 27 Sep 2017 18:02:35 +0100
Subject: [PATCH 027/185] CORDA-653 - Serialised enums should respect whitelist
 (#1692)

---
 docs/source/changelog.rst                     |  4 +
 .../serialization/amqp/SerializerFactory.kt   |  1 +
 .../internal/serialization/amqp/EnumTests.kt  | 78 +++++++++++++++++++
 3 files changed, 83 insertions(+)

diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index 2f01167fb3..c32cc9913a 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -9,6 +9,10 @@ UNRELEASED
 
 * ``Cordapp`` now has a name field for identifying CorDapps and all CorDapp names are printed to console at startup.
 
+* Enums now respsect the whitelist applied to the Serializer factory serializing / deserializing them. If the enum isn't
+  either annotated with the @CordaSerializable annotation or explicitly whitelisted then a NotSerializableException is
+  thrown.
+
 Release 1.0
 -----------
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
index fe05093168..2f0a734800 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
@@ -82,6 +82,7 @@ class SerializerFactory(val whitelist: ClassWhitelist, cl: ClassLoader) {
                 }
             }
             Enum::class.java.isAssignableFrom(actualClass ?: declaredClass) -> serializersByType.computeIfAbsent(actualClass ?: declaredClass) {
+                whitelisted(actualType)
                 EnumSerializer(actualType, actualClass ?: declaredClass, this)
             }
             else -> makeClassSerializer(actualClass ?: declaredClass, actualType, declaredType)
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt
index d46ec93c5a..d10152baf0 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt
@@ -1,5 +1,7 @@
 package net.corda.nodeapi.internal.serialization.amqp
 
+import net.corda.core.serialization.ClassWhitelist
+import net.corda.core.serialization.CordaSerializable
 import org.junit.Test
 import java.time.DayOfWeek
 
@@ -10,12 +12,18 @@ import java.io.File
 import java.io.NotSerializableException
 
 import net.corda.core.serialization.SerializedBytes
+import org.assertj.core.api.Assertions
 
 class EnumTests {
     enum class Bras {
         TSHIRT, UNDERWIRE, PUSHUP, BRALETTE, STRAPLESS, SPORTS, BACKLESS, PADDED
     }
 
+    @CordaSerializable
+    enum class AnnotatedBras {
+        TSHIRT, UNDERWIRE, PUSHUP, BRALETTE, STRAPLESS, SPORTS, BACKLESS, PADDED
+    }
+
     // The state of the OldBras enum when the tests in changedEnum1 were serialised
     //      - use if the test file needs regenerating
     //enum class OldBras {
@@ -186,4 +194,74 @@ class EnumTests {
         // we expect this to throw
         DeserializationInput(sf1).deserialize(SerializedBytes<C>(sc2))
     }
+
+    @Test
+    fun enumNotWhitelistedFails() {
+        data class C (val c: Bras)
+
+        class WL (val allowed: String): ClassWhitelist {
+            override fun hasListed(type: Class<*>): Boolean {
+                return type.name == allowed
+            }
+        }
+
+        val factory = SerializerFactory(WL(classTestName("C")), ClassLoader.getSystemClassLoader())
+
+        Assertions.assertThatThrownBy {
+            TestSerializationOutput(VERBOSE, factory).serialize(C(Bras.UNDERWIRE))
+        }.isInstanceOf(NotSerializableException::class.java)
+    }
+
+    @Test
+    fun enumWhitelisted() {
+        data class C (val c: Bras)
+
+        class WL : ClassWhitelist {
+            override fun hasListed(type: Class<*>): Boolean {
+                return type.name == "net.corda.nodeapi.internal.serialization.amqp.EnumTests\$enumWhitelisted\$C" ||
+                        type.name == "net.corda.nodeapi.internal.serialization.amqp.EnumTests\$Bras"
+            }
+        }
+
+        val factory = SerializerFactory(WL(), ClassLoader.getSystemClassLoader())
+
+        // if it all works, this won't explode
+        TestSerializationOutput(VERBOSE, factory).serialize(C(Bras.UNDERWIRE))
+    }
+
+    @Test
+    fun enumAnnotated() {
+        @CordaSerializable data class C (val c: AnnotatedBras)
+
+        class WL : ClassWhitelist {
+            override fun hasListed(type: Class<*>) = false
+        }
+
+        val factory = SerializerFactory(WL(), ClassLoader.getSystemClassLoader())
+
+        // if it all works, this won't explode
+        TestSerializationOutput(VERBOSE, factory).serialize(C(AnnotatedBras.UNDERWIRE))
+    }
+
+    @Test
+    fun deserializeNonWhitlistedEnum() {
+        data class C (val c: Bras)
+
+        class WL (val allowed: List<String>) : ClassWhitelist {
+            override fun hasListed(type: Class<*>) = type.name in allowed
+        }
+
+        // first serialise the class using a context in which Bras are whitelisted
+        val factory = SerializerFactory(WL(listOf (classTestName("C"),
+                "net.corda.nodeapi.internal.serialization.amqp.EnumTests\$Bras")),
+                ClassLoader.getSystemClassLoader())
+        val bytes = TestSerializationOutput(VERBOSE, factory).serialize(C(Bras.UNDERWIRE))
+
+        // then take that serialised object and attempt to deserialize it in a context that
+        // disallows the Bras enum
+        val factory2 = SerializerFactory(WL(listOf (classTestName("C"))), ClassLoader.getSystemClassLoader())
+        Assertions.assertThatThrownBy {
+            DeserializationInput(factory2).deserialize(bytes)
+        }.isInstanceOf(NotSerializableException::class.java)
+    }
 }
\ No newline at end of file

From 334164aa8605d79cfef2831cc484dcf0c7a5d16a Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Wed, 27 Sep 2017 18:34:17 +0100
Subject: [PATCH 028/185] Fixed several bugs in the contract constraints work
 (#1695)

* Added schedulable flows to cordapp scanning
* Fixed a bug where the core flows are included in every cordapp.
* Added a test to prove the scheduled flows are loaded correctly.
* Enabled a negative test to prove that we are not currently dynamically loading attachment classes from the network.
---
 .idea/compiler.xml                            |   2 +
 .../kotlin/net/corda/core/cordapp/Cordapp.kt  |   2 +
 .../core/internal/cordapp/CordappImpl.kt      |   1 +
 .../core/transactions/WireTransaction.kt      |   3 +-
 .../node/services/AttachmentLoadingTests.kt   |  17 +--
 .../net/corda/node/internal/AbstractNode.kt   |   7 +-
 .../kotlin/net/corda/node/internal/Node.kt    |  10 +-
 .../node/internal/cordapp/CordappLoader.kt    |  98 +++++++++++++-----
 .../internal/cordapp/CordappProviderImpl.kt   |   2 +-
 .../node/services/messaging/RPCServer.kt      |   2 +-
 .../corda/node/cordapp/CordappLoaderTest.kt   |  54 ----------
 .../internal/cordapp/CordappLoaderTest.kt     |  89 ++++++++++++++++
 .../cordapp/CordappProviderImplTests.kt       |   4 +-
 .../node/{ => internal}/cordapp/empty.jar     | Bin
 .../node/{ => internal}/cordapp/isolated.jar  | Bin
 .../corda/testing/node/MockCordappProvider.kt |   2 +-
 16 files changed, 193 insertions(+), 100 deletions(-)
 delete mode 100644 node/src/test/kotlin/net/corda/node/cordapp/CordappLoaderTest.kt
 create mode 100644 node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
 rename node/src/test/kotlin/net/corda/node/{ => internal}/cordapp/CordappProviderImplTests.kt (94%)
 rename node/src/test/resources/net/corda/node/{ => internal}/cordapp/empty.jar (100%)
 rename node/src/test/resources/net/corda/node/{ => internal}/cordapp/isolated.jar (100%)

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index f0b65c5a84..2d6467076b 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -41,6 +41,8 @@
       <module name="explorer_test" target="1.8" />
       <module name="finance_main" target="1.8" />
       <module name="finance_test" target="1.8" />
+      <module name="gradle-plugins-cordform-common_main" target="1.8" />
+      <module name="gradle-plugins-cordform-common_test" target="1.8" />
       <module name="graphs_main" target="1.8" />
       <module name="graphs_test" target="1.8" />
       <module name="irs-demo_integrationTest" target="1.8" />
diff --git a/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt b/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
index 2df896cbbe..ea9557d7c9 100644
--- a/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
+++ b/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
@@ -17,6 +17,7 @@ import java.net.URL
  * @property contractClassNames List of contracts
  * @property initiatedFlows List of initiatable flow classes
  * @property rpcFlows List of RPC initiable flows classes
+ * @property schedulableFlows List of flows startable by the scheduler
  * @property servies List of RPC services
  * @property plugins List of Corda plugin registries
  * @property customSchemas List of custom schemas
@@ -27,6 +28,7 @@ interface Cordapp {
     val contractClassNames: List<String>
     val initiatedFlows: List<Class<out FlowLogic<*>>>
     val rpcFlows: List<Class<out FlowLogic<*>>>
+    val schedulableFlows: List<Class<out FlowLogic<*>>>
     val services: List<Class<out SerializeAsToken>>
     val plugins: List<CordaPluginRegistry>
     val customSchemas: Set<MappedSchema>
diff --git a/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt b/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
index 38a5a0ecf4..8cfda77d42 100644
--- a/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
@@ -12,6 +12,7 @@ data class CordappImpl(
         override val contractClassNames: List<String>,
         override val initiatedFlows: List<Class<out FlowLogic<*>>>,
         override val rpcFlows: List<Class<out FlowLogic<*>>>,
+        override val schedulableFlows: List<Class<out FlowLogic<*>>>,
         override val services: List<Class<out SerializeAsToken>>,
         override val plugins: List<CordaPluginRegistry>,
         override val customSchemas: Set<MappedSchema>,
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 39de4816a9..3bba0b8ae6 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt
@@ -114,7 +114,8 @@ class WireTransaction(componentGroups: List<ComponentGroup>, val privacySalt: Pr
         }
         // Open attachments specified in this transaction. If we haven't downloaded them, we fail.
         val contractAttachments = findAttachmentContracts(resolvedInputs, resolveContractAttachment, resolveAttachment)
-        val attachments = contractAttachments + (attachments.map { resolveAttachment(it) ?: throw AttachmentResolutionException(it) }).distinct()
+        // Order of attachments is important since contracts may refer to indexes so only append automatic attachments
+        val attachments = (attachments.map { resolveAttachment(it) ?: throw AttachmentResolutionException(it) } + contractAttachments).distinct()
         return LedgerTransaction(resolvedInputs, outputs, authenticatedArgs, attachments, id, notary, timeWindow, privacySalt)
     }
 
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
index 03b9a9435e..4a344aec4e 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@@ -1,5 +1,6 @@
 package net.corda.node.services
 
+import net.corda.client.rpc.RPCException
 import net.corda.core.contracts.Contract
 import net.corda.core.contracts.PartyAndReference
 import net.corda.core.cordapp.CordappProvider
@@ -13,6 +14,7 @@ import net.corda.core.serialization.SerializationFactory
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.getOrThrow
+import net.corda.core.utilities.loggerFor
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
 import net.corda.nodeapi.User
@@ -21,6 +23,7 @@ import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.TestDependencyInjectionBase
 import net.corda.testing.driver.driver
 import net.corda.testing.node.MockServices
+import net.corda.testing.resetTestSerialization
 import org.junit.Assert.*
 import org.junit.Before
 import org.junit.Test
@@ -37,9 +40,10 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
         override val cordappProvider: CordappProvider = provider
     }
 
-    companion object {
-        private val isolatedJAR = this::class.java.getResource("isolated.jar")!!
-        private val ISOLATED_CONTRACT_ID = "net.corda.finance.contracts.isolated.AnotherDummyContract"
+    private companion object {
+        val logger = loggerFor<AttachmentLoadingTests>()
+        val isolatedJAR = AttachmentLoadingTests::class.java.getResource("isolated.jar")!!
+        val ISOLATED_CONTRACT_ID = "net.corda.finance.contracts.isolated.AnotherDummyContract"
     }
 
     private lateinit var services: Services
@@ -67,19 +71,20 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
         assertEquals(expected, actual)
     }
 
-    // TODO - activate this test
-    // @Test
+    @Test
     fun `test that attachments retrieved over the network are not used for code`() {
         driver(initialiseSerialization = false) {
             val bankAName = CordaX500Name("BankA", "Zurich", "CH")
             val bankBName = CordaX500Name("BankB", "Zurich", "CH")
             // Copy the app jar to the first node. The second won't have it.
             val path = (baseDirectory(bankAName.toString()) / "plugins").createDirectories() / "isolated.jar"
+            logger.info("Installing isolated jar to $path")
             isolatedJAR.openStream().buffered().use { input ->
                 Files.newOutputStream(path).buffered().use { output ->
                     input.copyTo(output)
                 }
             }
+
             val admin = User("admin", "admin", permissions = setOf("ALL"))
             val (bankA, bankB) = listOf(
                     startNode(providedName = bankAName, rpcUsers = listOf(admin)),
@@ -95,7 +100,7 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
                     val proxy = rpc.proxy
                     val party = proxy.wellKnownPartyFromX500Name(bankBName)!!
 
-                    assertFailsWith<Exception>("xxx") {
+                    assertFailsWith<RPCException>("net.corda.client.rpc.RPCException: net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Initiator") {
                         proxy.startFlowDynamic(clazz, party).returnValue.getOrThrow()
                     }
                 }
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 6ba72a75d6..ec5034ccdb 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -147,6 +147,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
     protected lateinit var database: CordaPersistence
     protected var dbCloser: (() -> Any?)? = null
     lateinit var cordappProvider: CordappProviderImpl
+    protected val cordappLoader by lazy { makeCordappLoader() }
 
     protected val _nodeReadyFuture = openFuture<Unit>()
     /** Completes once the node has successfully registered with the network map service
@@ -378,7 +379,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
      */
     private fun makeServices(): MutableList<Any> {
         checkpointStorage = DBCheckpointStorage()
-        cordappProvider = CordappProviderImpl(makeCordappLoader())
+        cordappProvider = CordappProviderImpl(cordappLoader)
         _services = ServiceHubInternalImpl()
         attachments = NodeAttachmentService(services.monitoringService.metrics)
         cordappProvider.start(attachments)
@@ -399,10 +400,10 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         val scanPackages = System.getProperty("net.corda.node.cordapp.scan.packages")
         return if (CordappLoader.testPackages.isNotEmpty()) {
             check(configuration.devMode) { "Package scanning can only occur in dev mode" }
-            CordappLoader.createWithTestPackages(CordappLoader.testPackages)
+            CordappLoader.createDefaultWithTestPackages(configuration.baseDirectory, CordappLoader.testPackages)
         } else if (scanPackages != null) {
             check(configuration.devMode) { "Package scanning can only occur in dev mode" }
-            CordappLoader.createWithTestPackages(scanPackages.split(","))
+            CordappLoader.createDefaultWithTestPackages(configuration.baseDirectory, scanPackages.split(","))
         } else {
             CordappLoader.createDefault(configuration.baseDirectory)
         }
diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt
index bc4dcb386f..17660cfe37 100644
--- a/node/src/main/kotlin/net/corda/node/internal/Node.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt
@@ -14,6 +14,7 @@ import net.corda.core.node.ServiceHub
 import net.corda.core.serialization.SerializationDefaults
 import net.corda.core.utilities.*
 import net.corda.node.VersionInfo
+import net.corda.node.internal.cordapp.CordappProviderImpl
 import net.corda.node.serialization.KryoServerSerializationScheme
 import net.corda.node.serialization.NodeClock
 import net.corda.node.services.RPCUserService
@@ -340,14 +341,15 @@ open class Node(override val configuration: FullNodeConfiguration,
     }
 
     private fun initialiseSerialization() {
+        val classloader = cordappLoader.appClassLoader
         SerializationDefaults.SERIALIZATION_FACTORY = SerializationFactoryImpl().apply {
             registerScheme(KryoServerSerializationScheme())
             registerScheme(AMQPServerSerializationScheme())
         }
-        SerializationDefaults.P2P_CONTEXT = KRYO_P2P_CONTEXT
-        SerializationDefaults.RPC_SERVER_CONTEXT = KRYO_RPC_SERVER_CONTEXT
-        SerializationDefaults.STORAGE_CONTEXT = KRYO_STORAGE_CONTEXT
-        SerializationDefaults.CHECKPOINT_CONTEXT = KRYO_CHECKPOINT_CONTEXT
+        SerializationDefaults.P2P_CONTEXT = KRYO_P2P_CONTEXT.withClassLoader(classloader)
+        SerializationDefaults.RPC_SERVER_CONTEXT = KRYO_RPC_SERVER_CONTEXT.withClassLoader(classloader)
+        SerializationDefaults.STORAGE_CONTEXT = KRYO_STORAGE_CONTEXT.withClassLoader(classloader)
+        SerializationDefaults.CHECKPOINT_CONTEXT = KRYO_CHECKPOINT_CONTEXT.withClassLoader(classloader)
     }
 
     /** Starts a blocking event loop for message dispatch. */
diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
index f29fe98ed4..bb98afbe43 100644
--- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
@@ -5,10 +5,7 @@ import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult
 import net.corda.core.contracts.Contract
 import net.corda.core.contracts.UpgradedContract
 import net.corda.core.cordapp.Cordapp
-import net.corda.core.flows.ContractUpgradeFlow
-import net.corda.core.flows.FlowLogic
-import net.corda.core.flows.InitiatedBy
-import net.corda.core.flows.StartableByRPC
+import net.corda.core.flows.*
 import net.corda.core.internal.*
 import net.corda.core.internal.cordapp.CordappImpl
 import net.corda.core.node.CordaPluginRegistry
@@ -40,10 +37,17 @@ import kotlin.streams.toList
  * @property cordappJarPaths The classpath of cordapp JARs
  */
 class CordappLoader private constructor(private val cordappJarPaths: List<URL>) {
-    val cordapps: List<Cordapp> by lazy { loadCordapps() }
+    val cordapps: List<Cordapp> by lazy { loadCordapps() + coreCordapp }
 
-    @VisibleForTesting
-    internal val appClassLoader: ClassLoader = javaClass.classLoader
+    internal val appClassLoader: ClassLoader = URLClassLoader(cordappJarPaths.toTypedArray(), javaClass.classLoader)
+
+    init {
+        if (cordappJarPaths.isEmpty()) {
+            logger.info("No CorDapp paths provided")
+        } else {
+            logger.info("Loading CorDapps from ${cordappJarPaths.joinToString()}")
+        }
+    }
 
     companion object {
         private val logger = loggerFor<CordappLoader>()
@@ -54,19 +58,31 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
          * @param baseDir The directory that this node is running in. Will use this to resolve the plugins directory
          *                  for classpath scanning.
          */
-        fun createDefault(baseDir: Path): CordappLoader {
-            val pluginsDir = getPluginsPath(baseDir)
-            return CordappLoader(if (!pluginsDir.exists()) emptyList<URL>() else pluginsDir.list {
-                it.filter { it.isRegularFile() && it.toString().endsWith(".jar") }.map { it.toUri().toURL() }.toList()
-            })
-        }
-
-        fun getPluginsPath(baseDir: Path): Path = baseDir / "plugins"
+        fun createDefault(baseDir: Path) = CordappLoader(getCordappsInDirectory(getPluginsPath(baseDir)))
 
         /**
-         * Create a dev mode CordappLoader for test environments
+         * Create a dev mode CordappLoader for test environments that creates and loads cordapps from the classpath
+         * and plugins directory. This is intended mostly for use by the driver.
+         *
+         * @param baseDir See [createDefault.baseDir]
+         * @param testPackages See [createWithTestPackages.testPackages]
          */
-        fun createWithTestPackages(testPackages: List<String> = CordappLoader.testPackages) = CordappLoader(testPackages.flatMap(this::createScanPackage))
+        @VisibleForTesting
+        @JvmOverloads
+        fun createDefaultWithTestPackages(baseDir: Path, testPackages: List<String> = CordappLoader.testPackages)
+                = CordappLoader(getCordappsInDirectory(getPluginsPath(baseDir)) + testPackages.flatMap(this::createScanPackage))
+
+        /**
+         * Create a dev mode CordappLoader for test environments that creates and loads cordapps from the classpath.
+         * This is intended for use in unit and integration tests.
+         *
+         * @param testPackages List of package names that contain CorDapp classes that can be automatically turned into
+         * CorDapps.
+         */
+        @VisibleForTesting
+        @JvmOverloads
+        fun createWithTestPackages(testPackages: List<String> = CordappLoader.testPackages)
+                = CordappLoader(testPackages.flatMap(this::createScanPackage))
 
         /**
          * Creates a dev mode CordappLoader intended only to be used in test environments
@@ -76,6 +92,8 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
         @VisibleForTesting
         fun createDevMode(scanJars: List<URL>) = CordappLoader(scanJars)
 
+        private fun getPluginsPath(baseDir: Path): Path = baseDir / "plugins"
+
         private fun createScanPackage(scanPackage: String): List<URL> {
             val resource = scanPackage.replace('.', '/')
             return this::class.java.classLoader.getResources(resource)
@@ -90,7 +108,7 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
                     .toList()
         }
 
-        /** Takes a package of classes and creates a JAR from them - only use in tests */
+        /** Takes a package of classes and creates a JAR from them - only use in tests. */
         private fun createDevCordappJar(scanPackage: String, path: URL, jarPackageName: String): URI {
             if(!generatedCordapps.contains(path)) {
                 val cordappDir = File("build/tmp/generated-test-cordapps")
@@ -118,12 +136,41 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
             return generatedCordapps[path]!!
         }
 
+        private fun getCordappsInDirectory(pluginsDir: Path): List<URL> {
+            return if (!pluginsDir.exists()) {
+                emptyList<URL>()
+            } else {
+                pluginsDir.list {
+                    it.filter { it.isRegularFile() && it.toString().endsWith(".jar") }.map { it.toUri().toURL() }.toList()
+                }
+            }
+        }
+
         /**
-         * A list of test packages that will be scanned as CorDapps and compiled into CorDapp JARs for use in tests only
+         * A list of test packages that will be scanned as CorDapps and compiled into CorDapp JARs for use in tests only.
          */
         @VisibleForTesting
         var testPackages: List<String> = emptyList()
         private val generatedCordapps = mutableMapOf<URL, URI>()
+
+        /** A list of the core RPC flows present in Corda */
+        private val coreRPCFlows = listOf(
+                ContractUpgradeFlow.Initiate::class.java,
+                ContractUpgradeFlow.Authorise::class.java,
+                ContractUpgradeFlow.Deauthorise::class.java)
+
+        /** A Cordapp representing the core package which is not scanned automatically. */
+        @VisibleForTesting
+        internal val coreCordapp = CordappImpl(
+                listOf(),
+                listOf(),
+                coreRPCFlows,
+                listOf(),
+                listOf(),
+                listOf(),
+                setOf(),
+                ContractUpgradeFlow.javaClass.protectionDomain.codeSource.location // Core JAR location
+        )
     }
 
     private fun loadCordapps(): List<Cordapp> {
@@ -132,6 +179,7 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
             CordappImpl(findContractClassNames(scanResult),
                     findInitiatedFlows(scanResult),
                     findRPCFlows(scanResult),
+                    findSchedulableFlows(scanResult),
                     findServices(scanResult),
                     findPlugins(it),
                     findCustomSchemas(scanResult),
@@ -163,13 +211,11 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
             return Modifier.isPublic(modifiers) && !isLocalClass && !isAnonymousClass && (!isMemberClass || Modifier.isStatic(modifiers))
         }
 
-        val found = scanResult.getClassesWithAnnotation(FlowLogic::class, StartableByRPC::class).filter { it.isUserInvokable() }
-        val coreFlows = listOf(
-                ContractUpgradeFlow.Initiate::class.java,
-                ContractUpgradeFlow.Authorise::class.java,
-                ContractUpgradeFlow.Deauthorise::class.java
-        )
-        return found + coreFlows
+        return scanResult.getClassesWithAnnotation(FlowLogic::class, StartableByRPC::class).filter { it.isUserInvokable() }
+    }
+
+    private fun findSchedulableFlows(scanResult: ScanResult): List<Class<out FlowLogic<*>>> {
+        return scanResult.getClassesWithAnnotation(FlowLogic::class, SchedulableFlow::class)
     }
 
     private fun findContractClassNames(scanResult: ScanResult): List<String> {
diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt
index 3eb485787f..9c3f58293f 100644
--- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt
@@ -66,7 +66,7 @@ open class CordappProviderImpl(private val cordappLoader: CordappLoader) : Singl
      * @return A cordapp context for the given CorDapp
      */
     fun getAppContext(cordapp: Cordapp): CordappContext {
-        return CordappContext(cordapp, getCordappAttachmentId(cordapp), URLClassLoader(arrayOf(cordapp.jarPath), cordappLoader.appClassLoader))
+        return CordappContext(cordapp, getCordappAttachmentId(cordapp), cordappLoader.appClassLoader)
     }
 
     /**
diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt b/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
index 70761cfc4e..ad2eb239fa 100644
--- a/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
+++ b/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
@@ -459,4 +459,4 @@ object RpcServerObservableSerializer : Serializer<Observable<*>>() {
         observableContext.clientAddressToObservables.put(observableContext.clientAddress, observableId)
         observableContext.observableMap.put(observableId, observableWithSubscription)
     }
-}
\ No newline at end of file
+}
diff --git a/node/src/test/kotlin/net/corda/node/cordapp/CordappLoaderTest.kt b/node/src/test/kotlin/net/corda/node/cordapp/CordappLoaderTest.kt
deleted file mode 100644
index aadf3ee066..0000000000
--- a/node/src/test/kotlin/net/corda/node/cordapp/CordappLoaderTest.kt
+++ /dev/null
@@ -1,54 +0,0 @@
-package net.corda.node.cordapp
-
-import net.corda.core.flows.FlowLogic
-import net.corda.core.flows.InitiatedBy
-import net.corda.core.flows.InitiatingFlow
-import net.corda.node.internal.cordapp.CordappLoader
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Test
-import java.nio.file.Paths
-
-@InitiatingFlow
-class DummyFlow : FlowLogic<Unit>() {
-    override fun call() { }
-}
-
-@InitiatedBy(DummyFlow::class)
-class LoaderTestFlow : FlowLogic<Unit>() {
-    override fun call() { }
-}
-
-class CordappLoaderTest {
-    @Test
-    fun `test that classes that aren't in cordapps aren't loaded`() {
-        // Basedir will not be a corda node directory so the dummy flow shouldn't be recognised as a part of a cordapp
-        val loader = CordappLoader.createDefault(Paths.get("."))
-        assertThat(loader.cordapps).isEmpty()
-    }
-
-    @Test
-    fun `test that classes that are in a cordapp are loaded`() {
-        val loader = CordappLoader.createWithTestPackages(listOf("net.corda.node.cordapp"))
-        val initiatedFlows = loader.cordapps.first().initiatedFlows
-        val expectedClass = loader.appClassLoader.loadClass("net.corda.node.cordapp.LoaderTestFlow").asSubclass(FlowLogic::class.java)
-        assertThat(initiatedFlows).contains(expectedClass)
-    }
-
-    @Test
-    fun `isolated JAR contains a CorDapp with a contract and plugin`() {
-        val isolatedJAR = CordappLoaderTest::class.java.getResource("isolated.jar")!!
-        val loader = CordappLoader.createDevMode(listOf(isolatedJAR))
-
-        val actual = loader.cordapps.toTypedArray()
-        assertThat(actual).hasSize(1)
-
-        val actualCordapp = actual.first()
-        assertThat(actualCordapp.contractClassNames).isEqualTo(listOf("net.corda.finance.contracts.isolated.AnotherDummyContract"))
-        assertThat(actualCordapp.initiatedFlows).isEmpty()
-        assertThat(actualCordapp.rpcFlows).contains(loader.appClassLoader.loadClass("net.corda.core.flows.ContractUpgradeFlow\$Initiate").asSubclass(FlowLogic::class.java))
-        assertThat(actualCordapp.services).isEmpty()
-        assertThat(actualCordapp.plugins).hasSize(1)
-        assertThat(actualCordapp.plugins.first().javaClass.name).isEqualTo("net.corda.finance.contracts.isolated.IsolatedPlugin")
-        assertThat(actualCordapp.jarPath).isEqualTo(isolatedJAR)
-    }
-}
diff --git a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
new file mode 100644
index 0000000000..806b7ac929
--- /dev/null
+++ b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
@@ -0,0 +1,89 @@
+package net.corda.node.internal.cordapp
+
+import net.corda.core.flows.*
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import java.nio.file.Paths
+
+@InitiatingFlow
+class DummyFlow : FlowLogic<Unit>() {
+    override fun call() { }
+}
+
+@InitiatedBy(DummyFlow::class)
+class LoaderTestFlow(unusedSession: FlowSession) : FlowLogic<Unit>() {
+    override fun call() { }
+}
+
+@SchedulableFlow
+class DummySchedulableFlow : FlowLogic<Unit>() {
+    override fun call() { }
+}
+
+@StartableByRPC
+class DummyRPCFlow : FlowLogic<Unit>() {
+    override fun call() { }
+}
+
+class CordappLoaderTest {
+    private companion object {
+        val testScanPackages = listOf("net.corda.node.internal.cordapp")
+        val isolatedContractId = "net.corda.finance.contracts.isolated.AnotherDummyContract"
+        val isolatedFlowName = "net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Initiator"
+    }
+
+    @Test
+    fun `test that classes that aren't in cordapps aren't loaded`() {
+        // Basedir will not be a corda node directory so the dummy flow shouldn't be recognised as a part of a cordapp
+        val loader = CordappLoader.createDefault(Paths.get("."))
+        assertThat(loader.cordapps)
+                .hasSize(1)
+                .contains(CordappLoader.coreCordapp)
+    }
+
+    @Test
+    fun `isolated JAR contains a CorDapp with a contract and plugin`() {
+        val isolatedJAR = CordappLoaderTest::class.java.getResource("isolated.jar")!!
+        val loader = CordappLoader.createDevMode(listOf(isolatedJAR))
+
+        val actual = loader.cordapps.toTypedArray()
+        assertThat(actual).hasSize(2)
+
+        val actualCordapp = actual.single { it != CordappLoader.coreCordapp }
+        assertThat(actualCordapp.contractClassNames).isEqualTo(listOf(isolatedContractId))
+        assertThat(actualCordapp.initiatedFlows.single().name).isEqualTo("net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Acceptor")
+        assertThat(actualCordapp.rpcFlows).isEmpty()
+        assertThat(actualCordapp.schedulableFlows).isEmpty()
+        assertThat(actualCordapp.services).isEmpty()
+        assertThat(actualCordapp.plugins).hasSize(1)
+        assertThat(actualCordapp.plugins.first().javaClass.name).isEqualTo("net.corda.finance.contracts.isolated.IsolatedPlugin")
+        assertThat(actualCordapp.jarPath).isEqualTo(isolatedJAR)
+    }
+
+    @Test
+    fun `flows are loaded by loader`() {
+        val loader = CordappLoader.createWithTestPackages(testScanPackages)
+
+        val actual = loader.cordapps.toTypedArray()
+        // One core cordapp, one cordapp from this source tree, and two others due to identically named locations
+        // in resources and the non-test part of node. This is okay due to this being test code. In production this
+        // cannot happen. In gradle it will also pick up the node jar. 
+        assertThat(actual.size == 4 || actual.size == 5).isTrue()
+
+        val actualCordapp = actual.single { !it.initiatedFlows.isEmpty() }
+        assertThat(actualCordapp.initiatedFlows).first().hasSameClassAs(DummyFlow::class.java)
+        assertThat(actualCordapp.rpcFlows).first().hasSameClassAs(DummyRPCFlow::class.java)
+        assertThat(actualCordapp.schedulableFlows).first().hasSameClassAs(DummySchedulableFlow::class.java)
+    }
+
+    // This test exists because the appClassLoader is used by serialisation and we need to ensure it is the classloader
+    // being used internally. Later iterations will use a classloader per cordapp and this test can be retired.
+    @Test
+    fun `cordapp classloader can load cordapp classes`() {
+        val isolatedJAR = CordappLoaderTest::class.java.getResource("isolated.jar")!!
+        val loader = CordappLoader.createDevMode(listOf(isolatedJAR))
+
+        loader.appClassLoader.loadClass(isolatedContractId)
+        loader.appClassLoader.loadClass(isolatedFlowName)
+    }
+}
diff --git a/node/src/test/kotlin/net/corda/node/cordapp/CordappProviderImplTests.kt b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt
similarity index 94%
rename from node/src/test/kotlin/net/corda/node/cordapp/CordappProviderImplTests.kt
rename to node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt
index 762761d99e..10dcd4a3ad 100644
--- a/node/src/test/kotlin/net/corda/node/cordapp/CordappProviderImplTests.kt
+++ b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt
@@ -1,8 +1,6 @@
-package net.corda.node.cordapp
+package net.corda.node.internal.cordapp
 
 import net.corda.core.node.services.AttachmentStorage
-import net.corda.node.internal.cordapp.CordappLoader
-import net.corda.node.internal.cordapp.CordappProviderImpl
 import net.corda.testing.node.MockAttachmentStorage
 import org.junit.Assert
 import org.junit.Before
diff --git a/node/src/test/resources/net/corda/node/cordapp/empty.jar b/node/src/test/resources/net/corda/node/internal/cordapp/empty.jar
similarity index 100%
rename from node/src/test/resources/net/corda/node/cordapp/empty.jar
rename to node/src/test/resources/net/corda/node/internal/cordapp/empty.jar
diff --git a/node/src/test/resources/net/corda/node/cordapp/isolated.jar b/node/src/test/resources/net/corda/node/internal/cordapp/isolated.jar
similarity index 100%
rename from node/src/test/resources/net/corda/node/cordapp/isolated.jar
rename to node/src/test/resources/net/corda/node/internal/cordapp/isolated.jar
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
index a0ca53fe0e..f51d59d20d 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
@@ -14,7 +14,7 @@ class MockCordappProvider(cordappLoader: CordappLoader) : CordappProviderImpl(co
     val cordappRegistry = mutableListOf<Pair<Cordapp, AttachmentId>>()
 
     fun addMockCordapp(contractClassName: ContractClassName, services: ServiceHub) {
-        val cordapp = CordappImpl(listOf(contractClassName), emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), Paths.get(".").toUri().toURL())
+        val cordapp = CordappImpl(listOf(contractClassName), emptyList(), emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), Paths.get(".").toUri().toURL())
         if (cordappRegistry.none { it.first.contractClassNames.contains(contractClassName) }) {
             cordappRegistry.add(Pair(cordapp, findOrImportAttachment(contractClassName.toByteArray(), services)))
         }

From f59b22ba9808d8dd5874fff57e40979e18eb04a5 Mon Sep 17 00:00:00 2001
From: Katelyn Baker <katelyn.baker@r3.com>
Date: Mon, 25 Sep 2017 20:37:19 +0100
Subject: [PATCH 029/185] CORDA-601 - Carpenter should respect whitelist

The class carpenter should refuse to carpent classes that are not
whitelisted or marked as CordaSerializable. This prevents any security
issue where a malicious message could indicate a class had a member of
some type that on construction did something bad. By respecting the
whitelist we avoid this.

As the carpeter annotates anythign it constructs as CordaSerializable,
it will always be able to carpent classes that contain memebrs that were
unknown, and thus unannotated, carpented classes
---
 .../serialization/amqp/SerializationHelper.kt |  26 ++++-
 .../serialization/amqp/SerializerFactory.kt   |  23 +---
 .../serialization/carpenter/ClassCarpenter.kt |  37 +++++--
 .../serialization/carpenter/Schema.kt         |  22 +++-
 .../carpenter/ClassCarpenterWhitelistTest.kt  | 100 ++++++++++++++++++
 5 files changed, 174 insertions(+), 34 deletions(-)
 create mode 100644 node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterWhitelistTest.kt

diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
index 45df43799e..1a56cf901b 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
@@ -1,5 +1,7 @@
 package net.corda.nodeapi.internal.serialization.amqp
 
+import net.corda.core.serialization.ClassWhitelist
+import net.corda.core.serialization.CordaSerializable
 import com.google.common.primitives.Primitives
 import com.google.common.reflect.TypeToken
 import net.corda.core.serialization.SerializationContext
@@ -51,7 +53,7 @@ internal fun constructorForDeserialization(type: Type): KFunction<Any>? {
             }
         }
 
-        return preferredCandidate?.apply { isAccessible = true}
+        return preferredCandidate?.apply { isAccessible = true }
                 ?: throw NotSerializableException("No constructor for deserialization found for $clazz.")
     } else {
         return null
@@ -81,7 +83,7 @@ private fun <T : Any> propertiesForSerializationFromConstructor(kotlinConstructo
         val name = param.name ?: throw NotSerializableException("Constructor parameter of $clazz has no name.")
         val matchingProperty = properties[name] ?:
                 throw NotSerializableException("No property matching constructor parameter named $name of $clazz." +
-                " If using Java, check that you have the -parameters option specified in the Java compiler.")
+                        " If using Java, check that you have the -parameters option specified in the Java compiler.")
         // Check that the method has a getter in java.
         val getter = matchingProperty.readMethod ?: throw NotSerializableException("Property has no getter method for $name of $clazz." +
                 " If using Java and the parameter name looks anonymous, check that you have the -parameters option specified in the Java compiler.")
@@ -123,7 +125,7 @@ private fun exploreType(type: Type?, interfaces: MutableSet<Type>, serializerFac
     val clazz = type?.asClass()
     if (clazz != null) {
         if (clazz.isInterface) {
-            if(serializerFactory.isNotWhitelisted(clazz)) return // We stop exploring once we reach a branch that has no `CordaSerializable` annotation or whitelisting.
+            if (serializerFactory.whitelist.isNotWhitelisted(clazz)) return // We stop exploring once we reach a branch that has no `CordaSerializable` annotation or whitelisting.
             else interfaces += type
         }
         for (newInterface in clazz.genericInterfaces) {
@@ -263,3 +265,21 @@ private fun Throwable.setMessage(newMsg: String) {
     detailMessageField.isAccessible = true
     detailMessageField.set(this, newMsg)
 }
+
+fun ClassWhitelist.whitelisted(type: Type) {
+    val clazz = type.asClass()!!
+    if (isNotWhitelisted(clazz)) {
+        throw NotSerializableException("Class $type is not on the whitelist or annotated with @CordaSerializable.")
+    }
+}
+
+// Ignore SimpleFieldAccess as we add it to anything we build in the carpenter.
+fun ClassWhitelist.isNotWhitelisted(clazz: Class<*>) =
+        !(hasListed(clazz) || hasAnnotationInHierarchy(clazz))
+
+// Recursively check the class, interfaces and superclasses for our annotation.
+fun ClassWhitelist.hasAnnotationInHierarchy(type: Class<*>): Boolean {
+    return type.isAnnotationPresent(CordaSerializable::class.java)
+            || type.interfaces.any { hasAnnotationInHierarchy(it) }
+            || (type.superclass != null && hasAnnotationInHierarchy(type.superclass))
+}
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
index 2f0a734800..65083a6150 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
@@ -4,7 +4,6 @@ import com.google.common.primitives.Primitives
 import com.google.common.reflect.TypeResolver
 import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.ClassWhitelist
-import net.corda.core.serialization.CordaSerializable
 import net.corda.nodeapi.internal.serialization.carpenter.*
 import org.apache.qpid.proton.amqp.*
 import java.io.NotSerializableException
@@ -243,10 +242,10 @@ class SerializerFactory(val whitelist: ClassWhitelist, cl: ClassLoader) {
                     if (clazz.componentType.isPrimitive) PrimArraySerializer.make(type, this)
                     else ArraySerializer.make(type, this)
                 } else if (clazz.kotlin.objectInstance != null) {
-                    whitelisted(clazz)
+                    whitelist.whitelisted(clazz)
                     SingletonSerializer(clazz, clazz.kotlin.objectInstance!!, this)
                 } else {
-                    whitelisted(type)
+                    whitelist.whitelisted(type)
                     ObjectSerializer(type, this)
                 }
             }
@@ -271,24 +270,6 @@ class SerializerFactory(val whitelist: ClassWhitelist, cl: ClassLoader) {
         return null
     }
 
-    private fun whitelisted(type: Type) {
-        val clazz = type.asClass()!!
-        if (isNotWhitelisted(clazz)) {
-            throw NotSerializableException("Class $type is not on the whitelist or annotated with @CordaSerializable.")
-        }
-    }
-
-    // Ignore SimpleFieldAccess as we add it to anything we build in the carpenter.
-    internal fun isNotWhitelisted(clazz: Class<*>): Boolean = clazz == SimpleFieldAccess::class.java ||
-            (!whitelist.hasListed(clazz) && !hasAnnotationInHierarchy(clazz))
-
-    // Recursively check the class, interfaces and superclasses for our annotation.
-    private fun hasAnnotationInHierarchy(type: Class<*>): Boolean {
-        return type.isAnnotationPresent(CordaSerializable::class.java) ||
-                type.interfaces.any { hasAnnotationInHierarchy(it) }
-                || (type.superclass != null && hasAnnotationInHierarchy(type.superclass))
-    }
-
     private fun makeMapSerializer(declaredType: ParameterizedType): AMQPSerializer<Any> {
         val rawType = declaredType.rawType as Class<*>
         rawType.checkSupportedMapType()
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt
index 9f727e09c7..7a0dee0703 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt
@@ -2,14 +2,13 @@ package net.corda.nodeapi.internal.serialization.carpenter
 
 import net.corda.core.serialization.ClassWhitelist
 import net.corda.core.serialization.CordaSerializable
+import net.corda.nodeapi.internal.serialization.amqp.whitelisted
 import org.objectweb.asm.ClassWriter
 import org.objectweb.asm.MethodVisitor
 import org.objectweb.asm.Opcodes.*
 import org.objectweb.asm.Type
-
 import java.lang.Character.isJavaIdentifierPart
 import java.lang.Character.isJavaIdentifierStart
-
 import java.util.*
 
 /**
@@ -17,6 +16,7 @@ import java.util.*
  * as if `this.class.getMethod("get" + name.capitalize()).invoke(this)` had been called. It is intended as a more
  * convenient alternative to reflection.
  */
+@CordaSerializable
 interface SimpleFieldAccess {
     operator fun get(name: String): Any?
 }
@@ -134,7 +134,10 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
                 visit(TARGET_VERSION, ACC_PUBLIC + ACC_FINAL + ACC_SUPER + ACC_ENUM, schema.jvmName,
                         "L$jlEnum<L${schema.jvmName};>;", jlEnum, null)
 
-                visitAnnotation(Type.getDescriptor(CordaSerializable::class.java), true).visitEnd()
+                if (schema.flags.getOrDefault(SchemaFlags.NotCordaSerializable, "false") == true) {
+                    visitAnnotation(Type.getDescriptor(CordaSerializable::class.java), true).visitEnd()
+                }
+
                 generateFields(schema)
                 generateStaticEnumConstructor(schema)
                 generateEnumConstructor()
@@ -151,8 +154,10 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
             cw.apply {
                 visit(TARGET_VERSION, ACC_PUBLIC + ACC_ABSTRACT + ACC_INTERFACE, schema.jvmName, null,
                         jlObject, interfaces)
-                visitAnnotation(Type.getDescriptor(CordaSerializable::class.java), true).visitEnd()
 
+                if (schema.flags.getOrDefault(SchemaFlags.NotCordaSerializable, "false") == true) {
+                    visitAnnotation(Type.getDescriptor(CordaSerializable::class.java), true).visitEnd()
+                }
                 generateAbstractGetters(schema)
             }.visitEnd()
         }
@@ -163,20 +168,25 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
             val superName = schema.superclass?.jvmName ?: jlObject
             val interfaces = schema.interfaces.map { it.name.jvm }.toMutableList()
 
-            if (SimpleFieldAccess::class.java !in schema.interfaces) {
+            if (SimpleFieldAccess::class.java !in schema.interfaces && (
+                    (schema.flags.getOrDefault(SchemaFlags.NotCordaSerializable, "false") == true) ||
+                            (schema.flags.getOrDefault(SchemaFlags.NoSimpleFieldAccess, "false") == true))) {
                 interfaces.add(SimpleFieldAccess::class.java.name.jvm)
             }
 
             cw.apply {
                 visit(TARGET_VERSION, ACC_PUBLIC + ACC_SUPER, schema.jvmName, null, superName,
                         interfaces.toTypedArray())
-                visitAnnotation(Type.getDescriptor(CordaSerializable::class.java), true).visitEnd()
 
+                if (schema.flags.getOrDefault(SchemaFlags.NotCordaSerializable, "false") == true) {
+                    visitAnnotation(Type.getDescriptor(CordaSerializable::class.java), true).visitEnd()
+                }
                 generateFields(schema)
                 generateClassConstructor(schema)
                 generateGetters(schema)
-                if (schema.superclass == null)
+                if (schema.superclass == null) {
                     generateGetMethod()   // From SimplePropertyAccess
+                }
                 generateToString(schema)
             }.visitEnd()
         }
@@ -388,11 +398,22 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
         }
     }
 
+    /**
+     * If a sub element isn't whitelist we will not build a class containing that type as a member. Since, by
+     * default, classes created by the [ClassCarpenter] are annotated as [CordaSerializable] we will always
+     * be able to carpent classes generated from our AMQP library as, at a base level, we will either be able to
+     * create the lowest level in the meta hierarchy because either all members are jvm primitives or
+     * whitelisted classes
+     */
     private fun validateSchema(schema: Schema) {
         if (schema.name in _loaded) throw DuplicateNameException()
         fun isJavaName(n: String) = n.isNotBlank() && isJavaIdentifierStart(n.first()) && n.all(::isJavaIdentifierPart)
         require(isJavaName(schema.name.split(".").last())) { "Not a valid Java name: ${schema.name}" }
-        schema.fields.keys.forEach { require(isJavaName(it)) { "Not a valid Java name: $it" } }
+        schema.fields.forEach {
+            require(isJavaName(it.key)) { "Not a valid Java name: $it" }
+            whitelist.whitelisted(it.value.field)
+        }
+
         // Now check each interface we've been asked to implement, as the JVM will unfortunately only catch the
         // fact that we didn't implement the interface we said we would at the moment the missing method is
         // actually called, which is a bit too dynamic for my tastes.
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt
index e6684756b8..bd98a4f2c7 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt
@@ -1,9 +1,12 @@
 package net.corda.nodeapi.internal.serialization.carpenter
 
-import kotlin.collections.LinkedHashMap
 import org.objectweb.asm.ClassWriter
 import org.objectweb.asm.Opcodes.*
 
+enum class SchemaFlags {
+    NoSimpleFieldAccess, NotCordaSerializable
+}
+
 /**
  * A Schema is the representation of an object the Carpenter can contsruct
  *
@@ -17,7 +20,8 @@ abstract class Schema(
         var fields: Map<String, Field>,
         val superclass: Schema? = null,
         val interfaces: List<Class<*>> = emptyList(),
-        updater: (String, Field) -> Unit) {
+        updater: (String, Field) -> Unit,
+        var flags : MutableMap<SchemaFlags, Boolean> =  mutableMapOf()) {
     private fun Map<String, Field>.descriptors() = LinkedHashMap(this.mapValues { it.value.descriptor })
 
     init {
@@ -41,6 +45,20 @@ abstract class Schema(
 
     val asArray: String
         get() = "[L$jvmName;"
+
+    @Suppress("Unused")
+    fun setNoSimpleFieldAccess() {
+        flags.replace (SchemaFlags.NoSimpleFieldAccess, true)
+    }
+
+    fun setNotCordaSerializable() {
+        flags.replace (SchemaFlags.NotCordaSerializable, true)
+    }
+
+    @Suppress("Unused")
+    fun setCordaSerializable() {
+        flags.replace (SchemaFlags.NotCordaSerializable, false)
+    }
 }
 
 /**
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterWhitelistTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterWhitelistTest.kt
new file mode 100644
index 0000000000..f2da9018ef
--- /dev/null
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterWhitelistTest.kt
@@ -0,0 +1,100 @@
+package net.corda.nodeapi.internal.serialization.carpenter
+
+import net.corda.core.serialization.ClassWhitelist
+import net.corda.core.serialization.CordaSerializable
+import org.assertj.core.api.Assertions
+import org.junit.Test
+import java.io.NotSerializableException
+
+class ClassCarpenterWhitelistTest {
+
+    // whitelisting a class on the class path will mean we will carpente up a class that
+    // contains it as a member
+    @Test
+    fun whitelisted() {
+        data class A(val a: Int)
+
+        class WL : ClassWhitelist {
+            private val allowedClasses = hashSetOf<String>(
+                    A::class.java.name
+            )
+
+            override fun hasListed(type: Class<*>): Boolean = type.name in allowedClasses
+        }
+
+        val cc = ClassCarpenter(whitelist = WL())
+
+        // if this works, the test works, if it throws then we're in a world of pain, we could
+        // go further but there are a lot of other tests that test weather we can build
+        // carpented objects
+        cc.build(ClassSchema("thing", mapOf("a" to NonNullableField(A::class.java))))
+    }
+
+    // However, a class on the class path that isn't whitelisted we will not create
+    // an object that contains a member of that type
+    @Test
+    fun notWhitelisted() {
+        data class A(val a: Int)
+
+        class WL : ClassWhitelist {
+            override fun hasListed(type: Class<*>) = false
+        }
+
+        val cc = ClassCarpenter(whitelist = WL())
+
+        // Class A isn't on the whitelist, so we should fail to carpent it
+        Assertions.assertThatThrownBy {
+            cc.build(ClassSchema("thing", mapOf("a" to NonNullableField(A::class.java))))
+        }.isInstanceOf(NotSerializableException::class.java)
+    }
+
+    // despite now being whitelisted and on the class path, we will carpent this because
+    // it's marked as CordaSerializable
+    @Test
+    fun notWhitelistedButAnnotated() {
+        @CordaSerializable data class A(val a: Int)
+
+        class WL : ClassWhitelist {
+            override fun hasListed(type: Class<*>) = false
+        }
+
+        val cc = ClassCarpenter(whitelist = WL())
+
+        // again, simply not throwing here is enough to show the test worked and the carpenter
+        // didn't reject the type even though it wasn't on the whitelist because it was
+        // annotated properly
+        cc.build(ClassSchema("thing", mapOf("a" to NonNullableField(A::class.java))))
+    }
+
+    @Test
+    fun notWhitelistedButCarpented() {
+        // just have the white list reject *Everything* except ints
+        class WL : ClassWhitelist {
+            override fun hasListed(type: Class<*>) = type.name == "int"
+        }
+
+        val cc = ClassCarpenter(whitelist = WL())
+
+        val schema1a = ClassSchema("thing1a", mapOf("a" to NonNullableField(Int::class.java)))
+
+        // thing 1 won't be set as corda serializable, meaning we won't build schema 2
+        schema1a.setNotCordaSerializable()
+
+        val clazz1a = cc.build(schema1a)
+        val schema2 = ClassSchema("thing2", mapOf("a" to NonNullableField(clazz1a)))
+
+        // thing 2 references thing 1 which wasn't carpented as corda s erializable and thus
+        // this will fail
+        Assertions.assertThatThrownBy {
+            cc.build(schema2)
+        }.isInstanceOf(NotSerializableException::class.java)
+
+        // create a second type of schema1, this time leave it as corda serialzable
+        val schema1b = ClassSchema("thing1b", mapOf("a" to NonNullableField(Int::class.java)))
+
+        val clazz1b = cc.build(schema1b)
+
+        // since schema 1b was created as CordaSerializable this will work
+        val schema2b = ClassSchema("thing2", mapOf("a" to NonNullableField(clazz1b)))
+    }
+}
\ No newline at end of file

From cfcc5aad6776d3ba89479f401931855bdbaee178 Mon Sep 17 00:00:00 2001
From: Katelyn Baker <katelyn.baker@r3.com>
Date: Wed, 27 Sep 2017 14:01:42 +0100
Subject: [PATCH 030/185] CORDA-601 - Review Comments

So...

On reflection, and adding a number of tests for static initialisation
with serialised types it looks like there is no chance that the
serializer factory will ever pass a non white-listed type through to the
carpenter in the first place.

As such leaving the plumbing in as it may be useful to pass a blacklist
at some point into the carpenter and the tests are always useful
(ignoring those that won't work without the white-list checking)
---
 .../serialization/CordaClassResolver.kt       |   9 +-
 .../serialization/amqp/SerializationHelper.kt |  10 +-
 .../serialization/amqp/SerializerFactory.kt   |  10 +-
 .../serialization/carpenter/ClassCarpenter.kt |  14 +-
 .../serialization/carpenter/Schema.kt         |  26 ++--
 ...ticInitialisationOfSerializedObjectTest.kt | 144 ++++++++++++++++++
 .../carpenter/ClassCarpenterWhitelistTest.kt  |  11 +-
 ...tionOfSerializedObjectTest.deserializeTest | Bin 0 -> 530 bytes
 ...ionOfSerializedObjectTest.deserializeTest2 | Bin 0 -> 531 bytes
 9 files changed, 181 insertions(+), 43 deletions(-)
 create mode 100644 node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.kt
 create mode 100644 node-api/src/test/resources/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.deserializeTest
 create mode 100644 node-api/src/test/resources/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.deserializeTest2

diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
index 09983c8c68..45f98cbda9 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
@@ -11,6 +11,7 @@ import net.corda.core.serialization.ClassWhitelist
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.serialization.SerializationContext
 import net.corda.core.utilities.loggerFor
+import net.corda.nodeapi.internal.serialization.amqp.hasAnnotationInHierarchy
 import java.io.PrintWriter
 import java.lang.reflect.Modifier.isAbstract
 import java.nio.charset.StandardCharsets
@@ -115,13 +116,7 @@ class CordaClassResolver(serializationContext: SerializationContext) : DefaultCl
         return (type.classLoader !is AttachmentsClassLoader)
                 && !KryoSerializable::class.java.isAssignableFrom(type)
                 && !type.isAnnotationPresent(DefaultSerializer::class.java)
-                && (type.isAnnotationPresent(CordaSerializable::class.java) || hasInheritedAnnotation(type))
-    }
-
-    // Recursively check interfaces for our annotation.
-    private fun hasInheritedAnnotation(type: Class<*>): Boolean {
-        return type.interfaces.any { it.isAnnotationPresent(CordaSerializable::class.java) || hasInheritedAnnotation(it) }
-                || (type.superclass != null && hasInheritedAnnotation(type.superclass))
+                && (type.isAnnotationPresent(CordaSerializable::class.java) || whitelist.hasAnnotationInHierarchy(type))
     }
 
     // Need to clear out class names from attachments.
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
index 1a56cf901b..ab218fb247 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
@@ -266,16 +266,14 @@ private fun Throwable.setMessage(newMsg: String) {
     detailMessageField.set(this, newMsg)
 }
 
-fun ClassWhitelist.whitelisted(type: Type) {
-    val clazz = type.asClass()!!
-    if (isNotWhitelisted(clazz)) {
+fun ClassWhitelist.requireWhitelisted(type: Type) {
+    if (!this.isWhitelisted(type.asClass()!!)) {
         throw NotSerializableException("Class $type is not on the whitelist or annotated with @CordaSerializable.")
     }
 }
 
-// Ignore SimpleFieldAccess as we add it to anything we build in the carpenter.
-fun ClassWhitelist.isNotWhitelisted(clazz: Class<*>) =
-        !(hasListed(clazz) || hasAnnotationInHierarchy(clazz))
+fun ClassWhitelist.isWhitelisted(clazz: Class<*>) = (hasListed(clazz) || hasAnnotationInHierarchy(clazz))
+fun ClassWhitelist.isNotWhitelisted(clazz: Class<*>) = !(this.isWhitelisted(clazz))
 
 // Recursively check the class, interfaces and superclasses for our annotation.
 fun ClassWhitelist.hasAnnotationInHierarchy(type: Class<*>): Boolean {
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
index 65083a6150..da8ae1afc6 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializerFactory.kt
@@ -30,11 +30,11 @@ data class FactorySchemaAndDescriptor(val schema: Schema, val typeDescriptor: An
 // TODO: need to rethink matching of constructor to properties in relation to implementing interfaces and needing those properties etc.
 // TODO: need to support super classes as well as interfaces with our current code base... what's involved?  If we continue to ban, what is the impact?
 @ThreadSafe
-class SerializerFactory(val whitelist: ClassWhitelist, cl: ClassLoader) {
+open class SerializerFactory(val whitelist: ClassWhitelist, cl: ClassLoader) {
     private val serializersByType = ConcurrentHashMap<Type, AMQPSerializer<Any>>()
     private val serializersByDescriptor = ConcurrentHashMap<Any, AMQPSerializer<Any>>()
     private val customSerializers = CopyOnWriteArrayList<CustomSerializer<out Any>>()
-    val classCarpenter = ClassCarpenter(cl, whitelist)
+    open val classCarpenter = ClassCarpenter(cl, whitelist)
     val classloader: ClassLoader
         get() = classCarpenter.classloader
 
@@ -81,7 +81,7 @@ class SerializerFactory(val whitelist: ClassWhitelist, cl: ClassLoader) {
                 }
             }
             Enum::class.java.isAssignableFrom(actualClass ?: declaredClass) -> serializersByType.computeIfAbsent(actualClass ?: declaredClass) {
-                whitelisted(actualType)
+                whitelist.requireWhitelisted(actualType)
                 EnumSerializer(actualType, actualClass ?: declaredClass, this)
             }
             else -> makeClassSerializer(actualClass ?: declaredClass, actualType, declaredType)
@@ -242,10 +242,10 @@ class SerializerFactory(val whitelist: ClassWhitelist, cl: ClassLoader) {
                     if (clazz.componentType.isPrimitive) PrimArraySerializer.make(type, this)
                     else ArraySerializer.make(type, this)
                 } else if (clazz.kotlin.objectInstance != null) {
-                    whitelist.whitelisted(clazz)
+                    whitelist.requireWhitelisted(clazz)
                     SingletonSerializer(clazz, clazz.kotlin.objectInstance!!, this)
                 } else {
-                    whitelist.whitelisted(type)
+                    whitelist.requireWhitelisted(type)
                     ObjectSerializer(type, this)
                 }
             }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt
index 7a0dee0703..2c98ebbc07 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt
@@ -2,7 +2,6 @@ package net.corda.nodeapi.internal.serialization.carpenter
 
 import net.corda.core.serialization.ClassWhitelist
 import net.corda.core.serialization.CordaSerializable
-import net.corda.nodeapi.internal.serialization.amqp.whitelisted
 import org.objectweb.asm.ClassWriter
 import org.objectweb.asm.MethodVisitor
 import org.objectweb.asm.Opcodes.*
@@ -134,7 +133,7 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
                 visit(TARGET_VERSION, ACC_PUBLIC + ACC_FINAL + ACC_SUPER + ACC_ENUM, schema.jvmName,
                         "L$jlEnum<L${schema.jvmName};>;", jlEnum, null)
 
-                if (schema.flags.getOrDefault(SchemaFlags.NotCordaSerializable, "false") == true) {
+                if (schema.flags.cordaSerializable()) {
                     visitAnnotation(Type.getDescriptor(CordaSerializable::class.java), true).visitEnd()
                 }
 
@@ -155,7 +154,7 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
                 visit(TARGET_VERSION, ACC_PUBLIC + ACC_ABSTRACT + ACC_INTERFACE, schema.jvmName, null,
                         jlObject, interfaces)
 
-                if (schema.flags.getOrDefault(SchemaFlags.NotCordaSerializable, "false") == true) {
+                if (schema.flags.cordaSerializable()) {
                     visitAnnotation(Type.getDescriptor(CordaSerializable::class.java), true).visitEnd()
                 }
                 generateAbstractGetters(schema)
@@ -168,9 +167,9 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
             val superName = schema.superclass?.jvmName ?: jlObject
             val interfaces = schema.interfaces.map { it.name.jvm }.toMutableList()
 
-            if (SimpleFieldAccess::class.java !in schema.interfaces && (
-                    (schema.flags.getOrDefault(SchemaFlags.NotCordaSerializable, "false") == true) ||
-                            (schema.flags.getOrDefault(SchemaFlags.NoSimpleFieldAccess, "false") == true))) {
+            if (SimpleFieldAccess::class.java !in schema.interfaces
+                    && schema.flags.cordaSerializable()
+                    && schema.flags.simpleFieldAccess()) {
                 interfaces.add(SimpleFieldAccess::class.java.name.jvm)
             }
 
@@ -178,7 +177,7 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
                 visit(TARGET_VERSION, ACC_PUBLIC + ACC_SUPER, schema.jvmName, null, superName,
                         interfaces.toTypedArray())
 
-                if (schema.flags.getOrDefault(SchemaFlags.NotCordaSerializable, "false") == true) {
+                if (schema.flags.cordaSerializable()) {
                     visitAnnotation(Type.getDescriptor(CordaSerializable::class.java), true).visitEnd()
                 }
                 generateFields(schema)
@@ -411,7 +410,6 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
         require(isJavaName(schema.name.split(".").last())) { "Not a valid Java name: ${schema.name}" }
         schema.fields.forEach {
             require(isJavaName(it.key)) { "Not a valid Java name: $it" }
-            whitelist.whitelisted(it.value.field)
         }
 
         // Now check each interface we've been asked to implement, as the JVM will unfortunately only catch the
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt
index bd98a4f2c7..e3a3bfab56 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt
@@ -2,9 +2,10 @@ package net.corda.nodeapi.internal.serialization.carpenter
 
 import org.objectweb.asm.ClassWriter
 import org.objectweb.asm.Opcodes.*
+import java.util.*
 
 enum class SchemaFlags {
-    NoSimpleFieldAccess, NotCordaSerializable
+    SimpleFieldAccess, CordaSerializable
 }
 
 /**
@@ -20,10 +21,11 @@ abstract class Schema(
         var fields: Map<String, Field>,
         val superclass: Schema? = null,
         val interfaces: List<Class<*>> = emptyList(),
-        updater: (String, Field) -> Unit,
-        var flags : MutableMap<SchemaFlags, Boolean> =  mutableMapOf()) {
+        updater: (String, Field) -> Unit) {
     private fun Map<String, Field>.descriptors() = LinkedHashMap(this.mapValues { it.value.descriptor })
 
+    var flags : EnumMap<SchemaFlags, Boolean> = EnumMap(SchemaFlags::class.java)
+
     init {
         fields.forEach { updater(it.key, it.value) }
 
@@ -46,19 +48,17 @@ abstract class Schema(
     val asArray: String
         get() = "[L$jvmName;"
 
-    @Suppress("Unused")
-    fun setNoSimpleFieldAccess() {
-        flags.replace (SchemaFlags.NoSimpleFieldAccess, true)
+    fun unsetCordaSerializable() {
+        flags.replace (SchemaFlags.CordaSerializable, false)
     }
+}
 
-    fun setNotCordaSerializable() {
-        flags.replace (SchemaFlags.NotCordaSerializable, true)
-    }
+fun EnumMap<SchemaFlags, Boolean>.cordaSerializable() : Boolean {
+    return this.getOrDefault(SchemaFlags.CordaSerializable, true) == true
+}
 
-    @Suppress("Unused")
-    fun setCordaSerializable() {
-        flags.replace (SchemaFlags.NotCordaSerializable, false)
-    }
+fun EnumMap<SchemaFlags, Boolean>.simpleFieldAccess() : Boolean {
+    return this.getOrDefault(SchemaFlags.SimpleFieldAccess, true) == true
 }
 
 /**
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.kt
new file mode 100644
index 0000000000..47decde9c0
--- /dev/null
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.kt
@@ -0,0 +1,144 @@
+package net.corda.nodeapi.internal.serialization.amqp
+
+import net.corda.core.serialization.ClassWhitelist
+import net.corda.core.serialization.SerializedBytes
+import net.corda.nodeapi.internal.serialization.AllWhitelist
+import net.corda.nodeapi.internal.serialization.carpenter.ClassCarpenter
+import org.assertj.core.api.Assertions
+import org.junit.Test
+import java.io.File
+import java.io.NotSerializableException
+import java.lang.reflect.Type
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.test.assertEquals
+
+class InStatic : Exception ("Help!, help!, I'm being repressed")
+
+class C {
+    companion object {
+        init {
+            throw InStatic()
+        }
+    }
+}
+
+// To re-setup the resource file for the tests
+//   * deserializeTest
+//   * deserializeTest2
+// comment out the companion object from here,  comment out the test code and uncomment
+// the generation code, then re-run the test and copy the file shown in the output print
+// to the resource directory
+class C2 (var b: Int) {
+    /*
+    companion object {
+        init {
+            throw InStatic()
+        }
+    }
+    */
+}
+
+class StaticInitialisationOfSerializedObjectTest {
+    @Test(expected=java.lang.ExceptionInInitializerError::class)
+    fun itBlowsUp() {
+        C()
+    }
+
+    @Test
+    fun KotlinObjectWithCompanionObject() {
+        data class D (val c : C)
+
+        val sf = SerializerFactory(AllWhitelist, ClassLoader.getSystemClassLoader())
+
+        val typeMap = sf::class.java.getDeclaredField("serializersByType")
+        typeMap.isAccessible = true
+
+        @Suppress("UNCHECKED_CAST")
+        val serialisersByType = typeMap.get(sf) as ConcurrentHashMap<Type, AMQPSerializer<Any>>
+
+        // pre building a serializer, we shouldn't have anything registered
+        assertEquals(0, serialisersByType.size)
+
+        // build a serializer for type D without an instance of it to serialise, since
+        // we can't actually construct one
+        sf.get(null, D::class.java)
+
+        // post creation of the serializer we should have one element in the map, this
+        // proves we didn't statically construct an instance of C when building the serializer
+        assertEquals(1, serialisersByType.size)
+    }
+
+
+    @Test
+    fun deserializeTest() {
+        data class D (val c : C2)
+
+        val path = EvolvabilityTests::class.java.getResource("StaticInitialisationOfSerializedObjectTest.deserializeTest")
+        val f = File(path.toURI())
+
+        // Original version of the class for the serialised version of this class
+        //
+        //val sf1 = SerializerFactory(AllWhitelist, ClassLoader.getSystemClassLoader())
+        //val sc = SerializationOutput(sf1).serialize(D(C2(20)))
+        //f.writeBytes(sc.bytes)
+        //println (path)
+
+        class WL : ClassWhitelist {
+            override fun hasListed(type: Class<*>) =
+                    type.name == "net.corda.nodeapi.internal.serialization.amqp" +
+                    ".StaticInitialisationOfSerializedObjectTest\$deserializeTest\$D"
+        }
+
+        val sf2 = SerializerFactory(WL(), ClassLoader.getSystemClassLoader())
+        val bytes = f.readBytes()
+
+        Assertions.assertThatThrownBy {
+            DeserializationInput(sf2).deserialize(SerializedBytes<D>(bytes))
+        }.isInstanceOf(NotSerializableException::class.java)
+    }
+
+    // Version of a serializer factory that will allow the class carpenter living on the
+    // factory to have a different whitelist applied to it than the factory
+    class TestSerializerFactory(wl1: ClassWhitelist, wl2: ClassWhitelist) :
+            SerializerFactory (wl1, ClassLoader.getSystemClassLoader()) {
+        override val classCarpenter = ClassCarpenter(ClassLoader.getSystemClassLoader(), wl2)
+    }
+
+    // This time have the serilization factory and the carpenter use different whitelists
+    @Test
+    fun deserializeTest2() {
+        data class D (val c : C2)
+
+        val path = EvolvabilityTests::class.java.getResource("StaticInitialisationOfSerializedObjectTest.deserializeTest2")
+        val f = File(path.toURI())
+
+        // Original version of the class for the serialised version of this class
+        //
+        //val sf1 = SerializerFactory(AllWhitelist, ClassLoader.getSystemClassLoader())
+        //val sc = SerializationOutput(sf1).serialize(D(C2(20)))
+        //f.writeBytes(sc.bytes)
+        //println (path)
+
+        // whitelist to be used by the serialisation factory
+        class WL1 : ClassWhitelist {
+            override fun hasListed(type: Class<*>) =
+                    type.name == "net.corda.nodeapi.internal.serialization.amqp" +
+                            ".StaticInitialisationOfSerializedObjectTest\$deserializeTest\$D"
+        }
+
+        // whitelist to be used by the carpenter
+        class WL2 : ClassWhitelist {
+            override fun hasListed(type: Class<*>) = true
+        }
+
+        val sf2 = TestSerializerFactory(WL1(), WL2())
+        val bytes = f.readBytes()
+
+        // Deserializing should throw because C is not on the whitelist NOT because
+        // we ever went anywhere near statically constructing it prior to not actually
+        // creating an instance of it
+        Assertions.assertThatThrownBy {
+            DeserializationInput(sf2).deserialize(SerializedBytes<D>(bytes))
+        }.isInstanceOf(NotSerializableException::class.java)
+    }
+}
\ No newline at end of file
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterWhitelistTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterWhitelistTest.kt
index f2da9018ef..deb51da65f 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterWhitelistTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenterWhitelistTest.kt
@@ -3,6 +3,7 @@ package net.corda.nodeapi.internal.serialization.carpenter
 import net.corda.core.serialization.ClassWhitelist
 import net.corda.core.serialization.CordaSerializable
 import org.assertj.core.api.Assertions
+import org.junit.Ignore
 import org.junit.Test
 import java.io.NotSerializableException
 
@@ -30,9 +31,9 @@ class ClassCarpenterWhitelistTest {
         cc.build(ClassSchema("thing", mapOf("a" to NonNullableField(A::class.java))))
     }
 
-    // However, a class on the class path that isn't whitelisted we will not create
-    // an object that contains a member of that type
     @Test
+    @Ignore("Currently the carpenter doesn't inspect it's whitelist so will carpent anything" +
+            "it's asked relying on the serializer factory to not ask for anything")
     fun notWhitelisted() {
         data class A(val a: Int)
 
@@ -67,6 +68,8 @@ class ClassCarpenterWhitelistTest {
     }
 
     @Test
+    @Ignore("Currently the carpenter doesn't inspect it's whitelist so will carpent anything" +
+            "it's asked relying on the serializer factory to not ask for anything")
     fun notWhitelistedButCarpented() {
         // just have the white list reject *Everything* except ints
         class WL : ClassWhitelist {
@@ -78,7 +81,7 @@ class ClassCarpenterWhitelistTest {
         val schema1a = ClassSchema("thing1a", mapOf("a" to NonNullableField(Int::class.java)))
 
         // thing 1 won't be set as corda serializable, meaning we won't build schema 2
-        schema1a.setNotCordaSerializable()
+        schema1a.unsetCordaSerializable()
 
         val clazz1a = cc.build(schema1a)
         val schema2 = ClassSchema("thing2", mapOf("a" to NonNullableField(clazz1a)))
@@ -95,6 +98,6 @@ class ClassCarpenterWhitelistTest {
         val clazz1b = cc.build(schema1b)
 
         // since schema 1b was created as CordaSerializable this will work
-        val schema2b = ClassSchema("thing2", mapOf("a" to NonNullableField(clazz1b)))
+        ClassSchema("thing2", mapOf("a" to NonNullableField(clazz1b)))
     }
 }
\ No newline at end of file
diff --git a/node-api/src/test/resources/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.deserializeTest b/node-api/src/test/resources/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.deserializeTest
new file mode 100644
index 0000000000000000000000000000000000000000..0ba0299a3f1df420ae32306cb098a9605c61585d
GIT binary patch
literal 530
zcmYe!FG@*dWME)u0Ahv%w-^{NFfcIw2C|tL7AxhYmgpseR9Ize2j==kg%?+ud8HdA
z7L`|In*^8!+S(q_W<*g}Xqjo|<7Z}46>gAQQI+YLWR~LQk`7eI%orj9w}c5~$uyuP
zVB31Zwlx4rkONo`yk=dP1-Dr*FFz$Uu^>|~Gp{7IC@(QbuQ;_RGchN#DzPLpKTj_)
zx3EAjxCF>a_RPyH0m&4DW&G2Ep$bz|{FAa$lS@KUi%V2eQepa2!F(47SGcp752!H_
z<7tNj9*l5JEC;OF7cwR<G$75%&PJ{d4vtQ6V^|Ngv65~E9>?Q~35Nr+$c`5PIzDM3
OGca^r7cv?ET?7DUk*x**

literal 0
HcmV?d00001

diff --git a/node-api/src/test/resources/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.deserializeTest2 b/node-api/src/test/resources/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.deserializeTest2
new file mode 100644
index 0000000000000000000000000000000000000000..6423985eafd8f7f5da84012386d5d7311182f876
GIT binary patch
literal 531
zcmYe!FG@*dWME)u0Ahv%w-^{NFfcIw0kWAG7AxhYmgpseR9I<Ol!s=PXji7D`={lY
zc%}O1=X#ks+S(q_W<*g}Xqjo|<7Z}46>gAQQI+YLWR~LQk`7eI%orj9w}c5~$#kG4
zVB7k@wlx4rkONo`ykT9K4Yye@FFz$Uu^>|~Gp{7IC@(QbuQ;_RGchN#DzPLpKTj_)
zx3EAjxCF>a_RPyH0m&4DW&G2Ep$bz|{FAa$lS@KUi%V2eQepa2L3|?>7YA3kyO<BC
zF%jcyhXWpra7`=+tl1YbCNDG~&CSk6t_}{4PH<yb545q8ZU!F5<BAH01G31D7XUgw
QX(2N(cwHAV8US4c07)^ea{vGU

literal 0
HcmV?d00001


From 57e131d8a0812581cd2b0c0151bb4158337fc218 Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Wed, 27 Sep 2017 23:49:20 +0100
Subject: [PATCH 031/185] Prevent the root project from building an unwanted
 dummy cordapp. (#1706)

---
 build.gradle | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index 0466b24455..97a02e8c18 100644
--- a/build.gradle
+++ b/build.gradle
@@ -175,7 +175,6 @@ repositories {
     }
 }
 
-// TODO: Corda root project currently produces a dummy cordapp when it shouldn't.
 // Required for building out the fat JAR.
 dependencies {
     cordaCompile project(':node')
@@ -196,6 +195,11 @@ dependencies {
     testCompile project(':test-utils')
 }
 
+jar {
+    // Prevent the root project from building an unwanted dummy CorDapp.
+    enabled = false
+}
+
 task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
     dependsOn = subprojects.test
     additionalSourceDirs = files(subprojects.sourceSets.main.allSource.srcDirs)

From c0dd8d338e53792138fed17ee4ab1953d76d6693 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Thu, 28 Sep 2017 10:06:10 +0100
Subject: [PATCH 032/185] CORDA-649: Improving logging (#1699)

---
 .../kotlin/net/corda/node/internal/Node.kt    |  7 +++++-
 .../network/PersistentNetworkMapCache.kt      |  8 +++++++
 .../network/PersistentNetworkMapCacheTest.kt  | 23 +++++++++++++------
 3 files changed, 30 insertions(+), 8 deletions(-)

diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt
index 17660cfe37..efb817f54a 100644
--- a/node/src/main/kotlin/net/corda/node/internal/Node.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt
@@ -47,6 +47,7 @@ import org.slf4j.LoggerFactory
 import java.io.IOException
 import java.time.Clock
 import java.util.*
+import java.util.concurrent.atomic.AtomicInteger
 import javax.management.ObjectName
 import kotlin.system.exitProcess
 
@@ -83,6 +84,8 @@ open class Node(override val configuration: FullNodeConfiguration,
         private fun createClock(configuration: FullNodeConfiguration): Clock {
             return if (configuration.useTestClock) TestClock() else NodeClock()
         }
+
+        private val sameVmNodeCounter = AtomicInteger()
     }
 
     override val log: Logger get() = logger
@@ -90,6 +93,8 @@ open class Node(override val configuration: FullNodeConfiguration,
     override val networkMapAddress: NetworkMapAddress? get() = configuration.networkMapService?.address?.let(::NetworkMapAddress)
     override fun makeTransactionVerifierService() = (network as NodeMessagingClient).verifierService
 
+    private val sameVmNodeNumber = sameVmNodeCounter.incrementAndGet() // Under normal (non-test execution) it will always be "1"
+
     // DISCUSSION
     //
     // We use a single server thread for now, which means all message handling is serialized.
@@ -127,7 +132,7 @@ open class Node(override val configuration: FullNodeConfiguration,
     //
     // The primary work done by the server thread is execution of flow logics, and related
     // serialisation/deserialisation work.
-    override val serverThread = AffinityExecutor.ServiceAffinityExecutor("Node thread", 1)
+    override val serverThread = AffinityExecutor.ServiceAffinityExecutor("Node thread-$sameVmNodeNumber", 1)
 
     private var messageBroker: ArtemisMessagingServer? = null
 
diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
index 45e2b6f9b0..1105c4981c 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
@@ -157,23 +157,30 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
     }
 
     override fun addNode(node: NodeInfo) {
+        logger.info("Adding node with info: $node")
         synchronized(_changed) {
             val previousNode = registeredNodes.put(node.legalIdentities.first().owningKey, node) // TODO hack... we left the first one as special one
             if (previousNode == null) {
+                logger.info("No previous node found")
                 serviceHub.database.transaction {
                     updateInfoDB(node)
                     changePublisher.onNext(MapChange.Added(node))
                 }
             } else if (previousNode != node) {
+                logger.info("Previous node was found as: $previousNode")
                 serviceHub.database.transaction {
                     updateInfoDB(node)
                     changePublisher.onNext(MapChange.Modified(node, previousNode))
                 }
+            } else {
+                logger.info("Previous node was identical to incoming one - doing nothing")
             }
         }
+        logger.info("Done adding node with info: $node")
     }
 
     override fun removeNode(node: NodeInfo) {
+        logger.info("Removing node with info: $node")
         synchronized(_changed) {
             registeredNodes.remove(node.legalIdentities.first().owningKey)
             serviceHub.database.transaction {
@@ -181,6 +188,7 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
                 changePublisher.onNext(MapChange.Removed(node))
             }
         }
+        logger.info("Done removing node with info: $node")
     }
 
     /**
diff --git a/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt b/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
index da94d376aa..0d34b7d142 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
@@ -25,6 +25,10 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
     val addressesMap: HashMap<CordaX500Name, NetworkHostAndPort> = HashMap()
     val infos: MutableSet<NodeInfo> = HashSet()
 
+    companion object {
+        val logger = loggerFor<PersistentNetworkMapCacheTest>()
+    }
+
     @Before
     fun start() {
         val nodes = startNodesWithPort(partiesList)
@@ -127,10 +131,13 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
             assertTrue(nms.info.chooseIdentity() in it.services.networkMapCache.allNodes.map { it.chooseIdentity() })
         }
         charlie.internals.nodeReadyFuture.get() // Finish registration.
+        logger.info("Checking connectivity")
         checkConnectivity(listOf(otherNodes[0], nms)) // Checks connectivity from A to NMS.
+        logger.info("Loading caches")
         val cacheA = otherNodes[0].services.networkMapCache.allNodes
         val cacheB = otherNodes[1].services.networkMapCache.allNodes
         val cacheC = charlie.services.networkMapCache.allNodes
+        logger.info("Performing verification")
         assertEquals(4, cacheC.size) // Charlie fetched data from NetworkMap
         assertThat(cacheB).contains(charlie.info)
         assertEquals(cacheA.toSet(), cacheB.toSet())
@@ -158,9 +165,11 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
     private fun checkConnectivity(nodes: List<StartedNode<*>>) {
         nodes.forEach { node1 ->
             nodes.forEach { node2 ->
-                node2.internals.registerInitiatedFlow(SendBackFlow::class.java)
-                val resultFuture = node1.services.startFlow(SendFlow(node2.info.chooseIdentity())).resultFuture
-                assertThat(resultFuture.getOrThrow()).isEqualTo("Hello!")
+                if(!(node1 === node2)) { // Do not check connectivity to itself
+                    node2.internals.registerInitiatedFlow(SendBackFlow::class.java)
+                    val resultFuture = node1.services.startFlow(SendFlow(node2.info.chooseIdentity())).resultFuture
+                    assertThat(resultFuture.getOrThrow()).isEqualTo("Hello!")
+                }
             }
         }
     }
@@ -169,8 +178,8 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
     private class SendFlow(val otherParty: Party) : FlowLogic<String>() {
         @Suspendable
         override fun call(): String {
-            println("SEND FLOW to $otherParty")
-            println("Party key ${otherParty.owningKey.toBase58String()}")
+            logger.info("SEND FLOW to $otherParty")
+            logger.info("Party key ${otherParty.owningKey.toBase58String()}")
             val session = initiateFlow(otherParty)
             return session.sendAndReceive<String>("Hi!").unwrap { it }
         }
@@ -180,8 +189,8 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
     private class SendBackFlow(val otherSideSession: FlowSession) : FlowLogic<Unit>() {
         @Suspendable
         override fun call() {
-            println("SEND BACK FLOW to ${otherSideSession.counterparty}")
-            println("Party key ${otherSideSession.counterparty.owningKey.toBase58String()}")
+            logger.info("SEND BACK FLOW to ${otherSideSession.counterparty}")
+            logger.info("Party key ${otherSideSession.counterparty.owningKey.toBase58String()}")
             otherSideSession.send("Hello!")
         }
     }

From f8a43a8331f8c6a07f37e411c482627d65935eb2 Mon Sep 17 00:00:00 2001
From: Andrius Dagys <andrius.dagys@r3.com>
Date: Wed, 27 Sep 2017 17:43:30 +0100
Subject: [PATCH 033/185] A temporary fix for contract upgrade transactions:
 during LedgerTransaction verification run the right logic based on whether it
 contains the UpgradeCommand.

Move ContractUpgradeFlowTest away from createSomeNodes()

Remove assembleBareTx as it's not used
---
 .../net/corda/core/contracts/Structures.kt    |  3 --
 .../corda/core/flows/ContractUpgradeFlow.kt   | 46 +------------------
 .../net/corda/core/internal/UpgradeCommand.kt |  7 +++
 .../core/transactions/LedgerTransaction.kt    | 29 +++++++++++-
 .../core/contracts/DummyContractV2Tests.kt    |  1 +
 .../core/flows/ContractUpgradeFlowTest.kt     | 15 ++----
 .../corda/node/services/CoreFlowHandlers.kt   |  6 +--
 .../kotlin/net/corda/testing/node/MockNode.kt |  2 +-
 .../testing/contracts/DummyContractV2.kt      |  3 +-
 9 files changed, 44 insertions(+), 68 deletions(-)
 create mode 100644 core/src/main/kotlin/net/corda/core/internal/UpgradeCommand.kt

diff --git a/core/src/main/kotlin/net/corda/core/contracts/Structures.kt b/core/src/main/kotlin/net/corda/core/contracts/Structures.kt
index 9ce12b7293..e509b7da14 100644
--- a/core/src/main/kotlin/net/corda/core/contracts/Structures.kt
+++ b/core/src/main/kotlin/net/corda/core/contracts/Structures.kt
@@ -199,9 +199,6 @@ interface MoveCommand : CommandData {
     val contract: Class<out Contract>?
 }
 
-/** Indicates that this transaction replaces the inputs contract state to another contract state */
-data class UpgradeCommand(val upgradedContractClass: ContractClassName) : CommandData
-
 // DOCSTART 6
 /** A [Command] where the signing parties have been looked up if they have a well known/recognised institutional key. */
 @CordaSerializable
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 c3ee51a861..e5eb960ac5 100644
--- a/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt
@@ -3,10 +3,6 @@ package net.corda.core.flows
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.contracts.*
 import net.corda.core.internal.ContractUpgradeUtils
-import net.corda.core.internal.uncheckedCast
-import net.corda.core.transactions.LedgerTransaction
-import net.corda.core.transactions.TransactionBuilder
-import java.security.PublicKey
 
 /**
  * A flow to be used for authorising and upgrading state objects of an old contract to a new contract.
@@ -17,29 +13,6 @@ import java.security.PublicKey
  * use the new updated state for future transactions.
  */
 object ContractUpgradeFlow {
-
-    @JvmStatic
-    fun verify(tx: LedgerTransaction) {
-        // Contract Upgrade transaction should have 1 input, 1 output and 1 command.
-        verify(tx.inputs.single().state,
-                tx.outputs.single(),
-                tx.commandsOfType<UpgradeCommand>().single())
-    }
-
-    @JvmStatic
-    fun verify(input: TransactionState<ContractState>, output: TransactionState<ContractState>, commandData: Command<UpgradeCommand>) {
-        val command = commandData.value
-        val participantKeys: Set<PublicKey> = input.data.participants.map { it.owningKey }.toSet()
-        val keysThatSigned: Set<PublicKey> = commandData.signers.toSet()
-        val upgradedContract: UpgradedContract<ContractState, *> = uncheckedCast(javaClass.classLoader.loadClass(command.upgradedContractClass).newInstance())
-        requireThat {
-            "The signing keys include all participant keys" using keysThatSigned.containsAll(participantKeys)
-            "Inputs state reference the legacy contract" using (input.contract == upgradedContract.legacyContract)
-            "Outputs state reference the upgraded contract" using (output.contract == command.upgradedContractClass)
-            "Output state must be an upgraded version of the input state" using (output.data == upgradedContract.upgrade(input.data))
-        }
-    }
-
     /**
      * Authorise a contract state upgrade.
      *
@@ -53,7 +26,7 @@ object ContractUpgradeFlow {
     class Authorise(
             val stateAndRef: StateAndRef<*>,
             private val upgradedContractClass: Class<out UpgradedContract<*, *>>
-        ) : FlowLogic<Void?>() {
+    ) : FlowLogic<Void?>() {
         @Suspendable
         override fun call(): Void? {
             val upgrade = upgradedContractClass.newInstance()
@@ -89,23 +62,6 @@ object ContractUpgradeFlow {
             newContractClass: Class<out UpgradedContract<OldState, NewState>>
     ) : AbstractStateReplacementFlow.Instigator<OldState, NewState, Class<out UpgradedContract<OldState, NewState>>>(originalState, newContractClass) {
 
-        companion object {
-            fun <OldState : ContractState, NewState : ContractState> assembleBareTx(
-                    stateRef: StateAndRef<OldState>,
-                    upgradedContractClass: Class<out UpgradedContract<OldState, NewState>>,
-                    privacySalt: PrivacySalt
-            ): TransactionBuilder {
-                val contractUpgrade = upgradedContractClass.newInstance()
-                return TransactionBuilder(stateRef.state.notary)
-                        .withItems(
-                                stateRef,
-                                StateAndContract(contractUpgrade.upgrade(stateRef.state.data), upgradedContractClass.name),
-                                Command(UpgradeCommand(upgradedContractClass.name), stateRef.state.data.participants.map { it.owningKey }),
-                                privacySalt
-                        )
-            }
-        }
-
         @Suspendable
         override fun assembleTx(): AbstractStateReplacementFlow.UpgradeTx {
             val baseTx = ContractUpgradeUtils.assembleBareTx(originalState, modification, PrivacySalt())
diff --git a/core/src/main/kotlin/net/corda/core/internal/UpgradeCommand.kt b/core/src/main/kotlin/net/corda/core/internal/UpgradeCommand.kt
new file mode 100644
index 0000000000..9c4e3abb7f
--- /dev/null
+++ b/core/src/main/kotlin/net/corda/core/internal/UpgradeCommand.kt
@@ -0,0 +1,7 @@
+package net.corda.core.internal
+
+import net.corda.core.contracts.CommandData
+import net.corda.core.contracts.ContractClassName
+
+/** Indicates that this transaction replaces the inputs contract state to another contract state */
+data class UpgradeCommand(val upgradedContractClass: ContractClassName) : CommandData
\ 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 f54d02e5fc..9f8bdf1001 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt
@@ -3,9 +3,11 @@ package net.corda.core.transactions
 import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
 import net.corda.core.identity.Party
+import net.corda.core.internal.UpgradeCommand
 import net.corda.core.internal.castIfPossible
 import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.CordaSerializable
+import java.security.PublicKey
 import java.util.*
 import java.util.function.Predicate
 
@@ -63,7 +65,13 @@ data class LedgerTransaction(
     @Throws(TransactionVerificationException::class)
     fun verify() {
         verifyConstraints()
-        verifyContracts()
+        // TODO: make contract upgrade transactions have a separate type
+        if (commands.any { it.value is UpgradeCommand }) {
+            verifyContractUpgrade()
+        }
+        else {
+            verifyContracts()
+        }
     }
 
     /**
@@ -153,6 +161,25 @@ data class LedgerTransaction(
         }
     }
 
+    private fun verifyContractUpgrade() {
+        // Contract Upgrade transaction should have 1 input, 1 output and 1 command.
+        val input = inputs.single().state
+        val output = outputs.single()
+        val commandData = commandsOfType<UpgradeCommand>().single()
+
+        val command = commandData.value
+        val participantKeys: Set<PublicKey> = input.data.participants.map { it.owningKey }.toSet()
+        val keysThatSigned: Set<PublicKey> = commandData.signers.toSet()
+        @Suppress("UNCHECKED_CAST")
+        val upgradedContract = javaClass.classLoader.loadClass(command.upgradedContractClass).newInstance() as UpgradedContract<ContractState, *>
+        requireThat {
+            "The signing keys include all participant keys" using keysThatSigned.containsAll(participantKeys)
+            "Inputs state reference the legacy contract" using (input.contract == upgradedContract.legacyContract)
+            "Outputs state reference the upgraded contract" using (output.contract == command.upgradedContractClass)
+            "Output state must be an upgraded version of the input state" using (output.data == upgradedContract.upgrade(input.data))
+        }
+    }
+
     /**
      * Given a type and a function that returns a grouping key, associates inputs and outputs together so that they
      * can be processed as one. The grouping key is any arbitrary object that can act as a map key (so must implement
diff --git a/core/src/test/kotlin/net/corda/core/contracts/DummyContractV2Tests.kt b/core/src/test/kotlin/net/corda/core/contracts/DummyContractV2Tests.kt
index 153ce6cc47..24509c3c52 100644
--- a/core/src/test/kotlin/net/corda/core/contracts/DummyContractV2Tests.kt
+++ b/core/src/test/kotlin/net/corda/core/contracts/DummyContractV2Tests.kt
@@ -1,6 +1,7 @@
 package net.corda.core.contracts
 
 import net.corda.core.crypto.SecureHash
+import net.corda.core.internal.UpgradeCommand
 import net.corda.testing.ALICE
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.TestDependencyInjectionBase
diff --git a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
index aeca91feb4..042e185472 100644
--- a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
@@ -42,22 +42,15 @@ class ContractUpgradeFlowTest {
     fun setup() {
         setCordappPackages("net.corda.testing.contracts", "net.corda.finance.contracts.asset", "net.corda.core.flows")
         mockNet = MockNetwork()
-        val nodes = mockNet.createSomeNodes(notaryKeyPair = null) // prevent generation of notary override
-        a = nodes.partyNodes[0]
-        b = nodes.partyNodes[1]
+        val notaryNode = mockNet.createNotaryNode()
+        a = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+        b = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
 
         // Process registration
         mockNet.runNetwork()
         a.internals.ensureRegistered()
 
-        notary = a.services.getDefaultNotary()
-        val nodeIdentity = nodes.notaryNode.info.legalIdentitiesAndCerts.single { it.party == notary }
-        a.database.transaction {
-            a.services.identityService.verifyAndRegisterIdentity(nodeIdentity)
-        }
-        b.database.transaction {
-            b.services.identityService.verifyAndRegisterIdentity(nodeIdentity)
-        }
+        notary = notaryNode.services.getDefaultNotary()
     }
 
     @After
diff --git a/node/src/main/kotlin/net/corda/node/services/CoreFlowHandlers.kt b/node/src/main/kotlin/net/corda/node/services/CoreFlowHandlers.kt
index e3819b661d..16d240eecc 100644
--- a/node/src/main/kotlin/net/corda/node/services/CoreFlowHandlers.kt
+++ b/node/src/main/kotlin/net/corda/node/services/CoreFlowHandlers.kt
@@ -2,7 +2,6 @@ package net.corda.node.services
 
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.contracts.ContractState
-import net.corda.core.contracts.UpgradeCommand
 import net.corda.core.contracts.UpgradedContract
 import net.corda.core.contracts.requireThat
 import net.corda.core.flows.*
@@ -64,9 +63,6 @@ class ContractUpgradeHandler(otherSide: FlowSession) : AbstractStateReplacementF
             "The proposed upgrade ${proposal.modification.javaClass} is a trusted upgrade path" using (proposal.modification.name == authorisedUpgrade)
             "The proposed tx matches the expected tx for this upgrade" using (proposedTx == expectedTx)
         }
-        ContractUpgradeFlow.verify(
-                oldStateAndRef.state,
-                expectedTx.outRef<ContractState>(0).state,
-                expectedTx.toLedgerTransaction(serviceHub).commandsOfType<UpgradeCommand>().single())
+        proposedTx.toLedgerTransaction(serviceHub).verify()
     }
 }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index 9baeb6d470..4d0a796258 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -391,7 +391,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
     @JvmOverloads
     fun createSomeNodes(numPartyNodes: Int = 2, nodeFactory: Factory<*> = defaultFactory, notaryKeyPair: KeyPair? = DUMMY_NOTARY_KEY): BasketOfNodes {
         require(nodes.isEmpty())
-        val notaryServiceInfo = ServiceInfo(SimpleNotaryService.type)
+        val notaryServiceInfo = ServiceInfo(ValidatingNotaryService.type)
         val notaryOverride = if (notaryKeyPair != null)
             mapOf(Pair(notaryServiceInfo, notaryKeyPair))
         else
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyContractV2.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyContractV2.kt
index 180aaa7b85..5b7f80044d 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyContractV2.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyContractV2.kt
@@ -1,8 +1,8 @@
 package net.corda.testing.contracts
 
 import net.corda.core.contracts.*
-import net.corda.core.flows.ContractUpgradeFlow
 import net.corda.core.identity.AbstractParty
+import net.corda.core.internal.UpgradeCommand
 import net.corda.core.node.ServicesForResolution
 import net.corda.core.transactions.LedgerTransaction
 import net.corda.core.transactions.TransactionBuilder
@@ -35,7 +35,6 @@ class DummyContractV2 : UpgradedContract<DummyContract.State, DummyContractV2.St
     }
 
     override fun verify(tx: LedgerTransaction) {
-        if (tx.commands.any { it.value is UpgradeCommand }) ContractUpgradeFlow.verify(tx)
         // Other verifications.
     }
     // DOCEND 1

From eb0e5ad417d53c43374d5a04e233c700484e2ddf Mon Sep 17 00:00:00 2001
From: Katarzyna Streich <katarzyna.streich@r3.com>
Date: Thu, 28 Sep 2017 15:01:08 +0100
Subject: [PATCH 034/185] Improve NodeTabView in DemoBench (#1639)

* Improve NodeTabView in DemoBench

Reflect recent changes with advertised services removal.

* Force selection of only one notary

* Update screenshots
---
 .../net/corda/node/internal/NodeStartup.kt    |   4 +--
 tools/demobench/demobench-configure-bank.png  | Bin 62526 -> 58499 bytes
 tools/demobench/demobench-initial.png         | Bin 43631 -> 53694 bytes
 .../corda/demobench/model/InstallFactory.kt   |   2 +-
 .../corda/demobench/model/NodeController.kt   |   3 +-
 .../demobench/model/ServiceController.kt      |  28 +++++++++++-------
 .../net/corda/demobench/views/NodeTabView.kt  |  16 ++++++++--
 .../src/main/resources/services.conf          |  14 ++++-----
 .../demobench/model/ServiceControllerTest.kt  |   4 +--
 .../test/resources/duplicate-services.conf    |   6 ++--
 .../src/test/resources/notary-services.conf   |   4 +--
 11 files changed, 49 insertions(+), 32 deletions(-)

diff --git a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
index 0b645a2c48..9fd82c83d0 100644
--- a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
@@ -260,8 +260,8 @@ open class NodeStartup(val args: Array<String>) {
     }
 
     private fun printPluginsAndServices(node: Node) {
-        node.configuration.extraAdvertisedServiceIds.let {
-            if (it.isNotEmpty()) Node.printBasicNodeInfo("Providing network services", it.joinToString())
+        node.configuration.extraAdvertisedServiceIds.filter { it.startsWith("corda.notary.") || it.startsWith("corda.network_map") }.let {
+            if (it.isNotEmpty()) Node.printBasicNodeInfo("Providing additional services", it.joinToString())
         }
         Node.printBasicNodeInfo("Loaded CorDapps", node.cordappProvider.cordapps.map { it.name }.joinToString())
         val plugins = node.pluginRegistries
diff --git a/tools/demobench/demobench-configure-bank.png b/tools/demobench/demobench-configure-bank.png
index 5e2c01211b75612f9fbb62dd9fb8d14ac45125bc..867e762506fcb7b2f0e7ecb6937e0307bf06e382 100644
GIT binary patch
literal 58499
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

literal 62526
zcmd>mXH=9~*ClOMM5Pe~6fl62L4qJrM4-tzClQJw6(BhysAz-aBsmuuBuiE?K_N&e
zN+_a$<RDNWdCr5~-}}v4v*!CV|E9WK3yONuz2}~@&))mi-)bsy6sPD<k&%&6$p3Xu
zgN*D*CmGpc@e{}3osd~Ac!TWN14X%eWc$c}>5aM3@Xkrczx18S$jGUXe}9lACey;3
z$6e%=WsZ*>r8{+vs-;mj1m0q>*3xs4cEDgz_Ac-%8JV;b%FG32aoOG4#p<%0yt0}F
zH|jVU*<~{Mds12+1M@@fK3dxE_J1xl^5;K^ICA31%w;{RKmR_(9$1q3P4B$E@kMqT
zBXagFX{I!}hYz`M18PTz?17nw>I$z0GGxc=<sZs8)=d?qRJ*b9NjXR<DnKBLENx?s
zI@)`xy%F7!!2AQp7KGBTKDZe&GOf||O`pm`zkgFZS%cwUKK=WbychEDa0jng^9j1&
zKb<=?_J959A~I;m>k9A6Kj%4-q0&<El>CCtR7Z-`)Ig<mmUE}LZn)UW^J8Zji{3sy
zuBh?U{P#iWW%)hJcEb&x1NH8uDk3x4Z)!h({;R*bm`X)hip!u<ZDyB`kFU~y-|yxM
z#qUExW9v(JUM43Oi7qu%yxYu>e#XwuKAYZI#i^Kd3ll|{)6P{%Iit_``_sb7XK;z=
zSYzj%Uq9=nGeZPiroW~;<)C`HyVsUm&f)}=1#SD3tgWrRrZb+!L`B`@`QzZgbg5oX
zk7}n$1@YB({(x~DPqUG6y&J`)_-0e<N9(<ss@7lArRv6lE;7r9T;S=`R29#0AMw?t
zq@-Ls|NF|b#wkJQY7EEq>$0C1+>J(!W)jgk;qi^8Gd~xH>Pd5@&9gs}9Qr<nUSyH~
z`|rP3Jj7t6qE*Cx-t$5t6JDf}4uaTRUvZLb*d_hqsqEZb9PjBbFK=F(-ue4R>gS+;
z=Fp1QRRUA7GhJRjCGD%Cq!fc8)-5${_h!n3M06hgeX3c_MhvZ*S5vul5?pJxCpX;0
zbCP<<e}6Y1KQ%u;f409OSE(mE_xGpOmgr?XuFId5_?4dOy?EQ$6|ZeG+)!IyQGqYe
z=4f1gN6vTpaq92O-)ZDuUmz0le%zy>p|Kfh@(m6T*HuzFEq>(ST#t^K&kxndAN}zA
z%#Rda>%U<7{d3->|3ns1@1KYHZ&4KRZ(N=Tuul4Y$ek05+J!n@|BTNameWa||NbTC
zW%bG5A9`}f<DZ!PfArHR_V=0JM7GCOvbAiouE<M-+`4U0tIXET<!Zg?LrZ$7n#gc)
z^-Ha{P=7V&DspSu&|i64YZaXpOW>j2PTq^lF8OkHU;HFw8hE{-#ApUlB@3R69z24U
z6O1=>x~LIAm~nr{fAHr=(yVLpWt34k7Jau}rAg_QSCebbPq-#&2%X~nyayj4yVT_q
zS3whJH}L)CebHTGQ(NNAe-_}SpLPtNJ3fC6OKB=O`vgs9(_YRwIWfV?!=oyZ7Jf`>
z!S71#kj+44exji5^&X4+0&qf`k2F2EW=2Hz44+yaSEGtUv0b|+4bjWSCU0hDCUDB;
z!yJj7gF`VPAwl7<zb@Z7Oh$Hx^eqY#v-u*cDQ%8?jP4PAYinyHhNz&Vlzmg}#=Cd#
zVqU(?TU&EME-fLEDhmtiPHaERei;j0J5j7)yZ==}^~uo_5%KZ4+1bqWhg`WOBuwhv
z7OsjRC$B2|(O-t|Bt5--lg#G*)ap%bs%J8KdbGCFaGrE8yTA(byu!0SCAl4z6Z$FZ
z_gNY(dAsP5p?T!BS<x_vzBIIJWO|}=HW<~q?!lgX>+01LUk^r3xLx5>#Vg_u_2EvI
zUE2z?H<TaCCpH&^P^O+w?Rri#r(;oUe(RT>y3SoMv%Pe1$TR9|ongg(B|J~it{=)R
z7Djkf6Q+B(TB|qXelIX#4a!u!AkInRVi3Pl%<sT`)Y4JSlC+ulNz0#b;h%|hba|z}
zI!`<O-D}D8-?!dZ;DrfdwtsT7+>@u<&e<KV<MC&1tZwNdkTM=VMOQEQ(0&Z)%$c&S
z81<XcYAZk8viYhgxZaG>&b__d^>lK%?Jbj6gL7Q<5{c>t&C+<NE%3T@>qceF_ss11
zyE7Y&cz-{;CoVqZ`5x~0L)e12a2G}20b$eJDa9myjyP*7j;iqJTl3C`O6qim2yWRn
zm&Ww1pHFNQ3JYovoBG8$Y}nI{QJ$LX)*thYp0w9o3Coj;m>^awR}(I}Na`lt;>*fH
zO-|-de`1;(DKiejak&$?gT=C%C!Dk!)Z|Z04ZT)RP4kQLC#c8=8Oh7@CEY6adZe@E
zg)vMW@zeZS5WBLwmGq+hG@VK5dCDvG#-cLGU8a${+qe^F(KRXu&vRz0W<5aFRqzPQ
zAQ#IA5kkl*=R@q_rLy>fiFCI~3hCf8&Q11AHx}AsgWHbknPD|QqGn&6#uqHw78ZKb
zlRPBzZ$3d+bLq#epxf2DdUYq^_W4e4Vhn?rYs@|`Ik7p7-Vv-_@_U-*qJckL8KrJ~
zRA?l7hvK3|%oD>gY{uu@R5!*XUMX3V)S@W&R653zWoi!8Eo-OCuh>0@_c|psyKvFk
zYd9XKi$OjtQ;N;&+PB^n^Z7NejCiZ23Jt6M#D?;nmNvmTZ8ch)Ph`vY7!aVY#1y{#
zTa|sKo&V(T*gQe~N8V!YYL)%$5yASE>};$?A+5Ec+rq4_?xZ5q>aQHf_}<%6TPW2@
zRCY^}Abv`qE$C$;@zq!Y2G`c1)Av$z!ni>%HR^IPr>XpHLZ-}$vCrRBsoK$~mn-oq
zM`JDYt9N>^t<8RoJ~^5~EUg0gN^`k{n>XLOat@Xb9%ob=%iWLdbi-Q5QMCDJ;14xM
zby?~YjIzGxC?*pO_XOkn)HTXRcye-D>wX^VFKxu;1x%ewKPZ`M{b_>*+xJ=W^Cw86
zJ%Wb!M0+mRFfxnT(qE|xi+pF)?H69jU;2Q-R<o)6xN|Ub{MZp+!}4q&codu|M;lj_
z&Fl-MRbq#0_bLmnB#H3jR?4d~>n9fU8Ude9UJ>7`TbSGW>WDlj_h6~7f1@l!X5<J{
zCh4@aeT!PVb0^1aAi0eIriZoGRE@XFuW|MM=4gSfZhst0%cRrn^ajUvpP}|z%h{Dp
z>7o=JykMuo?4rmVr@o@!=~D{|a!Ija5*3O}6`a(YKHa+;9N*_0lJAF;QG9wnIB1lU
zn_Fm0C=oyk%Ofv5XSe=2NiM?`!|qg{d<_4TkBa(-6^wZf)t@OI>2I!8SzWCPcgJcf
zP`9Mc#!0>mrPENT?9HjIbR%ToYQiE_Y$l%=Y&WWW#g`;#o#QDUW~1J;(Ive8D_=K?
z|7ypa`@7m(Wg59htQS<+3a3AN@d!+RuGq;<jVdi4Eoy(T$t|xe7p}8*^nw;6eJn+K
zL6*QgpK|Tw5xXE}-A<E^2fHk&mE4BR?@LYOsZrLnd=%1VL06hlt&>izrlHnJ$`19~
zsXSA-8q3gk%rY*s%&Xba79T$0Sh?e>oN|J1Im9(9J+eeu<lSGl6Kve`@(UcxtFi0n
zQ%(`lUTWM(J$34ofaB<$P)2csmS<;m@7+5>ffW18YiZjBNrIgN??uwwV_&=)NSJ$q
z#ysE%Lf;(I*tmB?&!9?^o%>{39rIrdRO}}8b(7MK9U8SCI`Yciziev}uODnwwP&H;
z&Jh$n`$Ef>pfo$IG23NeP}cavmBRh@MY>;HQzHE`$4h#0L#YaOU*SC)u58zc&|ep;
z;Pe#2XuMsUp+1}&rPlT$B)U28uQ5tW8>gue_Ap@%2AQ}NuBT6L+s4EWWvr;3mga6z
z)9OrhO4+!P@bh7JH758k`IGbStS2Y(Mq_m+xHiNzHQK3lS!dfQ`KbQ1n4GlP_ungg
zCp04L^2m~wPbof8d|S1a$xAKLd`WX+CiggFG&6BZv(MPwdVeadmAy9gQ#Ez1W57L+
zpe!wW`x2~bT1mcUuFb+gl~lOz_Cn3pI?=(EVC+6qH&@a#-Ie9~?&OWHR?qr>d`YUZ
zX#F$AwNKxMP{Kd~py<)ZFD3QXNhMKi&yJ=ZmeNv*bRJ}vHHcq)fn~>Ycbs(TTOv29
z^w<0mkRQp;Z(WRx>hPPn>Xa@tmpNb#+!Ir`r?ekxYsTi^B<T8#{>1ca;I3=jtvr8`
zZSs6yQOUx1a-^N)Qe63|voW0<ZY5oXRs1U$Z<XS@t#99W)9?3jZu&N*y9b&j22b}X
ze@XQ-7`w3%VXVixROi~E5{Ht$NsMzK-kKD5Y(Ax195v>~u@y+(>++6@8W-d>7L@Ul
zXs<c{_-yRp;0ZfkwXL1qH2>?==Z`2axLgcM9Ck}elvvw8(>qjdaqnKiuVSIX_3z4>
zX2$jGi!I^I@_XX-lS7sAI+k(HJT;1oj5lz*n`m}X?fz!Z)d2SfvrAQyOY0LTn}N3d
z&*fbGu{+tn6l<gup4%DBIQ!nNRoHj&d%7BA{h3$UmF_26rpl^=Csx*CraLD<-Ew<_
z$!BTe#f#IsbEf;<&3h!C6yNoJdU3DHlGopZABV{j8@+2jzM#7%FS0S{><S=Wi<KYU
zaY;E%!r1&%82-^8hv}7x0xm=To0Aum69wdp4XS=)mn_|QeT4^9H^{cG3H_=Qb<P<#
z6u#EbR<cQbVdh2lfUcT-q#u!vvhSvZM@k7Kh;MUTT=7ehZj&O{#uMcfx7T$!HN6}R
zI|O=H2qUpmPtXq|HQda;%npbR=nHX;T$71WOgW|at_Dk4wN#qr|AoILB5sG(zt(x|
z=T936bF9&q6vq~;0WHeiE$tH>MepvSOr5LNb8~J_HJDKQto%J6xEq{wYvF5+kn&Ua
z={)R)<T){e;z8er5E`83bzy!bP0I>P8z;h0M}79ZmU=z?kWRU*!P~*wmA!2)>TGPA
z@#1DRM)cyT7>b~k6$@`MzIQF*vrHb=3H4RW;jtpc(r5LnSz36{|8U|MoQ%V{u+_;|
zKFEBaP}hE<GM?G9K|)6E32uFJa@EUXd#A%3n=fvwf&bpl&rZ=fdoBBOM@L^d3fEg@
ztLwTrxcPGb!!6Gh3ncqMry}UJ2aQ%PG&tP6^a}w{vY_i@k6HC<9H?_GWS&WJAMTor
zH#NyHQc(%3wjU}83=EXT%gQ+oL6v&6r4!$?IUwLHfu>Q2L`6lnN8QO+wsZ8LS#-nl
z>%^Tt@5PZ?Xunx7@N&%V($}h|l@5lJD1{~C{*Poi8)1(4hLT8oG*=bBXiy3IWug66
zeN(T$hfev4X7s19^d77k>-WqI6-T${BwTRQzDeKug4DHlKGns6M@`u+x7}*PMN7U5
zwuSaOvD^?%I&{h6NPL+sA%N1Fg@LMn>U@H_x}a%gv&BY7vgnf5PhHcaZi8#_$54}p
z8txcpE6ABKg!-7I1^Y5Cuz!x|tWH)p54sZTQ*9LVuB8P<E34*VNvyV$Pvs(7#9Hg(
z%2BVC^%=t(BupPaJ#ScT*Y)e?xGUrys#N*9)eh0Q2@$~ZUW>I;G0;mx^p{@2u`n~U
z^7CtIVwJka!zKOhRpBFz+#$24`|&>;cxI(Org1lBm1KS8`hDhmqV?KwL2>~<1!H&m
z7x^B~=|-<;dk#hM7xQr$&YoLR3O()B(B5eL@$C|(U$C^03myGPTU1(?FsB>ZQ)-U>
z!ryG_R(q}`BKz0t0zoZ%l^l$nL0nOTSbw!~*%jPTb(`*quR`qH1&$Pj`gW6q(x8TC
zOgdw_rmeb`Sw~s~sO@P39<|3!h|9h!UpXyr(yS^Y5zZ;iXV-G_t3{lBiq|qzj0sxA
zai&t0SdH4G*lZk@_IpOD(VIqb@z!)jr$kSsb&n18Y4@dJV^widj6sdP?^h>r?{zIR
zvkXYXxzL}R7}vSvcazAW-1+bM6q`1in3U?Kh`4q?y<n2}<OmwozO&=QrT6L%Faz4*
zjN*qn6;)LU-#>&<U%XfdG{^A{!?>LNoheBL1qBWG7dxxgQ@1owrMNoPscT@62-AkI
zK&wK;dY&RDFI02e-6AClIixx{JL8*ty^Wn(S*mO<Ame|f_d_E3Q>@+jSJw#o<3$bA
zucAT^C(2*kxIMM*o$_?c7(2mHbKWa@`LHW{v92qQX}&6M-^&^6V#JSL)1R?_iNeiq
z{Pj@%xNMBJ+tTiEB0+Fu{7JaXaB#g_pQ|Jx{@BUR7t4;d<KMNCo$tE}H#2+pmycF`
z$_}3M?yr8goqUxjkP?YTxqq?i*Dy;F#pS)rd&Ms3;!^wQ3$KMGis4&m#XKoE#PxH%
zL7Z6gUO`}g#Uuw6&C8&S>D3O+32NQ8*cj%P1)ZP4lWqGW`>uy7&3W&w{_<sC_eNce
z8skIh1!?`6*{_k~JDOa<Qc5^!t{`DYjAJ35?4)PS)&soSw7=&q-|f)6i>-B@I+p6a
zIT?SvX}HEAjfTghh|92=RaDgQ;lqcsgwnJQ;qe#g+p)*^8@)&xz@Lydr_yYP>Re$8
zy3_X7ZWQa4-4*v*QzMiZbMy+raU(vfp(3uc*~5+ALV8T@3j^BjL$2}Mb<<aoTp#7q
zC37KPIq8<yLKT5oek$2H%!@RebHT(zDhe2*Oy`c<a;lQMmCX6Nr6yaeY5PW#-ou_#
zDRql=a{@@>N)(uhm?RYGXB}tsxTCMH9~=^*X<?E5qa&rzx(93Boh?60tSP;E?V6x<
zH#2FvOPZ&7$7!@S&38S)#A}A->C>k(5RE!;2=mOwh(F=UNh$%awQ2TeXu<sLsWktR
zlT_C~&yfls4BK$Ho+AB<HDH!zKU^@?D%2@Hgp%A@mKNV#>)}(@Oc8bOL(=C=Pwrf|
zB2V$ddI&Ev5@T}g`{Pv%3BA|*=sZb=UX!AC>y+5?^Qp>XgU~aZ9Rv3lzGqAFosFSz
zkEQ!V=ZEU{Y+R|ztFfPohULkjhZWpUa~TRWzB$<`^8PmYFQ(7elRxZX<h{vlObEuc
zDjse=<TJTLSDdb7{ZN;)-XD-71^vMys-Jix`Lg+3-{A#Y{efne{K3+u0&LB&*L?-c
z&4_G^vfXdni@F^>s;%4!byHz4wAv+8o%#+J7JgVGR>#J1pA^xqbjsP$*LV8xLB8a0
zv`dIC=h;*5?>4SymNttl8yl~9WvbqmIoV^vaT|k+;NsxWw8RW6%LzA+@Pv=tz(pv<
zD)kFcv^re!iHXACRy+=2toy4uaZxDR@*SPn#8t;9=N03*@yD5bF3TG<c$DcB>8W24
z!?m~f!un^0dx(fgfBBMjVYtx{!m|3<nM---R8Lt;dESPH<FevE-%}wGu!h$)wf+>w
zfY4$Pi?02s_!*}CU(ceVqXj)zCQgxdr?bM>+Biz5`_XBb^S+J9vFqQ=qq1qZ45oo-
zq_`wH5`;PY$^7FBb%@~6Ux~IQ`8pnM-SRiAmq*`j%@&r%BqkP^G<rSdtao2B31tw~
z85<i*6mhk=e9iz?&c`r@!iVD@XCS5PL|<2SX=BT^+FY3g!toT3ezaqMIVw0bR2yJw
zAB1R+q8r}0$)}b%-?Z5eZ<9OQ>)V4>_L?vI6a$ZY!PG|`k|MA?Ui-Tnr1^?Y8{k#F
zc1eW83;XT-oq5vF&Unq_#P<SCs2`WZriq;{t{E=S{wK=PwQstg%8{w8up}%t1ZNc~
zY;xXEQ(&*)-LJOGH|D?bDrzA)#8LE*D1r!YV_BsMp36UPzR0JROJC(24TDZuJA4dN
z)XO&Z=Hnk`*xuUO)d3;&v2fZ#dt>(r;jsrvdN=M9Q?F5PWjksH|Lu79ldE@5<F@Tc
zC+UM-o{-D?oOre(qtBD^F`_@0+8S)0IHh{4=<jbdw=uYy=lr3u#^BCs)?p-AJH;sI
zxqRh=|4mc%$H(wKT;&RZC9n98vu4hdI2HGHw_{h|?3OFIk5yu*OHGP1<4q-800b!J
zjhq?g=u=WS)gX(;@WhLS(A*}7(zNgs^*8LAbN`YVzDn&CtUbY|WA?CY{lbOTxz*M=
zQk(8d?L0xERCV~>RnJo)6Kw2JHF<wEeShFd9x_4F#^676M|`heY7(7zu%2^8#>gmn
z*n3I*ORBgbR1w1N#z^UxBq3Xvg{W-X(#Bi7UbEOF`);8TAF5xh)QpTJ+l%$8<QKSm
zcQ#iAz1QuKausjvme91jZs@z#B}cuuzgWLi;4sp(wKZ2N2z5?5flub-$&>T~RuOSr
zhFFHlKAK8SMJE59G6NX?iVl&vmpdpgK*OH}lpEK&6_0ZXIsZ_a{PAOU>>1M;dU<@Y
zq0kTz{%wHbAYQJt(os(R^r*D_LN6cnX}oKo%2v?lm*a=`@2w#60;YHjtCb=nBc(LO
z=IR!a?$SphZLw*4@y)b+3$K9F#9ukt*;ddv1#GNuFE#TtkCb{ZH45?4e-Tg~awB4F
zh}D?l0fdATjtb;&O;}_-s_I^(G-LTk&ZKW#rB8i~DW|I~8)@k>3)9pkhqgSiM};bz
zvn%><31v9(YM1&7Z_BA8GcVS=^D#M=l-)tTZ?n2=G;|fagBiM+^gB+}NMMq^nQL4R
z)m%-}8pV9`D=9ff#PHAVtZIMD2@$&}#7K*>B(5m7nU>#M%uz(O%5S{$|0P9v_}HbF
zVfug8$*j#}J(uu3^J0U4j+eX=BLhw6q@eZH$*JSB(>0t6rmxjLpp#3csZ?W(_40O`
z_hySsb)Kf<p4(q-Il(Bdy))#_zP0E5bYqdLF#XQ9<gYuPrA_pg${Eak{7QoxK9rv}
z46+vSb@+>qIj!@Cf2-HSNq6Gfrq2ou_0b=OhH)&-7@Wgjercs`BS!9n51%z{{<w%t
z8<HPF?*;>oR>8$_iB7O)XxzMclm51o#n;;DX{%5sNfRV&0*{irOvdUS+rKZlC@jA6
z`5K_ruCA`AY>txGcTN2^bAGfZP*w8oN3keYI!~z#`K*3%sx|sF;avzVQr)lbA*9wD
zX;weKf0!L<_RpD&<J8Z5^@`VZrdwuaW+s5N%FG4~a}@tkT@l`3JIG23^7867HU&^3
zT|d&HtswUVbXn&7VF<zkhp~H6$!wDs$tD4t4*^#5&Rja^bQg3ANN|y6@rt&6Md}t7
z7EklvVy$gJpV``I-Zvh1L+Gj5SmW*cs4ptk%G7N+Q;KP&<Py50ku(@rS>2}z9R_AO
zw!s)&iAN~ZwfW7-Ikmnx&Z#Uu8Iv35AR%S-a1u|p?6^&PYv-2u8E%Oi8#L<%pNt>m
zZXI{NrMFCU?Z%T5Qw8-rEME@=d#>wm%DqsF{6tmhjI|Tx4aV^)PfDz%C+=@()+P#)
zpZVP8hw1%kLXKstu+|i;MO7C0D{J%%E<){zO)E`~l6<a>r+g5U@my0ic51{S|8=`9
zR|ihBk3?uaLmutZbhzGuv0^NNs~L6MHZ>t?qR9Qabilddd6lG`0PPvsGt~qRV!7fW
z0mEvPJoXCFLD1?i^&DM$qCtgasNdGi4HOF1s#{(bL|lLdg~$=Z#C!kFWnm7E+qd-*
zd~hSpCzEJjuWVnlS}Xx6BLPcS*)dQy-Dl{4Z}40NNHcLNLp>j`GJuXCqYcHVm6c?F
zdy&0g<J1=}<mM>G+qA#D8PJ77(6oX=@O9<HY@pCE-(E?5`0xRrTCP7-hqkmVK;hy7
z{CEmo%%8q^@#4+Y`}gk^2$V&3R6(<q<S=7u{{Awz7&kvWtMM^rU)LTKNavoj>DRFT
z89B1Fcx>)UkJh~<37eI9$(-#a&9YD9PcBg#3`C)~-B80m(TUBQaqU>;LWY=rL5vE}
zgADF@9$jb4<9Xtn=Z_sl&Dqd8(FJjCe{~NQSrS`V>Xjd8xNY@5h2Tb0$J5w^;|-Ke
zWzf8t$hEoSN3GAOUv2RXTQQt)rB&pW*`1uEV}F&0h^shS5?Npxh!LD=r3On+>&~#9
zVF8T=;Ra^$h13iT#h`1*$jY|yo~FK_yVr9a7T5$S=qytSf)hskwu?K&H;fjDHL4^2
z`;A*0Oa7lz*uvd_M(C#2HOiplx10vuv8eI|Zc@X}t|--iZ!>~m4OO}|oJ<;eg`Rg$
z$zwr1nZ(7<#b~Oi>*>AJ(9p2Zj{~HV;X0S>Pg9`mp%YtIKV(l$O|8A9H?!Ft>2RFG
zP)|><@b{|NRF(fa^6Y7UdTFl!ej-Y-cYaqtc(z-Hk~^O2MS|t>GiL7vgN0IypR?>k
zAFC&CDL+lZzEh4Lj8f9ZWWS`O!9Ech)`}(%Vr_`3qr>Jq#w#i>y_SxA_|U1|=oGLE
zbl7*NuX#K>+Y&)Zm;V|*+xzenTl-|evWRkv+C9COnI&}!>fG_~jJcmCaX+OCQX-02
zHl5sw%emUD`vLOXE+h4(82g&Hww)(45RjTdW}gMVq?aOnL2wAlQ>;8#yj+|S+T5ME
zX4xwr>Rjh$nX`ps5LgWffnL<D=pf(i?`<Qw0I-OcBJ>JHE?G|=D>q&eammZf%oKna
zm+$_><j>hWVp@E3J=`)&HdMpKr4l64*f#>B<sxqLc@V%=Hh2XH>7unP-|h7PP%KE%
zD1C&<Bf%^kaqFHRtgSGpw90_#u!T&9fU1qfp|iF_#46j|<m5{zOG_OOyVW0G0{EgT
zuCz4yZfmKjxpO@j{MQShmN5?%*Jg+tqW@0g4R)VP7nw+(hejRjAlB0)PVM`oo`TNt
z{S7AE{+z?g4-1@2J#`;8w7sWOZB1L3ZT{DIq5DEqr2L|xY@v0lz||X%UQzq4v}#{`
z3#_I2gY!bD;9wdqjjndOa=%TPy&a$0#9OhRZEV3!KV_e8Oy}>cFHqMuFW>oWrtef`
zPwm6h5>an1C%FHhX$9R8(dd}bU|7>yy>rU8UqiOpFSu!ozSf{h!;dhIdWq#{D6=Ri
z9CKr$l3enMQw<v7z^UDD!`k)e50^x#qjNq5G2_M`$|lFYI8v#w&Qa~NXXEc5N-wD3
zJk^2cC~e3L;c0r^9q|B4eOr6G*4?}Bq@;tpXJRwl$PqmH{rh(p5?=Rs3J*7TUx{)3
zp}7QYZ6&1_+^<Iu`R@Guq@bwS15;S^{{6ia&mRdpcVo{(E<$JxD0BsT+avor9zLHV
zt{7C=#9miTy;Ql4);B2?Iu{lfgn}XiGbyrA*%KI8wbZ<C;=Qqm2Q+RxqeZMM+I|yo
zxXNw80BHrGEz})t02K3#$&WQ2NBuHb42bX?EOs_4T%sEo-3zQqv9a3LRz^d=*B8Ig
z;ay*0fiUKe0;ng?IJUlrP>Z|dS<se;gs{ZpPKGG71kvxkr4xVfg#S>Hos}7_cG{l4
z26s8+zV#)Z1gu@NX%KEwsgbi*r`=THZg}}deo+TYfYCfxR*s=;{M_#0Qo;2fNgTZy
z9RxSq?2$kGN=+gCH!G@mSkm*^<)+|*R40W_M__R4B1AX6YVGdi>Ybn~r6Z;bsEJv=
z?B{>~9eLi19<8MnBgPmG{{ts+cxuFV!`QP?kQh7xeM#?Ntusk-e^qjz);U);oY8o0
z6wAHvtxVd~f7f-?10r2&AsQNxaLGMk#|FP$FW+Bd&jQ9J_kKx-&~SAFOKRh?k4(hY
z=;O07adA3hWjOA7B?LQ2?5=6Ts+e8D@#t!3M1jAc%5&9ncS>@<Ysh_sVS1z*Lu3bh
zAnG=+2EaFrhiZLej-Z<6zvnqRSLgVu&h+62>O@g@gka~6$K^;pKE@^_r0dY|Gstae
zxL7?)HXkW68=qmi@^no+WujcRW^!$ph8q*bJj+4-)-jv4bR`~0xM41#Xj;vF$IsQM
zd-pC0m!R%j^lC3_(TjZRI1@qb_N%DFw=Iqhx~Jwo+4D}lbB1r@PM5N5awY_^wV>jZ
zrec||Sv6L4U;fOlFWJF+nhtvf{VIV!r>mNC6IH0!F@UC^)&TE`6hP}O=$m>gtu?Ex
zy6#2^Ja~UXzB>V(n%~>2CH`ylaozfWEs8b>$y;9%_~qd9u_~RSG2j^~lnZCv0xkoU
zh~=)IFPFs=!X>uyhCRkZ-~1#xG&8LIO1|wZfbK|s^E2Mmk4}Kz25=X>n1|zM!Lc(e
zA|eJt!yZ{sjkU&Z!e9Y$U;;!#xn*Z+F`)aK%TN_wZjt6L&}!=yK=ZdX5v|%=YTBIM
z6`7OOt$^!&`WP<`CqdXjU?2`ChA%=RF%w5BYlhsC?CWN*>E+QkRQrHuB)uc&nT9So
z!i=^K+#>i~RVL+R;j+F3#O2X@oET^E^$a458>*NQU)bHtD*wKrWqcEpoG1{kt=D5!
zd$omGS3bf@!6Df@O+?Vv*lZRHkucb#Ik!J`GS;5Tj2P8f9lONV_v3|c-9+pZo)jZN
zy_gUehc#;nvL1aCumv%sKlT$!=#jg@e^cE6xZZhIEG{(_;YyA?J)y3yUbnY3=h~wz
zbQJFlrNZmyhYMAHyIXG(tvGawBA7RQB#;h%YpqB1@U@vgsi;WJ``gV(Z;QZOE~D3K
zQB?Fpu;QV{*gdsQo%CI4z2OCk$aTFRtxI3o+Y2Nj9;hmMNq<-(z)jnx^s?~rX~3}i
zeSO|oH$n0uLBe8{lr)7YMi|0-)^A2WBWQqF<Dl!|@w(1!!Rza-fd<bCgb;+KaOX8q
zZ9#*$flz{BTueL6GIgyTVJy|zSJPZjoh|-6@Aw5o{O7+F2sQ8g6~tA0^<8oo3MKcm
za<=5US!ApP!Bj7=A<eINnPQT(IkCDaFv_Ewul(uEvz%f4NwzcBf%-)*4V6#CebH#n
zI!-fJ1>c*mNg8zS#Lsx4t0;tkq_P!zP}FT2$K;a^EkK|{de)Hx8&3gggKVt-X0AjF
zztES^k67i9zPjzGxx<<_3ya;C6jYP2bb9Xdj#gcnGO@CAmlW>az5Ddbahrlyuhf`)
z*CN6D)HB_eE&}Y@?3$M=-V&aXEKEs>D0XbSKJ{E`M%UlZp9??0z8BO1l;71B%K@wB
zD$2rQx=W4;qjmA<U)_LBr&*E1T!Zsng)g1xe3bRIK)Y~l$$#JQ=g*(?{FX1c8`m`G
zk>&nI{YzZM9}HnBdx)pwjk;BDo;tmt&3TFgDf<o=W$M8XkFGI3?wDR`dHRnP=~CC}
zGP5^jAFJm|>;KEi^M#ig7pD}N#z1a&dl%EIiKhDZV1w6+?CbJz$;<7Rr9^G|tEp1^
ztIw;e=F|LRd=k!d4UWHMA)FP-X;{uRFkywF?RbWB*=m$H_wOkNT8ooAllWQuXO{Ud
zRT*J>Z;#z+X0iuY5Aqs)Zb_>V-q&$lji8ix@D3T-f45cr$6)n;_$kmEut?>hM>ZiZ
zUSv}`etZAvQ^<%aau)i-E!CK$gDHUD*dGjB|9$TN$qV>@xXAzD9{m68h`{=r+Q>2k
zzhN7grHBhU(0k*{%;kXN6>R&sy1lyvwXh0ohY;D&T`5G>xy)pGFV@OIx17jpb~oLp
z)TGe`$5pdjLLRXG+cOuc{P-DKMn)!)A037ybEv#o@5Uj+(evJaR8sqco;2TI(It=!
zu;t}V^Ge{ZPlYdxG)pdTLjF0OeD>^F$?GE)2-^%+%R`_1H*uyDZuJ}(p#h`~BO?>I
zPC=iF8E()&E4KUy6gB#CCD2G{IQ7y26gTdy;6kxuP|17JN82Zz@__+#sviO)p!iY|
zpJhjKKJ+<Uj$%H)mK9q5F}HohzWwtBbecA6(_O$4oe^OIsD>Cm?Q0CZ*XO&i%1IXb
zI$5@_dwYA+$Dtk7czpcq84*H*r*r5<A#O*X!H1uIhKZi|_x^5C(4->Ngw$JoNSlkz
z`+mlLo0EKB4sX+1SX$b2B;Vcwo=n<=1E~HaAqO23lhn+tEPRIaahB`XgE$?CZufop
z<oT5OdH=KliWZ=xCg34(qcX#&9u+4nZQzzRI3y({r+q+cocQUHEbCeiMfkyk2QG*V
zF_g=<y|F}q+KJMSLz;yrPmai+GAgyZ7+cP%D3QkFIPX+D;Zz&g7Vq0+Mk{6eiJ^$%
zmcwungQy!g<4iz{IN`N`#6(92a&yf2`W2S5&`rPv*c-Tk*1?rq5Z%6dmJ%*%)pQfI
z@#_Wh%>-=cL5_M;hI@s(aglT%=(M`=Fwwvcq;S#mS^V{R%0n#ml<j?JC>4-O54hRz
zO8N{KO6_YWX(;Fg^4?Wd+x2Hc9>3~{0NEkmjiD{1&ZSeLK(*+4{cs%d%f6}2P4fft
z;ETxgTs=sKt}PToT3&#{R?`B^aph~kK+l4Rb@GWk&@O<ny_Vk|C*?}+vN=jzxgrHL
z<ykRzKqBCEsE6=^qXhkSex<J?jF6f)PzB@Z7{^ZWjcMQy`%0Vl*yU%tvYril&2h<h
zR}oAKL3z<Wv8FKRGhm%N1AbKXcy8lEQ%k_o?t+8&nU5r=ah(=-{9MF>c9LJIavHb?
zLFqM*?>{HB3pz+(SiS3<+t*R0g4Z590FYdWm>TOZiGl^3`-Z@dGkT2v0hH%t1gXEw
z{278`PHEl*$#3nOdH4*#sN0+i%i;bz(r{y5YL{VxCAR1Jk%7V|me|nB7SBedq!a^P
z!gVe=b^}nDHhpqzAF{HbqGVM9{A}48&M)+H$dmZ(%ae;cmQbxPkxmDsOI2#KS<A8A
zai;wfr{X)rR+UJLLxvZH?0bPXr4-&Duq{O-C8?}eZN%3PvzYUNrM2nGd<w!qc3|Kk
zc@^HZz3rvBpP!iGnO$dl<<ZFxgZhdMbKBe7-w1kbEEWTgC$DW-h;*Zg;@)mwYhz;0
zBl?o${!RsSnmWa|@-ZIO(A&s&taZ9A4CKFlEj*nF;sL#|V>)sI=%xfQ16p)+bO%64
z)Pm;x`DqX|@X@LgZ1N%yXOkP-v5ATFR-N4heYaq1?KzY9U6Yi5p7m1+=!$JYDp9@A
znA?c&Ly!P@bM{hvTKPBd!=y*bIW&^`q+0mpk>YIM@KaX48<-PU$Ztm&IYdv*Anix2
zu1P*3Ulf)$ol0hs^z-=|^FewOX8v&)50rE9t?8_QaTsr-G@lju*i!dA(%XWoKxL^)
zY+Bs^QdPdY20~aKFap%6&U>3vb5V-iU8&;U%<@Q{1dS0ODyh$q<+i2-Zn1h3p!u=D
zk3sVr1?#twI3g1U)&9K#k7<+GG@`tm6xqX>?q$N=ACqM*Hm=tJN-OyJ^Sm`LfEWmL
zKm5seYb_EtdFqJZr2CO#^2uCs6KET$!{+$K$jQljK!ssE(ZPJwcL+LwUC8zZATk5E
z!-7xY&7mDA1OZN)o11N&ouvX+wo1Fh=X}o`+(?)h#h<C5&|874K42V?oHuLZP}V?<
z2AKB<Aowty4;HOD0IT%mktG7~3wKp==K;UnpOR@!kfmi{VECq9K5vy<7Zn*v>Cy}n
zepGz88e>Qolu@uarAD+)f~2eik|Db<C&1FP;%gDW*J|Y0Qq$1%d3xv&{<oVcH+v(0
zBjvnH13)^FX1UF;Gxx_dP*SSKN{_`}mcI?f5ChbWa-gLwsGzjje0Af-ja&ngJUGKQ
zzh%ou2L@Jr`=*xylotKX2Tx>Q&}KkX3nU7;Xm2-O+4}9ez2r&H%q0wnFfdHW?pwO&
z>JNss+c~1*iCDVxeR^>@m6et0<;YmIwVk?DZ^SL=Fx;Rn=(E|S23ee31SUJ}?AA{C
zSW<TS(M?5SrGdkf$4BJIX*f^#Fi=uvK$5lo{{C-zA^T)7;k$n(;cP_N7p-Oy#{(Ie
zqlI<EGA9d*Or!V48Ig@&<KedJ^ZinyYziHjBw!544QM4;SXlDf*JgSihoReFQo5vo
ze*Da6sVF1);YT{DPdp9Ffq>ju<U#WF8hd)-%+`+Om&BtCxmavLUfy3({FoIay+wO@
zHJTvx*zwZEix<y7*o9Vw`fkxmTa9l&TRq-)<kHOUKM}x5QEm1HdM_7fJdV;>Zg_|#
z3O~#QI->}>L)?O!ZD*?Z76cenPc=s;P^-bU?-`IEj8H5P^1b!$4w!*Td1$>+UmNXT
zj|IsRmaoZ$^#VRP96&&n8H>;7;GwJ`#Hg_k;|R6RXc;-V<AKGMl>)}TBs{X>VYwR=
zyH1?B&dI3+dkGX&RpXf#hU#^xZm9GkREg`HP9wBd&yr0Bpu!fLG>SO-K%12hS}Fho
z1r?Pu^KG82a?;Je^Yk^v$6PDDSmld|zlTA@<%CFDbaWQvO=~C_&=qJtjkJnFtU%&x
zU!|oqDg1YS%0a%)x%<dz^@~uU|NdTR$rus#n8-2t3QP-nh%sV@>a@YAAvEat7-2KQ
zW7D>1X=t#(G4V|g!ZJbfffZ=~)Uwui*-c|EG+-tW*bG4%)wp->$v};R|JNx~X!WE@
zE7H^NfaeGyjc!36ob<Xx@t?V<yXytxBxwHeG_sFkwmU~L2L-qS8N(rv|D~p$QC!4=
z1eynFJGLYr-{|cwzCB-2w@^)_$BaYy+(Zloz0Lmqp!?qgyoQv$y}ga*IY|5zMXT54
zfiI>`^#{+6?YCEEQl*kG;<~23RjEMYixf@?f-l$5zLtfxJv!Msvb1Td;QRPE1Ux9g
z|9T1%1*|m+>;7}omx7E_xERh>6cusi<m9jcS<M}<h-?V?n(^3(n;?}IpOjPxdLn=w
zQ{;xeW=LlZ{84@#0ejCFy;vQ6I&M!PLUnPaovduoExT`*fk}Yi<G6Ke{Z%h=!sh+G
z`W?UKfoe=4jP)(6iwvRv3>kgAEOjb_t!4YmE1>LIe2z%(GK9fJ&_Wg1aNgAZ)2HWl
z9V|ey*~p~pR>BDImGG@YL<C^dK{jNCjR{bYq$ZD@rcIaJolzA)Hevx|Dt=AO_J|#^
zuOmg2BUwmUvn7b4=UbUMhw;d79831>LeH&>Y5=fwN{sTWYza27T>gRKckc$)xi6If
zfs_v$Oay*!;kk483bGXedEMo;{%3<qy3;?s7ulT?|F3_tPb4F?R%0-Ouhjt!u59lL
zoPaH6V@|cbCB~wzU`q)y`+6DfhT_dDC>V5VrZ52r2zLcu$zG_R3qCx)x>*S;@WaQC
zvyifKrQp-_WHU!+@nH<2y+FeR0tPQwk+iX|K{^ZA`*hH03iR$rcOA)7^=n3^T>#v?
z+UIF#K58J4h2r`0X^Is&_z7NbA|EZECV`-la6PHv5SiN0NE*CrMVn1K>c95~+33a%
z`1S7P{~ET-V$zM@O*{Vi%bUn2|Jl<6=Lz<|eVpvk!71eabR!mJwzn%m^r<4k5zLKs
zg!wn1de=w<Q$(8@f-Pb-+dqE%uz_7jNZRR~>UmCi4SJRE)^#xh;=u%c{Uz|(GzokV
zebDP52@k;sa`&VWmj*2GZZO-P?6k?azVBqR<;R9>|8f{Mg0%A$&eRLim6tb?VV)u3
zR%ZUG&(LEX*{Ib4empQpDD}|sir9U76%n9rZd*}j*Ew4)gRwxPZ2@}E4pbEaZQ}E_
z9O(rhu^Ud>rU4UOw=wL!nL#%CYIhHY_0Eu0#B%!_3F$N7F{s5Ku{WE-vc(tb^2kS_
z^am=?!0An2L-c)w+~cmDh{~#_z$ztxP;s>pz_-ZQ6RI<ta=l%HmUv9az_)T#$j5M|
zQb3-&5n~Bvv^G$izShErA@drPm6eHXPDDRu3<(dPO1g;5U>I4u^WDY*<*yHcteQ*P
z-$8$^h3B4i@ZU}Xg~^kGK}3M}&l#%<>z?ZfsJxNt@%`qAr64Axg^QhCfv4%$gRiwv
z4!}mI1R$h%nU<`Vu!PVCy&aU4snqAsTkY*^BEFLblTyS~Mb6WphLD(X`!J7H_un1@
zt3UxLD0Lt=#ejMR>x~U+j+M)2KrEFWKObQF%Vqle`w^E^v)`@@$iTg?n;;D!9vsAY
z1!(|$x@d6hr9gfMt2BD1vPY$GIeE4>Yo26SWs|cHNpt`Z^8<5pL8N~<kpP|6bdRd!
zK^25rL%}3r1ZJ@+`;m`plKZ(SZXgoOW<#R^^s&%1NxMqfw%arV=__DAQa5b2)5~Fd
zj{FENidbM7mzN!(sn(oIaZiPPP5>o$*P@|7WY5pr)ehNzNfFhJ0^D^2;C#IbvB*xe
z(tgMQ5`Ha$&f)flfU?E=mG*wv(CJ@a^ALMx7cx7@56m?XGClAaZ6l+iU%xz39N(Q3
zfyNr2El-8G4-u7+d8TH>k9<%yio1Dd<=8fzyRe_-A67djkZoo3Dp_Yc5fjh<&1dGI
zwh3o2gn7&yw68%P8&N!Za#aaA@g@a`Kn8Y5t;_$T&j~A=<#fw_Fc0G6E>dcn_O@&>
zBTdGzehGksNZ?YjMr2^#%<Cl9#ywz4bD=~jK!2|eon)oMh{TuV+nUI2fcKFE(f~VD
zH>@=~i~<5z+7tMxsi-u^*D-cbP0Gv5&jVun_U#*em9^_OM+`98h)b><*-#n+M!kqh
z=xLmlU-C*p<p&8#6S6#jtsL;d99#n`cn+)(9VWkD84y^I{JF)!)E$+r$kSN)aZEq&
z7RP?m05pKeS_H24V1~R7W@vLg8AeHpm?^TMq^yh|*;^NaAkTx?4-O9Q23QpXcm*01
z>-Wzo5iBq9YxJ;uH@HBn9()MCGc?O5R=DJLATek~50ODlv;-(jggMxj!oju@;^Si!
z<vgHbc~7>*2CPC}sCagU!6pqzA2&ZgztJ7A7Fwiv&E~Ivj=Z)2+v&jYLM-RphQ(B~
zO`1a^Cqp1@OeYRk0o=be8jU{Q0eAQf1ew<<$;oz|iGm!Cd(g_3MMp<30DvGxlsW(n
z>*nNCo)Q)HKoWMix~Z#!sjIpXO2;;E_myx_7f}w5LRk{4|1MD0!|NVmaNTv_T^E2Q
z?}vRKHP24dJ>W5V&AXi38hwKZoBxnhX)?ZEOpX{1Lq~WJxuFp-fH&OoI`o_Kfa>}|
z9j`*}1Ax&H@mvv%!O$K%*FJcV05K5#nnw_+&K`NFPKoWJg^lgAn~4x+R%vbn*6W}s
zSUC*7zPW6Ya@!e;JX<)uAbZ{pz|IA@_TH;%{eCwO@T$!>G&J0)*WPH<h+Z$X@eZ<q
z^|cEAg{n^2@Z$|uP$`05jlJ>LTFAQxcMjGmox(KNnn5SUl${rai=C&)<iZno{z=)r
z(&rH-3o5Pn&T@-X77w(uScH{>GzF3#&!H*wmqZp~wJQi`h~gBLY<&ha<N_D;TQCTQ
zUb?LTd;@uMNLUymjzC;z9VMsfE!cw_=>aAo_xbY^@*3Og3xc2pc{Z99>sMg=NWzfl
zU0{#MQS2|$0#O$zm^y^4QRJ?@htOd$jWgJ!^I-4-xtZ|V_o4x~W`Y24A_B;-<*~Zm
zbt0+dtmJf<=;Bw<y$$A?if#O3we|G!z(1wy{G+|Aabvg;++n2(*ZdJn87LkItr4(+
zHKPR^P&QZzDuEgRakI}hDOP0h_4wN7YvD&^S!LzqbhjHddNy2?i4}DlgHW;%v}X^n
z+v9AEB;lpsM~1~TeWcht3Z^Gjeqm9JV}->H#zA#2uR3VCF~leY%*l5c+(SJM1ePKN
z;+whzkxpy@wNZBvtBV1eOv5v4=;*|OBdmwlzNXq?#H4Tw2?Xjs)|qc*S<L7yZOmL`
zRFuY;5ri0vJV^57B217dfVY5xU;lBz@PbW+r6OzycljbnI5NNiJ6It&ADci2geWcJ
zA43bZlXP;M6*`B!=8BP;kqRsV;>gza<0{lGjk8WfHh*x4-2zk(&H*J5A5PB4=$m4$
z%O5^=I`5nwexgxhXuVX~TW2E`a$)9=&a_el$U<23f%S<q9*3Xy|2-h|Jbef-vJwsz
z5hKE=L4gE8qB{b$va)i>bZVk~FR}JtFTlhRkjmp<zSNs>2J>hk#3=`8Z}Rf;!7pCK
zn9;IxbC<a8av08wiisIT9r9o9!!iN^aix@Lb{INhLHm&)WDCV9TV+II2h(sfk`18(
z8l%&E-9m|#1-sg_3pFEgD1D$_l&T)50`#f^bGN<w2Zy&%f)t~G44$p}a%LSKZ$m+O
zp!wE<{*d=D_^tqY5ujs4+=O6mVFzRe*`V|*W9STeaBMH(Al2pNsXs$QZvg<r3;J;B
zI5tsVHZd_Vi*M0MNrq#Cp!NU}ZG(7Kp#eQjk6A?oyW6*KlU7777BJ#5BXy3#dy_j2
zs~tU%!?Pf7UpeQ~E0<&fUFa5M3jxf40Jz9<3^GE1MF-HD6CRt&lM?1Ftkq|U8o5yA
zTiTnwYul5GZ$v+MkZIz*Ah-)e*%thRynKpFzx*DeP9HuimR?v=SD?Q4!j@CAf~;3k
z7ExXVl4TiEUFW~47wYW#uP=&<6|nD*|3Y7Hjd*e-O8&}~4Cc$}0@Q38_s&tu1Pf3e
zrFKP8pI5){Uo=-Yn#s||Zmi`(t)`dF%5o@^BSgTOGWP0~h=^k|%vYlMnk7B>aKd!(
zEe)TyNn&ESLGMNDjj-fhXsi}>p%y5lP^@}Gy6Ax-8XFb$Jz@_a>zNsFk{}E;%x2r7
zM=Nosp|P<rI|Z+OR(HDwTdv0$m7ScN%)ZbwI(okmak~Jgn1|SJ0f=&JyvUagrJsRj
z4ybMCmp^H!sLT~LV|{fZJKJK{_VH^|v2k>;Y9I|E(E?x%S^pAHPz{%hn1!{=W6JBA
z9}7-4AFOG$q~7TZ$JRiHk3zOZ<XXdaKs*0t$RwyL1Jc{$Oy6>DKm7g#viT3k;`sP@
zPMQ#|2(<?Qk=-_Rs%HzH748~RvTwyZhkVF{I;;?daIWl2J&zud5tZ^0=MJpO$+{9~
z%cHUZnTk}R0q+BmqKWwRC!0j)DuR7<N-FnDD<zG&Dk?<;?7pe}@y8!-6<UfWiE5OJ
zR)rO&e;94Q^n}ftYQ6=oKlH&oH4Mf?jZTF8gfZ@hVpIvtEA+sKh58f)g*J4vz_uf1
z?HQnrYL3z!qoB_QjB5qjFmM(+un2+pD1aL-0EGkjwu+(A3h;>pLrw>%C+M|iMR)ob
z<WG0RW!G+50pOq@o2j6Xv1HxB_3WN%nnW>Vl~3!pxww=M{3R7=YC5|7E7Cz)ifMhN
zrlv?Z!s^O}0<8^8*lRT4IJftgS7t3p7UlvdYHx23<Y+u#p-R{zh|o0i-^x@rmI{j`
z3O}PKZMOCmwtDb<$Kl2$e7B~7`qlwOA9712SjvH>>|dZH0Fq4jVu>`EO-)UwPM?lp
z4yC=BY0&h0b_*EaLVNgVR<rnR1yIGsMz!U=&M>qG#RL|e&D+4E28~`-Zi|D~qDy0A
z8PHS?aAElALlNzXhTA9)&>v#2u<6eJ8|hg9t{~KqiHS+|8u-_{VB0|zj5~r8yFcWZ
z0}w=1TX2@EvFxfDlN_C$o%8(*4Z#aCq*M&3ixsll;p1m|p_eNl4R392*+6fBa9#&A
z3E1C|Z|z9NZmh5O!M9xq02PCHnxW$hXEsjO7qA}`Mzj#^VKnt-kr8IUeju&nAkv}d
zum)1R+B`Ki6^ZrhN-ysd7X5d|nGiQg9FM6zF}x%*5Uo8_ij*-j0$ovTRf6hK4p!E$
z0CrsWc06Gip9TdLsHBKYHu-I>%^V1K;6r`(NDa330F0bmSSW_?GO1U7U8v#OH*T|C
z(*Oiw794;Nmf$J{kjn<z&-G||7_*wju~n~M+&Xgm@ij`YE?}D>LUTauX~GnWiHpzZ
zk_l>P?{C8wQ9RnOwG2d0#wH}pEC+oC6OJ}ODs2$H_I8*2oe6Y1hsoYFBV9S`g^jsl
zDTEh7zPJOr9&l#sLPFkx$gtq0MYg6adI*|#(vXq;+Moh4*}!S&XeVq4WAp`83;C1_
zJSTDxP@sLtF4gf+A*W9Vq7#{#J;8Xn2y7y-;fBe*I_P`6^M9S@9e2;csF6LQI?}0@
z^J^05+`V1seqYC(6FdCa|DO+%slac)KbU;kBZwXPLhQSDcSR17J#vC(ASNm4A_H7Z
zP5DG>hQiTf$Drng0hvKIsRkehlnQvOn+}f0zrSB)Q0#KJAQ*3>4Y?lppWN@?ABY?w
zdxYbq4}~b#va({`M)JBARUrD`TjM0c9U(8cIAjXsB`ozXJ>eKQikuo=qeqZ6fxO<F
z{LjJ27X}@?Zk#~Qi@g5Z(>UgmtHnZ_5&QBbYsiPIg?NQ$Kq%84dn^Uhosp5jN5A<6
z20Y#1qlL~@+Pu2}+avKdVC9S-92}fJM|LN4WwleX(6Gi{5Gw&1B%%w#ZboP|UrWK2
z@Q)JEc^Wh!GO#pvyv~s2l@;j}o<1fWnirCkl;q><8=IQi5em1JcOAxma{pO21f9zf
zvh<Jp-rAb9p|aH?aF#q-<d0C3r;oq|b)o~c1yM9GQ+F^j%cr%&Sdz#dB^F`7tUTz0
zk+?&;iVV`SXge}xcTQr-{(WlRRruDQ(LZ$xV{@Y5tgo*8{@lUn-Z>eE`G+=x(WzHK
z@+~Yo@L;7`@pm5DJw(RMs$Z=iy$1)TZ)qtmbAs6m(kmWH6)**X8pvKIS>z2!G$q82
z&d;B}f~^K=4B33e0DmliNUG3Q7(9i7706vfxAvRq)6FsnL?1nR6f#H*JbDgvGg?s9
z&RFyD^8=^B2H!|xRFlF4yY!&k%m8&#yxidH<KqHMD~Fg^!@(I@*w|VpZyhEZWw%6T
zcvJ(w^^UBfzX+%g_+FyCc6}K~WhhjF;FK9SP4<TR@_hh4kN(8di`fEtg{*s?nmPwK
zX)UPb90XT@Hi(l4o&$uQLo)a7O#|kR?YFB|bYC32jR={DUlgj)&dyFR7y^d;winKL
zVzaZS!Mmmg)Wi8d|I7q}Vg}YB)GIu&{EJTg$YwHVLP3p+NlWAL_xDFUstC@8&H~`e
zO(fAqtwC#qY(1~GJ${za$dYLS7&K@zMVuy{Lv0Rx{1^{ZMHPT+h)+c6gG7()-+@yV
zw68!SBf+%_;L^xf07-kYY{Jdw0e>U7Vz%d-#KOkStpcr!CIE0n-zFGf62MB4%0jV?
z+9LFi?$v;R0E7&J;yN)to>jkCrwDx}R}}-W&d7j(uhW7rp%+vr(oByWBO{}3EaW42
zz3ynN<KXq%@d%~kmqoU^0OZ6e`7e)3DW{6*10A%ox*DCEn+u|LA>don3Up^5^f~M^
z->=UA<yHzy0;;f&k55cYOg3nN_kdLFg>bSE*mJ<oBKrslCf>?OQ39mm@}r$@b9<YE
znfX197>7eY>~H|LMWB<D6R5b?JUu<x0Oi7V*+f26Frrlf6*)JuzgNRN1GDoL8f~jW
zMg6xGyW1PKv%UEMkZWv-2m=6Y7s8=I>>*VD+B3-=DG=k?E5sZe92$Rqyom7b&@e2i
z{Q$)`1HLkA79OFX?Ck0iky9RW1=Im8Ks_YjABBx7?1w}UM<6u1b+}GF{Z6IUO}M-s
zqzP?5zb2SSWZx;YpEE$v<ITgxEp^ji+N@y<J3A|@8Z@LaAXUe5=pL9=!PSXRmwL>h
zKu*RgsT;502L`x-a+G3i4>Yku^k9uvBthKYA?2@+_A3hwA)6y1vM~U7bRZm)v4|BK
zXj10r*6a@<7l?th0Fin?*%Lsuoi8@5QE{E?i*2>&23zkz$4Qza#JfDK?n71^{AmW>
z|GGTZ!qBEyZI=Mv_fmj*ZJ$2L)z;Q>$2Y>j=@;v8nKl{0VtX~|3$aWb0sCVyOx7&4
zRlQWIVi`!gWwZ-PHV@g0DVwDZn^{VrHNP$orJ@g(8mt+OSyxmn`c@J`up+_`q*}x$
zzX0@K8N$Y;r(Xt8IG*VB=AwXAIvj(1X_<nuvi6-jkA^nkrVBw%LB1Uehr~1XJ+x0)
z*b%4(Y8Mo!Bn{02cbqlA5=2GDbnZa!w^q}<t87`J4<%k3AdW?q0n&1S(ruV{3zH}T
z<VbwaAu^*Wg*S*>0!kexAvF{Bs&+?Qkv{Pp2Hi;dg<!^?onosmUdU!a!gKF;LF_qz
z{MMjN>Zj?AKsE<jfq2;l8IfS>&o%S?$4_XaDvx$Bw-Sklh@&|?JRHnA1~zo?{Y_p_
z&?m>o&Feqn%Yl4>ePQ+&ggNB5x6Mloz+4S+z6Qegz#(*$g#bN1OYW?o{ot?QRmNL(
zFJT=4rD*Q%191r7`~<sd9zz0g`yxI8{jVC(M!<VoxbFbHqz-oMt@Q<t=+=o9U+%dC
zHcDFBJcK*ybB98OSSMj5ND!O--M-Kh!gKdRm2)tBU;|(THhLi|1*k8?d5^RHgDlno
zM6cOzW#gzG7wE)*7s#rByijse@Tx~2=z@soHqh+f?DuQzc<u~{*(~5>0@gqYb`&9q
z9Y7?!&ePLFO7Jsbf#*1LNjM$J1W1?+`)y+oI^D_LT^Eu>KFVdT?~DEIsn{4_Ksj((
z^F*MSK+e<F($X^XtwMJ)0=}oXB>d{#5)>qc^MKuffYboJzIq%X3c9Q~2_|-e>fp~p
z5*<Vik%4DZ?Eafa9DX0UH`-%fgEwbl(O$B3HO|mJvfr*R;P7#~PjF9{v%2yiFXFC*
z1G6Sy_d2^5UkQ-YsFlb|aqKap{|@lfLv_7ku+EDSpTn`o0X0ZjH8LNxRgeKO&>A2D
z5`j7P(>%t>UD|4Dj{R@c-Q21d{BMAc0RZ|l#021um9@2)xA)Z`S@g_3e*Cz!ZXTkQ
z9W-uufIjFgCTC{y&oGEsO@GZmoJ1uBX&tHJg|I}RF$=!sGOhN%*n97&s=p=McViBy
zm~+Mihylf%F=9X^ix?0C!3an&E9R_-h+;$q6hwj`A|PS_6-5w1Q49!z1W_<xc%K42
z=iKglyZgR(`;GU<WAy0$HNs}^^<ArK)||6yk;`;{e@k2|ywrOlNc#2F5!h67?Zz*h
zWOQzFYax)N{@LAXz$wFvras800Mw8U9XfpYwP&|_`4QR_6nPtug5BFY^`B*vP07;(
zs-#aynlKFpOCG$zATJNP;4=*CaP}X<Sxn02xtpD~npkuJfvyFc5`<o0_jo2`J?DCg
zJkQ6gCLCHsk9gU@rJ3tQz1i1sZ2Em=Y*1UtNyiQ?3$d(Ty?WlpdP4=khv4D;i9Uwp
z?e6g5=}EqoN9B6$^_t?MA{0V%?~E<<d0Hc%OT9xIucm}F)|nT))A#3zdd+$c7auB~
zFN#xj$+M&fsFZt+UuIwS@@UXh(`>2pkEBfZh=?-F$A_M;HIgI0(mN;;h}Va-CK@@T
z(txJt(QkV2QReTJqksCj^)yRq*%g8E)eYCHe5Te9`k_9fD+xgme>6XcHeX7_MI<MO
z+n+vtA_V4K>S17F)-6H@1)JsWW0l-hydrP!?E8+Nz&0jm|2i-AjqkD6$&9{GrEvB5
z>0X2gf&22&P(wse5i|hWxBfn2Nvi)b<l|H4&v(VTJvA>i!2Qv}WGQe{zJzN~M%29x
zdcYVh!DP@A(j+R{IAqJ-p7$NzTg;tnv&d{xZN<|2DVlD5C=kh<hcsvUj&0+lGv@S1
z-{OurQl3Zd?CaATn%nv9zOgiHWM3NQ_Bkr@sN}>xd&J|kzk)&FPi1@)`Zy`<hTCP`
z1bkDQYt^Ws2RoQ=e7D*se~o~MY%feb(m|SF+jWT(oRoWtRm!Yi#Z6@)DD&Mj9_N`Z
zqi<QA(n{J7<jHH!yxO&E*PQKzE1XvIPqZHf4kBz0%*x72>;9&@)0=E`{rn_TjV9uv
zlM)=AuY8v#&g=bNZ2Q5s0$B9ypIe){wsCq}|EKht(5(;~&SqVNzcc;PoQ+9INqroP
zW>Yb$@yF5irEU8&Pe!In<w8}8alk%TUuG%+!$`r$h`Jqv(moV-{^fsg$ij#11Rp_#
z1<7DNWHX$QWVr{6AOB>x-?7oQ28<S$lo-sOeL_{Fh{<`qaP*06#G|{Ce?KcP&ks0}
zL;g*HRQT|sfs;@1p;R({$fCz%w$y7&1WP8kTipz*4~&q%l)M6G;!@+u-&_DTsZ`rS
z`O!({HZbCmTbY?TQN6{mHP=Lb+`Csr_*8J3JCUv9p22f<vF!8|gA~3GH!`Itci0Yu
zc!R~1&aCcFvnQA;*5&y-gz}_lK-X+ddAqdr`DHO$;G-e*6CN4j5*j;zvk?isWO`}#
zdPDlHF)5`#aB_4!Pu&~pZT0VXg~&U?b>bH4*1mm=w{!S32hIf1$Q!2oS(2l(vlXX8
z;N48G-(PPJ>jQ!ZXgm)!O3B)=prD{YMsSFaRtALtokNdVC!gO3EZ2Otx%f~&c;MDU
zR~dr<S6+R!+CX>wcrl~v4r!{QlKFXb!%lL7u+31JOow8TNh<-lL)}vmZ=^ZW-Q0OR
zR7~iCdGyUXd`TcK3-7bDxfZ-d+xK)4?YCRjBn#u^=bH_um`!DUtgX^pYMRJ!OT9?t
zC)Rd4hI)D@=(EU0i{z{cdBseUR!L&$fKYhx;sq4(g}qr@vbsH+8<>NT21w8YUZCiA
zo-!q|R{lnWjAMhHBzM8xO(V0aYZQXvta02pqiL$yMFpW-K<=6wB_7ri!d%9HVlEpm
zopEsZlVP&}TE1AQdN)&^957^M!BHv&OOQN#PJ(9HvQFI<nZ<IzW-N(Jne%K*E-0UQ
zkdF6%2#2vWa#@t2dI1a)IOd?o0~_r@Hs{S7TY66HOm(4e)z;C)#SfI&*lP(w-u17q
zYxhNVH!Spo%DHgu$IqWxg@v>HgQ+b-Ekhc6G*Rej|Eban?35<78tkY?N%9ypCzBCq
z{K>lNIF&=nSF{_2tS9@KnNQ!{d8P6p26T+r#iy(af1bg)7aTFLGC<>=7_5hHvvx?-
zGV}EJ9zx9@lE{nNVLXD2jk=ZWLv;z(cqg{`byhcy4F2;+D(c=JbsK&nr0Z?)5YoZ@
z{G#<*m7MsmlpW>Yh#D0wgG@U?Z^W}V5*E%&>ZmyJ&bM2P7Ki`_V=?ZJ;h>$(YVP~?
zwTJz!v{1p6O{<Xj$B%<<CCAMTTsoZ>@ZA>^f3=GKN&1Iqrb?<$?Q{YpL3ljTQT|y;
z3lfG}NVVIbL7tX$NF0n=*e5<UHMO*`i~M^Vt$&aiPwoDUR{ej*fBYXORQ?-Z@Rj)i
zwF5}{5K63Gd`8C15hF&(a8#HP-w^XAJK_q0VrK7+h=@?GR(XmFyh$$sMVJ@G#{e*+
zS4wIx1H1~>p_2fgM|xRo&R;=|^qJ`$%Yu}cdMY&()t&UIi!Gze6fe8}g;`nN{Q7%b
z&xX`he%`x@DMpkfvCAl_2$w$OIBIY=FvdCH?MHnj#X2=XE;7R*3c1}Ud(@~=(!vC^
zHlL=a_ponDC`X&n^LX(O*a$s0-@cBJ{ig-qKvGYB{5C6V5v4zd$s`*4t@N`^G@1}j
zCsXrG2X>1u3P;&!V2s|laW$sUXmsALrMAsOytit8DY<<nL9a<Kl*FbL6<o0)*aE-%
z&sX)<>Oo&*EMuPv3qc^|WIO?2PB>O#FuisErNiqD`*BIsagKP=CO*srv>-o1NLtkg
zY)`_j=9DQ@ki_$DZfh8S|9<5BXU$YpPM~5u9lFKUb=ezPN#D@SG}>)#n)cW7m?$-c
zq}ArTe!J`$0qrX02g;!S_a()XWg*TEUAb~aa16r8x%U?h{Y0%ezH7|s=NUa5MpLoS
z9nevT6PTdnykWdM*DYJryL1`bW%AL7*g{KaL`-`?yE>Hic+<eSuCYlQFxL>nWk4?a
z@BTA9A9WhLh7KKSWRNY-jldQ9rm@pc?{7zkt~RCkN1q`zyB$A%oE{_ne3!>c3cY6^
z$d}oP$FHm|VEB*dQxSpsJbh`<7k-{<DBNZZ1kZQ)6d_`r2#F*$Xpacrk22Wj!<rf;
zMMYihUp@sWMYNlJx0%$>Xv3lE*~=lI?0$S*CR=)5@3hi~k<ab@gFSl@973jqR7n&j
z8r?O*BH&u_c0NG%-X}KNc^F-mJ`J9=zqIgW017o_z^J;qjismgoR{+iQpobK0``$0
z@cb1RwE8Z4t@D#|;0cvbhw(U%b`2$IPs=OJ&OR3%Jsg78cl?3Qxfu~xD76<{@vsFJ
z313sc<Cv$r1?sTKT|>H4xw8qM@YGWvXqKlqJr7&<o%rlaf=}CBR#s*mf3VwC5P<q;
z=ket{JFQ>XfchW(1X`!U?z8&49oee*ekH|;T1SVtJSm{`KGu2zNOLN%#E4{Y?A?l-
zhwbI$0Hd$8oK7*vY&jG0=*E6MbM1|fxF!pphlkpU6$Y5Qz}<)nO5pLcW}@jc{KVt&
zaw!|PXtx^TtS>-Q@*A5WLK+AkYb6f0a8Gm#tyttefdgwr+8sJ%*XyByY37G%QO9FK
zIQ^iu$*^!5_Ivj5;T9FYz02xO^(eVZ9Z%A?sT`@^OR!!+#<PN_RQ~xxe>0ZFyV`>@
zJECe8f+>XSx3RJD$ie|JMy5{9%+%eV^!PD0{XXy;AtM7`!m7~^Yo6O~>ea8-AE|>5
zLI+=|MerytGszPN3_gOn{aP|277*;^oZF2xN}Mwh`Hq@HQ-%-WfqmI{*Et-Pv-|n2
z23gikB~+y>-uXGYa=ozRdQ#N2arw|oAamXITJK-qyZo{+(8W7{{zS;+{OR4b64wkn
zpG&8SZYq|2GwI09Xs`}DlpoBY>}WCdJ=?t&?<a#Uk4X*LCyKgy{C>(K;oP#av)!*A
zJ)yymi?!Y6c)hkmHT+Vn5)$V1_CXq?iisrZ3aTaVF<T<0w22Q*_Lv%6WFAqE8BgH&
zIs+X!z^l;!lGpw&n}vP!X|+{<STzKine9^pOoDDX*n*mWfd$2bL}4{>_4i;Q3-I`S
z+$DQTCe2V8Ug~~)A{5B)pD%ykUD(H$kRf}1pk2-hY(R&u4q*p(>BBIbXNThfc6)}D
z9!A^j+?oZzV|5(~Q>HbDWz`hp9IKO;<QUJf!=iC%*FHIte3YtHsyy}22;RJ6xZ7VZ
zz@h{Bg$Pxazs@`Rkar@f9UOGWQNX9*Z*<+XsVl5Gb|PEXkbfR<3XTs$Bfig%XOAQo
z7{#G8F2qe8n#hED2dxKkP7|sns!F?-ESIIWr|v}yC(6b<1uN+8LNPK3Fds6$>DtC6
zB_;M@{&<+Bos6kfoo24e_~AXG-vW%hC$a2J*#E0&%dmxby+Ren)MH{&q4F`fQ{t{!
zI~*HIesMk<p^bA+`<Y=&PbSZDA&zJD^t>++9Gq>t@>*D!F~NHKwr!7~kuVYW5YwiV
z2pN|j2zM_eOJaGX`ux7*c%0Td5IIV4NsqtUf6!{EZD(4}XSSJAr_JD}@VA<phV*ZB
zKaRzOv=e>kwrqj4)w9<Y(zX&<`zX77G65o_cCn1IABYa-`X@B*DGM=vPyL&|`q$5P
z1t+((5g(UrROdF7w(N_^{q7QRAL978tsJ>O=Dgno7xf%(rJl29%@WssI`cvW8M6(a
z&E``i9x4E%4@4yQSs&VfeydB*-0wYpTy9METylNUAcxForE@V_MgjF|)(q_4WhOj%
zg9Z(fsma6<F0MN1iE(mvE|y)mUBr2sbDRl1cC^k-D^KSbxkxY0?>rXR+{Q(1TNd$X
zq2v+iAAc6efWnAX?5sC^938?x>eD%86BK=Bhi*UJ;xuj>$hdr0cUE1!Hc`j3B$jVU
zTSkQ|O#^=yL~;eWnRjJ#ykWzJ39D^+X#}<f{W5FTt9M0rIxZ@d&>2?=gT(L$@BQv~
z?ATF=WxvHnQUtfV{MP+3Wntcwwcn?QpZl1dl{Hh_@k!V+i!C0Dh=!qMA8dN;RuBIL
z{gO<4AP7ku!X6kgWH?7e<|yXD8QMQRP7{Q_|Db}fQ8LCz)|uFVlC(xVcs4P<4JfrA
z3oVT5(|@NA@>~A=V)wK24qfwm(+xlk-6s9;`!yFAv;`B1G~3CO)8M{3aKxfFH*^<l
zASZxa;=KdU`28c0^-vDOXZ2xdA%3G9315HS3UHrMsd=kbX6-G1t*I>S1nKd|s8VNU
zUJ#;~R4)1e39f6;o|kTvWlkuyUE#2r;gFw^Rpi14%@Tt`#2`s0zet_M7kRQrP^yik
zyHYM?kdmFy6`C>sCtI#=%j}5Pl-@>zy<{R+Mzgs@<Ir}dHH~I9(tBiay!anU{oY{d
z&6D2IXW4IV?@{McjLV*}5EmX3J2&4ohGd++#!`c`!DE4kw$gP0R7CV^1>v4%JE6?Q
zyUr>znUt6p_4{W)MxgGq74M&^0~=4H7^GLdXO>}H%Eqr-cIw#B)#;j(^z`&x&0orh
zR($Dvpn-Tk<e`vLM#E`@M7Fnvg~nH__ELi)V>ppvV&?;oEjOSW=;L#>7yd7BzisC=
z!_N9nKet<G<fb+&Ebr+*ar7mAi08m|*pV@#N2f*3c^n%%ikfYu&rdQs_&hYN7z8E?
z77X6XG;9CRjGfy6t22Eq-<ja{YIXK4hKrfdnhsC<Y2dh!_?uz(opLSB+XRzlMz)Xv
zS&tdBd9Li(%x$<GV2Pe?Si{PtQnFgQcka+(B+ThSyN_;JEK#WB_@LTHsr{eMxx2uG
zKq#{+o@Fy6YatY%!y<Yr57mko3MZrO89=s_ye7S<GEWWX$GPqq-#%sMYv%*Z-Lg?W
zB%IP$F}vSJzne%pR#&E8hns~C%op%tyEZW~F%{TEmdY=>P1K;En6_%w4}+91Nk8ww
zY=5}bM&?`Md7Jql2$IF&_)Dkk)<~OATN42#`x&<XyNzvoC}W}6j1qL3dB@|ME;uCS
zTaKj>hbF6_!2j*rdBO;=s18a&k4}$e_r#YrIZdP#e;4>5mDENzW0Q!><o&=}7t6d`
z<{!ER?L=@1oz-*5;K7YrwX!KQ_>4>^%(-*v2UN+)@3A1-8P7LuBVEP8tIHhNhE@ng
z4jbQql+z+rGOYrRW4RE*xXlpf^8hVzrNqpB`0>r{5Pp8fRe(EWPmy4|?OcIkeRqE+
z)64U=QM#v~0)UFu`}Q?J8VYG?@qBqgcLyckUKY2y%KLwJ7Zz*!*xjwB@)!Rg1&Pz5
zaLVA$0W01;wY^s8D=`Hw3)LrN*Y62o-%qV;Al`e~k+t>df3g-oC1<NK5-bZPphy1S
z5-fh^_7Tmw3`nm`AFCAgnt0Ud$FjNdWz78fXIYySY1XtH`%BW7JZr0U5A%!<p>p6E
znHZ5GD{O5f8Xvum{XfhpMG1bEzZ#>v6_sMTc9_-ku)x^McQ1c$2TzaBt!}n*wT;lY
zotG>rtQ9E@w#=&tvx#If%Y6ZPR{OoY7GJTC^OoRA;rFaH?fuCzM~Yz>=jl5mnL1b;
z+)f|GS*6O=au9bz2eqL;3Sz^2s+Y9=a?Iu3Jgu~lYSv-KrXMd-{-D|&fdgyr;pK|6
z5=s~!Dt*e{XFryf8dCfUsU7h~q8Oac8O~5h^8Go?9rh7VIYG-WIA#{IH00wbfm1D*
zvki^!&qFwP_1kau$pwmx_*WNoWw+r`?Lt-N9$$}^N#_0)78O@Td`Ie<NqeQw!@NO&
zu9l0#V&1Rm3{RIVG_N#>t@0xZbdXn|PD%0BZF+9lk?@EJKQg0quuA80|D&`hmC2ZO
zB3DTA+H8tJ@vn-(_Fg}eL$@<yHnzUC7^eNI@BLqB3yaI=gX0M`$$eodmK-?tzxi=b
zjB}^Fs_Nt6#89%)SG$8at5&b>N8JP7i}+wK5<S3%vk$f84Ogol|4dzdB(;U?dD5oT
zo0tyFQt8>TLh=et6r~!P)^?El-o5R>78!PrCwZ5qrkKy_K!X*+xe$8zLGT69nRyo1
zZ?P?>qXi_A+}FYv)wA29g$JXeq8Qkb5c$QL=9S4u`=5k>CCQ<5%lmUbcHjK*+wAN-
zyy(-}t<N(u8l%{;x6Dgjs~IINzNJG`N1MKCj@7a?oBr_Ko(Gx5msQ7(Gt2)2CTaIS
zY%-e$&0K1G-YCF}{5Pk}EPZp7o70f;9~*9a(@O|2zScGTZ*<-KlO%d&o>H~oMWm;B
zb;{joMAPQedF#n1dKox{rEVSrtEYb@zJ^1uv;5aiAGNj#+7+Kn@jrF*{LAZ3meDI_
zzlpwfUyJ6LXdIew_a*fRDtoP(HBUnIMBBT{iVW|*lz%U;8cIqo9{dp$6eKQ+24bE`
zZC!373RxF7cOL=_+A9j9{z<2Z@bJ60Z=Xw=AHti_?@}s1dmh=++O_%vRUZy67Mr?g
zCaImusm^39Hz7$I%*2TlU9!ELQ4HAxkB*Y#{Uh9K!vY|+h`a1df4{QhsN|%)JnSQ@
zc!Nuo%Gn#!Q@tyjrA{yUfK2;@$c<+tFfaGlaZ-W!DM0sMd*gknRBq!*ZqO;{rkeT^
z9%EkpieKL#oT$QVtk|Yb96J9#K^q63bbz)Vuv`a&QcO$?eux8<lRY-Z%+|%vEDk}^
z(`3vI_&^Mf4_*EC)vGz~vzQYoLaspb_U+qKsT|ndW{B^@hk7Cd>_0=<+l}rc4wJ+~
z>e9^MH9XhHP)a8#iDX(vV&W9Ke3Gdx&AZv!dtYO(qu0GB4$w>O&QXva5agco<mS5X
zKULTwTT{vNR?s>0c)4#lnDlB@JRY69wJWQs7y1RRC56+PisJ;fz4+tDsR+w5a~gu=
zJQ;4kv<>}-9*fE|yrO=VdJ4rOUKY5%#~xY>-WC>$Y9b#`+Dq}LP6DODV&oF;QW2f{
zBHwKJ4y*rOoI)v9A$~7qG9zHu3Yx2Ti(QSM7#hV(PXQgl(u0D>_ijRhE{zxrP)k18
zZMuw>+7ddL$rv(x7(;^)mx;rEn@MX$_w%sJzqVBD)~VCoZ98}FoGT-nkb&ri6+1s#
z^qzFm0yc^c;|1USD!meQmz)nz!h7&QQkO}C65oM(kMW}9?ENi+`)O$v!zzpzfha}1
zHY5rkLXJo)z}ORz+i1JvWT@<@Hmtw20To1kF;Bq<n-rI3A^2C^8GL`Fn9DDPUY+&=
z#!{>ltG+E~^v?~$LqSd3tinpxV(6+c{F^6${W)YVY3G*5BRx<Ei>pka!>cS2uiyDj
zR=Jn&a|ndqD_?@cs^h_v^6<$|oyJRtmNX-YEXNz(uevej1oR2$bTT#mUL?BK#gdOm
zrW$SAwjIA8YEc$|ATEVuXqpwT#w$(7j5(?epI)q`-S-;oPsHvnrT~Oi!-X?ucIyGA
zqL6b~uQgugIm8C;e<LfvQRz5d_P3M}aC)r=JMQfPAs-cc4-4Wt(^F@!+Y0T5<l?RA
zel3}b2D^sbBQoG9BHwY~#%bt3UuX-5Y~-1Dm(CQE%uxO9o({VQVIlL$Q=@)m>1{?C
zrLZbNT<<ny$V?zX)9T3u1#FXmhqBbW`n@Q(@*+}+{wy6)VBi7wuK-OQT<(mY#`Eqp
z(<})o=R^I9KxLJCFNm0d(`a1h1Me@thk$6*sFCW*mABj5++BVfW@F0=!a?2JSY{fx
zYV|=y=W3q-T}zrLAy!4S$I;#xvj!9}DGK_>$dQ#=g2x3-_7UcU5Finyu-LD~okTxM
z-7VMd&kthtz8|cTLlpd7?kAPU?6m+V8MDyUT{3eE{DJ5Po&Dc_Eqoc)%_rH!*ge57
z`0BNP>lK*SvcfB%9(>XNVAEEuE^z(baG3gJ%3TTG;Q5)-AtvqiIDqzUX{%W07hRs&
zLUisv(^h|zm{KK?%F356KnBa0YtIzRm4}B(Zqg0pv>8W=Yt*YpOMNzn_03XEZS5zo
zo?@!vqn=|@U0T)4P`e2izPJUKOo-pHb?ZashsbD3(VY?XM8<b2Qc{FXDEFRPZ98(+
z<`c5qK2@Q-+$W`Slfd{S5vzC4(D)az+B!U*z<!Q$xP-p<r>$AvRP67ql3bje?#>Oo
zGdJ*Q>sb_|@ZuA?zd`SWJ4tRFlHyi8LH(a9dy{%Y6$+zmmU7!3pY~o*e0<pi+%S6V
zI~ja~=i~(25mm_uht(qxg&%16y^M_g&m8RhVKpNUPI)TBx`LO!8aaL%G=*L12b259
zht0xAv(nf!jox_y;+zn{jUZqqL=U1*Y790jqI_M;ANfnxPKUS>E_=Cb9E?hG&Eewf
z-{!Nur8AwuD*DvEv<%+cSWgjcQ0{2e(>2R4j=x-d{k4)$L<EfMxwN42CL|e$ZJP~W
zuZo~ie$)ll%1l-n^@y=k_5Ev&i}d}yhc)lI(t}5IWZ2s4pr^Ay+J(pp98+ojwMQ+q
z7Pa^NZOSj$WodB|<II^IF1y4~LoqyErlEzh=2$m^ty0uPk9H8MNTxFo-W|&yd^Ky!
z2QPcX!IFr=?92_9$!d*<R9oIR3L+&JS5ddr`6Wg-$N|;swt6U54TEoZwQ}FyJpi%E
zu+hCR_r_LNImG|8p7;2a@8%A*bDDf9P_$>yqRWf89kWr}wmnecNl5AWV-1_zc3<K|
zLKpiSDi6o;9Alh?nTo5d=y}#xQSJ+_h_Je%RG@)ao~^B{tfBSLz?}KsS(B}`Jz*LB
zE?ms&j&-72hYlOIv_b<KUV$AhnO<}YwF%nZlt`!0Z~mfO@76WGXxLnNbFIYG**(k8
zc53$u>{E%HK|n&}@ICkg$Pr-mvKJBZ$o7hK_K<ibg&xG1+y1D#^VCw!EqU4078R*|
zI7RlzQKR0I02NIGvw=hM^`9BN9p~^v(S36vW9&p1?qu=qf9E%WgluWS8%=h2Pb=={
zG0`gRvNuCta%_NOGs|t$dbLGakZFqWo9dl@6G+6RR1Wd%|D@{KfyR<b;2345@4^=l
zc7PI}U=v&3Udpy|KxS3bFU9l~*@c@?_orBSZxmp<?H>^FVsN{rg5Q=#&Xtcay!)IG
zQ(BJAx~=s;mnqFMq62>Y`n6W#Ad-W+k$*Cv;a=sMeEM=*{P6BmJ(T?Ox;d7T31z1b
zr1W#mrXTZyY<*gljE;__puk7tOUtgc{}OA{jDW1`RTTPvu&<8g{ekM=HeUYr_3L?d
zBS|;n^<Z&oOY@5u%>2VkQ-iP0N?2V}aem;3@=hMzOW7tRwTYmVMw7<!?(0;nnQroD
zOHVAi)Nr1FmCm$J;8+vv&20FKgo^GnL2N>Y#@)Ux>H%9*`e@L1KNO37L(UW35q%dv
z98RhJ1mZyoeMk`9{kz)^^CxM`#g~w;NgS!{;5E#w5Z{=PU63gPS#UlHd`!r=MHijW
z1M+AQc3$Zvf?x%O;wKc63!TH4_n7WKY|W1_)T8#}g~Pi3Jy-o%IK}wWUtZw2CD*@=
zxxJ^Y5z$P9OX)NH_3M{r$rPtgYWr~T{z1@?gCvaU*hhf4U0|;c`W0Aqn-ZC@B0%kO
zkA%m+Kmf&U+bhDxG{0c*L+ceEb7qU#Y!b72YR<~RE?*YIvR;4w{tBZcpk8vMwLNJl
zxJJxuaNyTZ<<)C5_&kif39j(sFJIiLR-nBs1C2l9N6ra-w)lXmjD-_FGEY!SQ5Ypr
zUO~huBpuScP3l-dHbB#gi*Uw`+lvZHw3EqI)<i!U)G6#NaZ?SRZoeJYr$zMjiHHtE
z)am`}F~5a|qdfu$FPsJpjPzg2EL5CUnx_Llw4N%Zw9JX4Oh{p=^K-w^s+uD}8l*i>
z+Y_m80DfY*1SRyuL-FuRPbxWqIMVsR-9szU3sk$&U<s}Xs=AB9+U@93!FXcQzWVK*
zXF|#_|F@mSW0QI!hGtG5u`+=GjTB|TRyTKiRh4qEcb@r+1;3Y<Xck8L-np(Zr3|NN
z{Ms5yCo0LT>G(Gj{v}MJPDovW+e_M@C|fk&ziwkIEZ?|sTUEPt?mPya>L6|^s1$G5
zYTmy<0WmxN0>z0pu<o}2uCjpv6ztuVw~Hkq7ZFNKJjqb(Gag<<T4}qgXg$`u+`U`)
z5+jea6N?>Nl^>Vsc;e3&v<+m=^!;8Wmm}dsmhLG!1IE%;DoTw^?kB_h;w+J-D<*nb
z5210~8Q)R~DKR~38EY&bh$SVX1yx-shevoXxf17skjVEps9jv^uNr{W$WPuE=%0dM
zaYEGFxY~#vv6guSY75HOF6X+2-%qShO?yyS{sHcd)eXA>+(q;3zO=IdcW|!sJ*h5&
ze-$?|3arrj<M%@!La^F1=&f8Icon+^;7-#72L%^&$MMDVi;3YL;Lbe<FSKXeU)V=n
z<@#ji*2P61KR)8uZDS7aUj^8cZ9u7-?^|{W`CTr|(#PpKzUh~-EqSJ(mqx8y&-5QG
zF_U=B3ZyJHOs>=K`3VAvI<p?RTxgQV&lR1VP^`OZXx!6Ws=xo&=9Y`k7cF>T5~-eR
zp7Oc0vck7+xeLc?Tl^~ZcPVcp5I}&zC5114Uw)4zSCu2eeb<j)Jx9xualKP%Q4sMl
zBb;!UF=xCb_6@de>qD#Q?~&OQ5W6e7##)7_v8!d?8yYdq-(APUN=f<Yf3+S{l^0&Q
z;;AZH(|#M>2?>`mIYYH}h53f~3w73=1_`D*(`+E{JUXE?(d}&t($s4345O0|Nxddx
z5_mzs;Ow-2{V0F9g|iO^528tc9QUF0sM;j_8I>wmhHdV@se8@&2b;{hYS%Wn0nwB-
zTwcR){N?TqBa`9D#0M!}Qf#=G+uZ2!Q0<1>YUKBa*u+|?zdx`)bBfdV%Xo_cjVq6I
z9yBQ8-mmce<vv6z5GzPVv9hunGDuFGpM;GWuESP5$elU$3s(%a#jRQ1ww2tVuYIBx
zcCTk^4BT6XU5yx2XU)M@J-S~qO#jf9Z=Z95vm4NA26Qve;0&XK7eWO)XnBd4$t?;g
zTU~7Wv=E_`NS3hZh_1WVz`Wz?cWDzG$4mx2QmNEr(iTG5CiAm9Pd<7cU~I5(#<7%$
zQw0W-mJCyz$o*5d!1Z`{e|GIirionBgEmNyr`y0hKOHu?*h1g}2HZ<RuRPOzlG7$`
zg@Uz_zOamU-}c+l*0klbG~y5rWSmBNYXk(Ds%;x}(O0kc4FBMvOX$k1OGt-N$8<f@
zV1UsPBLbe#=yZXOgjkf*j0C0zrTXEreLz?L=YH`y2?-%>6-#Yjy9!AbqBCh`Xc~ir
z#wQVT9MkMDExFr$tXkO}uqD=S(eG*HSnej69Y)d`lGWk1R`1@ew3FR67x!NhXgn{_
z_``0AT)YeKLxIpmjC}FFQFe9S#vkQ%BEp_qd08_#V5Q+pzx#f{t8hAj9&Hm^_AvUg
z{dN4G@T#Op?fi!g>r0>S?_WOwMc$+zah|j6?g0S-XqTTE|7p!WkVr1$x#%G`k|Equ
zJ#&$bTph;nz-=VAzVq)jL!vn3cTe~Oad?+s|0KgWg*=hSMF70I^wox$-{F#ELP3&n
z>lAQzXZKvl`pecsF{Lf5Rs2^Hls`d6Z1IiLQ$gv6NMcO>)PU7R=pVO#bKTay7|rvL
zgQt>%IHdN#2lYOEWac6rVJTuk${vyg-f5>8uQNiQcRlc0*O;``%Q^+1GD5hTixmPm
zYyav-RiK6-dpa|^1{E}pb8|7+x7x&u@Zvw|Pt^z;IKgwZL*EetR<2wrQ-+uXA%7XH
zW;LiOR_<p;)XlnpvXqufuALP1{rH;iKB{-gb@Wc0X+wkUa`*T2wxVf`6-{2+e(|=&
z&+aLM&P4T!9cm<2FASmbG%%cuNQxWcFB3FI?`T3~@rf@ujU!kHF&U%{zznYXot0qr
zOFt=yb~Nqr1n?pd<(WN&ymZ!pE({Bno86U;J#kMEZWj%DN52BW-5S4;<&(%$VaqF!
z&l*K^$lci&?|m!te##~cU-KTk9_FS0xtU;7@xO;ZUc&XyGVR01^OaE*w0iNU3Fz@%
zCC;hhx8r&1-Fo)aqie$ZtS)n31W5GupzXuto#((FU9`0gAtQl3LH7qQ?+i>PO_Ej&
zu^MO0|J--dh!N|VKIC@bfSAkhXq*S#x*aj%+a%o6z{GFgzxxsiLi^1$4B39oD0Oa`
zQl>M5yiTg^QST)^mGG%P3EDkGHDI{9&pkUND$8nD<7EZ1Cg&9v((m`%`t=$YN5>pV
zCrQ^pv}U=9@%sC|<eJ(LS6=@Qapl76I7y}kn=5K0Fu!HbW@>{U8Z>u0<uJfL_u#L>
z-@gLx*-80<Orf(yN#Wb5B9cc_uQ8X0fb6z^?c&7+2Kj?Fr{Aa6XEeqXkM~e+6BqE)
zttx&x^H$3x$-jeEX3v>qUh`RWp{nX|<x2JUUaDD8Hf`CJ5Qht3Ip3}!(_0UkoR?~q
zaVu%y<g(BZ&A8XspR69?eO|Ahj@g)5UtA}(9$i&`c$1o*?W&EuKJ3~Z>myYvH5k48
zxBre|tGo_;I=Z4px5xnroGJRPtqy(14Ljb&t$y<kusimqYW3?sO1N3HbL-ZvcPim(
zsR5&?t<zzjNv@G!ik@FetA$kBzAKw~VF0LaQlpv~nvPCNm$xb^@(uZFeyjYqc>!Lc
zhUPO>e!+QCP1hfTy7I64!g~$wSpJ>ystxK^lJ9tYOmvf1DgPSNv;3d=i4GllZ+OLY
zg^I6z^_3ILUsC?p&dl{n^3zS)b?jIfc4^}T@7}sU8*HnBeznEVPrbS)Ka|^e^Mdjp
z%B1KhDk*V2cI=o*ZVwHOn=qNp<^4~MjQ#UL&+Dt*nb(`f(-9X9S=kQzYV`KFXA_hz
zf6Tm7fzudXXkPn1Ehb&8zCdxp(C_4<h5e)Xo_>#I@8m7+bA7n5&-~iq<;ya4b(}}V
zUmkh-(TQu<o@>l1={8t*!i14nL)&1n&a+o{o3LrqrgqruPrcm1M!l1e5Q~8RZR2<y
z9s4#5{w(f_YG(Xm#G0Q2F>EnY*a8dw6RQjYT#dSQZvn<R`U8!hmlfiXe;To}2XSMn
zp<y+}Qad{xx~WuDRMug$u)6)8K&ykeUjzhdexZ=A%V>zKp7>Uj+YC0&w!hV9QBoBs
z#veV~bvR`;$Fbtms?Fc#;kVfL$i&X0c(F{xhN(X_yLF49K3PW2WO#%MoattF_oldF
zmwqXjd33N-191K={-*E<+*t7%mTn=m?4yD7+AJ%4F$5>QRe-^@2QOZjx4bzd@$TJi
zOGdJtwEsM*4K7}h&KwqF)R(vtY!=`8+vhftfyO_m=J(#6H}DHD6lnK;8ojB>@t@%T
zE%&{dsH5{Prs6@4OfIqXM2p|Ld-pA>y_3^?GGD*mKmm6eDq5vRmGtGf;dJ!%8}S$v
z+jKUte)O3ssqBawSOP40#b?WT8racn=FDZtP|vU0*RJJSsbS}d3WaLt&K-L9Zb0HK
zDlWc3Zkrt}=9C+dUd++iaP8XQ{{8!(pwlde3i<BpdpuAy<VUQ7j4*SFJaIw+nG?3M
zu#MNy)wRZs9m}^{pjYaE6ent~U~Ra@=>+pF80GNT$ssP1%5wNgy`1M53P$pVF%M5Q
zHLV4t=9x8H9)2y|;`@Sri=RisM#G4&2mZyTr<(@sjEo#26kq<d$sIbJy1J?S1nqM@
z-@j+HnSIn&j2#_%_Edoa+MAHYg5J4vCz_0L3Fu;1_@cE!)VCk#y<NL^cRhEm3t_r`
zix%6#1#@UWADHk10b?UX>|7E@|204Q!&PVI<kT=SGMad}rxN{=U%5fJU87o$Kt>Gz
zs>Q7cx1ljVr=QbT>xJKVVV@SqN^x5@25XJd(^J`W!#D9YUB9<!iTj9IX;Ewt<J%^B
z^p=EN^!f9qix<1og|_eb@jVpFEl!W!qwS-tV5MgBMvO7VnL8RTlaX8lUqQcU(7xh|
zkDDhEed|^=mgOtep-QV(I~k}I`?go#x6Hdzti$EdO!<M`uk4%Kf4hw2z}5SmCxK#K
z`&?uWcJN$!;#F$78eg^R#(!1LOdDzieYc*#qR3<~VVP^o^v*!^ls?u^lw0ho#?-`H
zjM3-`=}fo9h=5<{X|w52eR_TMpn1KULm@BAe$cu~)v70va*PA#RweN7EG}M-X}6j%
zCw`+k?3)eK*=(?5&ky<eN`pPSeSuIW1Xg0~+xn=ewY$DY@rYPH!o~@_9_e|2&J?xj
z4KY$<P^qTcpr#a}b>i74d_Lt>SSE;F4<Fe0*-YHEZO@+S3On#*dcI5X+nOl6)<x#v
z-$$w7%$BV@w`cBS67#@6L4E7ht2SDys#SOdU-4Z9$23>ea2<IK2$;T>OL%K@P!8ix
zqLito;7rx1Q6n11%F>UoM{^OvX_$n8C7Av#NZ08ebEf$;Vs$o~Uc80G6cUuOX=HnH
z<R&cC&!g7PI#<_Y;^uYh6vwRjIZBXQjE+>HDtuF<p{3Oj1T*ktGsUsBp3}~D#{IDk
zX-C8Sn(>0oCKPGCFzzy&reFW%Z)>3YOwBsnVtW1M;bCF=5v#F|H<Rg1v$&GB?@neV
z6@G``egyfurkP6psUa0f=CX=CL$&}-BipGoGt>Nb4Y7ew`Xj5y+D8%na1)zdbF43e
zm|mG6w|+jPf9uw*8@FzaSrXOzq~2E0rv-1rIg!x6b=R)ZBS%)Eq6;Zo0laD7w{OU;
zpGzK}t%Fga=aLtLm0J&N#QJX>r|RqAaiss+UxRPX?ZpaihCDu&wym-5px;2=+{gzH
z54SjtK5a2$CcOAp_yOe?5ldfHf)ZF<MB8CK{HGR?dBn&c?Ic)R{0Y{%h)5LC{Ra(V
zE9sj~_R+t=&d9uO%q!RFo~702O}8#xs%vU$4y<1PN4S4BsBkW(CT=lWudn7h^5nW*
zyXsV_q(p4`KGK4o$v*QeE$1+gM$!td>4(_WcD5SOfT`n$?pj)P;NehHxm9yVA?Uoz
zr&ry&b@kNT_@9ONFhbI^3A*TiEw15YwCOW=g@eQ9<Hy^s&Dpl~yx~8Vo&qw^cqclM
z{?8qLZjHIfMfrta*stt{{gj#=J!xPvb8~tzC3^eLovYDSF<eww4PTIZJ82;LxpLXE
z7#``qqepiFxnJR{kws<CZA5^agQvE$o6_u_$`@wmsOs(;w+XAqT*$F8vy1|7&oHpC
znuwUZ@8H2rL>oG$K2>M`n-3aUS4ncY<@x@$k6X>^(ZCBn{`93wD&&j{!AA*)(1s`V
z)k+Fvgiyla@)^l(hK!_@`$Z%^xJYZ{7czBaX+mvybO>JPcn42f3#xM_MlW63lLo|g
zZW97A`B}O79FAPj^`5S-u2%n2k_uU}7gFi$qP)@W194ERC@#S%1a)uO85q>%PkKD%
zulZ~h9#(~dm$(>ghIdGzAjGDI`%m*xY0{(`AC!#i`S~8D*2!zvTFIRd;a;AeI|!V)
zZdXD=Tqk&MnBbihe%<1BUGj5_RkwIdDnN6~8Oo6_?%%HiSvwM_eb;i`@7nd~MYW3`
zy5>hSjQ7cY76?O%b<k0UeyeXa%Ozz+K4M$&E?RR8w7!}n72PKH@7=pMx~)E0eMOkf
z0b<adk^1)rYZ+zqr4y}ZtNu$BqOlZ2Az*HyiTP;%WtC9-ZcsC=rxt8KcyKE|(Ux(l
zBdJNJ>glZmr((saOfA*z=&@syoX<u@4PzlMA!;gyLk>Xf?&3||08%V@Kc5n%e%rQt
z=%HAJNsQ>!->F!YyBe#9oB3xn`t3wZUS;4)u##IZIFQ@ivGtIk5Ec>fhHTy6E=L7m
za3bSM!ol9rL7nz<%p|(N@IR!rp9?Z)^GV5?&OxPIM!1_*eT_`awlDhhY2(O~!_Cdx
z;BdKw@nIrt)?2+K<Kx-)J-0yQR+3CebzcN~8=H_IF*MBOi)P)nLwAz%DQD{Z7}2T2
zsexPm<ZH)AS#Aa?GvCY_ck#j{W*}6lUi}S!ig&ZM)Qg?isucrgh?x}HF_fB{BtyeU
zD7^01^6ayyflPVw{4vo-e>+Pv7b=BW5zWDT)z%MR2VgkOkvWW`VDdL)xK{+S{*FcM
zpylgirkPvf5|tE1MQ#0jEqDXIq`j)Dj>~;gDwWh>`jOcl3%ZzU8edYtz~10>FJW*r
zChWCqr(n&Tf#N!nJ>gwlsSRIC!@JAez-ACkT29?;ED;CG-!XJ2%I<Bf;`Rks7Co*e
z#q*$UZsa0Om4){PtbMr-1^NVpbt@-w;pMI&KL_dAi-S#t8O(E&ZvE&x$J%-aQCl?W
z9{N+3E$ampAsCoho?+qP%{9K{JnDGn?AehW_Q@1{1FvKg59nj`^=Jm1Po6y4?T~?*
z+qg-ST=msPvwrra!(8gCxz(Z@8%REi$MUM6pl-{So>uNYbhqyww6Y+RjZ#!vsvY+J
z_i-lLa$!RAJ#B|=Hq+cf6b%WnzZhlIrv-j`$8~VstVs-iX!q{jKlT!?jfw}kb?g7B
zyto>foMP#jcwmCJOjLKvVhEkD^3{n#DIG|N&su&btJt*dux&b(+O|F3RCD@>u8mHS
z_EW4j8f*BMT3eB^q7xGGT<djcM|EZLw;bCw#v;_xvxif!$^^1Uy0MS7x%_FX#-=f+
z*AH)ZzQnm|C8by`meTjipLbDdoN5Ew$77#7d7@F$v}x0*hu19x3)wd=|G5seA2L8&
zj<}jzyhe$xYJ&r%YUSly#-BK@03g?L-B5W1zob9udHHAKPfF=m5w+yibpF>>-Qb?<
z_~D$s2Gge97{O=h&|B-lf29JPU7q;LUwmGbddl*fmldSEF#EhF`f6?_x$fgsu@^Tc
zW(;`BkLd^eeZyB4XKV-v=<(shhkMi3&Y9C*bJq2H<<&!O>pyXJxc4;XO`SY{zJ^uE
zRl~d{+jKbd^F33fF8ZvtEKydlLv3n6t0Da>D?&``>>3lRM4&$9yiKdTNR<WeHRDcP
z#mlN!e4xuJAVq4u`QLn}yfT?Ep%&EBz9UCW^X#+Vz3b4YPova;Sy#S(nLA>H61*<E
z?Lk{0yzk?``{l4!Ccl_QJiKI+)|*Tp8ykDtFz>;=dpEHT6+zgag4b{I<=3EPudDC|
ziNhx{Iwq#4w?K%y1qZ(I<ftt-s1X)iqsz&E`X0Tmo7lC~Z=k33$Vi5!<{C|6<Kn8q
zOx}jaZ@+Kc*Ez$f?r;1luJrFUAdc(z1+!6|L}z4VocfMLxB-uN8v)1@JI9i+cY*JQ
zt2THAzZB;9u>+Q(oy>fh9k(4Kj|20XaI<vj(%}d^iowq;dJG!W5}?i=h{pS{gMmaZ
z7k)#;>o|018<fFVUL_D`{?qjI;``%tbUOb9JYm^se%aJLG*qR${vL_@fg5V7!GFf_
zf7>0nYgfShgEt8HTX*j4^YuIa1PjW^fvIqhn_#5oGBdbYpM@%$MxK0Bj36i&8snBL
zlcHN=M0(>1AedM|WZWq)DyMi2jzO2$cldA(w+U4VFJHfZKZT>Fyr`ri@9*%T83rBJ
zOis+_!k2C51{$Bc4!ko9TdD*vF_xFD-?*_Wi6Ay5r7^T=O+_Y|iBfe8j~voHMC-6J
z9<&%rxn;k9t)}HP=EaLPJk!w>niC5w)~p!{7v@S(Jy~7>fW5YE-+qH4yy)}$=~903
z?VJ~pgD{HCUhYA=UPn#My7bcPb!{{-(LXHp;*5S_SFh$uNqGaHy|k><_Mn@a)Fh6e
z3JN*n{9ZqUaC>B8b}T9?ikA6IOViHib-gLu2T%Cpw}Bs?Tx^NsNWc>_=bk=$*0Q_x
zk|lehe&#Rv%9XCmN^%Y480mMf;A=E=;?^s@^DP^F^VY4oz%#<?#?z-eQWa6x1u|bz
z!{l-m-lJk2^D^!oAJ&%4xD@XbY)Bvo$c9=GW@72GWsjbCfc4-@=VG<|nz;7YM%-C^
z=!F}-c<OU#P@!ZaFyG?oUZNXsqmn6u5tu%3;?Y7r+E&I=wga}}k#wYJ_{adAynCy9
zzhi$<N4A#>HEkVf7VdlR=zxY&d=?c6CZ?TBiciKbS}^+nOu3GBXCA4F3@$G(K4n+E
zGFi21aQWneDz-K@lK*X9Tx*VyF`O+tsm=6J<auR9Gg?^P%69!6pt!ix^x_!6!i9?$
z=PX!YWa$)cR#(wgQ}f*x0H{IjKcRQ3k-P2udGp#)uUA^HAT2{JG+nnq_uGTx!vg9!
zgEXYFxRbS9!!)=C0Kj$3=@G`p%}^}2%ZZfHG=6L0ZDpTx-+_W-i+%8Uq)SuXLmKNj
z9@=*5KsHcxApHW71F1+vP*=vBG$@uEjhX>=Vo@$(_SOq6J?7`ED~nr0atG4C(TC~(
zE<f47QiQTUN6wzzjv`cCeRbj&zr4N+F}~Vw<W`jyEqsrq8KzO4ExVlaslAy!z*yhq
z`ywZ&0jzF)V5|4EZ74*C8=2jTi&I+n;=&+8sqa7QgtT`Q-B9gvZml+IWu{HL4$8Iu
z-MUGW&6h9tUM2Il8a5%d(b=$!d1PkSS2ZW6jzUwg&o%1Ws0KZZ)ieN0QcF{a5)}Rv
zqLYtqWuIAZJW{K-hcZ@yfvIPvbrTYSDG{$3INi5yBBP@+Y4d2fU1>Om0bhf&oeA3v
z!rChBI$fUQLad6^xsx8rml6V~GYlz285LDovDCrgNyJKsF?hxIW?Xg9iAu`OAHzYr
zcI}2|9~q~5W7w~c^>%V$e1N&z1Xp5(B5~vcI#T8kD-?R~lgtR?qyABqJEy+`&9zgh
z(UU7cCL};}feK#3a6F0lLSx2jYM`xq_N3NMME>{gr-h!;Mq69kxy-Gm>qw@~ifsAN
zWiy+E&FViZYBx*?$6v{@$?G%T-YH?f5y>Sis5EM{NiZTiN@bf)istl&O?#McGS=9P
zi$UAQx5h{Ugt8*c=@Z)h{Dl*D`J7MG`-Z;L5oSL-9Tp<w)xxS6pcu_DX2vYeAlr2h
zU6yqwcsGz1;j&-5(af@sgoN}xJNejlY`Mj;U;tm&zf_f<Rw5hY)rSveS!;~>C1Bd6
z%Spc*hjz%Bs^;eW#p`ADizB%WhtzIgx5N3_3r$|~6q%W|m9t5r7<p1};exU3vd^x!
z7Skwv=fMLqx1_|`78V;x0MUtw_4wCb;S(p_z8)N`zr--(6HM2n7Sk<YU#Rf*(O!S0
zUm7#nXx36F<f;gVZP~|Z)_Ns#kixaG?W|(v;nSc6^<d97WB0Zy#M5Q9pwjlZxuj+R
z*v{uxHK<?Tqk_YRf%9|m+7>tWfcCO0Y}yw324?*lU1)yfWTz%Oc0DP1d$(bvH4Cd_
zX4Z=Nua(d~j+yAo{hrzi-<qVG3#K8pP=F+(`kO~?hqMq>eOTMJ1r`y@Y0VYYVxwy{
z*2?ng0{cd%2xL?9)yGaw*YMNIyU5hmag!(C!n*JZQDjBoH<Jxyhk(+jGRUj{>hFDI
z@@GRYW|uXirg>LyNd5XLwc2kHWOk>w{?X7yy91imOvF>OK{9j4j;E8B!_8nE@7F&<
z1556VTaB1n;P^Rb--|Uf6iXp9Bdv}6&DO(3O6Sx+Yhkhlf8Z8|<V#eb<GiO)Tp0LG
zjQcQTR8SlhN1ffP$%RsHkwiDnI=kDaSK+l!brtRC^LP?FgUqX_7PSW$7V^*ClAv8(
znTu>79!7a*sm*U97nWpSo#1_gr_!#$wuvtieUaDjtc*nseoz8a+iH-*#DHt?9+bkH
z`!?pr<6TKf(>5jwYm9rz&t}KTRP{!+h^)3X=1*vz`TIufu)>a|Uq4#3!kr(mo0wQh
zA$I~^ENyOaK9Od!k+ADae}1>;DfvEmv4skPB3Ge+<2^Dg6J}A{EEHxRhLM?=9)1N!
z7=~4Ys#Zv5%J8{Rg_nYYMmakVB*9n3HfdMzym`klJEOr$fy}KC`VA=$6U0r<*FF!A
zZPaZsV1+Xa@cwUkdSwas|IMnWAZ=IY=mau`iNt*R%o&|?tE5EUyLTP_ve_g~sfc;r
zoCO%nlZJjJUXlq%T{L_n_K4u_Je@HV-j6Uwb!}7&mc1RMxA?YJU!T~m^5EM0kjfzF
z>aZi3`&Nh1UFjxPYrR5bx(~~$499)v{{1-SADq<dy4T%(3%m#po*G0;?-wz(;0=O?
zw-a2kRZ=S1Q8sk7x~*!UB=RZWzI~hdhsq(D*x1^Z<gPBtRFbUnb0wj~-z<Cs<zNh)
z3KsPrN?kg12>Pp6nA<s78rY|PZ8}X|opRZNx!GVp9qb*YUifz$61&fsF+*e4^;YEN
zXm|>40@7AUj>lTC6=+vcFJo`Y#Kj+r(M?*(YE-F2K2(wZh-Z~QU}hd;Wu+!h4ojjU
zu~ZHAwhc`MpGNBTi;Rq{-=@uOd~5lATefWZl^KB;v^%>idF9X1W>nHWuOTf7!O_^*
zW?NdiLUzPJ1aKM2jt4=bJJiSQaf#=~F3H3wSza#F{9ldUqFG;mKBBSz!pw*!pcjOY
zVM2Z!D=RH6ZN@%=ZK@4}_vJg<=!f(W-LfUt*48i@*0ZKBbEFR3H=stJcSoa^M1!3s
z{z_;p!q@7l&!Q^RRIbDTq~75_`1Frx`P%6DDzzGm1i!xU%N1WAxVd(ew^ku72*K4h
zHp)y}<UwV;m&%Gh6Spq*hMhZgg1o8<U>ggGqt+d9dIv@X4))itUvoaJE$zVI^nHg8
zF`RYP)3mgh`}ZgHQ0eVG(G~JrfCxkya!T*8_faRcx!B+YB^R~wQhR&XkdP3Q7d_}5
zxpVifl7gd1Id9<n6nr$*H7qR5-Anzi@^;=YLHqaucmSTMp@~21YEW(FStMoc@CzW#
zR;^oGul{j!uEX@(bX8S&0hYPt_w=4v6%rR~vVKIJl+}|aA&Kzzb`3j7jb~a>U5etj
zEA5c&^|x`#JQtlFb*7Z7nNrE!($IYaVfsI<rdtladr6zB`rjARxFu0eD#M-5_nD>9
z#534P)Wb)4n=5i(Rc=$RFOxF1>U0Q74nSu#^c(PyzpP*Q7Y-?h5tO(3?x|kwpMq<J
z_$A-}{{`3oOmJPl<c<}s7Q;z1)i*%;4*Xl3zf%s&o$lyB5GQ!ZwKT|27gDa`zYzh6
zt`{hLyGvWYWPn2DJ226i97S#8`Bb+3DY@5hzg{q1SS~Yt^ylKnAe%g?wgA?Peir2C
zIP8UznDd`<#jbmLYON}jz$!Pm#TTJ+3xtG7P5Z{(tXG+$zsX<5ckZFX;kjph@6PM}
zIX9&?Nw>-4Y<w}#BUaWUc`fuH7`_4wGsxnRc|v01ZMkHJUf<JHra2U9lv!j|K1`ht
z&%+x^tH9<3Y(9}8ITw!@m#j#v8_yAo0b<v0(4Z1Vl2!O<a?(T8U+yGf_5Sll{zaJ`
zQ2j;~;?Ou$JF4cM)=xAd%RnaRiO#7rf)`3fZjhZW^&6RsLFa9__dW)xBUq^=hu7dA
zaQ3=Q5H$vFJfLJ}eYM7t^)a2`$EsOr{qPwDRAzt5+jbPyCr6Rxdn*1G)klZ8G$AN&
zLX#5?72S2jNxj)OHq}(DyLl77Y0N1ESE$IZ7`k?b7LwKbyOe5hGYdJXI$x5!$lJZc
z_h5h)ju`jRE^@1NK+{HzB<E2##e!B}Q91JM)3{X^K0E<0&N^*@a1^l=19^E_4K+-z
zJmx~x$QvFxcdi7zS8v{I1V!h$PCvVIk?l9GQm?IOhV3z?3|*&lYNrEt<#OE0%fnk?
z{k_c?pbc;YpGK{RcK8R~(yG~P|EsfZGO1I*EpVMMh)qFwXqZ&v5Ua*qy;oP!f7REX
z;&KB?+<5%BA+$h^I(6b8bS{ZP$$*3z*|bgfBn9nk*{?1LZmg+k3m*Tg+}!QdUF|e9
zl*vN1QRe8u*^W>?hsvoLql(PS4o>Jq*M~BVzK^fNBAsGveT`bRHs~3bn3xfp4-Z<Y
zDYyFCIyQlHXWo<qa0aei3JDoKe|~4=l8;QQv0&teRL(5hy<>x#Lg^;gPE;$9KDI7{
zckJ2~hYY&c)3Y{@1=BlFuN7T?EfG?%5HC4A_-u&J+yV1RyK<+cx_vp|xolZ`@r!HQ
zpmMp+<X~H(vwo+)M@B@FuSM<Qxatz%;oMI#(Lmvqf7*fC5dNc*0{wFb<|-u?Kf%4n
zSU7Arf=igDq>vUBk}B?V?#n=n>YJ6D%X1k88^~T|;P?ncYr(;IYEN*iK$W-I+W1@N
zM-BwBVAa~jQ;&tWi4O8u&a5$Ypq5BEz=72BzZpKYfdUL42xBaKBE7h#=3?)@B4N-U
zGaM0^=bC;(qgSu`NM6x2ZSUf0k^Fn1@wb9QWehTa<|Zu#JCRgR(V4w4<7!{k2IF_-
zHG=ve#9(h-&qy&@iFxU3hxM;Q>d-lKk`+;|S#!kHsr9e_DAu)IT5WLcfzmeV=;WlN
zfb(#rAVIKbOwg)a^g$;ML00xR{jgF``n}A^XpPwodatsA%>Lm;WJ@4{lyVOY8`g3?
z+-K4LnEO90dpECCsZwx^$><?0;bvSTc6N5V%8q+@Fz=+^F+F8P`A42V!Q;r&@D*L4
zIEw<-{?z@amJ8qY3L{JBU5jj6_FvjgtlFnobo!)jV;0;_vt(_Y7=ql2sNh?q<h_1f
zN#WLJHVozG!GELpe^JnF8S{mqpi9PEVj7?*|6Hoh2g%_oS((A}h5f#f-dI%%^?v=D
zLP#a9IT?C+q?MJ`uCkY;aGlYk=P>Gp<J=W%QT2V}^z(c7UB*z5t#Nb35r6<ZFsPyW
zAqT?`Lkv?6ABm-lu_yPO=!_jpk=z8HcPwHt_R33)qqTV+Rv*lh;u~}-WAIy2(!>hd
z7}_z#V*!jdG=l%~0bbL5HU$M~UAXXht?NbObPw7cRtC&H`{)yG(0E)<tx$<Mp66^1
zpUrfk^&B;x6j6x-HN2flCSbcq9|r`EQHF+1N((Y}pvs_RSA$%PW6eKemG>|^+Zjp@
zlZok~r6$J43zH6CzvFV|wb#kQEnFypopK8sUP-~dlAGz^&4f|KrZWJqNrY9%8v-nM
zXjZSjrmIT*edGTT<F96W7;9)Rs_EtSUlVvQ$b_^1y1=WvWlCeU`SCxUZ0OIDquye5
z#wT3^^_J5uc&a;hTf1%_@|Y^Z??M0^q40bn+sX6}munUl7D~gjgQvqaO;}s~Rk?r7
zWb;+$^s`s4^piRRBS`MiO5YX`&$jN^v61!XqStVDhT?a(sKu5xi*Tqz$anU9#m$5{
zZc%pc8=%VdbogL=ERTp2N4B-LOzeSz1{Rjui;OvT_;5LJ-gRzG>^8lZOQPOk_d|!~
zFa3bQYC9{Ox=`Dro7(j*1e#u^!g^7zfvx-bOh%fK@+d3Iz^^;7TxZ&}1~A6rV%vAu
zakfHaYZ!(E?U&p~rif-&s&{9b4O2wJ(AoR@>8nv_k5FxJlAzIfNDyIMA{W$)oj>Bk
zYwAYlEL&S!{8A^T`Plh0vqvy$wd2c}HA6BrOlvYKVC9MxqX79ZBD0rM6L0WklO4N^
z_H~PhSCT6%qhdC+dWzNYUYox|q+F~slso56emNonJ(X-uvQI;v)A`6X?~^*64yp{L
zzKuEnCh_?h2L^n-VJCh?A8oHvBluiIId}3$PSKfp%n1hbzga!rHs?Q3kLz+%%9ovz
zHHZi4>*5c;irr#?bu8z3xE3|qM+h9Lb7}lpN1x7JOT`IVAH*t#z%Cv%1QRhUGS-7Q
z`gqWs<@n+IJAdwqt-OZ!w3^iXoK~K1`)=K8!p+>K<6=_XPIXF5+NsPY@qMM+XPbaf
zu@W$da*nO-F4!(Xb%ut9*l~O(bC&akg?+&=8@u;ORjJt+&^(-b!!atbrsDUD)W&tw
z7W!AINW&QAllVTChyd#;6Tq9MciD|vSnn_YY;L|dG;KkT2Jr;6IiOr|9rCPYQ{)e!
z9X9_~!GDJYofJbG+6CjlN+68B1yPt@(EC;BEQ_2Ee@Ak{9~So(f&PGMQw`&F;`e~5
zhNP=~;lc$>j|#Yi$Tiz^I&ckXBQov{0J8Mh<PX7bg2>}>tx;%iF`!||K)c?IqL%xd
znM-vfd*cYqF>A}fC~Z|`X*y25=Cnc>=4zuZ(X*ESL5Jd6xE21Y7@xqUC5L{nR}Ds=
zaJsvo&n#+c+Tt_sG~`5%_Q`*_-gm}Jbhn3;*9WxU1=Or4uQT!0uRZCEF-#0Bq+dA0
z*!%bI&khIBV;*XZmzA<0p!m##c-2mwP6B4Z{!5oH_YJ-<%|{0?#3KW(nOf`q20CNI
z6Rri=a)U9f5s%i`$Lq@h2lkOG8{%+j`TX<mM5)F3b0EM`n(h!Z(dp?|pS)BTOC+6G
z4ts)pZ<%>dYmZ6-p}%3A>IQC{a|>wSp~J7q2A+Rq$bTnWTXi44h^eo4Ewh$~o6Oh5
z)=Rv*w$!86$dhvM-vz^#H|H)3nKhjZdn##Td*za64B<7LA5F|ksq$y5p{3pnwfWSk
z$9xfTofkRYR4xx`SgQzuA?5+Y+f|h0B~AXAW5vCRnn4M5#QPWC{HEzEMOHuWKexgW
zr9=$e0(KbXJ<Y?L%`i8~+)~g`K+8Wk@x)cnU>;KaM_T_i(b}cllpA>#pHlxC@=Eh>
zRk(cRzyAY)`+sU%M)VXJ`mb#n=6wUn{omM@sXP8ZU|SwPegv05A#Hv;>lBB<P5hv&
zYfyJ!SNvaA;!p8RovAS+RGAr=Yc8fALpQ_b2d$IrSt#XzoHfAzrT_6akJuZ293Aik
zKvFd9_orc^>`h<toy$?gas!R^sU`m20Oc>`rhv;TJS_8moQ1Cx76Vjx4-+c<<aqg3
zr@ceBS<3KM%(^4Jr^TeDHAh*bGoW&nO6x<-#*C>3_qJL1Db)s4>UHUJ*<!5m#HWY4
zI`7MDIAxExtbup0NSm-wakNHOQiQE8(`JMPW+VkcPpl?mp1B`5un`>bhO{P%CPX(K
zs@n<jho9fheuiR-scIXQsPT*$r^&h0;+`+8C%!MFm=K9d5zXnA0V(;B^@e^uk)GdA
z+ksF@!Mcz;eyAwUez^)|CKg)CMHwgSZ6Tr)8tGuiA_efm6`vV^dK)0&^oWhs2A0r$
zREy)5Z0)&YM{TKzDUP7r=Fq)^Dq2keE6|a;mQaoyEPf^U%9x=8ku;F{Q3u9gM1IKp
z5f<jb+d^xK1z9ZAYWmxi8EzHBWU1=-me&-i)K97W|CYEL8}xru+#S{Rg7ese+qHj|
z1gwq2p1SwYp=#k~yM-?y^xmcc%)d^l@8g#gfEGB}6yh{$N9*W}+jzV6@=IH`9K>C^
zKY$}SN#3<(E=p<?mskHl;yyfV?HcblOaBwCSg}r=#Pphe#ZDda%4GC2v2Kb-o=1R9
zvOT~ZZFD<5WrLlHtH{mU?VIc%PjgAzR(7TZ<|uKzmsF`zB@->u@%!g)P$YXXo8!-T
z18aYqLF}n&QRir&Im{qM?Y+T)fsck-bJd`Ll3}Z0w^sapPBUkQdhFY`9$y@cwiuCV
zf1)OS<UrL@UK9TxP?I;Q{jbzymw&G&KYTlssk{wE<UnSd4V>Xzit!r}>?W4+*-Mtp
zy7+4iZFTsgTFW4Nbka7kN&#-AEn7rL1p=W4q^3CW47EW_#x<$nk$vVwB>f7QaiuO^
zo2S>DwCI%ek2F6vs)ba#f*y|cuMaDSulFlgNnBzgGWzVRm%o4Y6XrGl6AfM4G3Mv&
znnc_iv%A$c3}2&E8;tPLe|`M-k1pswJ5Xs125u~%=s{cFq|+g0dt>$B5osLmkN5k%
z%;dQ=MI{c=dXKZI<Ywi{!pv&u@C?Es8RW0=^ir!WP>55WNwkiRjtT`Bhf6s&i&qfk
zwW@;W1ZNPNn%WdIbC^T^5%Zr|tr*;&-hAx8(Xy|Isha-ChBXY>F-2d#q?(j=ahuQ!
zY7V-n6*o<ou7)ldAnHB=sj_3}6}eV{Qg1t{x@m4e`@XhOCj-lvphqGu;;NjSgOQXo
zZHBJe3U(Q(+Q1;)3w4@koL6Om;^C>$wSyTXbY`f;oZp4Ne-6tpPC-IE4GkyM;)}Jv
zSHm(Wcv@Rn9Qdn}T&`THU>`iQmJdMptwoJ3*Rm&RZ`!>16ee3f*+8v(^!~4By*myY
z)|SzOZ?@E{|HyjxUsKh9DRHazIR}`9!w;^L`#()FG}lG$?b67n=${JsSP}jUm^Y_O
zfsfW*Uf`ECpup$GMVUNZUf|>W6<-^)e^+(&$_f~FRB!{oL>QRIX}9YrV0kJjuy*!H
zo@HT`v}Tk=Di97N^@d=4xc{;a7cO}H>@nKWu|F0fhdm+jOdqMmTb8Z{D6^f+K-6y@
z_R|C-LW#e@(fDuKE_m#y<z>9#3u~@>^2;CP%0?QY>5fguKS^86<`r!59j46h)>1&-
zHH!`!k^`)}RS)-IYO}w<+-QLp_SsnSTZ3(9l9pF!<jy0i7p)y3Z4=kBzl`wPiv<Cd
zE>cl@or6ctr#8dZ?Bw*{jEjqT@}vnn32T62-MJ~p4I>hlhnp3ej{dDa^5T)w)V)VS
zUp{=QL>1GP&h-t@Jg3+G{v{MKtuBw4m1Fx%O^eCD^A;??2q+C)mjVMv;C#-^&fbE3
z{BUxYQJx=-cAgA$p*GYG-vhk91$XGXs_+m5<;#~Z7kXeETJu$<e&oCVkti4g<CGE=
zW@^&Bj<cG7%UVa2?=NhyBW_HdbMf14FG6^s4m@w@WI7_E9@t!9)?^LTr;y(}oa>ZX
zkDK&tiH-JCCg@&bUic60D;7dWqC$x2E~+)p<Tk9wf2gCEB(2c|-|f6!&-X~3e-YBV
zfBG@a1YA1gA6SFF0c>t0jB0qlsx4S;fL~}hq|U(!-Y@Q5WYU6d^XVLyH<)X>s;MPC
zyZ4hK#5qg$u8WI{SR=B(v$V*iN<R9gc@|veZg}sM*5}Cc`K657xCX1ze`%%y*tLvy
zW(2RC4<-w0;i_N<3ZLo-!^!nAdoEqN<le$7gI0>dBNMzwju|t?t?-<@Gk7Kr2m9^a
z7UlX=hs6C$5E?K$nt3ejDz)yZSC-5|0chsv^$)%LA&>ZgR~rAoWjP&bjLdfCCXtvr
zFTAI9qtw7#`JjXZbUHXVIa3Q*w2XJtVvnwU*^EG+wbYy!gQL_MSFbJ&Tj?7s{kk^n
zNZ_)bpC`JGR0=oymE=C4yjjvA>T)ei<#M5oo9;NY@)`<bdQ%_u?%R46^2eZm78@Q5
zMr~FeF>ju#KpIqf<>tMsI5;?n`ao8fJxAcN;M$(2QEP|MBT^I2SExc*@TXVp)nT-H
zF^-}CfB_z#?_pw6AvVPFP?Qu@X~P{Hv;o=Gc_NYCtE3r=CrBI4MqDr$Y%}RtA#kt5
zBx!o_iOVgBS7o*mBeAcHc{45Jm$Q>o%%ey387(T}J=BOo!PKD(Q_K94==Kk`eb$8j
ztaX^@h!}MaY4xf5zY^Cwx9+d!`F8mLVeT;F#b6I)1R)F39hUwh*V`C;docua5xO(Z
zlpPY1PwKVn(W4%+i+I+B)s5WPO_I%D?SN<JX<M4MW7Bfz0jb-uhzcYHkmnD9yvp~Q
z8X6iZ1Rj%g*Fjaxp&>${K)06kNZ{`G&4VlhQxL=F-9iYrAfQr<HG`TR=<wnEl`Sdc
ziJc^E_@USI&4DJK^~H}SJx!d6kfCQ&@&m9q;ZhMHohWZrIT|wL$i<&9W4AfX54l<J
zbj!k)uk-VF0j=aG0@9v7jehyEEp7bHKEs+~$-<i*$E$}FTCn+lkf96;j5;^iCMG4u
z(NLRK0=YkY(Qro`6BYUecUji}IaT*Wuk0VID{GpCMMqsjC*2n(l{o+JIs&eT*)QM}
zsBTBh{UYm)beM6)W)Xu~uIUYdk{YpmdGBPazWA|E=yg>-lyLVh_hYnx+m~`XYy2@c
z_AFjJB}ku;ppcz+@82I?QI2yNp0eijK3mdrm)Krei-YTF*s_jjeN6?Cm<Dw3-hDJL
zgeHRJuR1zge$5j-@)j&-zX=WzepncA_?5kQ!YQa@4jB98PQfQkNBo~AJCgUO*gad%
zAHw?;`PuBR+gOmrx4|$A?77hR<@9j)_Ri_;#*n?cmaWlwa&o>VMXd};d6{mrcKrC7
z&_S3pCcdyPaGDz!W@@oyG3`58a?gLvi<{ev3>;Ih1zzT@fBaa|**YWi+y16n57n7%
zwFlbo=%AH#NjjLi@^wAekEIGzD~eh!b#N0}UiDqN9qCrCjn{6_vgHoZPryzBSQ(CD
zp0I{gE3~vmlTV%#badQa->dLbqw?vQnJM!zf|6&Mnf(}9w);_@1#)>aj*<1tdUXCD
zi)E8<-TBAyp#(3s5x97QP^3|^18>#8^`^5DH*h4^**9+9q3<bHeR;0ckMIiChH<Wc
zy#W7keQ!`|N-~>T@-bQg2T}3Wu_8h7efpYXEIs8T26Q{QcWw1f{6O!16<k6<w{1Fq
z&Fjq5;1864{ckzo?^Ht8lTKwlAAP(5^ea&KP=aR7hNPGp`R80$64IHPmVl$B`;!<K
zw(48&3J=2HmTUzkDV&~&#OG6TO)t&>xpqF_VQYx^TK|zBO}Fyi#Gvj|lBuj<Md((j
zewgp&cKR!#;BK&K-?ZXo1OA3$dJiS2WcdwsUBD5jQL`pnwcgjWPIbEdZDv0Cf3^3W
zVNsrIw-|SHC$a2o6AU&q5{=T7DqUkxQGp23q>M@vnE?e6DFY_4Bx0pFQpc!(bQxe^
zXhT$_&nUf*(nc7H4$Yy>w;s>l=X`sg^ZQ)q`o7~IF9sOidEe)`pZi{G-RrLR%n}>?
z)HU@t{H1@g82^y1LwoimSaV2AT2i~fxe}%n9vjA7{y!LYfW%gTb#Y@qr<Sg6qOJV$
z%aUXNC|)jc+~Tc*U!_H%^g#~Ni@bl`b)!2~E<_ItJ<`zg=^oeot0;H=GfJQYM0quQ
zl6knABRBpDQ~)G!Lzf6Sx5fud(e{m_m2}+_Y?^=sorq0DrH#W0bliQ==-=!(F7y0k
zwiz8|8{v=<{7Ap+I>X>^2!!*)A7!walaWC?CQ%z9FccRTV>pNWH#7m_J+UqW0z!f{
zHW{JhA<lI5k!N~G;5QM;&xo3p0Y{MTN}%vp2}s}#2AMSD$b0~69EQj^Vt|&n)A@qd
zR+B^vBmfVwG)`fraJLAS3uj=tfGqw#c-tk!fq7|xPygp=CA$b6>tGkGOe$bNes1W(
ztL&^(Hb9O^OLBZr-u#9g{Xr)l8)yc2%akD)L)4Yguz<wOp(OBYobQD5F`C0Y{o6m2
z&a=laa)v^_MB!)*lo?3SCPvMsh^pHtD-nrLz)I-tg0!P(Y*$I@C!ur9ZE(*w*tGnI
zAO3#(r_Dd^zSd}U?C~eRe6=mJhb3DU<#^7~_A74X&`Fs+O27TZCCclz><^zA@BVJ%
zrI!yr+jM#2QmzMo?AE<ICkCz@J~012WISf|g)z=_LQul^bzh?_Uml!66sln07<)*C
zqu}S~*9HgkoKvqJ%nfLBtAGtL6|;)fAoBFk6{3?iVJujvr!$h<poaXPNa+TVjv)t+
zRp;&6jC8@XR60MF3~3;iG|%~#!Ck0``r(8{J;Ft|^T5l!D@{|5p0?&v=7((B;E3P@
z2}d%<soDH!XO|2wPy?hEXHeC|fKqXT9t@85_C7ovp~j~{G>!oDr7qFOM<~Du#D$DY
z(TeXyYp0j*d|10zPMsFqb~?k6q6%>kc%2P}k%WCFXCP*dFP$?#vG%ByRX;q#>tOp4
zrI=appnL&CPZg1B)J~U9m*h21f!C|?FCC8$e)9$8lx#vqnBlt+rtuMad%JdcpAC1$
zDzjKzebn084IO-P+FlNp^TbqsfK{WiDq&Ijr%%;oF0TCjhF|*t5*}aJG$r9i7|p!8
z#exarR=ezd9T*OA2WrYKCfzt>9RP<9qVy$iifl{)d7*SVRLYP_n9?fv;NC-(EL7%&
zV!T#A&TBs0IO~zBLFcc49_~ODXbm8#+hODAX9dYi1bS*6f=2QrXu56dS!ZQsr6Zji
z_k~eb5}F)MtglDT{<$*bHu=Qlw%jyY_|Q};M7Q8hq#wbh=+#ZeZirTMJ;;L+!NI@F
zPiNqsb3F<Ut*)_@<b;^`^X=Qn75O&Xx%a2%@Qx`?dS{HNaQecLg>OMat2MjzWLOgG
z#*G^sQD#v+Wb?s2tC-&xPotP|!QZU0G&hKXeDV=AAazqf#&t0#yb4EOzFB)nqF>X}
z?y(%(we-y<PPj1+0sT>Jfuam`pT0^cb`)`Qz~a+0OQw!--^nz8OKiD5+-|i^rh$O3
zvn#%E7ONyK>9vvxboJxEn+Jaj3z`Gr#E(BED~peZ*OW9E0?J9}{qt2hs0xG_G{OHu
zwfJSvoIN$$xO6hZI}uyoBs?Z2W=<fTr>t4C#s|+(>qa-=7(ROHyN13Uh0L!SZkw%N
z#iZ-=$umM8<ccO)TA}b(aNlNf%Q4YmRzb13O!v*DRTefj3}^yF@6XceVw$;mY#9Cb
zT5ON<f#;8g;w+|dZz5~%$o}<FNKUMpg}-gSc>qR3aJK4p>)3ku-fg6@{g%v`qp7K>
z%_bdLxqr--Egf8IB90ZzZNWVO{1$>h*wkpm(;u(3PJZ^ulY#57!~JmEmf>AKw^2yP
zSQZOw>*k@O9Dn%u2`x~A{JKK-ae3+96*>wS@O&864-?k%oVHT@(W3I)Qe1FyVPRo;
zj2(a<o!1u^`@pk4w_sn&(Q4#-;|%WHcYxFm(dqNoj2<g0l6m%8UE>(a@QS)VU!m=E
zT1I&Ky$v7sjOJIyG~zR_H4MIhN<I#1P(65UoZqf!qi@lP=Z-#C@0gf^?Mv64*$waH
zNbCh+q@|fhyJ6tOTLq8o(bjhA?2W{g!M98AC}2(&5e|s6Z_(4sb*7-QEuL!k3>jRM
z{@p+KU0)k=X0q;*?(8!j;Kj!}l>};D)*NH|oED;)>DaIc@i>eI35E%fO8ZM+jTyES
zK|S+5%<7zAOUG$!Y<vVtHzhOE42KlXyzYS@0#1d|6vskcH|8Wwcf@FBgnH5#3e1Ix
zWM2d?A*zbHJxkX|;y`srj@9OwRdS5RohBYXhLS4t0gP6v#6hcm?(NIQrlx-2pnO!;
ztY<6q(sS4X+ZpmWtFEn9Oka1FUC3N3<GJs`5}9|Kva>S-fRGh|dYhP+p2<kBMd5L*
zE8k}}NKg>{sA=1!G+i4{KgpnZXbi^As*sOhrvLuA+r#Xen4hI&`{ekD^pDaj|Ko~Z
zP1In#fj$WpUeE-sJNI(W$36P;<!uD%^Lb-qSa_A|{X6gA)4BsDC(#WB&Fuy=Jz7cb
zeA3IM)`_X9+tImk+D`yk?flclwqfaT#l)40X|bXn;jfq6?P+;dWSS;K5?QQHxWPsP
zUDSvzWJA6i5mTLh6Cl4kdT7aR4Woz7b_kA9gQnWt8xUlIr*fDy*%-)*=jfu6r1n6r
zqNu6eJ)12OAm*(Le)nepR<am23Imx%qX+T)U=lc+KBaRWG%X2(@S3FziA1mie2er-
z_~h9NdsP}&WwtEUFf7j%!f;G<b^<UtB0EcF+<XioZ@?d1ef~n1HV$>0S@>MvRwFxC
zPLwxg9XgD1Mj)N#;E1zCUwR4FT3#jxiF#so_D&K&b4IWUYS6{d`XCrBcoz2dvF+{c
zZXMo*gGqSMd4V@z{%C}&60FHTWIyKL|6n1*wBI3OhRcN7(U1gt#QA7qr9@7!Y{T~1
zyl20CxmhiAVXhNyT>(A6Zxz446<S<=^ts=WX}_+e){}PW%1m6O<@P9X4s$-eZ3=cA
zn?Yp5l=Qf=8f}%#>%AxYD|7t(Mm7B~&e#ozf}BC%xuKyUAAFgF%rHQdkuSz!BE&54
z8r;Yj4B1wJkCr={A4mvVccyHSUBQ_XA@9Q|E@(N>fx+SzEf)i`$TgGmogAkMRTb#B
zsg2Q8gjuQ|_?q^U?cF#uB33(H*tFW=%pNm?$wqX<^xxUPp^7Xj&^eD_V^yxH0{pqL
zrA2sq?+Uwz=RHL8K$Ug?K&V85HVdu3PArXW7v6Vim6`2B+$dUpmlh(XGdU2*Lw)@4
z=IOl7)b=;zIMi%$h>*wNFOO5FDskVAMcS?QqqNYETQSSqeHxGK@5hd=LQ_uybf#|P
z_(2Hp!8UP&U?2di&fbx~{306%w@mPX;Fp6@WB#L>3%};F)W|Lg`S47BfV=_tWkIet
z@`}SqQo|KAH8nX{3cgj}G5TQ7%qIzwOZjj2u^9E-<NcaXQ*x4$wvgMRQvB{IoF3GW
zUK~a+S%KLg!4nVV>o6#@J$=q2IsPtWetqOmVCr6Yx^3jVxJH$4W#bryC6O_yMH9`#
z2fGisMNO2AQ#9<^I35OBtIT$th;Nd%I^U{;3+O%iRNGdPn~lE*?Z-n1zJm!S+rd`z
z5N8ArY70|m3x^k{%_ueBMTSc*r^Uh76egQL>(377$n83Fy!8DIZx?8=$Q@~bHkA88
zrui3Eec?K;;2KG{Fly)O-K8>yN1LYvyJ-dj@}P!sQE7QQq%nj~BXLt!WR=$x{@o!l
ztlc#+t!)r6hZbBXt!v=#riWA26zK>X_CwQjOJVBa7>#Wpi4LPZB6i<jzmC@P_aYe|
z{=t!_pvmK!=xKYQAkR^XEJ6j=@{XAWJ=e4{{MkDj>6W6!wD&lj1sojVzBonGr*tpM
z$TxFStgqg2mywbG`&v<Moqt+NO4SOz;diC|S{>A!>E$}sEy(C?im1ps>QPNhF0^H2
z%sR$SQVP#`comJXsc`2_D{1b0VKHr*y)xGg+|M9t$Q&93r9R{|UbaT#z?mga?*0|y
zCJYrI8P<(ua}u_yKUoC-PQ%cd2BsJzNnOyGDZz+>k|Q@uXLc04eGtY%Dm{$NM*Mfl
z@PdAfbR$C~7DfaMri=gQ;boB$i3Yj64d*h#d|B^_Uuhg>%WT4V#Yb8bvH6z1#Y5^w
zFluK;Ar#ZcoS6VD<$B<2>+mpjCL1kt;5Y2C@nYVOACHfptgNEYfsvl`>2rpXo%rYG
z_0A1v5kLoO)%lHoTl+H(f0rAAfzQi^K5l@&4kKO$V3sMuSdkfzVr7+g%rk0{4E6LS
za#KHn$m0+hu!GTxYwg-lrOC*APVNLe;w}>R?Em!TY77XWJ^)3Xgh`*xJ2(HIf9l_U
z>A&2UyA!vdlS;$N#>Vq6G8g@7D`9pmBlG=6GO0l3;wQ*h{#$(cQwruYXqiG))Bvk<
z(LJ(7G2mo3)+qjcN*33DhcEA2V9QWrQq$5jKanZZb?f_R+y2$xaQ49bd=b(R{QIx}
z<>SV`$jHPdp}F4U|8EM@rlzJfi)4<kR~P?l0R7ikShghKL>YjQjQ&M3bEcolJb9%E
z&%^KP$cm9sjwVA2{%>rg`#yBalcU@Fk&0Adu8#$UGPdgYvyesG71iPUN5u)cO;NF7
zBd$fXhwe;Q2^wZ~?pk=Elw$v2k8NVic}<<khsguK&{Yq(N&;`OEUdRj9TbiK0zZpd
z<P9uLT1-w&J-G7tuc;Xsb-)3^*F^x-JB?}Q7bjmA-3r#$E;(yCvur5hTJ`74pKjM|
z)OH!5xDWJg+A55l4fQRdgqB=&$LP1+q%v%5ZcfV1K7zMH>28kPgG>wz9<pTCf4ss!
zUn*Wn8Z)DhoAv5>oT9$mm~LSlV5}SEUwxfhTlqZ8)M2cJGUnWca>CNiE*f&^nTfX7
zzymDo>^wfln1`~!+(%v*ZJ=2H<mj0fLk2}QN3Ez&wv|R1!sb=xI9+jmUf#BAf%OOV
z_Pg|>+g%O#vX`x<_Tzia<2m<UUpIZk{RXv@j7)lHB3D{AG{so{yiz?_I$=ycu2jjb
zeG6?^b#3*MFZjnFN<JC7g&$q}_UFT^p1kik-k|lVEWUpC#<fu{_F(8v@iNNpd7QP!
z7wcaS*zk}x@46SS;U{dzuIoEn4yx`;c=N?$BV1X!)IB>gJz!tQOwE!WTI`2UhQi1j
zzdlj>R=vHMq7~_ru@Wz&d;g-Y6}51(Pp<Uh%(wWoO9D4G{DnHVUAz1sWYHxOfK=1u
z78e%kl1vx*aMq*~>00UI2oq|MPThrgBRGTMJvIC2Xf^!&EKor~1U1CLyHo2AhDzN{
zC#VATiWR%Gg1p%7?BN2}?bX}WJloRswWm3ql7aZ>f-@&$`E7ZQEech?6n<(Lr}a&J
zz=5fuJev*il2b`a2`sbOnky`moBH4_9H2LCo8ZC;q-q#fKr`e+l%am&=_M*^T}ib~
zY5hPi1$YtxwFXhAgSO0Xu3;QZ)W?ut4(#mJ&h|V<S(5eP2mg^60w0oUm}HJ-hD4v*
zPxN%Lv^2m1Xirvy75Q-SI8V}AVR#oMlc{ty`{TKW8>!@}As)VzVOII6p2O{_uSa5O
zV~$;VdgnSeB`-7l&i^oHvp`bg&niA4+0JizNWT>v@Rl*262d&#lKS-<J4a{7EhXyP
z__ZNhT1o?HvW=O4Z78(y<5vXH^|MrhHNBMro#QoYW(s-jEX$U7pFdZub{VLTju!JG
z{W>UGw@p!rj~RrR^0ZMyk{pqgMg)p%_ef5Jq-3qB(7rS{K&5Dy1+Ykc5RBp!q$AYq
za#@0rp&4YnFT#8Pu8h2|Z5-}E7?KXQp{2zgLvKhnjCl)13MP=Zqh*0Xz#3AC!_ZHh
zmql0B11Ov{KYNTE?N1h%<;@$Hb56Ay>v+9BJ7zz6Z&8Iyg_qvI#8z|f&$-=c_E!0G
zGpo2fSxx&sNdR9s$Tf&Jo(!w!CWTu5)ql3HBlf0zqsLDw@*x44aToe^m*+LN_!%yn
zccryq1GJn!{;GLAV;OIS{=2g4>-Dry1J~`WSeNsn#j9r0CV8&Oh7#|d5U>T1QxG8}
zWi2&V1DK%9^{lo-XNvA;q1Fk$X&LNlZLXxwZ5FDuIKlj=KS7(t7~`YIa0>K*C+tux
z_EDK`&|M?fciYmwj?2h3Wzc*ERTu+tMsW?N-}zL(wqzOC$#OjEO*s>)40fy0<A(dS
zc819*H%*1#XLRiOMkLbpEGm_TItfA|)&;P&2v$n!Ge+q|BB{XwKylc}k)fB{Fs<8`
zz$eP=)^C@tKlgGwU(hTbBfHBLO%H=;Lr^Jr{R=?syzd(TrUy@^QD`yMoO%#*@f90_
zlpup3v5t*G03O|jDe2UOBWPOJ3tbpz68MS0sJHaR2cT+*1ZppYuz=z^4;tnkVCkJu
zz1N|Uu9slQoStinF;o0_JuD>rE&x8@NgD}T3qctRWtnXA9}oZr09;mct&Ti5+`1ES
z!Jqu)l}AG?KgKJ0En0xAsO1kzY3Z|;SXvRidPGj0c9<u4Gq-H8bLM*b{LC<8bH2Ws
ze@TE%7+vpt$4--DT?~a#x-iRBYLF{>IV^CODpXB%vAtz`x^yMY3MN@YPHoB4hH_XL
zfw^OM0`kViSM5S8S9u$~>glBGPE>6T4E?rOc#}Vo*r5JE`rEP*T@Ak*es;}Is8KE3
z#G}5Yd3_n{IQ@6pGDYX@x(oDg@h)hX^8#7rJ7Zg@348N*X)M-Vae(GbOJL3hk224P
z4y_R#D|zuUbFXi!?A1h1tCqtd?mnZz<2<Y86ie6Sb*%DDa_xSn+N1Jo9vMf7i&D5X
zo&CPrDeluZLi*ZJ^Qni-eQ@h%qDXdgO+bKho2{v?W&yF2&HPmhVTbTlI-uhTYCMeP
ziue^o!jbjjd$^_AElxo+0NUh`C0mvQxJGO)oiI0@7LSVZ^X7uc$WfDUH2XZl158u0
zKXT+%u9V;|1T>hLnSo!4Dm*TD;KarWW{jZ|XGvsB>V?}%9N~7bbg1OY;Mb#$M@*nm
z-_ElYnniA}CZVZ)-3b&v0FnT;0C68WM>nGDzY-o<=%b1RKAD8A7p>`OO<=|0?1~MN
zThb4=fYoTHJp(ct4{kvpFj^Zmr|u(mhs{_^$OL?jOyhW)e0_2NWw8%G(>wd}cMqHH
z%r-Vd$c@|YZWvP`2+`lV(ojdr8sR?jE#fKPH1MlT$ynl|nC$G;cDANiLz-yi6v}rB
z8hEs4>vtwogE{8s1=Q&zdcIkyra}93<+G(majZz!Q8CBvDEIq$-HDoLduDXD`ip@y
zez4|^#1~1<?7?DFm4&zEl5!EZa_cNzZC-DRU)(=#(P0~_GE(@Jle?95!nk|ZywcK1
zz3;I&Du?@X8j1@2&E$d)X5Kqv95T~x9$S6ut<krPVILE+4kF7f>p3i6L%p{-lBfGi
zZ>#E0Uaqy(eOT`Pt}ebb`h|sax9!Bf6>o!fn+awnI(PQpv=-%f@*T$?c7-&4rJ&+z
zd$)JV28JqaHZfQdttxD5<7eh9u-LST&3vA&C><wnCaackDZqMC+t^q*1LmPKmTCPq
zS1c9x|GFN4z{gbt6^!hgHbiybF29yUXwOU+9R-FD8p#K9N%D62+t=i~^*sOD`_r})
zSJzt?#gi2wKmT?=;q(?n+yzC9y@B;%HCa0i%mob$;`w-Z$X4JD9X~Py<zL&t6>tlz
zb{y~it@fUb%qlZ7BVfeyZd8;j5DFeTo5j_NSuW`C@qmQS5Tljc(HCtl<SB-DU__&a
z(QF%E4ES{bxJC`Gqj^{#LK*)RFqn)3<eT#Nab<D9xDPr<gy>?e1)Sb`^57}^nyk77
zl$2#N{H0TaCFXD5PbSWEzMEMt>5Apn1avSN&Pz5#up%|1$W|Y8YAPu|m7LvBG4O8T
zs_?;y)vh9*z3_eXEn%WWHIbd|y5xOWOURw~z7_6`Tle*E&6-naDfOY{%;zo7lXO!`
z8Lzx=^5)tlCgC@u){l?r%?BA8ylc=o@%l5#B-*rZ1xgM6I@5WZ-#@B7#yfj!9mCi!
ztUjCN%pNJEz45bdyBlgGl(T2vp_tG385+E4Ktxhnthc;Ybz0)elM6HpnavltIgJ!k
z8(d?9{TX9!Q{pyBk0qtn^9#x$yJ{ct?FipDW~&FpZy3VJv&kCqvzr|a!@uw^+z}ci
z^p?y;F!|RL)h(Q?6SAn&QE_>7cBahoYJQHt-<U&5MU!3k6MbgToUiGgHWJDvE3$af
z(J8LZho65PH=Eas{n1ES@Dt@`(|iE;b$TUyL+lL%pc~Y@It!>c6Xn!g4jfFhAOIfx
z*o>ga@jTl(7BXF=p`p=tU7dFTr%bHwQ;e^P!(wC?B(v{&kGKO=G^sx~H#C=CJSsGt
z<{)<5A1s7Uxe|wn7+|Lm7S~?q4~HW|*(!|l{W#$gK?P{F?B-r;zb;U~TkPI{as{uU
znaBmwG%`xnG8#V+Ja~wLVcDh|Lg(Jg`oXF#h_|cvI>HX@u}P*Q5r!@ZAt59{y8Pq0
zp#_AQCkZ(}Yh71Z)9Ueh_HJ}huvh71XTDF*!>w-h4@~N&XiaC+Wc$bHqHYK2%w$SR
zdKH5`Z{gKGoium$x%{|@9vZLCHr%{^yKegVdD$lA>c`sqG(UAWVHJd&Rap~yguL{p
z{kqPfvzDvP>++ei=kdyE-GN_Y3XY#Foo0+_no8s5czvDvg9EvW-VDc}Ok1<T$Ul=G
zv5M7<E(|UWpuO=lWme#A`%~=9U0V{01|Aw1wx8ogEM>-BV_kEY>TxyQT)*bf4LOOp
z^01?Rp7DCKwLZrRb4B6OHBw65zI&z)J9Y{}-_K&b8(f_<qQ*}$@-lp!rD|5z)@<7r
zPe1e|WHyZu@*I-X`jdfzpO<d9N4R*xHu#h+TB<=~?l|!SrsWDwmSjd*?iJ|8U|gPk
zLu<jw?}gQaH`1J84FKMbkBP8dCk5EEv7jIg2}&Av#15Jd?*_ka&;IPO<sD9tY=PNU
zw0m-VPlM0~g%nz|b9YrhUz~un*{y>OHU;(p%Bm$3^-EPyd6eyYJTc8|3V5OFncrT)
z-8EgVZ!|4gHmd(YzJihOnK#@Y%F*YB^tR|+2>X?U%pA+<c(wG3C(A@Tm6&o9(ZN%%
z_zTX@k9jn;C?B#rKf>|6GWpHjgpr^mR<LoO1tpb#@#f+f`SEG^$_+T9^g9(mp;4Ls
z^3#1C=In12)I8o?+mY=)n_#j{uG{y*nuE(Z(u`Sqhu#G3v8sfUsoG3~^K~C|dTm^m
z8eDa^d&bf??0r8VF;3aJ(ky5PQ(7sEZGzczP;zFrN|x#c1A6N0BPG{uiuOC#oN4dz
zFbQ8@IPzrQbp9sl6OY(5y>=l8;1gkk3>eRzYiN9-Acx_IhBL216&`@72IEXe?tuUr
zu0Ti-*y45N(ks^6D1G$-Ito`rQSWv`Wco?3ti}uk)tb+{=|(hVK@5z!Twtb0_^z;g
zs%$j6EI^9A(pV$v0#zKPfNyjgb^l#F9m)+l*BNB=uqj2<$x#gXoe(hKrAWHq&z<dp
z6a6ND6oUYvu^^bhr<0CcO0&NTR<$3z2c=g`8zhx!x{!K*xyQ$YF@LXMS~-7j{(5oU
z2?15>^mY?B)mX<1wT<6dj*qv5Brv&C;|f*0E`MIW(aZ={K%0%@K9fiWm|RI|%SdOY
zZ%DE5mU^-9ol*)VJpXQSl<V>ui-X&mzHYi)QR45Iop*vK)=_3Fdpjib$#3d&Yl?Mk
zX4$29Q*~@T+QU6eU1P-8hw9Xv2d`Tj<qRH5&Tnl_-peH0ZRv`T`@3d8%(i=p9&poX
zYv*I!E7tiQ4$D6tBC;2pmQ5hXrVc!^x~Cm5^^CeEdg6w6@WUoG^bwpyeHjfAL;9)v
z)zx4qi<?+LG(Fqy)06};8TsA1P*PVRl?n&Hnbo`#b6YOAICADoygMBNI+yN5A*xVy
zdy`@}6=H;Z7i=KHs;QrR{+rvw_Jw}R!gqvLJ$v&(3WvOH9*?HX)tcRmJ1a7hzYsDy
zK3HTt{w_VzUwO>3$v`-I!HXO|+f+Rbi%y^DdOGL#iqdf|Bg<euPyfuj#ces$3DRAe
zM;*p|uOvjgF}Ny}mb{ay4c$26@%_BBMq3H9P`fL&P}68&Oll{v6|kHVHG`d$=X>ux
z@Xe&=6uu}tYI8I{a3Sgh#c{7=!-7?mcTD%Onf>&&2bbIZRJ4&2EDpQe6i?9$jR@Ev
zcq?FYwD{UcH4tqHt(<X%Oy(uL=)J2O0>9rHpWCCn2EvlMw5-w?nA;^MB_-KOK<TpI
z-Xn_@)QTRd-Vmr6i&yNr?{TU(mE^1h8N#_w^e1k!FmkIunm_H7|5zn$oLxtFDYzoK
zp^j%jr-hgg&5Ps^tc=4q-`w?}EgKnU0AwYx&DKHQMaBO1j*gBHaYez*oBmpi`$`RN
zR||hTy3Ie|Ry&=QuJ*O-*E$~WOeED)6pu;MSQE9Gx>t2i)0=i;A!*!Q(@>Hc)WCkB
zA$wQwuw_HEjh?D@ame1B5iHBL2X0|n8LsS9QMz)3AUe)5Xfy`#hW$+n+mDf96KSU}
zk>@<svt;?+if>3^S%w)eEcIK{*fSR)Yg+9UJ91a<kUOd2MI~fW4qslhwkL*2pdk0~
zAvzmE4ZrsVaYMis@(s)N{z%?5w6q4m@Ohsvg%{NT1SzM^#^cbfBaAKx*PU6A$#@mK
zxnkXs2D+N?yH1!m1y#zTL)OK=i@OLTj4_9aFx4;DrOH22hK!g2O>q*MQ*d_!Ez4{i
z9pk}ggUQyE8v9RoUG{7t!}g-plO+s42wqS|+Zj$ljPY8$);Sco?uRFyH94)%8svEm
zISF3uk>Nkwh11L#da2HE?Bze(kUVilqeRELrr$fstHxPK%wwgN)iu?zvJK|-xsO9p
z+9_A7V%Jagk2I7%py!M*J7#<po9#V+wQ_W)$?4Il;eFR>yi@EFy76qB#@k04k!#ev
zUKF_XD^_n8NB_z6urA#{yCFkm&InJ>B;413SN@X~G#X>MWVjSKQ4sfzMTVSFNHF4P
zJW;v~-UuISB2^b)4I+0)2wjjYTdSpXb)C-voKdBn&=o<E+2+b{RD+K|=eY(`l7BQD
zt&I|TdP=?}iVKy(w+}jz3kSTpyqbmM%oUEP=Fsn8!G@EPoT#EyaJ-St;ZwPZ6#KsT
zJ)#Q(BDo*Zg?Lh4kpjvPa|)9opj2*N8N{86gGM?Nt|tm6bUJ;2&tyV-=!Q`pkf!js
z$ju3%?YW(cQXCol?-KO9F)<Wax9Zvx5svf&;Hv9izI^#$1)6YbFmyT2(oE+&*z{Br
z(ipRxwvlQdRU+pFU}c%sf{f8|`)!GF(-Q%lapoxX^Qb~AzeD+{UTOLRf&@u^t!@2G
z;mPD>I^P+!_wFZW;&`%7Xm!USfmusxrli$PzUHj`dWOY8$@>~3uhia0mm}2NC2{Mr
z`@giaE!yF&8l-39)38>%|CQV=H%3BH-?gr+N<L*i;NZ6Y`*ka;-Ivg}_}=B47~2_(
z_-_((3kyPD`B|qa+v^B}S~R(m8?nA~))hiL{sZ(BL+9=_5h_-WK2tAq8nTioA!_fp
z*6q9AHTR<K<0c-OqL?16>Q$GAZw;WS^`&<udE*U#u=eIe)AAQ4o7c5VU#`=9{g@z-
z+<B4rcyoAuJ+QcCgZc^;UVhY4>C<U-uYm&72TZRC&xAap7vP{ux1>;**p^r#!}MEn
zdgqN(3jrNwvO1wDVZhOYFuT=AZR>$sJDhuEEFp3`qOXHU!x>ijEc~<^fbyEW7N?Hk
z5A3_DB)A2S1qo`1N&&-0`XH@x&6!7^MimOUSfYNYy7nc7;oxJESvZv1iGi}F-jnHA
z0w!DI8+%3`q<KP3WBRZSmqnC;q&g@0HR1kGUV95bECNy-AwdJ=r5`F3Ou&Bo{Q2o>
zm&V6ONPM(+ApIUV*#Ze9n52DU3fVnTlp&Ief3C?AeXOw7xGbi{UD3w#jGL>hlDw)2
zjYL(GU(Nc$bM?U5(76}epGBiQGP_#6Lg)1BBRU~3-`7o*6uxen8#^S8y_#&)nVa!P
z<L#`4H))cYn-so~EpcdgoEO_&u+1oF(!DLU!J7PD8&|Mk5*~fXeSpH8X^G?ZO4=Uu
z%BInoX$0<k6k=i)G@Kjk|G|H}oW{MU>Q!`-#!8$#r0(;y(qUYzSy!!^Nr_W`5r0S8
z)f+lK8DE-^H8wFBX;Ix}Im%-S=X6$&`J4?4`p~nAQrmL=!!bkkx9V-ld_&V&U_1my
zI;Ew2&T)c~my({F5b>)3eWY!80xXxRaMRH+1A>7;DTb5G6pmIcfs&^yEVjEscS+J)
z3^}ex%4~JzN1_P=#AgBe9n*9PCL=1zAVMnSzK;;XAxb>u*Tp7^ErEpR@AE>=ofI}i
zas!{KyQp(=0}rFP&4e0)z=Jv<=I6MpksAl@cr9KunCF|N<dj=bSHaFY#pHX>O5!v=
zJaY5CbT}NDl8>NqR!y9E$JF~qu#r{2)u4TYc1c=La_LcKzAQJ&uEs6n6@3!RezETI
z%AT3>0Qwt|hmxk(1k)JdSMH_9?z`Gbe3YCu;w$}WN?e>^4SA`aNyX}}dF?5V0Y%g<
zSJAoD;Yghtp$pP2RI%xGlf$hXXSb3aik1ts>Ok*@2Pth$`Gwx44h>>svg)yO+z}Ni
z8Div-(%mPz+A#yAh0M?~t$@2mqUq*}_G1_%e(}cs!7*uW6YGjA=k!x65=nUb3xgGK
ztp^Ynx}B!ZZ>f#Fow)o^$GOt}8#U^Z_^N2sQ!9hba~OOcU>WTc{+kh3Z*9}%j_b#q
zmU{U$YBjq(o%_r)kxTu4Eww!<#i!VxH`%TtXbvRxV5$7FmbsU}W47>^_kJJWdU}6z
zijQg86~b1aZ9SRA@`;aJ3Sy-<Z`1z2|G~|@e8-)-130%O#8OR-Tbs{I*b{`*(b}!G
zakulT3+J=uo^<Va`;o1wSscCPcyIon1KiJ)@FTCE)ja-RqzZDovLzS38P_LN%oPwV
z<Z`;@0$wE5Q?BbjTm2I`P+NDebcwlmgPBk3@y{y-)<IBp&^Eal_&8B9^7tLwv4cCs
z*V&W*Mjvg_ab87eAHpt+;yq$>^Y9xY1O2qej}IUf!c(blZGGF|{*fKS3s}AyK<&!{
zEgCYnB+gg>aBOJZxb`(Yp-ZvaGF3G($+2z;XCZJU9|oiMAW!;u%wdUdC|lA52_bpq
zb=l8rplvvApyS6tuK&A{`E1CDrS*{{(0>+tx78%6*4P!r<?YF&SRdnmVHkBVk<^CK
z`T;)R)h1-L9-|~AGCoiYwCd`)r??(l`JuHU-!^AP|BLt9ZYEuS2k+OEn^u(~Z=kt)
zIB3uInilEjF8Ev@H5I1DoGtjgG8daa<CFjYH(|=Z@~ZzXTls(TyJga)k_@#idL<iD
Q$VW0UHv2L2hvUEe2Ry*9LI3~&

diff --git a/tools/demobench/demobench-initial.png b/tools/demobench/demobench-initial.png
index 27c2855e2c1a4b3dbdc6f214d6cdd121e99c9e54..d0e0b2f7db9e3398a5f6d01710bc7f4166acab41 100644
GIT binary patch
literal 53694
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
G{q=7;7uwYT

literal 43631
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
E0R)o^ZvX%Q

diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
index e2eeb63203..ef4e59d91a 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
@@ -54,7 +54,7 @@ class InstallFactory : Controller() {
     }
 
     private fun Config.parseExtraServices(path: String): MutableList<String> {
-        val services = serviceController.services.toSortedSet() + ServiceInfo(ServiceType.networkMap).toString()
+        val services = serviceController.services.values.toSortedSet() + ServiceInfo(ServiceType.networkMap).toString()
         return this.getStringList(path)
                 .filter { !it.isNullOrEmpty() }
                 .map { svc ->
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
index 798c3609e1..f6479308c2 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
@@ -24,6 +24,7 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
 
     private val jvm by inject<JVMConfig>()
     private val pluginController by inject<PluginController>()
+    private val serviceController by inject<ServiceController>()
 
     private var baseDir: Path = baseDirFor(ManagementFactory.getRuntimeMXBean().startTime)
     private val cordaPath: Path = jvm.applicationDir.resolve("corda").resolve("corda.jar")
@@ -63,7 +64,7 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
                 nodeData.rpcPort.value,
                 nodeData.webPort.value,
                 nodeData.h2Port.value,
-                nodeData.extraServices.toMutableList()
+                nodeData.extraServices.map { serviceController.services[it]!! }.toMutableList()
         )
 
         if (nodes.putIfAbsent(config.key, config) != null) {
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt
index cfd1c23038..2f63b8e1c0 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt
@@ -8,31 +8,37 @@ import java.util.logging.Level
 
 class ServiceController(resourceName: String = "/services.conf") : Controller() {
 
-    val services: List<String> = loadConf(resources.url(resourceName))
+    val services: Map<String, String> = loadConf(resources.url(resourceName))
 
-    val notaries: List<String> = services.filter { it.startsWith("corda.notary.") }.toList()
+    val notaries: Map<String, String> = services.filter { it.value.startsWith("corda.notary.") }
+
+    val issuers: Map<String, String> = services.filter { it.value.startsWith("corda.issuer.") }
 
     /*
      * Load our list of known extra Corda services.
      */
-    private fun loadConf(url: URL?): List<String> {
+    private fun loadConf(url: URL?): Map<String, String> {
         return if (url == null) {
-            emptyList()
+            emptyMap()
         } else {
             try {
-                val set = sortedSetOf<String>()
+                val map = linkedMapOf<String, String>()
                 InputStreamReader(url.openStream()).useLines { sq ->
                     sq.forEach { line ->
-                        val service = line.trim()
-                        set.add(service)
-
-                        log.info("Supports: $service")
+                        val service = line.split(":").map { it.trim() }
+                        if (service.size != 2) {
+                            log.warning("Encountered corrupted line '$line' while reading services from config: $url")
+                        }
+                        else {
+                            map[service[1]] = service[0]
+                            log.info("Supports: $service")
+                        }
                     }
+                    map
                 }
-                set.toList()
             } catch (e: IOException) {
                 log.log(Level.SEVERE, "Failed to load $url: ${e.message}", e)
-                emptyList<String>()
+                emptyMap<String, String>()
             }
         }
     }
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTabView.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTabView.kt
index 8f3ec2d19d..f36edea872 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTabView.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTabView.kt
@@ -5,6 +5,7 @@ import de.jensd.fx.glyphs.fontawesome.FontAwesomeIconView
 import de.jensd.fx.glyphs.fontawesome.utils.FontAwesomeIconFactory
 import javafx.application.Platform
 import javafx.beans.InvalidationListener
+import javafx.collections.ListChangeListener
 import javafx.geometry.Pos
 import javafx.scene.control.ComboBox
 import javafx.scene.image.Image
@@ -61,7 +62,7 @@ class NodeTabView : Fragment() {
     private val chooser = FileChooser()
 
     private val model = NodeDataModel()
-    private val availableServices: List<String> = if (nodeController.hasNetworkMap()) serviceController.services else serviceController.notaries
+    private val availableServices: List<String> = if (nodeController.hasNetworkMap()) serviceController.issuers.keys.toList() else serviceController.notaries.keys.toList()
 
     private val nodeTerminalView = find<NodeTerminalView>()
     private val nodeConfigView = stackpane {
@@ -109,7 +110,7 @@ class NodeTabView : Fragment() {
                     }
                 }
 
-                fieldset("Services") {
+                fieldset("Additional configuration") {
                     styleClass.addAll("services-panel")
 
                     val servicesList = CheckListView(availableServices.observable()).apply {
@@ -117,6 +118,17 @@ class NodeTabView : Fragment() {
                         model.item.extraServices.set(checkModel.checkedItems)
                         if (!nodeController.hasNetworkMap()) {
                             checkModel.check(0)
+                            checkModel.checkedItems.addListener(ListChangeListener { change ->
+                                while (change.next()) {
+                                    if (change.wasAdded()) {
+                                        val item = change.addedSubList.last()
+                                        val idx = checkModel.getItemIndex(item)
+                                        checkModel.checkedIndices.forEach {
+                                            if (it != idx) checkModel.clearCheck(it)
+                                        }
+                                    }
+                                }
+                            })
                         }
                     }
                     add(servicesList)
diff --git a/tools/demobench/src/main/resources/services.conf b/tools/demobench/src/main/resources/services.conf
index cb475c0ade..d8319ddccb 100644
--- a/tools/demobench/src/main/resources/services.conf
+++ b/tools/demobench/src/main/resources/services.conf
@@ -1,8 +1,6 @@
-corda.notary.validating
-corda.notary.simple
-corda.interest_rates
-corda.issuer.USD
-corda.issuer.GBP
-corda.issuer.CHF
-corda.issuer.EUR
-corda.cash
+corda.notary.validating : Validating Notary
+corda.notary.simple : Non-validating Notary
+corda.issuer.USD : Issuer USD
+corda.issuer.GBP : Issuer GBP
+corda.issuer.CHF : Issuer CHF
+corda.issuer.EUR : Issuer EUR
\ No newline at end of file
diff --git a/tools/demobench/src/test/kotlin/net/corda/demobench/model/ServiceControllerTest.kt b/tools/demobench/src/test/kotlin/net/corda/demobench/model/ServiceControllerTest.kt
index 629ee90903..f80f13b165 100644
--- a/tools/demobench/src/test/kotlin/net/corda/demobench/model/ServiceControllerTest.kt
+++ b/tools/demobench/src/test/kotlin/net/corda/demobench/model/ServiceControllerTest.kt
@@ -21,14 +21,14 @@ class ServiceControllerTest {
     fun `test duplicates`() {
         val controller = ServiceController("/duplicate-services.conf")
         assertNotNull(controller.services)
-        assertEquals(listOf("corda.example"), controller.services)
+        assertEquals(listOf("corda.example"), controller.services.map { it.value })
     }
 
     @Test
     fun `test notaries`() {
         val controller = ServiceController("/notary-services.conf")
         assertNotNull(controller.notaries)
-        assertEquals(listOf("corda.notary.simple"), controller.notaries)
+        assertEquals(listOf("corda.notary.simple"), controller.notaries.map { it.value })
     }
 
     @Test
diff --git a/tools/demobench/src/test/resources/duplicate-services.conf b/tools/demobench/src/test/resources/duplicate-services.conf
index ffa2ac0e33..f7faf80aed 100644
--- a/tools/demobench/src/test/resources/duplicate-services.conf
+++ b/tools/demobench/src/test/resources/duplicate-services.conf
@@ -1,3 +1,3 @@
-corda.example
-corda.example
-corda.example
+corda.example : Example
+corda.example : Example
+corda.example : Example
diff --git a/tools/demobench/src/test/resources/notary-services.conf b/tools/demobench/src/test/resources/notary-services.conf
index 5f833b04af..79c6835073 100644
--- a/tools/demobench/src/test/resources/notary-services.conf
+++ b/tools/demobench/src/test/resources/notary-services.conf
@@ -1,2 +1,2 @@
-corda.notary.simple
-corda.example
+corda.notary.simple : Notary Simple
+corda.example : Example

From 5e5f9d779031e72f08d6ff9cf6882331a83f7f02 Mon Sep 17 00:00:00 2001
From: Alberto Arri <30873160+al-r3@users.noreply.github.com>
Date: Thu, 28 Sep 2017 16:44:05 +0100
Subject: [PATCH 035/185] add message warning windows users they might need to
 manually kill explorer demo nodes started by gradle (#1717)

---
 docs/source/node-explorer.rst | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/docs/source/node-explorer.rst b/docs/source/node-explorer.rst
index 4fc1a53068..48c0a96088 100644
--- a/docs/source/node-explorer.rst
+++ b/docs/source/node-explorer.rst
@@ -73,6 +73,9 @@ Explorer login credentials to the Issuer nodes are defaulted to ``manager`` and
 Explorer login credentials to the Participants nodes are defaulted to ``user1`` and ``test``.
 Please note you are not allowed to login to the notary.
 
+.. note:: When you start the nodes in Windows using the command prompt, they might not be killed when you close the
+          window or terminate the task. If that happens you need to manually terminate the Java processes running the nodes.
+
 .. note:: Alternatively, you may start the demo nodes from within IntelliJ using either of the run configurations
           ``Explorer - demo nodes`` or ``Explorer - demo nodes (simulation)``
 

From 2aaeb4c0b5761f7c0b81537d52476b8ecfd55c9d Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Thu, 28 Sep 2017 17:12:21 +0100
Subject: [PATCH 036/185] CORDA-652: Remove uses of `createSomeNodes` for
 consistency (#1492)

Replace use of `createSomeNodes()` with creating notary and party nodes individually. This typically results in less code as the basket of nodes isn't built first then the nodes, but instead the nodes generated directly. Notably this identified issues in notary change and contract upgrade tests, which were not actually using a validating notary and therefore it had been missed that the transactions were failing validation.

Renamed nodes in tests for consistency as well, so nodes are now `aliceNode`, `bobNode`, etc. instead of `a`, `b`, or `n0`, `n1`, or other variants of those.
---
 .../confidential/IdentitySyncFlowTests.kt     |   2 +-
 .../confidential/SwapIdentitiesFlowTests.kt   |   2 +-
 .../net/corda/core/flows/FlowsInJavaTest.java |  22 ++--
 .../net/corda/core/flows/AttachmentTests.kt   |  68 +++++------
 .../core/flows/CollectSignaturesFlowTests.kt  |  56 +++++----
 .../core/flows/ContractUpgradeFlowTest.kt     |  70 +++++------
 .../net/corda/core/flows/FinalityFlowTests.kt |  42 +++----
 .../internal/ResolveTransactionsFlowTest.kt   | 112 +++++++++---------
 .../corda/finance/flows/CashExitFlowTests.kt  |  11 +-
 .../corda/finance/flows/CashIssueFlowTests.kt |  10 +-
 .../finance/flows/CashPaymentFlowTests.kt     |   5 +-
 .../node/messaging/TwoPartyTradeFlowTests.kt  |  22 ++--
 .../services/network/NetworkMapCacheTest.kt   |  54 ++++-----
 .../kotlin/net/corda/testing/node/MockNode.kt |  30 +----
 14 files changed, 238 insertions(+), 268 deletions(-)

diff --git a/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt b/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
index f2907c7c7c..1fe89e43ec 100644
--- a/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
+++ b/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
@@ -40,7 +40,7 @@ class IdentitySyncFlowTests {
     @Test
     fun `sync confidential identities`() {
         // Set up values we'll need
-        val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name)
+        val notaryNode = mockNet.createNotaryNode()
         val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
         val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
         val alice: Party = aliceNode.services.myInfo.chooseIdentity()
diff --git a/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt b/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
index 684cd92c82..202da9412e 100644
--- a/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
+++ b/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
@@ -22,7 +22,7 @@ class SwapIdentitiesFlowTests {
         val mockNet = MockNetwork(false, true)
 
         // Set up values we'll need
-        val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name)
+        val notaryNode = mockNet.createNotaryNode()
         val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
         val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
         val alice: Party = aliceNode.services.myInfo.chooseIdentity()
diff --git a/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java b/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java
index 01855fb5e3..ff30e6547d 100644
--- a/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java
+++ b/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java
@@ -5,6 +5,7 @@ import com.google.common.primitives.Primitives;
 import net.corda.core.identity.Party;
 import net.corda.node.internal.StartedNode;
 import net.corda.testing.node.MockNetwork;
+import net.corda.testing.TestConstants;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -19,17 +20,18 @@ import static org.junit.Assert.fail;
 public class FlowsInJavaTest {
 
     private final MockNetwork mockNet = new MockNetwork();
-    private StartedNode<MockNetwork.MockNode> node1;
-    private StartedNode<MockNetwork.MockNode> node2;
+    private StartedNode<MockNetwork.MockNode> notaryNode;
+    private StartedNode<MockNetwork.MockNode> aliceNode;
+    private StartedNode<MockNetwork.MockNode> bobNode;
 
     @Before
     public void setUp() throws Exception {
-        MockNetwork.BasketOfNodes someNodes = mockNet.createSomeNodes(2);
-        node1 = someNodes.getPartyNodes().get(0);
-        node2 = someNodes.getPartyNodes().get(1);
+        notaryNode = mockNet.createNotaryNode();
+        aliceNode = mockNet.createPartyNode(notaryNode.getNetwork().getMyAddress(), TestConstants.getALICE().getName());
+        bobNode = mockNet.createPartyNode(notaryNode.getNetwork().getMyAddress(), TestConstants.getBOB().getName());
         mockNet.runNetwork();
         // Ensure registration was successful
-        node1.getInternals().getNodeReadyFuture().get();
+        aliceNode.getInternals().getNodeReadyFuture().get();
     }
 
     @After
@@ -39,8 +41,8 @@ public class FlowsInJavaTest {
 
     @Test
     public void suspendableActionInsideUnwrap() throws Exception {
-        node2.getInternals().registerInitiatedFlow(SendHelloAndThenReceive.class);
-        Future<String> result = node1.getServices().startFlow(new SendInUnwrapFlow(chooseIdentity(node2.getInfo()))).getResultFuture();
+        bobNode.getInternals().registerInitiatedFlow(SendHelloAndThenReceive.class);
+        Future<String> result = aliceNode.getServices().startFlow(new SendInUnwrapFlow(chooseIdentity(bobNode.getInfo()))).getResultFuture();
         mockNet.runNetwork();
         assertThat(result.get()).isEqualTo("Hello");
     }
@@ -55,8 +57,8 @@ public class FlowsInJavaTest {
     }
 
     private void primitiveReceiveTypeTest(Class<?> receiveType) throws InterruptedException {
-        PrimitiveReceiveFlow flow = new PrimitiveReceiveFlow(chooseIdentity(node2.getInfo()), receiveType);
-        Future<?> result = node1.getServices().startFlow(flow).getResultFuture();
+        PrimitiveReceiveFlow flow = new PrimitiveReceiveFlow(chooseIdentity(bobNode.getInfo()), receiveType);
+        Future<?> result = aliceNode.getServices().startFlow(flow).getResultFuture();
         mockNet.runNetwork();
         try {
             result.get();
diff --git a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
index 5a61e01605..dd5f1e6783 100644
--- a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
@@ -10,12 +10,14 @@ import net.corda.core.internal.FetchDataFlow
 import net.corda.core.messaging.SingleMessageRecipient
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.persistence.NodeAttachmentService
 import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.node.utilities.DatabaseTransactionManager
+import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.testing.ALICE
+import net.corda.testing.BOB
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.MockNetwork
 import org.junit.After
@@ -55,68 +57,68 @@ class AttachmentTests {
 
     @Test
     fun `download and store`() {
-        val nodes = mockNet.createSomeNodes(2)
-        val n0 = nodes.partyNodes[0]
-        val n1 = nodes.partyNodes[1]
+        val notaryNode = mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+        val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
 
         // Ensure that registration was successful before progressing any further
         mockNet.runNetwork()
-        n0.internals.ensureRegistered()
+        aliceNode.internals.ensureRegistered()
 
-        n0.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
-        n1.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
+        aliceNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
+        bobNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
 
         // Insert an attachment into node zero's store directly.
-        val id = n0.database.transaction {
-            n0.attachments.importAttachment(ByteArrayInputStream(fakeAttachment()))
+        val id = aliceNode.database.transaction {
+            aliceNode.attachments.importAttachment(ByteArrayInputStream(fakeAttachment()))
         }
 
         // Get node one to run a flow to fetch it and insert it.
         mockNet.runNetwork()
-        val f1 = n1.startAttachmentFlow(setOf(id), n0.info.chooseIdentity())
+        val bobFlow = bobNode.startAttachmentFlow(setOf(id), aliceNode.info.chooseIdentity())
         mockNet.runNetwork()
-        assertEquals(0, f1.resultFuture.getOrThrow().fromDisk.size)
+        assertEquals(0, bobFlow.resultFuture.getOrThrow().fromDisk.size)
 
         // Verify it was inserted into node one's store.
-        val attachment = n1.database.transaction {
-            n1.attachments.openAttachment(id)!!
+        val attachment = bobNode.database.transaction {
+            bobNode.attachments.openAttachment(id)!!
         }
 
         assertEquals(id, attachment.open().readBytes().sha256())
 
         // Shut down node zero and ensure node one can still resolve the attachment.
-        n0.dispose()
+        aliceNode.dispose()
 
-        val response: FetchDataFlow.Result<Attachment> = n1.startAttachmentFlow(setOf(id), n0.info.chooseIdentity()).resultFuture.getOrThrow()
+        val response: FetchDataFlow.Result<Attachment> = bobNode.startAttachmentFlow(setOf(id), aliceNode.info.chooseIdentity()).resultFuture.getOrThrow()
         assertEquals(attachment, response.fromDisk[0])
     }
 
     @Test
     fun `missing`() {
-        val nodes = mockNet.createSomeNodes(2)
-        val n0 = nodes.partyNodes[0]
-        val n1 = nodes.partyNodes[1]
+        val notaryNode = mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+        val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
 
         // Ensure that registration was successful before progressing any further
         mockNet.runNetwork()
-        n0.internals.ensureRegistered()
+        aliceNode.internals.ensureRegistered()
 
-        n0.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
-        n1.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
+        aliceNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
+        bobNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
 
         // Get node one to fetch a non-existent attachment.
         val hash = SecureHash.randomSHA256()
         mockNet.runNetwork()
-        val f1 = n1.startAttachmentFlow(setOf(hash), n0.info.chooseIdentity())
+        val bobFlow = bobNode.startAttachmentFlow(setOf(hash), aliceNode.info.chooseIdentity())
         mockNet.runNetwork()
-        val e = assertFailsWith<FetchDataFlow.HashNotFound> { f1.resultFuture.getOrThrow() }
+        val e = assertFailsWith<FetchDataFlow.HashNotFound> { bobFlow.resultFuture.getOrThrow() }
         assertEquals(hash, e.requested)
     }
 
     @Test
     fun `malicious response`() {
         // Make a node that doesn't do sanity checking at load time.
-        val n0 = mockNet.createNode(nodeFactory = object : MockNetwork.Factory<MockNetwork.MockNode> {
+        val aliceNode = mockNet.createNode(legalName = ALICE.name, nodeFactory = object : MockNetwork.Factory<MockNetwork.MockNode> {
             override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
                                 advertisedServices: Set<ServiceInfo>, id: Int,
                                 overrideServices: Map<ServiceInfo, KeyPair>?,
@@ -126,19 +128,19 @@ class AttachmentTests {
                 }
             }
         }, advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(SimpleNotaryService.type)))
-        val n1 = mockNet.createNode(n0.network.myAddress)
+        val bobNode = mockNet.createNode(aliceNode.network.myAddress, legalName = BOB.name)
 
         // Ensure that registration was successful before progressing any further
         mockNet.runNetwork()
-        n0.internals.ensureRegistered()
+        aliceNode.internals.ensureRegistered()
 
-        n0.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
-        n1.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
+        aliceNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
+        bobNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
 
         val attachment = fakeAttachment()
         // Insert an attachment into node zero's store directly.
-        val id = n0.database.transaction {
-            n0.attachments.importAttachment(ByteArrayInputStream(attachment))
+        val id = aliceNode.database.transaction {
+            aliceNode.attachments.importAttachment(ByteArrayInputStream(attachment))
         }
 
         // Corrupt its store.
@@ -146,15 +148,15 @@ class AttachmentTests {
         System.arraycopy(corruptBytes, 0, attachment, 0, corruptBytes.size)
 
         val corruptAttachment = NodeAttachmentService.DBAttachment(attId = id.toString(), content = attachment)
-        n0.database.transaction {
+        aliceNode.database.transaction {
             DatabaseTransactionManager.current().session.update(corruptAttachment)
         }
 
         // Get n1 to fetch the attachment. Should receive corrupted bytes.
         mockNet.runNetwork()
-        val f1 = n1.startAttachmentFlow(setOf(id), n0.info.chooseIdentity())
+        val bobFlow = bobNode.startAttachmentFlow(setOf(id), aliceNode.info.chooseIdentity())
         mockNet.runNetwork()
-        assertFailsWith<FetchDataFlow.DownloadedVsRequestedDataMismatch> { f1.resultFuture.getOrThrow() }
+        assertFailsWith<FetchDataFlow.DownloadedVsRequestedDataMismatch> { bobFlow.resultFuture.getOrThrow() }
     }
 
     private fun StartedNode<*>.startAttachmentFlow(hashes: Set<SecureHash>, otherSide: Party) = services.startFlow(InitiatingFetchAttachmentsFlow(otherSide, hashes))
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 6ea86cd6a3..8a913d5983 100644
--- a/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
@@ -24,24 +24,22 @@ import kotlin.test.assertFailsWith
 
 class CollectSignaturesFlowTests {
     lateinit var mockNet: MockNetwork
-    lateinit var a: StartedNode<MockNetwork.MockNode>
-    lateinit var b: StartedNode<MockNetwork.MockNode>
-    lateinit var c: StartedNode<MockNetwork.MockNode>
+    lateinit var aliceNode: StartedNode<MockNetwork.MockNode>
+    lateinit var bobNode: StartedNode<MockNetwork.MockNode>
+    lateinit var charlieNode: StartedNode<MockNetwork.MockNode>
     lateinit var notary: Party
-    lateinit var services: MockServices
 
     @Before
     fun setup() {
         setCordappPackages("net.corda.testing.contracts")
-        services = MockServices()
         mockNet = MockNetwork()
-        val nodes = mockNet.createSomeNodes(3)
-        a = nodes.partyNodes[0]
-        b = nodes.partyNodes[1]
-        c = nodes.partyNodes[2]
+        val notaryNode = mockNet.createNotaryNode()
+        aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+        bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
+        charlieNode = mockNet.createPartyNode(notaryNode.network.myAddress, CHARLIE.name)
         mockNet.runNetwork()
-        notary = a.services.getDefaultNotary()
-        a.internals.ensureRegistered()
+        notary = notaryNode.services.getDefaultNotary()
+        aliceNode.internals.ensureRegistered()
     }
 
     @After
@@ -51,7 +49,7 @@ class CollectSignaturesFlowTests {
     }
 
     private fun registerFlowOnAllNodes(flowClass: KClass<out FlowLogic<*>>) {
-        listOf(a, b, c).forEach {
+        listOf(aliceNode, bobNode, charlieNode).forEach {
             it.internals.registerInitiatedFlow(flowClass.java)
         }
     }
@@ -142,18 +140,18 @@ class CollectSignaturesFlowTests {
 
     @Test
     fun `successfully collects two signatures`() {
-        val bConfidentialIdentity = b.database.transaction {
-            b.services.keyManagementService.freshKeyAndCert(b.info.chooseIdentityAndCert(), false)
+        val bConfidentialIdentity = bobNode.database.transaction {
+            bobNode.services.keyManagementService.freshKeyAndCert(bobNode.info.chooseIdentityAndCert(), false)
         }
-        a.database.transaction {
+        aliceNode.database.transaction {
             // Normally this is handled by TransactionKeyFlow, but here we have to manually let A know about the identity
-            a.services.identityService.verifyAndRegisterIdentity(bConfidentialIdentity)
+            aliceNode.services.identityService.verifyAndRegisterIdentity(bConfidentialIdentity)
         }
         registerFlowOnAllNodes(TestFlowTwo.Responder::class)
         val magicNumber = 1337
-        val parties = listOf(a.info.chooseIdentity(), bConfidentialIdentity.party, c.info.chooseIdentity())
+        val parties = listOf(aliceNode.info.chooseIdentity(), bConfidentialIdentity.party, charlieNode.info.chooseIdentity())
         val state = DummyContract.MultiOwnerState(magicNumber, parties)
-        val flow = a.services.startFlow(TestFlowTwo.Initiator(state))
+        val flow = aliceNode.services.startFlow(TestFlowTwo.Initiator(state))
         mockNet.runNetwork()
         val result = flow.resultFuture.getOrThrow()
         result.verifyRequiredSignatures()
@@ -163,9 +161,9 @@ class CollectSignaturesFlowTests {
 
     @Test
     fun `no need to collect any signatures`() {
-        val onePartyDummyContract = DummyContract.generateInitial(1337, notary, a.info.chooseIdentity().ref(1))
-        val ptx = a.services.signInitialTransaction(onePartyDummyContract)
-        val flow = a.services.startFlow(CollectSignaturesFlow(ptx, emptySet()))
+        val onePartyDummyContract = DummyContract.generateInitial(1337, notary, aliceNode.info.chooseIdentity().ref(1))
+        val ptx = aliceNode.services.signInitialTransaction(onePartyDummyContract)
+        val flow = aliceNode.services.startFlow(CollectSignaturesFlow(ptx, emptySet()))
         mockNet.runNetwork()
         val result = flow.resultFuture.getOrThrow()
         result.verifyRequiredSignatures()
@@ -175,10 +173,10 @@ class CollectSignaturesFlowTests {
 
     @Test
     fun `fails when not signed by initiator`() {
-        val onePartyDummyContract = DummyContract.generateInitial(1337, notary, a.info.chooseIdentity().ref(1))
+        val onePartyDummyContract = DummyContract.generateInitial(1337, notary, aliceNode.info.chooseIdentity().ref(1))
         val miniCorpServices = MockServices(MINI_CORP_KEY)
         val ptx = miniCorpServices.signInitialTransaction(onePartyDummyContract)
-        val flow = a.services.startFlow(CollectSignaturesFlow(ptx, emptySet()))
+        val flow = aliceNode.services.startFlow(CollectSignaturesFlow(ptx, emptySet()))
         mockNet.runNetwork()
         assertFailsWith<IllegalArgumentException>("The Initiator of CollectSignaturesFlow must have signed the transaction.") {
             flow.resultFuture.getOrThrow()
@@ -188,12 +186,12 @@ class CollectSignaturesFlowTests {
     @Test
     fun `passes with multiple initial signatures`() {
         val twoPartyDummyContract = DummyContract.generateInitial(1337, notary,
-                a.info.chooseIdentity().ref(1),
-                b.info.chooseIdentity().ref(2),
-                b.info.chooseIdentity().ref(3))
-        val signedByA = a.services.signInitialTransaction(twoPartyDummyContract)
-        val signedByBoth = b.services.addSignature(signedByA)
-        val flow = a.services.startFlow(CollectSignaturesFlow(signedByBoth, emptySet()))
+                aliceNode.info.chooseIdentity().ref(1),
+                bobNode.info.chooseIdentity().ref(2),
+                bobNode.info.chooseIdentity().ref(3))
+        val signedByA = aliceNode.services.signInitialTransaction(twoPartyDummyContract)
+        val signedByBoth = bobNode.services.addSignature(signedByA)
+        val flow = aliceNode.services.startFlow(CollectSignaturesFlow(signedByBoth, emptySet()))
         mockNet.runNetwork()
         val result = flow.resultFuture.getOrThrow()
         println(result.tx)
diff --git a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
index 042e185472..18a422441a 100644
--- a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
@@ -34,8 +34,8 @@ import kotlin.test.assertTrue
 
 class ContractUpgradeFlowTest {
     lateinit var mockNet: MockNetwork
-    lateinit var a: StartedNode<MockNetwork.MockNode>
-    lateinit var b: StartedNode<MockNetwork.MockNode>
+    lateinit var aliceNode: StartedNode<MockNetwork.MockNode>
+    lateinit var bobNode: StartedNode<MockNetwork.MockNode>
     lateinit var notary: Party
 
     @Before
@@ -43,12 +43,12 @@ class ContractUpgradeFlowTest {
         setCordappPackages("net.corda.testing.contracts", "net.corda.finance.contracts.asset", "net.corda.core.flows")
         mockNet = MockNetwork()
         val notaryNode = mockNet.createNotaryNode()
-        a = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-        b = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
+        aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+        bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
 
         // Process registration
         mockNet.runNetwork()
-        a.internals.ensureRegistered()
+        aliceNode.internals.ensureRegistered()
 
         notary = notaryNode.services.getDefaultNotary()
     }
@@ -62,37 +62,37 @@ class ContractUpgradeFlowTest {
     @Test
     fun `2 parties contract upgrade`() {
         // Create dummy contract.
-        val twoPartyDummyContract = DummyContract.generateInitial(0, notary, a.info.chooseIdentity().ref(1), b.info.chooseIdentity().ref(1))
-        val signedByA = a.services.signInitialTransaction(twoPartyDummyContract)
-        val stx = b.services.addSignature(signedByA)
+        val twoPartyDummyContract = DummyContract.generateInitial(0, notary, aliceNode.info.chooseIdentity().ref(1), bobNode.info.chooseIdentity().ref(1))
+        val signedByA = aliceNode.services.signInitialTransaction(twoPartyDummyContract)
+        val stx = bobNode.services.addSignature(signedByA)
 
-        a.services.startFlow(FinalityFlow(stx, setOf(b.info.chooseIdentity())))
+        aliceNode.services.startFlow(FinalityFlow(stx, setOf(bobNode.info.chooseIdentity())))
         mockNet.runNetwork()
 
-        val atx = a.database.transaction { a.services.validatedTransactions.getTransaction(stx.id) }
-        val btx = b.database.transaction { b.services.validatedTransactions.getTransaction(stx.id) }
+        val atx = aliceNode.database.transaction { aliceNode.services.validatedTransactions.getTransaction(stx.id) }
+        val btx = bobNode.database.transaction { bobNode.services.validatedTransactions.getTransaction(stx.id) }
         requireNotNull(atx)
         requireNotNull(btx)
 
         // The request is expected to be rejected because party B hasn't authorised the upgrade yet.
-        val rejectedFuture = a.services.startFlow(ContractUpgradeFlow.Initiate(atx!!.tx.outRef(0), DummyContractV2::class.java)).resultFuture
+        val rejectedFuture = aliceNode.services.startFlow(ContractUpgradeFlow.Initiate(atx!!.tx.outRef(0), DummyContractV2::class.java)).resultFuture
         mockNet.runNetwork()
         assertFailsWith(UnexpectedFlowEndException::class) { rejectedFuture.getOrThrow() }
 
         // Party B authorise the contract state upgrade, and immediately deauthorise the same.
-        b.services.startFlow(ContractUpgradeFlow.Authorise(btx!!.tx.outRef<ContractState>(0), DummyContractV2::class.java)).resultFuture.getOrThrow()
-        b.services.startFlow(ContractUpgradeFlow.Deauthorise(btx.tx.outRef<ContractState>(0).ref)).resultFuture.getOrThrow()
+        bobNode.services.startFlow(ContractUpgradeFlow.Authorise(btx!!.tx.outRef<ContractState>(0), DummyContractV2::class.java)).resultFuture.getOrThrow()
+        bobNode.services.startFlow(ContractUpgradeFlow.Deauthorise(btx.tx.outRef<ContractState>(0).ref)).resultFuture.getOrThrow()
 
         // The request is expected to be rejected because party B has subsequently deauthorised and a previously authorised upgrade.
-        val deauthorisedFuture = a.services.startFlow(ContractUpgradeFlow.Initiate(atx.tx.outRef(0), DummyContractV2::class.java)).resultFuture
+        val deauthorisedFuture = aliceNode.services.startFlow(ContractUpgradeFlow.Initiate(atx.tx.outRef(0), DummyContractV2::class.java)).resultFuture
         mockNet.runNetwork()
         assertFailsWith(UnexpectedFlowEndException::class) { deauthorisedFuture.getOrThrow() }
 
         // Party B authorise the contract state upgrade
-        b.services.startFlow(ContractUpgradeFlow.Authorise(btx.tx.outRef<ContractState>(0), DummyContractV2::class.java)).resultFuture.getOrThrow()
+        bobNode.services.startFlow(ContractUpgradeFlow.Authorise(btx.tx.outRef<ContractState>(0), DummyContractV2::class.java)).resultFuture.getOrThrow()
 
         // Party A initiates contract upgrade flow, expected to succeed this time.
-        val resultFuture = a.services.startFlow(ContractUpgradeFlow.Initiate(atx.tx.outRef(0), DummyContractV2::class.java)).resultFuture
+        val resultFuture = aliceNode.services.startFlow(ContractUpgradeFlow.Initiate(atx.tx.outRef(0), DummyContractV2::class.java)).resultFuture
         mockNet.runNetwork()
 
         val result = resultFuture.getOrThrow()
@@ -113,8 +113,8 @@ class ContractUpgradeFlowTest {
             // Verify outputs.
             assertTrue(nodeStx!!.tx.outputs.single().data is DummyContractV2.State)
         }
-        check(a)
-        check(b)
+        check(aliceNode)
+        check(bobNode)
     }
 
     private fun RPCDriverExposedDSLInterface.startProxy(node: StartedNode<*>, user: User): CordaRPCOps {
@@ -132,9 +132,9 @@ class ContractUpgradeFlowTest {
     fun `2 parties contract upgrade using RPC`() {
         rpcDriver(initialiseSerialization = false) {
             // Create dummy contract.
-            val twoPartyDummyContract = DummyContract.generateInitial(0, notary, a.info.chooseIdentity().ref(1), b.info.chooseIdentity().ref(1))
-            val signedByA = a.services.signInitialTransaction(twoPartyDummyContract)
-            val stx = b.services.addSignature(signedByA)
+            val twoPartyDummyContract = DummyContract.generateInitial(0, notary, aliceNode.info.chooseIdentity().ref(1), bobNode.info.chooseIdentity().ref(1))
+            val signedByA = aliceNode.services.signInitialTransaction(twoPartyDummyContract)
+            val stx = bobNode.services.addSignature(signedByA)
 
             val user = rpcTestUser.copy(permissions = setOf(
                     startFlowPermission<FinalityInvoker>(),
@@ -142,14 +142,14 @@ class ContractUpgradeFlowTest {
                     startFlowPermission<ContractUpgradeFlow.Authorise>(),
                     startFlowPermission<ContractUpgradeFlow.Deauthorise>()
             ))
-            val rpcA = startProxy(a, user)
-            val rpcB = startProxy(b, user)
-            val handle = rpcA.startFlow(::FinalityInvoker, stx, setOf(b.info.chooseIdentity()))
+            val rpcA = startProxy(aliceNode, user)
+            val rpcB = startProxy(bobNode, user)
+            val handle = rpcA.startFlow(::FinalityInvoker, stx, setOf(bobNode.info.chooseIdentity()))
             mockNet.runNetwork()
             handle.returnValue.getOrThrow()
 
-            val atx = a.database.transaction { a.services.validatedTransactions.getTransaction(stx.id) }
-            val btx = b.database.transaction { b.services.validatedTransactions.getTransaction(stx.id) }
+            val atx = aliceNode.database.transaction { aliceNode.services.validatedTransactions.getTransaction(stx.id) }
+            val btx = bobNode.database.transaction { bobNode.services.validatedTransactions.getTransaction(stx.id) }
             requireNotNull(atx)
             requireNotNull(btx)
 
@@ -188,12 +188,12 @@ class ContractUpgradeFlowTest {
             mockNet.runNetwork()
             val result = resultFuture.getOrThrow()
             // Check results.
-            listOf(a, b).forEach {
-                val signedTX = a.database.transaction { a.services.validatedTransactions.getTransaction(result.ref.txhash) }
+            listOf(aliceNode, bobNode).forEach {
+                val signedTX = aliceNode.database.transaction { aliceNode.services.validatedTransactions.getTransaction(result.ref.txhash) }
                 requireNotNull(signedTX)
 
                 // Verify inputs.
-                val input = a.database.transaction { a.services.validatedTransactions.getTransaction(signedTX!!.tx.inputs.single().txhash) }
+                val input = aliceNode.database.transaction { aliceNode.services.validatedTransactions.getTransaction(signedTX!!.tx.inputs.single().txhash) }
                 requireNotNull(input)
                 assertTrue(input!!.tx.outputs.single().data is DummyContract.State)
 
@@ -206,20 +206,20 @@ class ContractUpgradeFlowTest {
     @Test
     fun `upgrade Cash to v2`() {
         // Create some cash.
-        val chosenIdentity = a.info.chooseIdentity()
-        val result = a.services.startFlow(CashIssueFlow(Amount(1000, USD), OpaqueBytes.of(1), notary)).resultFuture
+        val chosenIdentity = aliceNode.info.chooseIdentity()
+        val result = aliceNode.services.startFlow(CashIssueFlow(Amount(1000, USD), OpaqueBytes.of(1), notary)).resultFuture
         mockNet.runNetwork()
         val stx = result.getOrThrow().stx
         val anonymisedRecipient = result.get().recipient!!
         val stateAndRef = stx.tx.outRef<Cash.State>(0)
-        val baseState = a.database.transaction { a.services.vaultService.queryBy<ContractState>().states.single() }
+        val baseState = aliceNode.database.transaction { aliceNode.services.vaultService.queryBy<ContractState>().states.single() }
         assertTrue(baseState.state.data is Cash.State, "Contract state is old version.")
         // Starts contract upgrade flow.
-        val upgradeResult = a.services.startFlow(ContractUpgradeFlow.Initiate(stateAndRef, CashV2::class.java)).resultFuture
+        val upgradeResult = aliceNode.services.startFlow(ContractUpgradeFlow.Initiate(stateAndRef, CashV2::class.java)).resultFuture
         mockNet.runNetwork()
         upgradeResult.getOrThrow()
         // Get contract state from the vault.
-        val firstState = a.database.transaction { a.services.vaultService.queryBy<ContractState>().states.single() }
+        val firstState = aliceNode.database.transaction { aliceNode.services.vaultService.queryBy<ContractState>().states.single() }
         assertTrue(firstState.state.data is CashV2.State, "Contract state is upgraded to the new version.")
         assertEquals(Amount(1000000, USD).`issued by`(chosenIdentity.ref(1)), (firstState.state.data as CashV2.State).amount, "Upgraded cash contain the correct amount.")
         assertEquals<Collection<AbstractParty>>(listOf(anonymisedRecipient), (firstState.state.data as CashV2.State).owners, "Upgraded cash belongs to the right owner.")
diff --git a/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt b/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
index 865026c958..0d38513c25 100644
--- a/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
@@ -7,13 +7,8 @@ import net.corda.finance.POUNDS
 import net.corda.finance.contracts.asset.Cash
 import net.corda.finance.issuedBy
 import net.corda.node.internal.StartedNode
-import net.corda.testing.ALICE
-import net.corda.testing.chooseIdentity
-import net.corda.testing.getDefaultNotary
+import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
-import net.corda.testing.node.MockServices
-import net.corda.testing.setCordappPackages
-import net.corda.testing.unsetCordappPackages
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -22,21 +17,20 @@ import kotlin.test.assertFailsWith
 
 class FinalityFlowTests {
     lateinit var mockNet: MockNetwork
-    lateinit var nodeA: StartedNode<MockNetwork.MockNode>
-    lateinit var nodeB: StartedNode<MockNetwork.MockNode>
+    lateinit var aliceNode: StartedNode<MockNetwork.MockNode>
+    lateinit var bobNode: StartedNode<MockNetwork.MockNode>
     lateinit var notary: Party
-    val services = MockServices()
 
     @Before
     fun setup() {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork()
-        val nodes = mockNet.createSomeNodes(2)
-        nodeA = nodes.partyNodes[0]
-        nodeB = nodes.partyNodes[1]
+        val notaryNode = mockNet.createNotaryNode()
+        aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+        bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
         mockNet.runNetwork()
-        nodeA.internals.ensureRegistered()
-        notary = nodeA.services.getDefaultNotary()
+        aliceNode.internals.ensureRegistered()
+        notary = aliceNode.services.getDefaultNotary()
     }
 
     @After
@@ -47,28 +41,28 @@ class FinalityFlowTests {
 
     @Test
     fun `finalise a simple transaction`() {
-        val amount = 1000.POUNDS.issuedBy(nodeA.info.chooseIdentity().ref(0))
+        val amount = 1000.POUNDS.issuedBy(aliceNode.info.chooseIdentity().ref(0))
         val builder = TransactionBuilder(notary)
-        Cash().generateIssue(builder, amount, nodeB.info.chooseIdentity(), notary)
-        val stx = nodeA.services.signInitialTransaction(builder)
-        val flow = nodeA.services.startFlow(FinalityFlow(stx))
+        Cash().generateIssue(builder, amount, bobNode.info.chooseIdentity(), notary)
+        val stx = aliceNode.services.signInitialTransaction(builder)
+        val flow = aliceNode.services.startFlow(FinalityFlow(stx))
         mockNet.runNetwork()
         val notarisedTx = flow.resultFuture.getOrThrow()
         notarisedTx.verifyRequiredSignatures()
-        val transactionSeenByB = nodeB.services.database.transaction {
-            nodeB.services.validatedTransactions.getTransaction(notarisedTx.id)
+        val transactionSeenByB = bobNode.services.database.transaction {
+            bobNode.services.validatedTransactions.getTransaction(notarisedTx.id)
         }
         assertEquals(notarisedTx, transactionSeenByB)
     }
 
     @Test
     fun `reject a transaction with unknown parties`() {
-        val amount = 1000.POUNDS.issuedBy(nodeA.info.chooseIdentity().ref(0))
-        val fakeIdentity = ALICE // Alice isn't part of this network, so node A won't recognise them
+        val amount = 1000.POUNDS.issuedBy(aliceNode.info.chooseIdentity().ref(0))
+        val fakeIdentity = CHARLIE // Charlie isn't part of this network, so node A won't recognise them
         val builder = TransactionBuilder(notary)
         Cash().generateIssue(builder, amount, fakeIdentity, notary)
-        val stx = nodeA.services.signInitialTransaction(builder)
-        val flow = nodeA.services.startFlow(FinalityFlow(stx))
+        val stx = aliceNode.services.signInitialTransaction(builder)
+        val flow = aliceNode.services.startFlow(FinalityFlow(stx))
         mockNet.runNetwork()
         assertFailsWith<IllegalArgumentException> {
             flow.resultFuture.getOrThrow()
diff --git a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
index c5762a136e..1576852791 100644
--- a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
@@ -12,7 +12,6 @@ import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.getDefaultNotary
 import net.corda.testing.node.MockNetwork
-import net.corda.testing.node.MockServices
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -27,25 +26,26 @@ import kotlin.test.assertNull
 
 class ResolveTransactionsFlowTest {
     lateinit var mockNet: MockNetwork
-    lateinit var a: StartedNode<MockNetwork.MockNode>
-    lateinit var b: StartedNode<MockNetwork.MockNode>
+    lateinit var notaryNode: StartedNode<MockNetwork.MockNode>
+    lateinit var megaCorpNode: StartedNode<MockNetwork.MockNode>
+    lateinit var miniCorpNode: StartedNode<MockNetwork.MockNode>
+    lateinit var megaCorp: Party
+    lateinit var miniCorp: Party
     lateinit var notary: Party
-    lateinit var megaCorpServices: MockServices
-    lateinit var notaryServices: MockServices
 
     @Before
     fun setup() {
         setCordappPackages("net.corda.testing.contracts")
-        megaCorpServices = MockServices(MEGA_CORP_KEY)
-        notaryServices = MockServices(DUMMY_NOTARY_KEY)
         mockNet = MockNetwork()
-        val nodes = mockNet.createSomeNodes()
-        a = nodes.partyNodes[0]
-        b = nodes.partyNodes[1]
-        a.internals.registerInitiatedFlow(TestResponseFlow::class.java)
-        b.internals.registerInitiatedFlow(TestResponseFlow::class.java)
+        notaryNode = mockNet.createNotaryNode()
+        megaCorpNode = mockNet.createPartyNode(notaryNode.network.myAddress, MEGA_CORP.name)
+        miniCorpNode = mockNet.createPartyNode(notaryNode.network.myAddress, MINI_CORP.name)
+        megaCorpNode.internals.registerInitiatedFlow(TestResponseFlow::class.java)
+        miniCorpNode.internals.registerInitiatedFlow(TestResponseFlow::class.java)
         mockNet.runNetwork()
-        notary = a.services.getDefaultNotary()
+        notary = notaryNode.services.getDefaultNotary()
+        megaCorp = megaCorpNode.info.chooseIdentity()
+        miniCorp = miniCorpNode.info.chooseIdentity()
     }
 
     @After
@@ -58,14 +58,14 @@ class ResolveTransactionsFlowTest {
     @Test
     fun `resolve from two hashes`() {
         val (stx1, stx2) = makeTransactions()
-        val p = TestFlow(setOf(stx2.id), a.info.chooseIdentity())
-        val future = b.services.startFlow(p).resultFuture
+        val p = TestFlow(setOf(stx2.id), megaCorp)
+        val future = miniCorpNode.services.startFlow(p).resultFuture
         mockNet.runNetwork()
         val results = future.getOrThrow()
         assertEquals(listOf(stx1.id, stx2.id), results.map { it.id })
-        b.database.transaction {
-            assertEquals(stx1, b.services.validatedTransactions.getTransaction(stx1.id))
-            assertEquals(stx2, b.services.validatedTransactions.getTransaction(stx2.id))
+        miniCorpNode.database.transaction {
+            assertEquals(stx1, miniCorpNode.services.validatedTransactions.getTransaction(stx1.id))
+            assertEquals(stx2, miniCorpNode.services.validatedTransactions.getTransaction(stx2.id))
         }
     }
     // DOCEND 1
@@ -73,8 +73,8 @@ class ResolveTransactionsFlowTest {
     @Test
     fun `dependency with an error`() {
         val stx = makeTransactions(signFirstTX = false).second
-        val p = TestFlow(setOf(stx.id), a.info.chooseIdentity())
-        val future = b.services.startFlow(p).resultFuture
+        val p = TestFlow(setOf(stx.id), megaCorp)
+        val future = miniCorpNode.services.startFlow(p).resultFuture
         mockNet.runNetwork()
         assertFailsWith(SignedTransaction.SignaturesMissingException::class) { future.getOrThrow() }
     }
@@ -82,14 +82,14 @@ class ResolveTransactionsFlowTest {
     @Test
     fun `resolve from a signed transaction`() {
         val (stx1, stx2) = makeTransactions()
-        val p = TestFlow(stx2, a.info.chooseIdentity())
-        val future = b.services.startFlow(p).resultFuture
+        val p = TestFlow(stx2, megaCorp)
+        val future = miniCorpNode.services.startFlow(p).resultFuture
         mockNet.runNetwork()
         future.getOrThrow()
-        b.database.transaction {
-            assertEquals(stx1, b.services.validatedTransactions.getTransaction(stx1.id))
+        miniCorpNode.database.transaction {
+            assertEquals(stx1, miniCorpNode.services.validatedTransactions.getTransaction(stx1.id))
             // But stx2 wasn't inserted, just stx1.
-            assertNull(b.services.validatedTransactions.getTransaction(stx2.id))
+            assertNull(miniCorpNode.services.validatedTransactions.getTransaction(stx2.id))
         }
     }
 
@@ -100,15 +100,15 @@ class ResolveTransactionsFlowTest {
         val count = 50
         var cursor = stx2
         repeat(count) {
-            val builder = DummyContract.move(cursor.tx.outRef(0), MINI_CORP)
-            val stx = megaCorpServices.signInitialTransaction(builder)
-            a.database.transaction {
-                a.services.recordTransactions(stx)
+            val builder = DummyContract.move(cursor.tx.outRef(0), miniCorp)
+            val stx = megaCorpNode.services.signInitialTransaction(builder)
+            megaCorpNode.database.transaction {
+                megaCorpNode.services.recordTransactions(stx)
             }
             cursor = stx
         }
-        val p = TestFlow(setOf(cursor.id), a.info.chooseIdentity(), 40)
-        val future = b.services.startFlow(p).resultFuture
+        val p = TestFlow(setOf(cursor.id), megaCorp, 40)
+        val future = miniCorpNode.services.startFlow(p).resultFuture
         mockNet.runNetwork()
         assertFailsWith<ResolveTransactionsFlow.ExcessivelyLargeTransactionGraph> { future.getOrThrow() }
     }
@@ -117,22 +117,22 @@ class ResolveTransactionsFlowTest {
     fun `triangle of transactions resolves fine`() {
         val stx1 = makeTransactions().first
 
-        val stx2 = DummyContract.move(stx1.tx.outRef(0), MINI_CORP).run {
-            val ptx = megaCorpServices.signInitialTransaction(this)
-            notaryServices.addSignature(ptx)
+        val stx2 = DummyContract.move(stx1.tx.outRef(0), miniCorp).let { builder ->
+            val ptx = megaCorpNode.services.signInitialTransaction(builder)
+            notaryNode.services.addSignature(ptx, notary.owningKey)
         }
 
-        val stx3 = DummyContract.move(listOf(stx1.tx.outRef(0), stx2.tx.outRef(0)), MINI_CORP).run {
-            val ptx = megaCorpServices.signInitialTransaction(this)
-            notaryServices.addSignature(ptx)
+        val stx3 = DummyContract.move(listOf(stx1.tx.outRef(0), stx2.tx.outRef(0)), miniCorp).let { builder ->
+            val ptx = megaCorpNode.services.signInitialTransaction(builder)
+            notaryNode.services.addSignature(ptx, notary.owningKey)
         }
 
-        a.database.transaction {
-            a.services.recordTransactions(stx2, stx3)
+        megaCorpNode.database.transaction {
+            megaCorpNode.services.recordTransactions(stx2, stx3)
         }
 
-        val p = TestFlow(setOf(stx3.id), a.info.chooseIdentity())
-        val future = b.services.startFlow(p).resultFuture
+        val p = TestFlow(setOf(stx3.id), megaCorp)
+        val future = miniCorpNode.services.startFlow(p).resultFuture
         mockNet.runNetwork()
         future.getOrThrow()
     }
@@ -149,43 +149,43 @@ class ResolveTransactionsFlowTest {
             return bs.toByteArray().sequence().open()
         }
         // TODO: this operation should not require an explicit transaction
-        val id = a.database.transaction {
-            a.services.attachments.importAttachment(makeJar())
+        val id = megaCorpNode.database.transaction {
+            megaCorpNode.services.attachments.importAttachment(makeJar())
         }
         val stx2 = makeTransactions(withAttachment = id).second
-        val p = TestFlow(stx2, a.info.chooseIdentity())
-        val future = b.services.startFlow(p).resultFuture
+        val p = TestFlow(stx2, megaCorp)
+        val future = miniCorpNode.services.startFlow(p).resultFuture
         mockNet.runNetwork()
         future.getOrThrow()
 
         // TODO: this operation should not require an explicit transaction
-        b.database.transaction {
-            assertNotNull(b.services.attachments.openAttachment(id))
+        miniCorpNode.database.transaction {
+            assertNotNull(miniCorpNode.services.attachments.openAttachment(id))
         }
     }
 
     // DOCSTART 2
     private fun makeTransactions(signFirstTX: Boolean = true, withAttachment: SecureHash? = null): Pair<SignedTransaction, SignedTransaction> {
         // Make a chain of custody of dummy states and insert into node A.
-        val dummy1: SignedTransaction = DummyContract.generateInitial(0, notary, MEGA_CORP.ref(1)).let {
+        val dummy1: SignedTransaction = DummyContract.generateInitial(0, notary, megaCorp.ref(1)).let {
             if (withAttachment != null)
                 it.addAttachment(withAttachment)
             when (signFirstTX) {
                 true -> {
-                    val ptx = megaCorpServices.signInitialTransaction(it)
-                    notaryServices.addSignature(ptx)
+                    val ptx = megaCorpNode.services.signInitialTransaction(it)
+                    notaryNode.services.addSignature(ptx, notary.owningKey)
                 }
                 false -> {
-                    notaryServices.signInitialTransaction(it)
+                    notaryNode.services.signInitialTransaction(it, notary.owningKey)
                 }
             }
         }
-        val dummy2: SignedTransaction = DummyContract.move(dummy1.tx.outRef(0), MINI_CORP).let {
-            val ptx = megaCorpServices.signInitialTransaction(it)
-            notaryServices.addSignature(ptx)
+        val dummy2: SignedTransaction = DummyContract.move(dummy1.tx.outRef(0), miniCorp).let {
+            val ptx = megaCorpNode.services.signInitialTransaction(it)
+            notaryNode.services.addSignature(ptx, notary.owningKey)
         }
-        a.database.transaction {
-            a.services.recordTransactions(dummy1, dummy2)
+        megaCorpNode.database.transaction {
+            megaCorpNode.services.recordTransactions(dummy1, dummy2)
         }
         return Pair(dummy1, dummy2)
     }
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
index 1180a73ff0..60c50f3211 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
@@ -7,13 +7,10 @@ import net.corda.finance.DOLLARS
 import net.corda.finance.`issued by`
 import net.corda.finance.contracts.asset.Cash
 import net.corda.node.internal.StartedNode
-import net.corda.testing.chooseIdentity
-import net.corda.testing.getDefaultNotary
+import net.corda.testing.*
 import net.corda.testing.node.InMemoryMessagingNetwork.ServicePeerAllocationStrategy.RoundRobin
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
-import net.corda.testing.setCordappPackages
-import net.corda.testing.unsetCordappPackages
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -33,9 +30,9 @@ class CashExitFlowTests {
     fun start() {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
-        val nodes = mockNet.createSomeNodes(1)
-        notaryNode = nodes.notaryNode
-        bankOfCordaNode = nodes.partyNodes[0]
+        notaryNode = mockNet.createNotaryNode()
+        bankOfCordaNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
+        notary = notaryNode.services.getDefaultNotary()
         bankOfCorda = bankOfCordaNode.info.chooseIdentity()
 
         mockNet.runNetwork()
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
index b5901c1c30..87299eea8d 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
@@ -9,6 +9,8 @@ import net.corda.finance.contracts.asset.Cash
 import net.corda.node.internal.StartedNode
 import net.corda.testing.chooseIdentity
 import net.corda.testing.getDefaultNotary
+import net.corda.testing.BOC
+import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.node.InMemoryMessagingNetwork.ServicePeerAllocationStrategy.RoundRobin
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
@@ -30,13 +32,11 @@ class CashIssueFlowTests {
     fun start() {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
-        val nodes = mockNet.createSomeNodes(1)
-        notaryNode = nodes.notaryNode
-        bankOfCordaNode = nodes.partyNodes[0]
+        notaryNode = mockNet.createNotaryNode()
+        bankOfCordaNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
         bankOfCorda = bankOfCordaNode.info.chooseIdentity()
-
+        notary = notaryNode.services.getDefaultNotary()
         mockNet.runNetwork()
-        notary = bankOfCordaNode.services.getDefaultNotary()
     }
 
     @After
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
index 5a26f1196f..5ba26a9712 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
@@ -33,9 +33,8 @@ class CashPaymentFlowTests {
     fun start() {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
-        val nodes = mockNet.createSomeNodes(1)
-        notaryNode = nodes.notaryNode
-        bankOfCordaNode = nodes.partyNodes[0]
+        notaryNode = mockNet.createNotaryNode()
+        bankOfCordaNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
         bankOfCorda = bankOfCordaNode.info.chooseIdentity()
         notary = notaryNode.services.getDefaultNotary()
         val future = bankOfCordaNode.services.startFlow(CashIssueFlow(initialBalance, ref, notary)).resultFuture
diff --git a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
index 25f2f94923..30ec451570 100644
--- a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
@@ -93,15 +93,13 @@ class TwoPartyTradeFlowTests {
         mockNet = MockNetwork(false, true)
 
         ledger(initialiseSerialization = false) {
-            val basketOfNodes = mockNet.createSomeNodes(3)
-            val notaryNode = basketOfNodes.notaryNode
-            val aliceNode = basketOfNodes.partyNodes[0]
-            val bobNode = basketOfNodes.partyNodes[1]
-            val bankNode = basketOfNodes.partyNodes[2]
+            val notaryNode = mockNet.createNotaryNode()
+            val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+            val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
+            val bankNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
+            val notary = notaryNode.services.getDefaultNotary()
             val cashIssuer = bankNode.info.chooseIdentity().ref(1)
             val cpIssuer = bankNode.info.chooseIdentity().ref(1, 2, 3)
-            val notary = aliceNode.services.getDefaultNotary()
-
 
             aliceNode.internals.disableDBCloseOnStop()
             bobNode.internals.disableDBCloseOnStop()
@@ -144,7 +142,7 @@ class TwoPartyTradeFlowTests {
         mockNet = MockNetwork(false, true)
 
         ledger(initialiseSerialization = false) {
-            val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name)
+            val notaryNode = mockNet.createNotaryNode()
             val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
             val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
             val bankNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
@@ -198,7 +196,7 @@ class TwoPartyTradeFlowTests {
     fun `shutdown and restore`() {
         mockNet = MockNetwork(false)
         ledger(initialiseSerialization = false) {
-            val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name)
+            val notaryNode = mockNet.createNotaryNode()
             val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
             var bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
             val bankNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
@@ -332,7 +330,7 @@ class TwoPartyTradeFlowTests {
     fun `check dependencies of sale asset are resolved`() {
         mockNet = MockNetwork(false)
 
-        val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name)
+        val notaryNode = mockNet.createNotaryNode()
         val aliceNode = makeNodeWithTracking(notaryNode.network.myAddress, ALICE.name)
         val bobNode = makeNodeWithTracking(notaryNode.network.myAddress, BOB.name)
         val bankNode = makeNodeWithTracking(notaryNode.network.myAddress, BOC.name)
@@ -439,7 +437,7 @@ class TwoPartyTradeFlowTests {
     fun `track works`() {
         mockNet = MockNetwork(false)
 
-        val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name)
+        val notaryNode = mockNet.createNotaryNode()
         val aliceNode = makeNodeWithTracking(notaryNode.network.myAddress, ALICE.name)
         val bobNode = makeNodeWithTracking(notaryNode.network.myAddress, BOB.name)
         val bankNode = makeNodeWithTracking(notaryNode.network.myAddress, BOC.name)
@@ -596,7 +594,7 @@ class TwoPartyTradeFlowTests {
             aliceError: Boolean,
             expectedMessageSubstring: String
     ) {
-        val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name)
+        val notaryNode = mockNet.createNotaryNode()
         val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
         val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
         val bankNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
diff --git a/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt b/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
index 1297d979cb..01a65de71e 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
@@ -5,6 +5,7 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.ALICE
 import net.corda.testing.BOB
+import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.MockNetwork
 import org.assertj.core.api.Assertions.assertThat
@@ -29,10 +30,9 @@ class NetworkMapCacheTest {
 
     @Test
     fun registerWithNetwork() {
-        val nodes = mockNet.createSomeNodes(1)
-        val n0 = nodes.mapNode
-        val n1 = nodes.partyNodes[0]
-        val future = n1.services.networkMapCache.addMapService(n1.network, n0.network.myAddress, false, null)
+        val mapNode = mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(mapNode.network.myAddress, ALICE.name)
+        val future = aliceNode.services.networkMapCache.addMapService(aliceNode.network, mapNode.network.myAddress, false, null)
         mockNet.runNetwork()
         future.getOrThrow()
     }
@@ -40,30 +40,29 @@ class NetworkMapCacheTest {
     @Test
     fun `key collision`() {
         val entropy = BigInteger.valueOf(24012017L)
-        val nodeA = mockNet.createNode(nodeFactory = MockNetwork.DefaultFactory, legalName = ALICE.name, entropyRoot = entropy, advertisedServices = ServiceInfo(NetworkMapService.type))
-        val nodeB = mockNet.createNode(nodeFactory = MockNetwork.DefaultFactory, legalName = BOB.name, entropyRoot = entropy, advertisedServices = ServiceInfo(NetworkMapService.type))
-        assertEquals(nodeA.info.chooseIdentity(), nodeB.info.chooseIdentity())
+        val aliceNode = mockNet.createNode(nodeFactory = MockNetwork.DefaultFactory, legalName = ALICE.name, entropyRoot = entropy, advertisedServices = ServiceInfo(NetworkMapService.type))
+        val bobNode = mockNet.createNode(nodeFactory = MockNetwork.DefaultFactory, legalName = BOB.name, entropyRoot = entropy, advertisedServices = ServiceInfo(NetworkMapService.type))
+        assertEquals(aliceNode.info.chooseIdentity(), bobNode.info.chooseIdentity())
 
         mockNet.runNetwork()
 
         // Node A currently knows only about itself, so this returns node A
-        assertEquals(nodeA.services.networkMapCache.getNodesByLegalIdentityKey(nodeA.info.chooseIdentity().owningKey).singleOrNull(), nodeA.info)
+        assertEquals(aliceNode.services.networkMapCache.getNodesByLegalIdentityKey(aliceNode.info.chooseIdentity().owningKey).singleOrNull(), aliceNode.info)
 
-        nodeA.services.networkMapCache.addNode(nodeB.info)
+        aliceNode.services.networkMapCache.addNode(bobNode.info)
         // The details of node B write over those for node A
-        assertEquals(nodeA.services.networkMapCache.getNodesByLegalIdentityKey(nodeA.info.chooseIdentity().owningKey).singleOrNull(), nodeB.info)
+        assertEquals(aliceNode.services.networkMapCache.getNodesByLegalIdentityKey(aliceNode.info.chooseIdentity().owningKey).singleOrNull(), bobNode.info)
     }
 
     @Test
     fun `getNodeByLegalIdentity`() {
-        val nodes = mockNet.createSomeNodes(1)
-        val n0 = nodes.mapNode
-        val n1 = nodes.partyNodes[0]
-        val node0Cache: NetworkMapCache = n0.services.networkMapCache
-        val expected = n1.info
+        val notaryNode = mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+        val notaryCache: NetworkMapCache = notaryNode.services.networkMapCache
+        val expected = aliceNode.info
 
         mockNet.runNetwork()
-        val actual = n0.database.transaction { node0Cache.getNodeByLegalIdentity(n1.info.chooseIdentity()) }
+        val actual = notaryNode.database.transaction { notaryCache.getNodeByLegalIdentity(aliceNode.info.chooseIdentity()) }
         assertEquals(expected, actual)
 
         // TODO: Should have a test case with anonymous lookup
@@ -71,19 +70,18 @@ class NetworkMapCacheTest {
 
     @Test
     fun `remove node from cache`() {
-        val nodes = mockNet.createSomeNodes(1)
-        val n0 = nodes.mapNode
-        val n1 = nodes.partyNodes[0]
-        val n0Identity = n0.info.chooseIdentity()
-        val n1Identity = n1.info.chooseIdentity()
-        val node0Cache = n0.services.networkMapCache as PersistentNetworkMapCache
+        val notaryNode = mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+        val notaryLegalIdentity = notaryNode.info.chooseIdentity()
+        val alice = aliceNode.info.chooseIdentity()
+        val notaryCache = notaryNode.services.networkMapCache as PersistentNetworkMapCache
         mockNet.runNetwork()
-        n0.database.transaction {
-            assertThat(node0Cache.getNodeByLegalIdentity(n1Identity) != null)
-            node0Cache.removeNode(n1.info)
-            assertThat(node0Cache.getNodeByLegalIdentity(n1Identity) == null)
-            assertThat(node0Cache.getNodeByLegalIdentity(n0Identity) != null)
-            assertThat(node0Cache.getNodeByLegalName(n1Identity.name) == null)
+        notaryNode.database.transaction {
+            assertThat(notaryCache.getNodeByLegalIdentity(alice) != null)
+            notaryCache.removeNode(aliceNode.info)
+            assertThat(notaryCache.getNodeByLegalIdentity(alice) == null)
+            assertThat(notaryCache.getNodeByLegalIdentity(notaryLegalIdentity) != null)
+            assertThat(notaryCache.getNodeByLegalName(alice.name) == null)
         }
     }
 }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index 4d0a796258..63dd79f8d8 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -379,31 +379,9 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
     }
 
     /**
-     * A bundle that separates the generic user nodes and service-providing nodes. A real network might not be so
-     * clearly separated, but this is convenient for testing.
+     * Construct a default notary node.
      */
-    data class BasketOfNodes(val partyNodes: List<StartedNode<MockNode>>, val notaryNode: StartedNode<MockNode>, val mapNode: StartedNode<MockNode>)
-
-    /**
-     * Sets up a network with the requested number of nodes (defaulting to two), with one or more service nodes that
-     * run a notary, network map, any oracles etc.
-     */
-    @JvmOverloads
-    fun createSomeNodes(numPartyNodes: Int = 2, nodeFactory: Factory<*> = defaultFactory, notaryKeyPair: KeyPair? = DUMMY_NOTARY_KEY): BasketOfNodes {
-        require(nodes.isEmpty())
-        val notaryServiceInfo = ServiceInfo(ValidatingNotaryService.type)
-        val notaryOverride = if (notaryKeyPair != null)
-            mapOf(Pair(notaryServiceInfo, notaryKeyPair))
-        else
-            null
-        val mapNode = createNode(nodeFactory = nodeFactory, advertisedServices = ServiceInfo(NetworkMapService.type))
-        val mapAddress = mapNode.network.myAddress
-        val notaryNode = createNode(mapAddress, nodeFactory = nodeFactory, overrideServices = notaryOverride, advertisedServices = notaryServiceInfo)
-        val nodes = (1..numPartyNodes).map {
-            createPartyNode(mapAddress)
-        }
-        return BasketOfNodes(nodes, notaryNode, mapNode)
-    }
+    fun createNotaryNode() = createNotaryNode(null, DUMMY_NOTARY.name, null, null)
 
     fun createNotaryNode(networkMapAddress: SingleMessageRecipient? = null,
                          legalName: CordaX500Name? = null,
@@ -413,6 +391,10 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                 advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(ValidatingNotaryService.type, serviceName)))
     }
 
+    // Convenience method for Java
+    fun createPartyNode(networkMapAddress: SingleMessageRecipient,
+                        legalName: CordaX500Name) = createPartyNode(networkMapAddress, legalName, null)
+
     fun createPartyNode(networkMapAddress: SingleMessageRecipient,
                         legalName: CordaX500Name? = null,
                         overrideServices: Map<ServiceInfo, KeyPair>? = null): StartedNode<MockNode> {

From 89ef4034c07c85a0f43f6918c2d18a6582eb2afd Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Thu, 28 Sep 2017 17:42:32 +0100
Subject: [PATCH 037/185] Clean up of Dokka comments (#1632)

* Remove use of @see as a cross-reference to actual docs; this is inappropriate (it reflects "See Also", not "See Other"), and often longer than having the actual documentation in place.
* Correct syntactical errors in docs
* Correct "@returns" to "@return"
* Add note about currencies with 3 decimal places
---
 .../kotlin/net/corda/core/contracts/Amount.kt | 40 +++++++++++--------
 .../kotlin/net/corda/core/flows/FlowLogic.kt  |  6 +--
 .../net/corda/core/flows/FlowSession.kt       |  6 +--
 .../core/transactions/MerkleTransaction.kt    |  4 +-
 .../finance/contracts/asset/Obligation.kt     |  3 +-
 .../kotlin/net/corda/irs/contract/IRSUtils.kt |  2 +-
 .../net/corda/testing/LedgerDSLInterpreter.kt |  8 ++--
 .../testing/TransactionDSLInterpreter.kt      | 15 ++++---
 8 files changed, 48 insertions(+), 36 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/contracts/Amount.kt b/core/src/main/kotlin/net/corda/core/contracts/Amount.kt
index 43101b2a3e..64849d3430 100644
--- a/core/src/main/kotlin/net/corda/core/contracts/Amount.kt
+++ b/core/src/main/kotlin/net/corda/core/contracts/Amount.kt
@@ -21,7 +21,8 @@ interface TokenizableAssetInfo {
  * Amount represents a positive quantity of some token (currency, asset, etc.), measured in quantity of the smallest
  * representable units. The nominal quantity represented by each individual token is equal to the [displayTokenSize].
  * The scale property of the [displayTokenSize] should correctly reflect the displayed decimal places and is used
- * when rounding conversions from indicative/displayed amounts in [BigDecimal] to Amount occur via the Amount.fromDecimal method.
+ * when rounding conversions from indicative/displayed amounts in [BigDecimal] to Amount occur via the
+ * [Amount.fromDecimal] method.
  *
  * Amounts of different tokens *do not mix* and attempting to add or subtract two amounts of different currencies
  * will throw [IllegalArgumentException]. Amounts may not be negative. Amounts are represented internally using a signed
@@ -29,10 +30,11 @@ interface TokenizableAssetInfo {
  * multiplication are overflow checked and will throw [ArithmeticException] if the operation would have caused integer
  * overflow.
  *
- * @property quantity the number of tokens as a Long value.
- * @property displayTokenSize the nominal display unit size of a single token, potentially with trailing decimal display places if the scale parameter is non-zero.
- * @property token an instance of type T, usually a singleton.
- * @param T the type of the token, for example [Currency]. T should implement TokenizableAssetInfo if automatic conversion to/from a display format is required.
+ * @property quantity the number of tokens as a long value.
+ * @property displayTokenSize the nominal display unit size of a single token, potentially with trailing decimal display
+ * places if the scale parameter is non-zero.
+ * @property token the type of token this is an amount of. This is usually a singleton.
+ * @param T the type of the token, for example [Currency]. T should implement [TokenizableAssetInfo] if automatic conversion to/from a display format is required.
  */
 @CordaSerializable
 data class Amount<T : Any>(val quantity: Long, val displayTokenSize: BigDecimal, val token: T) : Comparable<Amount<T>> {
@@ -40,11 +42,10 @@ data class Amount<T : Any>(val quantity: Long, val displayTokenSize: BigDecimal,
     companion object {
         /**
          * Build an Amount from a decimal representation. For example, with an input of "12.34 GBP",
-         * returns an amount with a quantity of "1234" tokens. The displayTokenSize as determined via
-         * getDisplayTokenSize is used to determine the conversion scaling.
-         * e.g. Bonds might be in nominal amounts of 100, currencies in 0.01 penny units.
+         * returns an amount with a quantity of "1234" tokens. The function [getDisplayTokenSize] is used to determine the
+         * conversion scaling, for example bonds might be in nominal amounts of 100, currencies in 0.01 penny units.
          *
-         * @see Amount<Currency>.toDecimal
+         * @see Amount.toDecimal
          * @throws ArithmeticException if the intermediate calculations cannot be converted to an unsigned 63-bit token amount.
          */
         @JvmStatic
@@ -195,6 +196,7 @@ data class Amount<T : Any>(val quantity: Long, val displayTokenSize: BigDecimal,
      * Mixing non-identical token types will throw [IllegalArgumentException].
      *
      * @throws ArithmeticException if there is overflow of Amount tokens during the summation
+     * @throws IllegalArgumentException if mixing non-identical token types.
      */
     operator fun plus(other: Amount<T>): Amount<T> {
         checkToken(other)
@@ -202,11 +204,11 @@ data class Amount<T : Any>(val quantity: Long, val displayTokenSize: BigDecimal,
     }
 
     /**
-     * A checked addition operator is supported to simplify netting of Amounts.
-     * If this leads to the Amount going negative this will throw [IllegalArgumentException].
-     * Mixing non-identical token types will throw [IllegalArgumentException].
+     * A checked subtraction operator is supported to simplify netting of Amounts.
      *
-     * @throws ArithmeticException if there is Numeric underflow
+     * @throws ArithmeticException if there is numeric underflow.
+     * @throws IllegalArgumentException if this leads to the amount going negative, or would mix non-identical token
+     * types.
      */
     operator fun minus(other: Amount<T>): Amount<T> {
         checkToken(other)
@@ -222,6 +224,8 @@ data class Amount<T : Any>(val quantity: Long, val displayTokenSize: BigDecimal,
      * The multiplication operator is supported to allow easy calculation for multiples of a primitive Amount.
      * Note this is not a conserving operation, so it may not always be correct modelling of proper token behaviour.
      * N.B. Division is not supported as fractional tokens are not representable by an Amount.
+     *
+     * @throws ArithmeticException if there is overflow of Amount tokens during the multiplication.
      */
     operator fun times(other: Long): Amount<T> = Amount(Math.multiplyExact(quantity, other), displayTokenSize, token)
 
@@ -229,13 +233,15 @@ data class Amount<T : Any>(val quantity: Long, val displayTokenSize: BigDecimal,
      * The multiplication operator is supported to allow easy calculation for multiples of a primitive Amount.
      * Note this is not a conserving operation, so it may not always be correct modelling of proper token behaviour.
      * N.B. Division is not supported as fractional tokens are not representable by an Amount.
+     *
+     * @throws ArithmeticException if there is overflow of Amount tokens during the multiplication.
      */
     operator fun times(other: Int): Amount<T> = Amount(Math.multiplyExact(quantity, other.toLong()), displayTokenSize, token)
 
     /**
      * This method provides a token conserving divide mechanism.
      * @param partitions the number of amounts to divide the current quantity into.
-     * @result Returns [partitions] separate Amount objects which sum to the same quantity as this Amount
+     * @return 'partitions' separate Amount objects which sum to the same quantity as this Amount
      * and differ by no more than a single token in size.
      */
     fun splitEvenly(partitions: Int): List<Amount<T>> {
@@ -249,8 +255,10 @@ data class Amount<T : Any>(val quantity: Long, val displayTokenSize: BigDecimal,
 
     /**
      * Convert a currency [Amount] to a decimal representation. For example, with an amount with a quantity
-     * of "1234" GBP, returns "12.34". The precise representation is controlled by the displayTokenSize,
-     * which determines the size of a single token and controls the trailing decimal places via it's scale property.
+     * of "1234" GBP, returns "12.34". The precise representation is controlled by the display token size (
+     * from [getDisplayTokenSize]), which determines the size of a single token and controls the trailing decimal
+     * places via its scale property. *Note* that currencies such as the Bahraini Dinar use 3 decimal places,
+     * and it must not be presumed that this converts amounts to 2 decimal places.
      *
      * @see Amount.fromDecimal
      */
diff --git a/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt b/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
index 2137b5ee03..9145ae4baa 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
@@ -100,7 +100,7 @@ abstract class FlowLogic<out T> {
      * Note that this function is not just a simple send+receive pair: it is more efficient and more correct to
      * use this when you expect to do a message swap than do use [send] and then [receive] in turn.
      *
-     * @returns an [UntrustworthyData] wrapper around the received object.
+     * @return an [UntrustworthyData] wrapper around the received object.
      */
     @Deprecated("Use FlowSession.sendAndReceive()", level = DeprecationLevel.WARNING)
     inline fun <reified R : Any> sendAndReceive(otherParty: Party, payload: Any): UntrustworthyData<R> {
@@ -116,7 +116,7 @@ abstract class FlowLogic<out T> {
      * Note that this function is not just a simple send+receive pair: it is more efficient and more correct to
      * use this when you expect to do a message swap than do use [send] and then [receive] in turn.
      *
-     * @returns an [UntrustworthyData] wrapper around the received object.
+     * @return an [UntrustworthyData] wrapper around the received object.
      */
     @Deprecated("Use FlowSession.sendAndReceive()", level = DeprecationLevel.WARNING)
     @Suspendable
@@ -165,7 +165,7 @@ abstract class FlowLogic<out T> {
      * verified for consistency and that all expectations are satisfied, as a malicious peer may send you subtly
      * corrupted data in order to exploit your code.
      *
-     * @returns an [UntrustworthyData] wrapper around the received object.
+     * @return an [UntrustworthyData] wrapper around the received object.
      */
     @Deprecated("Use FlowSession.receive()", level = DeprecationLevel.WARNING)
     @Suspendable
diff --git a/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt b/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
index 74bd247a78..7effaa9f52 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
@@ -69,7 +69,7 @@ abstract class FlowSession {
      * Note that this function is not just a simple send+receive pair: it is more efficient and more correct to
      * use this when you expect to do a message swap than do use [send] and then [receive] in turn.
      *
-     * @returns an [UntrustworthyData] wrapper around the received object.
+     * @return an [UntrustworthyData] wrapper around the received object.
      */
     @Suspendable
     inline fun <reified R : Any> sendAndReceive(payload: Any): UntrustworthyData<R> {
@@ -84,7 +84,7 @@ abstract class FlowSession {
      * Note that this function is not just a simple send+receive pair: it is more efficient and more correct to
      * use this when you expect to do a message swap than do use [send] and then [receive] in turn.
      *
-     * @returns an [UntrustworthyData] wrapper around the received object.
+     * @return an [UntrustworthyData] wrapper around the received object.
      */
     @Suspendable
     abstract fun <R : Any> sendAndReceive(receiveType: Class<R>, payload: Any): UntrustworthyData<R>
@@ -107,7 +107,7 @@ abstract class FlowSession {
      * verified for consistency and that all expectations are satisfied, as a malicious peer may send you subtly
      * corrupted data in order to exploit your code.
      *
-     * @returns an [UntrustworthyData] wrapper around the received object.
+     * @return an [UntrustworthyData] wrapper around the received object.
      */
     @Suspendable
     abstract fun <R : Any> receive(receiveType: Class<R>): UntrustworthyData<R>
diff --git a/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt
index ea99e30811..0daaedc713 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt
@@ -104,7 +104,7 @@ class FilteredTransaction private constructor(
          * Construction of partial transaction from [WireTransaction] based on filtering.
          * Note that list of nonces to be sent is updated on the fly, based on the index of the filtered tx component.
          * @param filtering filtering over the whole WireTransaction.
-         * @returns a list of [FilteredComponentGroup] used in PartialMerkleTree calculation and verification.
+         * @return a list of [FilteredComponentGroup] used in PartialMerkleTree calculation and verification.
          */
         private fun filterWithFun(wtx: WireTransaction, filtering: Predicate<Any>): List<FilteredComponentGroup> {
             val filteredSerialisedComponents: MutableMap<Int, MutableList<OpaqueBytes>> = hashMapOf()
@@ -196,7 +196,7 @@ class FilteredTransaction private constructor(
      * over a transaction with the attachment that wasn't verified. Of course it depends on how you implement it, but else -> false
      * should solve a problem with possible later extensions to WireTransaction.
      * @param checkingFun function that performs type checking on the structure fields and provides verification logic accordingly.
-     * @returns false if no elements were matched on a structure or checkingFun returned false.
+     * @return false if no elements were matched on a structure or checkingFun returned false.
      */
     fun checkWithFun(checkingFun: (Any) -> Boolean): Boolean {
         val checkList = availableComponentGroups.flatten().map { checkingFun(it) }
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt
index d499c08233..38371297bb 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt
@@ -199,7 +199,8 @@ class Obligation<P : Any> : Contract {
         /**
          * A command stating that the obligor is settling some or all of the amount owed by transferring a suitable
          * state object to the beneficiary. If this reduces the balance to zero, the state object is destroyed.
-         * @see [MoveCommand].
+         *
+         * @see MoveCommand
          */
         data class Settle<P : Any>(val amount: Amount<Issued<Terms<P>>>) : CommandData
 
diff --git a/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt b/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt
index 12ef6e2cd4..b8950ee871 100644
--- a/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt
+++ b/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt
@@ -52,7 +52,7 @@ open class Rate(val ratioUnit: RatioUnit? = null) {
     }
 
     /**
-     * @returns the hash code of the ratioUnit or zero if the ratioUnit is null, as is the case for floating rate fixings
+     * @return the hash code of the ratioUnit or zero if the ratioUnit is null, as is the case for floating rate fixings
      * that have not yet happened.  Yet-to-be fixed floating rates need to be equal such that schedules can be tested
      * for equality.
      */
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/LedgerDSLInterpreter.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/LedgerDSLInterpreter.kt
index c3fb15115e..9f4f829433 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/LedgerDSLInterpreter.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/LedgerDSLInterpreter.kt
@@ -127,7 +127,7 @@ class LedgerDSL<out T : TransactionDSLInterpreter, out L : LedgerDSLInterpreter<
         LedgerDSLInterpreter<TransactionDSLInterpreter> by interpreter {
 
     /**
-     * @see LedgerDSLInterpreter._transaction
+     * Creates and adds a transaction to the ledger.
      */
     @JvmOverloads
     fun transaction(label: String? = null, transactionBuilder: TransactionBuilder = TransactionBuilder(notary = DUMMY_NOTARY),
@@ -135,7 +135,7 @@ class LedgerDSL<out T : TransactionDSLInterpreter, out L : LedgerDSLInterpreter<
             _transaction(label, transactionBuilder, dsl)
 
     /**
-     * @see LedgerDSLInterpreter._unverifiedTransaction
+     * Creates and adds a transaction to the ledger that will not be verified by [verifies].
      */
     @JvmOverloads
     fun unverifiedTransaction(label: String? = null, transactionBuilder: TransactionBuilder = TransactionBuilder(notary = DUMMY_NOTARY),
@@ -143,7 +143,7 @@ class LedgerDSL<out T : TransactionDSLInterpreter, out L : LedgerDSLInterpreter<
             _unverifiedTransaction(label, transactionBuilder, dsl)
 
     /**
-     * @see OutputStateLookup.retrieveOutputStateAndRef
+     * Retrieves an output previously defined by [TransactionDSLInterpreter._output] with a label passed in.
      */
     inline fun <reified S : ContractState> String.outputStateAndRef(): StateAndRef<S> =
             retrieveOutputStateAndRef(S::class.java, this)
@@ -156,7 +156,7 @@ class LedgerDSL<out T : TransactionDSLInterpreter, out L : LedgerDSLInterpreter<
             outputStateAndRef<S>().state.data
 
     /**
-     * @see OutputStateLookup.retrieveOutputStateAndRef
+     * Retrieves an output previously defined by [TransactionDSLInterpreter._output] with a label passed in.
      */
     fun <S : ContractState> retrieveOutput(clazz: Class<S>, label: String) =
             retrieveOutputStateAndRef(clazz, label).state.data
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/TransactionDSLInterpreter.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/TransactionDSLInterpreter.kt
index 22b70bc15a..4916b32b3c 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/TransactionDSLInterpreter.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/TransactionDSLInterpreter.kt
@@ -12,7 +12,7 @@ import java.time.Instant
 /**
  * This interface defines the bare bone functionality that a Transaction DSL interpreter should implement.
  * @param <R> The return type of [verifies]/[failsWith] and the like. It is generic so that we have control over whether
- * we want to enforce users to call these methods (@see [EnforceVerifyOrFail]) or not.
+ * we want to enforce users to call these methods (see [EnforceVerifyOrFail]) or not.
  */
 interface TransactionDSLInterpreter : Verifies, OutputStateLookup {
     /**
@@ -33,7 +33,7 @@ interface TransactionDSLInterpreter : Verifies, OutputStateLookup {
      * @param encumbrance The position of the encumbrance state.
      * @param attachmentConstraint The attachment constraint
      * @param contractState The state itself.
-     * @params contractClassName The class name of the contract that verifies this state.
+     * @param contractClassName The class name of the contract that verifies this state.
      */
     fun _output(contractClassName: ContractClassName,
                 label: String?,
@@ -96,7 +96,7 @@ class TransactionDSL<out T : TransactionDSLInterpreter>(val interpreter: T) : Tr
     fun input(contractClassName: ContractClassName, stateClosure: () -> ContractState) = input(contractClassName, stateClosure())
 
     /**
-     * @see TransactionDSLInterpreter._output
+     * Adds an output to the transaction.
      */
     @JvmOverloads
     fun output(contractClassName: ContractClassName,
@@ -108,24 +108,27 @@ class TransactionDSL<out T : TransactionDSLInterpreter>(val interpreter: T) : Tr
             _output(contractClassName, label, notary, encumbrance, attachmentConstraint, contractStateClosure())
 
     /**
-     * @see TransactionDSLInterpreter._output
+     * Adds a labelled output to the transaction.
      */
     @JvmOverloads
     fun output(contractClassName: ContractClassName, label: String, contractState: ContractState, attachmentConstraint: AttachmentConstraint = AutomaticHashConstraint) =
             _output(contractClassName, label, DUMMY_NOTARY, null, attachmentConstraint, contractState)
 
+    /**
+     * Adds an output to the transaction.
+     */
     @JvmOverloads
     fun output(contractClassName: ContractClassName, contractState: ContractState, attachmentConstraint: AttachmentConstraint = AutomaticHashConstraint) =
             _output(contractClassName,null, DUMMY_NOTARY, null, attachmentConstraint, contractState)
 
     /**
-     * @see TransactionDSLInterpreter._command
+     * Adds a command to the transaction.
      */
     fun command(vararg signers: PublicKey, commandDataClosure: () -> CommandData) =
             _command(listOf(*signers), commandDataClosure())
 
     /**
-     * @see TransactionDSLInterpreter._command
+     * Adds a command to the transaction.
      */
     fun command(signer: PublicKey, commandData: CommandData) = _command(listOf(signer), commandData)
 

From d13bf77473f06151659e5f8ab1f787475c0c3f3c Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Thu, 28 Sep 2017 17:46:36 +0100
Subject: [PATCH 038/185] CORDA-649: Improve stability of
 PersistentNetworkMapCacheTest (#1711)

Improve stability of the NetworkMap test by ensuring that cluster of nodes is in a stable state before performing testing
---
 build.gradle                                  |  1 +
 node/build.gradle                             |  1 +
 .../network/PersistentNetworkMapCacheTest.kt  | 58 ++++++++++++-------
 .../services/messaging/P2PSecurityTest.kt     |  3 +
 .../node/services/config/NodeConfiguration.kt | 14 ++++-
 .../messaging/ArtemisMessagingServer.kt       |  8 +--
 node/src/main/resources/reference.conf        |  7 +++
 .../config/FullNodeConfigurationTest.kt       |  3 +-
 8 files changed, 68 insertions(+), 27 deletions(-)
 rename node/src/{test => integration-test}/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt (77%)

diff --git a/build.gradle b/build.gradle
index 97a02e8c18..1a624d147a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -27,6 +27,7 @@ buildscript {
     ext.jersey_version = '2.25'
     ext.jolokia_version = '2.0.0-M3'
     ext.assertj_version = '3.6.1'
+    ext.kotlintest_version = '2.0.5'
     ext.slf4j_version = '1.7.25'
     ext.log4j_version = '2.7'
     ext.bouncycastle_version = constants.getProperty("bouncycastleVersion")
diff --git a/node/build.gradle b/node/build.gradle
index d6b76f8b45..f793837c13 100644
--- a/node/build.gradle
+++ b/node/build.gradle
@@ -132,6 +132,7 @@ dependencies {
     // Unit testing helpers.
     testCompile "junit:junit:$junit_version"
     testCompile "org.assertj:assertj-core:${assertj_version}"
+    testCompile "io.kotlintest:kotlintest:${kotlintest_version}"
     testCompile project(':test-utils')
     testCompile project(':client:jfx')
     testCompile project(':finance')
diff --git a/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
similarity index 77%
rename from node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
rename to node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
index 0d34b7d142..0e69839461 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
@@ -1,6 +1,8 @@
 package net.corda.node.services.network
 
 import co.paralleluniverse.fibers.Suspendable
+import io.kotlintest.eventually
+import io.kotlintest.milliseconds
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.FlowSession
 import net.corda.core.flows.InitiatedBy
@@ -20,10 +22,12 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFails
 import kotlin.test.assertTrue
 
+private const val BRIDGE_RETRY_MS: Long = 100
+
 class PersistentNetworkMapCacheTest : NodeBasedTest() {
-    val partiesList = listOf(DUMMY_NOTARY, ALICE, BOB)
-    val addressesMap: HashMap<CordaX500Name, NetworkHostAndPort> = HashMap()
-    val infos: MutableSet<NodeInfo> = HashSet()
+    private val partiesList = listOf(DUMMY_NOTARY, ALICE, BOB)
+    private val addressesMap: HashMap<CordaX500Name, NetworkHostAndPort> = HashMap()
+    private val infos: MutableSet<NodeInfo> = HashSet()
 
     companion object {
         val logger = loggerFor<PersistentNetworkMapCacheTest>()
@@ -48,7 +52,7 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
             val res = netCache.getNodeByLegalIdentity(alice.info.chooseIdentity())
             assertEquals(alice.info, res)
             val res2 = netCache.getNodeByLegalName(DUMMY_NOTARY.name)
-            assertEquals(infos.filter { DUMMY_NOTARY.name in it.legalIdentitiesAndCerts.map { it.name } }.singleOrNull(), res2)
+            assertEquals(infos.singleOrNull { DUMMY_NOTARY.name in it.legalIdentitiesAndCerts.map { it.name } }, res2)
         }
     }
 
@@ -111,19 +115,23 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
 
     @Test
     fun `new node joins network without network map started`() {
+
+        fun customNodesStart(parties: List<Party>): List<StartedNode<Node>> =
+                startNodesWithPort(parties, noNetworkMap = false, customRetryIntervalMs = BRIDGE_RETRY_MS)
+
         val parties = partiesList.subList(1, partiesList.size)
         // Start 2 nodes pointing at network map, but don't start network map service.
-        val otherNodes = startNodesWithPort(parties, noNetworkMap = false)
+        val otherNodes = customNodesStart(parties)
         otherNodes.forEach { node ->
             assertTrue(infos.any { it.legalIdentitiesAndCerts.toSet() == node.info.legalIdentitiesAndCerts.toSet() })
         }
         // Start node that is not in databases of other nodes. Point to NMS. Which has't started yet.
-        val charlie = startNodesWithPort(listOf(CHARLIE), noNetworkMap = false)[0]
+        val charlie = customNodesStart(listOf(CHARLIE)).single()
         otherNodes.forEach {
             assertThat(it.services.networkMapCache.allNodes).doesNotContain(charlie.info)
         }
         // Start Network Map and see that charlie node appears in caches.
-        val nms = startNodesWithPort(listOf(DUMMY_NOTARY), noNetworkMap = false)[0]
+        val nms = customNodesStart(listOf(DUMMY_NOTARY)).single()
         nms.internals.startupComplete.get()
         assertTrue(nms.inNodeNetworkMapService != NullNetworkMapService)
         assertTrue(infos.any { it.legalIdentities.toSet() == nms.info.legalIdentities.toSet() })
@@ -131,24 +139,34 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
             assertTrue(nms.info.chooseIdentity() in it.services.networkMapCache.allNodes.map { it.chooseIdentity() })
         }
         charlie.internals.nodeReadyFuture.get() // Finish registration.
-        logger.info("Checking connectivity")
-        checkConnectivity(listOf(otherNodes[0], nms)) // Checks connectivity from A to NMS.
-        logger.info("Loading caches")
-        val cacheA = otherNodes[0].services.networkMapCache.allNodes
-        val cacheB = otherNodes[1].services.networkMapCache.allNodes
-        val cacheC = charlie.services.networkMapCache.allNodes
-        logger.info("Performing verification")
-        assertEquals(4, cacheC.size) // Charlie fetched data from NetworkMap
-        assertThat(cacheB).contains(charlie.info)
-        assertEquals(cacheA.toSet(), cacheB.toSet())
-        assertEquals(cacheA.toSet(), cacheC.toSet())
+
+        val allTheStartedNodesPopulation = otherNodes.plus(charlie).plus(nms)
+
+        // This is prediction of the longest time it will take to get the cluster into a stable state such that further
+        // testing can be performed upon it
+        val maxInstabilityInterval = BRIDGE_RETRY_MS * allTheStartedNodesPopulation.size * 2
+
+        eventually(maxInstabilityInterval.milliseconds) {
+            logger.info("Checking connectivity")
+            checkConnectivity(listOf(otherNodes[0], nms)) // Checks connectivity from A to NMS.
+            logger.info("Loading caches")
+            val cacheA = otherNodes[0].services.networkMapCache.allNodes
+            val cacheB = otherNodes[1].services.networkMapCache.allNodes
+            val cacheC = charlie.services.networkMapCache.allNodes
+            logger.info("Performing verification")
+            assertEquals(4, cacheC.size) // Charlie fetched data from NetworkMap
+            assertThat(cacheB).contains(charlie.info)
+            assertEquals(cacheA.toSet(), cacheB.toSet())
+            assertEquals(cacheA.toSet(), cacheC.toSet())
+        }
     }
 
     // HELPERS
     // Helper function to restart nodes with the same host and port.
-    private fun startNodesWithPort(nodesToStart: List<Party>, noNetworkMap: Boolean = false): List<StartedNode<Node>> {
+    private fun startNodesWithPort(nodesToStart: List<Party>, noNetworkMap: Boolean = false, customRetryIntervalMs: Long? = null): List<StartedNode<Node>> {
         return nodesToStart.map { party ->
-            val configOverrides = addressesMap[party.name]?.let { mapOf("p2pAddress" to it.toString()) } ?: emptyMap()
+            val configOverrides = (addressesMap[party.name]?.let { mapOf("p2pAddress" to it.toString()) } ?: emptyMap()) +
+                    (customRetryIntervalMs?.let { mapOf("activeMQServer.bridge.retryIntervalMs" to it.toString()) } ?: emptyMap())
             if (party == DUMMY_NOTARY) {
                 startNetworkMapNode(party.name, configOverrides = configOverrides)
             }
diff --git a/node/src/integration-test/kotlin/net/corda/services/messaging/P2PSecurityTest.kt b/node/src/integration-test/kotlin/net/corda/services/messaging/P2PSecurityTest.kt
index 8d4b6fab55..317252e531 100644
--- a/node/src/integration-test/kotlin/net/corda/services/messaging/P2PSecurityTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/services/messaging/P2PSecurityTest.kt
@@ -9,6 +9,8 @@ import net.corda.core.internal.cert
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.seconds
 import net.corda.node.internal.NetworkMapInfo
+import net.corda.node.services.config.ActiveMqServerConfiguration
+import net.corda.node.services.config.BridgeConfiguration
 import net.corda.node.services.config.configureWithDevSSLCertificate
 import net.corda.node.services.messaging.sendRequest
 import net.corda.node.services.network.NetworkMapService
@@ -60,6 +62,7 @@ class P2PSecurityTest : NodeBasedTest() {
                 baseDirectory = baseDirectory(legalName),
                 myLegalName = legalName).also {
             whenever(it.networkMapService).thenReturn(NetworkMapInfo(networkMapNode.internals.configuration.p2pAddress, networkMapNode.info.chooseIdentity().name))
+            whenever(it.activeMQServer).thenReturn(ActiveMqServerConfiguration(BridgeConfiguration(1001, 2, 3.4)))
         }
         config.configureWithDevSSLCertificate() // This creates the node's TLS cert with the CN as the legal name
         return SimpleNode(config, trustRoot = trustRoot).apply { start() }
diff --git a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
index d078c1df48..7d500b2202 100644
--- a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
+++ b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
@@ -37,8 +37,17 @@ interface NodeConfiguration : NodeSSLConfiguration {
     val bftSMaRt: BFTSMaRtConfiguration
     val notaryNodeAddress: NetworkHostAndPort?
     val notaryClusterAddresses: List<NetworkHostAndPort>
+    val activeMQServer: ActiveMqServerConfiguration
 }
 
+data class BridgeConfiguration(
+        val retryIntervalMs: Long,
+        val maxRetryIntervalMin: Long,
+        val retryIntervalMultiplier: Double
+)
+
+data class ActiveMqServerConfiguration(val bridge: BridgeConfiguration)
+
 data class FullNodeConfiguration(
         /** This is not retrieved from the config file but rather from a command line argument. */
         override val baseDirectory: Path,
@@ -68,7 +77,8 @@ data class FullNodeConfiguration(
         override val certificateChainCheckPolicies: List<CertChainPolicyConfig>,
         override val devMode: Boolean = false,
         val useTestClock: Boolean = false,
-        val detectPublicIp: Boolean = true
+        val detectPublicIp: Boolean = true,
+        override val activeMQServer: ActiveMqServerConfiguration
 ) : NodeConfiguration {
     override val exportJMXto: String get() = "http"
 
@@ -104,7 +114,7 @@ enum class CertChainPolicyType {
     MustContainOneOf
 }
 
-data class CertChainPolicyConfig(val role: String, val policy: CertChainPolicyType, val trustedAliases: Set<String>) {
+data class CertChainPolicyConfig(val role: String, private val policy: CertChainPolicyType, private val trustedAliases: Set<String>) {
     val certificateChainCheckPolicy: CertificateChainCheckPolicy get() {
         return when (policy) {
             CertChainPolicyType.Any -> CertificateChainCheckPolicy.Any
diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt b/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt
index 32c866da19..b648721633 100644
--- a/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt
+++ b/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt
@@ -57,6 +57,7 @@ import java.math.BigInteger
 import java.security.KeyStore
 import java.security.KeyStoreException
 import java.security.Principal
+import java.time.Duration
 import java.util.*
 import java.util.concurrent.Executor
 import java.util.concurrent.ScheduledExecutorService
@@ -390,10 +391,9 @@ class ArtemisMessagingServer(override val config: NodeConfiguration,
             isUseDuplicateDetection = true // Enable the bridge's automatic deduplication logic
             // We keep trying until the network map deems the node unreachable and tells us it's been removed at which
             // point we destroy the bridge
-            // TODO Give some thought to the retry settings
-            retryInterval = 5.seconds.toMillis()
-            retryIntervalMultiplier = 1.5  // Exponential backoff
-            maxRetryInterval = 3.minutes.toMillis()
+            retryInterval = config.activeMQServer.bridge.retryIntervalMs
+            retryIntervalMultiplier = config.activeMQServer.bridge.retryIntervalMultiplier
+            maxRetryInterval = Duration.ofMinutes(config.activeMQServer.bridge.maxRetryIntervalMin).toMillis()
             // As a peer of the target node we must connect to it using the peer user. Actual authentication is done using
             // our TLS certificate.
             user = PEER_USER
diff --git a/node/src/main/resources/reference.conf b/node/src/main/resources/reference.conf
index 1b3711c8c4..37a91c5e5e 100644
--- a/node/src/main/resources/reference.conf
+++ b/node/src/main/resources/reference.conf
@@ -23,3 +23,10 @@ bftSMaRt = {
     replicaId = -1
     debug = false
 }
+activeMQServer = {
+    bridge = {
+        retryIntervalMs = 5000
+        retryIntervalMultiplier = 1.5
+        maxRetryIntervalMin = 3
+    }
+}
diff --git a/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
index ef4e7128e4..b4cce7d46f 100644
--- a/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
@@ -34,7 +34,8 @@ class FullNodeConfigurationTest {
                 notaryNodeAddress = null,
                 notaryClusterAddresses = emptyList(),
                 certificateChainCheckPolicies = emptyList(),
-                devMode = true)
+                devMode = true,
+                activeMQServer = ActiveMqServerConfiguration(BridgeConfiguration(0, 0, 0.0)))
 
         fun configWithRPCUsername(username: String) {
             testConfiguration.copy(rpcUsers = listOf(User(username, "pass", emptySet())))

From 5fa7381883f6d819b565a75d44f56a76dd4fd683 Mon Sep 17 00:00:00 2001
From: Matthew Nesbit <matthew.nesbit@r3cev.com>
Date: Thu, 28 Sep 2017 13:25:08 +0100
Subject: [PATCH 039/185] Custom exceptions in corda, should either derive from
 an appropriate closely related java exception, or CordaException, or
 CordaRuntimeException. They should not inherit just from Exception, or
 RuntimeException.

Handle PR comments

Add nicer constructors to CordaException and CordaRuntimeException

(cherry picked from commit 89478c8)

Fix ambiguous defaulted constructor

(cherry picked from commit ec9bafe)

Address PR comment

Update a few more custom exceptions
---
 .../client/jackson/StringToMethodCallParser.kt      |  3 ++-
 .../net/corda/client/rpc/PermissionException.kt     |  4 ++--
 .../main/kotlin/net/corda/core/CordaException.kt    |  9 ++++++---
 .../net/corda/core/crypto/PartialMerkleTree.kt      |  3 ++-
 .../corda/core/internal/ResolveTransactionsFlow.kt  |  3 ++-
 .../net/corda/core/node/services/IdentityService.kt |  3 ++-
 .../serialization/MissingAttachmentsException.kt    |  3 ++-
 .../corda/core/transactions/MerkleTransaction.kt    |  5 +++--
 .../core/transactions/MissingContractAttachments.kt |  3 ++-
 .../net/corda/finance/contracts/FinanceTypes.kt     |  3 ++-
 .../amqp/custom/ThrowableSerializer.kt              |  2 +-
 .../internal/serialization/carpenter/Exceptions.kt  | 11 +++++++----
 .../kotlin/net/corda/node/internal/AbstractNode.kt  |  5 +++--
 .../src/main/kotlin/net/corda/node/internal/Node.kt |  3 ++-
 .../corda/node/services/api/ServiceHubInternal.kt   |  5 +++--
 .../node/services/network/NetworkMapService.kt      | 13 +++++++------
 .../services/network/PersistentNetworkMapCache.kt   |  8 ++++----
 .../services/persistence/NodeAttachmentService.kt   |  3 ++-
 .../services/statemachine/StateMachineManager.kt    |  3 ++-
 .../kotlin/net/corda/node/shell/InteractiveShell.kt |  3 ++-
 .../registration/NetworkRegistrationService.kt      |  3 ++-
 .../main/kotlin/net/corda/irs/flows/RatesFixFlow.kt |  4 ++--
 .../main/kotlin/net/corda/testing/driver/Driver.kt  |  3 ++-
 .../src/main/kotlin/net/corda/testing/TestDSL.kt    |  7 ++++---
 24 files changed, 68 insertions(+), 44 deletions(-)

diff --git a/client/jackson/src/main/kotlin/net/corda/client/jackson/StringToMethodCallParser.kt b/client/jackson/src/main/kotlin/net/corda/client/jackson/StringToMethodCallParser.kt
index ddbf924c27..a49409eca2 100644
--- a/client/jackson/src/main/kotlin/net/corda/client/jackson/StringToMethodCallParser.kt
+++ b/client/jackson/src/main/kotlin/net/corda/client/jackson/StringToMethodCallParser.kt
@@ -6,6 +6,7 @@ import com.fasterxml.jackson.dataformat.yaml.YAMLFactory
 import com.google.common.collect.HashMultimap
 import com.google.common.collect.Multimap
 import net.corda.client.jackson.StringToMethodCallParser.ParsedMethodCall
+import net.corda.core.CordaException
 import org.slf4j.LoggerFactory
 import java.lang.reflect.Constructor
 import java.lang.reflect.Method
@@ -146,7 +147,7 @@ open class StringToMethodCallParser<in T : Any> @JvmOverloads constructor(
         }
     }
 
-    open class UnparseableCallException(command: String, cause: Throwable? = null) : Exception("Could not parse as a command: $command", cause) {
+    open class UnparseableCallException(command: String, cause: Throwable? = null) : CordaException("Could not parse as a command: $command", cause) {
         class UnknownMethod(val methodName: String) : UnparseableCallException("Unknown command name: $methodName")
         class MissingParameter(methodName: String, val paramName: String, command: String) : UnparseableCallException("Parameter $paramName missing from attempt to invoke $methodName in command: $command")
         class TooManyParameters(methodName: String, command: String) : UnparseableCallException("Too many parameters provided for $methodName: $command")
diff --git a/client/rpc/src/main/kotlin/net/corda/client/rpc/PermissionException.kt b/client/rpc/src/main/kotlin/net/corda/client/rpc/PermissionException.kt
index 0498801989..71596c6e5e 100644
--- a/client/rpc/src/main/kotlin/net/corda/client/rpc/PermissionException.kt
+++ b/client/rpc/src/main/kotlin/net/corda/client/rpc/PermissionException.kt
@@ -1,10 +1,10 @@
 package net.corda.client.rpc
 
+import net.corda.core.CordaRuntimeException
 import net.corda.core.serialization.CordaSerializable
 
 /**
  * Thrown to indicate that the calling user does not have permission for something they have requested (for example
  * calling a method).
  */
-@CordaSerializable
-class PermissionException(msg: String) : RuntimeException(msg)
+class PermissionException(msg: String) : CordaRuntimeException(msg)
diff --git a/core/src/main/kotlin/net/corda/core/CordaException.kt b/core/src/main/kotlin/net/corda/core/CordaException.kt
index 4e5353fa77..52bbd82172 100644
--- a/core/src/main/kotlin/net/corda/core/CordaException.kt
+++ b/core/src/main/kotlin/net/corda/core/CordaException.kt
@@ -15,10 +15,11 @@ interface CordaThrowable {
 open class CordaException internal constructor(override var originalExceptionClassName: String? = null,
                                                private var _message: String? = null,
                                                private var _cause: Throwable? = null) : Exception(null, null, true, true), CordaThrowable {
-
     constructor(message: String?,
                 cause: Throwable?) : this(null, message, cause)
 
+    constructor(message: String?) : this(null, message, null)
+
     override val message: String?
         get() = if (originalExceptionClassName == null) originalMessage else {
             if (originalMessage == null) "$originalExceptionClassName" else "$originalExceptionClassName: $originalMessage"
@@ -59,10 +60,12 @@ open class CordaException internal constructor(override var originalExceptionCla
 }
 
 open class CordaRuntimeException(override var originalExceptionClassName: String?,
-                                 private var _message: String? = null,
-                                 private var _cause: Throwable? = null) : RuntimeException(null, null, true, true), CordaThrowable {
+                                 private var _message: String?,
+                                 private var _cause: Throwable?) : RuntimeException(null, null, true, true), CordaThrowable {
     constructor(message: String?, cause: Throwable?) : this(null, message, cause)
 
+    constructor(message: String?) : this(null, message, null)
+
     override val message: String?
         get() = if (originalExceptionClassName == null) originalMessage else {
             if (originalMessage == null) "$originalExceptionClassName" else "$originalExceptionClassName: $originalMessage"
diff --git a/core/src/main/kotlin/net/corda/core/crypto/PartialMerkleTree.kt b/core/src/main/kotlin/net/corda/core/crypto/PartialMerkleTree.kt
index 0011198d75..77e06bf1c2 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/PartialMerkleTree.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/PartialMerkleTree.kt
@@ -1,11 +1,12 @@
 package net.corda.core.crypto
 
+import net.corda.core.CordaException
 import net.corda.core.crypto.SecureHash.Companion.zeroHash
 import net.corda.core.serialization.CordaSerializable
 import java.util.*
 
 @CordaSerializable
-class MerkleTreeException(val reason: String) : Exception("Partial Merkle Tree exception. Reason: $reason")
+class MerkleTreeException(val reason: String) : CordaException("Partial Merkle Tree exception. Reason: $reason")
 
 /**
  * Building and verification of Partial Merkle Tree.
diff --git a/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt b/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt
index f297fc7c5b..9ef8101bdd 100644
--- a/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt
@@ -2,6 +2,7 @@ package net.corda.core.internal
 
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.crypto.SecureHash
+import net.corda.core.flows.FlowException
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.FlowSession
 import net.corda.core.serialization.CordaSerializable
@@ -63,7 +64,7 @@ class ResolveTransactionsFlow(private val txHashes: Set<SecureHash>,
     }
 
     @CordaSerializable
-    class ExcessivelyLargeTransactionGraph : Exception()
+    class ExcessivelyLargeTransactionGraph : FlowException()
 
     /** Transaction for fetch attachments for */
     private var signedTransaction: SignedTransaction? = null
diff --git a/core/src/main/kotlin/net/corda/core/node/services/IdentityService.kt b/core/src/main/kotlin/net/corda/core/node/services/IdentityService.kt
index 41a60bb30d..645afb5550 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/IdentityService.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/IdentityService.kt
@@ -1,5 +1,6 @@
 package net.corda.core.node.services
 
+import net.corda.core.CordaException
 import net.corda.core.contracts.PartyAndReference
 import net.corda.core.identity.*
 import java.security.InvalidAlgorithmParameterException
@@ -105,4 +106,4 @@ interface IdentityService {
     fun partiesFromName(query: String, exactMatch: Boolean): Set<Party>
 }
 
-class UnknownAnonymousPartyException(msg: String) : Exception(msg)
+class UnknownAnonymousPartyException(msg: String) : CordaException(msg)
diff --git a/core/src/main/kotlin/net/corda/core/serialization/MissingAttachmentsException.kt b/core/src/main/kotlin/net/corda/core/serialization/MissingAttachmentsException.kt
index 08a920ab63..a5934be42d 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/MissingAttachmentsException.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/MissingAttachmentsException.kt
@@ -1,7 +1,8 @@
 package net.corda.core.serialization
 
+import net.corda.core.CordaException
 import net.corda.core.crypto.SecureHash
 
 /** Thrown during deserialisation to indicate that an attachment needed to construct the [WireTransaction] is not found. */
 @CordaSerializable
-class MissingAttachmentsException(val ids: List<SecureHash>) : Exception()
\ No newline at end of file
+class MissingAttachmentsException(val ids: List<SecureHash>) : CordaException()
\ No newline at end of file
diff --git a/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt
index 0daaedc713..4cd1332659 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt
@@ -1,5 +1,6 @@
 package net.corda.core.transactions
 
+import net.corda.core.CordaException
 import net.corda.core.contracts.*
 import net.corda.core.crypto.*
 import net.corda.core.identity.Party
@@ -263,11 +264,11 @@ data class FilteredComponentGroup(override val groupIndex: Int, override val com
  * @param reason information about the exception.
  */
 @CordaSerializable
-class ComponentVisibilityException(val id: SecureHash, val reason: String) : Exception("Component visibility error for transaction with id:$id. Reason: $reason")
+class ComponentVisibilityException(val id: SecureHash, val reason: String) : CordaException("Component visibility error for transaction with id:$id. Reason: $reason")
 
 /** Thrown when [FilteredTransaction.verify] fails.
  * @param id transaction's id.
  * @param reason information about the exception.
  */
 @CordaSerializable
-class FilteredTransactionVerificationException(val id: SecureHash, val reason: String) : Exception("Transaction with id:$id cannot be verified. Reason: $reason")
+class FilteredTransactionVerificationException(val id: SecureHash, val reason: String) : CordaException("Transaction with id:$id cannot be verified. Reason: $reason")
diff --git a/core/src/main/kotlin/net/corda/core/transactions/MissingContractAttachments.kt b/core/src/main/kotlin/net/corda/core/transactions/MissingContractAttachments.kt
index ac75722df9..935ddfdd8d 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/MissingContractAttachments.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/MissingContractAttachments.kt
@@ -2,6 +2,7 @@ package net.corda.core.transactions
 
 import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.TransactionState
+import net.corda.core.flows.FlowException
 import net.corda.core.serialization.CordaSerializable
 
 /**
@@ -11,4 +12,4 @@ import net.corda.core.serialization.CordaSerializable
  */
 @CordaSerializable
 class MissingContractAttachments(val states: List<TransactionState<ContractState>>)
-    : Exception("Cannot find contract attachments for ${states.map { it.contract }.distinct() }")
\ No newline at end of file
+    : FlowException("Cannot find contract attachments for ${states.map { it.contract }.distinct() }")
\ No newline at end of file
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt b/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
index b79c9d01a6..13248bd58e 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
@@ -12,6 +12,7 @@ import net.corda.core.contracts.CommandData
 import net.corda.core.contracts.LinearState
 import net.corda.core.contracts.StateAndRef
 import net.corda.core.contracts.TokenizableAssetInfo
+import net.corda.core.flows.FlowException
 import net.corda.core.identity.Party
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.transactions.TransactionBuilder
@@ -199,7 +200,7 @@ enum class Frequency(val annualCompoundCount: Int, val offset: LocalDate.(Long)
 @CordaSerializable
 open class BusinessCalendar (val holidayDates: List<LocalDate>) {
     @CordaSerializable
-    class UnknownCalendar(name: String) : Exception("$name not found")
+    class UnknownCalendar(name: String) : FlowException("$name not found")
 
     companion object {
         val calendars = listOf("London", "NewYork")
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ThrowableSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ThrowableSerializer.kt
index 696b2616b9..ad8394db2d 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ThrowableSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ThrowableSerializer.kt
@@ -67,7 +67,7 @@ class ThrowableSerializer(factory: SerializerFactory) : CustomSerializer.Proxy<T
             logger.warn("Unexpected exception de-serializing throwable: ${proxy.exceptionClass}. Converting to CordaRuntimeException.", e)
         }
         // If the criteria are not met or we experience an exception constructing the exception, we fall back to our own unchecked exception.
-        return CordaRuntimeException(proxy.exceptionClass).apply {
+        return CordaRuntimeException(proxy.exceptionClass, null, null).apply {
             this.setMessage(proxy.message)
             this.setCause(proxy.cause)
             this.stackTrace = proxy.stackTrace
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Exceptions.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Exceptions.kt
index c96ae86e91..a260d82272 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Exceptions.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Exceptions.kt
@@ -1,11 +1,14 @@
 package net.corda.nodeapi.internal.serialization.carpenter
 
-class DuplicateNameException : RuntimeException(
+import net.corda.core.CordaException
+import net.corda.core.CordaRuntimeException
+
+class DuplicateNameException : CordaRuntimeException(
         "An attempt was made to register two classes with the same name within the same ClassCarpenter namespace.")
 
-class InterfaceMismatchException(msg: String) : RuntimeException(msg)
+class InterfaceMismatchException(msg: String) : CordaRuntimeException(msg)
 
-class NullablePrimitiveException(msg: String) : RuntimeException(msg)
+class NullablePrimitiveException(msg: String) : CordaRuntimeException(msg)
 
 class UncarpentableException(name: String, field: String, type: String) :
-        Exception("Class $name is loadable yet contains field $field of unknown type $type")
+        CordaException("Class $name is loadable yet contains field $field of unknown type $type")
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index ec5034ccdb..ea492d2a64 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -6,6 +6,7 @@ import com.google.common.collect.MutableClassToInstanceMap
 import com.google.common.util.concurrent.MoreExecutors
 import net.corda.confidential.SwapIdentitiesFlow
 import net.corda.confidential.SwapIdentitiesHandler
+import net.corda.core.CordaException
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.cordapp.CordappProvider
 import net.corda.core.flows.*
@@ -231,7 +232,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         }
     }
 
-    private class ServiceInstantiationException(cause: Throwable?) : Exception(cause)
+    private class ServiceInstantiationException(cause: Throwable?) : CordaException("Service Instantiation Error", cause)
 
     private fun installCordaServices() {
         cordappProvider.cordapps.flatMap { it.services }.forEach {
@@ -465,7 +466,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
     }
 
     // Specific class so that MockNode can catch it.
-    class DatabaseConfigurationException(msg: String) : Exception(msg)
+    class DatabaseConfigurationException(msg: String) : CordaException(msg)
 
     protected open fun <T> initialiseDatabasePersistence(insideTransaction: () -> T): T {
         val props = configuration.dataSourceProperties
diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt
index efb817f54a..689ef67e20 100644
--- a/node/src/main/kotlin/net/corda/node/internal/Node.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt
@@ -1,6 +1,7 @@
 package net.corda.node.internal
 
 import com.codahale.metrics.JmxReporter
+import net.corda.core.CordaException
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.PartyAndCertificate
@@ -384,6 +385,6 @@ open class Node(override val configuration: FullNodeConfiguration,
     }
 }
 
-class ConfigurationException(message: String) : Exception(message)
+class ConfigurationException(message: String) : CordaException(message)
 
 data class NetworkMapInfo(val address: NetworkHostAndPort, val legalName: CordaX500Name)
diff --git a/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt b/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
index 5492f24c1d..c1fb4f0c1b 100644
--- a/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
+++ b/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
@@ -1,5 +1,6 @@
 package net.corda.node.services.api
 
+import net.corda.core.CordaException
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.crypto.SecureHash
 import net.corda.core.flows.FlowInitiator
@@ -62,9 +63,9 @@ interface NetworkMapCacheInternal : NetworkMapCache {
 }
 
 @CordaSerializable
-sealed class NetworkCacheError : Exception() {
+sealed class NetworkCacheException : CordaException("Network Cache Error") {
     /** Indicates a failure to deregister, because of a rejected request from the remote node */
-    class DeregistrationFailed : NetworkCacheError()
+    class DeregistrationFailed : NetworkCacheException()
 }
 
 interface ServiceHubInternal : ServiceHub {
diff --git a/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt b/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt
index 81448e1469..3e9d3984ae 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt
@@ -1,5 +1,6 @@
 package net.corda.node.services.network
 
+import net.corda.core.CordaException
 import net.corda.core.crypto.DigitalSignature
 import net.corda.core.crypto.SignedData
 import net.corda.core.crypto.isFulfilledBy
@@ -189,7 +190,7 @@ abstract class AbstractNetworkMapService(services: ServiceHubInternal,
     }
 
     private fun addSubscriber(subscriber: MessageRecipients) {
-        if (subscriber !is SingleMessageRecipient) throw NodeMapError.InvalidSubscriber()
+        if (subscriber !is SingleMessageRecipient) throw NodeMapException.InvalidSubscriber()
         subscribers.locked {
             if (!containsKey(subscriber)) {
                 put(subscriber, LastAcknowledgeInfo(mapVersion))
@@ -198,12 +199,12 @@ abstract class AbstractNetworkMapService(services: ServiceHubInternal,
     }
 
     private fun removeSubscriber(subscriber: MessageRecipients) {
-        if (subscriber !is SingleMessageRecipient) throw NodeMapError.InvalidSubscriber()
+        if (subscriber !is SingleMessageRecipient) throw NodeMapException.InvalidSubscriber()
         subscribers.locked { remove(subscriber) }
     }
 
     private fun processAcknowledge(request: UpdateAcknowledge): Unit {
-        if (request.replyTo !is SingleMessageRecipient) throw NodeMapError.InvalidSubscriber()
+        if (request.replyTo !is SingleMessageRecipient) throw NodeMapException.InvalidSubscriber()
         subscribers.locked {
             val lastVersionAcked = this[request.replyTo]?.mapVersion
             if ((lastVersionAcked ?: 0) < request.mapVersion) {
@@ -360,13 +361,13 @@ class WireNodeRegistration(raw: SerializedBytes<NodeRegistration>, sig: DigitalS
 }
 
 @CordaSerializable
-sealed class NodeMapError : Exception() {
+sealed class NodeMapException : CordaException("Network Map Protocol Error") {
 
     /** Thrown if the signature on the node info does not match the public key for the identity */
-    class InvalidSignature : NodeMapError()
+    class InvalidSignature : NodeMapException()
 
     /** Thrown if the replyTo of a subscription change message is not a single message recipient */
-    class InvalidSubscriber : NodeMapError()
+    class InvalidSubscriber : NodeMapException()
 }
 
 @CordaSerializable
diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
index 1105c4981c..3260da43ca 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
@@ -21,7 +21,7 @@ import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.loggerFor
 import net.corda.core.utilities.parsePublicKeyBase58
 import net.corda.core.utilities.toBase58String
-import net.corda.node.services.api.NetworkCacheError
+import net.corda.node.services.api.NetworkCacheException
 import net.corda.node.services.api.NetworkMapCacheInternal
 import net.corda.node.services.api.ServiceHubInternal
 import net.corda.node.services.messaging.MessagingService
@@ -135,7 +135,7 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
                             data = NetworkMapService.UpdateAcknowledge(req.mapVersion, network.myAddress).serialize().bytes)
                     network.send(ackMessage, req.replyTo)
                     processUpdatePush(req)
-                } catch (e: NodeMapError) {
+                } catch (e: NodeMapException) {
                     logger.warn("Failure during node map update due to bad update: ${e.javaClass.name}")
                 } catch (e: Exception) {
                     logger.error("Exception processing update from network map service", e)
@@ -202,7 +202,7 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
         val address = getPartyInfo(mapParty)?.let { network.getAddressOfParty(it) } ?:
                 throw IllegalArgumentException("Can't deregister for updates, don't know the party: $mapParty")
         val future = network.sendRequest<SubscribeResponse>(NetworkMapService.SUBSCRIPTION_TOPIC, req, address).map {
-            if (it.confirmed) Unit else throw NetworkCacheError.DeregistrationFailed()
+            if (it.confirmed) Unit else throw NetworkCacheException.DeregistrationFailed()
         }
         _registrationFuture.captureLater(future.map { null })
         return future
@@ -213,7 +213,7 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
             val reg = req.wireReg.verified()
             processRegistration(reg)
         } catch (e: SignatureException) {
-            throw NodeMapError.InvalidSignature()
+            throw NodeMapException.InvalidSignature()
         }
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt b/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt
index b6acddd45e..3a175effb4 100644
--- a/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt
@@ -6,6 +6,7 @@ import com.google.common.hash.HashCode
 import com.google.common.hash.Hashing
 import com.google.common.hash.HashingInputStream
 import com.google.common.io.CountingInputStream
+import net.corda.core.CordaRuntimeException
 import net.corda.core.internal.AbstractAttachment
 import net.corda.core.contracts.Attachment
 import net.corda.core.crypto.SecureHash
@@ -58,7 +59,7 @@ class NodeAttachmentService(metrics: MetricRegistry) : AttachmentStorage, Single
     }
 
     @CordaSerializable
-    class HashMismatchException(val expected: SecureHash, val actual: SecureHash) : RuntimeException("File $expected hashed to $actual: corruption in attachment store?")
+    class HashMismatchException(val expected: SecureHash, val actual: SecureHash) : CordaRuntimeException("File $expected hashed to $actual: corruption in attachment store?")
 
     /**
      * Wraps a stream and hashes data as it is read: if the entire stream is consumed, then at the end the hash of
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
index 2382614752..11c3d219bc 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
@@ -9,6 +9,7 @@ import com.codahale.metrics.Gauge
 import com.esotericsoftware.kryo.KryoException
 import com.google.common.collect.HashMultimap
 import com.google.common.util.concurrent.MoreExecutors
+import net.corda.core.CordaException
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.random63BitValue
@@ -641,6 +642,6 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
     }
 }
 
-class SessionRejectException(val rejectMessage: String, val logMessage: String) : Exception() {
+class SessionRejectException(val rejectMessage: String, val logMessage: String) : CordaException(rejectMessage) {
     constructor(message: String) : this(message, message)
 }
diff --git a/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt b/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt
index 35e695d78e..07ee7e3f96 100644
--- a/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt
+++ b/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt
@@ -23,6 +23,7 @@ import net.corda.core.messaging.StateMachineUpdate
 import net.corda.core.utilities.loggerFor
 import net.corda.client.jackson.JacksonSupport
 import net.corda.client.jackson.StringToMethodCallParser
+import net.corda.core.CordaException
 import net.corda.node.internal.Node
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.messaging.CURRENT_RPC_CONTEXT
@@ -258,7 +259,7 @@ object InteractiveShell {
         }
     }
 
-    class NoApplicableConstructor(val errors: List<String>) : Exception() {
+    class NoApplicableConstructor(val errors: List<String>) : CordaException(this.toString()) {
         override fun toString() = (listOf("No applicable constructor for flow. Problems were:") + errors).joinToString(System.lineSeparator())
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/utilities/registration/NetworkRegistrationService.kt b/node/src/main/kotlin/net/corda/node/utilities/registration/NetworkRegistrationService.kt
index e22121b2e2..ffe8bece0f 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/registration/NetworkRegistrationService.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/registration/NetworkRegistrationService.kt
@@ -1,5 +1,6 @@
 package net.corda.node.utilities.registration
 
+import net.corda.core.CordaException
 import net.corda.core.serialization.CordaSerializable
 import org.bouncycastle.pkcs.PKCS10CertificationRequest
 import java.security.cert.Certificate
@@ -14,4 +15,4 @@ interface NetworkRegistrationService {
 }
 
 @CordaSerializable
-class CertificateRequestException(message: String) : Exception(message)
+class CertificateRequestException(message: String) : CordaException(message)
diff --git a/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/RatesFixFlow.kt b/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/RatesFixFlow.kt
index 285d477a69..c2370a8ddf 100644
--- a/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/RatesFixFlow.kt
+++ b/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/RatesFixFlow.kt
@@ -3,6 +3,7 @@ package net.corda.irs.flows
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.crypto.TransactionSignature
 import net.corda.core.crypto.isFulfilledBy
+import net.corda.core.flows.FlowException
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.FlowSession
 import net.corda.core.flows.InitiatingFlow
@@ -44,8 +45,7 @@ open class RatesFixFlow(protected val tx: TransactionBuilder,
         fun tracker(fixName: String) = ProgressTracker(QUERYING(fixName), WORKING, SIGNING)
     }
 
-    @CordaSerializable
-    class FixOutOfRange(@Suppress("unused") val byAmount: BigDecimal) : Exception("Fix out of range by $byAmount")
+    class FixOutOfRange(@Suppress("unused") val byAmount: BigDecimal) : FlowException("Fix out of range by $byAmount")
 
     @CordaSerializable
     data class QueryRequest(val queries: List<FixOf>)
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
index c279e0aa4d..64645569a4 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
@@ -9,6 +9,7 @@ import net.corda.client.rpc.CordaRPCClient
 import net.corda.cordform.CordformContext
 import net.corda.cordform.CordformNode
 import net.corda.cordform.NodeDefinition
+import net.corda.core.CordaException
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.concurrent.firstOf
 import net.corda.core.identity.CordaX500Name
@@ -411,7 +412,7 @@ fun getTimestampAsDirectoryName(): String {
     return DateTimeFormatter.ofPattern("yyyyMMddHHmmss").withZone(UTC).format(Instant.now())
 }
 
-class ListenProcessDeathException(hostAndPort: NetworkHostAndPort, listenProcess: Process) : Exception("The process that was expected to listen on $hostAndPort has died with status: ${listenProcess.exitValue()}")
+class ListenProcessDeathException(hostAndPort: NetworkHostAndPort, listenProcess: Process) : CordaException("The process that was expected to listen on $hostAndPort has died with status: ${listenProcess.exitValue()}")
 
 /**
  * @throws ListenProcessDeathException if [listenProcess] dies before the check succeeds, i.e. the check can't succeed as intended.
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
index 6db7662380..d157583c2e 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
@@ -4,6 +4,7 @@ import net.corda.core.contracts.*
 import net.corda.core.cordapp.CordappProvider
 import net.corda.core.crypto.*
 import net.corda.core.crypto.NullKeys.NULL_SIGNATURE
+import net.corda.core.flows.FlowException
 import net.corda.core.identity.Party
 import net.corda.core.internal.uncheckedCast
 import net.corda.core.node.ServiceHub
@@ -52,9 +53,9 @@ sealed class EnforceVerifyOrFail {
     internal object Token : EnforceVerifyOrFail()
 }
 
-class DuplicateOutputLabel(label: String) : Exception("Output label '$label' already used")
-class DoubleSpentInputs(ids: List<SecureHash>) : Exception("Transactions spend the same input. Conflicting transactions ids: '$ids'")
-class AttachmentResolutionException(attachmentId: SecureHash) : Exception("Attachment with id $attachmentId not found")
+class DuplicateOutputLabel(label: String) : FlowException("Output label '$label' already used")
+class DoubleSpentInputs(ids: List<SecureHash>) : FlowException("Transactions spend the same input. Conflicting transactions ids: '$ids'")
+class AttachmentResolutionException(attachmentId: SecureHash) : FlowException("Attachment with id $attachmentId not found")
 
 /**
  * This interpreter builds a transaction, and [TransactionDSL.verifies] that the resolved transaction is correct. Note

From bdc33892062958b4dc9cc6ef34693a33cee7d118 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Fri, 29 Sep 2017 12:23:40 +0100
Subject: [PATCH 040/185] CORDA-540: Fix exception type thrown in AMQP mode
 (#1680)

---
 .../corda/core/transactions/SignedTransaction.kt   |  9 ++++++++-
 .../serialization/amqp/PropertySerializer.kt       | 14 ++++++++++++--
 .../serialization/amqp/SerializationHelper.kt      |  2 +-
 3 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
index 31857af7e9..2705e02ef9 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
@@ -1,5 +1,7 @@
 package net.corda.core.transactions
 
+import net.corda.core.CordaException
+import net.corda.core.CordaThrowable
 import net.corda.core.contracts.*
 import net.corda.core.crypto.*
 import net.corda.core.identity.Party
@@ -187,7 +189,12 @@ data class SignedTransaction(val txBits: SerializedBytes<CoreTransaction>,
 
     override fun toString(): String = "${javaClass.simpleName}(id=$id)"
 
+    companion object {
+        private fun missingSignatureMsg(missing: Set<PublicKey>, descriptions: List<String>, id: SecureHash): String =
+                "Missing signatures for $descriptions on transaction ${id.prefixChars()} for ${missing.joinToString()}"
+    }
+
     @CordaSerializable
     class SignaturesMissingException(val missing: Set<PublicKey>, val descriptions: List<String>, override val id: SecureHash)
-        : NamedByHash, SignatureException("Missing signatures for $descriptions on transaction ${id.prefixChars()} for ${missing.joinToString()}")
+        : NamedByHash, SignatureException(missingSignatureMsg(missing, descriptions, id)), CordaThrowable by CordaException(missingSignatureMsg(missing, descriptions, id))
 }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
index 2decd00d37..7c7714b9e9 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
@@ -1,5 +1,6 @@
 package net.corda.nodeapi.internal.serialization.amqp
 
+import net.corda.core.utilities.loggerFor
 import org.apache.qpid.proton.amqp.Binary
 import org.apache.qpid.proton.codec.Data
 import java.lang.reflect.Method
@@ -48,11 +49,20 @@ sealed class PropertySerializer(val name: String, val readMethod: Method?, val r
     }
 
     private fun Method.returnsNullable(): Boolean {
-        val returnTypeString = this.declaringClass.kotlin.memberProperties.firstOrNull { it.javaGetter == this }?.returnType?.toString() ?: "?"
-        return returnTypeString.endsWith('?') || returnTypeString.endsWith('!')
+        try {
+            val returnTypeString = this.declaringClass.kotlin.memberProperties.firstOrNull { it.javaGetter == this }?.returnType?.toString() ?: "?"
+            return returnTypeString.endsWith('?') || returnTypeString.endsWith('!')
+        } catch(e: kotlin.reflect.jvm.internal.KotlinReflectionInternalError) {
+            // This might happen for some types, e.g. kotlin.Throwable? - the root cause of the issue is: https://youtrack.jetbrains.com/issue/KT-13077
+            // TODO: Revisit this when Kotlin issue is fixed.
+            logger.error("Unexpected internal Kotlin error", e)
+            return true
+        }
     }
 
     companion object {
+        private val logger = loggerFor<PropertySerializer>()
+
         fun make(name: String, readMethod: Method?, resolvedType: Type, factory: SerializerFactory): PropertySerializer {
             readMethod?.isAccessible = true
             if (SerializerFactory.isPrimitive(resolvedType)) {
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
index ab218fb247..6a1377d083 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationHelper.kt
@@ -82,7 +82,7 @@ private fun <T : Any> propertiesForSerializationFromConstructor(kotlinConstructo
     for (param in kotlinConstructor.parameters) {
         val name = param.name ?: throw NotSerializableException("Constructor parameter of $clazz has no name.")
         val matchingProperty = properties[name] ?:
-                throw NotSerializableException("No property matching constructor parameter named $name of $clazz." +
+                throw NotSerializableException("No property matching constructor parameter named '$name' of '$clazz'." +
                         " If using Java, check that you have the -parameters option specified in the Java compiler.")
         // Check that the method has a getter in java.
         val getter = matchingProperty.readMethod ?: throw NotSerializableException("Property has no getter method for $name of $clazz." +

From ddee4b94e2e87638e36f428a9a6e0bdb20f3ff39 Mon Sep 17 00:00:00 2001
From: Katelyn Baker <katelyn.baker@r3.com>
Date: Fri, 29 Sep 2017 12:27:48 +0100
Subject: [PATCH 041/185] CORDA-594 - SIMM Demo doc update (#1723)

* CORDA-594 - SIMM Demo doc update

For V1 write a series of JSON / curl commands a user can follow to run
the demo

* Review Comments

* Updated the rationale behind as to why SIMM was introduced.

* typo
---
 docs/source/running-the-demos.rst        | 214 +++++++++++++++++++++++
 samples/simm-valuation-demo/build.gradle |  16 +-
 2 files changed, 226 insertions(+), 4 deletions(-)

diff --git a/docs/source/running-the-demos.rst b/docs/source/running-the-demos.rst
index cd19580688..32a99967c6 100644
--- a/docs/source/running-the-demos.rst
+++ b/docs/source/running-the-demos.rst
@@ -218,3 +218,217 @@ Using the following login details:
 
 See https://docs.corda.net/node-explorer.html for further details on usage.
 
+.. _simm-demo:
+
+SIMM and Portfolio Demo - aka the Initial Margin Agreement Demo
+---------------------------------------------------------------
+
+Background and SIMM Introduction
+********************************
+
+This app is a demonstration of how Corda can be used for the real world requirement of initial margin calculation and
+agreement; featuring the integration of complex and industry proven third party libraries into Corda nodes.
+
+SIMM is an acronym for "Standard Initial Margin Model". It is effectively the calculation of a "margin" that is paid
+by one party to another when they agree a trade on certain types of transaction.
+
+The SIMM was introduced to standardise the calculation of how much margin counterparties charge each other on their
+bilateral transactions. Before SIMM, each counterparty computed margins according to its own model and it was made it very
+ difficult to agree the exact margin with the counterparty that faces the same trade on the other side.
+
+To enact this, in September 2016, the ISDA committee - with full backing from various governing bodies -
+`issued a ruling on what is known as the ISDA SIMM ™ model <http://www2.isda.org/news/isda-simm-deployed-today-new-industry-standard-for-calculating-initial-margin-widely-adopted-by-market-participants>`_,
+a way of fairly and consistently calculating this margin. Any parties wishing to trade a financial product that is
+covered under this ruling would, independently, use this model and calculate their margin payment requirement,
+agree it with their trading counterparty and then pay (or receive, depending on the results of this calculation)
+this amount. In the case of disagreement that is not resolved in a timely fashion, this payment would increase
+and so therefore it is in the parties' interest to reach agreement in as short as time frame as possible.
+
+To be more accurate, the SIMM calculation is not performed on just one trade - it is calculated on an aggregate of
+intermediary values (which in this model are sensitivities to risk factors) from a portfolio of trades; therefore
+the input to a SIMM is actually this data, not the individual trades themselves.
+
+Also note that implementations of the SIMM are actually protected and subject to license restrictions by ISDA
+(this is due to the model itself being protected). We were fortunate enough to technically partner with
+`OpenGamma <http://www.opengamma.com>`_  who allowed us to demonstrate the SIMM process using their proprietary model.
+In the source code released, we have replaced their analytics engine with very simple stub functions that allow
+the process to run without actually calculating correct values, and can easily be swapped out in place for their real libraries.
+
+What happens in the demo (notionally)
+*************************************
+
+Preliminaries
+    - Ensure that there are a number of live trades with another party based on financial products that are covered under the
+      ISDA SIMM agreement (if none, then use the demo to enter some simple trades as described below).
+
+Initial Margin Agreement Process
+    - Agree that one will be performing the margining calculation against a portfolio of trades with another party, and agree the trades in that portfolio. In practice, one node will start the flow but it does not matter which node does.
+    - Individually (at the node level), identify the data (static, reference etc) one will need in order to be able to calculate the metrics on those trades
+    - Confirm with the other counterparty the dataset from the above set
+    - Calculate any intermediary steps and values needed for the margin calculation (ie sensitivities to risk factors)
+    - Agree on the results of these steps
+    - Calculate the initial margin
+    - Agree on the calculation of the above with the other party
+    - In practice, pay (or receive) this margin (omitted for the sake of complexity for this example)
+
+Demo execution (step by step)
+*****************************
+
+**Setting up the Corda infrastructure**
+
+To run from the command line in Unix:
+
+1. Deploy the nodes using ``./gradlew samples:simm-valuation-demo:deployNodes``
+2. Run the nodes using ``./samples/simm-valuation-demo/build/nodes/runnodes``
+
+To run from the command line in Windows:
+
+1. Deploy the nodes using ``gradlew samples:simm-valuation-demo:deployNodes``
+2. Run the nodes using ``samples\simm-valuation-demo\build\nodes\runnodes``
+
+**Getting Bank A's details**
+
+From the command line run
+
+.. sourcecode:: bash
+
+  curl http://localhost:10005/api/simmvaluationdemo/whoami
+
+The response should be something like
+
+.. sourcecode:: none
+
+    {
+        "self" : {
+            "id" : "8Kqd4oWdx4KQGHGQW3FwXHQpjiv7cHaSsaAWMwRrK25bBJj792Z4rag7EtA",
+            "text" : "C=GB,L=London,O=Bank A"
+        },
+        "counterparties" : [
+            {
+                "id" : "8Kqd4oWdx4KQGHGL1DzULumUmZyyokeSGJDY1n5M6neUfAj2sjbf65wYwQM",
+                "text" : "C=JP,L=Tokyo,O=Bank C"
+            },
+            {
+                "id" : "8Kqd4oWdx4KQGHGTBm34eCM2nrpcWKeM1ZG3DUYat3JTFUQTwB3Lv2WbPM8",
+                "text" : "C=US,L=New York,O=Bank B"
+            }
+        ]
+    }
+
+Now, if we ask the same question of Bank C we will see that it's id matches the id for Bank C as a counter
+party to Bank A and Bank A will appear as a counter party
+
+.. sourcecode:: bash
+
+  curl -i -H "Content-Type: application/json" -X GET http://localhost:10011/api/simmvaluationdemo/whoami
+
+**Creating a trade with Bank C**
+
+In what follows, we assume we are Bank A (which is listening on port 10005)
+
+Notice the id field in the output of the ``whoami`` command. We are going to use the id assocatied
+with Bank C, one of our counter parties, to create a trade. The general command for this is:
+
+.. sourcecode:: bash
+
+  curl -i -H "Content-Type: application/json" -X PUT -d <<<JSON representation of the trade>>>  http://localhost:10005/api/simmvaluationdemo/<<<counter party id>>>/trades
+
+where the representation of the trade is
+
+.. sourcecode:: none
+
+  {
+      "id"          : "trade1",
+      "description" : "desc",
+      "tradeDate"   : [ 2016, 6, 6 ],
+      "convention"  : "EUR_FIXED_1Y_EURIBOR_3M",
+      "startDate"   : [ 2016, 6, 6 ],
+      "endDate"     : [ 2020, 1, 2 ],
+      "buySell"     : "BUY",
+      "notional"    : "1000",
+      "fixedRate"   : "0.1"
+  }
+
+Continuing our example, the specific command we would run is
+
+.. sourcecode:: bash
+
+    curl -i -H "Content-Type: application/json" \
+        -X PUT \
+        -d '{"id":"trade1","description" : "desc","tradeDate" : [ 2016, 6, 6 ],  "convention" : "EUR_FIXED_1Y_EURIBOR_3M",  "startDate" : [ 2016, 6, 6 ],  "endDate" : [ 2020, 1, 2 ],  "buySell" : "BUY",  "notional" : "1000",  "fixedRate" : "0.1"}' \
+        http://localhost:10005/api/simmvaluationdemo/8Kqd4oWdx4KQGHGL1DzULumUmZyyokeSGJDY1n5M6neUfAj2sjbf65wYwQM/trades
+
+With an expected response of
+
+.. sourcecode:: none
+
+  HTTP/1.1 202 Accepted
+  Date: Thu, 28 Sep 2017 17:19:39 GMT
+  Content-Type: text/plain
+      Access-Control-Allow-Origin: *
+  Content-Length: 2
+  Server: Jetty(9.3.9.v20160517)
+
+**Verifying trade completion**
+
+With the trade completed and stored by both parties, the complete list of trades with our couterparty can be seen with the following command
+
+.. sourcecode:: bash
+
+  curl -X GET http://localhost:10005/api/simmvaluationdemo/<<<counter party id>>>/trades
+
+The command for our example, using Bank A, would thus be
+
+.. sourcecode:: bash
+
+  curl -X GET http://localhost:10005/api/simmvaluationdemo/8Kqd4oWdx4KQGHGL1DzULumUmZyyokeSGJDY1n5M6neUfAj2sjbf65wYwQM/trades
+
+whilst a specific trade can be seen with
+
+.. sourcecode:: bash
+
+ curl  -X GET http://localhost:10005/api/simmvaluationdemo/<<<counter party id>>>/trades/<<<trade id>>>
+
+If we look at the trade we created above, we assigned it the id "trade1", the complete command in this case would be
+
+.. sourcecode:: bash
+
+ curl  -X GET http://localhost:10005/api/simmvaluationdemo/8Kqd4oWdx4KQGHGL1DzULumUmZyyokeSGJDY1n5M6neUfAj2sjbf65wYwQM/trades/trade1
+
+**Generating a valuation**
+
+.. sourcecode:: bash
+
+    curl -i -H "Content-Type: application/json" \
+        -X POST \
+        -d <<<JSON representation>>>
+        http://localhost:10005/api/simmvaluationdemo/<<<counter party id>>>/portfolio/valuations/calculate
+
+Again, the specific command to continue our example would be
+
+.. sourcecode:: bash
+
+    curl -i -H "Content-Type: application/json" \
+        -X POST \
+        -d '{"valuationDate":[2016,6,6]}' \
+        http://localhost:10005/api/simmvaluationdemo/8Kqd4oWdx4KQGHGL1DzLumUmZyyokeSGJDY1n5M6neUfAj2sjbf65wYwQM/portfolio/valuations/calculate
+
+**Viewing a valuation**
+
+In the same way we can ask for specific instances of trades with a counter party, we can request details of valuations
+
+.. sourcecode:: bash
+
+  curl -i -H "Content-Type: application/json" -X GET http://localhost:10005/api/simmvaluationdemo/<<<counter party id>>>/portfolio/valuations
+
+The specific command for out Bank A example is
+
+.. sourcecode:: bash
+
+  curl -i -H "Content-Type: application/json" \
+    -X GET http://localhost:10005/api/simmvaluationdemo/8Kqd4oWdx4KQGHGL1DzULumUmZyyokeSGJDY1n5M6neUfAj2sjbf65YwQM/portfolio/valuations
+
+
+
+
+
diff --git a/samples/simm-valuation-demo/build.gradle b/samples/simm-valuation-demo/build.gradle
index b06cef6212..1d7d654ee8 100644
--- a/samples/simm-valuation-demo/build.gradle
+++ b/samples/simm-valuation-demo/build.gradle
@@ -62,6 +62,8 @@ dependencies {
 }
 
 task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
+    ext.rpcUsers = [['username': "default", 'password': "default", 'permissions': [ 'ALL' ]]]
+
     directory "./build/nodes"
     networkMap "O=Notary Service,L=Zurich,C=CH"
     node {
@@ -75,21 +77,27 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
         advertisedServices = []
         p2pPort 10004
         webPort 10005
+        rpcPort 10006
         cordapps = ["net.corda:finance:$corda_release_version"]
+        rpcUsers = ext.rpcUsers
     }
     node {
         name "O=Bank B,L=New York,C=US"
         advertisedServices = []
-        p2pPort 10006
-        webPort 10007
+        p2pPort 10007
+        webPort 10008
+        rpcPort 10009
         cordapps = ["net.corda:finance:$corda_release_version"]
+        rpcUsers = ext.rpcUsers
     }
     node {
         name "O=Bank C,L=Tokyo,C=JP"
         advertisedServices = []
-        p2pPort 10008
-        webPort 10009
+        p2pPort 10010
+        webPort 10011
+        rpcPort 10012
         cordapps = ["net.corda:finance:$corda_release_version"]
+        rpcUsers = ext.rpcUsers
     }
 }
 

From 7787896cbbd917a81fdc277015835b963fa66f98 Mon Sep 17 00:00:00 2001
From: Rick Parker <rick.parker@r3.com>
Date: Fri, 29 Sep 2017 13:13:38 +0100
Subject: [PATCH 042/185] Hide SerializationContext from public API on
 TransactionBuilder (#1715)

---
 .../net/corda/core/internal/InternalUtils.kt  | 21 ++++++++++++++++++-
 .../core/transactions/TransactionBuilder.kt   |  9 +++++---
 .../internal/AttachmentsClassLoaderTests.kt   |  2 ++
 .../node/services/AttachmentLoadingTests.kt   |  1 +
 4 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
index 5d3eafdca1..ccc6cee84c 100644
--- a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
@@ -2,6 +2,11 @@ package net.corda.core.internal
 
 import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.sha256
+import net.corda.core.node.ServiceHub
+import net.corda.core.node.ServicesForResolution
+import net.corda.core.serialization.SerializationContext
+import net.corda.core.transactions.TransactionBuilder
+import net.corda.core.transactions.WireTransaction
 import org.bouncycastle.cert.X509CertificateHolder
 import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter
 import org.slf4j.Logger
@@ -273,4 +278,18 @@ annotation class VisibleForTesting
 @Suppress("UNCHECKED_CAST")
 fun <T, U : T> uncheckedCast(obj: T) = obj as U
 
-fun <K, V> Iterable<Pair<K, V>>.toMultiMap(): Map<K, List<V>> = this.groupBy({ it.first }) { it.second }
\ No newline at end of file
+fun <K, V> Iterable<Pair<K, V>>.toMultiMap(): Map<K, List<V>> = this.groupBy({ it.first }) { it.second }
+
+/**
+ * Provide access to internal method for AttachmentClassLoaderTests
+ * @suppress
+ */
+fun TransactionBuilder.toWireTransaction(services: ServicesForResolution, serializationContext: SerializationContext): WireTransaction {
+    return toWireTransactionWithContext(services, serializationContext)
+}
+
+/**
+ * Provide access to internal method for AttachmentClassLoaderTests
+ * @suppress
+ */
+fun TransactionBuilder.toLedgerTransaction(services: ServiceHub, serializationContext: SerializationContext) = toLedgerTransactionWithContext(services, serializationContext)
diff --git a/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt b/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt
index 9f972ee155..ad6c538451 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt
@@ -81,9 +81,10 @@ open class TransactionBuilder(
      *
      * @returns A new [WireTransaction] that will be unaffected by further changes to this [TransactionBuilder].
      */
-    @JvmOverloads
     @Throws(MissingContractAttachments::class)
-    fun toWireTransaction(services: ServicesForResolution, serializationContext: SerializationContext? = null): WireTransaction {
+    fun toWireTransaction(services: ServicesForResolution): WireTransaction = toWireTransactionWithContext(services)
+
+    internal fun toWireTransactionWithContext(services: ServicesForResolution, serializationContext: SerializationContext? = null): WireTransaction {
         // Resolves the AutomaticHashConstraints to HashAttachmentConstraints for convenience. The AutomaticHashConstraint
         // allows for less boiler plate when constructing transactions since for the typical case the named contract
         // will be available when building the transaction. In exceptional cases the TransactionStates must be created
@@ -103,7 +104,9 @@ open class TransactionBuilder(
     }
 
     @Throws(AttachmentResolutionException::class, TransactionResolutionException::class)
-    fun toLedgerTransaction(services: ServiceHub, serializationContext: SerializationContext? = null) = toWireTransaction(services, serializationContext).toLedgerTransaction(services)
+    fun toLedgerTransaction(services: ServiceHub) = toWireTransaction(services).toLedgerTransaction(services)
+
+    internal fun toLedgerTransactionWithContext(services: ServiceHub, serializationContext: SerializationContext) = toWireTransactionWithContext(services, serializationContext).toLedgerTransaction(services)
 
     @Throws(AttachmentResolutionException::class, TransactionResolutionException::class, TransactionVerificationException::class)
     fun verify(services: ServiceHub) {
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
index 5fc205e666..9d756a8812 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
@@ -5,6 +5,8 @@ import com.nhaarman.mockito_kotlin.whenever
 import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
 import net.corda.core.internal.declaredField
+import net.corda.core.internal.toLedgerTransaction
+import net.corda.core.internal.toWireTransaction
 import net.corda.core.node.ServiceHub
 import net.corda.core.node.services.AttachmentStorage
 import net.corda.core.serialization.*
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
index 4a344aec4e..353203e557 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@@ -10,6 +10,7 @@ import net.corda.core.identity.Party
 import net.corda.core.internal.concurrent.transpose
 import net.corda.core.internal.createDirectories
 import net.corda.core.internal.div
+import net.corda.core.internal.toLedgerTransaction
 import net.corda.core.serialization.SerializationFactory
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.OpaqueBytes

From c2b0ed6ed5b7f152f1f8281669f6df1670036790 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Fri, 29 Sep 2017 13:43:42 +0100
Subject: [PATCH 043/185] CORDA-650: Eliminate unnecessary dependency on
 "graphstream" library (#1732)

This library has one usage in ClientRPC example and:
* Uses Scala 2.10 - which is quite dated
* Has a transitive dependency on JUnit
---
 docs/source/example-code/build.gradle   | 1 +
 node/build.gradle                       | 5 -----
 samples/network-visualiser/build.gradle | 2 --
 3 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/docs/source/example-code/build.gradle b/docs/source/example-code/build.gradle
index 46336ef9f0..cf0c3046e8 100644
--- a/docs/source/example-code/build.gradle
+++ b/docs/source/example-code/build.gradle
@@ -39,6 +39,7 @@ dependencies {
     compile "org.graphstream:gs-core:1.3"
     compile("org.graphstream:gs-ui:1.3") {
         exclude group: "bouncycastle"
+        exclude group: "junit"
     }
 
     cordaCompile project(path: ":node:capsule", configuration: 'runtimeArtifacts')
diff --git a/node/build.gradle b/node/build.gradle
index f793837c13..6a0c142c9f 100644
--- a/node/build.gradle
+++ b/node/build.gradle
@@ -108,11 +108,6 @@ dependencies {
     // Manifests: for reading stuff from the manifest file
     compile "com.jcabi:jcabi-manifests:1.1"
 
-    // GraphStream: For visualisation
-    testCompile "org.graphstream:gs-core:1.3"
-    testCompile("org.graphstream:gs-ui:1.3") {
-        exclude group: "bouncycastle"
-    }
     compile("com.intellij:forms_rt:7.0.3") {
         exclude group: "asm"
     }
diff --git a/samples/network-visualiser/build.gradle b/samples/network-visualiser/build.gradle
index d472b1e5b3..72ba1207c3 100644
--- a/samples/network-visualiser/build.gradle
+++ b/samples/network-visualiser/build.gradle
@@ -21,8 +21,6 @@ dependencies {
     // Cordapp dependencies
     // GraphStream: For visualisation
     compileOnly "co.paralleluniverse:capsule:$capsule_version"
-    compile "org.graphstream:gs-core:1.3"
-    compile "org.graphstream:gs-ui:1.3"
 }
 
 idea {

From 2704165d7a358eca6b0fc9705ab6cc2a77e31625 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Fri, 29 Sep 2017 14:57:47 +0100
Subject: [PATCH 044/185] CORDA-649: Disable unstable test (#1733)

---
 .../node/services/network/PersistentNetworkMapCacheTest.kt      | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
index 0e69839461..4da002b539 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
@@ -17,6 +17,7 @@ import net.corda.testing.*
 import net.corda.testing.node.NodeBasedTest
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Before
+import org.junit.Ignore
 import org.junit.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFails
@@ -113,6 +114,7 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
         assertFails { startNode(CHARLIE.name, noNetworkMap = true).getOrThrow(2.seconds) }
     }
 
+    @Ignore("Unstable test that needs more work")
     @Test
     fun `new node joins network without network map started`() {
 

From cac739e48d349369e5329ed2f215d7450344b1eb Mon Sep 17 00:00:00 2001
From: Katarzyna Streich <katarzyna.streich@r3.com>
Date: Fri, 29 Sep 2017 15:38:05 +0100
Subject: [PATCH 045/185] Add explanation to NetworkMapCache docs. (#1727)

NodeInfo lookup can return more than one node for distribute services.
---
 .../main/kotlin/net/corda/core/messaging/CordaRPCOps.kt   | 2 ++
 .../net/corda/core/node/services/NetworkMapCache.kt       | 8 +++++++-
 .../node/services/network/PersistentNetworkMapCache.kt    | 2 +-
 3 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt b/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
index 50664c52e3..60979b02cb 100644
--- a/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
+++ b/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
@@ -271,6 +271,8 @@ interface CordaRPCOps : RPCOps {
 
     /**
      * Returns a node's info from the network map cache, where known.
+     * Notice that when there are more than one node for a given name (in case of distributed services) first service node
+     * found will be returned.
      *
      * @return the node info if available.
      */
diff --git a/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt b/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
index 8eb0a52a07..428a656220 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
@@ -50,6 +50,8 @@ interface NetworkMapCache {
      * Look up the node info for a specific party. Will attempt to de-anonymise the party if applicable; if the party
      * is anonymised and the well known party cannot be resolved, it is impossible ot identify the node and therefore this
      * returns null.
+     * Notice that when there are more than one node for a given party (in case of distributed services) first service node
+     * found will be returned. See also: [getNodesByLegalIdentityKey].
      *
      * @param party party to retrieve node information for.
      * @return the node for the identity, or null if the node could not be found. This does not necessarily mean there is
@@ -57,7 +59,11 @@ interface NetworkMapCache {
      */
     fun getNodeByLegalIdentity(party: AbstractParty): NodeInfo?
 
-    /** Look up the node info for a legal name. */
+    /**
+     * Look up the node info for a legal name.
+     * Notice that when there are more than one node for a given name (in case of distributed services) first service node
+     * found will be returned.
+     */
     fun getNodeByLegalName(name: CordaX500Name): NodeInfo?
 
     /** Look up the node info for a host and port. */
diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
index 3260da43ca..400db60ef3 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
@@ -112,7 +112,7 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
     override fun getNodeByLegalIdentity(party: AbstractParty): NodeInfo? {
         val wellKnownParty = serviceHub.identityService.wellKnownPartyFromAnonymous(party)
         return wellKnownParty?.let {
-            getNodesByLegalIdentityKey(it.owningKey).singleOrNull()
+            getNodesByLegalIdentityKey(it.owningKey).firstOrNull()
         }
     }
 

From de88f3ecba6e7d2c725919a905b08c179646cfaf Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Fri, 29 Sep 2017 16:29:09 +0100
Subject: [PATCH 046/185] Contract constraints documentation (#1703)

* Added a contract constraints section to the key concepts doc.

* Documentation for contract constraints.

* Added to index.

* Review fixes round 1.

* More review fixes.

* Review fixes.

* Explained package contents.

* review fixes.

* Addressed RGB's final review comments.

* Updated source code type to 'java'
---
 docs/packages.md                              |   6 +
 docs/source/cordapp-overview.rst              |   2 +-
 .../key-concepts-contract-constraints.rst     | 149 ++++++++++++++++++
 docs/source/key-concepts.rst                  |   1 +
 4 files changed, 157 insertions(+), 1 deletion(-)
 create mode 100644 docs/source/key-concepts-contract-constraints.rst

diff --git a/docs/packages.md b/docs/packages.md
index 61a4b2cb93..2c2090e790 100644
--- a/docs/packages.md
+++ b/docs/packages.md
@@ -24,6 +24,12 @@ RPC client interface to Corda, for use both by user-facing client and integratio
 
 Internal, do not use. These APIs and implementations which are currently being revised and are subject to future change.
 
+# Package net.corda.core.cordapp
+
+This package contains the interface to CorDapps from within a node. A CorDapp can access its own context by using
+the CordappProvider.getAppContext() class. These classes are not intended to be constructed manually and no interface
+to do this will be provided. 
+
 # Package net.corda.core.concurrent
 
 Provides a simplified [java.util.concurrent.Future] class that allows registration of a callback to execute when the future
diff --git a/docs/source/cordapp-overview.rst b/docs/source/cordapp-overview.rst
index 2999489ef6..6ac7bbedd3 100644
--- a/docs/source/cordapp-overview.rst
+++ b/docs/source/cordapp-overview.rst
@@ -22,4 +22,4 @@ CorDapps are made up of definitions for the following components:
 * Contracts
 * Flows
 * Web APIs and static web content
-* Services
+* Services
\ No newline at end of file
diff --git a/docs/source/key-concepts-contract-constraints.rst b/docs/source/key-concepts-contract-constraints.rst
new file mode 100644
index 0000000000..6c3e536264
--- /dev/null
+++ b/docs/source/key-concepts-contract-constraints.rst
@@ -0,0 +1,149 @@
+Contract Constraints
+====================
+
+A basic understanding of contract key concepts, which can be found :doc:`here </key-concepts-contracts>`,
+is required reading for this page.
+
+Transaction states specify a constraint over the contract that will be used to verify it.  For a transaction to be
+valid, the verify() function associated with each state must run successfully. However, for this to be secure, it is
+not sufficient to specify the verify() function by name as there may exist multiple different implementations with the
+same method signature and enclosing class. Contract constraints solve this problem by allowing a contract developer to
+constrain which verify() functions out of the universe of implementations can be used.
+(ie the universe is everything that matches the signature and contract constraints restricts this universe to a subset.)
+
+A typical constraint is the hash of the CorDapp JAR that contains the contract and states but will in future releases
+include constraints that require specific signers of the JAR, or both the signer and the hash. Constraints can be
+specified when constructing a transaction; if unspecified, an automatic constraint is used.
+
+``TransactionState``s have a ``constraint`` field that represents that state's attachment constraint. When a party
+constructs a ``TransactionState`` without specifying the constraint parameter a default value
+(``AutomaticHashConstraint``) is used. This default will be automatically resolved to a specific
+``HashAttachmentConstraint`` that contains the hash of the attachment which contains the contract of that
+``TransactionState``. This automatic resolution occurs when a ``TransactionBuilder`` is converted to a
+``WireTransaction``. This reduces the boilerplate involved in finding a specific hash constraint when building a transaction.
+
+It is possible to specify the constraint explicitly with any other class that implements the ``AttachmentConstraint``
+interface. To specify a hash manually the ``HashAttachmentConstraint`` can be used and to not provide any constraint
+the ``AlwaysAcceptAttachmentConstraint`` can be used - though this is intended for testing only. An example below
+shows how to construct a ``TransactionState`` with an explicitly specified hash constraint from within a flow;
+
+.. sourcecode:: java
+
+     // Constructing a transaction with a custom hash constraint on a state
+     TransactionBuilder tx = new TransactionBuilder()
+
+     Party notaryParty = ... // a notary party
+     DummyState contractState = new DummyState()
+     SecureHash myAttachmentsHash = serviceHub.cordappProvider.getContractAttachmentID(DummyContract.PROGRAM_ID)
+     TransactionState transactionState = new TransactionState(contractState, DummyContract.Companion.getPROGRAMID(), notaryParty, new AttachmentHashConstraint(myAttachmentsHash))
+
+     tx.addOutputState(transactionState)
+     WireTransaction wtx = tx.toWireTransaction(serviceHub) // This is where an automatic constraint would be resolved
+     LedgerTransaction ltx = wtx.toLedgerTransaction(serviceHub)
+     ltx.verify() // Verifies both the attachment constraints and contracts
+
+
+This mechanism exists both for integrity and security reasons. It is important not to verify against the wrong contract,
+which could happen if the wrong version of the contract is attached. More importantly when resolving transaction chains
+there will, in a future release, be attachments loaded from the network into the attachment sandbox that are used
+to verify the transaction chain. Ensuring the attachment used is the correct one ensures that the verification will
+not be tamperable by providing a fake contract.
+
+CorDapps as attachments
+-----------------------
+
+CorDapp JARs (:doc:`cordapp-overview`) that are installed to the node and contain classes implementing the ``Contract``
+interface are automatically loaded into the ``AttachmentStorage`` of a node at startup.
+
+After CorDapps are loaded into the attachment store the node creates a link between contract classes and the
+attachment that they were loaded from. This makes it possible to find the attachment for any given contract.
+This is how the automatic resolution of attachments is done by the ``TransactionBuilder`` and how, when verifying
+the constraints and contracts, attachments are associated with their respective contracts.
+
+Implementations
+---------------
+
+There are three implementations of ``AttachmentConstraints`` with more planned in the future.
+
+``AlwaysAcceptAttachmentConstraint``: Any attachment (except a missing one) will satisfy this constraint.
+
+``AutomaticHashConstraint``: This will be resolved to a ``HashAttachmentConstraint`` when a ``TransactionBuilder`` is
+converted to a ``WireTransaction``. The ``HashAttachmentConstraint`` will include the attachment hash of the CorDapp
+that contains the ``ContractState`` on the ``TransactionState.contract`` field.
+
+``HashAttachmentConstraint``: Will require that the hash of the attachment containing the contract matches the hash
+stored in the constraint.
+
+We plan to add a future ``AttachmentConstraint`` that will only be satisfied by the presence of signatures on the
+attachment JAR. This allows for trusting of attachments from trusted entities.
+
+Limitations
+-----------
+
+``AttachmentConstraint``s are verified by running the ``AttachmentConstraint.isSatisfiedBy`` method. When this is called
+it is provided only the relevant attachment by the transaction that is verifying it.
+
+Testing
+-------
+
+Since all tests involving transactions now require attachments it is also required to load the correct attachments
+for tests. Unit test environments in JVM ecosystems tend to use class directories rather than JARs, and so CorDapp JARs
+typically aren't built for testing. Requiring this would add significant complexity to the build systems of Corda
+and CorDapps, so the test suite has a set of convenient functions to generate CorDapps from package names or
+to specify JAR URLs in the case that the CorDapp(s) involved in testing already exist.
+
+MockNetwork/MockNode
+********************
+
+The most simple way to ensure that a vanilla instance of a MockNode generates the correct CorDapps is to make a call
+to ``setCordappPackages`` before the MockNetwork/Node are created and then ``unsetCordappPackages`` after the test
+has finished. These calls will cause the ``AbstractNode`` to use the named packages as sources for CorDapps. All files
+within those packages will be zipped into a JAR and added to the attachment store and loaded as CorDapps by the
+``CordappLoader``. An example of this usage would be:
+
+.. sourcecode:: java
+
+    class SomeTestClass {
+         MockNetwork network = null
+
+         @Before
+         void setup() {
+             // The ordering of the two below lines is important - if the MockNetwork is created before the nodes and network
+             // are created the CorDapps will not be loaded into the MockNodes correctly.
+             setCordappPackages(Arrays.asList("com.domain.cordapp"))
+             network = new MockNetwork()
+         }
+
+         @After
+         void teardown() {
+             // This must be called at the end otherwise the global state set by setCordappPackages may leak into future
+             // tests in the same test runner environment.
+             unsetCordappPackages()
+         }
+
+         ... // Your tests go here
+    }
+
+MockServices
+************
+
+If your test uses a ``MockServices`` directly you can instantiate it using a constructor that takes a list of packages
+to use as CorDapps using the ``cordappPackages`` parameter.
+
+.. sourcecode:: java
+
+    MockServices mockServices = new MockServices(Arrays.asList("com.domain.cordapp"))
+
+Driver
+******
+
+The driver takes a parameter called ``extraCordappPackagesToScan`` which is a list of packages to use as CorDapps.
+
+.. sourcecode:: java
+
+   driver(new DriverParameters().setExtraCordappPackagesToScan(Arrays.asList("com.domain.cordapp"))) ...
+
+Full Nodes
+**********
+
+When testing against full nodes simply place your CorDapp into the plugins directory of the node.
diff --git a/docs/source/key-concepts.rst b/docs/source/key-concepts.rst
index fdf2b0231c..e83d04d093 100644
--- a/docs/source/key-concepts.rst
+++ b/docs/source/key-concepts.rst
@@ -15,6 +15,7 @@ This section should be read in order:
    key-concepts-ledger
    key-concepts-states
    key-concepts-contracts
+   key-concepts-contract-constraints
    key-concepts-transactions
    key-concepts-flows
    key-concepts-consensus

From 7861135403fb3b9c2f15912745e52f375dd132dd Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Fri, 29 Sep 2017 16:46:59 +0100
Subject: [PATCH 047/185] Hide companion object completely from external
 visibility (#1742)

---
 .../kotlin/net/corda/core/transactions/SignedTransaction.kt     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
index 2705e02ef9..af811c25b3 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
@@ -189,7 +189,7 @@ data class SignedTransaction(val txBits: SerializedBytes<CoreTransaction>,
 
     override fun toString(): String = "${javaClass.simpleName}(id=$id)"
 
-    companion object {
+    private companion object {
         private fun missingSignatureMsg(missing: Set<PublicKey>, descriptions: List<String>, id: SecureHash): String =
                 "Missing signatures for $descriptions on transaction ${id.prefixChars()} for ${missing.joinToString()}"
     }

From 1e12aebe0a22ed692b66cb37a9479bd889dba61b Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Fri, 29 Sep 2017 16:55:26 +0100
Subject: [PATCH 048/185] Gradle API Scanner plugin (#1669)

* Skeleton plugin.
* Implement Gradle api-scanner plugin, and apply it.
* Generate API documentation for any jar without a classifier.
* Fix usage of smokeTests classifier.
* Tweak Gradle API usage.
* Upgrade to fast-classpath-scanner 2.7.0
* Include interfaces and more modifiers in the class description.
* Allow system classes to be supertypes and implemented interfaces.
* Make API Scanner plugin configuration tweakable via build.gradle.
* Add a miserable amount of unit testing.
* Sort methods and fields using their natural comparators. Way easier!
* Add README for api-scanner plugin.
* Add @OutputFiles to ScanApiTask.
* Rename ScanApiTask to ScanApi.
* Allow the ScanApi task to be disabled.
* WIP: Create a top-level GenerateApi task to collate the ScanApi output.
* Exclude package-private classes, as well as bridge/synthetic methods.
* Replace "End of Class" delimiter with '##'.
* Don't scan modules whose API is still "in flux".
* Include constructors in the API definitions.
* Finish implementation of GenerateApi task.
* Update README to include GenerateApi task.
* Filter out Kotlin's "internal" methods.
* Assign "fatjar" classifier to the fat jar artifact.
* Enhance README for GenerateApi.
* Explain effect of api-scanner plugin, and link to Corda's API strategy.
* Tweak README
* Exclude synthetic Kotlin classes by analysing @Metadata.
* Allow us to exclude some classes explicitly from the API.
---
 build.gradle                                  |   5 +
 client/jackson/build.gradle                   |   1 +
 client/jfx/build.gradle                       |   2 +-
 client/mock/build.gradle                      |   2 +-
 client/rpc/build.gradle                       |   1 +
 constants.properties                          |   2 +-
 core/build.gradle                             |   8 +
 gradle-plugins/api-scanner/README.md          |  79 +++++
 gradle-plugins/api-scanner/build.gradle       |  18 +
 .../java/net/corda/plugins/ApiScanner.java    |  70 ++++
 .../java/net/corda/plugins/GenerateApi.java   |  61 ++++
 .../main/java/net/corda/plugins/ScanApi.java  | 311 ++++++++++++++++++
 .../net/corda/plugins/ScannerExtension.java   |  37 +++
 .../net.corda.plugins.api-scanner.properties  |   1 +
 gradle-plugins/build.gradle                   |   4 +-
 gradle-plugins/cordformation/build.gradle     |   2 +-
 gradle-plugins/settings.gradle                |   3 +-
 node/build.gradle                             |   2 +-
 .../kotlin/net/corda/node/CordappSmokeTest.kt |   2 +-
 19 files changed, 602 insertions(+), 9 deletions(-)
 create mode 100644 gradle-plugins/api-scanner/README.md
 create mode 100644 gradle-plugins/api-scanner/build.gradle
 create mode 100644 gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ApiScanner.java
 create mode 100644 gradle-plugins/api-scanner/src/main/java/net/corda/plugins/GenerateApi.java
 create mode 100644 gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
 create mode 100644 gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScannerExtension.java
 create mode 100644 gradle-plugins/api-scanner/src/main/resources/META-INF/gradle-plugins/net.corda.plugins.api-scanner.properties

diff --git a/build.gradle b/build.gradle
index 1a624d147a..63cce612c6 100644
--- a/build.gradle
+++ b/build.gradle
@@ -60,6 +60,7 @@ buildscript {
         classpath "net.corda.plugins:publish-utils:$gradle_plugins_version"
         classpath "net.corda.plugins:quasar-utils:$gradle_plugins_version"
         classpath "net.corda.plugins:cordformation:$gradle_plugins_version"
+        classpath "net.corda.plugins:api-scanner:$gradle_plugins_version"
         classpath 'com.github.ben-manes:gradle-versions-plugin:0.15.0'
         classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version"
         classpath "org.jetbrains.dokka:dokka-gradle-plugin:${dokka_version}"
@@ -302,3 +303,7 @@ artifactory {
         }
     }
 }
+
+task generateApi(type: net.corda.plugins.GenerateApi){
+    baseName = "api-corda"
+}
diff --git a/client/jackson/build.gradle b/client/jackson/build.gradle
index 4e6c9b1f69..bcff947dfb 100644
--- a/client/jackson/build.gradle
+++ b/client/jackson/build.gradle
@@ -1,6 +1,7 @@
 apply plugin: 'java'
 apply plugin: 'kotlin'
 apply plugin: 'net.corda.plugins.publish-utils'
+apply plugin: 'net.corda.plugins.api-scanner'
 apply plugin: 'com.jfrog.artifactory'
 
 dependencies {
diff --git a/client/jfx/build.gradle b/client/jfx/build.gradle
index 7dd7878175..867ba2b9f0 100644
--- a/client/jfx/build.gradle
+++ b/client/jfx/build.gradle
@@ -61,4 +61,4 @@ jar {
 
 publish {
     name jar.baseName
-}
\ No newline at end of file
+}
diff --git a/client/mock/build.gradle b/client/mock/build.gradle
index 7432fdd312..1080cf9b7a 100644
--- a/client/mock/build.gradle
+++ b/client/mock/build.gradle
@@ -25,4 +25,4 @@ jar {
 
 publish {
     name jar.baseName
-}
\ No newline at end of file
+}
diff --git a/client/rpc/build.gradle b/client/rpc/build.gradle
index 2f36d1c315..d8c61b4a99 100644
--- a/client/rpc/build.gradle
+++ b/client/rpc/build.gradle
@@ -1,6 +1,7 @@
 apply plugin: 'kotlin'
 apply plugin: 'net.corda.plugins.quasar-utils'
 apply plugin: 'net.corda.plugins.publish-utils'
+apply plugin: 'net.corda.plugins.api-scanner'
 apply plugin: 'com.jfrog.artifactory'
 
 description 'Corda client RPC modules'
diff --git a/constants.properties b/constants.properties
index 93971c05df..a9ce732db8 100644
--- a/constants.properties
+++ b/constants.properties
@@ -1,4 +1,4 @@
-gradlePluginsVersion=1.0.0
+gradlePluginsVersion=1.0.1
 kotlinVersion=1.1.50
 guavaVersion=21.0
 bouncycastleVersion=1.57
diff --git a/core/build.gradle b/core/build.gradle
index 655067d680..d821ec7d37 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -2,6 +2,7 @@ apply plugin: 'kotlin'
 apply plugin: 'kotlin-jpa'
 apply plugin: 'net.corda.plugins.quasar-utils'
 apply plugin: 'net.corda.plugins.publish-utils'
+apply plugin: 'net.corda.plugins.api-scanner'
 apply plugin: 'com.jfrog.artifactory'
 
 description 'Corda core'
@@ -94,6 +95,13 @@ jar {
     baseName 'corda-core'
 }
 
+scanApi {
+    excludeClasses = [
+        // Kotlin should probably have declared this class as "synthetic".
+        "net.corda.core.Utils\$toFuture\$1\$subscription\$1"
+    ]
+}
+
 publish {
     name jar.baseName
 }
diff --git a/gradle-plugins/api-scanner/README.md b/gradle-plugins/api-scanner/README.md
new file mode 100644
index 0000000000..9f8fc4f674
--- /dev/null
+++ b/gradle-plugins/api-scanner/README.md
@@ -0,0 +1,79 @@
+# API Scanner
+
+Generates a text summary of Corda's public API that we can check for API-breaking changes.
+
+```bash
+$ gradlew generateApi
+```
+
+See [here](../../docs/source/api-index.rst) for Corda's public API strategy. We will need to
+apply this plugin to other modules in future Corda releases as those modules' APIs stabilise.
+
+Basically, this plugin will document a module's `public` and `protected` classes/methods/fields,
+excluding those from our `*.internal.*` packgages, any synthetic methods, bridge methods, or methods
+identified as having Kotlin's  `internal` scope. (Kotlin doesn't seem to have implemented `internal`
+scope for classes or fields yet as these are currently `public` inside the `.class` file.)
+
+## Usage
+Include this line in the `build.gradle` file of every Corda module that exports public API:
+
+```gradle
+apply plugin: 'net.corda.plugins.api-scanner'
+```
+
+This will create a Gradle task called `scanApi` which will analyse that module's Jar artifacts. More precisely,
+it will analyse all of the Jar artifacts that have not been assigned a Maven classifier, on the basis
+that these should be the module's main artifacts.
+
+The `scanApi` task supports the following configuration options:
+```gradle
+scanApi {
+    // Make the classpath-scanning phase more verbose.
+    verbose = {true|false}
+
+    // Enable / disable the task within this module.
+    enabled = {true|false}
+
+    // Names of classes that should be excluded from the output.
+    excludeClasses = [
+        ...
+    ]
+}
+```
+
+All of the `ScanApi` tasks write their output files to their own `$buildDir/api` directory, where they
+are collated into a single output file by the `GenerateApi` task. The `GenerateApi` task is declared
+in the root project's `build.gradle` file:
+
+```gradle
+task generateApi(type: net.corda.plugins.GenerateApi){
+    baseName = "api-corda"
+}
+```
+
+The final API file is written to `$buildDir/api/$baseName-$project.version.txt`
+
+### Sample Output
+```
+public interface net.corda.core.contracts.Attachment extends net.corda.core.contracts.NamedByHash
+  public abstract void extractFile(String, java.io.OutputStream)
+  @org.jetbrains.annotations.NotNull public abstract List getSigners()
+  @org.jetbrains.annotations.NotNull public abstract java.io.InputStream open()
+  @org.jetbrains.annotations.NotNull public abstract jar.JarInputStream openAsJAR()
+##
+public interface net.corda.core.contracts.AttachmentConstraint
+  public abstract boolean isSatisfiedBy(net.corda.core.contracts.Attachment)
+##
+public final class net.corda.core.contracts.AttachmentResolutionException extends net.corda.core.flows.FlowException
+  public <init>(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getHash()
+##
+```
+
+#### Notes
+The `GenerateApi` task will collate the output of every `ScanApi` task found either in the same project,
+or in any of that project's subprojects. So it is _theoretically_ possible also to collate the API output
+from subtrees of modules simply by defining a new `GenerateApi` task at the root of that subtree.
+
+## Plugin Installation
+See [here](../README.rst) for full installation instructions.
diff --git a/gradle-plugins/api-scanner/build.gradle b/gradle-plugins/api-scanner/build.gradle
new file mode 100644
index 0000000000..85f7b4d0f9
--- /dev/null
+++ b/gradle-plugins/api-scanner/build.gradle
@@ -0,0 +1,18 @@
+apply plugin: 'java'
+apply plugin: 'net.corda.plugins.publish-utils'
+
+description "Generates a summary of the artifact's public API"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    compile gradleApi()
+    compile "io.github.lukehutch:fast-classpath-scanner:2.7.0"
+    testCompile "junit:junit:4.12"
+}
+
+publish {
+    name project.name
+}
diff --git a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ApiScanner.java b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ApiScanner.java
new file mode 100644
index 0000000000..0861605258
--- /dev/null
+++ b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ApiScanner.java
@@ -0,0 +1,70 @@
+package net.corda.plugins;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.ConfigurationContainer;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.tasks.TaskCollection;
+import org.gradle.jvm.tasks.Jar;
+
+public class ApiScanner implements Plugin<Project> {
+
+    /**
+     * Identify the Gradle Jar tasks creating jars
+     * without Maven classifiers, and generate API
+     * documentation for them.
+     * @param p Current project.
+     */
+    @Override
+    public void apply(Project p) {
+        p.getLogger().info("Applying API scanner to {}", p.getName());
+
+        ScannerExtension extension = p.getExtensions().create("scanApi", ScannerExtension.class);
+
+        p.afterEvaluate(project -> {
+            TaskCollection<Jar> jarTasks = project.getTasks()
+                .withType(Jar.class)
+                .matching(jarTask -> jarTask.getClassifier().isEmpty() && jarTask.isEnabled());
+            if (jarTasks.isEmpty()) {
+                return;
+            }
+
+            project.getLogger().info("Adding scanApi task to {}", project.getName());
+            project.getTasks().create("scanApi", ScanApi.class, scanTask -> {
+                scanTask.setClasspath(compilationClasspath(project.getConfigurations()));
+                scanTask.setSources(project.files(jarTasks));
+                scanTask.setExcludeClasses(extension.getExcludeClasses());
+                scanTask.setVerbose(extension.isVerbose());
+                scanTask.setEnabled(extension.isEnabled());
+                scanTask.dependsOn(jarTasks);
+
+                // Declare this ScanApi task to be a dependency of any
+                // GenerateApi tasks belonging to any of our ancestors.
+                project.getRootProject().getTasks()
+                    .withType(GenerateApi.class)
+                    .matching(generateTask -> isAncestorOf(generateTask.getProject(), project))
+                    .forEach(generateTask -> generateTask.dependsOn(scanTask));
+            });
+        });
+    }
+
+    /*
+     * Recurse through a child project's parents until we reach the root,
+     * and return true iff we find our target project along the way.
+     */
+    private static boolean isAncestorOf(Project target, Project child) {
+        Project p = child;
+        while (p != null) {
+            if (p == target) {
+                return true;
+            }
+            p = p.getParent();
+        }
+        return false;
+    }
+
+    private static FileCollection compilationClasspath(ConfigurationContainer configurations) {
+        return configurations.getByName("compile")
+                .plus(configurations.getByName("compileOnly"));
+    }
+}
diff --git a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/GenerateApi.java b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/GenerateApi.java
new file mode 100644
index 0000000000..59dbeca87b
--- /dev/null
+++ b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/GenerateApi.java
@@ -0,0 +1,61 @@
+package net.corda.plugins;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.tasks.OutputFile;
+import org.gradle.api.tasks.TaskAction;
+
+import java.io.*;
+import java.nio.file.Files;
+
+import static java.util.Comparator.comparing;
+import static java.util.stream.Collectors.toList;
+
+@SuppressWarnings("unused")
+public class GenerateApi extends DefaultTask {
+
+    private final File outputDir;
+    private String baseName;
+
+    public GenerateApi() {
+        outputDir = new File(getProject().getBuildDir(), "api");
+        baseName = "api-" + getProject().getName();
+    }
+
+    public void setBaseName(String baseName) {
+        this.baseName = baseName;
+    }
+
+    @InputFiles
+    public FileCollection getSources() {
+        return getProject().files(getProject().getAllprojects().stream()
+            .flatMap(project -> project.getTasks()
+                         .withType(ScanApi.class)
+                         .matching(ScanApi::isEnabled)
+                         .stream())
+            .flatMap(scanTask -> scanTask.getTargets().getFiles().stream())
+            .sorted(comparing(File::getName))
+            .collect(toList())
+        );
+    }
+
+    @OutputFile
+    public File getTarget() {
+        return new File(outputDir, String.format("%s-%s.txt", baseName, getProject().getVersion()));
+    }
+
+    @TaskAction
+    public void generate() {
+        FileCollection apiFiles = getSources();
+        if (!apiFiles.isEmpty() && (outputDir.isDirectory() || outputDir.mkdirs())) {
+            try (OutputStream output = new BufferedOutputStream(new FileOutputStream(getTarget()))) {
+                for (File apiFile : apiFiles) {
+                    Files.copy(apiFile.toPath(), output);
+                }
+            } catch (IOException e) {
+                getLogger().error("Failed to generate API file", e);
+            }
+        }
+    }
+}
diff --git a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
new file mode 100644
index 0000000000..667feb860c
--- /dev/null
+++ b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
@@ -0,0 +1,311 @@
+package net.corda.plugins;
+
+import io.github.lukehutch.fastclasspathscanner.FastClasspathScanner;
+import io.github.lukehutch.fastclasspathscanner.scanner.ClassInfo;
+import io.github.lukehutch.fastclasspathscanner.scanner.FieldInfo;
+import io.github.lukehutch.fastclasspathscanner.scanner.MethodInfo;
+import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.OutputFiles;
+import org.gradle.api.tasks.TaskAction;
+
+import java.io.*;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.*;
+import java.util.stream.StreamSupport;
+
+import static java.util.Collections.unmodifiableSet;
+import static java.util.stream.Collectors.*;
+
+@SuppressWarnings("unused")
+public class ScanApi extends DefaultTask {
+    private static final int CLASS_MASK = Modifier.classModifiers();
+    private static final int INTERFACE_MASK = Modifier.interfaceModifiers() & ~Modifier.ABSTRACT;
+    private static final int METHOD_MASK = Modifier.methodModifiers();
+    private static final int FIELD_MASK = Modifier.fieldModifiers();
+    private static final int VISIBILITY_MASK = Modifier.PUBLIC | Modifier.PROTECTED;
+
+    /**
+     * This information has been lifted from:
+     * @link <a href="https://github.com/JetBrains/kotlin/blob/master/core/runtime.jvm/src/kotlin/Metadata.kt">Metadata.kt</a>
+     */
+    private static final String KOTLIN_METADATA = "kotlin.Metadata";
+    private static final String KOTLIN_CLASSTYPE_METHOD = "k";
+    private static final int KOTLIN_SYNTHETIC = 3;
+
+    private final ConfigurableFileCollection sources;
+    private final ConfigurableFileCollection classpath;
+    private final Set<String> excludeClasses;
+    private final File outputDir;
+    private boolean verbose;
+
+    public ScanApi() {
+        sources = getProject().files();
+        classpath = getProject().files();
+        excludeClasses = new LinkedHashSet<>();
+        outputDir = new File(getProject().getBuildDir(), "api");
+    }
+
+    @Input
+    public FileCollection getSources() {
+        return sources;
+    }
+
+    void setSources(FileCollection sources) {
+        this.sources.setFrom(sources);
+    }
+
+    @Input
+    public FileCollection getClasspath() {
+        return classpath;
+    }
+
+    void setClasspath(FileCollection classpath) {
+        this.classpath.setFrom(classpath);
+    }
+
+    @Input
+    public Collection<String> getExcludeClasses() {
+        return unmodifiableSet(excludeClasses);
+    }
+
+    void setExcludeClasses(Collection<String> excludeClasses) {
+        this.excludeClasses.clear();
+        this.excludeClasses.addAll(excludeClasses);
+    }
+
+    @OutputFiles
+    public FileCollection getTargets() {
+        return getProject().files(
+            StreamSupport.stream(sources.spliterator(), false)
+                .map(this::toTarget)
+                .collect(toList())
+        );
+    }
+
+    public boolean isVerbose() {
+        return verbose;
+    }
+
+    void setVerbose(boolean verbose) {
+        this.verbose = verbose;
+    }
+
+    private File toTarget(File source) {
+        return new File(outputDir, source.getName().replaceAll(".jar$", ".txt"));
+    }
+
+    @TaskAction
+    public void scan() {
+        if (outputDir.isDirectory() || outputDir.mkdirs()) {
+            try (Scanner scanner = new Scanner(classpath)) {
+                for (File source : sources) {
+                    scanner.scan(source);
+                }
+            } catch (IOException e) {
+                getLogger().error("Failed to write API file", e);
+            }
+        } else {
+            getLogger().error("Cannot create directory '{}'", outputDir.getAbsolutePath());
+        }
+    }
+
+    class Scanner implements Closeable {
+        private final URLClassLoader classpathLoader;
+        private final Class<? extends Annotation> metadataClass;
+        private final Method classTypeMethod;
+
+        @SuppressWarnings("unchecked")
+        Scanner(URLClassLoader classpathLoader) {
+            this.classpathLoader = classpathLoader;
+
+            Class<? extends Annotation> kClass;
+            Method kMethod;
+            try {
+                kClass = (Class<Annotation>) Class.forName(KOTLIN_METADATA, true, classpathLoader);
+                kMethod = kClass.getDeclaredMethod(KOTLIN_CLASSTYPE_METHOD);
+            } catch (ClassNotFoundException | NoSuchMethodException e) {
+                kClass = null;
+                kMethod = null;
+            }
+
+            metadataClass = kClass;
+            classTypeMethod = kMethod;
+        }
+
+        Scanner(FileCollection classpath) throws MalformedURLException {
+            this(new URLClassLoader(toURLs(classpath)));
+        }
+
+        @Override
+        public void close() throws IOException {
+            classpathLoader.close();
+        }
+
+        void scan(File source) {
+            File target = toTarget(source);
+            try (
+                URLClassLoader appLoader = new URLClassLoader(new URL[]{ toURL(source) }, classpathLoader);
+                PrintWriter writer = new PrintWriter(target, "UTF-8")
+            ) {
+                scan(writer, appLoader);
+            } catch (IOException e) {
+                getLogger().error("API scan has failed", e);
+            }
+        }
+
+        void scan(PrintWriter writer, ClassLoader appLoader) {
+            ScanResult result = new FastClasspathScanner(getScanSpecification())
+                .overrideClassLoaders(appLoader)
+                .ignoreParentClassLoaders()
+                .ignoreMethodVisibility()
+                .ignoreFieldVisibility()
+                .enableMethodInfo()
+                .enableFieldInfo()
+                .verbose(verbose)
+                .scan();
+            writeApis(writer, result);
+        }
+
+        private String[] getScanSpecification() {
+            String[] spec = new String[2 + excludeClasses.size()];
+            spec[0] = "!";     // Don't blacklist system classes from the output.
+            spec[1] = "-dir:"; // Ignore classes on the filesystem.
+
+            int i = 2;
+            for (String excludeClass : excludeClasses) {
+                spec[i++] = '-' + excludeClass;
+            }
+            return spec;
+        }
+
+        private void writeApis(PrintWriter writer, ScanResult result) {
+            Map<String, ClassInfo> allInfo = result.getClassNameToClassInfo();
+            result.getNamesOfAllClasses().forEach(className -> {
+                if (className.contains(".internal.")) {
+                    // These classes belong to internal Corda packages.
+                    return;
+                }
+                ClassInfo classInfo = allInfo.get(className);
+                if (classInfo.getClassLoaders() == null) {
+                    // Ignore classes that belong to one of our target ClassLoader's parents.
+                    return;
+                }
+
+                Class<?> javaClass = result.classNameToClassRef(className);
+                if (!isVisible(javaClass.getModifiers())) {
+                    // Excludes private and package-protected classes
+                    return;
+                }
+
+                int kotlinClassType = getKotlinClassType(javaClass);
+                if (kotlinClassType == KOTLIN_SYNTHETIC) {
+                    // Exclude classes synthesised by the Kotlin compiler.
+                    return;
+                }
+
+                writeClass(writer, classInfo, javaClass.getModifiers());
+                writeMethods(writer, classInfo.getMethodAndConstructorInfo());
+                writeFields(writer, classInfo.getFieldInfo());
+                writer.println("##");
+            });
+        }
+
+        private void writeClass(PrintWriter writer, ClassInfo classInfo, int modifiers) {
+            if (classInfo.isAnnotation()) {
+                writer.append(Modifier.toString(modifiers & INTERFACE_MASK));
+                writer.append(" @interface ").print(classInfo);
+            } else if (classInfo.isStandardClass()) {
+                writer.append(Modifier.toString(modifiers & CLASS_MASK));
+                writer.append(" class ").print(classInfo);
+                Set<ClassInfo> superclasses = classInfo.getDirectSuperclasses();
+                if (!superclasses.isEmpty()) {
+                    writer.append(" extends ").print(stringOf(superclasses));
+                }
+                Set<ClassInfo> interfaces = classInfo.getDirectlyImplementedInterfaces();
+                if (!interfaces.isEmpty()) {
+                    writer.append(" implements ").print(stringOf(interfaces));
+                }
+            } else {
+                writer.append(Modifier.toString(modifiers & INTERFACE_MASK));
+                writer.append(" interface ").print(classInfo);
+                Set<ClassInfo> superinterfaces = classInfo.getDirectSuperinterfaces();
+                if (!superinterfaces.isEmpty()) {
+                    writer.append(" extends ").print(stringOf(superinterfaces));
+                }
+            }
+            writer.println();
+        }
+
+        private void writeMethods(PrintWriter writer, List<MethodInfo> methods) {
+            Collections.sort(methods);
+            for (MethodInfo method : methods) {
+                if (isVisible(method.getAccessFlags()) // Only public and protected methods
+                        && isValid(method.getAccessFlags(), METHOD_MASK) // Excludes bridge and synthetic methods
+                        && !isKotlinInternalScope(method)) {
+                    writer.append("  ").println(method);
+                }
+            }
+        }
+
+        private void writeFields(PrintWriter output, List<FieldInfo> fields) {
+            Collections.sort(fields);
+            for (FieldInfo field : fields) {
+                if (isVisible(field.getAccessFlags()) && isValid(field.getAccessFlags(), FIELD_MASK)) {
+                    output.append("  ").println(field);
+                }
+            }
+        }
+
+        private int getKotlinClassType(Class<?> javaClass) {
+            if (metadataClass != null) {
+                Annotation metadata = javaClass.getAnnotation(metadataClass);
+                if (metadata != null) {
+                    try {
+                        return (int) classTypeMethod.invoke(metadata);
+                    } catch (IllegalAccessException | InvocationTargetException e) {
+                        getLogger().error("Failed to read Kotlin annotation", e);
+                    }
+                }
+            }
+            return 0;
+        }
+    }
+
+    private static boolean isKotlinInternalScope(MethodInfo method) {
+        return method.getMethodName().indexOf('$') >= 0;
+    }
+
+    private static boolean isValid(int modifiers, int mask) {
+        return (modifiers & mask) == modifiers;
+    }
+
+    private static boolean isVisible(int accessFlags) {
+        return (accessFlags & VISIBILITY_MASK) != 0;
+    }
+
+    private static String stringOf(Collection<ClassInfo> items) {
+        return items.stream().map(ClassInfo::toString).collect(joining(", "));
+    }
+
+    private static URL toURL(File file) throws MalformedURLException {
+        return file.toURI().toURL();
+    }
+
+    private static URL[] toURLs(Iterable<File> files) throws MalformedURLException {
+        List<URL> urls = new LinkedList<>();
+        for (File file : files) {
+            urls.add(toURL(file));
+        }
+        return urls.toArray(new URL[urls.size()]);
+    }
+}
diff --git a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScannerExtension.java b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScannerExtension.java
new file mode 100644
index 0000000000..4e77437cfc
--- /dev/null
+++ b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScannerExtension.java
@@ -0,0 +1,37 @@
+package net.corda.plugins;
+
+import java.util.List;
+
+import static java.util.Collections.emptyList;
+
+@SuppressWarnings("unused")
+public class ScannerExtension {
+
+    private boolean verbose;
+    private boolean enabled = true;
+    private List<String> excludeClasses = emptyList();
+
+    public boolean isVerbose() {
+        return verbose;
+    }
+
+    public void setVerbose(boolean verbose) {
+        this.verbose = verbose;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void setEnabled(boolean enabled) {
+        this.enabled = enabled;
+    }
+
+    public List<String> getExcludeClasses() {
+        return excludeClasses;
+    }
+
+    public void setExcludeClasses(List<String> excludeClasses) {
+        this.excludeClasses = excludeClasses;
+    }
+}
diff --git a/gradle-plugins/api-scanner/src/main/resources/META-INF/gradle-plugins/net.corda.plugins.api-scanner.properties b/gradle-plugins/api-scanner/src/main/resources/META-INF/gradle-plugins/net.corda.plugins.api-scanner.properties
new file mode 100644
index 0000000000..fc9e2277a5
--- /dev/null
+++ b/gradle-plugins/api-scanner/src/main/resources/META-INF/gradle-plugins/net.corda.plugins.api-scanner.properties
@@ -0,0 +1 @@
+implementation-class=net.corda.plugins.ApiScanner
diff --git a/gradle-plugins/build.gradle b/gradle-plugins/build.gradle
index 9825dc1106..acfdbb2b05 100644
--- a/gradle-plugins/build.gradle
+++ b/gradle-plugins/build.gradle
@@ -25,7 +25,7 @@ buildscript {
 apply plugin: 'net.corda.plugins.publish-utils'
 
 allprojects {
-    version "$gradle_plugins_version"
+    version gradle_plugins_version
     group 'net.corda.plugins'
 }
 
@@ -39,7 +39,7 @@ bintrayConfig {
     projectUrl = 'https://github.com/corda/corda'
     gpgSign = true
     gpgPassphrase = System.getenv('CORDA_BINTRAY_GPG_PASSPHRASE')
-    publications = ['cordformation', 'quasar-utils', 'cordform-common']
+    publications = ['cordformation', 'quasar-utils', 'cordform-common', 'api-scanner']
     license {
         name = 'Apache-2.0'
         url = 'https://www.apache.org/licenses/LICENSE-2.0'
diff --git a/gradle-plugins/cordformation/build.gradle b/gradle-plugins/cordformation/build.gradle
index 390ea7c8ba..414aa34b30 100644
--- a/gradle-plugins/cordformation/build.gradle
+++ b/gradle-plugins/cordformation/build.gradle
@@ -51,7 +51,7 @@ task createNodeRunner(type: Jar, dependsOn: [classes]) {
     manifest {
         attributes('Main-Class': 'net.corda.plugins.NodeRunnerKt')
     }
-    baseName = project.name + '-fatjar'
+    classifier = 'fatjar'
     from { configurations.noderunner.collect { it.isDirectory() ? it : zipTree(it) } }
     from sourceSets.runnodes.output
 }
diff --git a/gradle-plugins/settings.gradle b/gradle-plugins/settings.gradle
index f71f2da269..64349cda39 100644
--- a/gradle-plugins/settings.gradle
+++ b/gradle-plugins/settings.gradle
@@ -2,4 +2,5 @@ rootProject.name = 'corda-gradle-plugins'
 include 'publish-utils'
 include 'quasar-utils'
 include 'cordformation'
-include 'cordform-common'
\ No newline at end of file
+include 'cordform-common'
+include 'api-scanner'
diff --git a/node/build.gradle b/node/build.gradle
index 6a0c142c9f..bcdc43d571 100644
--- a/node/build.gradle
+++ b/node/build.gradle
@@ -188,7 +188,7 @@ task integrationTest(type: Test) {
 }
 
 task smokeTestJar(type: Jar) {
-    baseName = project.name + '-smoke-test'
+    classifier 'smokeTests'
     from sourceSets.smokeTest.output
 }
 
diff --git a/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt b/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt
index bd2d072d64..a4bfc6d12b 100644
--- a/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt
+++ b/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt
@@ -42,7 +42,7 @@ class CordappSmokeTest {
         val pluginsDir = (factory.baseDirectory(aliceConfig) / "plugins").createDirectories()
         // Find the jar file for the smoke tests of this module
         val selfCordapp = Paths.get("build", "libs").list {
-            it.filter { "-smoke-test" in it.toString() }.toList().single()
+            it.filter { "-smokeTests" in it.toString() }.toList().single()
         }
         selfCordapp.copyToDirectory(pluginsDir)
 

From e9ec8f96500b79befb8db8ab4846ea6809c4f6d0 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Fri, 29 Sep 2017 17:42:49 +0100
Subject: [PATCH 049/185] Fixes docsite dead links.

---
 docs/source/json.rst  | 4 ++--
 docs/source/shell.rst | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/source/json.rst b/docs/source/json.rst
index 126c9f5791..773ad9bccc 100644
--- a/docs/source/json.rst
+++ b/docs/source/json.rst
@@ -19,8 +19,8 @@ connection to the node (see ":doc:`clientrpc`") then your JSON mapper can resolv
 
 The API is described in detail here:
 
-* `Kotlin API docs <api/kotlin/corda/net.corda.jackson/-jackson-support/index.html>`_
-* `JavaDoc <api/javadoc/net/corda/jackson/package-summary.html>`_
+* `Kotlin API docs <api/kotlin/corda/net.corda.client.jackson/-jackson-support/index.html>`_
+* `JavaDoc <api/javadoc/net/corda/client/jackson/package-summary.html>`_
 
 .. container:: codeset
 
diff --git a/docs/source/shell.rst b/docs/source/shell.rst
index 8cc68a4313..5d00d73890 100644
--- a/docs/source/shell.rst
+++ b/docs/source/shell.rst
@@ -139,6 +139,6 @@ The shell will be enhanced over time. The currently known limitations include:
 * The ``jul`` command advertises access to logs, but it doesn't work with the logging framework we're using.
 
 .. _Yaml: http://www.yaml.org/spec/1.2/spec.html
-.. _the defined parsers: api/kotlin/corda/net.corda.jackson/-jackson-support/index.html
+.. _the defined parsers: api/kotlin/corda/net.corda.client.jackson/-jackson-support/index.html
 .. _Groovy: http://groovy-lang.org/
 .. _CRaSH: http://www.crashub.org/

From d15eeaa2b97dbe16ee4918de2f18d04de2495a8d Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Fri, 29 Sep 2017 18:11:15 +0100
Subject: [PATCH 050/185] Updates readme for v1.0 (#1747)

* Updates readme for v1.0

* Addresses review comments
---
 README.md | 55 ++++++-------------------------------------------------
 1 file changed, 6 insertions(+), 49 deletions(-)

diff --git a/README.md b/README.md
index d490c71ae2..25b9d8e2e5 100644
--- a/README.md
+++ b/README.md
@@ -17,63 +17,20 @@ Corda is a decentralised database system in which nodes trust each other as litt
 
 ## Getting started
 
-Firstly, read the [Getting started](https://docs.corda.net/getting-set-up.html) documentation. 
-
-Next, use the following guides to set up your dev environment:
-
-* If you are on **Windows** [use this getting started guide](https://www.corda.net/wp-content/uploads/2017/01/Corda-Windows-Quick-start-guide-1.pdf) which also explains through how to run the sample apps.
-
-* Alternatively if you are on **Mac/Linux**, [watch this brief Webinar](https://vimeo.com/200167665) which walks through getting Corda, installing it, building it, running nodes and opening projects in IntelliJ.
-
-After the above, watching the following webinars will give you a great introduction to Corda:
-
-### Webinar 1 – [Introduction to Corda](https://vimeo.com/192757743/c2ec39c1e1)
- 
-Richard Brown, R3 Chief Technology Officer, explains Corda's unique architecture, the only distributed ledger platform designed by and for the financial industry's unique requirements. You may want to read the [Corda non-technical whitepaper](https://www.r3cev.com/s/corda-introductory-whitepaper-final.pdf) as pre-reading for this session.
- 
-### Webinar 2 – [Corda Developers’ Tutorial](https://vimeo.com/192797322/aab499b152)
- 
-Roger Willis, R3 Developer Relations Lead, provides an overview of Corda from a developer’s perspective and guidance on how to start building CorDapps. You may want to view [Webinar 1 - Introduction to Corda](https://vimeo.com/192757743/c2ec39c1e1) as preparation for this session. **NB. This was recorded for the M5 release.**
-
-## Building on Corda
-
-To build your own CorDapps:
-
-1. Clone the [CorDapp Template repository](https://github.com/corda/cordapp-template)
-2. Read the [README](https://github.com/corda/cordapp-template/blob/master/README.md) (**IMPORTANT!**)
-3. Read the [Writing a CorDapp](https://docs.corda.net/tutorial-cordapp.html) documentation
-
-To look at the Corda source and run some sample applications:
-
-1. Clone this repository
-2. To run some sample CorDapps, read the [running the demos documentation](https://docs.corda.r3cev.com/running-the-demos.html)
-3. Start hacking and [contribute](./CONTRIBUTING.md)!
+1. Read the [Getting started](https://docs.corda.net/getting-set-up.html) documentation
+2. Run the [example CorDapp](https://docs.corda.net/tutorial-cordapp.html)
+3. Read about Corda's [Key Concepts](https://docs.corda.net/key-concepts.html)
+3. Follow the [Hello, World! tutorial](https://docs.corda.net/hello-world-index.html)
 
 ## Useful links
 
 * [Project website](https://corda.net)
 * [Documentation](https://docs.corda.net)
 * [Slack channel](https://slack.corda.net/)
+* [Stack Overflow tag](https://stackoverflow.com/questions/tagged/corda)
 * [Forum](https://discourse.corda.net)
 * [Meetups](https://www.meetup.com/pro/corda/)
-* [Training Course](https://www.corda.net/corda-training/)
-
-
-## Development State
- 
-Corda is under active development and is maturing rapidly. We are targeting
-production-readiness in 2017. The API will continue to evolve throughout 2017;
-backwards compatibility not assured until version 1.0.
-
-Pull requests, experiments, and contributions are encouraged and welcomed.
-
-## Background
-
-The project is supported by R3, a financial industry consortium, which is why it 
-contains some code for financial use cases and why the documentation focuses on finance. The goal is to use it
-to construct a global ledger, simplifying finance and reducing the overheads of banking. But it is run as 
-an open source project and the basic technology of a peer-to-peer decentralised database may be useful 
-for many different projects.
+* [Training Courses](https://www.corda.net/corda-training/)
 
 ## Contributing
 

From f36ca78f8803c5a0f44581a0e337adaaf8a9f79c Mon Sep 17 00:00:00 2001
From: Konstantinos Chalkias <konstantinos.chalkias@r3.com>
Date: Fri, 29 Sep 2017 20:41:12 +0100
Subject: [PATCH 051/185] optimise checkNoDuplicateInputs (#1741)

---
 .../kotlin/net/corda/core/transactions/BaseTransaction.kt    | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

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 3ff6773082..0d5a798d9f 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,8 @@ package net.corda.core.transactions
 
 import net.corda.core.contracts.*
 import net.corda.core.identity.Party
-import net.corda.core.internal.indexOfOrThrow
 import net.corda.core.internal.castIfPossible
+import net.corda.core.internal.indexOfOrThrow
 import net.corda.core.internal.uncheckedCast
 import java.util.function.Predicate
 
@@ -34,8 +34,7 @@ abstract class BaseTransaction : NamedByHash {
     }
 
     private fun checkNoDuplicateInputs() {
-        val duplicates = inputs.groupBy { it }.filter { it.value.size > 1 }.keys
-        check(duplicates.isEmpty()) { "Duplicate input states detected" }
+        check(inputs.size == inputs.toSet().size) { "Duplicate input states detected" }
     }
 
     /**

From 4d4027947b80c715eb70b50078868ce5b50b6907 Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Sat, 30 Sep 2017 21:55:51 +0100
Subject: [PATCH 052/185] Annotate Gradle task inputs correctly. (#1752)

---
 .../java/net/corda/plugins/GenerateApi.java   |  2 +-
 .../main/java/net/corda/plugins/ScanApi.java  | 21 +++++++++----------
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/GenerateApi.java b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/GenerateApi.java
index 59dbeca87b..9c87224075 100644
--- a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/GenerateApi.java
+++ b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/GenerateApi.java
@@ -48,7 +48,7 @@ public class GenerateApi extends DefaultTask {
     @TaskAction
     public void generate() {
         FileCollection apiFiles = getSources();
-        if (!apiFiles.isEmpty() && (outputDir.isDirectory() || outputDir.mkdirs())) {
+        if (!apiFiles.isEmpty()) {
             try (OutputStream output = new BufferedOutputStream(new FileOutputStream(getTarget()))) {
                 for (File apiFile : apiFiles) {
                     Files.copy(apiFile.toPath(), output);
diff --git a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
index 667feb860c..53f7ee9fc0 100644
--- a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
+++ b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
@@ -8,7 +8,9 @@ import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult;
 import org.gradle.api.DefaultTask;
 import org.gradle.api.file.ConfigurableFileCollection;
 import org.gradle.api.file.FileCollection;
+import org.gradle.api.tasks.CompileClasspath;
 import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputFiles;
 import org.gradle.api.tasks.OutputFiles;
 import org.gradle.api.tasks.TaskAction;
 
@@ -55,7 +57,7 @@ public class ScanApi extends DefaultTask {
         outputDir = new File(getProject().getBuildDir(), "api");
     }
 
-    @Input
+    @InputFiles
     public FileCollection getSources() {
         return sources;
     }
@@ -64,7 +66,8 @@ public class ScanApi extends DefaultTask {
         this.sources.setFrom(sources);
     }
 
-    @Input
+    @CompileClasspath
+    @InputFiles
     public FileCollection getClasspath() {
         return classpath;
     }
@@ -106,16 +109,12 @@ public class ScanApi extends DefaultTask {
 
     @TaskAction
     public void scan() {
-        if (outputDir.isDirectory() || outputDir.mkdirs()) {
-            try (Scanner scanner = new Scanner(classpath)) {
-                for (File source : sources) {
-                    scanner.scan(source);
-                }
-            } catch (IOException e) {
-                getLogger().error("Failed to write API file", e);
+        try (Scanner scanner = new Scanner(classpath)) {
+            for (File source : sources) {
+                scanner.scan(source);
             }
-        } else {
-            getLogger().error("Cannot create directory '{}'", outputDir.getAbsolutePath());
+        } catch (IOException e) {
+            getLogger().error("Failed to write API file", e);
         }
     }
 

From 4641d3c4dd76bb370886b84c0621049f3bcea927 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Sun, 1 Oct 2017 23:33:15 +0100
Subject: [PATCH 053/185] Moves code sections in tutorials to code files.

---
 .../corda/core/flows/ContractUpgradeFlow.kt   |    4 +
 .../core/node/services/NetworkMapCache.kt     |    5 +
 .../internal/ResolveTransactionsFlowTest.kt   |    3 +
 docs/source/_static/corda-cheat-sheet.pdf     |  Bin 140780 -> 141625 bytes
 docs/source/api-index.rst                     |    2 +
 docs/source/api-rpc.rst                       |   10 +-
 docs/source/api-service-hub.rst               |    6 +-
 docs/source/contract-upgrade.rst              |  124 +-
 docs/source/corda-repo-layout.rst             |    6 +-
 docs/source/event-scheduling.rst              |   22 +-
 .../corda/docs/IntegrationTestingTutorial.kt  |    6 +-
 .../java/net/corda/docs/FlowCookbookJava.java |   32 +-
 .../tutorial/contract/CommercialPaper.java    |  101 ++
 .../docs/java/tutorial/contract/State.java    |   90 ++
 .../TutorialFlowStateMachines.java            |   38 +
 .../tutorial/testdsl/CommercialPaperTest.java |  270 ++++
 .../net/corda/docs/ClientRpcTutorial.kt       |    5 +-
 .../kotlin/net/corda/docs/FlowCookbook.kt     | 1171 +++++++++--------
 .../tutorial/contract/TutorialContract.kt     |  136 ++
 .../TutorialFlowStateMachines.kt              |   64 +
 .../tutorial/tearoffs/TutorialTearOffs.kt     |   45 +
 .../docs/tutorial/testdsl/TutorialTestDSL.kt  |  247 ++++
 docs/source/flow-state-machines.rst           |  197 +--
 docs/source/flow-testing.rst                  |   58 +-
 docs/source/getting-set-up.rst                |   22 +-
 docs/source/hello-world-running.rst           |    2 +-
 docs/source/key-concepts-node.rst             |    2 +-
 docs/source/oracles.rst                       |  115 +-
 docs/source/running-a-notary.rst              |    9 +-
 docs/source/tutorial-attachments.rst          |   55 +-
 .../source/tutorial-building-transactions.rst |  180 ++-
 docs/source/tutorial-clientrpc-api.rst        |   62 +-
 docs/source/tutorial-contract.rst             |  414 ++----
 docs/source/tutorial-integration-testing.rst  |   59 +-
 docs/source/tutorial-tear-offs.rst            |   91 +-
 docs/source/tutorial-test-dsl.rst             |  538 ++------
 docs/source/tutorials-index.rst               |    1 -
 docs/source/using-a-notary.rst                |  138 --
 .../contracts/JavaCommercialPaper.java        |    2 +-
 .../corda/finance/contracts/FinanceTypes.kt   |    4 +
 .../corda/attachmentdemo/AttachmentDemo.kt    |    4 +
 .../main/kotlin/net/corda/irs/contract/IRS.kt |    2 +
 42 files changed, 2264 insertions(+), 2078 deletions(-)
 create mode 100644 docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/CommercialPaper.java
 create mode 100644 docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/State.java
 create mode 100644 docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/flowstatemachines/TutorialFlowStateMachines.java
 create mode 100644 docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/flowstatemachines/TutorialFlowStateMachines.kt
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
 delete mode 100644 docs/source/using-a-notary.rst

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 e5eb960ac5..d1217909da 100644
--- a/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt
@@ -22,11 +22,13 @@ object ContractUpgradeFlow {
      *
      * This flow will NOT initiate the upgrade process. To start the upgrade process, see [Initiate].
      */
+    // DOCSTART 1
     @StartableByRPC
     class Authorise(
             val stateAndRef: StateAndRef<*>,
             private val upgradedContractClass: Class<out UpgradedContract<*, *>>
     ) : FlowLogic<Void?>() {
+    // DOCEND 1
         @Suspendable
         override fun call(): Void? {
             val upgrade = upgradedContractClass.newInstance()
@@ -43,10 +45,12 @@ object ContractUpgradeFlow {
      * Deauthorise a contract state upgrade.
      * This will remove the upgrade authorisation from persistent store (and prevent any further upgrade)
      */
+    // DOCSTART 2
     @StartableByRPC
     class Deauthorise(val stateRef: StateRef) : FlowLogic<Void?>() {
         @Suspendable
         override fun call(): Void? {
+    //DOCEND 2
             serviceHub.contractUpgradeService.removeAuthorisedContractUpgrade(stateRef)
             return null
         }
diff --git a/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt b/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
index 428a656220..2bb1dc0bb4 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
@@ -28,6 +28,7 @@ interface NetworkMapCache {
         data class Modified(override val node: NodeInfo, val previousNode: NodeInfo) : MapChange()
     }
 
+    // DOCSTART 1
     /**
      * A list of notary services available on the network.
      *
@@ -35,6 +36,8 @@ interface NetworkMapCache {
      */
     // TODO this list will be taken from NetworkParameters distributed by NetworkMap.
     val notaryIdentities: List<Party>
+    // DOCEND 1
+
     /** Tracks changes to the network map cache. */
     val changed: Observable<MapChange>
     /** Future to track completion of the NetworkMapService registration. */
@@ -87,8 +90,10 @@ interface NetworkMapCache {
     /** Returns information about the party, which may be a specific node or a service */
     fun getPartyInfo(party: Party): PartyInfo?
 
+    // DOCSTART 2
     /** Gets a notary identity by the given name. */
     fun getNotary(name: CordaX500Name): Party? = notaryIdentities.firstOrNull { it.name == name }
+    // DOCEND 2
 
     /** Checks whether a given party is an advertised notary identity. */
     fun isNotary(party: Party): Boolean = party in notaryIdentities
diff --git a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
index 1576852791..6e446d0bd8 100644
--- a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
@@ -24,6 +24,7 @@ import kotlin.test.assertFailsWith
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 
+// DOCSTART 3
 class ResolveTransactionsFlowTest {
     lateinit var mockNet: MockNetwork
     lateinit var notaryNode: StartedNode<MockNetwork.MockNode>
@@ -53,6 +54,8 @@ class ResolveTransactionsFlowTest {
         mockNet.stopNodes()
         unsetCordappPackages()
     }
+// DOCEND 3
+
 
     // DOCSTART 1
     @Test
diff --git a/docs/source/_static/corda-cheat-sheet.pdf b/docs/source/_static/corda-cheat-sheet.pdf
index cc00820e046ac75ba2de652a5e29d9d65cf6367f..b7c3b7d1cb02d15e81828a053ece7ba5f9c0cd7e 100644
GIT binary patch
delta 63384
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

delta 62406
zcmX`Rb9iLU^FF-FM!PXL+Sr+mZBIP$#J0`Z*tR#et%+?r+1NJsm*?}n-uJ)0>h!5T
zRbAERuDiN<8t!BSE*b<Gi^UhW-#@>_aEkqCp`Q!o@2>;LB;$rmk4BUH923kHuAL&w
z{`ezZ%n!xNib%eZSK_>uANk*CS=mvUb>!0756N1F*$xukRbC#RZqjbje=M&9hgk*8
zZyNxYnMeETjCE}}2!DGDpU0awU%NYhM&rK?9m(vlUFUk8a*a($SRZ)UhJo#6`_BDp
z>}F}>s<-i+x<The_4+XqGG_9;X4#ws@v&q-rjAcs30u=|SdrbYy?xT}(2`ZX-tDt)
z*O0|74O_B=W_I?n|C6B_+j}09rXqMNl``WDntu60UP=Un{dWXPodC?Q2$?!pr;cH#
z)w(U8H((!+S!+QgZu7bSk~Np|oU*TkJsP)C#S@Osn!^`IdLkQ{S2rzMt0=bxG1ae}
z|8z3_I#!X28?H2K-P)>Vz4y61DNhVMYu)ZUTXv+0nGoO4RG&<&m0zc+ZTZtLM9%ag
zCc~&zOVg6AR4_1nT4Ji<__5Ejb`jelRmal!dY2~U2lWcXxw=EmYA;POuiu_kL)hGT
zF<`>jyw+kp58UPBNt&`;cF$2DJAp|1D?e&>*0{OHs6vj$i%zljw9mYqEB`u1y4=O0
zx970%vv*O!d>UuoUg4+%onq-ypML$uD~9wKd$hi$<RjstXSfG;+MHZ=(cIT#&GOO=
zq65#o0+mt-%od|<p(|{j*z&A-q+10RzfVD;$KIFHB}rkT!>h!tqQusc67TB>3>#{1
z^JdQC;uxUL^t1EG%$g0EDx#f|RDt-Cx7VW>Q~jbY{AfQyeh|1@2!GDr8+d4tl5@{E
zny&ODA(d=X?cZ1N#DiC6Z%$=!=(BaqVh-(w!^(h2>WfPX0Y%Y4utLrf^oB^Sd^F3P
znq$9w8H!23Sz+DkyC&k-09)9BW&Xz@2&R`ZC=EBF!Eii7%uPhf@2Mm&(c^~|w7h(t
zyj~qm+LNsNfjxu}O9VL%%Y_Frr60R=)8_y$7YuJ)dulzx<2mE~kcXJ?Tfdd^o0?4J
zx-7&bZq2ySNcP&fMZ1h$KKaLm@sm(bX6>P@|Cu8+r?C7kpo%oApl!ouK5h7FHF^Mq
z^}Vbi!9<);%B@eWp<gR6mB5W|_tuhg#j+uwhBPX_P2F-~M0u|E{VnO$s{UCJp2+X-
z?^D(+JF;v_+3?-yjD#EuE=IcFXXNuhOm4IR`*SCs+*wZhEIZUr*aA+Qg`*1Fm&T3Q
z;>QLNehUFL5@kYHQceMTP6U4Skzoz`znbDn7_5r_6=#Lnl(G^kCW+xpHM;8YjGF-L
z<{m2NZg%G|hyWw3cb8YEH%lW)HDcFSX@?!sS)R9Ya)nuRg>v2l13Y|u5H2mqQqoXd
zhZpdWa^@?q4Wz?#P_@HShtG@ab>VQNBkS#moUev-H&a(nTR2;gIG{PD>?#~Bwz=QA
zfnKO4(^h0q6wb}<(y_&w<l??>hWbjovBO2i_izUOAxLHKxo{>U>7|<Z{6|j5I$s9E
z%Yy3Z25>*<4?p8DyIkSQA$lJ~haKUm3^b#&(NGxgOLBqUlD^tF>72P$Re5Sjx;<qA
zSozSr8oZS_QsDh8e=O1G1uG0!22uDfb_r#C4J$;Sy*W8_+<5ysL-`}7_;{I4*=<TJ
zy&>DJIeB$tl-BVc9@xGmjQjXy-4t9lQ>CJRC8GR#6zi+-31+0nRO1BFM)UM#g3eRx
z<gWMcwYoSYV*hr_8;0*W@o9E-$Im<<<c`tJSId(rOC}4>;vgo+;3jw^mLZELdjQ_b
zJ%>EY^UCq*YNIZQ@Z2bj^H{W$w3{iarO{_SclEMG>lf*|br`;JT2zu>!rJbX*vdL!
z0G94GPKKGjI^n#|EpH0q97pN6ESKEI<EE%ldVHrAxoCZ7WWM&2Sq8-1=i@AVK2w)g
z8@JtD_NpJjcfXhH_~$Kij?&uWHUhh@!MEOq9wz+t@Y@mg8pok3$yr--b<f7h$ElBw
zPzWjSH~ya`n?nqo&!^AlS+dh*5MWk6-v^-jNtj$3eN_D!2-Ximxd9DadVc;imCIEM
zt85<-SXsESw&wNk4ST{i_I`nVql^J-8kbOsNXYAc^Ej;3g=O^B3AHrD7P;(rX|8oe
zH7VC0Y{`DaOGKtr3VV!8JY`>vKf4}HYbT7ei)Msb^!N`}($?iQk-=WPv8h8L@ym`d
zE3dZy+8b*5>wpWy#YTIZUh{Wk?n<?7<7$;Cw$Hy@N>>jRO|>}nl`oZ?Etn2-n`V}>
zN)^3Ro4&nMm&B3dS}9NYV>?50M1oFF6#T=QABhHgD>(Q)*73m(0e7C0{f9D!O$@S8
z)m!aete>`si??s_E<<)rN?BgcMZD`w-Y!HqYs95VQUp37#;VYbPg_m<p7J9=J_@<F
zi#mR?AruG8w7arRlj>Y$<Lg?UQ%rP2_O$Idq!&WtiTSfPL8oBAkA2d;lj)M6Q<a+o
zBnq}l-bSe=QQiAU@%@M3M`t#*nQhU<n#)x&|DfQ>d(;6u51%aWrjoZUzya002F5cU
zSEXmPXhb@MNLSKto~2@{650xV+HOU5k%r&U)ETaO^sY|)Rsg|z9*fy0j`+92xjxW*
z9*K0)cfvkW^ZD*!O3>MplUy&?k1DN}>>dfJ(l(O|eh(0a<tnQbsc2;H^Xzr)*sa6E
z41s@yOb;D-GPM5gRq`-+?F>MopV(<~9zgjr!$bx-7=&5)MksKeDQo-sp!V41P01#A
z7Uj~T#=Ly0a^TR)rF#@F-i*U~uTe|cYd-7z^oI-D-tKw3_hbN`x6|vc<S)vhecBkK
zYV3}!4_reo*`K?;w^@IEXmzQqFw5OM>t-O9Iy163pIS2-Kzf$`w5f@<6F%3zwwrpE
z)87x-s9f$yA=9(R(GJ6+{44G95at9l5%Tez$~qJm&`(M(kx0YhM0t?`imYPg^jCa2
zgR6-dBh|lc9hi^y9RDZBUit48I~SZ5*|qGSTsh~Ug6$Ti-4-LKb~ftS<9GD%)N{;U
znYk7$8gUfuAd(tJ=`L^8NMsFGHrN5)cOyV1EIT*>0{>o*(^Sv-p#S=Aj;_92(2>p#
zmbhz(FZ1TLILr;6<stPTmyFH1Ufz-u3>qDOOIv}FioEYvvKzc=aua2?T-vh4OQ%C?
z_-)RZ6v@PLu><W4OX8}jY5{D<cs<XBDZZ*B@$l90+bq=OSdQmaf)AcbtpC=4=}{qJ
z47TN#jQfwRX{{?GrLEX5q`4=vL-t<PYc|;V8ns11DrK3nPMr81c?MxzI5soo1U9~7
zvR@%>gAE!Pf%VVN$IoD_sbE&ST)xq5<xAbHlMs_fT?7G2)WjC@Qy&%kryV?cUyDTB
zxH-EhF5)pBA?Rk?fCL%hmKEPNni<5yX>MLC5Wn$(XX7LYPHt59Ts1*t`I`{a#jiJs
z*>I)Mkj@cFMLe7m!5~L|^$_gxN8dK=!cH9JvL$N^;od~2YfeVX>ilP!q&}|tHOJ2b
zr@=$<6=K$R>0#@YNB*bMwN{^96QVM@H#0=B@^ApZv@2&*pIn2P^-QLMz~_)ugWj~-
z;)U)BP~3^BgiOnWLyM|+nBL6iMavlq6VX%(*sdZY>NGE`dfSv(Pws?*eWK}v$4MeH
zhf&=UA{7Bm$F$zM)7F38mK6FtAf(nDv~qdcLTnK1HJJty^6=C3;29=c{gNfa{PV6G
z#qI0v>DqDW!iLWJYFA+tg8^jJygsMFZH>S)T0MklIvF@W_+U><6Yo?tk8k?@+K(0G
zQW_)rZD3$Q#^WFwVnO}f&dcw1H4fdnI@q>)_KgL?X9y?2uzPcQs;s1R4|hLfvEs6N
zt*f!fp5XcSKm5j#W9xNuU_u@@ui9vXHbdJ8cwJ+7vQZ@}YxYPqa3DMw4ZG2AunJK)
zHyzhLH6lt-R@><(gaZ1vxIIDEnrgqC{vthSEkPrp$$(Y>zL4t$)p!@eHMUlH7D@+w
z<oX6_4)20T+lKYR;qUt>L4Zj9BDk8I)l~Cy&^M7o4vINW6fKwt)i3o1BXz-#w3%$N
z$$&8ur0*vh`Q*mmBq60^&{xWztW@M_6>1^iI2hA@O!O~B8jM`(^I<FK_F|fxJ?9EP
z2Kte2)ZfYnkLR0x2l~@_ivsGC(G-kN_9LSmcMIxktX#W;9;u|aM*G|wt94y$g|@!B
zF!poWmnb05JHj{mvECz}Tc%Fd^NWw%<7tJT9b?L7_2}%0fFT|8%siC+9h6x)7tgfB
z6QbhR+T_!sN#c~toY$`}NmizDcc9~LA*(N#I>=&vC9o<0eX$<caRSxu;Z!aRYTCqp
z*nYp}W1U>jSI6#a90Yz{7Wvt%%d5Zolmd={59*`eL5m*8hNoeC4>H{I29Bqa2Ds?{
zsjoL#PnHrh5|EqxsY6oCDdnP-FMmpPU&YcYnEKWGaXKi7%sZ~<3C*`)e^>@puw1;}
zJw3gu(uw}-9MubF9Fmx&u-q1n9xHz?cO3ut7i+`?-U4OvrP5l1{x%oyJG2S<T&j=|
zEqD1B2z|M@O<Pd?XB)w}0f?l-`ZjC0ii~i%kb6)Q#RL(#7b&7k^SftGuQ2WRaZcno
z@-*&!p!9;<C|}QHkV=~UxRvk(cW8IB@#JBGKl!n{Kl`c8krA$OpOTN_C^thPj9!~7
zPuTz&SCPy2sL2#2`TKNIdGb`X4VT1gl${n=!FSq*fcbZ5V<nzZdVdDsTi5h{-Fpgm
z`>UPw#~o7ty73Fy5|OY>kLYOgVG4i2FDN`0vwE>XdD-vCyW8!rd0&}+s|)2?`eCrQ
zZFk<A=e0mauUX}xZ1?O9ZV>KG9l!p%L4OHMtBTc>s{pe5g|q46uzC;qS_IcEz-hP|
z{*}o{Ao(Hz6@yZ57y3LxUE$-6)H8fUMZt-`;0zJ-kj~US9fE{k29lwt%edxc-Krml
zzTCdvjppaN5ZP2*dYLp`&xIHFJ1h3gz`{P%>7-ptlgZM_#@W>UdW(09=5V8@%uM_`
z*GaIlbHAcNZ^Gt2FsaL@5s1Y0YRG58Z!YOCBYaSn=s*>_TB|k0`(u@r+oai(ns!RV
zo($qd-r}a5L7b({2zd(#ed6Ye-p}`b26lMS5XDhWeD|8dme^zF?~}~fweP`12#f4!
zart0Bz}=sxU!(y%Y0r30`BPA!yrRW3buPj2fay%UN6Y|1;tzw_goPSoYkv#K1Q4l6
z1X_FdB3MRd8Qb!Z?I6HwQ65$=rZ*A};zE+C@@Jl?>doT?xsNb5embo0tvkF4nlY-?
zyCWh$#BTZkzj9_g)pc93#&omcqKaOGqlxMx%Kx@k>BYX?IGWN~$`#=f1ZSO3*V)ui
zA;EaD>DwJKu4^#v4;!*noZwkTnEAljVU?*?vOiz%31jnXZb0Am24YZq(tGCZZ6OV+
zb4}5k><g99cBq$|hud|gRo+5Pm1~D;g2R=tGSX7}gq0W)B6PeXx-Wd}EPF+<@k}%f
zIkTxUvA-Wbzxq)gb|my?V74q6RjWV2c%Y^VC-kYN)bUfj$s5z*-%8ZlEw)V+p|vdQ
zzD(E7<jGyNp1LPe<#)6nMG{{-4;hrn%N1A|oKkqmiK;?!$Xu)W3Ei;t)a0A1!8VYl
zz>1S-F83dR*|(|aX!qQfeJVY+sj#WEshG58R+d5MstH2BTos!C!nX4#>5H#Ve*W1w
z!TOV;8J}l7OYtKspXtX@7|U>wWJdLwK2LnIJzqCL2e+BNz2k`Vx99AxH3)Dla`o?x
z_~#&Fs&Iau2o++g$Qm07m5{rz6&G`V3^`0k3JM1bXEMCRV^l(3M&cwzhIaM&kfCIZ
zjwB{nJ>V@h5zET?&9<mTPaq?}ti<Ed?fHR3$}s?sSuzEmD9PaHmyQhwb~ibRdAK;2
z&r*)Z<W?SkTrObSxKn*U7IKKNf^Je?o``gj*i1`7{B`G5mxMOWvuo;)iu6Z0vo#nC
z;mz>d99uhCjM6B!j(Gm+gQ42+RnV%0?yY3bbDT=)x6KV#G4*Ixue)Z<8gO5H@oI3W
z#i-3)n!WYztyHO;csR<WL^4i)3~F7_8~~?)%d{_}P)Xv)yq!mgI;1z9F*DarA3#54
zrF*xhVsDqo?%dr+y4Ioe6l0h+!PyW|bw7c*m%e9KZB|*LNIE<i5>?rCM-`R!@M8NO
zFH+A@(Z59#8|I(?xbwB+*2{C5v|1I##+kcw1-{~ZbYaR(75!?dIMWGdN*T`d<Du@B
zW(}wBV^K&W^skB)FGR>AGFjAF-wf#9psxix=@#mSg8XV!=;G`-xYD?mX)G=1DlG>_
z!E8|E<|Y4Dyg)|ODAcViX@XA3j=5I@FSB)0P3PB_{OcM?C-)5p;C@dKA&f6sdwF_X
zhz`$lnI*s>rDe7S0On)XQN3A(8*^evQ~eAwWW&b)cvM!k3ONUAYi_(<JRLoq53YIq
zds<1Gu+iRVhk7cCwG_rZb06s2z{X|3;Hf-E&=xwZ%0xOauJ-1Rmx`-vNpo9z=yMkY
z+l~J|wXoJMeB6Vw+<xfd2t$zTO#jWAY2-rlXP@$`SmMo>35SPR!Fb)z23MCgR%aSn
zXH6e^EI*a^SwX0b@CQVmw;%E{x+a?sy2?6>a4E$Kxl1fgnc$P_Lg>nz`<=@?!;PdC
z=9T9vTEtug+)+-@)f)+&L%0o$y(nKJuHUJvMWE~plYEC*{A=NiDz6>qSfBYo>Z+!1
z8bP*59&ybZ>lNRmkpC~EDdO%iVX_118}QUyJrG~^8iJVB)Iu^ex@pcVU_2WT7Vzyp
z-FXOK^OCHQk-&CtH-Hn6#DdjcByj=aG<Ke&-(8k+Hg?sk<CcJDLt>ahu$<O26>HE*
z8ud{Ut)$jTf^%7P(!eV&YeyW=lv|+RRTfQo&CFf3G;+!3TCpc%Z4&P<`C*x@SA6%4
ztj;A08`3@qQp(Z#=<9dCT_E8qw_FozSDh>ApU#$iVIrf-x{9XRA~J35y3={^>A3DL
z^4ZkXXILs|)Gl|EDOobOZrj#0N*eW$17M#kjTWQ$4BM8zHoNjFH#w_uhQ%>A3v0!^
z3S4nIZV;baS&(MzFTovOl}h3P?lmEwv9MVrKq$e7hKeS%R)eZsb3m_{(8?kbD-IE+
zB3*}FgXS*3n<vnsje;@GKUC{^vY{-{#o(Scdf;t~psk`gk~Kn*GW+qZ4~)xTxaAq^
zb9Z|pO@@7*Z?mz}pNtyCNXs)!Z{w<raf>s|5bc5GVk%|~&3J80x`muf^TL?1c6|Ia
zh&|82ae=K`v%2*P%a-Xm-#RE`eQY<shbA$lH(Cs>w8C>JwvQ1LF=czzG5s+Xek40|
zq9F|i+u+7ht+m_DnKUQ{wtcK<CDXtkY<uT08Oj}3@BGKIy-2m3NovE^$vYI%hUii^
z*k_4-%}~r_g}a2|;OnnPVusbnQmUQ@S;-m^mDiFz2sJzQ()RzOH#gr*StVD1a_ExW
ztwZiB1+GC+uI%F-l44vjKh*rhU<f>W*2e&3V8yoe6QX{b{qb}`qU80l=lYsK==-xl
zhwq5{-f1WIede%H(yc7;vzShttAB;2$1sg%JNeW*f2KXUcRf}Ca^9JWUwB@ER5%Fk
zcmF4jy=l-<%KVQ^o3jpMqA_}B*iuR*ha!sN|C5b{w|a4l?GGAIGjC_Qj4j0sfY#~N
zKxb+h?=0FVJrqyd5ab^E-<Vrz@%J%~xIk0^FJ-Te<Bu4t&jEyT9?Uu?T*Cz;v^S>9
zh*X;vVJ-VeyqR~25c&&QMW!w4cQL-g>I9d|%Q(S16^99{<z7eN&U1R|+`gaBwA-?p
zAPCf8n{hzd6cu3N9!^MwwJA7Xgs&DAJ`**d%uc_0X0|CfZa_h7t$AV?Fwb;pSkb9*
zq2{kCH!97+KSf~;UvlQR3p%6`O~gh`cU!!Hc}82P90o()l4Tmp?8h-XpXZ7lSfCp>
zhg97s5+_MDdn@F0VbhvWPn)+l@x&}A8Lgx<hsQ^`QJSFZKMQR&=KaaoPKgGHJ=_X4
zGy3{=zJJdigj~5vKJc@jymUod%h`2{G!!mQn@AlAbCZ=z9XvVgOVn579#6NFmDR2@
zEPSu2%=dt(KLx*~o$z>@OeCe&ovh`n<mA_(y^2b$X|5kqqyYc;Q&WJ`>W(v`Y}QAP
z<y4kIz57z<rfY3H9pie_*13t?XJ;E{;9A*AUe|TvRcQemRKmr+%Lo83_+jogi?0pZ
z?oHkw5#D$U%G@TgB1^W0_L%b>FLn}%75uTs=7FRXj`ga?2-w~B4kueaKoa8^YXn6V
zhuzSSVh8mo?ly;X3X91rRh`3sp{42o7lU3YG^AfB@Kihp*Z92qXmuj$w0x+Zfxnae
z(*aC5YPqu}hT-r_RW%V*gbx6yUf5lFI;B4)sn=_vaW>J3pm?>OTW?b}WqEkIfseqp
z7zDXoK4|V=7ku*Cx(mF0wT8A>&G*}^WeCrLHMjqqbyRaj#aco8+tEg4MTdCrypAm4
z$9PfYTFUbK!8_X(`T9r>YmemXnDsvH_yH^AD1M)A&0-C?Q&jh+*Iu?88|@CFB&@*^
zAwq>QbvGX}jPEM92fYINP`z$S&8@+;Yly8BbMl1u)Q@MA#yr9UJ!?tN!pC}x=G2e-
zW_&l`y-%CN-RO<SCS&|*2KA|H8foI}|4jK)#oH=iKgbd+d?U@MHs}NDq}+eQw>l(P
z2p4`aNyBFUps0Sj&7a_w^63nBX*t^2(9i;QBVx2`P=z9n4iQO?!ohWO4;aEPJr2pT
zbv;BQWN%w-=T3mPb2O*pw&EJ91<FOxt6h!QH03A%-G5VG51f<8uyCS2UYr&iIlA`f
zPuef(pY5|?Y;lS(jjJtB?K`xzO3)XnnN=Naw)=3NpM*{+(YQxT8Fdo)#z@hqje2Xh
znpz~3LiO6z2Z$ry<_36ov39-l))4lLT$iL5mcWtkcyaT8gG#p0mOO-8H;PIOGfgQU
zQqX9eN4~@j?Mr!Ykrq@jn&tgzmPqM-r?oMhXWPlz4xHtW%MY73+5i)RdwuNFd*5KX
z8Hl!CVi0{ENOJun5Or0AT=&yP3mzW?rIu|TXoexVM5-#F7aVfTy5$Rxd`Nwy^NX#4
zhnv^3xoYJmJ`P^+_0eI^NhWquB@-OpjH&_KF=o_Z={8T~gt13_lq){6R+{Q|z7VoH
z#pX^?%Y=4<@axoPA7%n%3(In^BipCniWB-?js%S9^<QH=<0=9f_4#|F(foW4v8(9-
z>ure)Uhrb#+hP1OPx;~X>X7BkImH-#D8@kIrFXwSCW@a-O{~bb@3_m4I5akSsc?2A
zpk~H!?F}yF+&p|Rd4~3sddh0`%)*+8HEmpt+mKB1lXdr#?9Fy5VzqHY(oMH^(hobm
z{YuD8tOC>&Y3m+f&VL3V8OGXbzIS{g*^-sTvuW?y{@K6EaDB{v4&i&-TWhSGx_A|a
zQ2CCe8&W(>l1YSrP(;b?lE@EvY%<?J>GQ3kOvM?z?)wE(%P8QbQcH5XQ59LQmoQnk
zKeW6VcJpbp|7cSJz>rX%xEG?4p)D9hR4&75im{C761!nNon~j_WXgx{@NqNK@o}r_
zJj>;ZL@y;+DIbaZ1mfQLwDo#BR%(ad$l5w@70{qM#likW&W`i;kYrG1I2I|82H+{m
zj4`9O5c-o1>{ov!%H(TphqidX_S|yJUG4$3iru0mWSk6G#JTQtS#tw^D8h4BL`|kA
zuN1OZLP4hy#ZhsHenJ`eK=Cm|XGFX_qIH_wZ(y<52HE>R5O=X3H<1|A*+AKn!^7mS
z!A8dfE{eAVqg|HwKSz#W)=`tF6+gD6J}RXfUI)`RcK>n+*z%=T!zW!|68LI`e^t9z
zg?szhh&B)qM^OB)|9b0m8|h2Q-SBdmzKD_gzVGzHkK1)2yXm1YX$eQ3>W@BIbrgxt
zY7@@mWcO-r-H_Jf#a^A)xn#y}644cQA%?(QrBum@qAvxWW&{Of0c9AZv+6zl&Xw0M
zs57Twc6<77+2XG0=<feEEmA<?CBbyl4I)#e2YG!__TSR|6tEX^d93rosHb$iZWkb&
zuP1BVZm6Pgj{546jh|ggdE57xHd!n8&v>jZ(c1q+euiuTD$mrZ9yHwnDw35sE7O!!
zPG<(&8;jM}_iB{7q`>gl8vR+%N%9AHhXNeMBF2K|L_B(<tkGs(z0`(e#xshmdQDGW
zfd{o6@4q8ZJ@Y_mDuEX0s)-@G)Vd(W8nR>`{RJ`bZ;!wf%!Vy#4%%}>Bm(Ml2!rMN
z7ja{`YzWJZWrqZ!KzAr!NKa5&cd>BR?%wCO@6C+nIx(NJUnS94n57SI3fJvdC89bl
zcG8x){l&#_&Pn5#o+d*`Q5n@@U>5c1YY8s-o&w_|Ibi8u@}EFX&s@Pp*9{g(b2bLE
z^A~l0>R^bD+HY;>=csAvrPQtW3bpcXAM_WyTp`_Z(+A~EY8l_LfX^KdFw(&mv$Blk
zk`PtKk`KJ&(<EF9=YgJEXL`HhSp!Rh76?7*b#qbBd%$_!nOOS)g3Yzrv3EypM@|m_
zOzFP#c2xOvKB3|EsyxzB)c&_HJk7{{VhK-!3hyQl+I!7zAg%VK7gn2Y%eeXcnQM#%
z3i0r|K0UCTz5h2z3Rw(|#bGMXy$Am#xdd;KJU$F=eNQxl>7AygOdJoo!Q=Z@N8-pv
z*c1C`5$#=V^wUEkorL^ET{`oO>Xr1k#s)YMYQd?3@C)BVshNP=<SIY*yK1Lp-Ozb!
z!<Nmsg+1v@G)0H^Ew24)2ZFF~U5i1|7Nqy$D3F_BRO_6h13>BL9zQUa_O|($HgeB$
z_ljo85&uhRBH98OJ~J{Kzh@xO0@J8?+;N5sr@qBp?Ahc9alYKzQHCXa;VY?ooJ-<z
z&)G4Z_saMAIRCQT6b_sEV=AXt3m8i$HAoTxLbCj3IoRN_T%l&b&@h)w7fED56(ZkA
zW>e?q-fqlEp!k3&HSQ8pE#JI%3roxO6wGkNZg4{D=@E5dCb$~d%y)k$%YgBAGEfQi
z<ST$ynZTO?Px#g|=lb1c+d0AQOTDS}$IEL!z<9{c0SaSK<Go3WNZvD1jh=mGBeU8Q
z8+{M+DGpCxWKK_b3w+`pd8a!Oh>|ZzquOUXVKj@X6Q^5e>1-#Za@pu!rvV;TX3|p4
z6xZ!3dN#+XH7RbDiv62(xaRQJS`LEKKb27jtwbSoI78NTD62+9htl(|L2`iO3TuVB
zvh1N04GasFd*JV)%xBvMV?BZKdF>a3zQK#<37Nc!w2DdO)W-zi-8<NXG(x5$|Ea^>
zq7ww%{WS_03;sare$ux{IBQuY?y4Ep-VA+yIJ=ALXn%QoB(Dr4(9lB!sak3Pag1Xn
z0w4u&Uq2V71xpotJgj)>Q!%3h%l>@T?_e)myB7R-c!zP&%dlv{XO2uAAp50<YWm4I
z?I+><FX<H=rjmmheM{E|NReQ|d}dPLb(pj^Rbf6L-T=4Z!2PaVN+mfY?ZBwbH!xON
zl$!Wq!rIOAU>Q}Oem7jKk~3(J2AX_HWN>0A?z`9QKVZc;Ak-O}%VmVd(p!TpLv{7$
zmKH9yoYdk!aGOuWz~9zf`}wPZ#Y|+cTiLqx_EcD$!^H*rTalSL<k@3n<m}I4c)-tB
zLS6op1f)f8vGay~B;tq(eip^KW%CTNk*73e-3GG`C!JnhEf77HMu34w6G9%p#hlpe
zNQ1W->tY<k8&!`S?X)8Q*?_kY?GYNGiRk(H`kJ=4$14gqm<g9oSgO>f_if<!vQ|v)
zINlJn)X-SA{mp$CV$o}tE0tk)pz}ksfal4FT(^ZilQ!q?_s<{JLEZ*N@D_h~REkXs
zA2wTycZ;RTUjz1o&U~i#v&$#s05(;!;hyepE++S)UIXS-Vj(oiQS}SU5q5=o%2EvL
z^tsz|Cd$0s+hs>l3;b_)S6^G*J-i(L=E~AN4!n2{X>shDLW0Lzk!CWH#$#Vq+^Oiv
z_<kclQ{<*ax*nuc;N&i`#tmU9anl;DGn&`X&!n-{CvJAIFD2Xy{=JFEd+1$|FG?k&
z^GkMX5oME>k$`O8nhLGbDQ78w!yhJ<u`JQ}Ko>036=*cuy>g}?t?q5<qtmFYjX}vS
zyB>4A1FYw92z<1$Na@@w!x5sLLS1w?u4f$`>8SYEFWO>ZHAa8X5x2$L{AA$!x-ULJ
ztGf(k%c4lc#xjM!P?Jbuz08}6Ny4Y5mPVs-;KHMvn9(k7kIIu8=NW;Et@!)LbDOct
z{BGACr`!Zb9V*t_TD#}R%`oq%!wO^P|1pnkTh+~PLNxz9Nsu~NJqf4THGakD+iLsA
z!;Q+q%j&dGHyko<c7nZ~)EDp>dK2LH4OK0Zk6H$h8{v%uW9Dwz?_F!7(o1Hz@WNC3
zcRUtTeMmU1GHUr1><AaN_DW*zdAm7wd)nonUyJrL3DtpqNG?TmjN&A6MQ%iN{rGu<
z{%u#a9MT6hMgN@m>0myqv7>|T-y1=@_tlP#1}->~DT|H&r>n(?0CZ>5vaO<*ENmT6
zZH#97ef07J{ruCOX25KMtCNy`)GPyF8uR8p{v@wRd)@xlo5>g3dZ@~O=d*UIiN2Xu
z(ZN8M=3f}XctT%ABW=-p@d!uyH*nCOf7hb_av=9gCn4X=v=J(Br-QzIe*$uTJ3FqJ
z*jR(Myj+b1+30L|I=#{lxi{wCQPv11N|{A7A#=VJFjigz?@&;z{UH>O8qAu6@?$oT
zm)F|`n&spcHqDaxJ(X+N+1oIMEz3RU!4qQTpWzQl$17d)Tq*uEE`$vSy+`y&27l^D
zjUnyzWDf36`~#-8Bex&SgG&TU%(!hv=7~@0ZJ(wkDBp+-4$cnjtR!<v8?x_5IoJLr
zIC2w)^n72vZSFV^P$pd!xce{^^__Bc&q32#+E;P_6(3*!;YTHz0eK)Pk*fhNnfhp=
zO?W}g^|Y}ydRAw9VmA7|F28eI53hGQYbQjSA%XkMU_tY-ECfj46DjTQA$E27bS&2a
ziCAgrkPF&U`?9y;G0_zl`n7BdWB>beB$Dm(Q-UFQT_>T<vXQ=nx2S}OtQ%JWp1qm1
zowq2K8KY6}?cyTz?U^b<5~z3Fjf}SUeR}}=3(-AoM8u=`;8hT1$D8epHqPz)0P@h6
z{M7Je9J$ed<1N@OswD6xoK2fo!VBUGUhwAj4$F(bZC4y{Xv50TIvWF=lY$Ax?1ygW
zY3;yRuoqn-AZUniH(<#3E5kRupW)Itl!>*;3f{nqP43-7SAr0_`eHa(=BOF#`^bkS
zd^!b0uTPQHYHwp&fESHz{8w5j2!?i`1tUtx5MHqK+(S-472;bt+08}{5(5O=hCun(
zOc>>fUBt~z<(1uxT5T45Y0<Fh;ko~`LIR2KwCxc`3CP<F2Sv}C<Wjq#-;O*eZZAOH
zj51>`@od(46_HkD6vfgZJ9>`MVPW0$m#v~u>IQ66(ia6HI3rKPWD#rwh#`1@K`w6S
zo4D#F+dZJOEopg@RED#JO<lp%16bd{Hb_tbOEij<X?C4PKk2ww1}FDAL6)T=^LeS7
z$U9aP>t|}(r*2A}zlz&eRJSLM<rkIUlS`147Z=0Tx@}XgQ_J?<?{B+%`F25G?A#h`
z=h2wt^ik{N@p~7K=c#QS5EaQx*3HQv*%&oTAym`9L5Y-s2vdH}!d#dg=8~B|W>Pg&
zYQi?(d#h1{k#D@p)6ybdFT0vT4n%cWC)Hq@@$33JhAbVo#=<`wN{{feW^(E@3fYE%
z!8Sj7?nB$saUaL+xhe0%+|yOUGnr$UtQUjE$FB!}w<#yIB+$;oLUbQy0tcx{pgjLt
z@4m<7#J~CKUD`b5y}adk6$jK&1t2_^)#5i-5-*xS0@#U@I*qE67*<^F^nHe2`Lj8}
zuRqSi38&a~E|xD~JbpgeNPqtFdQDpzNTo`c#-pdN;L4M^g3WV9_${%3+n|K*1SykE
zhW0JrQ9HSdEnjaF1aSwv>V)rrM@f<_PPZr-VFYln30AIE?8z1!)?KR<N8}quI9hNv
z|7a`FTABxeSaqnl@z?zAUQ-AqvQ@YGb!QRaay@6XgQ@nZ)fuMJDrp<<ThFk$lo0Vu
zaWWrE3z5AU$6qn6%wFqbu!H=>T`YI7TJCLsj?vIfhUAw&LcStj5xYyur_Qu-5Y^~~
zYb`sdfLI1Uo1*Y$mUgA2cQ4ha1@e1@D8~u%2>I#Tn_3A3?7>4#c|#wR%Nkxa@Uoz=
zIp6<?U0zzEpVnxmtC|Se{|aV8wQ~O<@6L@!YM%HzjY3|zyIQx3E}1o@K8P%K66N!I
zGi#iyKNx#88Pd39ebG-LZ)d`M=y2~EY9cM9Cn)a5vA1!<0~X!!x5=P@>!4c;jreWm
zW1=F&@{#JZl=pwlYQ7$pvBE!}6yWMk*fV7rHC(%EroG!q*mP`5Tt&qfhmNs~OUL4c
zsWlQUoM92mZnXDYvAL~x5<4_fP8@1C+#43FAho(ekY5`keR(yPwR>LWA*d!cCWz_i
z`8y~t&Y&2~bK0JJSz0k&Bo*qIyTG7|TUNtv2aQh~<mtj|K*_<TRhC{VOtK@|WIJW5
zVwQS7(Tai%nT{@`rZ(?}jlyu7t{u!Rm~AVwGPg>F&=Hvwk@Tog>c)gvp!%^QZe=f)
z8}oiRL~v#|k^OsxYgqG7vErZQd^gHctj*l<O2c3sacdRaCgRq5!yd}Pu|2N)V|Kn1
zv%O>c?+!7oKZ#wsel*4bCG*pho`lXYZMc^P+j)rDZP@g!s?^gJXe4G;f5o-R+mAnA
zse9BSwHi<h9nHoLj?t6Z(|YJ@N{tgBx6vhoAS%LwLjPcDRcPX+&p<kZGA_}XNBVMm
zZOdOOmD1jqaqbE)CNl(SSj9!l=4;!2F`X!N{p`)HWow_6wjV~)#E@CXzbkdfO|p}Y
zIN+a%phaCAoX?fy);0Z>x}XC`4e<9{rmrp6qmC(KU^JnjE}qTjf{`{IwQpFE-H~aB
z{9KFJp3X1Eri%w8JtzD!#>62(`-%s{T#QJLK6oUBT3LWdF^1P>SH}vc(3yEpoA-tg
zduvuatPEnRM&4m=4q?VB-76Kc#4>M^_M+T5(Q_{2Xk1+URgH*di80#C5HEdF#_%I8
zvRbQ}UD`<{II?S{KeZk=+qdq>*0jwE0swL<N)F+kOBM<NIGKl}z+h~1m`jtZJ25r}
ze?*VOFe2A~a@*Yp*kt|;YTHgAxMGfaHf(pv`=trTx*Je0Io)p)MdoByk>##Z2WcR+
zVnQsF_OW7bUgG`GAa{mvZ{y4^8u@rL4Nujs@5=}67?3%Y#D!k+<TOP|yfg`<RE{cO
z^_0M4l<JcPgB$yFAbSl4FjOL?Xaa~?fj}PjEWj6+*4j5;ra4#(Mr&p#>u{_h$L=_5
zqG+Afl@R}zA3vl;m9m--jZVw#BwzK&-py~o9yu+GNR*|HiB98@02rPA-vn6?=EfC<
zhQ7R*v>9oKvsgJTI&x-+eRU?HiHaXFh~j}N*-nEhMMOns*j3caQGkHG4W(5gb{E!;
zGG0QZP|b)2E@c*W+RUQTRT%HHXzeeXQ_Mn<=zKLk(xbkzwZ>DBYVT4}GLr^%vA}yW
zsO|nyrRS7l5CRvIXN?$Zic$Hf;2~KhM6-#I=jO}~n=4kToozux{W$ryCshn7%T=x&
z?SHO*tOD@1ejv6_WE6{#ZZI#WBco6P&kZewT32hufbmW>V^EsonNs4SLsqdPk_Gp+
z>~}01fWlZIOJl@Dr8qC<{H>it><r=Ff<k+~tl5+av8=i(*h~&<Q>pCJ@hSy!Cru}n
za8|*lfYK4rxDo`!R9xG#JZ{l|k%FI)t-cN?cy!nzE3r_9Qf}-d1V%OKVbqgJYXO0X
z+o2ejp-;B7ZFywXtZNn%&W`zc!SO>+Xo}Ue<O$Qq=s<$z<|G?+aq8Z^gvwFhnH|AN
zl5>O@VEHHEk~<4(^j3MM>RK)vOU|Lzm04<PKtNai0)*O3ROkpaoB{+=IH@e4g4xJZ
zDnfZeNm>7Gc?rR6(=YpfuHEV&IHcMD!W)CIffV&~l*<U!hd-X_!w7t;<ATKZwX`IQ
ze-bz7361<O+&@3onb=@CZuha}%BWzoY0~zE3ghwLniYJbQ?~?KsP;Y<B@e%+X?#6j
zk_SY%aLb4xq9w_9PhX?oLUIr*51eF>Ly*u4VjBN1ziwq0@+YtF)~jd(A`+-Pdcve#
zT8*}Q-h+71DtVHr8Ie40@Mxr=J#|Y0?wF<N22_SJl(vjWF1piP24LK$p-x$ay-Ha%
z4OQ*KYLxL1b`$KSc3PYntlnVnX+*$)9GLQtBu@r}hbYo0e#tJ@Zw9lWw$CChR5(Bi
z<0at6EHc~UujAv>PocInH;LQF&naTg>x&woi!iJP2g&NKw(nf>SCL9%s?zG;nP{ZS
zi-~Jo`@0(E+*K&3G`MiIMX2x+zG$w4`X3dTy0Z}!Xcc>V6Bf>|K=YPzD)0B78Z;&v
z@+06s1F(**P}O`Q+u(6?1HvUWX%It}_`8A-$pO9FwOpvXr#?RZgD@6Mat)G$A`JCT
zB4RNP40~t6bT|N2M9XfarZ8z3Jy-hAc&Fqm%^^dvREcBLj=8;#pJ<CEs&s%U4G82I
z#3SYT&`Fie;aS%3WKXcz<LWRZGqtqYu0DzUrixaL>5six^b)2t7p`KBlAMv5nYC&I
zT05y)KfSX`&gU@JJ%VF3JoQ~?!|u!<lz6sPzs`^6?1h(7ZHZNLcJp>XzM*QkNdEhl
zudZk~LHUm4T-2PPW2w<*d*D!WWgTpe{Q%JFuMs)dFC7ChU};y3*(NEZ>Mxs0jxb3j
zz=)1^N_}`CBQBP-p09^SwV^<ZqcP!5K-yXd7l}tTC)<SW*FEcAJa>%gIaR{ya;h^B
zmv)Mn)c*O&PS-)lKo%IN^c)HrN>HRpUjaJ)q`99qIPR39BT62)s;j7X5fri>h@L*-
zQGpR6skHea(SP-k-VF-ryOK3UlQ28;g;D%5f(^CGCy6eV47=n>L{9%Xq3>o`Hy=sG
zo5v6gq@Su6e;Ky~A^4EAA?5X6MauBV$_ZgLVQ05X*X&4r3b4{DlBk_4h`iteCaUrM
zLSC!=^nJCo%PqxlHtCBd7TST;=1&x|c@!RQL6I}b!R<R5d;NLHxEK}K9IZY8hoVNb
z^<$D6Usdp~mSK)#*cmN$BzYy228HBlTJVEvbPXI&Rl>kkKy=?}#?dFm>^P8~rYg-R
z`E1_#@3(c0++ezMBTB-2lOzTS$HPwFrFS(ysScL~Pp46RJg9R#!ln_)g*7d?6yvWN
z29-bV<M$pR_U=F$Oc(U9tVt4G=nNjqI&(ct{7|{|-AtU(;z2)489um4lU~e<h@8oq
z9!Z?aMJ6=Z0t4){is3r_?-sc(&_-afVmyGSb{+}Kq;H0aOD-CiaKyWbSq;u8aQYr!
z2;Y6riN@g@Y^F)LL8&TRY+G@Ao1xx2ufSyR$np|AoeTLYUh+hcyJWd~rN)QHbcBct
ze@>Su7lftYp51Gxl=DpD5)Z6M2T7pc!sMJ<otvl^gb$vgy2jtC5mJvCaZPXb=s%J)
zDk4y~L*uJ^ukzzX52@MV+0fQpjup%7jjBC2+tyrE-wzVrw#ZoAkwPoW<S{9_EPYrM
zm3^aFWk}SnR(i<l=?WGSeiykbosM*O?v2pUma~l|&vL&MW+qGG1V#9h5C<lgul9hQ
z*$;p2PSuEA#T{S&Q6HGn2x&I+StYW__x+BVi3{z!64eHvZ+%VauBBJ_qQB+ddE69y
zEZAi5lRgpf2{!ubM|}8?6q0IHtZ7tRbvQzK5y<}^2`lOHOsDlQ`Xm|;xD7u^5GkrX
z;|avTbVNohV%F83J&APOqB{%`)$5Y3M|Q2XfX!k9>b!v~8C33^?ciNu)~obO+(lFo
zeK!E9g$SWP_dG{5NBgfo)t*sO)N#&6hBfz%NBK257%8VV>M2V$!&|}WG;t0P^Dna1
zx<YmI)%u)1dcWg?VPNPLu?b?sD@_cIoaPMJ7BKMuec(}IeOkumBf&sK8>^(JPDA>y
zUlRitTciYO(zHv;H(Bg5&=85*&KbZM%g~nDU)wZE;^}hYAZXxZPRY*OQ7lcfqJ^S;
zR4v~>ePWpFx%^CuXsTl=uU&IU;^Bx@YpwLou|{?!X!tfEKKd#c%GHl4rW#KBtC75M
zeLh+ZuOL+xu^5J?y)(Sj5kt}Yr|NR_w5g9MvvZ8|->HSPJiJt(M)CZR*6ENBDKDD_
zI#!{6eCT#{KRirPt7!p-+J!nw+(Zo2j?<dA30Jkp*2Ro%NImPHxh6HlNC(|aGh5I}
zV>SpGlb}SgE`M5RD7pl|Ua>R0R_c(M!MHOcTb~xk+$*1<eRS$bN&P!~A>_2_t9^6y
z4wA-1mQrs-oBnb!4f&~1Jv8tS0BK3*7v5ODDhisvliM0ROmsa=o>ZkQ1vc2i=tx7_
zG}Z|lkyrK)hfo~0NQo)rY}jw`Qj`JTHv2Ow>lZu~;IHj^d8X`gzU(|WA!eV&AIRFF
zcuC0^D!>p!uTbTR*jS+7;mvzI8#yIi3xk9Q$Bq*kT4h%J>kEzYU5jC@q-$Z|`4Eil
z-+$E##ekiHo)hPmGVA<Fc*ImA4QG?!L7dwJ(6}<_KV<F{0pWqY(%*T%mgBh=pdV;_
zmtV`-&od#^{OjsqSkJ`=gA{o*VikU>a5jg#p40G}kNqm$N5qIYxI!Qh^^0~m&#!mE
zErtjz(qXps&NywbQxe8N1Vgm`PNd9E>ag)nKrFGcB_Kg&bFGgvC>FPwRGP)8Y3Iy~
z^{O*wMY`4$GB&ngk!%YFk3p|C)$EVsHFL@)P^Xgcnhg}$5Ai)d7vDC=U{{O|3a1J`
zDxI~T$duvm=IpE-diUE;Wjc^Y%G|}mR*}?pS^Say$*2HFw}S*^m?ArJ`10yN7<Zsn
zur&R36z8t3+@hK!g9n~7R$q7+NUkV0_!ua!!xaaHIMe<)hY7Lfkm(ORZ4+VlXwWW_
z1*)^tNFbc%r!Pp#1KrA6K18Qv3Ly9e9|&D<eK{kcxh`ub=J-=KE=8^=I~3sKtjfh~
zR}GZZNBwu;-ByrEg_Y(TUo$4TK|$v|Ck0P`yPXj0ZdxhV|NVX&>Xe*pLx2UO>YV|v
zMtM*}+{T-@QhQ^s%nY7Yv<W)&dyw5}Tr3g9zDL6G?)NZe=i93SX^hGzcJIirvW@aR
zbAM6)ujYG4P@MY>PH^O+($*VX-*_646tSVyRO#y9p-ymUo*1J$42QocV&;;V63c~6
z)u~sg=zh>i%$lfe4mTnRr!JO!>)m0HB!`qlN$aD!7u3gQ>f2+Jy<_kpD@i(Pa!$b*
z7WC7MW=aZYNjW>Al=<lrgD*wJ4E;)IOi(GS`ub-x!lt@Z_Z(3R_t5FeU_`Cz{^L9l
z$PMVkP)k`YG2%{~LOze~m)T3QJaSYM&rI%T&ihTd<QOhO9f&5yMhi-sMUQLAgA}U4
zz`(P8LkBMlCB(uT-sT4v#;Vbf<0{-<D9$G(JCGZgQ<85B@UdQs8YdJ52U`_WF4ba_
z^Y+pF%FBHP4gY@?)=I3Je>^75A+=c1PhzL8bZQxWRN%a}x|Y>R4@(rfB%RRML6U#M
z-yGe3+MX(-o+6I=hQLW)h{aJz5?5j`$?4xY0<vmp8uEnd`GuGkvIHu==w2pHK!~WT
zVl{HC8iiwPB8#F-x+HF?udpOt0_gq8jguH!nEcV;n%q@qc1Bz;$&JvzS2C=tWM+bX
zaLsHX+>6GM<dN@h=4r*$ui5bu@AmxA%QrmLI<kO!iWMM3%JGNr4R<AVzDR`G8nfEw
z2~2~9tfwGdW$jTE)p_Apnmd_AhXXNKB@RN)7+=YH@3t8Oihmk{o~sE%XXhjRsC<(A
z06u*&iA9|;M^pIdA@NHbLZ5T2G>)(5?@r<z&Af}q;f?x35w(U*g*kAGwecEM=24d?
za$F@<kk94xQyw7H*qI0vH+0f5i^x#<K{AGflwN!}PX3SpU6RNFfmOo>bQWR>d{20h
z@)fz9FPccuFM9);(?Q%Mp8`j{FJMMfmyn^qlP6P@r$0Q2;CoUBoJdF!zt?L?YUo_Z
z(2I1oV;@HvNBnOgzUcu6l+`<3*uY|y?P$c{S_Q_077zqPY~eLO>!t|<4(*G<LMb$a
z)oJ6KRhHsZm0qAD5bLYBResjKpXRyvYo{4NbE3z;_emcUgRGZ9&4BGc{qXT~0khtk
z<cJA37;($dM?zbFrSw7{KOX*?Dn*5%)KPRStA7297**oG`&UZW?t+~5!VmD1xSq)K
zBeQY#A>=(t-pAR}!KVYtpRNrUNb(e}gc*J+=ya9QBamBEetti7IB-7kCUHlWe!&t4
z3)KA&u}DEw{;z`JMuG~gNfEE;qDeWCzpHP)@&gP#@=DT~;k+-%XC)4v&hP8O9&UQ0
zEhxtjH>EN{OUR3jel|sun)*ZJ2|1iKfz|0OV?`jh66H6IdnZe-d#lN?Vx}|umjh$f
zxRxiFC|D3KHIpgy2|eLi<Nvqc?|zDhr<ECUtpgAH2dYa3NuqB5m4eF=8nDB72PrXL
zIcV=u6H4_M>MHeKn9TVBc=95^7FWiR=(OrI4l3cmPYjhrp42bDAWpTKIQvUTP<b&_
z^aZ&f4u-9#F6@DKC#vWcYJLz}_YYU#e-I*$Yf{2OGdT;v-nyKTq+_wekCIG`jSkT?
zKMoGxl~@;D^bMv{lhNn&T}|ul_BIEEzyL%1YY>c=uQJr<RHVFdxs0PdQ(F-BVHh8O
zkQ}``X$i|#7oG+(F7P2?q>C)^<W<H_Ii)?};JsCA<<KEZomg!U!I{`Xu-UAJf;_sg
z5eK3xe+D{c)(DyE@Q;I_XX)|y#kaWqIc-EG{}mYJb%mbGS^7pCKw~tiGp7C@4zu#n
z(cD#k=T&nQhl>D)Jb;jVYo1;wU_hxuoEoUV292QQ0+MjBYC|nCY(+cO9QR{^Iv~E9
z3131z1Zi|e5rJGMgyHlwA3+t0rp2*9mKZO$!u_d(N<C+}lSKRb7#HaFT<t7GR0$7F
z)XT?^OB@^^UZ%%^gi(ynL>g5zzmzFr6sfi!ISIHxoBO&aST=&MU}e;uvurq<yBrOm
zLG+*f3JEj+9O}vnZ*(MvqY`hQNCF^Bxx?W?vDkN*<}_7WC>F0$HXevojWSmxEFJ%-
z=_*nm>7&*LhQpmMX82`9^R8$rclm?TLGaTjfI_(e?p)w3Y8MvUCq!e?5+@&T*?rx=
zF=LlmGn}hr5*L%DxYK^zAQL#4+DPmWV(S7;2=k=_S5N`E#eQTFfJN!uG9GQ2q&<l_
zi0)J~X-P!l&69mRiTt%%UHlVghTrxUYF7(vxq{WhlEk;6y{l+m6swb9R)TkHecspL
z(6%5hqa_eOk;iF(9Wd+Hh+^&uCg+(e#r^buMh42tn=9eTocPzIv^5Bn1@J;joZ7_d
zBaM_+1mC~aRF!#Wl`m&mK8_}(SHEH=zQZ2!Yu|r&OBahhGT$|xBgGG5-_4gqixzCl
zO^iI`K}}f3U}*H?6!CKzIzELXJ_&1IZaF+Y8C&P?LJ1sLm|{zJ>Vm}gqK>+Hdb;9j
zupUvzqu6s9L1wd!nBeh+a|yz<>;1=vHf`4q9f&w06j`I6imeg~7qN!KM5aWegY<|<
zuEgtD8vGFSR`Xrr|Izf8VR1A~+i-9V?iO5vyKB(J-Q8V7@D1+1us8$_!QI{6-GaNj
z=H2UlzVFA*(Z|eAch_`HS9P7$=de8T(MW};&1(Y)wL`IHNmTQ{ew*wgsp+lOS&)+F
zLN3omnbio?U8J8MD=fJ2EAp^%3Jom8#p^n%ATG*)lOzkC^yuih15sQ5DDZY0#aGk;
zlGgE-H3Q_?PWOXsrt&(^mPhF3@Z0Pu&T7d!3^1a7Gja2uE(W%pLa)8_erdT0h!<A9
zE;a~^I+xNaMk)#$8UN<4P)VsO8b^jK@BUzIAV*_yzshPZ@;$yth}?&|wv&`SY~s^x
z!bGcIlecPJ$ZmZ3o%WCpkR#1rvVKnleyC1Pe%p|jx(UZd?tabrQt~5}&p6kc_G^?j
zo_)U+lxw39ER*#i=`L(5ZA4*Hm29;tfUqjSb8}#%?kp~1I$%e*nokgY2jqi9`Shwc
znvt)<(ei#K1j307j4#-B<Ij8B<~Bt2bKMjgO})Jf960vIC|j7C4CXRKbcTcM4t*06
zE-JTue+wYLF(~$_S4-v-R%R&Zzs-@xYGqAxPXT4@Wxax3+Gz)xS>Olr+0u?^==)}i
zX5T}yhu$j5YZP#G?l$sp{6$VsU@e;o5e`y~5WQDr$N4)HOh<gaMPQ}CnXz<N47eU-
zCH~tch`0|cr%1$EWk1AS1FFyh<yO6a-Q_7@(cg2(RnN;<Bo(H#p;V?`uB!pCt2ms=
znb?UMbvn&$pXEj>)=#l76VsSeB){C?$&dZ$Z{ISl91x?Gn;@=%8yY5J@Pox$C$mVh
zaFQ8*npQ{}=XIr`Zjw}2lNkJVT;G81#thFPM@!?}Kd+a-cGIn9GbM)v#Ox42n11I^
zr?%7$<H8-|b%iYK0nEgdG|Gb+dPWskuTGl|SZY4S5$1EexST5po-Z%2mT3WJQ*fM#
zFj%Pg)b(CJ75{FVe5o?|b^e<jbov@Lvl7C(RWh!|@?Fi1`mWpEAGNb{48KTHZUwU*
zTmt)0Y*s9_bsk;%waT;xD3ma*vvQ8&VDe?kU7=m1kf}(a?rNG<<`f>U);9of!t{h3
zi)8$OmEJ9JB2ij`ux&5KYculzJJ)UroH3f*QA28qOuvon=$ntXo`9982p0@!Q9lA<
zA?Y*uhL;WmyIt+4jfq4Osf$i(lV9!g^96>6$T3(db)r>UMbB3QO&u|r-FTPdnzY9T
zNuP1sy@c4xd8#Y2@~wMUxW>?q{FDpmLT0^koA>HW!Sdew@CAIAaf!rGI+rG}G78`F
z6D3yyU8VIeDse2i06l3ASDrcpT%DO80Y02XN9oRfNevmn$EUwyNFs9_Y3ShURxcMx
z-r72>&Q169i)nFycn>+kz^RGM%To8Y&6}o<Kq;%qwn_Wq-iNEw3ulrsFretm*(=`L
zU0@f#<kzC=Sg%QDdVWMk;=AYoWJ>v#B}G6S=s@IZg6UT0!x$tWnZPRl+`L0lSp2dZ
z6>Gem*iM~FM#fORW8WVC#VeO0UL%LIf{c72In*;Kc-jPbMHn$}UBW_=iTd;xMtQ;=
zVHqk3BypR4s4&$dKBM8hXS<QO6y7owm4q(zNbw?YrE8vWlXc2(+_g`nAOf?^|M(pE
z+1s{QW@qP5=Q<bxZ;Dh#veR$!{){B#0qwptS;bX?>(ZfX^<0)Y{}n^abS{Y^wrn-A
z*<v}fzquD^UT64shyZw|n}&$`L!f2E7z91}^z-X7lqSonNS?r217W<ExOc97n?qJX
zOUL8oHZ}sZO_1;=^hlfeA_o`qp*wBnk$tE`WaK5?_r%AV3f+#~P~ckBIBR2}>Gmf8
zgVP)}W^^)>wA|*$I5&*Y;XPchJ702xK?f!Q6uBahvqXTVKQIwqVUa}nb~QhyZqLF1
zRL+Fqs7Wc@y6T3;k4v;6kH@e~i9@lOuFpHHhW-nJtnk4z?{d?J@);Q;M}UjWIdf=3
z);6Z56Xr0T9mTZp5=PE6Bocmq#gNPyeuW>wUp-S3xF5@kHKgM?w6tx{v`@#vmrS?$
z;06HG`*)0qixQU0P<}c^`0h^tGZP3(BJguLncWgyivmN&;W&Q<CyfomcF<)v-ug*h
zTA;AeXt1`JYwb+!<frM>bP!1F4noVZV7dR=zqiFe#w=(Qt6X(R=AZtPYKGOgPs+$p
zuP}x)a)R|=%#I^~JX>x;(wxSAUlpsAh9BrLQiKRuD{BTD#1N<{W6QGS$Bdm>Nc6X8
z4j$8<Zr5`O|7`NImJd$oZQlLN$lyV#n{Dbr<7`{9=kTqRH4C}JhVyjMKVM$n?luPB
za-c6MU?SUVWuDp%;eYrOkHk!bh2xlz(Yh{x8EF}ns;%Fv0m+$GF@4v!6aXj$wu={3
zJ8;99-Ei1AYd72i0(f}8UGR=kvZXKi8qKFxFjbLqQMbsB!+8QIwt7!dByZ}DzcX&G
z5iSSWj@WhKB4B}V0!!44LA9P}01C@_{D=`n_*<ur_2QVMyjVQzb}YtGz$j0Z2XkCG
z`AB$5P^$YWNR6_L)pC9buF?uv?~uB4@@X@V941Pg12(6&v){n!MZG|S?{cifO&*JL
z+l(-oMv7RNBbnLFJg$94lWUusV0H$W>gJTKCW~_qCvo$~;dwi*u1fyp-m_1EZjVKF
z*bowdg1}m;#^kiTjU#LK{XqrBtRuMl%zkjm7N`4JkB1@aaaRU6rbR&HCMAZ#J<Gd_
zP7r2`+$^oDUHUom@lqS}BU0gdB<Q7HV}F!Bl*`C?)Y{G6yE~uPMBeT`tf^08%A*DZ
z)3ScpH&?kLnH1k&-Vv-edVUWVw0;-=u-Mg2P2)RNmK3!PiAsMh3S#`9MAmL~g@K*w
zk`pslUB>N=(ahSw@-bT5sBGCNM}m3-2c-)h07HTnn7NE$wT)EUMfw-+)a^l`!?~Pz
zerr(6{9T=NDcfeDyxiM9tcQhnml4kV+}SHGf)RAG`w8*pUAh{+<cf)>7F)8OQXMaV
z0i$Z&;lKCIBkny%KZ9g<A2tih(Dj4rPCEfdP(FQGd<4i(hk7(t5<4+W?YzPmN8G}X
zB%<%?-zci+)qUDh-I~yrZNp3bJgmmjr0y1(=XlRg`I7XC{Lnr-$Bxm+sLlL_1PHY7
z*9Gh!c(khmCObMI0sFZ0TUsvH%<XxveTpiZ{Zy!-E3x{Bb}(CcJNbyre<PP94<SaH
z!bDmG9-*u=s>9dd@*<WmI@V%<pl4nrjde%Y)*#^x&@n^@#(F#-H0nB#cv`^G-4?1I
z6bSPzB;^Wv$XIUp3N8BtZK}u&1)XAC=R{4qtG*Lu;ykxfO7nR*vZbtS$@*B$ke6E!
z5)Seo87!jay4>G*h{JZif$RyqjFN-rO$J`=jH6(^u%<Prsr;{=JsUxPm%g!m(oET}
zJPa}U)({kEG&^nV9ArSmG589Bl9r3x?W(An*5f*D*o#*>+ap|hm?+Qu)Drfn<oTPF
zMriD+Xl(BJgFYhvB3+(PYbsS-;(brjODJcR*Zl{HPW@QKj~MOPu1Fup7dQtpdoQ-L
z{#h15xm^FMPgnYXu{(sK1dbE;kPl|UHR`ogas{`V$NsIEbtErGNMdVEutEd@#Ho>R
zPwY0^G81yt5ojWjIb5i)#8`8Yz}MD>uL<HK7Q!#mIFeIA#!Pp%_YXYk@zl*ju?e<Z
z{S#+Dl^|fsP-Ninl8=E5B!o;?3U(}5CVQ7mG$X_aKYa063(ms6g%Nv~IyT<~70zpY
zrDGCjfUA8`lN@O)eii4h`7DPYy`oU8%F;;TqH;2)mhykvUE=2KZA}|jGS{$QFL+78
zWW_qNT<(AaSxsnmnO~W%!~ZuDD3Uy8F07~L0*5E%tyoCF#?l~l0QDYAQF%+S+A!%o
zoSB<DnqS>EjdNg~2R*?rpjjMw5kJ2;pNb9>^2aeLNuj3006QfHL9a@^luqpD!h$NM
zeKmn1+`x5*p6mft;|1`w?%jTtOzB|DFn+{Mi^(k;`*yPJtibsgCZDpfK0}JMR;<*H
zbZG(pjI|vQa8GjDUw=)8KijC_&&^-0<2sn)q|0H#J*oAFZu!u!&EjDcG@xD8G6fFx
zj^SA>s!`r#VlMOQWFbYIS_!(LW-|sWNi-rF+Pl;1+<dpS_Qgu!hfd~Dju=?$9&7b5
z>D&?e{);ZMa5}POx`u^xN76rz&FCen_FFCKa_TSOw}VdrOQS(cp07+G-BT&ez~952
zZp1FSV6<`VUvw<&(IbuUhB&!t@+7CT6fxR|pP+~AYRy}aNhybjJSrxa{$w*~{c;R#
zW2-!!h59{B@CW`e@bt3-)_NUv>DS#4PLzudXlOSXwfo4Hd9rn72qvWKA7|o>xsHHm
z>Kl;_j93V7#ky@o15EN;zCg4a&(T-h3h}118!t%^o{~lV0yPpDn!yag%IvmRtN;Y9
z`yC4OSEL$o?VFv9082mk6S6wqI{qMcGrAZgftdGI0_mc_A>>?DoRXozynHj9&b&X>
zG6-il_+0GDf@~e(;FsU8y+FSjSJo6qOb{~gkZ8TckG2V+OSKmEF;L1S*G->%OSKE(
zk)a9lOI*T7bkmnL5^fH?2~DDsnj%|=z(@@Ik1x>dEy7QqNm_)d(Z|0%d)US)lzj*{
zEB|K{j(a>uBi6~1z-oA-_<%T^7Ut$EgB1?(?e(BnF^vnv0GO%2B92tO57Q2mz!4cU
zr$e&!5|FC#uujlxHzf$Yg|zfxUuV@D_K`yIKYQlb<2(wvL{Dt$J9@qyVC&49(!mk*
z3i?kbfXkOOgvZb%gqw!W?)9ZXNGk@xub`>Dhrc2K%BJwWKq>nFi8KQdX$7FfKy&i~
zJ@U6xCp7$Ajv>K}!8kB<y-^`S4e-@hUjb29<01kGLpQm<#oUZO-uG}O7dQWrownw!
zf}A|Aq5`yax%B(CVu#XS_+YZ;sylo2cat3h<)SV~ENVV5ecqtMY7CYkVF_Or=>q2V
zZw{$%HmukP^fL}|C5bzByk$^t3;ZMhp+*bUQ*2T{1!OoNN-&%qF~WQe>(@l{>5zvZ
zR1#t}g=B=W)`$ATI8*S}>59bErgTU5AsX@wgap?6cUh6bX`Vi}Lx#)S<x3GQrh^RO
z=L~%p)@8GWAY+t^nI)^ScHy8`7o>bv^b2(W`h}Drgs*1lzgIK-CXTyuwKjz6yoJ`7
zeAF6c1SVQ#lmBN@*lQ2n3xMhFtjFJm0uP%+yc6%Rmr=d0)`ZfPg`Jwtd6W{_)=iv5
z`cJe><Pl}?5hJ@Xsw<!-gu<`>1sd~1H({IJjLFW1QH%QCAXmSpw>EIfz%CGmg$;Ky
zB{=fRLY5_rI*hPBSzGN3P`Ld2&${Hda1cTUM)qis)&f}H`DBb)=srdEgpqv-tS(Sm
z73bfw(QxZ;1sR|H!haIj6FckiTCX>o38{KMF)P~S1Dz!DuWr=mj2Jc6bAL=$*E;;O
zg6mli)nCj($d@}HNwZtAMUl#2JL5RZsUz}<PUzzm@a{q<?3^ADfsgZ*Xm3lV0ZOsi
zU(>%uv#@jBP0ctE<VsmR4OaipiY83$(GH~G-+adpl)Ks;@P|vjd(I}S7zkRsv8Fuk
z!gBw&56Z`v`{P%}im{rx0+U&|vc$&<SS9Rpe4-eIO?v+dAz)x=5e-x`7D>^^Qfu17
zE{RWd(C6<M-Ubo?TRVzk{qt&b>Czj*V86g|LgrpsLWs@k0BoK~c)6fj$Sa#7Y`x1#
z0sK_~`%YCq>_Nzf{?7_dx{roQT39qR+o|0;4@)HWk#$)TjQaXX0DIY+#Q#~z{M3NW
z|Jg3vy)na$s;!wW-mz9=V~h&ryObh`la%BR+{AKfySYCTI?KK8tC*|tbd{{Ty(@5<
zYXBnPy{|DyIit0q6fS$4m@cezZ4^Vy*T7r<xe)&k!5<Ja{)Fjy$hRw_V{KyEL-B)>
z|DWRco)UmUbsk@~#(k(-yUqkGc-}soU1V@^#6HOn8lNPsd9I>1;uS<}|6iRfJU{dT
z_WRC-TD}YZh@8D3v3;=fywK5e`DKy1RXW9<Ok5eGw%yK}+tB1-Th4cbOOu$%9J8O3
zT&h72Rhc}ip-b~7CXyofu+<AQn)C*fWK_MhY!EX;M<4na_X54mzlG}&b8Ft0tfEN(
zO^};xr^x_Bmzwi@*yyBmbwGm0TMJXl^%q(*U{b&tr-nGqx!U-jp1*X`5a>A2gmvIh
zueO-*=pz9_uMy}v=5g>j3uS0KERq4e*$R(jId?%t{OU>!p#fsE@(&^7uGh$veKeY1
z5_mmCk1es}=x6?*EBN#PLGuKM$J=tOPtH@CNU^{a54^Ix|8Nlv2fSYXun~skgll#=
z)&*}#B86)6NX}5p#-B7Dv>4}8IXFq5Gvrux8w;DgKBxapf+mJ%wzpQ!Wx&c!xl?1P
zq4{IWR@B)Y#3-MO#DKmJ!PSvy06E~h*_nXi!RB>qnhpyYV+(<3h*95H8sBd$1UpE1
z1CR5m?=6V`tcS}{lq4DD9dcU)$wTzT-Iwc_#&WM8(srRH$OErHBjNW{&E8jfDMm7g
zznv@VBUh1vgP+_+J~A{@2nKN^spMBtJrc^XUTK`n72>aQGz;)TYG67vQ?n01rnQ%)
zer7|}+XOglH(~QoSZ1jsNlrGA$OC;!LCaVRTxn{?CJ;yVYu0H?8fa>D4egI)j~feZ
zH6MPmnRSqS?KY$y2T^=%36^-ejzYyJ27=WYh_C#+(uAb}(#04fL)m<Z*Os)iyL|%%
zP%JhpMFW)(*ulashVws3q%5#54$UNZU3X{(9^Ba>X)GAC{b+ztcc3tSGQ_q9I8g%*
zTGBN1vZ6<b-cS|xso245lLLhy1UXjNOs0c4C7-~O`MTU_x&JTY!OU$9($Si%=*U`E
zh;&z+Y$@n{dHZgVE;z`EhGQfCSLznZE>f#?XU~3tzJ2h7wDw<PrR%Q$*I0cl-!&G{
zO%S?cy31V1`o9}Ua`HP9*rx^xHTxsM5)4=d0RKQp=U8ZqAc+nl$!k-kutt*uuy}Mv
zYEGi~>i-Sn!(Dp9Y_f{lAmnMuKSzQgSva6IwnC4VS2<P~IbqtSTw)}`TLXoej9jk~
zA}l!(Eccdk0|fx#p@zhu5I#`7yjQusa6Qc9j8VR2Jx2t4R?<K4_qwYR&DH;&|24#!
zr{42K-Bh^X!^c+h@n<mS$5#h@Pc{OC$uHtXveSBGMawn58z_)xv=GwCK(ij2K}Tb=
zGSugST&d`=n2HQ+JPY++6ry(NG@(b_+0phR!Sgw}f!8MlFgpgU3Z^Hrv+@}g+zq+v
zNJwLlhqhy&pp}5cQtBs)pFIB3LVzDp$K<I*gRxv<FFTw3O;;1BGb_I;EqLyl06)hM
z{JBD^?4vqqH!Ck=+-aPt_7dR8ubcO}M(U4r*{gYCPr#pamsG#gFTdSAIiMljS5i3G
z-PR=HH;R;*Q(V|N-F~tHc5*-OD3>4l(^$oKI3po*@|@N0_ej22WPT5!1d~BA7w4B>
zX{~1+;`E&lJ*m|q`jX(>37c-Q#_0gfzFRw%_6OoWo?FUCMYBFal+{Us`alAK2HzSh
zdLS-Bb=6V<>N&%Gm_)2pVX3l?Fe{2PTmJ8V-lPhN3vI{V^PG<BgJUCSvZEd~Fd4!$
zGXb-@I)pk#wc%R#t=<84ArM5)%ZBcTLWAxGnQ^_r(d4|VW2f?U+{y>yPM~peUO^w&
z7So-$`M&MAeG!{=%tS122<nlLNlM}58R3*I`*7MXagm!W$`m`5tXTWGp@RyM>HPec
z?W%N0)y!sO;Rm)m9T_P9dqF2qjAM8rdk@jApyPk8*2SrBLZ+IuKSl0{qqq~q*IK7P
z6?ZD_fmxm1YS(xeg;cs6;dtDF>9P3m0E+G2Aq#hKMz<-;fw}!S=M}VIl=hzqTiwL;
zfHw+S@22$oEcl~vavIBBFrJ*3`sQUe9P`<0QJUf2{boo6X4T;oh#Fc4Avd5V9{YA8
zR$eN6<dKCWUkC{*-MHU`TW!jSot{{?rln<iK?H6m+bdpU5w8Tl@IQa!y8b71gD}*K
zZhRmkyQyfBP$$=~U4kvKD()qZ83~uex0q|%s(!)*RsTYQsUI4yBr(ihnEUtd(3w9W
zW&9yNni8!>wF(<c8b&??Ou)B@^~rTSm6$0VA;d{RS()5nIs|=$s-I5rKfYq_>*EC_
z%&+4J4j3nE8E^o1!_qhd%_6q%`ufc@<fsp8;`aSm6jnF%=A`U@i$zhuAAHWL`)N~0
z-{)Rw+Y`nqLthZ4bJ!I(ayEZ6o0TLhl*O-x%Km-d@1R{bf!6qF^1G-DehW$pY%~Qe
zqmx<a#_ln-<}*Shw-bS8q?1UgByUZc#;Ak|r{b663=R??3XMR~-uj9Bvj(B-neYp%
z+w1mIcU(!b$=eFWTbln1S;<}}+Un4pT&?;b`>VupmPb<U`tf}z)7Kv)-_YAh>d?p0
zr|t2<TtqS_H!eNnhW&x>32UeFgk$WlYG1LWg4D==S&Ld3x77B7dY@ecB0c`RXo-4@
zM}Fy0u1F~WKFX<TImncxiH*^i@Hf(w6@qHb7#WxY5z&X#AgH~dm9fJ`7EUtg5=7+^
zj8vs65MrKugmE0Y@nk=Q%2b@UNzuM$-I+`^`%74#x*Bo?k#eZNy;Fe-`u2!}p8s$K
z3g-Ab;t&#lZw#sYEqY7eQ}lXd`nrX`PO+Bk9w}SCQU{fOA?Rd38>9dtIdA{AM<k>2
zHS6(4$w6;tFn3p){ljlHR&*bY`aXAsVRJK?%?J;;xj7S?bvu6O2K#E~Esfw!I6T23
zL3df$kyf4jLybcf`AcFp*17-<nEqCbMEoE6s9+$_``537{IvCU#2F49iP0Hvx;<^F
z#t2d2kr=Ec2TFz?W-LD-k%}*AKh!plk{<5!+Oh2~|1E9OCi_NII%{3;atIH3IqRBi
zs&y^_)6_|~?8ikWkvk5%y)q9M%`i^Rxy@>7mUIY?Qg%rBRYxZ%zoOJ3rjq<h&${-A
zWH3-ccAaCY)o{Bv?3AD-;e<&)oP-@@#D=+@#Cc8qm9gA}8qzcPzzh@R2w2L6%6{(L
zU!Q+b7Gr5x&@{u?YGyt`X@rrV2}(d(+h)K4sz5yJytq;6Qkp}Y2hy>MW!Xuj3Dh%y
zG(ZvW#M${k&@R8V73sv`8c^)zhR8X?NlHJz>i|dYTbCu4`gj9-aI=q=Mx_}Zw@*~p
ziGUrpC&ikDwc@a!<n1v$Hu!k@UE-<=qbmIu$N-tyIh|585RA0iR)(`1s@1Nhyh#Ea
zR-z%KP`vuAZO6f&=YYR%%aZZw$fY>J<DI|iB~5*B7*<_P7pzD~`C3&k;J321t*{!3
zBA3v#P-T$mQDM3kjg|tpnT`oy>)?_NJ3eW=4K;plt@LAG?m2B$>VS<|`aW>lvzPD@
z^MizKI~r<`od9J#gvbwxV1LlY;piS1v5izfhe{%pUKsCwnG~TfOjdtMik>K8d&K_(
z2c~m*D#2?hVY?dva|qr52=pQ#kaTF5t&4>!tUmIP2&fXg^URaW+#&OE)?KSU8}ky#
zE?P>6sDbK$allc_bqC^*gj@toiMfH0=%oprOW6w)g!W#9KK&jUqQK52P~HM2r4rqU
z(_v%-+P-||i=Xe0p~4oV3gWv<-vPc-jYFx?w{YF_YmX(+EoDupSju63W*SN&_h4&9
zjgf#c*HruJ0MFc16YPp{4VsuP{;Er|UCN8Pv;3U95W~OmGurG~I;Y2NBIR#;R=Cs!
z%`Tkw?$in#miC9Dw>@K3o8b*`(J=Kl`ad|SuLm7$=Usym0b{Luv90Z&t=;ZDUsmKv
zzBAf<Vck;7?eJqb>v*$zVV$F!%2isLql3`F>LO=~v_N>EL*ljl>My}B@gvE$jK!f{
zZH==Jr*|XSA8!)5aa$c(Z*Ns|V4&#x0)!@X0~2YlLf5y&?h}d)mVz=+mdzGR=y^-I
zg!SL&UPl*zC0BX@k<ld0VYo7O&YkA%_3ltK?L*3lZ+vR8a{bf9{hZv~reVbAA0I|W
zs{VDKH=#JTZhiQqEnCX7(vhkF%{uPrfqeb%Zhf%`O%M(o6%C%s>dsG3W2b9nr<a!^
z2A%1fovDwW0=lYEiB^-ib5%y;`zwdehjYfA1*5<>QIf@Af@DWCVpuM2UXJ7#vsC~G
zIXf3Q8@U=etBgB4IXn0N$|54<tkTX-9^^to<g6MR9OV4}_ZJNfc5=S|ipY?&oaF3m
z|Nm(&a(4FMYV)RQb0~jY7!SAaV0LdP4luJf6lRmVH<UFB*cuj^2UAyES6xn>QPI-L
z!I@dY*}(!#6$+&Qeu0Hf06VlmVSqbZpb)^W8&HJcb~tEe@ID+gH<%0_8Wn644#f=j
zzuUnE@X*a*`3NW;ST;6x9<UMuG!4)|W2xg(@3rYMXXQ4>)XIyK6BUMXxEql&s<q*_
zDt7SHPfRIT(p;f=dR0ovihOnxWr^~J5Vv`POd_+`@P3j4q<3om$OhZHV((>87>_NW
z!q$;&l<CrW;#18-)@#eZ4Z*&QjwL<ce-D@MuayleI!&cf1hQ06`7Fjw<zc`O(biip
zFYD)T#2ecziHFz{U0wNB`>nFZx9k)Wv!f07jFkTG-z9b)V9Qc9rC%&Q#hVB5VI0pH
z2o=LFIj&<JGx~K}JKo>)c)y!3R~a-pjQzbunx(tAA6wLvs#M-zDw)@CUgldq^zdAq
z*ZgdxERTr!%>D1}*YX4=Ds?bW12Y}5UqZu-3N~lRo<`z2+RTQd6JuP|*pB55!PU0!
z@t>J_d2VjIb}c_J&*v}9@waokb{>uqx+{?hfz*g8zaM!S{>=Ua#r@V{BK#YYnKR5>
ze~72p`F!z=L{L~aLjE-)SsP`sWb>o2DuvHMJ$VynA$OysOfSGs<;EldbBtl=3jVgx
zKQRPjPZ1Si^KR=>kpK_akNJXk4+pH{QUFsz@Kan-Lvh7`A;5OpS2D#=D%20*PuXZs
zazh@+bf^Kd{;!7jjmy_}7NzC_Lc)ZrK$3*jrS5nbm$aUEr`}(gSKr_f9Irs=t7d<<
z2;P47K*3j_>iuC-lZO!kc5bl<Uxd8J>lVIydW}QBYEjF*LRT++n(&<jOrSoTu_Qla
zg$l>+TwJ~uZdg|9<91yJ8wyU$R_ZL<hLJj6(FfBOF5&zfJXcjSr*Vi6l3C6Bh1EC_
zTp{af|A}l6g$zy1AJw5JkU6C~z2_S$j}se!I7US~lV*Ya_e2m8Fss7$=LvyM*F|}K
zPETut<!ozRb)~97+bCTHb8y3-W~<NTgOew9)qsxkVDe4u@{klS9bF{GD>=rbyiw>B
z)Kt#jCe`Ioql8SQAp_{EMFXg0^?muDKykHlMN0Ipy)gZ>!rdmOpYYhyM3q@5n!1IA
z$Fp}q2aP>hX3<<j+DHR<&AB~i5Ts|t(Z!f%ear+eIGr=UFx`=j3i+Z1Y0kN~9zIPE
zhepxyXFmOt5vl@DPvIwp`rZ(UWUfH*ZLbauo1kkS0&NWDSo`3h8lO^fB4nZg@HjFw
zJun*^X61umfx!|#P!zt_g`N>f+ETAbm4{$~`S%}6E33331x5=`6j)zEDn+$0LXOsB
z@3UCY_gPu&n6u*86Bx4>CIZv2dfkK!EUKd7pXlhFx(Pvl<RYP}NRzP7)Z9J^T^NjT
zVy^RDOu}im8@dgMW055hQ18%0LdjNt^8*@yaN-fjh@%Mb?NfI0$ys{U%NLmj^e7<d
z96t%n!;f_TO1e$*xa<WBf62E=!ugKv09CCAopevD<FbhLsjgI#gZC$rZ!s1dC80SM
z!JXAe0;~_`k&8hYyR06k4HcH1ibO0Fmw|*7h(;>uJ2`~@rk<XG{JVPoV3Zm0PZJ=B
z90?dm`8fl&AHF_Q>ta=z^P}q{;a~VV&Fsv)yz=b(9_qpR@FP*SB3^RE73O52Y4kub
zO|%rueNr?Zc8eYR3e#XOBOh-DS2A*z`SO#)00zy>&qK$2D4*-*Xp+F_YAT^0hBlZi
z$jp-6d+U)@g2Qq*9Q@K~N!qgbE#g3bz88V}8IoD0ciDRZqvI0o-*I>e$j!0`lueLD
z%rjhSD3t~+u_UD-MOCuV4Ot7VVIo?R(pv|mAzgz;KUXgOk1@|!utCAX9<8pd<CAaT
zn_Ra6bojCGURJvVA9XuRYIv9ab)0>#nQ56z#9h?>9qhAY<L<3z!Z!#3Q$8@(AjI$5
z=;pIGuYts@N)UDe-FduUqBFC%ax0|*xjsL5SPBIv5y`6}++fyYl=fuF0bIGgL5x^~
zeIvt>l<;qQI0^B0f<jY~{ME$oGqpod^A^*6%xHVrX`{`$VPW%_&gDg?e_OL;3>eT>
z7{YR8+a{UY^a#v2BTeBiYX<gjd=IdjAzvunm*V58g8lLn=tq#tgF8eC!`Vvx<zs^W
z(v20p^-=G^XXv~^BbGRHpTiyR0|(qLcD!4(araQ^qy~Dz!ZXxqg)K=@X!1Szlh2|T
zM`}om7IXJEU1U!9b4wOaQ@{Sn=IN$jfm@YthG26!)(YAe*L*wY(l0=`H0@dlPyqI7
zou7T$p8GSa_Td3j65RB6-&a1d_e31o3l;tOn^z*cdukhsTD1HD$b%bi;76%c(KT7T
zuiet~PEzHq)OF6RTKg#1ID^}I^;fF|Yt9=7qR87+L|lzTqAe-F<HbJLVTzZqVXW`t
z;H4Bl{OiWvn;{HnT^N{$hUS5-1jEgatFFh6)fc>kJ%!LtR)z4)#N2DG-(p)#S&}oW
zO45-)&LcE?zI;<%G3W_3WLJ}d%0n1W=J0tL%}g-v9JSHPVajwZqym3U!XdimyV+W3
z1=1R&gM4*^>F(pTNY?>%BeKKWM{18qZl)mL;Ng=npL9pC`2x`EtXnH4_BJQpQAk=0
zb_i3lhJzonn_c&g)k}f=C#M%N4^q`@t_V@qUp{3Dfqa>$5Q0b~;6wx|QVpd~Om9Ip
z-_?>_z8osqzgK0ZNUCe<K<Xsw9f=$vFI|r7B%B?pQtH?k@?(MmLh9rgO5J|t+CGb<
z>x`8>({VkzkxXEkzQY|tkd_W531$E@YPYNoqRij+-%;^VhlLu))pt=sTAK`Ar8V}8
zc5(KKtG@MX^{n=y+FJD4qn94Kt>NEG?$z(s?yOP!t0%5nY7lP$2@R3r$B1^4-*z;D
zz2b%se{220kleX!S<n5(1b&4?H)M2$wQ`3}kfJP1VETdRZ-EWA3R`a#N=kGfCu?AE
zA0)bvT$r(^Xi+foo8qUfx^=C=1=5{93Ub1v7?39gE_?&;ToL!i&GFgA%i4T*va<yJ
z{kLJ`drE27D|4pHJEzaKa_-#H>vR$q`tc-be%ZDMw?-8W<pR}4U{3cB4;ev6w6?tK
zxSIWaWG-M;)w@i1&c(Nr+KPC^r#EGXS?i_a)2???;dq}S5AIVqLe2)sd`;4X362O2
z84J+eF4^Rf;L5x?oHI^`EQ(J+U6xiIt1k8iS?42kC4qt$E5;aMt#0?LWIJp4ld8Zx
zdWYDhx#*A}THeyaW)5Yl`NpRm4ctJDC=lXL@FURRAigCqzGoFtuoBIn?W^H)YE>~k
z1I1~-&o#MEk$i(J<$*nt#b?}zZ}s*n;ZT*MW0#Wn7K}l`2dXszf6+03r`R(v=V$5<
z;m*f%@AWWp8;bI&V&qA(+%_<YE_$Kwef9Y_^mJO3K2HA7*V6&XDUWrQTeDt;R2b=o
z7(amW#BA_xa_JeIlvFe<L<;aUBKVC`jBBWiVf7$K!kN!<YaDJjv(hF<QfqP^S?sGO
zkCMc-H!3@UWMd88++*Bj%x5Tk)6S;CzsN|w(s%a^8}m#k-qVhuwYhtkD1dmUBs)e*
zy<5zs5wd2y{i1Z3VM}fbTn8rvbAC=h;cEjysamENM%Ql2C!@Y`?e_;W$M(s&>#vLt
z%oAw1O^Sv>hYR1!lT+rxZ7#wodeqmJb@Z2(hXXiySxf#kpa3VYOD?^G-hcY{v((bP
ze^kEtz1Y7HY>01JZUsc$nAb-c+Q>lNcB7nl&6h`{CQ8PJ*kEe@`KA)d59fh=RKE<o
z#+-&drcx=DjnbkDFRP>+I5oRVC9Z3&zqR^)e8BY88>zI^T>iCS2Kl46GcZ73oQKvT
zR?0^{7>LKr6A<G;MO8GSF~Q}&hP=Y1KfGvR&mEEhhv{KPMoJemw`a>c?I=Ozh^aJJ
z7gQPpQoT}ngANG&D?&6eIj4EIwTu9aUMZG3gSn2Kj{o&w1z%ywe6(5!Wx2uJ5$`<}
z<!zUrfh8X#Kx0!@C~jE5sO2W5d#@)>OIxSTK}XHd?;wBY(nZqEWg5#;?PmM(;(S+N
zT33o2JMbCd8=Z)9_i^=D2K7mG^f8F+WX1S(IwvP5qiAfA6aW1EVG)~I^qmk$ET-Qa
zV(y^#eDJc+%jH?`b-m*a{Fu_#6O3KVsoZMEyS@x=62(Qqc<)bQ;$~@#)DX1qUbgt%
zI8T52i-l#>oScQ9BF=pXTX!p#P2bpX?7{y~WYWeS&xdeIe!ZqY$Tl3W+PH4%NHU}0
zuggpa^P?x3@M>gu3<&3iZ$kojdc4cPQ0}{G;VH<~?WCN8x4qAI;z;`vkrSg)(7;`*
zL#1(Iw<n!{4eiR1luk>~YxnhxSWCrIV4z;$3D+8pDR6R{#Z>Jms9Li%NPsWAg3Qq$
z-WE*m82Y3kh(*i23izc8&*~~SUoJNtiWGkA))9`a8d9zk1X~g^S%VJzgu+fouo@DQ
zV8uDxPB-rS$8Kp6F_yA)euRiko+UIx&Mjo+Lu{EBhPN6T)!pu%i^`#@$o33ou~#Ia
zGGr42*~tnK;ag7xOU}2|PBzCXJ2<s(>=<@zml0OXGlX7p-FvYiuZd3N26|yOq6qhA
z{uv_GnZ@Q6_$%GrHaucLDapO8Lq*xg3bqZ)6Pt?s6bm`3U7yde71Aiso^ahNpL$9L
zIR8T1vP(;)yCq`vQR+^j59)tXKT>JF*69;<W!tHDPN6Mmo-Z)@Yg3-1NPoe4?2xJ?
zYQ0hJFQapy-g`EE95^8{#7;})+%df7xu;0U{s&6Mf-+5t>6v2{7zPgS{5YF2&AglC
zGOhD~Z13F0!=*vF7OCgSkLJ~k4pLK*qkHYAR-i<ZZvXKUK@&~&ULf|9WVFOF%{X2l
z8Ofwpg&s&J80+-67_N9;r)gp{8)hINS-F88lv?UOp;w2++8p9x8pI|iD7V7Qg*;`S
zv()j&Thkg)<dlI13>Yq1@nBL2GOSO$2*q2j;QCr|XX_>LO0|#p&fsB}t8SE6)k}Cj
z1|T`WAGf-dpETq6W=t1rK9nl$y;FnZQxg=l(3X&z>l3I|{UG{-?GB{(Yu_sD$-pMK
z`X8PX6|x2U;1z9*sqhY66%ox6pKPpmM*)lU^>R|Txok8NkdXqbbG<3qvMdygP)3tt
z_7SfE#fur#&|~6g$VT9UQ}J1&5c!p8m#)7PPxLkEJ$vKnM&2%OkTqSbX-?Py#ojEw
zme~XSW}4pyhIyw&fjeVSM>bZ?b`BYjG*L(zoRXFT>&rLHm%5ER4h$~H-+nu|ZI)87
zA!DWd*>r*qbXfKHR5p>UqdI{|x@i<|`|veWSJl|~dSb{J`0h&IUXJZD5H*bJ=qzK<
zEJ0e(XGU>?8T09d>B%CIPuyeih=jWs0K*~%<q$a|pvyIMJir$}u|J&|J0geK=u`dE
z>?Zb!=Ws%+yKBq4`3_IX>{&K{Mh8W0PK}fPhYar&aInuzOz*%#l)FY-$v*b6O1D=e
zkM8%Ymi|$u|9x2yIto5$L|!6y#z(%l?w9&(%8w7PqnJGNveZibCTfygMVqlun=vl6
z0woWD5F1}2InH!utxOBa!mNYnUMN-YJV@ufG;)rcVPTNS+uvX#qMlw*u7;jUEo+7)
zniDe#D5C@KGkyQcXMhM3w!J>FA#%1$%aSmNC6Z^L%f-qYx*OsmaEQ?xTI-fcT~e%@
zY*UC)r1~Hyh%0LNJocwZc;Eiy;Cwyc1@;x;RsWu@C%m%Ku&L<D=$B>B%0rXrqjk-e
zzw>JEPNchAZHb@P*<<eB{%qE>I~W{Lh1}!=WT^Za5n)OqK2fVerDb-M8EDsMLU%?U
zxc$b0YVv2DhStnC9y#XM6tlSD1b&m*^3yQOLe((!BCaFHuum<Ao{{bMZ67|<qNWu+
z{EjiPcBGk4?9v0JQ*MECIXO|%K!h^APnsB&O~EHU8Ly<NYBKw@mTk2gEjfx3*#(m=
z!0@wQz8;EkwAKj6d8B~wi?sK&g1(vUvxtib*Hlvrsh>-*Cv`qyHDGHG0`HNG_DGNV
zHHLP#y&0)TM~6ZqPwq>d{W5KWg^rF|w*}TkCf~X+y(;A5XT}S|ySMoBhF`^D=>z}n
z&8AkejyZ1zH%Jm+^vNzA=^w4u&!>0ofHpB1Hf-M%%Av*Uusr6|Gk19hu}YXR%oDO*
zS0dLNFtx7$fzV++R8f!0<d|c3M?WX*Ffr(h`KN!GUaS_$FI5@0dN8BJ+3Ma6zJjN;
z8!T($ZKK%!)U~x?XR;NS$Gk_~*G#Pl;*P~paN11m4uh2)2>P*JWji<#2mQl*fbuG~
z2RgmB<j-!K|8P?YG|W4XGQIPmv8RW)QhM{P4@yO|*4&O%#)9aIaV#vRYv$w9+Dt5H
z+Y&`T#;<ovPzGJ!nIuF8spL~50%Wt~YQGswTcF#WDol7#Nt)|nKx>tVWS@rH9~s~E
z!3a8t_SlJQ>=v2|k+M@s&fz@N0RN5rxdm?l%~etCzo_9GU>x|b0UdPVCW_d(0<FO8
zw|Tu`Hy$uAWu!|rkAIAU`)sykNSLMV6Xt`juhXhCut=25hB^3mv)z24-In52Nk-P+
zQ$;D~(KFff7mPU!IE*+9-3+3@qhU46N1tj0gtlcT5aLEGV)=Xr_QN5(Pl!lKogb;v
zp*TKA;hMtsotQlH8jdrE@g#CGGhPOG%KcZZHQt8>yR<W!#JtWGQocF;PkTNwlr457
zGx}W963ooSvB-`o<+PIH{iO>do@4vHIf1=7V$?CyD=z6l{B)TDLhG3-@ni<Tm=ZJ#
znI}+c^=^bhmHOCqC+j~p-~el<){NjZ?3%Cjzol)XPOG5~IW5Y~;DEv*?swGhk_P1z
zs&a}jG-(74Q(;P$VR=pb6$^gk?83PI8yM9iN<VxAzM_C7*Hcq-I;-n|xHDROFdube
z`g@mdtFTcjJl@ljGu~uZiz&>N6@~^{GX6koprK!@!=^jBlP~=)@EZ3J`0v$y-;r>h
zPQljq`c54|xobGb68O*F51QM`(rH!8SSZs<ElM!Y9DiaU<x@OT-0qtxsZ}XEZ5edP
zsJMNdDOLVwx{<?Ydgp4Ud~`g@)`NwaQP-{^BHa;JTs`j?0V&Zof$yHzl%6R*hK^;q
z7dV^fMJRM9!LP&;z%@(XBiWUxM-||cjceC>h|W@k?5gRst-fp-Q~eQ7L|%zf<Plf%
z6YJTw)^6Msd*MFV)Z;|V-1L3GQ<Fa59s#yB?p_W5z9zo^Ca`$Z=ocxhCnY8EV|+4w
zX3p<F)`;=|%)iS39!j_V4K>|gO8n7#u6xT<$&NbXojq7wz<TO7?5{cf6Dw}5St--E
zXSkj<N&eJp2rM)3jnrIHY#`2lp~O}8&$*70Le9w%sg2#zj?qeG+L9$=PdOuE%F7h|
zFT0b&8`E|_@`>~JkI^1F*?gS_@XHT3IPZk%FFWo}Cht4CB8R#0_g4d5GZb=EAl#f*
zQu7J@Ub?$%La-atBwIxGGZ<z36jlc7uyvkULOnv0Ck+M%1WsDufREtjuMJ_^MSlJP
z=inoMgS}qS08OvYP5KFhM&JulXiDJqKJ^CmJ9QuRDfL?6Z@CA#xTji|PS2gNe+j^K
zSB_OoPn>O#^}smH!jd{nASRFy6S2^!3#+a3_iy-0WmX^TN7Rf^`OmlbPM`M?!Hq0g
zTNtC5W4uZ&&XWmU`Dd!s`UCkAiecj6j_;SGc)KxUT)%fH;--O=F_J<L9|*w9o8@qA
z;SX7xHl2VhL8bt<19ofeUH5P{hiUPk1FJaG>_#RRqS=4AebQf<i!J)Ag|2lGotzMR
zH1!+H^*Su&f2Rz7>=VUW<{G}DyrMpIdE6bzx7R4y6=N@-B7W_%sDgZO@{FfZWj$u<
z;67jM`-U!ShT`|TPxZ8B6^J3gvO!YZg<1R&4$S6+SU8}{Nspe-p){(0I(VwQu_sBK
zF$^H>`&)mJ)L5%$vqx=pC_q!Xi=>iZTQ96V7X6eaaIZ8{=jd}HV9TL0S`=d~gP`&j
zs{HB4d@aQ!U(!fto!dsrG23htI=ciqTFMLEdwV+)f3RQ3rjc6MSUN1Q+@=LGy8>Tv
zSEJQf2ZufP#*}6?+eXl$;+6yH8ns9dxblCPz=mme9+886r^Wf`5~D2g<4iUA3kJ?t
z6dzO0<zpkwzNi`xmQI8cyHQYay5IEAH=KThF?$}l(TqfTOW)(aOGNdvBI5s}#6|?0
zyqQv{2^-5YlCr1nk*~y+yN6Y3p4%ZpYf}^<+MkC$vlT%tbs4pk5P7Yn-Z^NiJozdr
zVLo|GdgO&cl1sGxtJxI{7AJ@P3PhA?gGDQ_jH?PWtrtaYdTu1~<2ZayiW>b_l)H7k
zSK_Y;USjsO9~oV!dzj)6IEo&V|EHeilDT()8^etDQ}}*mG53A^w1^sLVA`|XYoTv<
zm@_%YGOx(JN+n}A)I6bTPL17}?nt4vN+cKAuBPu$46K}g=S7~82o8)61qx&lKO33y
zsUw%T$hX=K25nZsE7ff6+V6Ni=s6#)mXCCZKC58(9!vUJ$q-zoY-KZ^c+@X+qv(rh
zHM_X>{fS|yMjsnjsr>7^jVU=`NC6EJ{9SeQ@hb0K;VRtnXLsw^X*+oO?d7j|Jffh}
zcM?W@SHfJ~7&o5C{pO}N0Py}=5k?L~{}IsSOaWzE^pu1414<U{={d}~`RESrLTB_k
zwrBW&yz)%mqO<l#P`wzIO9L`F(VmnA6cdKLC3EHEGah{9&;YGxn(zSH++CLu{+RQ3
z6LANa4<OSM=9W|r>Yk>iloC!h<&D2Whf-dUQM|r{ABxnho$D*qKcM%ZSY%I0-v%!8
zaG_=u_mS%Yk$27SB@EFE`CFgB#qIAwzGj88XzW6MB!99?g0{1f7Agx^cJf(z;9LRi
zEaI0Og>xGGikVLIdFFfEqi*k3wNiC*`p(OW4>p}ujyytAIr#|t!5KW~=%3~2OTT*v
z?F0YLs87Wj-UC<KUx9;bXVJoKEBN&1>=dkbJWQ<%6bdLEF>Z$i>)|R+!rp*v$`L=X
z*8E>qr$b~M7dokU{9_!_RfO+>02LKDk!<P0{M32?^l0p1Z7L$a-b(x@DEkL;v7<I$
z`{T)q^{eOVdoI&s$0+&}*f(t$xdM70kT#Y37?J@-{TIEe9N>9z_;O^ts2QD&;F>so
zr=J!Rx<A=TF(1`BRe!bmlT!9!`gMdTdcJ{Gt!{Qq7B;6I1~uH4Uix^y0~f*dxDCe+
z2x{V#^8^=VMxNQFyU@8IEe1ZDa#ti-m+SE89S=>uPfa%r+JwGm-Erya1KKG+g;t(6
zL;TjILpU=35-8;z!aMlI|HwHLe`3m|Hnh2!{9j(n{W*e2x{4vak~HFz$PKfLDD~b0
zm7gK$_2^aiv@%-Gr`6G)Zr6`aEIWh&zJpuY*Syw=k5*6|8GDKBHd~Y&DGF3`Bf=K&
z>2g+yzSoAU?*zf_SLYu>9Jx&09Zd*V{_+eWx8iSI&=emAYk%u3{g4^54FsGA+hbn;
zELK&JaTobG(mZb!Sbp$>iJGB^Kl5_1vm;wNSvZ^7A@hSX*PyuJRMn(qq`<hLP~_m8
zW+*|hODL2v3^zYJcsdk{5amDQl7oW>a%2O)g+dX*k#q6$A%ls-prqi)x!E|7!IqFB
z7`+uL9L&}Vg$%>a#s<C&gTe!AghSziOIo3r;HCesiOg`Q8u<UiO~GkxP^>V#>}+5~
z1ZZlYFOr{zRO4f5tG)9vO@}4Lu@YT&!Y3qZ3i3n)awHG4<xnMA2_5LjZfddK%Ag3F
zPm%dY5o`41I~>^|MdG9cQX#ISS>6ICF_Q|?q`2X#9+F2FKTbRmf&?x*E?)z>9$#Bu
zwH7)wn^M(FCZBWF7aYe{iN(=R17R#TllUuuc>z0_pN1=Lwdz~)A8*<|y|utqKpdgV
z&m~tM{k;Qa_>z~74WEM1xVb0OzjTDl6QDcyBFy-z{dD!2OKQ}d@g38O5!G4eU`=&?
zhrZMYkL%*ve-Y{SU79*zvW-do(nh>nzL>i2SmVn$m|ZbOWWFEyMXZ%QV~LeIjU}iG
zm`5-w{t21(s@vw%3oFwYR1fQ>hNwx|5g^x*=>tB=;(lK^g+aMS^2aHewwJO^nN>(T
zyz_TE@6^D{k(aB6PZ^He!rL1em|%AumRB6O<JybG{CRT2RdsF9%Md$JD@J<)Ak*9x
z+i>|@alnij0WAl>oWV6Hj^E?Zu6NZ6B&<635)N8oy-qsHU$*BpF^E}UIxB4|`D%`Q
zOp+F(4P#W{b<LN<Z_+y!s!e7j)E>Gm<CWbP{TlhU`_v93B!l*#P0fjfg+aw_*E?3Q
z6tH&7z%o$M4%*SclKjj^5jbiBmpNirdrg#@?}h}zc%f~Vqr{+ib4XKc?DK?t+n`&D
zwud^16xI!G5;NeKb9KIGDrQC!EfDX_f>t-ML*DWlDzR?M*E(VEzR)nPsr+-&8`;1|
za!tPWnTk=IroKb%4fJ!=x&%)U)FvHq+vhx_B*8ZQTeTsZVOo-5nC0P$>EDCAkM(}O
zv84JZP7|`9lh!X5$LHDgI51d_fSY~Lo=I>McH+v)W6|HLO)~N=Bjqc;sr^$SE<`5*
z__s6&+^e{&(5u{)BIs|DS#5=R>+4_jY|rcKtYqq1{Wv*ECHJl>84$UI?)2nqs4QY!
z6Diw|a1kv%X`E_y3E^IL?CRX-Hw;{Lllk#(ayEOualgyHx^B4jQ&s85I}p2+H9<kA
z?~+2`ELVT#rK@%E!~gwm{_;)yrqoQ={2%yVEcC1IJ&O9jzJC^R?*rU2g@+@z;pao|
zhQa5`75w?W7;TPSB_BF=C8DxlPP}^q<}#>y?F&z;-{G~E*15$mf^$Sy4oxm#q9__j
zMr~VMIyB7}JU*f-VUYxmk%4$g9iv>Ox6W#ZWToyM^D8XhSyBb?<+5*!CW%Vji$N?U
zkdH%4DWzgtmN<YbYNdEaTx*RMM{Aiz+hf+Lg4wxw8>ky-?sZN?)uxI7L-7e!KNG}+
zwB;B}VrfzWcW?9DDjBcNxs(%ZO6Fl<r*yEYH6-@$Y63C&Q^X02;ek<ZUtw<cbU#=m
zF3QoS*Meb-sf4kX--`=>T4w!2)XJ!_)yIma%52osPUg{ZntHw-l6w)QN=eohjVIwG
zl*s~w-OH9LVjXBJ^_66w%qcz8tNWjjU@YtMPkdPx%@bgYp`nEN!w93S;J)w@pK!ZZ
zRy#|zXOE}(8bAFw@(ipkJ>&Q9s&8%OkoB<Rx1lyR=eM!MOx@l3DXoP@^vpZ&b{A;V
zqUZNzjJpnT?D!;4i&?v@>{Pq5tf;ZPz6>weCLOOqLB2djrTgThbvnY5h`pO5uB#ia
zVH|GAxSH%Ysz#aRTL6=KJX9*hZFg1bb+UJPg;-w-rM;PyQzy`1@8DxYwagSstH5wW
zTe^*CEJ2I9cWLfzWB=l&mbpk4>jK-8SEl3C$&rcG{szPi`dAvsu>U7BpvTf5CH`;a
zLf&`)+8=$P+0{WwX)4HC+mXq>ztd}!=-Lj^L3d^kwLJIK?R$k!s%0~DR+H&PJ1yRn
zEvnF|Ez{@n8xXLy74P@uJGn2_n9*N`^PpJExpzb2l)>2xxX~bvsjS(PoCZcB9>ax2
zQt+Cc&Na5<{{w|UdcUn;l{K)o)~fIQpsh_Tdo62g6KiV|Yiq5tR&9%vHM0db+219@
z*y?e}7%c9gIxViBh9r0OSi7lpw7Qr^xt%v99p!=S16@vaK<^nFe=y+1*4f}OgU7He
zl=Lhs4j&t1S<ahAxs#5PeX%SPJ~rcG?niA{-qzOEUcWs0UA`P|+uPX`wddqSi;)}%
zaAi$FT3^-_P_{G#T%OW^#2(C!JxKGEq9zb}Az3&E8SLT}NCt?!k5?~?!^<MQET6?(
zcI2G!Hmb}&M!poze}E<OugI753$S1nmp_qz^Fj4^)8#@xnTWm!cVZ^He)@Aebi(_v
z0Y;E#;5OI_H{ktpXo8J!2i#3tVFz@<LDGXYEP|hrLMVj$p#$!Z+!}cqk=wV#9chIr
z_{L4J9Ug@5P@QhU)VnwXOCnqOC6W8FlpS%;7%a0H^A3_sf9^c2##ZW}8SaBfWK?8M
z<nahn0dhz@cCrwzf$6XWegp5pw{%bBD2U(yH~3*21jGM|OpH8*>eT^5!3WjQ0^4~_
z<aw0kT5QRHxZqlRdmh}3W7&@NKLI^t8TkcGp`*BATyNyL$QO}ISkep$FanX;G?<Iy
z*@C4X!taZ4e}eF&fJ`8hNh8@$4w6@B18t(~=o#)F?qK-C$ZsNlL%hWy-bloGt%8Zz
z+Co?Xcf+Hw2M)q%=p`1COU9Eqq?vS+6I4&VbQ$fYFVmMfk*nY)aXWaYXb9aGNsR1`
zd=&Wt5TC$s#ERo^M3q?M45&eBFTrmMw80we-<?RWe|wPf58-&a;W>C7UWd2gckoyE
z1U@0D#Dgu4AY-xBD(rbJj(8)v3wwW>{D!<m-X|ZEZ>SObQAia!jxNFetfWuU{j`T3
zrl;vy?3ad1=c>6@uAS@PKIA^eC1mAi@JsnN{vF{R(IYLpB!mZtPlo>%xjFKF<P)6V
zYoQGLe>w^0r3Sxs_+5zKW>}0fy#f2Y4ST%<`@9PthR0zqJc~W=!S4Y$1}E@)8fW-z
z_zRBV5`tkZNg^&XkPIS)WHi!$2GV~uSwrq1Tgf&Y%Wm=%d4;@9ddWW#Vtr3SRKgLN
zsGHW%db$utw1#%jd+2@i&s-XpiQlnYIakj$e{xH?J=~MrGu(^ZSKLJ$7tfF8r{Z@S
zzl7h&2lzJx5FCP6C>5p(*9&(D9m2!HNzo%-C(aVri1&z3<M&IcRC-L>k5IxR7s*rP
zlk#~S-#y4RSARaHICEqq&dwBgfE<R`$+skd48b{4kY7J1apXbd$pBJqH9QTy$bY|&
ze+-4)uoA*Zx7(o|UP6SELS#N24n&ek4_QEVku*3)1f1<p5c-b;1y0hB@%=)a>1JG!
zPf!6Vd;uv~PxSD2!jY{=<3(V@89I&}^D?}K>!b+GWEeb4rou^ZMM}6k;R)h^DWvk!
zZmPha;R^_b_rMm?iyXHTvFf+bO{QZXf0O7woVgd_EqDMrcrX76&hZlD(t3Cj7T_1i
zYouNoRXpmNkt2!<@`nx0%N;U!P)_#1tW0l4x+l%;N=+G%oRpa0bl7dyc#GL&j5FwU
zT8%7;0?$zbgUUSR4X%K<A;5b*6DAC1_ntZUU{1dWC~EOh`PF3tF81CW%(|+ie}W|!
z{Gg-~EvZ~CNldO{C>}h>RpxO8UN7~yf~01OAJf}PJ=LzjSv6gyrg^V=W564?8{cr1
zIh#sd0n*?q3zV;D>Ofd9co6B*X~%iSHEIVBf-bENlR8WV$~~=Jq<l0{6STbSnl1{m
z0mm4q@RXJXd>(uitKl-r=FAUFf1ZNaB+2cr9y};O#?AB04FFSMIcgCYr#2H1#|0#{
z8CP=vhXY$&U4xEyYz>-VZbOcKzGwcNT7Q6>gLRYz%sGMasG-KM>2(es6eN46`vaPB
zDm*;`6_NE_zV)SueXupuotyg?PvSbtoXsxwc1Oo%SK!ep{(hAuxmlIff7Mv&;6asB
z{ch~Fr)(=~`wT>8>Ikq>;>^X4vuA9W(E&%{Nk+pBu7Jif*3;B+Ljz7$Vn+a`u6B1P
zRwzdzA3;T#t7E#~;|`Q0d8+4>CU;q(W9sT2pW^aeoilh)m&qKZbXS})me3peCmL}U
zqIqgcEzVNd>poHw)<=&of1n_b&2wQ-{GI^K7{P+Z5zsMj1kMP4stHoG8R^&1VY&uK
z7Z5T`9#_XVfQ;Zd`^D8y=ER<e8K!T5WiocT%yI$L4Kel$<m3dhvl*vI<8W%RXQS2o
z!oh=91S&nPCRd;m5gknS<4e`o<RZ!4ZZ^wXf(p#Vo51=h{^-36f9582gOZE5hc>XB
z<9#`{>sikFzMRXiH+Ybp52)?~TR`?+{uxd7__C&J0>u7bWH(0haru<Fx_BX@W3t~n
zr(;W!x1nQeHF9-1uIi4Ca*wOLqoHF?FtUEG$7S+#bX8V%w3gv&j1DOnIld(+plq#f
zB1qIgev}%4_;G$Ne~B{A#1u{9FjYCtQ#qx^&t`)$SAfsJpKrdWY<@Gc(E7PI;C$h4
z&Q`{4?haGH_brZ&;3Lypp3@{i;sanc1xT?vEE0hD0Ktj(1vtkD%p5Et9cU4vs`Erg
z&%-)QuSeN82IJ?rn_&XqLOgs66tH{#DC`$LhoRyIXc5jse-B>)2e>~Y(s&ad=1|K?
zHPDLr2gLKRoPQp=`S-DoOOV7hfm?VO#!1gYgRl}73GJ{)7!1wAT390FLlfNylZ3f2
zpZ_yFNFIP1o`+o+Z<aQ|F7`~g7Mk##hw-|BHo-zJ35L@{Fq8iy%H|d*6!(ILdna-M
z`;&>@r1$8Xe<TI{A<Q2Z^)~?`9}%4$fQaLeI`Npi{GrT6gC8FKRU+D)=x9>!HEI|Q
zw3pL5OzH75KpYqmy|Is34J{DQ{4t380C5_6YA{ZOBsK5qAQ=Wg3Z!Ch+>nO;v2@JN
zKvz{JWWhklh8!3KgJB5dLLTbRVUU0I>;K=~F;C-<e?NtY?$~D(ewV{D@O$`<q?74n
zJvl=Y=m(sSdy5~%-_D=nKNl>*hho0?xD=0QW1ZZsp_=Ek6SaTRP1p76e{PTrr{c!P
zJ#F+F#~Z&iEj7JsZZiMNa$P(Ze_i~uR>Ar!TcK^Y?UFsmJ_}H_q9uY~oK*>`x&%H*
zoZTQwf6oyode;bf=OD*{RuqE7afst+g+{^>jza`|^1aVEb0(V37gv2#Jkj)Rah2(t
zVkjv#g^Ir^#^lgEx7lsZz<?mHTyk;8FDU|C1Q&lCtJQ^P&{ZPiivlG{A|S_u**JcD
zg*;E%1uv7w_<1^C+`ady4OE5BpFMweVp(J9f5%W#Vi`GdXdcNIso7+4c)Tnk|MA$|
z71a|TsPH$5a60s9_^;vb!uF%x<S#@Z3Dkx>ye>S0{9SEtgc8TvGebOUPd5*TGg#5b
z+V#cFjt;5{TRb1Sx=qh;1ST{y-_9bE^4Pp~Y_oD^Q+UQ{>Lde*Og=l>9Uc(A82&W$
ze>t|fJ~Ev=OX85S!@4;_gG5kpkx)*+c1e&*2RR=<dueQlYEw8i$gMi7j?lqnlFZGo
z&LeS3__l1eHph@J5W_CO`UWW$LSe3*LnDJ$2v|?`GFDHo=}R-Kq7pUn`o!vJP4RA<
zdkpo4-lGfFU@gx@dPx_0uXT{4*l{Xgf1Ri^V2_S-glp6I^b7lXR2Lh4)!DkCc^ShH
zn2DY=Z(+f3GCY66gnYa{m{5@K^W_&zV7;3V8NrpJ&B}qISkQG%uBV)pQjRh=HgG|*
zsRt?qg7HD><5#NvJzsSeIj8C@l;q;jHw!~@Hs5$+Xr2a56|OY&(9h{yq4&acfAMLo
zpLmdT52CFszzD@c3C9aB0?+9QPeGs;xFD6g1)q2nEu2LVrRn*zmXVC2B_*NaDA%~n
z9<zt6CGNXF5srO7M#x1L$JNM>z<z5`PAyTaI=y}?I*K(K;Pfx@7)g3vkQx*%HmoB$
z=>idhWQ$@l@~M0-&uNT2;_!+%e|?bZ4{CgdJN8D~X5*@_tFNoNR2(WcTd)&nk#lqL
zhK-WH(S*Y!`R05ZcF63`FcYpRrMr7aXbe3To+R{MjBE?<Co{Iu#?UV8qdI4NEzX$(
zshj?$NW^s@9oG~6I*TqLHhH@>n&U=d+->tY`{wX$9WKXy^H{>BlJuL(fB1gs%hSrH
zmR)@9go1(zY>qFjzcSMl_D6bo9x0ZM66<3n?SSim`-JO+o4;0nZOUx@?3DSM8&lTn
zJGH-bYpi)@+sJ{z$Xkk2ZyuQ?>s*<6HiG_mo6E*&z(!<SklfvEnUfGCH!0TR=t5aH
zRA)qCp9@G^ATk8WgGzele;lMUPmT{ELv|MwB-`fMccsshDn=ORC4UR^h_7hj&KTWM
zP%w^SbDw**4od1my=)#zLUrM2s!nBvajTW&3~yqR$t;NGMB_~G3h6V6DakSuGQ`Z8
z=*hv~2K-=zRx9z0Ci#q3aYPa&(Pp*h4;x;TA4k*`F`5(&FB)E0f8h0`Nn(HUl2Lcj
zv#*@^=-PF=UK*Iav}WE7`n#oHKmOS9!a29Sdu{QKwL7O>LtK62&i&2jCwG*uoPF&?
zZ)VXowT&%L9ND+Fc+rF+|DZurXRex8c4^S%X`ra-Ksbu)K|-I#qsr)o8lvSWl{LH|
z$mq8g=nMi@f|5><f2lA-l&qpC$r5l{UPA>U^7R^xh~i(AWn}T^NfJ=%z-2b28(xrb
zBVr1!DhI-VB+yYCwd0a9eS7wN`25+ARc<aWF(Z93Ig(xYV{9!WTVw206Ov#mF5YZ9
zfr^0C;fm(moQK3?sHe|9{7LAxk9X6<mJs<DTZp7LjIOZoe<>83C@fkc?~4ZHuSD3V
z6mF*El;LFJ9|(7fyh>lybI*~Z`lAN!8TyQVpMkqwzl-kDb8V)!gxl$@34E3u2gDGh
z2?um*%o>!k35uOx<3vG;2&5u8FPX@#Heb@JjWKqqW14H2IUh=@LcJxSUNbXJ8FN@1
zf>z9k&k!8)e|*qdFp%v0e4?@H=A*Yy_4FZg)Ttlj56O#WEKhAFaJz~eBJXi=UNhbd
z<3&STL-^}o1j4`DLzbeQU-(wr&%%da4d3+PbL3@m{Tt*u{@LmqH#`~sYj^nT@cm!;
zxBi@vKahMfjvRR$*M1Mqa|h0|4l&YN#Zx5fb?Deae}!YH2iaLqFr^1et5lJwZv<b$
zg1(Wd%YaP|6Frw_N*!D_XV-X5W}}&kg2;<hw8q=wsTilV%qMmZ1G8+H5AmX7esmpV
zXJ_YZ$Tz!P4pe<s%DXf2T}8t!g#|Rz>-O}Jp`_y8|M=&z@SEYY;UoLW&=q@s^+vEG
z{8E!}f2^=Fd}jpy7!EwT#XFoNy!v}GWJEU3@c~o`5p`6}%5aJ2v>Kf(3KEZk9i)1m
z*Kzeg<$9egXbf5oWS#H?c>=UVTVaqJbw2%qUtW>3byeqk`#4b@EL-}04_M4GRveng
z6rnkG9pEZM6KHp6BJIBPoN(-}a6xD2*j<eKe~{kXJ=il1%uup<>8f67Sg$m=wnXfv
ztPx3tPHxorwEcU-q`kT*Q14W!QmF6254+*%p??l_(Mh4MyVV}t70Si-AI44$#rBz&
zw;?>EoQztYVFucWihjYf(Sb*?i8{R{3@^mzn>`Qj*uhp)-ze5$Edt~!4)mbZ3o^rc
ze^lTrB-)6Ia>3cl1Y|3kY00WktRkdQ&pos-RD`v?c_;P>_prs!ur@uZQ<mq+c{*z3
z7RtzZ4uPJQPwJ>fdqSYElHbsiJa?2Fp$7$SKY5bw5x8CSKK>qo+a%mB?;_l4+Aeeu
zu9+?n))20m&JdajH(V&v)etU=j3gr|f5$lq;WaWL@;)7*u6;5uxPp<NE2EJ|T<8uG
zX2_CNmL*=+Xl8J{mE(9O_-5#|R-H~uP=C(=f}8IM3<RRrB3>0iK8HHoeE<YP5h%D6
zGd|L25kiPalQ<-;I7UaZa1%QPWSWYYDix((3Jy2xAovV@!XlJ#-WgH@6&acHe^Gz4
zAA;Vhvj}_{7dq6bk0F`OC<+nKTpi(70ZK&FNwe!_N5zL4E=4V~G(SFHL-ON290NeD
zzje|Xbh7j9yE;SPWrY5@T{w2p#~=QF44-_lmruWl2N2YCB;Yh5x2{zxi{uI1c$v%M
zGUXA7+Bu_45yoIBbCN92h~hCue-=r@NP$F<cmdtI1PfrnMzKPtK^da$<FTkJjSk9z
z98z3TjPR0i%jOtT1EyP-E=4L3Gcq7CA8>JJ?s8umj(vTAUx0n}U)+bl4VI%!Uym|f
zj}~5w;ut4e*N7U!8sMC*T*Ux$tHzhyN9I0Ah*C?HR>Me=JtNU;%+Psle}Z#9iI>dt
zA&ForPLC-EZ=DYo8G{6Bm`_Yv4A@4P8nDC$;sPd$F)Xm8J7Q9LSUQtm>0B$BNL~z=
zgkK0B36FlA%>Di2;SY9`MFgHAp2r^#zbo{H$A*t$_GogPjQ$<D;q}h_;g7n)--qwp
zi%y|mlBE4?eBFp5eK-$se`v?vp$saJO?rdQtT!bPBk1c*rZ^)?jyT*)HtBgooUK)?
zNHR3W`4WF9t{It2eoAVfPV!QxENLVv#%JKPp%8L-Em~VUaZ(JdlDQr1LP9%<si*9m
z><#hmVU84nz+DpE2sGo(j$xxoVZjjM=_VPM{5L)N;2rbBUpDX9e{tcyt&=BjyjM78
zPyO}XJC3=Xq3J?iSkD!$y{=+y0YjiTJ{0F@!6(5RN|jM-G$d)03_02y!zk@2gPbQ@
z;*17#+8S{EMVF%9s58ZD4P2ZhiI^d--eLirNj4)Lv<4lREpfcj<Y*Oti_m$1qSI9j
zFgBWe$yXEPJj!uge^OB;h9JIAu3uSZ2sx;1DvrrkCz2_RCdyu0j6?}utH#kz5-A3D
zDZU+?LQ+2xA#>FA5ecCkF1xGA^c>0fX6DA-OV1pk=0l-#(|7C$?btSH@-6oX$E+zY
zcdj~AM?%x-(@3q{u%3=UYOOB7RhbldpIgNcGD%n3(7+~qfA*95y&l16Gun-g)!Git
zHm#`DYV{+vHG01xkQzvnN<E7PzLw36)Q<GL<l$a*yykp4m3uDx1bJQ09VSN|&pEkY
z(0z_4v$-<5lkQC8hRAC)`wdiM(D`&f*HK;Cf;8ev<Ls>t;t0|-MVGiHo`YYKV}z<W
zD2-c_rEw6jfB#l${V?Mn88o9}Q0}0TL3BW?%a~_WjGQq@Rx7$(D8UK$<vbZh5~yA4
z&N7%(S9O-bBPa=-uN$TYC<yAz`S{C6vjQpa@@6I_n=HI&_6iwEmI3X+XG-lP*_7B$
zL@&p-Nn^n2GIT<zS63Hbgm9WMW~P^Y3ky`R?U0a9f72M&cG#m_j9@$I##^7MxTSPh
z+2P>eiM3D6Z93SvYFc|)_0p`u0lzqQ=hx5P_8zfReqGi!regfujxD2`RyRC6YhlN%
zpOr73lvh)jymH$IEsuV&9p}i6dVT_Ov;^Z77mvW00)i<#^dYHQL4#U>`$%XMKSEE(
zlShcHf6u54o$oW%`_v}d>rs4B$iM}fb6jRPxKqg6zWw{Rgghpt$03HR!L~$LrDQFn
zL_o8ca5H$piiQ+Lr9@_ch&l^JF?#c`6Rk3l87AitgY$^Vg%{AWodSe9dRnnQmL(x9
z_o%SEE{e<1*ePLl?vIc-3>lhNr)n1B8TTmpe}tTSG_>A@5_&toG>R4)@NC*d?4O?G
zD^)s9qtob<xCC8-euOweDw0R&%VnQ_rtH@*lsC(_>+j?5lke9*!SB=T(;w!8nxOt9
zIV~oG)=Ev<8d@V<uRSbC>rug?=Dwjv(8w%SuBCdN3ylzYh9Fu6LDUF5KSQgrYPA|p
zf2-5Q^pl<vq=p`;p+`)pM?+u4*%4@vdVAQ(oFL6m%o2lP3^wZYs{WQ#{VkG*uwXi9
z@uHX}B<rw(3S4&p(IPtY1CUrf(R3-X>c7$C%woSHVSc2+WBMFb%g{W8{!!AR-X<P2
za~kd=Ib?4N`2`ueGhCA#zAiitO`D4!e=vp3r=vowzW4+#uSIA>zl#>V2~y!#%Fq-%
zu9l?e%>!lQ00c8YOlH4cB3hG};1_jZ!lweQB^7R4v&QFYSaBJ<p{dJM#@Q0o8jK&g
zI8*VB%;sW}FxldibPjKPhEuZDfJKLaT~4S0tJYl8rzX(I1>f}5iYX=45SJ2Xe{K>|
z4Fj4;oROG{bD%HRl9<d3Ng2s}LKB}TU_Q@9^RWOidkUE$421=NHnO8oNQ*<AlY#~_
zThm_t-46fzw|o*lLMlGJ?GIDKHSH(cSG=-p`5P@4c;({p=N2s{lg@okCN5icYSHqy
z+LoVbZ#%i}g)q~qd+-#51?4ECf6`GUH%T$;Qxq{FN+qNWI`WWCI<yNYH^3;E0LfF~
zHr0a9wRTf~8nO9giWPr9rcitaDpDj4VPqnVI4YTbNTGf-5Eu>6`*fKGSCf!uB!nv@
zM0jLoA`NU-KpB>4%ji?XDy8guw)o$><r6YKeCX3n?@l9oR01ts{$|Ssf1x+@i^Yq=
zUH|wZ+#RD&+nM(ED18VtBNsi7T$BiRD$WxLM5h?-BPk2AWHf`(rA1^^uUU##>o@5%
zMg-NU3bK@V&hJ3l;ZcZ+WU)Ekm(<XYT9?gX#C9m=F+}?~Y80F8yvF90y}Vtl0gV|0
z!OGPT$)c^fBHK~KGkX{re<I2RQF9o%!;+pqEQRpTw{%{3C46D^+Z)f_-!d_LVP7~L
ze)<t&e|quhtz3QCu?QSqd8X}{uYCiV@cF~Uc>mZN7%wcrvA!4Mg+t2Vt5*zLB~;7S
z3~Jl|cD4K)KKNf>DQ5D6mGa)dT`5BE_sRWM3SAuf=MUCO6Vm55f5;0CaKS}oW;SH=
zG?7mf9TF$g1O&%ix#2VWcl0}sKNR<O`Z@Oxo`09V%l(n(*rAitHm-*|Vmk%g1NJ>}
zPusaW61FDojN?`%+-|r%j>|<O)Z}zQkj_^|m^&jbqA|LN>~bY5Fd1hDmuMb(>`>Xs
zR==Q2W;5Y3lWu3Tf2ktP+${Ut{aLIJNg%{$21FhDk}zHx`WPixjMrQPQZ4bKE+s?j
zjTdo64$!%3Ak}4&tQcvMYmm#>>SOr+3Yb7sWGQjPQI8ARt!OxNSUB8KK@>lPGVh$k
z=dHNr{$H&Me;fYY&A-5-7WTa>=%pe2XHQRi=x0juqQIO-f0s|sA<d(gZS|4558iz2
zjkoXp@K;}7(?B{~Z=1TXawlrvNyv`1xR>C79ZFS#Y&K~uhB%|vV$d12l3q4xB-C19
z*J_NNCXw?S?Zi$D+BmaCl69iqpt;eA-c1S>3Hn;YOC}Y1O*ZmIpYzcpq$LV7&~MDl
zpt>s6q(sS8e}|-Ev@z!!@uRLr6K@kTtX|$Gtp_olTaS82wRUW{^x|+kBI;ZA6y`_q
z6s@f)8aO=euf1EhZ_ioiLs$JBZg)=Ij#ZaNaHm%7Z=a8c#VO1W&*0A>7p38Jo;?DF
z$Z;jfU>%vHWIIxnRL=xCZLk$Yk3Ut)_B*sFTe6iTf1_VA(s=9OGyzaW4bwO4Zp>^>
z@(sPLreZ!>CW6t)h9fEA;;v|^g7ksT6qAJ$c~0P{XwFE;$jBJrHHq;xWS}#%2GUb7
zuyDp2$V$wv0dKNL)n1n^ylm#DRVA=xNS@1`>mB0uGzodG!A-=S_5%@}GstEiWXo>i
zbL^OHf3rrjk%My38*i1+ahEoPWadYC=33+rPg*(xQYO0Wj*O_dM%OR1q4=_GSw-P<
z$F_dBb=3W%Pu#Wr<>`}p*Y6B}*SV8ucC2}OZg}3x*V@h<`}OCGPx8v8hyHfM&c`Ng
zTEDny(PIZj%wKfxrTgw9!u^eHQ<uNGqUW<ue_vSpYjm>^JRb-A6qIvLct$B1#gQ~c
zFsI1W?$9~3PTV~83zF8UMQo%+IB4e`PF?LW?VH*UwVbvh(NP<49(TUw<ea{QwNaFS
zussUi`!Ef&<Ik4#fdzyLh!m`%Ny>;b7!6c3iTWC1kX3|0a?tUoQr2#<p|8ajZ=<4(
ze?yR9;q6U`PNU?*34o>OfMPlh%}s>B1(_;#M^Cxg^WfI&Ut786g_^C##5-DUKJBt@
zMXmPp)|Pd@{V?<vm7XtIyky_H$?t}jGXASU5{$vMrNiCg&MpD>T81mxxDOzpIungr
zgFen^R`)yJ;;6uN$JHJ;zGb9>v0LLae?1ygV&}*C6*OlE7@1weePldmqy$AnbzLZ$
z#kS2{Tpq`L#GS)2s98~$4$2=~Y$fCT-H+f@)Kw$#Fg;sjY4ox6+b!YH-SK)}X=z?=
zX{lq|HWAcRZeD2^F%6r?T{w>>oJTDjSN!ivM1w#c-A&_G(A)6**<ShwK|o(Ue`yc}
zG92Am%nCr{H%s6V8l&4$o)rbj=*gEfq81GU5CkpyvH%T7qz09F^k4;PZa3d8VWh-~
z6?&JRXlk`S-P$8D@Wbpjwi&|a9xb<Gwtbq*re3}B^U;qZFsD6_o+_5$(3F;$$DWDh
zdcc6-g;Pt=F@^3O&#rCcUvGq-f1;~ShW@lo=)JU;912|sy+ZyT#?1rRj02CyF>}B$
z2A%@w^IX=V=W<I7wf6U1M*WtXw<1e?j|X5?s)^sC{22&mlnJ6N8W*|S<Tg#4@mBd(
z&8<d_TM<3D8Zxu8QU=8HmVr*c!Qeq42%=@6)@-%Jr)rbA0VznIOg?L1e-5&Wr8YiD
z^STGrreJh9t9GC-JGL_V?eRv}Mild_WU4w_Y*MMl;9_)*SQ3(S`oxR`eR2)xv`IQ=
z4TpzOnGT9cA8Wdo6EZS*ua`sllP+XlSs|<pGZbvNPsG-Uqu)|tD+K{FTQ!%HySDhM
zZfKu$XN|l3%<84jOy53ifA#bQPfpx2bj|cRPfppwE6+FO;hs;!`c2DTdoA=Vo%+j-
zlUJSk3^&yWzr5}G_LHxL@eo8zmLN5qa41OIm9dH1-y5$86r+eD1!V~nDIjX}TKxOa
z|D{Ahfx=8rGU76|{+}fZsUyBpq*y;nT_seezqSg6$`(^XM^vcrf67ZJQ_lS9icFdE
zPE@8aWb}Kaf&pT_$2dPoHov4xXy(!P*sS#>Uky&wO$1dgqVLg>5$~lLdaqqfK;r=A
zBKjUNWi(*QDKNWAgFzw}S3^uX3>YL)1D4o8hOrZki27AP;z*-c3?oV(xwvO%_@xWq
zhhN&c=hCy^FMF}Af9=I(7x~&ld;i)Seu`Y*`<K0k?+AwvuXwGc<+T-uamybi<ip`*
zf(}Q+Y@#E|kQBwKOF|VfP^Q*6BZzD=oqnCpg!^Dt=3+~3mMh%GTGPKZiI_I-Z!{*P
zirU1C6mNnSQC6ymL6XLa08IJ`qtO!2@$pf8V7<caecIUOf6yE3UYo($#5?quZ-~3B
zjbjtrXAz<6n0b1lYL_Y3hqp|7chje&B7EeNTi)|;p?QZcw7j`|=_@PRQJ0=twk+KJ
z`MGe{;zgmu!o2Vc>rS?{pIP4a)^eoJ4dG?{J2CqF$WCDN(Mzhe5cfZ_6MjgX|1FE!
z%#g>wwW#0uf46o5uY5m@`u?3sP4HYU&}~Q^Gb~oT2rabKXp$v7$)!cUF>7&ym{22c
zGD{WlrdqSl(s1Uo8I9XSC?IjS1GlwG&=DAuj8S-?i{sF*t&hW9L{8g;3~Ic>4hRoo
z)9qkpAv&WIh-cw;<<6>W#`*@Ol;4t;xSdxXsjtgee-XcYbzS&x;ZBrY!y~=)IQG;F
z-zoLG<=ut@ngjY1niG04$5o&&aowul;(8=ymwUJNRjSc&38eDxR`Rs#UF#>nIf&Cn
zkI<9$caphXsSmpLQ*QNu)vljYE=x{9++?+Bv^vgV#6$79coaHFhbmgmpCPe>3Dm}J
zJr2KFe~0)GZcJ>BtH_FEp}mtuWU={p8cFN6`Z6Ex0~>X!38U)Sn0vGrPaE{ssl;M{
zT@@tBo^)q|(ZmaUy0{*kro{C`@E~SSFgn&pO=kvT*?#g;^oXMFCG6CJN-moftr+}9
z&);M+Un%0xK36HK6MC$sby4Y@tgQ79jwpJ5e_Q=iBm9e2O<$3jdB={z!Y4QE<WAQu
zsVOeZ8#;DM<#n@fJ34j3{MCzn#koVuudAq-y>2(t6f==8HVD5%+|{TI(}ASr@K^xD
zC!z-TWD$SpC~lX@BI<Nar&g4-GE)`;o+)5whwu#5_HMCOI*Na#)R0v@`bS@9=LOD3
ze|@E2GRBFqjbmigez|=11?>}J-}a|JZ98^M_+5B$)EZ$u>OiSImRHcqTA`%n%LY71
zCHdoZaUdd2)#FyCLtksGNT9V2pR*5I^ley0@r?>}8PHK@z{}aqUad}}qcKCnmLXdZ
z>WWr8j;}LGHNe?1hzf7E;f<)rihgHyf6!xiAx<Qo{b0sHVaGOW%9HKwkEhzUH^2SJ
zBfoFvl`wy_e16-~+LG7ErO;=8?%lBAlTX<g3K0Vq;uu7@P00(2uL!3^^y4w#@2q~l
z-&y^9zoMu`s>(=H+(#XVkkQvIe1*PWA38G!GH0e_ei&)n-<hd;fBWDok~!)Ff3Et$
zaSY}Jj=3s{r|@2~m^AMU$0eX)@+s$xB388C#fPxB%nLjvLpzd=6iT%-w5#at^b|cM
zXokxp_0_tS@+$pp{Oy`M^zu&re$D;*eR5EDQa-IYt(P+??mY^b@<6?ipiR)N!heit
zwM1SP^#pH?d4jiG@dU>}F7pJ>f4brco)z7xWS-zzKj{fBL{G35J;8;{6D<D76Fd+^
znvb5~0`vsq<`t%qcx)&4p*N$_>}vn-mp|Oe{Xg*ksz4c6EnMvd)^y^3Z0Zv5Pd3x;
z4re8W_l6%&L{fjo+1YjRIH$Yx4UotM+=KWKDXxQnQgK*ER_ZqEf&ynWf21064ct#H
zLp)!EG?CCdE^&A|ZI+fp_c_O`17;=gfc(R(g5goCVEAFN0*yL61<4*kw+5qwTA%)*
zKKtN2nl}d?H5@mf6;$14EU<NR`4q#|TiLP2%l2&8PBq#D%q(#2BQ6ZWTgl`5!#&~P
z6XZc$6HCaB(8bWp<aD@*e~x0SArm$8P#moUJ<9l%6n)4%Zr@w^bS|B5!hh;ecD4%l
zKqLw6q`py#T;Ez@gQU240S~RjNfgu_njjh2!;XdpX;BYadGr{byvEHITsk7boj5YE
z8@F$c(n+K>wts`h5FUvO)kV*fqI6J48?%Zw3%G2UJ;XNdW!$-Ef94Q7sn<8Z#1o%+
z4_QGL-5XkY&l#N2qg?s-!^lTy@w^x5mAt^tRXV@}<x0GBT}lcbt`ylBy$oE?NxR)a
zGOnB3jeqwZcaWXaOMm<b{+TVtlHZ2Djao){6p0xh_`CYprMsW?*+0!g>;PHl_E<u=
zW0=o33~w$U(Cj-mf7TZxWm33f<ZabH%~KKy;4z5@6(Pb-a}zv5CSF=E`E+-xhhcHU
zMBQXKpQyT^kQ@%&D@FU4odsP!(VHk$AM^;lgRYxV8b15<h8=9KFJbLnYVE_6B(-*k
z2oEZF<Up-ny0l*O>F)i4jh*esF#V7i>Scy0>PwP|C+a+Se>l=Al37*WMA3iH!yRMw
zlX$g$hJ)2lWE8B7rhX7IF5qx3^y;Z|GyYrBit{o6{aWdWD559F2lYEK&Q4z!!ASg9
zVJZG&tsKU~1pJ>}1^$QWI`#i+lkvY=Q}KU*)8Tsj=iN;FKU+2WDrP|~JcVcE4`XWt
z+aPK$L~IMnJEu%7A77R;uJLDW?aNk=Z)t04o(J%sgN2A93T19&b98cLVQmU!Ze(v_
zY6>zoATS_rVrmL8F*r0ampZrsJ_bxjQ&&+|mwvbbAeZ{v0X&!5xB+UH7P$csmr}U_
zDFO;GmoEhZ7ni&R0xg&21p*P5Y`Fmnm)yAlGnZYu0Xdgo-2qOQmbw8Emj&JdECx(R
zQ&&+|m)W`jxdu2OFd$M2m-F5MF9b0)IX00lBA4yE0Th3<O@Jh1BMAwCG?4_tCIUhN
z1W^J8B!CMjAQI$-B?N;5CI%QMG7bu&FM|#?-~?n*5FJ2>3*aClE-;bja{v`O#dqp<
z!XPvA|NFk%eQquHcGWqj&RW%vKRRz3F_CHl#6Pv_fw@G#%<BoEv!>2}JU-M`pCm-c
zm_GNRs!)Gh+m7wHhh{C99%@@F35n@bIqiXpP@4p?%&x?aP@DF_@~+CN$8j8fnLfnZ
z;aPL0c0RZA&goSTJlQ!vIg9Q1*$-4r;|~Z)xeISS=FWNSalJ{BH(|MQ?xWK>->0R7
zC~@LYlBg1LS~x~yg=2^V#kVp96G<Wu6PXCaMw)+!gAi%F5=SI_%AX5L($g<p-h00_
z|0;>YU*mP?@yJYGo-BPL`^KscDz&QjVKelQKfvE9RV;=O@x+Z)H^Zb>eI)**>&gfa
zHEEYnO~ZGrFP8>(qv5210N$&KNS%aXJxsql5Fwy;y>8R*R<Z$mEPCC%<L`r|fj(*`
zi?M&tM0|KRk_^0S`gjKYEtOcXN73uD{*I*AMZF*N9zpM+{xSxPLC0bUGPuFudItQm
z2Yy}*KV7Sneq!*`KJnVsGU-|!T&otZUg<7fErY9m@k)32$B(JfKd!@%sqnuHeqiuF
z8F1MN-#0)zqS(%$J#h1c|EBo&!Eotfg>-+Z0WMa+cMQJ$CR+NI!8g(HHG>Ne!&eOc
zwg=9C87ZB=4qryXxd!+vgD)7IJrgdSWpE}OPB*~kpM^`GGx%(cQTi+#K3xo-<Ut!Y
z+VbEOgOeX?(n$s%YjA?WaR$d~?b5Ms@Rtbqh{1;qaCEg#I?CV!21gddVFvFrc#nU<
zp$%r~AcF%8_A_{w!9E;spA+_)p!Lstq*exhey3de^B(wfwfN2+pY%>SyyF-5_+U4K
zT@4VZA1J-eU?&zkufv~kthX4vSphpL;Ext)aln5wc!T*n;B^Mu8NB9zZ49=)YLT{P
zz^fK`Ws6;Ur3Y-W!yjHwk^Zn4UQU03-!s_E;3Wplzl)TbE8ur8+N9q_!izTetp=MI
zY{W@6GT2~-rWblkO$=V>4UIT|V*@lizej3d@I1=a^Lya=YH|HqpR~Rl*89bE41UAl
zIcz_-2iE$a9+^=;5S~S9pLN0-Bh+C>T?MR0rmglttsPb|Sjk`ogXJ}LX*qv`8aw<K
zgJle!u@_3ujDe*Ls-J`<PcN31FnD?~ERKbz7%Z~DLIzJTn9pF|<0fgI73Kvf@t+nS
zH^Jlk#K#=)m|uL9!6OXjGMF=aj5MbKW>@u)W{-iY9x#i+!x=D>!Hf*3ybcfTf$0pU
zF{ofL^}$$aDuV}!O?ogE9$<ekg~9y{CQmR*lPyqQ0h12HL~KlS!UQ9rM3*{YJcDrz
z?u(9;?#qC&48|}R&EVd}Fp9xFP8i8x1Wl1fFc`iEhV_7<C2nbG4wT&OkV@Pzq{uA|
zVK5k5gDapITg7{z$PI(AV^9v<U1*o?cEH^M!S6SSg#)cpp&beX0>OXQK)*#AXoZ0R
zx({3a0+ZyofImR1u~lF)NChS+2vEPjLL9)LKcdk8I^;9x*8}nx<RXJ}E1++Bl+<?^
z<S@uiaZ1??vW7vQv?!_1Fv!FrlR*Z)n86?&AE!q_S`?&WE!7RZ4G~iBJ&=+dCZ#wb
zB_Qx=lWle>ISi6Hx($C~QZJvB#Gn_x*~<q#g*>SzgB}bL8FaUTFQQQL6~SFr@G?lS
zTBQUAp7<2Wvl!x2AZ{4M;>@uOVi<Ho-gaXUjjIwJ2~i9p8Mqm^a0FK|M1-eE5rq)$
zv`OJ9;Iu&)z8B^M2mao{z>bvL3&Dmn*z8~n@y=>7NmeUZL%e^pm^H~_0!xT@X5^h&
z12gjOEzx8E6PK+V(a1nUN;C$B2vBXHFpzO*nSta4K;qy!2-qRy0YwC83J@F60IjH5
zLzDjhxyb+Hq@e2zkfS<mqt9W<<A?xRAuK^J-Sr8O1Ne@hzZalK=_<M#>s!#TA0^Ak
zk5q&AX%5y}@wb1aq6d5H$tL~R_3$m32k(%R<On%~wQp%I;BV<k;-Tkoo>jNz5TF%X
z2k^cKTA`H2(JJyXeFH~aL;`dUSt4L5jK+~a5>H_7M`Q(l){&RV9ISH+mLdLMkhjQc
za)rDgTqF~)zMC9Ed>Fc4ofg_guHi`Ag#N;GeD4sBwt;_apvy=bc}yhe${9H?wFyZ$
z>RU(wArF#GQk(Pw=LeQ;(hv9q11vcpI~6Zd!FjiZzC+W6k>n))ei0c9li(3JLu*8@
z_yk-e^#Xw@WF|Q#waHFWuXstlJe@8Or|6$WINBoN32_SDMlRx*55mvb_8?}PbczXi
zOBgMUltzCd&C{`OlYXxc-DMm32(BaFpA#4zA{Ijd(z8e$PF^6Jaoj}Y3?XwM3um80
z7D;PDAF>TUDbgBfK#uC%pqWB{vPqauS0lF9kehR05Xr$gVx-HYhQ5V(6J;@ZOll(p
ztGx($TahIZ)te;8+gb!)NkxnQ-qQHPWuBDeJDPv-HYL7=jA}72h!5PnIjU5QmdaYB
zZY|(bTSTAt{C|3QJ|%hBsM7cVbrlWj9JXl6AnY7diZkGscjI(L*ca+3X_0*REt%31
zKeaNx)>iAytF=wbOTqXrc^KYCmHv^^XUhWgW=(($irIxxB-}q49~+Y6<BMhtYN1oG
zp(TG~M=uZ7jLGrEh-UHVQg2y&ZG3G>MQwa>eB}cbh__zigK4#8sYt<?(iwOkTk2`?
zmqp*IPAe<pvzz!h_!E4+whTv@**OB1dRJ-(zGO}w7T*HhN0r`N+EP6zy2U@JEZXCV
zFKXF0s<dU_plDB78NOw?g(+gZc!s+ZXDff=Z0Uv1ZJ|++MgHg(QdV2b#~f4Y^|Vyi
z)<)MN9i8m}*>^_=C3klCJ39h|kAa*hLVqv{2gAbaiRK+%kJp2EmJPzW?R;s95K~WC
z3P$6kl4~hKu6TmhAxz>DjAc!zB*#13uVYz?;6qrAa1r4M!d(bq2=fpQA=D%A=j(qE
z__%zWcM%RCEb4@=IxjCHv?Kh0P=&zzRw1+^4l}WALs*8u`zsLmn8Oh`-Yp1c5JsW?
zgmM#1l!#0xV>=$Thi5BYmw*)@VrNsr>_)+QC_^!Hy@aKv*NvS$CM?Z*-J;+1v<quC
zV#hQj3~Npjj`s)z7s8#Fn?#Z*5>0=)kr)z7;t(rBJS2g5$z7OabjMaA=|Os;t|pOW
zl0tf8Pbxwh!vBp|x{g$L#QYSEr?coYbQ9f4zZ7DH;leE86huKWJPHRzSu7T-#c!kv
zX`7raZ<ntqeU)nELseC0sV}SF7%B|E(cIc7txo&I7;9W_{EJC84LAL0t~7uD)zaNE
z+p+=Y5lAI#5G$pZaorRW_l}+i5?o&APO3`F1d*g3Jk_2~Y^T~!wWo#IJ$9eR?x_?>
z@G*!Ee$5&b%g;YPD);0l3ncgESK=Y`3%$@{zUhC^ZWA0<m&t6hxXfl#O0v*9$%XQg
zk=Z9JTT0JyQA!GPOa_@siZy@T>?TQ&prkiC5<I@f*ak<FVkSMPB7?`IiaALhcaLbR
zM+{SYI6Tp+*%sZ~5#HB!w*6r6pzXcOw#)WhyCc`0%kK^sR?<o8dl#-<{^T$Ch<D&a
zS8f{WrDC&ukJVd+^u1z}cu!e^fexTqeNt&=xKmbK-b4%aCXlQ?**Sl`u{%36Bf=Hl
z8@uFiXM|#*c+bqp&KW>+1TSq)><;whp~JSdjU2Ok=4b4i+SM6p@4r59S#iI`MGwr)
z%bqmx@Wx(~lB2ygSlw|Vy`eI`SV?^8AEjSc6%V534_95P7*ad9;SIOz?L^<i5&f1P
zEBXDT#`oPWtBdOfrFDNd$H91cK59xi&*FFEf@#E<G%y<V0#H_fWFr(Kj6;}?Fdtz#
zLIc7Ugq;ZQA$)>hE*~h7ud#9!K`2MxEvE)hEz;7dEQC89E^l`stB)fG#@8%cR@2<L
zetn}n{{rjx&DSjNo6GdTm*?ogb{(%th*#q6c!|Ww@sh|TtXzLb5XuqBNUZck$VDhY
zC_|WmumE8dLKDJPgk1<n5I#pRbG(!;yfPyk;Z8yEW;?R_2y~K;Q!`>G&u?e>=gzbI
z_V4I>UtOT@aap8fx{xH+3a5}fE9VzRKNKa@n3R?t<_Y&q7w@`pRyeg)f0x#v@P19#
z<GZd9Z@E!3-u{0Zic(K&=oHpW*Rxsr_%{p19E<{hxcx?ftQ2W15n@5qH3b#s%E2_6
zNxiV3HF$Zi)b>ji&VL*&Yq4}37tR}+N5M{<CqSgs-DoEb*uV!iT#4gp>8NQ^mM_ze
z=u!*KV=L+W4`_Dq@K&+%Py2UV|C}Q);7Sv54&ou8WE6k;<ER<T1i)NKz^F7z6jmCj
zNh7hUC|gZ;S!}`Jsr>c~T|F-Fnxj)E#3QH$N4N@jAk&^1?zMaEo-E-U>q$TLTzdcg
zBONQGnBd>xqhRLCY!j{6i*wW0Ip4(lkp~LFW#Up9;v5oyM2N=&gkp&l@5Y@i8L9i{
zDsYbS4}E`~_GO1Ti1)KbHlMBMYa)<RI!s&uNA<DwRk^i-U1Nn-lCuZn>>KAe&?{So
z>JVRi$d~OpUo`T9e<1NuB1)p*lSBnU_DPax@PVcxP@e`G@nLWZ8uCqPq%Fuc$)GB-
z9@rVARLzK{#>I_F{)J$B7t>VTbSP*+LPn&krhb24maszsO3VFG8nI#|T2DmWBNIe0
zi3UYhm(x{(T29I-cyuB0fLEw&qubaYuhJtYW_MhjbwcuXi15bsBwE8TFs5WR+SYWm
zt&ya+KPvJ~vLm7q%x{`@*cuHD&=eJxVIt{rT9hr=p26+)g)8k>+HIGwT~70%6^kc!
z8}Wa1*)PFvb8yQgrjOV>k)3A;XaS9xxOv3TZQ~9dJb0*dYe`nmp0t6^rL$>M&z{Hn
z``K~!5&H`}?(dIlL&-(tZ7K5BK)AT-wutKsMn|~X%5juu73DdkZ~wYlcJD=)(=kby
z*0J%Z)V7Vy-PWPIe2R)sL>b355}!Xz6B>WXN>yx>C7J`V3du2;P`5IWK3s+Nj4SOK
zX<U=}`e)(&2=r&~)7;<zn#<nDVQ(ziwoP2hWr<=OK*Yf)g(mV4#}`9PlvWFZ8Sy13
zrCfR~TvE^OM$yB)SacU?63>R@SUZap@mByrLNFqA0!lQ&*LI`qch$7c8kbB|BvgMP
z>ZNw?U8ueS6{&R(yVk_6?v{>sXu`GYX_7bi1K6&Aq2q{gj&2(aWK0N0O`iy(@Y`@S
z>Np07(21FHCuW@Q|B4yMhuYDSATnXpDGd3PwRZ$Qm5$%Y5szF?6OY`;K^z1!4`pl;
z%9s)3EU!Pz&}fCm@CIv>n`D@><qUsEmK((@*ePDN%W2dmcoRa><OsX14y#sdXj-wN
zX~T+>KXr6m`zhG*lW>ui&?xo|dz%H=H#Cx#u!XFeK22BB6||aF>+>H%9?Zk_S25~K
z^1ErHjWiloI&7MXfryl0?rSHphD;}y@nAc8Y!rkmJT5`nGP1M!bocr^8Df99Q%piS
zY5k?T-)>sNhSRsMQ-R&Qap?mowd2_OnwoW6zB=>8-#T8!DUs%Sobv?E8HVxWOn+Zg
zdeCGah#>hy5ej9Igo7B~XmB=~R~kjh9$}C{13T$v0WC5^w5L0@SW{Yzj?+Po6b2%l
z@kc&K4#N@rgaQw4CG_B<EP;Q<QdgK4dQ*<8T}NBKMTYS6$l0The!gSGqN(p5rOnr<
z{8Gp9FP?k0ajo#KbIul4Nf*3S-myw*`|HQ+_XuSjm!Da_bQQ`uw-G~e{SwK4`TLtq
zg2m{Ijf+(cf};82;$jOmV{DvA!{2ni;%>ClH_0nvqp!i<)FW0i#zlWCq<eI(CEcmy
zCZzR1at;RDFQ9zmb-Ou1+Ws|&LTjfA+}ddhQK%w-B2aGKZbeIRNG`66H=%oCRxAxI
zRx0ID)m<1>!Ieq7Cf9GNdVc1|``FLH8K)k8?4!!2ZS$U+b^IM_J~ysa+Wb+!{F+Cm
zR(jp(AOETC%aoK)O9p?fS~Pcld}L~C^WpzZMB3LO?fr2bV@OZG%L)#RWDSk(CL3KD
zYmK$13$Y|E_LlUb_27hrp-wm>TslS=$7S)RjFBD3vo~FL)MSlcFmC*l9;@kt+~UG*
zGiPkOyC_fS4=)5wRppWW^7H#ePMQVRf|XytThK2ruipR^U~YeJ@X}?<M9%vMNwQ?n
z45DTL&8P`fFd9+56jed_l2la@e1K;`Ch8-mLQN7t1)02MR82<BpoTUUjObiH4Edg5
z{=u#V;IhR1Pp1#Esk#GKBrH_)<2&32z95t1AWn?aQXy4L(h8tJ?5j->CP+q?vAfU<
zd}1%Dhni&Y8M}X*vT$=UOU#q{sd<Jz#%$AAGL}vdN@2V>PMRoBR7R`g4W-6%(?e>d
zX#va^7Z~Ony|~Es%xKEL;5Ab3q55qnx7Qy!xA*7=81vj11PQ^jV(axJcp}Jmw`y>W
zyy7CXFFna@e=n4lsCbjxs*s&-rOx459ltlG?ygoxliPnx-D0FglTCx-MLB#xFWVI^
zju{xYaGgJR;YyG@H$CV_<w7Y<^T(vcrNyUt(h{0UGi?@{wPxeyh-O!_yE(Es%2M7L
zwsW_am1Fm2>5Gg(eLtF|hxAI;0F+BE3qouEmwvx+)(daYUAy|dS^e6FH~#SxUA}Je
zzKPTKl&*h1)W3VYkom~mX>(8R?m4_;>6VK7-`%`tf6Vd)*?j_uiK9nntmDfskav;R
zQrs;vqFqVzN4asgxXx;*3vaTvMsJKH4#!}(NtUCEW01BCG-uqYq0{Cx<)%@zWqO){
z_+n0ync=`(ic2NNWtq^hvSxX0?edzH9bYAHoc@2ocNdRVH1!Sygw#(?pJ_XF_O$Ti
z=u&os{SW&)J2ZaG8op&k$pOU2hrEv@ss1R_YV$rDSsl4Aq7H0zhE^UxI54X(j>5RL
zD}J!CE0=9o|6KsV6Cln>(KqzBqgjxhp*||!yJ2L>y7Jd|@7X@(g@L(ANwhC@;-_z~
z<ad7u=6!km*!g|~IA0ba9u7pw7UGLUoKbZaXPw$)X{8&%B@$T}Y<C!kaK7**|21Dw
zLqls9@;VVzM}(XH1Q{j-0==6mj$XX<!L$v`y0WHb_3E0Mm2g71`<M1LW5&~dG@ROL
z&Uj}0<n-B7ZD&q*;WGvK5{~#}hN2mMB+GxJ83Da*x8n$@7<<YXU-S4ijHfbKc0*ct
zHbKKZ;j+$+@UB1$mrDr=l{h8%mAdzh(tTAk4oqY>*l8O7!zVwrn4Vi%vt1SHCdgkO
z?wk8I@+y~xQ4{sEzcxO;wPm)xUT8xSkxyZyk3UMXQIon;rgdbaMc%IoVG1!wve|!X
zblOhkA4IE=p)1A(lq1_^jOkH=!jU5}6oVr@koWNXRZKiFbp&0?mIPQEP1^dV>}<OC
zp{e!3R5(#TGQhW&`TDRSqN7tshxijCO|j9525_tni!jv1M$}mWH8j?GpvV4RiIGG$
z4VE1a&k$75gPp5oyKv!PNI7k7n0bF=LVkxlhdFgg4*7xp0$0S&#dKw5!h{t|S3Fz4
za><Io<!^^?8S`NC-OsN~exd5%rAr5AHKYcF++&}9dhFQer`Z=l7VH+ivv>057IpFD
zNi>ftRHb?2COpUKKzT?0MeF=a_PY%hz_Vz%&faR;s8K;CL(K-+SnTAwr>lR3ePvJ`
zO_=oy1h)hW?jGb~7cMTr-QC^Y12?$4dvJG$06{PA?hxGFf_%JNyR}={t@@_s$JCjA
z`aFGl{>*gGdGz?jMl3Yr><6o2uMDYXst90NycR~qldI4^OzZocG*<SEN9Xp8514QG
zRvHJLoOpN+&t7NRr#N<6ErqkxrlBAYDXKH|Ig`Rt08vfD7NRtqmRK);hMuQ5da@e1
z;19>BFo@(fL~4>wBnW?EvXl0(<bO$2gEgO_cgr4t1w(Ha7?}C+p?pN@5=m#F`0P$P
zCgwDlQ{09^|3utRl@H_O_oEF9`@;}be!{1(pR=X0%QS*sO!BGATY?w~N*K_|MX7g?
zibBa^W_)u;w%oZ1Z#a!;PlXnGiMo1TMlCcI<`B9WTjv;ZV-hQIkY|ECd%hu#WtWNN
z>9rS1fWT6Y<$R=yN4YlvzNvis^q?aJTE*cV)?LF?vhi4RTI5YhOTTw(_ux({h8a0F
zR9ulSZuZ_^UXG-JsYabwn`LTCcslP(eTYQ;!dpse-y7b(H^|54$NmW;JIinl4mSGM
ztGUA-9LpUt_B4R#G>_+p1665-W7bBzwb)lD&kTOul0R|wispZtogt7v3n{l2sSA8#
z{<Qx?jxu)R59S(LxsZy4OhZLr#?f{zhZnd&mdvf3TbS6A#E@udjE}r*(7K(qqMzMO
zBf{sTZ(5h~Xs@%=wEG(|U%uQA*^!AZ2dW&J?QbJUnkOWg)J2k(PU-PQMR?N<?8ZW0
z{mQ|=bU$i-RQ;$sSxH(%+Js-$Z&j*QrB*g)CDN#7TM<*@KG%Lsah!jYf80I?nT2>+
zww?jV$q#M)pXI~Q7O1p5K!yX8*v@)m^u%-LbE~;jt<^ub)3gBJ@O6llT>P_+J%lx$
zUW_9;&osyxUJRL-`{|Ugki+c{v9HJ@pS8f%cW>Su!YOz5H}rx1;Q23(!{u#Sxq6kt
zV3x1V;$Cv(3m}QCFbD!%i0enL9{3hl@lWB3o^sQ>oKtj^Zcnmy`hml3jn>EW6}s(v
z+wu!cx<B1e$Fp7wPDj(4<mK#*Nb0+Cb+QWRJZ5pE9RoB-D{V5laQ1h7>1Q@hlXJjU
zjqFn}H3D!xvj%J0YkS>OcWX{t{B{B^+&n(_)!&{l+ua=1Z%^GxWbE?<Di9v8v8}nI
z2en>OFHiW~5ZCVGE^n-gr5AQ%$G?Jfg1MH4_+9~;EYP(g`Gs>e`co!pC1@+90bXvA
z5}8l25o+lh<`h7ydPsr?zP&s}3k}#*y8cgC&bsaOig=u&OQLP!nqqV<7dn^S7U32~
z%B{9Woe#}+tNYTA$EBJd?$s0gCtP%LpzFT)4>BdK3=Lb$gQ4=|Y5VubkHO_^YYv9%
ziny4^^K8)$b?IlAS>?U=t;Z)uS=HFe(Wwf<j`9sQbc!bC!iq7m$d9VShQ?rZ&kq>O
zogI9q2U2-w5`di*%t)17>jfPCwqnoGZPA2v;x;SUKM-TL@oxuNwa6*@su8~T88aj@
zi{yKqbM5yX#=)q!T6sXm^*YG0?bvX-mRc5*#`Zj;=V2EgcjZXzec289uut2DZJf%N
z6H2!>{k76kF_@y_x-rAYMozF@SA5J!Zo7b856eu;*y`eCs3ThjujhL0HKfVWouOm!
zZo!>h;C8c(Q9Ow5*5#k86o}2#_70CrrDXme*;O#AsCdyIKxD#XfewNxhpr{+M4erb
z^cwmH;_N>%r&YR#+9XS_^gc;EEN4A|u$;iICqY;*Kxa0#gmDrVtT8yt@-^F{-mz;`
z6n2#ka}qr0LH`}X?3DYDi2yea?^R+ShEl<g*Tc?j;Q?FAGXZ7Hn@?dL+*)VN7dr~D
zs#sLrGzhy`r|o|BVAYdC(FPA@?;G#Pl!2Z*g0WC!y=}z4{;#L6<P>cTV?S~ydI*uG
zSV`qrpV&l&DLpZQ9xlO@!>-yGjc)=}iY*MQ+gJJDc@jz#?)unDChZQ;$_H4g+3>#_
z6Ncrp2xGZmUXsuRTQCmen)is{FDoA~-6nd|>v1e4eld}5b*hRl-OC7{#Sp1=EV0bg
zvck1zV3Yl9_RGaFn0*E?#-*=8%U8;8>M@&YG)E4bT_7susFev$rlgdF34~JW1b+Q8
zV}`_5AY~g@^8qJRx-V#2c^P9Y>f7;fEA2$98?nXf=^hNv(rq%Qdjly<&POC3EyKAe
zGea+Ufo&l@G;zIoQf9}9HGvNl|Ew;!_?27;V>ntP>G%sqJ==&m<FWH5Pw9xEwpu%o
z*&}m^7UYFnGr7!z12I(h6rqVbT*MGRvz~=w*cBFb?E!}U^PJgnj8RRwvvNm^k+JaZ
zQLr?T7q0sFmp?dW7LiB6bw^~A?Dh)w580rhHf#+{RRQr0ocRm*Ec3Vuf44{f<CB7o
zAo79JJC&a#uMy+)PN`r{DE&p$ETw-`6hezD!@FJEevuOe2Byr3c^EdQF`AW+7_od_
z?iuYfDp5vTWc>5K7qL9;+=NR-JgkrwWtZn`vFt+4s=n?1v+_8Pe4K|^w8@?8L3>x8
zZKtflX&J>dmgSk<q1~x9b8QOO@F@NUNgOtmJ3+h!j(ibUA@189F)v51`)R?g>b)HP
z=ov^bWTqP)Y_a>Z<7EG590jKgKW#Kh6+Exs=JB#qeOJk_YfINs0)!X$_k|v@=oO~2
zUiuAN&|1qEBU0*Ynqq0*?ZcRHT6Wvyto>iSnh5*eB(?0p#VUD6Z>Gn2g~*?)(&}$N
zgB{m=8bj`@JF1zSPoJ34)H^h~p7H2?YpZ;p>rbRc!2T8sbqjK{F~8Yzgubz!|Dq9s
z^hUpNZ#`TjXz3a4$&-sbn3zxipFR=5t#d1V3Y8jEGlKh_SR3PYbf(?@=5Xrc+8?@@
z$$|WtNjEUmG`d{ia+y{A#vjMZ%kA4s8?(km+U_m08quo}pO~GXSneuw?%@-j|0j3$
z(=rL5HMov+K*B20Z{XvqBHC4gEFWpF2^%Vf9P??QVmGM?T!4)iKw@U8mg(1`V3!?#
z)LYq>%7&+@0lY&e#l496qTH%{6xn5q+?wM)1)hBN%;kAq8YS|?$x}S9zYu5kDk`<e
zg@p|*Uhorl{A$4BhO}4$%ML&96oI_d<)9688bE?NZpZ}5Q#L0tFEL~<<uOMw7@e5y
zb=^^tqG&9egU0lxA!KjNYg1A96<t!)Iv_>x12h3D7t6bU-+wv)a;2;ULb1b%%L%E8
zNu|uKKvAZ2eSqd^W?zMxgi4`@gJ%4%dz|Y~jVW00(7<N$4JdplunLoD@ApBH$4^rG
z;@@GQ=rerAuQZ{Qam|@<3{qIBb@K(nALHl7%bPnM?>a~r!$;oY3%6~bi5ZbAK22mN
zi;I7a|HHYQaAW_^am}VE%+p-f9#!NLa~P%g>Ro{|W1i}B9kMP%$^t7)DKuT63&J7o
zw6{dD$LUPlgnWeqKA5C0)OOF*hG&|X60vYZp$!Gs{ZdgPzfuRssW<j`Q&WO`UwGVf
zciV&inrxR;k|BCOH_=>3#=w^!szpYyBW53({PV52Cz_aPOMC1yZ?Sk??S3qFbzXf(
zyzdVGFk|LWu@Rc`r5OAfPwcu#{G@(EXAgZTFKkCg%pY}$Ofb>F3*(n&%zGa-JEF6D
ztyb#Q>Sm{;7R>f=@1-b-Ovc}qCvcSG+n)4azHUc4bj?_0jn6=>eg7j6$CUw@iPE7b
z<re<59bv)dC@@C((<$5oDxZR(=YhN_%~2o&(ZenLQY6Uk>?<>m13H=GD8z5hfz%!0
zK40yO&kjZgHU%7|QOCk8z122yEVYFmNH>}Phj>xmZ_toJ*Zpl1`|MBm7bJJ^C%GG+
zPiImt_3;=CVBw#3gg@-#>Zdxh-MXp)abA|dje&2oy=6(49&Yv2G9w0dUhy1p5vHW~
z686d=BSb~8e5aC~09A34Ywu+?#q^b#?9(p|GZlW({uN-!w$Qol#=P~S%CNH>Wd`mi
zo(%u=)b*lJbRrOn_so;Wed%35XTqFeXC=fvk8Tu#8*O=(e`>c8cNg)k%QxAqz4^j6
zc;=<;`&vw!4|Iup`k$$yn&*Y}_BHLxpKbSU_c0kgM>4%`lRoY<$sg|bifUXG?JNHz
zyWRYpaBl?T)}h&tA7-6Z*&->6*f+J89e($XBowp+%RBp51A>Grrt^A<)#xC#D^pi&
zYIM5Y$rQ~Qs!EImQLA!0W(L=7hqdd&6ECS!rt;2Z=b*Ms4()3B<H~1M`m*1s1V{3m
zG*A4MD9WBO=Ly3vcVvSt0>Ys6P`sm8LBUQ%&t~xX<uCvpx9ac=lK#^9C!^eFCEfns
zR@hYcT;~4CEQ0?yz4wYI^-4C$5QL`O2{pD7iK~yuoQuIfVST;a*0aMw-%vHtSe4RP
zMblVy+*sAGwLo5J-8s)8Pf&(F_2Si*U4%Z}(WWgwjp>p?T+ZX#UUgi?bgW~}&Gr*3
zMGqY73wSZ%J`kk156}-44pYKo&R|O#77jVmTrvV5l!N>LOXiFSbbh5+QnbdV&c$9L
z3H2jA+!;jaiMlv-syd2uvJIu&eG4IBW0gqC;j|mc_)@8AjU*jUcI|AcycErAn!2*5
z6&)RGSuZ&P=dJYg<r=qysV*!t4inyD*I=Kb$7GAV4jVMBwu)q?sp;FacNhIjG_*Bk
zU@`s8!{*VXMqC(56%!2l_$712vb_1h%68t%O_qm>`su<(F<XDVXveFsBFE+f5ILG-
z(*3*f={6MCJ<dGorbdAG$fE;0!L8^TYKx`<`^ph&g^kb<)@dbv{*Pwr%YRls3V_R-
zyvm8Un>Q0Lp{v>}iF_J=!=)-(Yh=LA0Ig6BG&Bcm4Cuc=%|sFy9AK(hcB@R&<mFro
zsrd*D{`$~fY1fCkMwyg#N?nSwrhq(n+n-sM9UmFLjVekSe&a_wr&*YN7aYG`=(oL`
z_l7pF@&bmwW3YxngeP5U4SI_~c>#-$fz{Y$PAkE$O-cQzf=mjl-&F{fYn)0sXKNSF
z&pS^&r#8_gH5((2Q^L)4MGhVXMHCO31mn8e*S*d+($&NFo&*&+wKaL0%e)Jx6lRs}
zXFtOqg_n72t1)Q!bZfY05?FVKpW|5v9oYEcmiNC04QMf@YxilC_rITD4MwpD4jgP|
zOz+yfGHr9^@?t;bzWNlNlSR$OQoK3kwW?(4N?SL_V0YQ0de(g1(KuZqC%B?uqu4$)
zLRGFZ1@@s)t8h`*Rlx-Jv3|VLiRmgo>d$4rYbW4K#+R%6f;PgjAF5lJysY&N=Y9yQ
z<eET*NnQ4i`=w!R_e=MJf3|p74lXJXT)~G6mzDhT(#95n7F`fR0~FoVvhR|PU`YZs
z@QvesOZaSCHi<rcZTFB0V9*%Y2+LIQ?ZudSr4ty#nCx%W-vK|ez#;E-z2-4vcwrub
zA5V)2?-)U}*<;2a8x(8vi5ig;wt0Dy+AQ|q)e1N(_Mo+(@|bNfIav5lp$*K6F!7a`
zUDzt#Qg^l(y5nS8aREBHyg_CN1v7xgbBPN`+}JKr_%P@{NMHlBHa%Vv@1s!f#!%4U
z{X@k7MME$Igr*Lf-W?e1jg3lJq_X*BZ6;tE6EEgzgTOH6y##-QQXQu*su!9WdBes-
z;I|%NLx5b%2H*x4D}0fU8;}r)Qh^EJ8ZG#aT|c5pbZm5A1HaT;p*|W(DFtmqCI7o}
z+TH2r6-Qz)D$s^rEDgFh*RQcA1JD(90`>Fu<GObwky&-E@d@KRq|^V!T8a0OHpfgM
zc5g<?D?Vm-?%D1&^#<k;WGlJj8!3RYC~H_~!-RF=bmIZ$^jhxMGk`2@EOD~OQ7e*-
z6@ePE+bl>rWV#BwX7JVr&v#?4QVOj!RpIWzCa-L)<X46})($Oj^o1+}RhOx%c<s<0
zK!0J|6E7XkI+8kVziVoPXXQJDKX@y>UVxR}6YM)`?+hQPCkGuQCZa`%GIXnB6bx|!
zOM<Y06D)Xc(#Wb%wITYfKo={|{lMobwi8yb_YuXHqw4d6;VY+P@^s-pRd~}r(=XF@
zmN7TACrRQ%#=DMJX1i!}?>-LtD)Lq@=60OwY1QJ}6wQWk05uKn>#ep>S(6z<o^fMo
zKnQhHq%LZeHdL9r0WrZ+OsyVzKyl9rNT<s{TnOCw`-JF@_}%0EyU!qh(9k2}pYe1N
zeA7vbbfjZjsJUqjEz}dR%)J7q&*<rDh&3(AK!hje`8L_BxX$_YOg!qsN6Ru5syS&+
zsSH3&j#S6=h!Tm}b~i8mj^>q3t74~+9*uph$Q8>YQ4n3q7wlo1-H_pkVaMG_E9Hn;
zk}|Mvy0SOooy4!Z+93JouG6}%tNm^so<sN9ptKESevh~{am$~vvSw^1%6Kv~g#=6Z
zZd3&19Z+j=@-dT@-_vNiL^U^?q)sY$(|hJ8&A+oR*>3WZcytDJ3@6v!cRvQ%0DYq7
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

diff --git a/docs/source/api-index.rst b/docs/source/api-index.rst
index 04e64c7c50..76e1689b89 100644
--- a/docs/source/api-index.rst
+++ b/docs/source/api-index.rst
@@ -12,6 +12,8 @@ This section describes the APIs that are available for the development of CorDap
    api-vault-query
    api-transactions
    api-flows
+   api-service-hub
+   api-rpc
    api-core-types
 
 Before reading this page, you should be familiar with the :doc:`key concepts of Corda <key-concepts>`.
diff --git a/docs/source/api-rpc.rst b/docs/source/api-rpc.rst
index 8c7d79d9a5..442c675a36 100644
--- a/docs/source/api-rpc.rst
+++ b/docs/source/api-rpc.rst
@@ -9,9 +9,7 @@ The key RPC operations exposed by the node are:
     * Extract states from the node's vault based on a query criteria
 * ``CordaRPCOps.vaultTrackBy``
     * As above, but also returns an observable of future states matching the query
-* ``CordaRPCOps.verifiedTransactions``
-    * Extract all transactions from the node's local storage, as well as an observable of all future transactions
-* ``CordaRPCOps.networkMapUpdates``
+* ``CordaRPCOps.networkMapFeed``
     * A list of network nodes, and an observable of changes to the network map
 * ``CordaRPCOps.registeredFlows``
     * See a list of registered flows on the node
@@ -19,10 +17,10 @@ The key RPC operations exposed by the node are:
     * Start one of the node's registered flows
 * ``CordaRPCOps.startTrackedFlowDynamic``
     * As above, but also returns a progress handle for the flow
-* ``CordaRPCOps.nodeIdentity``
-    * Returns the node's identity
+* ``CordaRPCOps.nodeInfo``
+    * Returns information about the node
 * ``CordaRPCOps.currentNodeTime``
-    * Returns the node's current time
+    * Returns the current time according to the node's clock
 * ``CordaRPCOps.partyFromKey/CordaRPCOps.wellKnownPartyFromX500Name``
     * Retrieves a party on the network based on a public key or X500 name
 * ``CordaRPCOps.uploadAttachment``/``CordaRPCOps.openAttachment``/``CordaRPCOps.attachmentExists``
diff --git a/docs/source/api-service-hub.rst b/docs/source/api-service-hub.rst
index e6804f8cca..edd4874c40 100644
--- a/docs/source/api-service-hub.rst
+++ b/docs/source/api-service-hub.rst
@@ -24,7 +24,5 @@ Additional, ``ServiceHub`` exposes the following properties:
 
 * ``ServiceHub.loadState`` and ``ServiceHub.toStateAndRef`` to resolve a ``StateRef`` into a ``TransactionState`` or
   a ``StateAndRef``
-* ``ServiceHub.toSignedTransaction`` to sign a ``TransactionBuilder`` and convert it into a ``SignedTransaction``
-* ``ServiceHub.createSignature`` and ``ServiceHub.addSignature`` to create and add signatures to a ``SignedTransaction``
-
-Finally, ``ServiceHub`` exposes notary identity key via ``ServiceHub.notaryIdentityKey``.
\ No newline at end of file
+* ``ServiceHub.signInitialTransaction`` to sign a ``TransactionBuilder`` and convert it into a ``SignedTransaction``
+* ``ServiceHub.createSignature`` and ``ServiceHub.addSignature`` to create and add signatures to a ``SignedTransaction``
\ No newline at end of file
diff --git a/docs/source/contract-upgrade.rst b/docs/source/contract-upgrade.rst
index a00b6b0870..13322bdc4e 100644
--- a/docs/source/contract-upgrade.rst
+++ b/docs/source/contract-upgrade.rst
@@ -7,95 +7,93 @@
 Upgrading contracts
 ===================
 
-While every care is taken in development of contract code, 
-inevitably upgrades will be required to fix bugs (in either design or implementation). 
-Upgrades can involve a substitution of one version of the contract code for another or changing 
-to a different contract that understands how to migrate the existing state objects. State objects 
-refer to the contract code (by hash) they are intended for, and even where state objects can be used 
-with different contract versions, changing this value requires issuing a new state object.
+While every care is taken in development of contract code, inevitably upgrades will be required to fix bugs (in either
+design or implementation). Upgrades can involve a substitution of one version of the contract code for another or
+changing to a different contract that understands how to migrate the existing state objects. When state objects are
+added as outputs to transactions, they are linked to the contract code they are intended for via the
+``StateAndContract`` type. Changing a state's contract only requires substituting one ``ContractClassName`` for another.
 
 Workflow
 --------
-
 Here's the workflow for contract upgrades:
 
-1. Two banks, A and B negotiate a trade, off-platform
+1. Banks A and B negotiate a trade, off-platform
 
-2. Banks A and B execute a protocol to construct a state object representing the trade, using contract X, and include it in a transaction (which is then signed and sent to the consensus service).
+2. Banks A and B execute a flow to construct a state object representing the trade, using contract X, and include it in
+   a transaction (which is then signed and sent to the consensus service)
 
-3. Time passes.
+3. Time passes
 
-4. The developer of contract X discovers a bug in the contract code, and releases a new version, contract Y. The developer will then notify all existing users (e.g. via a mailing list or CorDapp store) to stop their nodes from issuing further states with contract X.
+4. The developer of contract X discovers a bug in the contract code, and releases a new version, contract Y. The
+   developer will then notify all existing users (e.g. via a mailing list or CorDapp store) to stop their nodes from
+   issuing further states with contract X
 
-5. Banks A and B review the new contract via standard change control processes and identify the contract states they agree to upgrade (they may decide not to upgrade some contract states as these might be needed for some other obligation contract).
+5. Banks A and B review the new contract via standard change control processes and identify the contract states they
+   agree to upgrade (they may decide not to upgrade some contract states as these might be needed for some other
+   obligation contract)
 
-6. Banks A and B instruct their Corda nodes (via RPC) to be willing to upgrade state objects of contract X, to state objects for contract Y using agreed upgrade path.
+6. Banks A and B instruct their Corda nodes (via RPC) to be willing to upgrade state objects with contract X to state
+   objects with contract Y using the agreed upgrade path
 
-7. One of the parties initiates (``Initiator``) an upgrade of state objects referring to contract X, to a new state object referring to contract Y.
+7. One of the parties (the ``Initiator``) initiates a flow to replace state objects referring to contract X with new
+   state objects referring to contract Y
 
-8. A proposed transaction ``Proposal``, taking in the old state and outputting the reissued version, is created and signed with the node's private key.
+8. A proposed transaction (the ``Proposal``), with the old states as input and the reissued states as outputs, is
+   created and signed with the node's private key
 
-9. The ``Initiator`` node sends the proposed transaction, along with details of the new contract upgrade path its proposing, to all participants of the state object.
+9. The ``Initiator`` node sends the proposed transaction, along with details of the new contract upgrade path that it
+   is proposing, to all participants of the state object
 
-10. Each counterparty ``Acceptor`` verifies the proposal, signs or rejects the state reissuance accordingly, and sends a signature or rejection notification back to the initiating node.
+10. Each counterparty (the ``Acceptor``s) verifies the proposal, signs or rejects the state reissuance accordingly, and
+    sends a signature or rejection notification back to the initiating node
 
-11. If signatures are received from all parties, the initiating node assembles the complete signed transaction and sends it to the consensus service.
+11. If signatures are received from all parties, the ``Initiator`` assembles the complete signed transaction and sends
+    it to the notary
 
+Authorising an upgrade
+----------------------
+Each of the participants in the state for which the contract is being upgraded will have to instruct their node that
+they agree to the upgrade before the upgrade can take place. The ``ContractUpgradeFlow`` is used to manage the
+authorisation process. Each node administrator can use RPC to trigger either an ``Authorise`` or a ``Deauthorise`` flow
+for the state in question.
 
-Authorising upgrade
--------------------
+.. literalinclude:: ../../core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt
+    :language: kotlin
+    :start-after: DOCSTART 1
+    :end-before: DOCEND 1
+    :dedent: 4
 
-Each of the participants in the upgrading contract will have to instruct their node that they are willing to upgrade the state object before the upgrade.
-The ``ContractUpgradeFlow`` is used to manage the authorisation records. The administrator can use RPC to trigger either an ``Authorise`` or  ``Deauthorise`` flow.
-
-.. container:: codeset
-
-   .. sourcecode:: kotlin
-
-    /**
-     * Authorise a contract state upgrade.
-     * This will store the upgrade authorisation in persistent store, and will be queried by [ContractUpgradeFlow.Acceptor] during contract upgrade process.
-     * Invoking this flow indicates the node is willing to upgrade the [StateAndRef] using the [UpgradedContract] class.
-     * This method will NOT initiate the upgrade process. To start the upgrade process, see [Initiator].
-     */
-    @StartableByRPC
-    class Authorise(
-            val stateAndRef: StateAndRef<*>,
-            private val upgradedContractClass: Class<out UpgradedContract<*, *>>
-        ) : FlowLogic<Void?>()
-
-    /**
-     * Deauthorise a contract state upgrade.
-     * This will remove the upgrade authorisation from persistent store (and prevent any further upgrade)
-     */
-    @StartableByRPC
-    class Deauthorise(
-            val stateRef: StateRef
-    ) : FlowLogic< Void?>()
+.. literalinclude:: ../../core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt
+    :language: kotlin
+    :start-after: DOCSTART 2
+    :end-before: DOCEND 2
+    :dedent: 4
 
 Proposing an upgrade
 --------------------
+After all parties have authorised the contract upgrade for the state, one of the contract participants can initiate the
+upgrade process by triggering the ``ContractUpgradeFlow.Initiate`` flow. ``Initiate`` creates a transaction including
+the old state and the updated state, and sends it to each of the participants. Each participant will verify the
+transaction, create a signature over it, and send the signature back to the initiator. Once all the signatures are
+collected, the transaction will be notarised and persisted to every participant's vault.
 
-After all parties have registered the intention of upgrading the contract state, one of the contract participants can initiate the upgrade process by triggering the ``Initiator`` contract upgrade flow.
-The ``Initiator`` will create a new state and sent to each participant for signatures, each of the participants (Acceptor) will verify, sign the proposal and return to the initiator.
-The transaction will be notarised and persisted once every participant verified and signed the upgrade proposal.
+Example
+-------
+Suppose Bank A has entered into an agreement with Bank B which is represented by the state object
+``DummyContractState`` and governed by the contract code ``DummyContract``. A few days after the exchange of contracts,
+the developer of the contract code discovers a bug in the contract code.
 
-Examples
---------
+Bank A and Bank B decide to upgrade the contract to ``DummyContractV2``:
 
-Lets assume Bank A has entered into an agreement with Bank B, and the contract is translated into contract code ``DummyContract`` with state object ``DummyContractState``.
+1. The developer creates a new contract ``DummyContractV2`` extending the ``UpgradedContract`` class, and a new state
+   object ``DummyContractV2.State`` referencing the new contract.
 
-A few days after the exchange of contracts, the developer of the contract code discovered a bug/misrepresentation in the contract code.
-Bank A and Bank B decided to upgrade the contract to ``DummyContractV2``
-
-1. Developer will create a new contract extending the ``UpgradedContract`` class, and a new state object ``DummyContractV2.State`` referencing the new contract.
-
-.. literalinclude:: /../../test-utils/src/main/kotlin/net/corda/testing/contracts/DummyContractV2.kt
+.. literalinclude:: /../../testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyContractV2.kt
     :language: kotlin
     :start-after: DOCSTART 1
     :end-before: DOCEND 1
 
-2. Bank A will instruct its node to accept the contract upgrade to ``DummyContractV2`` for the contract state.
+2. Bank A instructs its node to accept the contract upgrade to ``DummyContractV2`` for the contract state.
 
 .. container:: codeset
 
@@ -105,9 +103,9 @@ Bank A and Bank B decided to upgrade the contract to ``DummyContractV2``
       val rpcA = rpcClient.proxy()
       rpcA.startFlow(ContractUpgradeFlow.Authorise(<<StateAndRef of the contract state>>, DummyContractV2::class.java))
 
-3. Bank B now initiate the upgrade Flow, this will send a upgrade proposal to all contract participants.
-Each of the participants of the contract state will sign and return the contract state upgrade proposal once they have validated and agreed with the upgrade.
-The upgraded transaction state will be recorded in every participant's node at the end of the flow.
+3. Bank B initiates the upgrade flow, which will send an upgrade proposal to all contract participants. Each of the
+   participants of the contract state will sign and return the contract state upgrade proposal once they have validated
+   and agreed with the upgrade. The upgraded transaction will be recorded in every participant's node by the flow.
 
 .. container:: codeset
 
diff --git a/docs/source/corda-repo-layout.rst b/docs/source/corda-repo-layout.rst
index 9c8fc9cb1f..bbec123ab4 100644
--- a/docs/source/corda-repo-layout.rst
+++ b/docs/source/corda-repo-layout.rst
@@ -6,11 +6,11 @@ The Corda repository comprises the following folders:
 * **buildSrc** contains necessary gradle plugins to build Corda
 * **client** contains libraries for connecting to a node, working with it remotely and binding server-side data to
   JavaFX UI
+* **confidential-identities** contains experimental support for confidential identities on the ledger
 * **config** contains logging configurations and the default node configuration file
 * **core** containing the core Corda libraries such as crypto functions, types for Corda's building blocks: states,
   contracts, transactions, attachments, etc. and some interfaces for nodes and protocols
-* **docs** contains the Corda docsite in restructured text format as well as the built docs in html. The docs can be
-  accessed via ``/docs/index.html`` from the root of the repo
+* **docs** contains the Corda docsite in restructured text format
 * **experimental** contains platform improvements that are still in the experimental stage
 * **finance** defines a range of elementary contracts (and associated schemas) and protocols, such as abstract fungible
   assets, cash, obligation and commercial paper
@@ -20,7 +20,7 @@ The Corda repository comprises the following folders:
 * **node** contains the core code of the Corda node (eg: node driver, node services, messaging, persistence)
 * **node-api** contains data structures shared between the node and the client module, e.g. types sent via RPC
 * **samples** contains all our Corda demos and code samples
-* **test-utils** contains some utilities for unit testing contracts ( the contracts testing DSL) and protocols (the
+* **testing** contains some utilities for unit testing contracts (the contracts testing DSL) and flows (the
   mock network) implementation
 * **tools** contains the explorer which is a GUI front-end for Corda, and also the DemoBench which is a GUI tool that
   allows you to run Corda nodes locally for demonstrations
diff --git a/docs/source/event-scheduling.rst b/docs/source/event-scheduling.rst
index b5df1bcf1c..3ba100a3ef 100644
--- a/docs/source/event-scheduling.rst
+++ b/docs/source/event-scheduling.rst
@@ -42,7 +42,7 @@ There are two main steps to implementing scheduled events:
   ``nextScheduledActivity`` to be implemented which returns an optional ``ScheduledActivity`` instance.
   ``ScheduledActivity`` captures what ``FlowLogic`` instance each node will run, to perform the activity, and when it
   will run is described by a ``java.time.Instant``.  Once your state implements this interface and is tracked by the
-  wallet, it can expect to be queried for the next activity when committed to the wallet. The ``FlowLogic`` must be
+  vault, it can expect to be queried for the next activity when committed to the vault. The ``FlowLogic`` must be
   annotated with ``@SchedulableFlow``.
 * If nothing suitable exists, implement a ``FlowLogic`` to be executed by each node as the activity itself.
   The important thing to remember is that in the current implementation, each node that is party to the transaction
@@ -58,7 +58,7 @@ handler to help with obtaining a unique and secure random session.  An example i
 The production and consumption of ``ContractStates`` is observed by the scheduler and the activities associated with
 any consumed states are unscheduled.  Any newly produced states are then queried via the ``nextScheduledActivity``
 method and if they do not return ``null`` then that activity is scheduled based on the content of the
-``ScheduledActivity`` object returned. Be aware that this *only* happens if the wallet considers the state
+``ScheduledActivity`` object returned. Be aware that this *only* happens if the vault considers the state
 "relevant", for instance, because the owner of the node also owns that state. States that your node happens to
 encounter but which aren't related to yourself will not have any activities scheduled.
 
@@ -68,21 +68,13 @@ An example
 Let's take an example of the interest rate swap fixings for our scheduled events.  The first task is to implement the
 ``nextScheduledActivity`` method on the ``State``.
 
-
 .. container:: codeset
 
-   .. sourcecode:: kotlin
-
-        override fun nextScheduledActivity(thisStateRef: StateRef,
-                                           flowLogicRefFactory: FlowLogicRefFactory): ScheduledActivity? {
-            val nextFixingOf = nextFixingOf() ?: return null
-
-            val (instant, duration) = suggestInterestRateAnnouncementTimeWindow(index = nextFixingOf.name,
-                                                                                source = floatingLeg.indexSource,
-                                                                                date = nextFixingOf.forDay)
-            return ScheduledActivity(flowLogicRefFactory.create(TwoPartyDealFlow.FixingRoleDecider::class.java,
-                                                                    thisStateRef, duration), instant)
-        }
+    .. literalinclude:: ../../samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRS.kt
+        :language: kotlin
+        :start-after: DOCSTART 1
+        :end-before: DOCEND 1
+        :dedent: 8
 
 The first thing this does is establish if there are any remaining fixings.  If there are none, then it returns ``null``
 to indicate that there is no activity to schedule.  Otherwise it calculates the ``Instant`` at which the interest rate
diff --git a/docs/source/example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt b/docs/source/example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
index e4de7b4864..07ef6d6983 100644
--- a/docs/source/example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
+++ b/docs/source/example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
@@ -24,7 +24,7 @@ class IntegrationTestingTutorial {
     fun `alice bob cash exchange example`() {
         // START 1
         driver(startNodesInProcess = true,
-               extraCordappPackagesToScan = listOf("net.corda.finance.contracts.asset")) {
+                extraCordappPackagesToScan = listOf("net.corda.finance.contracts.asset")) {
             val aliceUser = User("aliceUser", "testPassword1", permissions = setOf(
                     startFlowPermission<CashIssueFlow>(),
                     startFlowPermission<CashPaymentFlow>()
@@ -104,7 +104,7 @@ class IntegrationTestingTutorial {
                         }
                 )
             }
+            // END 5
         }
     }
-}
-// END 5
+}
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
index 8d92b01786..c9d708540d 100644
--- a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
+++ b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
@@ -34,8 +34,6 @@ import java.util.Set;
 import static net.corda.core.contracts.ContractsDSL.requireThat;
 import static net.corda.testing.TestConstants.getALICE_KEY;
 
-// We group our two flows inside a singleton object to indicate that they work
-// together.
 @SuppressWarnings("unused")
 public class FlowCookbookJava {
     // ``InitiatorFlow`` is our first flow, and will communicate with
@@ -121,20 +119,24 @@ public class FlowCookbookJava {
 
             // A transaction generally needs a notary:
             //   - To prevent double-spends if the transaction has inputs
-            //   - To serve as a timestamping authority if the transaction has a time-window
+            //   - To serve as a timestamping authority if the transaction has a
+            //     time-window
             // We retrieve a notary from the network map.
             // DOCSTART 1
-            Party specificNotary = getServiceHub().getNetworkMapCache().getNotary(new CordaX500Name("Notary Service", "London", "UK"));
-            // Alternatively, we can pick an arbitrary notary from the notary list. However, it is always preferable to
-            // specify which notary to use explicitly, as the notary list might change when new notaries are introduced,
-            // or old ones decommissioned.
+            CordaX500Name notaryName = new CordaX500Name("Notary Service", "London", "GB");
+            Party specificNotary = getServiceHub().getNetworkMapCache().getNotary(notaryName);
+            // Alternatively, we can pick an arbitrary notary from the notary
+            // list. However, it is always preferable to specify the notary
+            // explicitly, as the notary list might change when new notaries are
+            // introduced, or old ones decommissioned.
             Party firstNotary = getServiceHub().getNetworkMapCache().getNotaryIdentities().get(0);
             // DOCEND 1
 
-            // We may also need to identify a specific counterparty.
-            // Again, we do so using the network map.
+            // We may also need to identify a specific counterparty. We do so
+            // using the identity service.
             // DOCSTART 2
-            Party namedCounterparty = getServiceHub().getIdentityService().wellKnownPartyFromX500Name(new CordaX500Name("NodeA", "London", "UK"));
+            CordaX500Name counterPartyName = new CordaX500Name("NodeA", "London", "GB");
+            Party namedCounterparty = getServiceHub().getIdentityService().wellKnownPartyFromX500Name(counterPartyName);
             Party keyedCounterparty = getServiceHub().getIdentityService().partyFromKey(dummyPubKey);
             // DOCEND 2
 
@@ -143,6 +145,13 @@ public class FlowCookbookJava {
             ------------------------------*/
             progressTracker.setCurrentStep(SENDING_AND_RECEIVING_DATA);
 
+            // We start by initiating a flow session with the counterparty. We
+            // will use this session to send and receive messages from the
+            // counterparty.
+            // DOCSTART initiateFlow
+            FlowSession counterpartySession = initiateFlow(counterparty);
+            // DOCEND initiateFlow
+
             // We can send arbitrary data to a counterparty.
             // If this is the first ``send``, the counterparty will either:
             // 1. Ignore the message if they are not registered to respond
@@ -154,7 +163,6 @@ public class FlowCookbookJava {
             // registered to respond to this flow, and has a corresponding
             // ``receive`` call.
             // DOCSTART 4
-            FlowSession counterpartySession = initiateFlow(counterparty);
             counterpartySession.send(new Object());
             // DOCEND 4
 
@@ -617,7 +625,7 @@ public class FlowCookbookJava {
             progressTracker.setCurrentStep(RECEIVING_AND_SENDING_DATA);
 
             // We need to respond to the messages sent by the initiator:
-            // 1. They sent us an ``Any`` instance
+            // 1. They sent us an ``Object`` instance
             // 2. They waited to receive an ``Integer`` instance back
             // 3. They sent a ``String`` instance and waited to receive a
             //    ``Boolean`` instance back
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/CommercialPaper.java b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/CommercialPaper.java
new file mode 100644
index 0000000000..8159838082
--- /dev/null
+++ b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/CommercialPaper.java
@@ -0,0 +1,101 @@
+package net.corda.docs.java.tutorial.contract;
+
+import net.corda.core.contracts.*;
+import net.corda.core.transactions.LedgerTransaction;
+import net.corda.core.transactions.LedgerTransaction.InOutGroup;
+
+import java.time.Instant;
+import java.util.Currency;
+import java.util.List;
+
+import static net.corda.core.contracts.ContractsDSL.requireSingleCommand;
+import static net.corda.core.contracts.ContractsDSL.requireThat;
+import static net.corda.finance.utils.StateSumming.sumCashBy;
+
+public class CommercialPaper implements Contract {
+    // DOCSTART 1
+    public static final String IOU_CONTRACT_ID = "com.example.contract.IOUContract";
+    // DOCEND 1
+
+    // DOCSTART 3
+    @Override
+    public void verify(LedgerTransaction tx) {
+        List<InOutGroup<State, State>> groups = tx.groupStates(State.class, State::withoutOwner);
+        CommandWithParties<Commands> cmd = requireSingleCommand(tx.getCommands(), Commands.class);
+        // DOCEND 3
+
+        // DOCSTART 4
+        TimeWindow timeWindow = tx.getTimeWindow();
+
+        for (InOutGroup group : groups) {
+            List<State> inputs = group.getInputs();
+            List<State> outputs = group.getOutputs();
+
+            if (cmd.getValue() instanceof Commands.Move) {
+                State input = inputs.get(0);
+                requireThat(require -> {
+                    require.using("the transaction is signed by the owner of the CP", cmd.getSigners().contains(input.getOwner().getOwningKey()));
+                    require.using("the state is propagated", outputs.size() == 1);
+                    // Don't need to check anything else, as if outputs.size == 1 then the output is equal to
+                    // the input ignoring the owner field due to the grouping.
+                    return null;
+                });
+
+            } else if (cmd.getValue() instanceof Commands.Redeem) {
+                // Redemption of the paper requires movement of on-ledger cash.
+                State input = inputs.get(0);
+                Amount<Issued<Currency>> received = sumCashBy(tx.getOutputStates(), input.getOwner());
+                if (timeWindow == null) throw new IllegalArgumentException("Redemptions must be timestamped");
+                Instant time = timeWindow.getFromTime();
+                requireThat(require -> {
+                    require.using("the paper must have matured", time.isAfter(input.getMaturityDate()));
+                    require.using("the received amount equals the face value", received == input.getFaceValue());
+                    require.using("the paper must be destroyed", outputs.size() == 0);
+                    require.using("the transaction is signed by the owner of the CP", cmd.getSigners().contains(input.getOwner().getOwningKey()));
+                    return null;
+                });
+            } else if (cmd.getValue() instanceof Commands.Issue) {
+                State output = outputs.get(0);
+                if (timeWindow == null) throw new IllegalArgumentException("Issuances must be timestamped");
+                Instant time = timeWindow.getUntilTime();
+                requireThat(require -> {
+                    // Don't allow people to issue commercial paper under other entities identities.
+                    require.using("output states are issued by a command signer", cmd.getSigners().contains(output.getIssuance().getParty().getOwningKey()));
+                    require.using("output values sum to more than the inputs", output.getFaceValue().getQuantity() > 0);
+                    require.using("the maturity date is not in the past", time.isBefore(output.getMaturityDate()));
+                    // Don't allow an existing CP state to be replaced by this issuance.
+                    require.using("can't reissue an existing state", inputs.isEmpty());
+                    return null;
+                });
+            } else {
+                throw new IllegalArgumentException("Unrecognised command");
+            }
+        }
+        // DOCEND 4
+    }
+
+    // DOCSTART 2
+    public static class Commands implements CommandData {
+        public static class Move extends Commands {
+            @Override
+            public boolean equals(Object obj) {
+                return obj instanceof Move;
+            }
+        }
+
+        public static class Redeem extends Commands {
+            @Override
+            public boolean equals(Object obj) {
+                return obj instanceof Redeem;
+            }
+        }
+
+        public static class Issue extends Commands {
+            @Override
+            public boolean equals(Object obj) {
+                return obj instanceof Issue;
+            }
+        }
+    }
+    // DOCEND 2
+}
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/State.java b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/State.java
new file mode 100644
index 0000000000..295fba8700
--- /dev/null
+++ b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/State.java
@@ -0,0 +1,90 @@
+package net.corda.docs.java.tutorial.contract;
+
+import com.google.common.collect.ImmutableList;
+import net.corda.core.contracts.*;
+import net.corda.core.crypto.NullKeys;
+import net.corda.core.identity.AbstractParty;
+import net.corda.core.identity.AnonymousParty;
+import org.jetbrains.annotations.NotNull;
+
+import java.time.Instant;
+import java.util.Currency;
+import java.util.List;
+
+// DOCSTART 1
+public class State implements OwnableState {
+    private PartyAndReference issuance;
+    private AbstractParty owner;
+    private Amount<Issued<Currency>> faceValue;
+    private Instant maturityDate;
+
+    public State() {
+    }  // For serialization
+
+    public State(PartyAndReference issuance, AbstractParty owner, Amount<Issued<Currency>> faceValue,
+                 Instant maturityDate) {
+        this.issuance = issuance;
+        this.owner = owner;
+        this.faceValue = faceValue;
+        this.maturityDate = maturityDate;
+    }
+
+    public State copy() {
+        return new State(this.issuance, this.owner, this.faceValue, this.maturityDate);
+    }
+
+    public State withoutOwner() {
+        return new State(this.issuance, new AnonymousParty(NullKeys.NullPublicKey.INSTANCE), this.faceValue, this.maturityDate);
+    }
+
+    @NotNull
+    @Override
+    public CommandAndState withNewOwner(@NotNull AbstractParty newOwner) {
+        return new CommandAndState(new CommercialPaper.Commands.Move(), new State(this.issuance, newOwner, this.faceValue, this.maturityDate));
+    }
+
+    public PartyAndReference getIssuance() {
+        return issuance;
+    }
+
+    public AbstractParty getOwner() {
+        return owner;
+    }
+
+    public Amount<Issued<Currency>> getFaceValue() {
+        return faceValue;
+    }
+
+    public Instant getMaturityDate() {
+        return maturityDate;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        State state = (State) o;
+
+        if (issuance != null ? !issuance.equals(state.issuance) : state.issuance != null) return false;
+        if (owner != null ? !owner.equals(state.owner) : state.owner != null) return false;
+        if (faceValue != null ? !faceValue.equals(state.faceValue) : state.faceValue != null) return false;
+        return !(maturityDate != null ? !maturityDate.equals(state.maturityDate) : state.maturityDate != null);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = issuance != null ? issuance.hashCode() : 0;
+        result = 31 * result + (owner != null ? owner.hashCode() : 0);
+        result = 31 * result + (faceValue != null ? faceValue.hashCode() : 0);
+        result = 31 * result + (maturityDate != null ? maturityDate.hashCode() : 0);
+        return result;
+    }
+
+    @NotNull
+    @Override
+    public List<AbstractParty> getParticipants() {
+        return ImmutableList.of(this.owner);
+    }
+}
+// DOCEND 1
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/flowstatemachines/TutorialFlowStateMachines.java b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/flowstatemachines/TutorialFlowStateMachines.java
new file mode 100644
index 0000000000..ac7f387ee7
--- /dev/null
+++ b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/flowstatemachines/TutorialFlowStateMachines.java
@@ -0,0 +1,38 @@
+package net.corda.docs.java.tutorial.flowstatemachines;
+
+import net.corda.core.flows.SignTransactionFlow;
+import net.corda.core.utilities.ProgressTracker;
+import org.jetbrains.annotations.Nullable;
+
+public class TutorialFlowStateMachines {
+    // DOCSTART 1
+    private final ProgressTracker progressTracker = new ProgressTracker(
+            RECEIVING,
+            VERIFYING,
+            SIGNING,
+            COLLECTING_SIGNATURES,
+            RECORDING
+    );
+
+    private static final ProgressTracker.Step RECEIVING = new ProgressTracker.Step(
+            "Waiting for seller trading info");
+    private static final ProgressTracker.Step VERIFYING = new ProgressTracker.Step(
+            "Verifying seller assets");
+    private static final ProgressTracker.Step SIGNING = new ProgressTracker.Step(
+            "Generating and signing transaction proposal");
+    private static final ProgressTracker.Step COLLECTING_SIGNATURES = new ProgressTracker.Step(
+            "Collecting signatures from other parties");
+    private static final ProgressTracker.Step RECORDING = new ProgressTracker.Step(
+            "Recording completed transaction");
+    // DOCEND 1
+
+    // DOCSTART 2
+    private static final ProgressTracker.Step VERIFYING_AND_SIGNING = new ProgressTracker.Step("Verifying and signing transaction proposal") {
+        @Nullable
+        @Override
+        public ProgressTracker childProgressTracker() {
+            return SignTransactionFlow.Companion.tracker();
+        }
+    };
+    // DOCEND 2
+}
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
new file mode 100644
index 0000000000..ee91484dbf
--- /dev/null
+++ b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
@@ -0,0 +1,270 @@
+package net.corda.docs.java.tutorial.testdsl;
+
+import kotlin.Unit;
+import net.corda.core.contracts.PartyAndReference;
+import net.corda.core.utilities.OpaqueBytes;
+import net.corda.finance.contracts.ICommercialPaperState;
+import net.corda.finance.contracts.JavaCommercialPaper;
+import net.corda.finance.contracts.asset.Cash;
+import org.junit.Test;
+
+import java.time.temporal.ChronoUnit;
+
+import static net.corda.finance.Currencies.DOLLARS;
+import static net.corda.finance.Currencies.issuedBy;
+import static net.corda.finance.contracts.JavaCommercialPaper.JCP_PROGRAM_ID;
+import static net.corda.testing.CoreTestUtils.*;
+import static net.corda.testing.NodeTestUtils.ledger;
+import static net.corda.testing.NodeTestUtils.transaction;
+import static net.corda.testing.TestConstants.*;
+
+public class CommercialPaperTest {
+    private final OpaqueBytes defaultRef = new OpaqueBytes(new byte[]{123});
+
+    // DOCSTART 1
+    private ICommercialPaperState getPaper() {
+        return new JavaCommercialPaper.State(
+                getMEGA_CORP().ref(defaultRef),
+                getMEGA_CORP(),
+                issuedBy(DOLLARS(1000), getMEGA_CORP().ref(defaultRef)),
+                getTEST_TX_TIME().plus(7, ChronoUnit.DAYS)
+        );
+    }
+    // DOCEND 1
+
+    // DOCSTART 2
+    @Test
+    public void simpleCP() {
+        ICommercialPaperState inState = getPaper();
+        ledger(l -> {
+            l.transaction(tx -> {
+                tx.attachments(JCP_PROGRAM_ID);
+                tx.input(JCP_PROGRAM_ID, inState);
+                return tx.verifies();
+            });
+            return Unit.INSTANCE;
+        });
+    }
+    // DOCEND 2
+
+    // DOCSTART 3
+    @Test
+    public void simpleCPMove() {
+        ICommercialPaperState inState = getPaper();
+        ledger(l -> {
+            l.transaction(tx -> {
+                tx.input(JCP_PROGRAM_ID, inState);
+                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                tx.attachments(JCP_PROGRAM_ID);
+                return tx.verifies();
+            });
+            return Unit.INSTANCE;
+        });
+    }
+    // DOCEND 3
+
+    // DOCSTART 4
+    @Test
+    public void simpleCPMoveFails() {
+        ICommercialPaperState inState = getPaper();
+        ledger(l -> {
+            l.transaction(tx -> {
+                tx.input(JCP_PROGRAM_ID, inState);
+                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                tx.attachments(JCP_PROGRAM_ID);
+                return tx.failsWith("the state is propagated");
+            });
+            return Unit.INSTANCE;
+        });
+    }
+    // DOCEND 4
+
+    // DOCSTART 5
+    @Test
+    public void simpleCPMoveSuccess() {
+        ICommercialPaperState inState = getPaper();
+        ledger(l -> {
+            l.transaction(tx -> {
+                tx.input(JCP_PROGRAM_ID, inState);
+                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                tx.attachments(JCP_PROGRAM_ID);
+                tx.failsWith("the state is propagated");
+                tx.output(JCP_PROGRAM_ID, "alice's paper", inState.withOwner(getALICE()));
+                return tx.verifies();
+            });
+            return Unit.INSTANCE;
+        });
+    }
+    // DOCEND 5
+
+    // DOCSTART 6
+    @Test
+    public void simpleIssuanceWithTweak() {
+        ledger(l -> {
+            l.transaction(tx -> {
+                tx.output(JCP_PROGRAM_ID, "paper", getPaper()); // Some CP is issued onto the ledger by MegaCorp.
+                tx.attachments(JCP_PROGRAM_ID);
+                tx.tweak(tw -> {
+                    tw.command(getBIG_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                    tw.timeWindow(getTEST_TX_TIME());
+                    return tw.failsWith("output states are issued by a command signer");
+                });
+                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                tx.timeWindow(getTEST_TX_TIME());
+                return tx.verifies();
+            });
+            return Unit.INSTANCE;
+        });
+    }
+    // DOCEND 6
+
+    // DOCSTART 7
+    @Test
+    public void simpleIssuanceWithTweakTopLevelTx() {
+        transaction(tx -> {
+            tx.output(JCP_PROGRAM_ID, "paper", getPaper()); // Some CP is issued onto the ledger by MegaCorp.
+            tx.attachments(JCP_PROGRAM_ID);
+            tx.tweak(tw -> {
+                tw.command(getBIG_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                tw.timeWindow(getTEST_TX_TIME());
+                return tw.failsWith("output states are issued by a command signer");
+            });
+            tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+            tx.timeWindow(getTEST_TX_TIME());
+            return tx.verifies();
+        });
+    }
+    // DOCEND 7
+
+    // DOCSTART 8
+    @Test
+    public void chainCommercialPaper() {
+        PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
+        ledger(l -> {
+            l.unverifiedTransaction(tx -> {
+                tx.output(Cash.PROGRAM_ID, "alice's $900",
+                        new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE()));
+                tx.attachments(Cash.PROGRAM_ID);
+                return Unit.INSTANCE;
+            });
+
+            // Some CP is issued onto the ledger by MegaCorp.
+            l.transaction("Issuance", tx -> {
+                tx.output(JCP_PROGRAM_ID, "paper", getPaper());
+                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                tx.attachments(JCP_PROGRAM_ID);
+                tx.timeWindow(getTEST_TX_TIME());
+                return tx.verifies();
+            });
+
+            l.transaction("Trade", tx -> {
+                tx.input("paper");
+                tx.input("alice's $900");
+                tx.output(Cash.PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP()));
+                JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
+                tx.output(JCP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE()));
+                tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
+                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                return tx.verifies();
+            });
+            return Unit.INSTANCE;
+        });
+    }
+    // DOCEND 8
+
+    // DOCSTART 9
+    @Test
+    public void chainCommercialPaperDoubleSpend() {
+        PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
+        ledger(l -> {
+            l.unverifiedTransaction(tx -> {
+                tx.output(Cash.PROGRAM_ID, "alice's $900",
+                        new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE()));
+                tx.attachments(Cash.PROGRAM_ID);
+                return Unit.INSTANCE;
+            });
+
+            // Some CP is issued onto the ledger by MegaCorp.
+            l.transaction("Issuance", tx -> {
+                tx.output(Cash.PROGRAM_ID, "paper", getPaper());
+                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                tx.attachments(JCP_PROGRAM_ID);
+                tx.timeWindow(getTEST_TX_TIME());
+                return tx.verifies();
+            });
+
+            l.transaction("Trade", tx -> {
+                tx.input("paper");
+                tx.input("alice's $900");
+                tx.output(Cash.PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP()));
+                JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
+                tx.output(JCP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE()));
+                tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
+                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                return tx.verifies();
+            });
+
+            l.transaction(tx -> {
+                tx.input("paper");
+                JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
+                // We moved a paper to other pubkey.
+                tx.output(JCP_PROGRAM_ID, "bob's paper", inputPaper.withOwner(getBOB()));
+                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                return tx.verifies();
+            });
+            l.fails();
+            return Unit.INSTANCE;
+        });
+    }
+    // DOCEND 9
+
+    // DOCSTART 10
+    @Test
+    public void chainCommercialPaperTweak() {
+        PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
+        ledger(l -> {
+            l.unverifiedTransaction(tx -> {
+                tx.output(Cash.PROGRAM_ID, "alice's $900",
+                        new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE()));
+                tx.attachments(Cash.PROGRAM_ID);
+                return Unit.INSTANCE;
+            });
+
+            // Some CP is issued onto the ledger by MegaCorp.
+            l.transaction("Issuance", tx -> {
+                tx.output(Cash.PROGRAM_ID, "paper", getPaper());
+                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                tx.attachments(JCP_PROGRAM_ID);
+                tx.timeWindow(getTEST_TX_TIME());
+                return tx.verifies();
+            });
+
+            l.transaction("Trade", tx -> {
+                tx.input("paper");
+                tx.input("alice's $900");
+                tx.output(Cash.PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP()));
+                JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
+                tx.output(JCP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE()));
+                tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
+                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                return tx.verifies();
+            });
+
+            l.tweak(lw -> {
+                lw.transaction(tx -> {
+                    tx.input("paper");
+                    JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
+                    // We moved a paper to another pubkey.
+                    tx.output(JCP_PROGRAM_ID, "bob's paper", inputPaper.withOwner(getBOB()));
+                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                    return tx.verifies();
+                });
+                lw.fails();
+                return Unit.INSTANCE;
+            });
+            l.verifies();
+            return Unit.INSTANCE;
+        });
+    }
+    // DOCEND 10
+}
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
index b2ffa4b3f2..bc21a3b5f2 100644
--- a/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
@@ -49,7 +49,7 @@ fun main(args: Array<String>) {
             startFlowPermission<CashPaymentFlow>(),
             startFlowPermission<CashExitFlow>()))
 
-    driver(driverDirectory = baseDirectory) {
+    driver(driverDirectory = baseDirectory, extraCordappPackagesToScan = listOf("net.corda.finance")) {
         startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(ValidatingNotaryService.type)))
         val node = startNode(providedName = ALICE.name, rpcUsers = listOf(user)).get()
         // END 1
@@ -100,10 +100,9 @@ fun main(args: Array<String>) {
             }
         }
         waitForAllNodesToFinish()
+        // END 5
     }
-
 }
-// END 5
 
 // START 6
 fun generateTransactions(proxy: CordaRPCOps) {
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 6fb9df18b2..8aa248f709 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
@@ -28,606 +28,615 @@ import net.corda.testing.contracts.DummyState
 import java.security.PublicKey
 import java.time.Instant
 
-// We group our two flows inside a singleton object to indicate that they work
-// together.
-object FlowCookbook {
-    // ``InitiatorFlow`` is our first flow, and will communicate with
-    // ``ResponderFlow``, below.
-    // We mark ``InitiatorFlow`` as an ``InitiatingFlow``, allowing it to be
-    // started directly by the node.
-    @InitiatingFlow
-    // We also mark ``InitiatorFlow`` as ``StartableByRPC``, allowing the
-    // node's owner to start the flow via RPC.
-    @StartableByRPC
-    // Every flow must subclass ``FlowLogic``. The generic indicates the
-    // flow's return type.
-    class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty: Party, val regulator: Party) : FlowLogic<Unit>() {
+// ``InitiatorFlow`` is our first flow, and will communicate with
+// ``ResponderFlow``, below.
+// We mark ``InitiatorFlow`` as an ``InitiatingFlow``, allowing it to be
+// started directly by the node.
+@InitiatingFlow
+// We also mark ``InitiatorFlow`` as ``StartableByRPC``, allowing the
+// node's owner to start the flow via RPC.
+@StartableByRPC
+// Every flow must subclass ``FlowLogic``. The generic indicates the
+// flow's return type.
+class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty: Party, val regulator: Party) : FlowLogic<Unit>() {
 
-        /**---------------------------------
-         * WIRING UP THE PROGRESS TRACKER *
-        ---------------------------------**/
-        // Giving our flow a progress tracker allows us to see the flow's
-        // progress visually in our node's CRaSH shell.
-        // DOCSTART 17
-        companion object {
-            object ID_OTHER_NODES : Step("Identifying other nodes on the network.")
-            object SENDING_AND_RECEIVING_DATA : Step("Sending data between parties.")
-            object EXTRACTING_VAULT_STATES : Step("Extracting states from the vault.")
-            object OTHER_TX_COMPONENTS : Step("Gathering a transaction's other components.")
-            object TX_BUILDING : Step("Building a transaction.")
-            object TX_SIGNING : Step("Signing a transaction.")
-            object TX_VERIFICATION : Step("Verifying a transaction.")
-            object SIGS_GATHERING : Step("Gathering a transaction's signatures.") {
-                // Wiring up a child progress tracker allows us to see the
-                // subflow's progress steps in our flow's progress tracker.
-                override fun childProgressTracker() = CollectSignaturesFlow.tracker()
-            }
-
-            object VERIFYING_SIGS : Step("Verifying a transaction's signatures.")
-            object FINALISATION : Step("Finalising a transaction.") {
-                override fun childProgressTracker() = FinalityFlow.tracker()
-            }
-
-            fun tracker() = ProgressTracker(
-                    ID_OTHER_NODES,
-                    SENDING_AND_RECEIVING_DATA,
-                    EXTRACTING_VAULT_STATES,
-                    OTHER_TX_COMPONENTS,
-                    TX_BUILDING,
-                    TX_SIGNING,
-                    TX_VERIFICATION,
-                    SIGS_GATHERING,
-                    VERIFYING_SIGS,
-                    FINALISATION
-            )
+    /**---------------------------------
+     * WIRING UP THE PROGRESS TRACKER *
+    ---------------------------------**/
+    // Giving our flow a progress tracker allows us to see the flow's
+    // progress visually in our node's CRaSH shell.
+    // DOCSTART 17
+    companion object {
+        object ID_OTHER_NODES : Step("Identifying other nodes on the network.")
+        object SENDING_AND_RECEIVING_DATA : Step("Sending data between parties.")
+        object EXTRACTING_VAULT_STATES : Step("Extracting states from the vault.")
+        object OTHER_TX_COMPONENTS : Step("Gathering a transaction's other components.")
+        object TX_BUILDING : Step("Building a transaction.")
+        object TX_SIGNING : Step("Signing a transaction.")
+        object TX_VERIFICATION : Step("Verifying a transaction.")
+        object SIGS_GATHERING : Step("Gathering a transaction's signatures.") {
+            // Wiring up a child progress tracker allows us to see the
+            // subflow's progress steps in our flow's progress tracker.
+            override fun childProgressTracker() = CollectSignaturesFlow.tracker()
         }
-        // DOCEND 17
 
-        override val progressTracker: ProgressTracker = tracker()
-
-        @Suppress("RemoveExplicitTypeArguments")
-        @Suspendable
-        override fun call() {
-            // We'll be using a dummy public key for demonstration purposes.
-            // These are built in to Corda, and are generally used for writing
-            // tests.
-            val dummyPubKey: PublicKey = ALICE_PUBKEY
-
-            /**--------------------------
-             * IDENTIFYING OTHER NODES *
-            --------------------------**/
-            // DOCSTART 18
-            progressTracker.currentStep = ID_OTHER_NODES
-            // DOCEND 18
-
-            // A transaction generally needs a notary:
-            //   - To prevent double-spends if the transaction has inputs
-            //   - To serve as a timestamping authority if the transaction has a time-window
-            // We retrieve the notary from the network map.
-            // DOCSTART 1
-            val specificNotary: Party = serviceHub.networkMapCache.getNotary(CordaX500Name(organisation = "Notary Service", locality = "London", country = "UK"))!!
-            // Alternatively, we can pick an arbitrary notary from the notary list. However, it is always preferable to
-            // specify which notary to use explicitly, as the notary list might change when new notaries are introduced,
-            // or old ones decommissioned.
-            val firstNotary: Party = serviceHub.networkMapCache.notaryIdentities.first()
-            // DOCEND 1
-
-            // We may also need to identify a specific counterparty. We
-            // do so using identity service.
-            // DOCSTART 2
-            val namedCounterparty: Party = serviceHub.identityService.wellKnownPartyFromX500Name(CordaX500Name(organisation = "NodeA", locality = "London", country = "UK")) ?:
-                    throw IllegalArgumentException("Couldn't find counterparty for NodeA in identity service")
-            val keyedCounterparty: Party = serviceHub.identityService.partyFromKey(dummyPubKey) ?:
-                    throw IllegalArgumentException("Couldn't find counterparty with key: $dummyPubKey in identity service")
-            // DOCEND 2
-
-            // DOCSTART initiateFlow
-            val counterpartySession = initiateFlow(counterparty)
-            // DOCEND initiateFlow
-
-            /**-----------------------------
-             * SENDING AND RECEIVING DATA *
-            -----------------------------**/
-            progressTracker.currentStep = SENDING_AND_RECEIVING_DATA
-
-            // We can send arbitrary data to a counterparty.
-            // If this is the first ``send``, the counterparty will either:
-            // 1. Ignore the message if they are not registered to respond
-            //    to messages from this flow.
-            // 2. Start the flow they have registered to respond to this flow,
-            //    and run the flow until the first call to ``receive``, at
-            //    which point they process the message.
-            // In other words, we are assuming that the counterparty is
-            // registered to respond to this flow, and has a corresponding
-            // ``receive`` call.
-            // DOCSTART 4
-            counterpartySession.send(Any())
-            // DOCEND 4
-
-            // We can wait to receive arbitrary data of a specific type from a
-            // counterparty. Again, this implies a corresponding ``send`` call
-            // in the counterparty's flow. A few scenarios:
-            // - We never receive a message back. In the current design, the
-            //   flow is paused until the node's owner kills the flow.
-            // - Instead of sending a message back, the counterparty throws a
-            //   ``FlowException``. This exception is propagated back to us,
-            //   and we can use the error message to establish what happened.
-            // - We receive a message back, but it's of the wrong type. In
-            //   this case, a ``FlowException`` is thrown.
-            // - We receive back a message of the correct type. All is good.
-            //
-            // Upon calling ``receive()`` (or ``sendAndReceive()``), the
-            // ``FlowLogic`` is suspended until it receives a response.
-            //
-            // We receive the data wrapped in an ``UntrustworthyData``
-            // instance. This is a reminder that the data we receive may not
-            // be what it appears to be! We must unwrap the
-            // ``UntrustworthyData`` using a lambda.
-            // DOCSTART 5
-            val packet1: UntrustworthyData<Int> = counterpartySession.receive<Int>()
-            val int: Int = packet1.unwrap { data ->
-                // Perform checking on the object received.
-                // T O D O: Check the received object.
-                // Return the object.
-                data
-            }
-            // DOCEND 5
-
-            // We can also use a single call to send data to a counterparty
-            // and wait to receive data of a specific type back. The type of
-            // data sent doesn't need to match the type of the data received
-            // back.
-            // DOCSTART 7
-            val packet2: UntrustworthyData<Boolean> = counterpartySession.sendAndReceive<Boolean>("You can send and receive any class!")
-            val boolean: Boolean = packet2.unwrap { data ->
-                // Perform checking on the object received.
-                // T O D O: Check the received object.
-                // Return the object.
-                data
-            }
-            // DOCEND 7
-
-            // We're not limited to sending to and receiving from a single
-            // counterparty. A flow can send messages to as many parties as it
-            // likes, and each party can invoke a different response flow.
-            // DOCSTART 6
-            val regulatorSession = initiateFlow(regulator)
-            regulatorSession.send(Any())
-            val packet3: UntrustworthyData<Any> = regulatorSession.receive<Any>()
-            // DOCEND 6
-
-            /**-----------------------------------
-             * EXTRACTING STATES FROM THE VAULT *
-            -----------------------------------**/
-            progressTracker.currentStep = EXTRACTING_VAULT_STATES
-
-            // Let's assume there are already some ``DummyState``s in our
-            // node's vault, stored there as a result of running past flows,
-            // and we want to consume them in a transaction. There are many
-            // ways to extract these states from our vault.
-
-            // For example, we would extract any unconsumed ``DummyState``s
-            // from our vault as follows:
-            val criteria: VaultQueryCriteria = VaultQueryCriteria() // default is UNCONSUMED
-            val results: Page<DummyState> = serviceHub.vaultService.queryBy<DummyState>(criteria)
-            val dummyStates: List<StateAndRef<DummyState>> = results.states
-
-            // For a full list of the available ways of extracting states from
-            // the vault, see the Vault Query docs page.
-
-            // When building a transaction, input states are passed in as
-            // ``StateRef`` instances, which pair the hash of the transaction
-            // that generated the state with the state's index in the outputs
-            // of that transaction. In practice, we'd pass the transaction hash
-            // or the ``StateRef`` as a parameter to the flow, or extract the
-            // ``StateRef`` from our vault.
-            // DOCSTART 20
-            val ourStateRef: StateRef = StateRef(SecureHash.sha256("DummyTransactionHash"), 0)
-            // DOCEND 20
-            // A ``StateAndRef`` pairs a ``StateRef`` with the state it points to.
-            // DOCSTART 21
-            val ourStateAndRef: StateAndRef<DummyState> = serviceHub.toStateAndRef<DummyState>(ourStateRef)
-            // DOCEND 21
-
-            /**-----------------------------------------
-             * GATHERING OTHER TRANSACTION COMPONENTS *
-            -----------------------------------------**/
-            progressTracker.currentStep = OTHER_TX_COMPONENTS
-
-            // Output states are constructed from scratch.
-            // DOCSTART 22
-            val ourOutputState: DummyState = DummyState()
-            // DOCEND 22
-            // Or as copies of other states with some properties changed.
-            // DOCSTART 23
-            val ourOtherOutputState: DummyState = ourOutputState.copy(magicNumber = 77)
-            // DOCEND 23
-
-            // We then need to pair our output state with a contract.
-            // DOCSTART 47
-            val contractName: String = "net.corda.testing.contracts.DummyContract"
-            val ourOutput: StateAndContract = StateAndContract(ourOutputState, contractName)
-            // DOCEND 47
-
-            // Commands pair a ``CommandData`` instance with a list of
-            // public keys. To be valid, the transaction requires a signature
-            // matching every public key in all of the transaction's commands.
-            // DOCSTART 24
-            val commandData: DummyContract.Commands.Create = DummyContract.Commands.Create()
-            val ourPubKey: PublicKey = serviceHub.myInfo.legalIdentitiesAndCerts.first().owningKey
-            val counterpartyPubKey: PublicKey = counterparty.owningKey
-            val requiredSigners: List<PublicKey> = listOf(ourPubKey, counterpartyPubKey)
-            val ourCommand: Command<DummyContract.Commands.Create> = Command(commandData, requiredSigners)
-            // DOCEND 24
-
-            // ``CommandData`` can either be:
-            // 1. Of type ``TypeOnlyCommandData``, in which case it only
-            //    serves to attach signers to the transaction and possibly
-            //    fork the contract's verification logic.
-            val typeOnlyCommandData: TypeOnlyCommandData = DummyContract.Commands.Create()
-            // 2. Include additional data which can be used by the contract
-            //    during verification, alongside fulfilling the roles above.
-            val commandDataWithData: CommandData = Cash.Commands.Issue()
-
-            // Attachments are identified by their hash.
-            // The attachment with the corresponding hash must have been
-            // uploaded ahead of time via the node's RPC interface.
-            // DOCSTART 25
-            val ourAttachment: SecureHash = SecureHash.sha256("DummyAttachment")
-            // DOCEND 25
-
-            // Time windows can have a start and end time, or be open at either end.
-            // DOCSTART 26
-            val ourTimeWindow: TimeWindow = TimeWindow.between(Instant.MIN, Instant.MAX)
-            val ourAfter: TimeWindow = TimeWindow.fromOnly(Instant.MIN)
-            val ourBefore: TimeWindow = TimeWindow.untilOnly(Instant.MAX)
-            // DOCEND 26
-
-            // We can also define a time window as an ``Instant`` +/- a time
-            // tolerance (e.g. 30 seconds):
-            // DOCSTART 42
-            val ourTimeWindow2: TimeWindow = TimeWindow.withTolerance(serviceHub.clock.instant(), 30.seconds)
-            // DOCEND 42
-            // Or as a start-time plus a duration:
-            // DOCSTART 43
-            val ourTimeWindow3: TimeWindow = TimeWindow.fromStartAndDuration(serviceHub.clock.instant(), 30.seconds)
-            // DOCEND 43
-
-            /**-----------------------
-             * TRANSACTION BUILDING *
-            -----------------------**/
-            progressTracker.currentStep = TX_BUILDING
-
-            // If our transaction has input states or a time-window, we must instantiate it with a
-            // notary.
-            // DOCSTART 19
-            val txBuilder: TransactionBuilder = TransactionBuilder(specificNotary)
-            // DOCEND 19
-
-            // Otherwise, we can choose to instantiate it without one:
-            // DOCSTART 46
-            val txBuilderNoNotary: TransactionBuilder = TransactionBuilder()
-            // DOCEND 46
-
-            // We add items to the transaction builder using ``TransactionBuilder.withItems``:
-            // DOCSTART 27
-            txBuilder.withItems(
-                    // Inputs, as ``StateAndRef``s that reference the outputs of previous transactions
-                    ourStateAndRef,
-                    // Outputs, as ``StateAndContract``s
-                    ourOutput,
-                    // Commands, as ``Command``s
-                    ourCommand,
-                    // Attachments, as ``SecureHash``es
-                    ourAttachment,
-                    // A time-window, as ``TimeWindow``
-                    ourTimeWindow
-            )
-            // DOCEND 27
-
-            // We can also add items using methods for the individual components.
-
-            // The individual methods for adding input states and attachments:
-            // DOCSTART 28
-            txBuilder.addInputState(ourStateAndRef)
-            txBuilder.addAttachment(ourAttachment)
-            // DOCEND 28
-
-            // An output state can be added as a ``ContractState``, contract class name and notary.
-            // DOCSTART 49
-            txBuilder.addOutputState(ourOutputState, DummyContract.PROGRAM_ID, specificNotary)
-            // DOCEND 49
-            // We can also leave the notary field blank, in which case the transaction's default
-            // notary is used.
-            // DOCSTART 50
-            txBuilder.addOutputState(ourOutputState, DummyContract.PROGRAM_ID)
-            // DOCEND 50
-            // Or we can add the output state as a ``TransactionState``, which already specifies
-            // the output's contract and notary.
-            // DOCSTART 51
-            val txState: TransactionState<DummyState> = TransactionState(ourOutputState, DummyContract.PROGRAM_ID, specificNotary)
-            // DOCEND 51
-
-            // Commands can be added as ``Command``s.
-            // DOCSTART 52
-            txBuilder.addCommand(ourCommand)
-            // DOCEND 52
-            // Or as ``CommandData`` and a ``vararg PublicKey``.
-            // DOCSTART 53
-            txBuilder.addCommand(commandData, ourPubKey, counterpartyPubKey)
-            // DOCEND 53
-
-            // We can set a time-window directly.
-            // DOCSTART 44
-            txBuilder.setTimeWindow(ourTimeWindow)
-            // DOCEND 44
-            // Or as a start time plus a duration (e.g. 45 seconds).
-            // DOCSTART 45
-            txBuilder.setTimeWindow(serviceHub.clock.instant(), 45.seconds)
-            // DOCEND 45
-
-            /**----------------------
-             * TRANSACTION SIGNING *
-            ----------------------**/
-            progressTracker.currentStep = TX_SIGNING
-
-            // We finalise the transaction by signing it, converting it into a
-            // ``SignedTransaction``.
-            // DOCSTART 29
-            val onceSignedTx: SignedTransaction = serviceHub.signInitialTransaction(txBuilder)
-            // DOCEND 29
-            // We can also sign the transaction using a different public key:
-            // DOCSTART 30
-            val otherKey: PublicKey = serviceHub.keyManagementService.freshKey()
-            val onceSignedTx2: SignedTransaction = serviceHub.signInitialTransaction(txBuilder, otherKey)
-            // DOCEND 30
-
-            // If instead this was a ``SignedTransaction`` that we'd received
-            // from a counterparty and we needed to sign it, we would add our
-            // signature using:
-            // DOCSTART 38
-            val twiceSignedTx: SignedTransaction = serviceHub.addSignature(onceSignedTx)
-            // DOCEND 38
-            // Or, if we wanted to use a different public key:
-            val otherKey2: PublicKey = serviceHub.keyManagementService.freshKey()
-            // DOCSTART 39
-            val twiceSignedTx2: SignedTransaction = serviceHub.addSignature(onceSignedTx, otherKey2)
-            // DOCEND 39
-
-            // We can also generate a signature over the transaction without
-            // adding it to the transaction itself. We may do this when
-            // sending just the signature in a flow instead of returning the
-            // entire transaction with our signature. This way, the receiving
-            // node does not need to check we haven't changed anything in the
-            // transaction.
-            // DOCSTART 40
-            val sig: TransactionSignature = serviceHub.createSignature(onceSignedTx)
-            // DOCEND 40
-            // And again, if we wanted to use a different public key:
-            // DOCSTART 41
-            val sig2: TransactionSignature = serviceHub.createSignature(onceSignedTx, otherKey2)
-            // DOCEND 41
-
-            // In practice, however, the process of gathering every signature
-            // but the first can be automated using ``CollectSignaturesFlow``.
-            // See the "Gathering Signatures" section below.
-
-            /**---------------------------
-             * TRANSACTION VERIFICATION *
-            ---------------------------**/
-            progressTracker.currentStep = TX_VERIFICATION
-
-            // Verifying a transaction will also verify every transaction in
-            // the transaction's dependency chain, which will require
-            // transaction data access on counterparty's node. The
-            // ``SendTransactionFlow`` can be used to automate the sending and
-            // data vending process. The ``SendTransactionFlow`` will listen
-            // for data request until the transaction is resolved and verified
-            // on the other side:
-            // DOCSTART 12
-            subFlow(SendTransactionFlow(counterpartySession, twiceSignedTx))
-
-            // Optional request verification to further restrict data access.
-            subFlow(object : SendTransactionFlow(counterpartySession, twiceSignedTx) {
-                override fun verifyDataRequest(dataRequest: FetchDataFlow.Request.Data) {
-                    // Extra request verification.
-                }
-            })
-            // DOCEND 12
-
-            // We can receive the transaction using ``ReceiveTransactionFlow``,
-            // which will automatically download all the dependencies and verify
-            // the transaction
-            // DOCSTART 13
-            val verifiedTransaction = subFlow(ReceiveTransactionFlow(counterpartySession))
-            // DOCEND 13
-
-            // We can also send and receive a `StateAndRef` dependency chain
-            // and automatically resolve its dependencies.
-            // DOCSTART 14
-            subFlow(SendStateAndRefFlow(counterpartySession, dummyStates))
-
-            // On the receive side ...
-            val resolvedStateAndRef = subFlow(ReceiveStateAndRefFlow<DummyState>(counterpartySession))
-            // DOCEND 14
-
-            // We can now verify the transaction to ensure that it satisfies
-            // the contracts of all the transaction's input and output states.
-            // DOCSTART 33
-            twiceSignedTx.verify(serviceHub)
-            // DOCEND 33
-
-            // We'll often want to perform our own additional verification
-            // too. Just because a transaction is valid based on the contract
-            // rules and requires our signature doesn't mean we have to
-            // sign it! We need to make sure the transaction represents an
-            // agreement we actually want to enter into.
-
-            // To do this, we need to convert our ``SignedTransaction``
-            // into a ``LedgerTransaction``. This will use our ServiceHub
-            // to resolve the transaction's inputs and attachments into
-            // actual objects, rather than just references.
-            // DOCSTART 32
-            val ledgerTx: LedgerTransaction = twiceSignedTx.toLedgerTransaction(serviceHub)
-            // DOCEND 32
-
-            // We can now perform our additional verification.
-            // DOCSTART 34
-            val outputState: DummyState = ledgerTx.outputsOfType<DummyState>().single()
-            if (outputState.magicNumber == 777) {
-                // ``FlowException`` is a special exception type. It will be
-                // propagated back to any counterparty flows waiting for a
-                // message from this flow, notifying them that the flow has
-                // failed.
-                throw FlowException("We expected a magic number of 777.")
-            }
-            // DOCEND 34
-
-            // Of course, if you are not a required signer on the transaction,
-            // you have no power to decide whether it is valid or not. If it
-            // requires signatures from all the required signers and is
-            // contractually valid, it's a valid ledger update.
-
-            /**-----------------------
-             * GATHERING SIGNATURES *
-            -----------------------**/
-            progressTracker.currentStep = SIGS_GATHERING
-
-            // The list of parties who need to sign a transaction is dictated
-            // by the transaction's commands. Once we've signed a transaction
-            // ourselves, we can automatically gather the signatures of the
-            // other required signers using ``CollectSignaturesFlow``.
-            // The responder flow will need to call ``SignTransactionFlow``.
-            // DOCSTART 15
-            val fullySignedTx: SignedTransaction = subFlow(CollectSignaturesFlow(twiceSignedTx, setOf(counterpartySession, regulatorSession), SIGS_GATHERING.childProgressTracker()))
-            // DOCEND 15
-
-            /**-----------------------
-             * VERIFYING SIGNATURES *
-            -----------------------**/
-            progressTracker.currentStep = VERIFYING_SIGS
-
-            // We can verify that a transaction has all the required
-            // signatures, and that they're all valid, by running:
-            // DOCSTART 35
-            fullySignedTx.verifyRequiredSignatures()
-            // DOCEND 35
-
-            // If the transaction is only partially signed, we have to pass in
-            // a list of the public keys corresponding to the missing
-            // signatures, explicitly telling the system not to check them.
-            // DOCSTART 36
-            onceSignedTx.verifySignaturesExcept(counterpartyPubKey)
-            // DOCEND 36
-
-            // We can also choose to only check the signatures that are
-            // present. BE VERY CAREFUL - this function provides no guarantees
-            // that the signatures are correct, or that none are missing.
-            // DOCSTART 37
-            twiceSignedTx.checkSignaturesAreValid()
-            // DOCEND 37
-
-            /**-----------------------------
-             * FINALISING THE TRANSACTION *
-            -----------------------------**/
-            progressTracker.currentStep = FINALISATION
-
-            // We notarise the transaction and get it recorded in the vault of
-            // the participants of all the transaction's states.
-            // DOCSTART 9
-            val notarisedTx1: SignedTransaction = subFlow(FinalityFlow(fullySignedTx, FINALISATION.childProgressTracker()))
-            // DOCEND 9
-            // We can also choose to send it to additional parties who aren't one
-            // of the state's participants.
-            // DOCSTART 10
-            val additionalParties: Set<Party> = setOf(regulator)
-            val notarisedTx2: SignedTransaction = subFlow(FinalityFlow(fullySignedTx, additionalParties, FINALISATION.childProgressTracker()))
-            // DOCEND 10
-
-            // DOCSTART FlowSession porting
-            send(regulator, Any()) // Old API
-            // becomes
-            val session = initiateFlow(regulator)
-            session.send(Any())
-            // DOCEND FlowSession porting
+        object VERIFYING_SIGS : Step("Verifying a transaction's signatures.")
+        object FINALISATION : Step("Finalising a transaction.") {
+            override fun childProgressTracker() = FinalityFlow.tracker()
         }
+
+        fun tracker() = ProgressTracker(
+                ID_OTHER_NODES,
+                SENDING_AND_RECEIVING_DATA,
+                EXTRACTING_VAULT_STATES,
+                OTHER_TX_COMPONENTS,
+                TX_BUILDING,
+                TX_SIGNING,
+                TX_VERIFICATION,
+                SIGS_GATHERING,
+                VERIFYING_SIGS,
+                FINALISATION
+        )
     }
+    // DOCEND 17
 
-    // ``ResponderFlow`` is our second flow, and will communicate with
-    // ``InitiatorFlow``.
-    // We mark ``ResponderFlow`` as an ``InitiatedByFlow``, meaning that it
-    // can only be started in response to a message from its initiating flow.
-    // That's ``InitiatorFlow`` in this case.
-    // Each node also has several flow pairs registered by default - see
-    // ``AbstractNode.installCoreFlows``.
-    @InitiatedBy(InitiatorFlow::class)
-    class ResponderFlow(val counterpartySession: FlowSession) : FlowLogic<Unit>() {
+    override val progressTracker: ProgressTracker = tracker()
 
-        companion object {
-            object RECEIVING_AND_SENDING_DATA : Step("Sending data between parties.")
-            object SIGNING : Step("Responding to CollectSignaturesFlow.")
-            object FINALISATION : Step("Finalising a transaction.")
+    @Suppress("RemoveExplicitTypeArguments")
+    @Suspendable
+    override fun call() {
+        // We'll be using a dummy public key for demonstration purposes.
+        // These are built in to Corda, and are generally used for writing
+        // tests.
+        val dummyPubKey: PublicKey = ALICE_PUBKEY
 
-            fun tracker() = ProgressTracker(
-                    RECEIVING_AND_SENDING_DATA,
-                    SIGNING,
-                    FINALISATION
-            )
+        /**--------------------------
+         * IDENTIFYING OTHER NODES *
+        --------------------------**/
+        // DOCSTART 18
+        progressTracker.currentStep = ID_OTHER_NODES
+        // DOCEND 18
+
+        // A transaction generally needs a notary:
+        //   - To prevent double-spends if the transaction has inputs
+        //   - To serve as a timestamping authority if the transaction has a
+        //     time-window
+        // We retrieve the notary from the network map.
+        // DOCSTART 1
+        val notaryName: CordaX500Name = CordaX500Name(
+                organisation = "Notary Service",
+                locality = "London",
+                country = "GB")
+        val specificNotary: Party = serviceHub.networkMapCache.getNotary(notaryName)!!
+        // Alternatively, we can pick an arbitrary notary from the notary
+        // list. However, it is always preferable to specify the notary
+        // explicitly, as the notary list might change when new notaries are
+        // introduced, or old ones decommissioned.
+        val firstNotary: Party = serviceHub.networkMapCache.notaryIdentities.first()
+        // DOCEND 1
+
+        // We may also need to identify a specific counterparty. We do so
+        // using the identity service.
+        // DOCSTART 2
+        val counterpartyName: CordaX500Name = CordaX500Name(
+                organisation = "NodeA",
+                locality = "London",
+                country = "GB")
+        val namedCounterparty: Party = serviceHub.identityService.wellKnownPartyFromX500Name(counterpartyName) ?:
+                throw IllegalArgumentException("Couldn't find counterparty for NodeA in identity service")
+        val keyedCounterparty: Party = serviceHub.identityService.partyFromKey(dummyPubKey) ?:
+                throw IllegalArgumentException("Couldn't find counterparty with key: $dummyPubKey in identity service")
+        // DOCEND 2
+
+        /**-----------------------------
+         * SENDING AND RECEIVING DATA *
+        -----------------------------**/
+        progressTracker.currentStep = SENDING_AND_RECEIVING_DATA
+
+        // We start by initiating a flow session with the counterparty. We
+        // will use this session to send and receive messages from the
+        // counterparty.
+        // DOCSTART initiateFlow
+        val counterpartySession: FlowSession = initiateFlow(counterparty)
+        // DOCEND initiateFlow
+
+        // We can send arbitrary data to a counterparty.
+        // If this is the first ``send``, the counterparty will either:
+        // 1. Ignore the message if they are not registered to respond
+        //    to messages from this flow.
+        // 2. Start the flow they have registered to respond to this flow,
+        //    and run the flow until the first call to ``receive``, at
+        //    which point they process the message.
+        // In other words, we are assuming that the counterparty is
+        // registered to respond to this flow, and has a corresponding
+        // ``receive`` call.
+        // DOCSTART 4
+        counterpartySession.send(Any())
+        // DOCEND 4
+
+        // We can wait to receive arbitrary data of a specific type from a
+        // counterparty. Again, this implies a corresponding ``send`` call
+        // in the counterparty's flow. A few scenarios:
+        // - We never receive a message back. In the current design, the
+        //   flow is paused until the node's owner kills the flow.
+        // - Instead of sending a message back, the counterparty throws a
+        //   ``FlowException``. This exception is propagated back to us,
+        //   and we can use the error message to establish what happened.
+        // - We receive a message back, but it's of the wrong type. In
+        //   this case, a ``FlowException`` is thrown.
+        // - We receive back a message of the correct type. All is good.
+        //
+        // Upon calling ``receive()`` (or ``sendAndReceive()``), the
+        // ``FlowLogic`` is suspended until it receives a response.
+        //
+        // We receive the data wrapped in an ``UntrustworthyData``
+        // instance. This is a reminder that the data we receive may not
+        // be what it appears to be! We must unwrap the
+        // ``UntrustworthyData`` using a lambda.
+        // DOCSTART 5
+        val packet1: UntrustworthyData<Int> = counterpartySession.receive<Int>()
+        val int: Int = packet1.unwrap { data ->
+            // Perform checking on the object received.
+            // T O D O: Check the received object.
+            // Return the object.
+            data
         }
+        // DOCEND 5
 
-        override val progressTracker: ProgressTracker = tracker()
+        // We can also use a single call to send data to a counterparty
+        // and wait to receive data of a specific type back. The type of
+        // data sent doesn't need to match the type of the data received
+        // back.
+        // DOCSTART 7
+        val packet2: UntrustworthyData<Boolean> = counterpartySession.sendAndReceive<Boolean>("You can send and receive any class!")
+        val boolean: Boolean = packet2.unwrap { data ->
+            // Perform checking on the object received.
+            // T O D O: Check the received object.
+            // Return the object.
+            data
+        }
+        // DOCEND 7
 
-        @Suspendable
-        override fun call() {
-            // The ``ResponderFlow` has all the same APIs available. It looks
-            // up network information, sends and receives data, and constructs
-            // transactions in exactly the same way.
+        // We're not limited to sending to and receiving from a single
+        // counterparty. A flow can send messages to as many parties as it
+        // likes, and each party can invoke a different response flow.
+        // DOCSTART 6
+        val regulatorSession: FlowSession = initiateFlow(regulator)
+        regulatorSession.send(Any())
+        val packet3: UntrustworthyData<Any> = regulatorSession.receive<Any>()
+        // DOCEND 6
 
-            /**-----------------------------
-             * SENDING AND RECEIVING DATA *
-            -----------------------------**/
-            progressTracker.currentStep = RECEIVING_AND_SENDING_DATA
+        /**-----------------------------------
+         * EXTRACTING STATES FROM THE VAULT *
+        -----------------------------------**/
+        progressTracker.currentStep = EXTRACTING_VAULT_STATES
 
-            // We need to respond to the messages sent by the initiator:
-            // 1. They sent us an ``Any`` instance
-            // 2. They waited to receive an ``Integer`` instance back
-            // 3. They sent a ``String`` instance and waited to receive a
-            //    ``Boolean`` instance back
-            // Our side of the flow must mirror these calls.
-            // DOCSTART 8
-            val any: Any = counterpartySession.receive<Any>().unwrap { data -> data }
-            val string: String = counterpartySession.sendAndReceive<String>(99).unwrap { data -> data }
-            counterpartySession.send(true)
-            // DOCEND 8
+        // Let's assume there are already some ``DummyState``s in our
+        // node's vault, stored there as a result of running past flows,
+        // and we want to consume them in a transaction. There are many
+        // ways to extract these states from our vault.
 
-            /**----------------------------------------
-             * RESPONDING TO COLLECT_SIGNATURES_FLOW *
-            ----------------------------------------**/
-            progressTracker.currentStep = SIGNING
+        // For example, we would extract any unconsumed ``DummyState``s
+        // from our vault as follows:
+        val criteria: VaultQueryCriteria = VaultQueryCriteria() // default is UNCONSUMED
+        val results: Page<DummyState> = serviceHub.vaultService.queryBy<DummyState>(criteria)
+        val dummyStates: List<StateAndRef<DummyState>> = results.states
 
-            // The responder will often need to respond to a call to
-            // ``CollectSignaturesFlow``. It does so my invoking its own
-            // ``SignTransactionFlow`` subclass.
-            // DOCSTART 16
-            val signTransactionFlow: SignTransactionFlow = object : SignTransactionFlow(counterpartySession) {
-                override fun checkTransaction(stx: SignedTransaction) = requireThat {
-                    // Any additional checking we see fit...
-                    val outputState = stx.tx.outputsOfType<DummyState>().single()
-                    assert(outputState.magicNumber == 777)
-                }
+        // For a full list of the available ways of extracting states from
+        // the vault, see the Vault Query docs page.
+
+        // When building a transaction, input states are passed in as
+        // ``StateRef`` instances, which pair the hash of the transaction
+        // that generated the state with the state's index in the outputs
+        // of that transaction. In practice, we'd pass the transaction hash
+        // or the ``StateRef`` as a parameter to the flow, or extract the
+        // ``StateRef`` from our vault.
+        // DOCSTART 20
+        val ourStateRef: StateRef = StateRef(SecureHash.sha256("DummyTransactionHash"), 0)
+        // DOCEND 20
+        // A ``StateAndRef`` pairs a ``StateRef`` with the state it points to.
+        // DOCSTART 21
+        val ourStateAndRef: StateAndRef<DummyState> = serviceHub.toStateAndRef<DummyState>(ourStateRef)
+        // DOCEND 21
+
+        /**-----------------------------------------
+         * GATHERING OTHER TRANSACTION COMPONENTS *
+        -----------------------------------------**/
+        progressTracker.currentStep = OTHER_TX_COMPONENTS
+
+        // Output states are constructed from scratch.
+        // DOCSTART 22
+        val ourOutputState: DummyState = DummyState()
+        // DOCEND 22
+        // Or as copies of other states with some properties changed.
+        // DOCSTART 23
+        val ourOtherOutputState: DummyState = ourOutputState.copy(magicNumber = 77)
+        // DOCEND 23
+
+        // We then need to pair our output state with a contract.
+        // DOCSTART 47
+        val contractName: String = "net.corda.testing.contracts.DummyContract"
+        val ourOutput: StateAndContract = StateAndContract(ourOutputState, contractName)
+        // DOCEND 47
+
+        // Commands pair a ``CommandData`` instance with a list of
+        // public keys. To be valid, the transaction requires a signature
+        // matching every public key in all of the transaction's commands.
+        // DOCSTART 24
+        val commandData: DummyContract.Commands.Create = DummyContract.Commands.Create()
+        val ourPubKey: PublicKey = serviceHub.myInfo.legalIdentitiesAndCerts.first().owningKey
+        val counterpartyPubKey: PublicKey = counterparty.owningKey
+        val requiredSigners: List<PublicKey> = listOf(ourPubKey, counterpartyPubKey)
+        val ourCommand: Command<DummyContract.Commands.Create> = Command(commandData, requiredSigners)
+        // DOCEND 24
+
+        // ``CommandData`` can either be:
+        // 1. Of type ``TypeOnlyCommandData``, in which case it only
+        //    serves to attach signers to the transaction and possibly
+        //    fork the contract's verification logic.
+        val typeOnlyCommandData: TypeOnlyCommandData = DummyContract.Commands.Create()
+        // 2. Include additional data which can be used by the contract
+        //    during verification, alongside fulfilling the roles above.
+        val commandDataWithData: CommandData = Cash.Commands.Issue()
+
+        // Attachments are identified by their hash.
+        // The attachment with the corresponding hash must have been
+        // uploaded ahead of time via the node's RPC interface.
+        // DOCSTART 25
+        val ourAttachment: SecureHash = SecureHash.sha256("DummyAttachment")
+        // DOCEND 25
+
+        // Time windows can have a start and end time, or be open at either end.
+        // DOCSTART 26
+        val ourTimeWindow: TimeWindow = TimeWindow.between(Instant.MIN, Instant.MAX)
+        val ourAfter: TimeWindow = TimeWindow.fromOnly(Instant.MIN)
+        val ourBefore: TimeWindow = TimeWindow.untilOnly(Instant.MAX)
+        // DOCEND 26
+
+        // We can also define a time window as an ``Instant`` +/- a time
+        // tolerance (e.g. 30 seconds):
+        // DOCSTART 42
+        val ourTimeWindow2: TimeWindow = TimeWindow.withTolerance(serviceHub.clock.instant(), 30.seconds)
+        // DOCEND 42
+        // Or as a start-time plus a duration:
+        // DOCSTART 43
+        val ourTimeWindow3: TimeWindow = TimeWindow.fromStartAndDuration(serviceHub.clock.instant(), 30.seconds)
+        // DOCEND 43
+
+        /**-----------------------
+         * TRANSACTION BUILDING *
+        -----------------------**/
+        progressTracker.currentStep = TX_BUILDING
+
+        // If our transaction has input states or a time-window, we must instantiate it with a
+        // notary.
+        // DOCSTART 19
+        val txBuilder: TransactionBuilder = TransactionBuilder(specificNotary)
+        // DOCEND 19
+
+        // Otherwise, we can choose to instantiate it without one:
+        // DOCSTART 46
+        val txBuilderNoNotary: TransactionBuilder = TransactionBuilder()
+        // DOCEND 46
+
+        // We add items to the transaction builder using ``TransactionBuilder.withItems``:
+        // DOCSTART 27
+        txBuilder.withItems(
+                // Inputs, as ``StateAndRef``s that reference the outputs of previous transactions
+                ourStateAndRef,
+                // Outputs, as ``StateAndContract``s
+                ourOutput,
+                // Commands, as ``Command``s
+                ourCommand,
+                // Attachments, as ``SecureHash``es
+                ourAttachment,
+                // A time-window, as ``TimeWindow``
+                ourTimeWindow
+        )
+        // DOCEND 27
+
+        // We can also add items using methods for the individual components.
+
+        // The individual methods for adding input states and attachments:
+        // DOCSTART 28
+        txBuilder.addInputState(ourStateAndRef)
+        txBuilder.addAttachment(ourAttachment)
+        // DOCEND 28
+
+        // An output state can be added as a ``ContractState``, contract class name and notary.
+        // DOCSTART 49
+        txBuilder.addOutputState(ourOutputState, DummyContract.PROGRAM_ID, specificNotary)
+        // DOCEND 49
+        // We can also leave the notary field blank, in which case the transaction's default
+        // notary is used.
+        // DOCSTART 50
+        txBuilder.addOutputState(ourOutputState, DummyContract.PROGRAM_ID)
+        // DOCEND 50
+        // Or we can add the output state as a ``TransactionState``, which already specifies
+        // the output's contract and notary.
+        // DOCSTART 51
+        val txState: TransactionState<DummyState> = TransactionState(ourOutputState, DummyContract.PROGRAM_ID, specificNotary)
+        // DOCEND 51
+
+        // Commands can be added as ``Command``s.
+        // DOCSTART 52
+        txBuilder.addCommand(ourCommand)
+        // DOCEND 52
+        // Or as ``CommandData`` and a ``vararg PublicKey``.
+        // DOCSTART 53
+        txBuilder.addCommand(commandData, ourPubKey, counterpartyPubKey)
+        // DOCEND 53
+
+        // We can set a time-window directly.
+        // DOCSTART 44
+        txBuilder.setTimeWindow(ourTimeWindow)
+        // DOCEND 44
+        // Or as a start time plus a duration (e.g. 45 seconds).
+        // DOCSTART 45
+        txBuilder.setTimeWindow(serviceHub.clock.instant(), 45.seconds)
+        // DOCEND 45
+
+        /**----------------------
+         * TRANSACTION SIGNING *
+        ----------------------**/
+        progressTracker.currentStep = TX_SIGNING
+
+        // We finalise the transaction by signing it, converting it into a
+        // ``SignedTransaction``.
+        // DOCSTART 29
+        val onceSignedTx: SignedTransaction = serviceHub.signInitialTransaction(txBuilder)
+        // DOCEND 29
+        // We can also sign the transaction using a different public key:
+        // DOCSTART 30
+        val otherKey: PublicKey = serviceHub.keyManagementService.freshKey()
+        val onceSignedTx2: SignedTransaction = serviceHub.signInitialTransaction(txBuilder, otherKey)
+        // DOCEND 30
+
+        // If instead this was a ``SignedTransaction`` that we'd received
+        // from a counterparty and we needed to sign it, we would add our
+        // signature using:
+        // DOCSTART 38
+        val twiceSignedTx: SignedTransaction = serviceHub.addSignature(onceSignedTx)
+        // DOCEND 38
+        // Or, if we wanted to use a different public key:
+        val otherKey2: PublicKey = serviceHub.keyManagementService.freshKey()
+        // DOCSTART 39
+        val twiceSignedTx2: SignedTransaction = serviceHub.addSignature(onceSignedTx, otherKey2)
+        // DOCEND 39
+
+        // We can also generate a signature over the transaction without
+        // adding it to the transaction itself. We may do this when
+        // sending just the signature in a flow instead of returning the
+        // entire transaction with our signature. This way, the receiving
+        // node does not need to check we haven't changed anything in the
+        // transaction.
+        // DOCSTART 40
+        val sig: TransactionSignature = serviceHub.createSignature(onceSignedTx)
+        // DOCEND 40
+        // And again, if we wanted to use a different public key:
+        // DOCSTART 41
+        val sig2: TransactionSignature = serviceHub.createSignature(onceSignedTx, otherKey2)
+        // DOCEND 41
+
+        // In practice, however, the process of gathering every signature
+        // but the first can be automated using ``CollectSignaturesFlow``.
+        // See the "Gathering Signatures" section below.
+
+        /**---------------------------
+         * TRANSACTION VERIFICATION *
+        ---------------------------**/
+        progressTracker.currentStep = TX_VERIFICATION
+
+        // Verifying a transaction will also verify every transaction in
+        // the transaction's dependency chain, which will require
+        // transaction data access on counterparty's node. The
+        // ``SendTransactionFlow`` can be used to automate the sending and
+        // data vending process. The ``SendTransactionFlow`` will listen
+        // for data request until the transaction is resolved and verified
+        // on the other side:
+        // DOCSTART 12
+        subFlow(SendTransactionFlow(counterpartySession, twiceSignedTx))
+
+        // Optional request verification to further restrict data access.
+        subFlow(object : SendTransactionFlow(counterpartySession, twiceSignedTx) {
+            override fun verifyDataRequest(dataRequest: FetchDataFlow.Request.Data) {
+                // Extra request verification.
             }
+        })
+        // DOCEND 12
 
-            subFlow(signTransactionFlow)
-            // DOCEND 16
+        // We can receive the transaction using ``ReceiveTransactionFlow``,
+        // which will automatically download all the dependencies and verify
+        // the transaction
+        // DOCSTART 13
+        val verifiedTransaction = subFlow(ReceiveTransactionFlow(counterpartySession))
+        // DOCEND 13
 
-            /**-----------------------------
-             * FINALISING THE TRANSACTION *
-            -----------------------------**/
-            progressTracker.currentStep = FINALISATION
+        // We can also send and receive a `StateAndRef` dependency chain
+        // and automatically resolve its dependencies.
+        // DOCSTART 14
+        subFlow(SendStateAndRefFlow(counterpartySession, dummyStates))
 
-            // Nothing to do here! As long as some other party calls
-            // ``FinalityFlow``, the recording of the transaction on our node
-            // we be handled automatically.
+        // On the receive side ...
+        val resolvedStateAndRef = subFlow(ReceiveStateAndRefFlow<DummyState>(counterpartySession))
+        // DOCEND 14
+
+        // We can now verify the transaction to ensure that it satisfies
+        // the contracts of all the transaction's input and output states.
+        // DOCSTART 33
+        twiceSignedTx.verify(serviceHub)
+        // DOCEND 33
+
+        // We'll often want to perform our own additional verification
+        // too. Just because a transaction is valid based on the contract
+        // rules and requires our signature doesn't mean we have to
+        // sign it! We need to make sure the transaction represents an
+        // agreement we actually want to enter into.
+
+        // To do this, we need to convert our ``SignedTransaction``
+        // into a ``LedgerTransaction``. This will use our ServiceHub
+        // to resolve the transaction's inputs and attachments into
+        // actual objects, rather than just references.
+        // DOCSTART 32
+        val ledgerTx: LedgerTransaction = twiceSignedTx.toLedgerTransaction(serviceHub)
+        // DOCEND 32
+
+        // We can now perform our additional verification.
+        // DOCSTART 34
+        val outputState: DummyState = ledgerTx.outputsOfType<DummyState>().single()
+        if (outputState.magicNumber == 777) {
+            // ``FlowException`` is a special exception type. It will be
+            // propagated back to any counterparty flows waiting for a
+            // message from this flow, notifying them that the flow has
+            // failed.
+            throw FlowException("We expected a magic number of 777.")
         }
+        // DOCEND 34
+
+        // Of course, if you are not a required signer on the transaction,
+        // you have no power to decide whether it is valid or not. If it
+        // requires signatures from all the required signers and is
+        // contractually valid, it's a valid ledger update.
+
+        /**-----------------------
+         * GATHERING SIGNATURES *
+        -----------------------**/
+        progressTracker.currentStep = SIGS_GATHERING
+
+        // The list of parties who need to sign a transaction is dictated
+        // by the transaction's commands. Once we've signed a transaction
+        // ourselves, we can automatically gather the signatures of the
+        // other required signers using ``CollectSignaturesFlow``.
+        // The responder flow will need to call ``SignTransactionFlow``.
+        // DOCSTART 15
+        val fullySignedTx: SignedTransaction = subFlow(CollectSignaturesFlow(twiceSignedTx, setOf(counterpartySession, regulatorSession), SIGS_GATHERING.childProgressTracker()))
+        // DOCEND 15
+
+        /**-----------------------
+         * VERIFYING SIGNATURES *
+        -----------------------**/
+        progressTracker.currentStep = VERIFYING_SIGS
+
+        // We can verify that a transaction has all the required
+        // signatures, and that they're all valid, by running:
+        // DOCSTART 35
+        fullySignedTx.verifyRequiredSignatures()
+        // DOCEND 35
+
+        // If the transaction is only partially signed, we have to pass in
+        // a list of the public keys corresponding to the missing
+        // signatures, explicitly telling the system not to check them.
+        // DOCSTART 36
+        onceSignedTx.verifySignaturesExcept(counterpartyPubKey)
+        // DOCEND 36
+
+        // We can also choose to only check the signatures that are
+        // present. BE VERY CAREFUL - this function provides no guarantees
+        // that the signatures are correct, or that none are missing.
+        // DOCSTART 37
+        twiceSignedTx.checkSignaturesAreValid()
+        // DOCEND 37
+
+        /**-----------------------------
+         * FINALISING THE TRANSACTION *
+        -----------------------------**/
+        progressTracker.currentStep = FINALISATION
+
+        // We notarise the transaction and get it recorded in the vault of
+        // the participants of all the transaction's states.
+        // DOCSTART 9
+        val notarisedTx1: SignedTransaction = subFlow(FinalityFlow(fullySignedTx, FINALISATION.childProgressTracker()))
+        // DOCEND 9
+        // We can also choose to send it to additional parties who aren't one
+        // of the state's participants.
+        // DOCSTART 10
+        val additionalParties: Set<Party> = setOf(regulator)
+        val notarisedTx2: SignedTransaction = subFlow(FinalityFlow(fullySignedTx, additionalParties, FINALISATION.childProgressTracker()))
+        // DOCEND 10
+
+        // DOCSTART FlowSession porting
+        send(regulator, Any()) // Old API
+        // becomes
+        val session = initiateFlow(regulator)
+        session.send(Any())
+        // DOCEND FlowSession porting
+    }
+}
+
+// ``ResponderFlow`` is our second flow, and will communicate with
+// ``InitiatorFlow``.
+// We mark ``ResponderFlow`` as an ``InitiatedByFlow``, meaning that it
+// can only be started in response to a message from its initiating flow.
+// That's ``InitiatorFlow`` in this case.
+// Each node also has several flow pairs registered by default - see
+// ``AbstractNode.installCoreFlows``.
+@InitiatedBy(InitiatorFlow::class)
+class ResponderFlow(val counterpartySession: FlowSession) : FlowLogic<Unit>() {
+
+    companion object {
+        object RECEIVING_AND_SENDING_DATA : Step("Sending data between parties.")
+        object SIGNING : Step("Responding to CollectSignaturesFlow.")
+        object FINALISATION : Step("Finalising a transaction.")
+
+        fun tracker() = ProgressTracker(
+                RECEIVING_AND_SENDING_DATA,
+                SIGNING,
+                FINALISATION
+        )
+    }
+
+    override val progressTracker: ProgressTracker = tracker()
+
+    @Suspendable
+    override fun call() {
+        // The ``ResponderFlow` has all the same APIs available. It looks
+        // up network information, sends and receives data, and constructs
+        // transactions in exactly the same way.
+
+        /**-----------------------------
+         * SENDING AND RECEIVING DATA *
+        -----------------------------**/
+        progressTracker.currentStep = RECEIVING_AND_SENDING_DATA
+
+        // We need to respond to the messages sent by the initiator:
+        // 1. They sent us an ``Any`` instance
+        // 2. They waited to receive an ``Integer`` instance back
+        // 3. They sent a ``String`` instance and waited to receive a
+        //    ``Boolean`` instance back
+        // Our side of the flow must mirror these calls.
+        // DOCSTART 8
+        val any: Any = counterpartySession.receive<Any>().unwrap { data -> data }
+        val string: String = counterpartySession.sendAndReceive<String>(99).unwrap { data -> data }
+        counterpartySession.send(true)
+        // DOCEND 8
+
+        /**----------------------------------------
+         * RESPONDING TO COLLECT_SIGNATURES_FLOW *
+        ----------------------------------------**/
+        progressTracker.currentStep = SIGNING
+
+        // The responder will often need to respond to a call to
+        // ``CollectSignaturesFlow``. It does so my invoking its own
+        // ``SignTransactionFlow`` subclass.
+        // DOCSTART 16
+        val signTransactionFlow: SignTransactionFlow = object : SignTransactionFlow(counterpartySession) {
+            override fun checkTransaction(stx: SignedTransaction) = requireThat {
+                // Any additional checking we see fit...
+                val outputState = stx.tx.outputsOfType<DummyState>().single()
+                assert(outputState.magicNumber == 777)
+            }
+        }
+
+        subFlow(signTransactionFlow)
+        // DOCEND 16
+
+        /**-----------------------------
+         * FINALISING THE TRANSACTION *
+        -----------------------------**/
+        progressTracker.currentStep = FINALISATION
+
+        // Nothing to do here! As long as some other party calls
+        // ``FinalityFlow``, the recording of the transaction on our node
+        // we be handled automatically.
     }
 }
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
new file mode 100644
index 0000000000..8389e73a99
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
@@ -0,0 +1,136 @@
+package net.corda.docs.tutorial.contract
+
+import net.corda.core.contracts.*
+import net.corda.core.crypto.NullKeys
+import net.corda.core.identity.AbstractParty
+import net.corda.core.identity.AnonymousParty
+import net.corda.core.identity.Party
+import net.corda.core.node.ServiceHub
+import net.corda.core.transactions.LedgerTransaction
+import net.corda.core.transactions.TransactionBuilder
+import net.corda.finance.contracts.asset.Cash
+import net.corda.finance.utils.sumCashBy
+import net.corda.testing.chooseIdentityAndCert
+import java.time.Instant
+import java.util.*
+
+class CommercialPaper : Contract {
+    // DOCSTART 8
+    companion object {
+        const val CP_PROGRAM_ID: ContractClassName = "net.corda.finance.contracts.CommercialPaper"
+    }
+    // DOCEND 8
+
+    // DOCSTART 3
+    override fun verify(tx: LedgerTransaction) {
+        // Group by everything except owner: any modification to the CP at all is considered changing it fundamentally.
+        val groups = tx.groupStates(State::withoutOwner)
+
+        // There are two possible things that can be done with this CP. The first is trading it. The second is redeeming
+        // it for cash on or after the maturity date.
+        val command = tx.commands.requireSingleCommand<CommercialPaper.Commands>()
+        // DOCEND 3
+
+        // DOCSTART 4
+        val timeWindow: TimeWindow? = tx.timeWindow
+
+        for ((inputs, outputs, _) in groups) {
+            when (command.value) {
+                is Commands.Move -> {
+                    val input = inputs.single()
+                    requireThat {
+                        "the transaction is signed by the owner of the CP" using (input.owner.owningKey in command.signers)
+                        "the state is propagated" using (outputs.size == 1)
+                        // Don't need to check anything else, as if outputs.size == 1 then the output is equal to
+                        // the input ignoring the owner field due to the grouping.
+                    }
+                }
+
+                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 time = timeWindow?.fromTime ?: throw IllegalArgumentException("Redemptions must be timestamped")
+                    requireThat {
+                        "the paper must have matured" using (time >= input.maturityDate)
+                        "the received amount equals the face value" using (received == input.faceValue)
+                        "the paper must be destroyed" using outputs.isEmpty()
+                        "the transaction is signed by the owner of the CP" using (input.owner.owningKey in command.signers)
+                    }
+                }
+
+                is Commands.Issue -> {
+                    val output = outputs.single()
+                    val time = timeWindow?.untilTime ?: throw IllegalArgumentException("Issuances must be timestamped")
+                    requireThat {
+                        // Don't allow people to issue commercial paper under other entities identities.
+                        "output states are issued by a command signer" using (output.issuance.party.owningKey in command.signers)
+                        "output values sum to more than the inputs" using (output.faceValue.quantity > 0)
+                        "the maturity date is not in the past" using (time < output.maturityDate)
+                        // Don't allow an existing CP state to be replaced by this issuance.
+                        "can't reissue an existing state" using inputs.isEmpty()
+                    }
+                }
+
+                else -> throw IllegalArgumentException("Unrecognised command")
+            }
+        }
+        // DOCEND 4
+    }
+
+    // DOCSTART 2
+    interface Commands : CommandData {
+        class Move : TypeOnlyCommandData(), Commands
+        class Redeem : TypeOnlyCommandData(), Commands
+        class Issue : TypeOnlyCommandData(), Commands
+    }
+    // DOCEND 2
+
+    // DOCSTART 5
+    fun generateIssue(issuance: PartyAndReference, faceValue: Amount<Issued<Currency>>, maturityDate: Instant,
+                      notary: Party): TransactionBuilder {
+        val state = State(issuance, issuance.party, faceValue, maturityDate)
+        val stateAndContract = StateAndContract(state, CP_PROGRAM_ID)
+        return TransactionBuilder(notary = notary).withItems(stateAndContract, Command(Commands.Issue(), issuance.party.owningKey))
+    }
+    // DOCEND 5
+
+    // DOCSTART 6
+    fun generateMove(tx: TransactionBuilder, paper: StateAndRef<State>, newOwner: AbstractParty) {
+        tx.addInputState(paper)
+        val outputState = paper.state.data.withNewOwner(newOwner).ownableState
+        tx.addOutputState(outputState, CP_PROGRAM_ID)
+        tx.addCommand(Command(Commands.Move(), paper.state.data.owner.owningKey))
+    }
+    // DOCEND 6
+
+    // DOCSTART 7
+    @Throws(InsufficientBalanceException::class)
+    fun generateRedeem(tx: TransactionBuilder, paper: StateAndRef<State>, services: ServiceHub) {
+        // Add the cash movement using the states in our vault.
+        Cash.generateSpend(
+                services = services,
+                tx = tx,
+                amount = paper.state.data.faceValue.withoutIssuer(),
+                ourIdentity = services.myInfo.chooseIdentityAndCert(),
+                to = paper.state.data.owner
+        )
+        tx.addInputState(paper)
+        tx.addCommand(Command(Commands.Redeem(), paper.state.data.owner.owningKey))
+    }
+    // DOCEND 7
+}
+
+// DOCSTART 1
+data class State(
+        val issuance: PartyAndReference,
+        override val owner: AbstractParty,
+        val faceValue: Amount<Issued<Currency>>,
+        val maturityDate: Instant
+) : OwnableState {
+    override val participants = listOf(owner)
+
+    fun withoutOwner() = copy(owner = AnonymousParty(NullKeys.NullPublicKey))
+    override fun withNewOwner(newOwner: AbstractParty) = CommandAndState(CommercialPaper.Commands.Move(), copy(owner = newOwner))
+}
+// DOCEND 1
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/flowstatemachines/TutorialFlowStateMachines.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/flowstatemachines/TutorialFlowStateMachines.kt
new file mode 100644
index 0000000000..0131077a8f
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/flowstatemachines/TutorialFlowStateMachines.kt
@@ -0,0 +1,64 @@
+package net.corda.docs.tutorial.flowstatemachines
+
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.contracts.Amount
+import net.corda.core.contracts.OwnableState
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.flows.FlowException
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.FlowSession
+import net.corda.core.identity.Party
+import net.corda.core.identity.PartyAndCertificate
+import net.corda.core.serialization.CordaSerializable
+import net.corda.core.transactions.SignedTransaction
+import net.corda.core.utilities.ProgressTracker
+import net.corda.finance.flows.TwoPartyTradeFlow
+import java.util.*
+
+// DOCSTART 1
+object TwoPartyTradeFlow {
+    class UnacceptablePriceException(givenPrice: Amount<Currency>) : FlowException("Unacceptable price: $givenPrice")
+    class AssetMismatchException(val expectedTypeName: String, val typeName: String) : FlowException() {
+        override fun toString() = "The submitted asset didn't match the expected type: $expectedTypeName vs $typeName"
+    }
+
+    /**
+     * This object is serialised to the network and is the first flow message the seller sends to the buyer.
+     *
+     * @param payToIdentity anonymous identity of the seller, for payment to be sent to.
+     */
+    @CordaSerializable
+    data class SellerTradeInfo(
+            val price: Amount<Currency>,
+            val payToIdentity: PartyAndCertificate
+    )
+
+    open class Seller(private val otherSideSession: FlowSession,
+                      private val assetToSell: StateAndRef<OwnableState>,
+                      private val price: Amount<Currency>,
+                      private val myParty: PartyAndCertificate,
+                      override val progressTracker: ProgressTracker = TwoPartyTradeFlow.Seller.tracker()) : FlowLogic<SignedTransaction>() {
+
+        companion object {
+            fun tracker() = ProgressTracker()
+        }
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            TODO()
+        }
+    }
+
+    open class Buyer(private val sellerSession: FlowSession,
+                     private val notary: Party,
+                     private val acceptablePrice: Amount<Currency>,
+                     private val typeToBuy: Class<out OwnableState>,
+                     private val anonymous: Boolean) : FlowLogic<SignedTransaction>() {
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            TODO()
+        }
+    }
+}
+// DOCEND 1
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt
new file mode 100644
index 0000000000..c560c4f3f4
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt
@@ -0,0 +1,45 @@
+package net.corda.docs.tutorial.tearoffs
+
+import net.corda.core.contracts.Command
+import net.corda.core.contracts.StateRef
+import net.corda.core.contracts.TimeWindow
+import net.corda.core.crypto.MerkleTreeException
+import net.corda.core.transactions.FilteredTransaction
+import net.corda.core.transactions.FilteredTransactionVerificationException
+import net.corda.core.transactions.SignedTransaction
+import net.corda.finance.contracts.Fix
+import net.corda.testing.ALICE
+import java.util.function.Predicate
+
+fun main(args: Array<String>) {
+    // Typealias to make the example coherent.
+    val oracle = ALICE
+    val stx = Any() as SignedTransaction
+
+    // DOCSTART 1
+    val filtering = Predicate<Any> {
+        when (it) {
+            is Command<*> -> oracle.owningKey in it.signers && it.value is Fix
+            else -> false
+        }
+    }
+    // DOCEND 1
+
+    // DOCSTART 2
+    val ftx: FilteredTransaction = stx.buildFilteredTransaction(filtering)
+    // DOCEND 2
+
+    // DOCSTART 3
+    // Direct access to included commands, inputs, outputs, attachments etc.
+    val cmds: List<Command<*>> = ftx.commands
+    val ins: List<StateRef> = ftx.inputs
+    val timeWindow: TimeWindow? = ftx.timeWindow
+    // ...
+    // DOCEND 3
+
+    try {
+        ftx.verify()
+    } catch (e: FilteredTransactionVerificationException) {
+        throw MerkleTreeException("Rate Fix Oracle: Couldn't verify partial Merkle tree.")
+    }
+}
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
new file mode 100644
index 0000000000..2b25fe726e
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
@@ -0,0 +1,247 @@
+package net.corda.docs.tutorial.testdsl
+
+import net.corda.core.utilities.days
+import net.corda.finance.DOLLARS
+import net.corda.finance.`issued by`
+import net.corda.finance.contracts.CP_PROGRAM_ID
+import net.corda.finance.contracts.CommercialPaper
+import net.corda.finance.contracts.ICommercialPaperState
+import net.corda.finance.contracts.asset.CASH
+import net.corda.finance.contracts.asset.Cash
+import net.corda.finance.contracts.asset.`issued by`
+import net.corda.finance.contracts.asset.`owned by`
+import net.corda.testing.*
+import org.junit.Test
+
+class CommercialPaperTest {
+    // DOCSTART 1
+    fun getPaper(): ICommercialPaperState = CommercialPaper.State(
+            issuance = MEGA_CORP.ref(123),
+            owner = MEGA_CORP,
+            faceValue = 1000.DOLLARS `issued by` MEGA_CORP.ref(123),
+            maturityDate = TEST_TX_TIME + 7.days
+    )
+    // DOCEND 1
+
+    // DOCSTART 2
+    @Test
+    fun simpleCP() {
+        val inState = getPaper()
+        ledger {
+            transaction {
+                attachments(CP_PROGRAM_ID)
+                input(CP_PROGRAM_ID) { inState }
+                this.verifies()
+            }
+        }
+    }
+    // DOCEND 2
+
+    // DOCSTART 3
+    @Test
+    fun simpleCPMove() {
+        val inState = getPaper()
+        ledger {
+            transaction {
+                input(CP_PROGRAM_ID) { inState }
+                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
+                attachments(CP_PROGRAM_ID)
+                this.verifies()
+            }
+        }
+    }
+    // DOCEND 3
+
+    // DOCSTART 4
+    @Test
+    fun simpleCPMoveFails() {
+        val inState = getPaper()
+        ledger {
+            transaction {
+                input(CP_PROGRAM_ID) { inState }
+                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
+                attachments(CP_PROGRAM_ID)
+                this `fails with` "the state is propagated"
+            }
+        }
+    }
+    // DOCEND 4
+
+    // DOCSTART 5
+    @Test
+    fun simpleCPMoveSuccess() {
+        val inState = getPaper()
+        ledger {
+            transaction {
+                input(CP_PROGRAM_ID) { inState }
+                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
+                attachments(CP_PROGRAM_ID)
+                this `fails with` "the state is propagated"
+                output(CP_PROGRAM_ID, "alice's paper") { inState.withOwner(ALICE) }
+                this.verifies()
+            }
+        }
+    }
+    // DOCEND 5
+
+    // DOCSTART 6
+    @Test
+    fun `simple issuance with tweak`() {
+        ledger {
+            transaction {
+                output(CP_PROGRAM_ID, "paper") { getPaper() } // Some CP is issued onto the ledger by MegaCorp.
+                attachments(CP_PROGRAM_ID)
+                tweak {
+                    // The wrong pubkey.
+                    command(BIG_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
+                    timeWindow(TEST_TX_TIME)
+                    this `fails with` "output states are issued by a command signer"
+                }
+                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
+                timeWindow(TEST_TX_TIME)
+                this.verifies()
+            }
+        }
+    }
+    // DOCEND 6
+
+    // DOCSTART 7
+    @Test
+    fun `simple issuance with tweak and top level transaction`() {
+        transaction {
+            output(CP_PROGRAM_ID, "paper") { getPaper() } // Some CP is issued onto the ledger by MegaCorp.
+            attachments(CP_PROGRAM_ID)
+            tweak {
+                // The wrong pubkey.
+                command(BIG_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
+                timeWindow(TEST_TX_TIME)
+                this `fails with` "output states are issued by a command signer"
+            }
+            command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
+            timeWindow(TEST_TX_TIME)
+            this.verifies()
+        }
+    }
+    // DOCEND 7
+
+    // DOCSTART 8
+    @Test
+    fun `chain commercial paper`() {
+        val issuer = MEGA_CORP.ref(123)
+
+        ledger {
+            unverifiedTransaction {
+                attachments(Cash.PROGRAM_ID)
+                output(Cash.PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE)
+            }
+
+            // Some CP is issued onto the ledger by MegaCorp.
+            transaction("Issuance") {
+                output(CP_PROGRAM_ID, "paper") { getPaper() }
+                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
+                attachments(CP_PROGRAM_ID)
+                timeWindow(TEST_TX_TIME)
+                this.verifies()
+            }
+
+
+            transaction("Trade") {
+                input("paper")
+                input("alice's $900")
+                output(Cash.PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP }
+                output(CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>().withOwner(ALICE) }
+                command(ALICE_PUBKEY) { Cash.Commands.Move() }
+                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
+                this.verifies()
+            }
+        }
+    }
+    // DOCEND 8
+
+    // DOCSTART 9
+    @Test
+    fun `chain commercial paper double spend`() {
+        val issuer = MEGA_CORP.ref(123)
+        ledger {
+            unverifiedTransaction {
+                attachments(Cash.PROGRAM_ID)
+                output(Cash.PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE)
+            }
+
+            // Some CP is issued onto the ledger by MegaCorp.
+            transaction("Issuance") {
+                output(CP_PROGRAM_ID, "paper") { getPaper() }
+                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
+                attachments(CP_PROGRAM_ID)
+                timeWindow(TEST_TX_TIME)
+                this.verifies()
+            }
+
+            transaction("Trade") {
+                input("paper")
+                input("alice's $900")
+                output(Cash.PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP }
+                output(CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>().withOwner(ALICE) }
+                command(ALICE_PUBKEY) { Cash.Commands.Move() }
+                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
+                this.verifies()
+            }
+
+            transaction {
+                input("paper")
+                // We moved a paper to another pubkey.
+                output(CP_PROGRAM_ID, "bob's paper") { "paper".output<ICommercialPaperState>().withOwner(BOB) }
+                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
+                this.verifies()
+            }
+
+            this.fails()
+        }
+    }
+    // DOCEND 9
+
+    // DOCSTART 10
+    @Test
+    fun `chain commercial tweak`() {
+        val issuer = MEGA_CORP.ref(123)
+        ledger {
+            unverifiedTransaction {
+                attachments(Cash.PROGRAM_ID)
+                output(Cash.PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE)
+            }
+
+            // Some CP is issued onto the ledger by MegaCorp.
+            transaction("Issuance") {
+                output(CP_PROGRAM_ID, "paper") { getPaper() }
+                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
+                attachments(CP_PROGRAM_ID)
+                timeWindow(TEST_TX_TIME)
+                this.verifies()
+            }
+
+            transaction("Trade") {
+                input("paper")
+                input("alice's $900")
+                output(Cash.PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP }
+                output(CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>().withOwner(ALICE) }
+                command(ALICE_PUBKEY) { Cash.Commands.Move() }
+                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
+                this.verifies()
+            }
+
+            tweak {
+                transaction {
+                    input("paper")
+                    // We moved a paper to another pubkey.
+                    output(CP_PROGRAM_ID, "bob's paper") { "paper".output<ICommercialPaperState>().withOwner(BOB) }
+                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
+                    this.verifies()
+                }
+                this.fails()
+            }
+
+            this.verifies()
+        }
+    }
+    // DOCEND 10
+}
\ No newline at end of file
diff --git a/docs/source/flow-state-machines.rst b/docs/source/flow-state-machines.rst
index a125c6c221..bc7e484ae1 100644
--- a/docs/source/flow-state-machines.rst
+++ b/docs/source/flow-state-machines.rst
@@ -86,13 +86,14 @@ Our flow has two parties (B and S for buyer and seller) and will proceed as foll
 
 1. S sends a ``StateAndRef`` pointing to the state they want to sell to B, along with info about the price they require
    B to pay.
-2. B sends to S a ``SignedTransaction`` that includes the state as input, B's cash as input, the state with the new
-   owner key as output, and any change cash as output. It contains a single signature from B but isn't valid because
-   it lacks a signature from S authorising movement of the asset.
+2. B sends to S a ``SignedTransaction`` that includes two inputs (the state owned by S, and cash owned by B) and three
+   outputs (the state now owned by B, the cash now owned by S, and any change cash still owned by B). The
+   ``SignedTransaction`` has a single signature from B but isn't valid because it lacks a signature from S authorising
+   movement of the asset.
 3. S signs the transaction and sends it back to B.
-4. B *finalises* the transaction by sending it to the notary who checks the transaction for validity,
-   recording the transaction in B's local vault, and then sending it on to S who also checks it and commits
-   the transaction to S's local vault.
+4. B *finalises* the transaction by sending it to the notary who checks the transaction for validity, recording the
+   transaction in B's local vault, and then sending it on to S who also checks it and commits the transaction to S's
+   local vault.
 
 You can find the implementation of this flow in the file ``finance/src/main/kotlin/net/corda/finance/TwoPartyTradeFlow.kt``.
 
@@ -109,64 +110,31 @@ each side.
 
 .. container:: codeset
 
-   .. sourcecode:: kotlin
-
-      object TwoPartyTradeFlow {
-          class UnacceptablePriceException(val givenPrice: Amount<Currency>) : FlowException("Unacceptable price: $givenPrice")
-          class AssetMismatchException(val expectedTypeName: String, val typeName: String) : FlowException() {
-              override fun toString() = "The submitted asset didn't match the expected type: $expectedTypeName vs $typeName"
-          }
-
-          // This object is serialised to the network and is the first flow message the seller sends to the buyer.
-          @CordaSerializable
-          data class SellerTradeInfo(
-                  val assetForSale: StateAndRef<OwnableState>,
-                  val price: Amount<Currency>,
-                  val sellerOwnerKey: PublicKey
-          )
-
-          open class Seller(val otherParty: Party,
-                            val notaryNode: NodeInfo,
-                            val assetToSell: StateAndRef<OwnableState>,
-                            val price: Amount<Currency>,
-                            val myKey: PublicKey,
-                            override val progressTracker: ProgressTracker = Seller.tracker()) : FlowLogic<SignedTransaction>() {
-              @Suspendable
-              override fun call(): SignedTransaction {
-                  TODO()
-              }
-          }
-
-          open class Buyer(val otherParty: Party,
-                           val notary: Party,
-                           val acceptablePrice: Amount<Currency>,
-                           val typeToBuy: Class<out OwnableState>) : FlowLogic<SignedTransaction>() {
-              @Suspendable
-              override fun call(): SignedTransaction {
-                  TODO()
-              }
-          }
-      }
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/flowstatemachines/TutorialFlowStateMachines.kt
+        :language: kotlin
+        :start-after: DOCSTART 1
+        :end-before: DOCEND 1
 
 This code defines several classes nested inside the main ``TwoPartyTradeFlow`` singleton. Some of the classes are
 simply flow messages or exceptions. The other two represent the buyer and seller side of the flow.
 
 Going through the data needed to become a seller, we have:
 
-- ``otherParty: Party`` - the party with which you are trading.
-- ``notaryNode: NodeInfo`` - the entry in the network map for the chosen notary. See ":doc:`key-concepts-notaries`" for more
-  information on notaries.
-- ``assetToSell: StateAndRef<OwnableState>`` - a pointer to the ledger entry that represents the thing being sold.
-- ``price: Amount<Currency>`` - the agreed on price that the asset is being sold for (without an issuer constraint).
-- ``myKey: PublicKey`` - the PublicKey part of the node's internal KeyPair that controls the asset being sold.
-The matching PrivateKey stored in the KeyManagementService will be used to sign the transaction.
+- ``otherSideSession: FlowSession`` - a flow session for communication with the buyer
+- ``assetToSell: StateAndRef<OwnableState>`` - a pointer to the ledger entry that represents the thing being sold
+- ``price: Amount<Currency>`` - the agreed on price that the asset is being sold for (without an issuer constraint)
+- ``myParty: PartyAndCertificate`` - the certificate representing the party that controls the asset being sold
 
 And for the buyer:
 
+- ``sellerSession: FlowSession`` - a flow session for communication with the seller
+- ``notary: Party`` - the entry in the network map for the chosen notary. See “Notaries” for more information on
+  notaries
 - ``acceptablePrice: Amount<Currency>`` - the price that was agreed upon out of band. If the seller specifies
-  a price less than or equal to this, then the trade will go ahead.
+  a price less than or equal to this, then the trade will go ahead
 - ``typeToBuy: Class<out OwnableState>`` - the type of state that is being purchased. This is used to check that the
-  sell side of the flow isn't trying to sell us the wrong thing, whether by accident or on purpose.
+  sell side of the flow isn't trying to sell us the wrong thing, whether by accident or on purpose
+- ``anonymous: Boolean`` - whether to generate a fresh, anonymous public key for the transaction
 
 Alright, so using this flow shouldn't be too hard: in the simplest case we can just create a Buyer or Seller
 with the details of the trade, depending on who we are. We then have to start the flow in some way. Just
@@ -191,9 +159,9 @@ and try again.
 Whitelisted classes with the Corda node
 ---------------------------------------
 
-For security reasons, we do not want Corda nodes to be able to receive instances of any class on the classpath
+For security reasons, we do not want Corda nodes to be able to just receive instances of any class on the classpath
 via messaging, since this has been exploited in other Java application containers in the past.  Instead, we require
-that every class contained in messages is whitelisted.  Some classes are whitelisted by default (see ``DefaultWhitelist``),
+every class contained in messages to be whitelisted. Some classes are whitelisted by default (see ``DefaultWhitelist``),
 but others outside of that set need to be whitelisted either by using the annotation ``@CordaSerializable`` or via the
 plugin framework.  See :doc:`serialization`.  You can see above that the ``SellerTradeInfo`` has been annotated.
 
@@ -231,26 +199,28 @@ These will return a ``FlowProgressHandle``, which is just like a ``FlowHandle``
 Implementing the seller
 -----------------------
 
-Let's implement the ``Seller.call`` method. This will be run when the flow is invoked.
+Let's implement the ``Seller.call`` method that will be run when the flow is invoked.
 
 .. container:: codeset
 
     .. literalinclude:: ../../finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt
-            :language: kotlin
-            :start-after: DOCSTART 4
-            :end-before: DOCEND 4
-            :dedent: 4
+        :language: kotlin
+        :start-after: DOCSTART 4
+        :end-before: DOCEND 4
+        :dedent: 8
 
 We start by sending information about the asset we wish to sell to the buyer. We fill out the initial flow message with
-the trade info, and then call ``send``. which takes two arguments:
+the trade info, and then call ``otherSideSession.send``. which takes two arguments:
 
-- The party we wish to send the message to.
-- The payload being sent.
+- The party we wish to send the message to
+- The payload being sent
 
-``send`` will serialise the payload and send it to the other party automatically.
+``otherSideSession.send`` will serialise the payload and send it to the other party automatically.
 
-Next, we call a *subflow* called ``SignTransactionFlow`` (see :ref:`subflows`). ``SignTransactionFlow`` automates the
-process of:
+Next, we call a *subflow* called ``IdentitySyncFlow.Receive`` (see :ref:`subflows`). ``IdentitySyncFlow.Receive``
+ensures that our node can de-anonymise any confidential identities in the transaction it's about to be asked to sign.
+
+Next, we call another subflow called ``SignTransactionFlow``. ``SignTransactionFlow`` automates the process of:
 
 * Receiving a proposed trade transaction from the buyer, with the buyer's signature attached.
 * Checking that the proposed transaction is valid.
@@ -273,7 +243,7 @@ OK, let's do the same for the buyer side:
          :language: kotlin
          :start-after: DOCSTART 1
          :end-before: DOCEND 1
-         :dedent: 4
+         :dedent: 8
 
 This code is longer but no more complicated. Here are some things to pay attention to:
 
@@ -472,7 +442,7 @@ Exception handling
 Flows can throw exceptions to prematurely terminate their execution. The flow framework gives special treatment to
 ``FlowException`` and its subtypes. These exceptions are treated as error responses of the flow and are propagated
 to all counterparties it is communicating with. The receiving flows will throw the same exception the next time they do
-a ``receive`` or ``sendAndReceive`` and thus end the flow session. If the receiver was invoked via ``subFlow`` (details below)
+a ``receive`` or ``sendAndReceive`` and thus end the flow session. If the receiver was invoked via ``subFlow``
 then the exception can  be caught there enabling re-invocation of the sub-flow.
 
 If the exception thrown by the erroring flow is not a ``FlowException`` it will still terminate but will not propagate to
@@ -505,59 +475,40 @@ A flow might declare some steps with code inside the flow class like this:
 .. container:: codeset
 
     .. literalinclude:: ../../finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt
-            :language: kotlin
-            :start-after: DOCSTART 2
-            :end-before: DOCEND 2
-            :dedent: 4
+        :language: kotlin
+        :start-after: DOCSTART 2
+        :end-before: DOCEND 2
+        :dedent: 8
 
-    .. sourcecode:: java
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/flowstatemachines/TutorialFlowStateMachines.java
+        :language: java
+        :start-after: DOCSTART 1
+        :end-before: DOCEND 1
+        :dedent: 4
 
-       private final ProgressTracker progressTracker = new ProgressTracker(
-               RECEIVING,
-               VERIFYING,
-               SIGNING,
-               COLLECTING_SIGNATURES,
-               RECORDING
-       );
+Each step exposes a label. By defining your own step types, you can export progress in a way that's both human readable
+and machine readable.
 
-       private static final ProgressTracker.Step RECEIVING = new ProgressTracker.Step(
-               "Waiting for seller trading info");
-       private static final ProgressTracker.Step VERIFYING = new ProgressTracker.Step(
-               "Verifying seller assets");
-       private static final ProgressTracker.Step SIGNING = new ProgressTracker.Step(
-               "Generating and signing transaction proposal");
-       private static final ProgressTracker.Step COLLECTING_SIGNATURES = new ProgressTracker.Step(
-               "Collecting signatures from other parties");
-       private static final ProgressTracker.Step RECORDING = new ProgressTracker.Step(
-               "Recording completed transaction");
-
-Each step exposes a label. By default labels are fixed, but by subclassing ``RelabelableStep`` you can make a step
-that can update its label on the fly. That's useful for steps that want to expose non-structured progress information
-like the current file being downloaded. By defining your own step types, you can export progress in a way that's both
-human readable and machine readable.
-
-Progress trackers are hierarchical. Each step can be the parent for another tracker. By altering the
-``ProgressTracker.childrenFor`` map, a tree of steps can be created. It's allowed to alter the hierarchy
-at runtime, on the fly, and the progress renderers will adapt to that properly. This can be helpful when you don't
-fully know ahead of time what steps will be required. If you *do* know what is required, configuring as much of the
-hierarchy ahead of time is a good idea, as that will help the users see what is coming up. You can pre-configure
-steps by overriding the ``Step`` class like this:
+Progress trackers are hierarchical. Each step can be the parent for another tracker. By setting
+``Step.childProgressTracker``, a tree of steps can be created. It's allowed to alter the hierarchy at runtime, on the
+fly, and the progress renderers will adapt to that properly. This can be helpful when you don't fully know ahead of
+time what steps will be required. If you *do* know what is required, configuring as much of the hierarchy ahead of time
+is a good idea, as that will help the users see what is coming up. You can pre-configure steps by overriding the
+``Step`` class like this:
 
 .. container:: codeset
 
     .. literalinclude:: ../../finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt
-            :language: kotlin
-            :start-after: DOCSTART 3
-            :end-before: DOCEND 3
-            :dedent: 4
+        :language: kotlin
+        :start-after: DOCSTART 3
+        :end-before: DOCEND 3
+        :dedent: 12
 
-    .. sourcecode:: java
-
-       private static final ProgressTracker.Step VERIFYING_AND_SIGNING = new ProgressTracker.Step("Verifying and signing transaction proposal") {
-           @Nullable @Override public ProgressTracker childProgressTracker() {
-               return SignTransactionFlow.Companion.tracker();
-           }
-       };
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/flowstatemachines/TutorialFlowStateMachines.java
+        :language: java
+        :start-after: DOCSTART 2
+        :end-before: DOCEND 2
+        :dedent: 4
 
 Every tracker has not only the steps given to it at construction time, but also the singleton
 ``ProgressTracker.UNSTARTED`` step and the ``ProgressTracker.DONE`` step. Once a tracker has become ``DONE`` its
@@ -586,22 +537,6 @@ and linked ahead of time.
 In future, the progress tracking framework will become a vital part of how exceptions, errors, and other faults are
 surfaced to human operators for investigation and resolution.
 
-Versioning
-----------
-
-Fibers involve persisting object-serialised stack frames to disk. Although we may do some R&D into in-place upgrades
-in future, for now the upgrade process for flows is simple: you duplicate the code and rename it so it has a
-new set of class names. Old versions of the flow can then drain out of the system whilst new versions are
-initiated. When enough time has passed that no old versions are still waiting for anything to happen, the previous
-copy of the code can be deleted.
-
-Whilst kind of ugly, this is a very simple approach that should suffice for now.
-
-.. warning:: Flows are not meant to live for months or years, and by implication they are not meant to implement entire deal
-   lifecycles. For instance, implementing the entire life cycle of an interest rate swap as a single flow - whilst
-   technically possible - would not be a good idea. The platform provides a job scheduler tool that can invoke
-   flows for this reason (see ":doc:`event-scheduling`")
-
 Future features
 ---------------
 
@@ -611,6 +546,6 @@ the features we have planned:
 * Exception management, with a "flow hospital" tool to manually provide solutions to unavoidable
   problems (e.g. the other side doesn't know the trade)
 * Being able to interact with people, either via some sort of external ticketing system, or email, or a custom UI.
-  For example to implement human transaction authorisations.
+  For example to implement human transaction authorisations
 * A standard library of flows that can be easily sub-classed by local developers in order to integrate internal
-  reporting logic, or anything else that might be required as part of a communications lifecycle.
\ No newline at end of file
+  reporting logic, or anything else that might be required as part of a communications lifecycle
\ No newline at end of file
diff --git a/docs/source/flow-testing.rst b/docs/source/flow-testing.rst
index 1d53696b61..939da0769e 100644
--- a/docs/source/flow-testing.rst
+++ b/docs/source/flow-testing.rst
@@ -15,74 +15,56 @@ A good example to examine for learning how to unit test flows is the ``ResolveTr
 flow takes care of downloading and verifying transaction graphs, with all the needed dependencies. We start
 with this basic skeleton:
 
-.. container:: codeset
-
-   .. sourcecode:: kotlin
-
-      class ResolveTransactionsFlowTest {
-          lateinit var mockNet: MockNetwork
-          lateinit var a: MockNetwork.MockNode
-          lateinit var b: MockNetwork.MockNode
-          lateinit var notary: Party
-
-          @Before
-          fun setup() {
-              mockNet = MockNetwork()
-              val nodes = mockNet.createSomeNodes()
-              a = nodes.partyNodes[0]
-              b = nodes.partyNodes[1]
-              mockNet.runNetwork()
-              notary = a.services.getDefaultNotary()
-          }
-
-          @After
-          fun tearDown() {
-              mockNet.stopNodes()
-          }
-      }
+.. literalinclude:: ../../core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
+    :language: kotlin
+    :start-after: DOCSTART 3
+    :end-before: DOCEND 3
 
 We create a mock network in our ``@Before`` setup method and create a couple of nodes. We also record the identity
 of the notary in our test network, which will come in handy later. We also tidy up when we're done.
 
 Next, we write a test case:
 
-.. literalinclude:: ../../core/src/test/kotlin/net/corda/core/flows/ResolveTransactionsFlowTest.kt
+.. literalinclude:: ../../core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
     :language: kotlin
     :start-after: DOCSTART 1
     :end-before: DOCEND 1
+    :dedent: 4
 
 We'll take a look at the ``makeTransactions`` function in a moment. For now, it's enough to know that it returns two
-``SignedTransaction`` objects, the second of which spends the first. Both transactions are known by node A
-but not node B.
+``SignedTransaction`` objects, the second of which spends the first. Both transactions are known by MegaCorpNode but
+not MiniCorpNode.
 
-The test logic is simple enough: we create the flow, giving it node A's identity as the target to talk to.
-Then we start it on node B and use the ``mockNet.runNetwork()`` method to bounce messages around until things have
+The test logic is simple enough: we create the flow, giving it MegaCorpNode's identity as the target to talk to.
+Then we start it on MiniCorpNode and use the ``mockNet.runNetwork()`` method to bounce messages around until things have
 settled (i.e. there are no more messages waiting to be delivered). All this is done using an in memory message
 routing implementation that is fast to initialise and use. Finally, we obtain the result of the flow and do
-some tests on it. We also check the contents of node B's database to see that the flow had the intended effect
+some tests on it. We also check the contents of MiniCorpNode's database to see that the flow had the intended effect
 on the node's persistent state.
 
 Here's what ``makeTransactions`` looks like:
 
-.. literalinclude:: ../../core/src/test/kotlin/net/corda/core/flows/ResolveTransactionsFlowTest.kt
+.. literalinclude:: ../../core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
     :language: kotlin
     :start-after: DOCSTART 2
     :end-before: DOCEND 2
+    :dedent: 4
 
 We're using the ``DummyContract``, a simple test smart contract which stores a single number in its states, along
 with ownership and issuer information. You can issue such states, exit them and re-assign ownership (move them).
 It doesn't do anything else. This code simply creates a transaction that issues a dummy state (the issuer is
 ``MEGA_CORP``, a pre-defined unit test identity), signs it with the test notary and MegaCorp keys and then
 converts the builder to the final ``SignedTransaction``. It then does so again, but this time instead of issuing
-it re-assigns ownership instead. The chain of two transactions is finally committed to node A by sending them
-directly to the ``a.services.recordTransaction`` method (note that this method doesn't check the transactions are
-valid) inside a ``database.transaction``.  All node flows run within a database transaction in the nodes themselves,
-but any time we need to use the database directly from a unit test, you need to provide a database transaction as shown
-here.
+it re-assigns ownership instead. The chain of two transactions is finally committed to MegaCorpNode by sending them
+directly to the ``megaCorpNode.services.recordTransaction`` method (note that this method doesn't check the
+transactions are valid) inside a ``database.transaction``.  All node flows run within a database transaction in the
+nodes themselves, but any time we need to use the database directly from a unit test, you need to provide a database
+transaction as shown here.
 
 With regards to initiated flows (see :doc:`flow-state-machines` for information on initiated and initiating flows), the
 full node automatically registers them by scanning the CorDapp jars. In a unit test environment this is not possible so
 ``MockNode`` has the ``registerInitiatedFlow`` method to manually register an initiated flow.
 
-And that's it: you can explore the documentation for the `MockNetwork API <api/kotlin/corda/net.corda.testing.node/-mock-network/index.html>`_
+And that's it: you can explore the documentation for the
+`MockNetwork API <api/kotlin/corda/net.corda.testing.node/-mock-network/index.html>`_
 here.
diff --git a/docs/source/getting-set-up.rst b/docs/source/getting-set-up.rst
index 04901d29fa..7a9b09b140 100644
--- a/docs/source/getting-set-up.rst
+++ b/docs/source/getting-set-up.rst
@@ -74,14 +74,14 @@ IntelliJ
 Download a sample project
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 1. Open a command prompt
-2. Clone the CorDapp tutorial repo by running ``git clone https://github.com/corda/cordapp-tutorial``
-3. Move into the cordapp-tutorial folder by running ``cd cordapp-tutorial``
+2. Clone the CorDapp example repo by running ``git clone https://github.com/corda/cordapp-example``
+3. Move into the cordapp-example folder by running ``cd cordapp-example``
 4. Retrieve a list of all the releases by running ``git branch -a --list``
 5. Check out the latest milestone release by running ``git checkout release-MX`` (where "X" is the latest milestone)
 
 Run from the command prompt
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-1. From the cordapp-tutorial folder, deploy the nodes by running ``gradlew deployNodes``
+1. From the cordapp-example folder, deploy the nodes by running ``gradlew deployNodes``
 2. Start the nodes by running ``call kotlin-source/build/nodes/runnodes.bat``
 3. Wait until all the terminal windows display either "Webserver started up in XX.X sec" or "Node for "NodeC" started up and registered in XX.XX sec"
 4. Test the CorDapp is running correctly by visiting the front end at http://localhost:10007/web/example/
@@ -89,7 +89,7 @@ Run from the command prompt
 Run from IntelliJ
 ^^^^^^^^^^^^^^^^^
 1. Open IntelliJ Community Edition
-2. On the splash screen, click "Open" (do NOT click "Import Project") and select the cordapp-tutorial folder
+2. On the splash screen, click "Open" (do NOT click "Import Project") and select the cordapp-example folder
 
 .. warning:: If you click "Import Project" instead of "Open", the project's run configurations will be erased!
 
@@ -123,14 +123,14 @@ IntelliJ
 Download a sample project
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 1. Open a terminal
-2. Clone the CorDapp tutorial repo by running ``git clone https://github.com/corda/cordapp-tutorial``
-3. Move into the cordapp-tutorial folder by running ``cd cordapp-tutorial``
+2. Clone the CorDapp example repo by running ``git clone https://github.com/corda/cordapp-example``
+3. Move into the cordapp-example folder by running ``cd cordapp-example``
 4. Retrieve a list of all the releases by running ``git branch -a --list``
 5. Check out the latest milestone release by running ``git checkout release-MX`` (where "X" is the latest milestone)
 
 Run from the terminal
 ^^^^^^^^^^^^^^^^^^^^^
-1. From the cordapp-tutorial folder, deploy the nodes by running ``./gradlew deployNodes``
+1. From the cordapp-example folder, deploy the nodes by running ``./gradlew deployNodes``
 2. Start the nodes by running ``kotlin-source/build/nodes/runnodes``. Do not click while 8 additional terminal windows start up.
 3. Wait until all the terminal windows display either "Webserver started up in XX.X sec" or "Node for "NodeC" started up and registered in XX.XX sec"
 4. Test the CorDapp is running correctly by visiting the front end at http://localhost:10007/web/example/
@@ -138,7 +138,7 @@ Run from the terminal
 Run from IntelliJ
 ^^^^^^^^^^^^^^^^^
 1. Open IntelliJ Community Edition
-2. On the splash screen, click "Open" (do NOT click "Import Project") and select the cordapp-tutorial folder
+2. On the splash screen, click "Open" (do NOT click "Import Project") and select the cordapp-example folder
 3. Once the project is open, click "File > Project Structure". Under "Project SDK:", set the project SDK by clicking "New...", clicking "JDK", and navigating to /Library/Java/JavaVirtualMachines/jdk1.8.0_XXX (where "XXX" is the latest minor version number). Click "OK".
 4. Click "View > Tool Windows > Event Log", and click "Import Gradle project", then "OK". Wait, and click "OK" again when the "Gradle Project Data To Import" window appears
 5. Wait for indexing to finish (a progress bar will display at the bottom-right of the IntelliJ window until indexing is complete)
@@ -161,7 +161,7 @@ A CorDapp template that you can use as the basis for your own CorDapps is availa
 
 And a simple example CorDapp for you to explore basic concepts is available here:
 
-	https://github.com/corda/cordapp-tutorial.git
+	https://github.com/corda/cordapp-example.git
 
 You can clone these repos to your local machine by running the command ``git clone [repo URL]``.
 
@@ -170,8 +170,8 @@ instead by running ``git checkout release-MX`` (where “X” is the latest mile
 
 Next steps
 ----------
-The best way to check that everything is working fine is by running the :doc:`tutorial CorDapp <tutorial-cordapp>` and
-the :doc:`samples <running-the-demos>`.
+The best way to check that everything is working fine is by taking a deeper look at the
+:doc:`example CorDapp <tutorial-cordapp>`.
 
 Next, you should read through :doc:`Corda Key Concepts <key-concepts>` to understand how Corda works.
 
diff --git a/docs/source/hello-world-running.rst b/docs/source/hello-world-running.rst
index 2e15aaf74e..6bc74a3117 100644
--- a/docs/source/hello-world-running.rst
+++ b/docs/source/hello-world-running.rst
@@ -185,7 +185,7 @@ There are a number of improvements we could make to this CorDapp:
 * We could add an API, to make it easier to interact with the CorDapp
 
 We will explore some of these improvements in future tutorials. But you should now be ready to develop your own
-CorDapps. There's `a more fleshed-out version of the IOU CorDapp <https://github.com/corda/cordapp-tutorial>`_ with an
+CorDapps. There's `a more fleshed-out version of the IOU CorDapp <https://github.com/corda/cordapp-example>`_ with an
 API and web front-end, and a set of example CorDapps in `the main Corda repo <https://github.com/corda/corda>`_, under
 ``samples``. An explanation of how to run these samples :doc:`here <running-the-demos>`.
 
diff --git a/docs/source/key-concepts-node.rst b/docs/source/key-concepts-node.rst
index aa6517249a..537d0aebc4 100644
--- a/docs/source/key-concepts-node.rst
+++ b/docs/source/key-concepts-node.rst
@@ -55,7 +55,7 @@ node's owner does not interact with other network nodes directly.
 RPC interface
 -------------
 The node's owner interacts with the node via remote procedure calls (RPC). The key RPC operations the node exposes
-are documented in :doc:``api-rpc``.
+are documented in :doc:`api-rpc`.
 
 The service hub
 ---------------
diff --git a/docs/source/oracles.rst b/docs/source/oracles.rst
index 177da9a320..802e9f33c0 100644
--- a/docs/source/oracles.rst
+++ b/docs/source/oracles.rst
@@ -17,25 +17,25 @@ Introduction to oracles
 -----------------------
 
 Oracles are a key concept in the block chain/decentralised ledger space. They can be essential for many kinds of
-application, because we often wish to condition a transaction on some fact being true or false, but the ledger itself
+application, because we often wish to condition the validity of a transaction on some fact being true or false, but the ledger itself
 has a design that is essentially functional: all transactions are *pure* and *immutable*. Phrased another way, a
-smart contract cannot perform any input/output or depend on any state outside of the transaction itself. There is no
-way to download a web page or interact with the user, in a smart contract. It must be this way because everyone must
-be able to independently check a transaction and arrive at an identical conclusion for the ledger to maintain its
+contract cannot perform any input/output or depend on any state outside of the transaction itself. For example, there is no
+way to download a web page or interact with the user from within a contract. It must be this way because everyone must
+be able to independently check a transaction and arrive at an identical conclusion regarding its validity for the ledger to maintain its
 integrity: if a transaction could evaluate to "valid" on one computer and then "invalid" a few minutes later on a
 different computer, the entire shared ledger concept wouldn't work.
 
-But it is often essential that transactions do depend on data from the outside world, for example, verifying that an
+But transaction validity does often depend on data from the outside world - verifying that an
 interest rate swap is paying out correctly may require data on interest rates, verifying that a loan has reached
 maturity requires knowledge about the current time, knowing which side of a bet receives the payment may require
-arbitrary facts about the real world (e.g. the bankruptcy or solvency of a company or country) ... and so on.
+arbitrary facts about the real world (e.g. the bankruptcy or solvency of a company or country), and so on.
 
 We can solve this problem by introducing services that create digitally signed data structures which assert facts.
 These structures can then be used as an input to a transaction and distributed with the transaction data itself. Because
 the statements are themselves immutable and signed, it is impossible for an oracle to change its mind later and
 invalidate transactions that were previously found to be valid. In contrast, consider what would happen if a contract
 could do an HTTP request: it's possible that an answer would change after being downloaded, resulting in loss of
-consensus (breaks).
+consensus.
 
 The two basic approaches
 ~~~~~~~~~~~~~~~~~~~~~~~~
@@ -78,7 +78,7 @@ Asserting continuously varying data
 Let's look at the interest rates oracle that can be found in the ``NodeInterestRates`` file. This is an example of
 an oracle that uses a command because the current interest rate fix is a constantly changing fact.
 
-The obvious way to implement such a service is like this:
+The obvious way to implement such a service is this:
 
 1. The creator of the transaction that depends on the interest rate sends it to the oracle.
 2. The oracle inserts a command with the rate and signs the transaction.
@@ -101,40 +101,38 @@ class that binds it to the network layer.
 
 Here is an extract from the ``NodeInterestRates.Oracle`` class and supporting types:
 
+.. literalinclude:: ../../finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
+    :language: kotlin
+    :start-after: DOCSTART 1
+    :end-before: DOCEND 1
+
+.. literalinclude:: ../../finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
+    :language: kotlin
+    :start-after: DOCSTART 2
+    :end-before: DOCEND 2
+
 .. sourcecode:: kotlin
 
-   /** A [FixOf] identifies the question side of a fix: what day, tenor and type of fix ("LIBOR", "EURIBOR" etc) */
-   data class FixOf(val name: String, val forDay: LocalDate, val ofTenor: Tenor)
-
-   /** A [Fix] represents a named interest rate, on a given day, for a given duration. It can be embedded in a tx. */
-   data class Fix(val of: FixOf, val value: BigDecimal) : CommandData
-
    class Oracle {
-       fun query(queries: List<FixOf>, deadline: Instant): List<Fix>
+       fun query(queries: List<FixOf>): List<Fix>
 
-       fun sign(ftx: FilteredTransaction, txId: SecureHash): TransactionSignature
+       fun sign(ftx: FilteredTransaction): TransactionSignature
    }
 
-Because the fix contains a timestamp (the ``forDay`` field), that identifies the version of the data being requested,
-there can be an arbitrary delay between a fix being requested via ``query`` and the signature being requested via ``sign``
-as the Oracle can know which, potentially historical, value it is being asked to sign for.  This is an important
-technique for continuously varying data.
-
-The ``query`` method takes a deadline, which is a point in time the requester is willing to wait until for the necessary
-data to be available.  Not every oracle will need this.  This can be useful where data is expected to be available on a
-particular schedule and we use scheduling functionality to automatically launch the processing associated with it.
-We can schedule for the expected announcement (or publish) time and give a suitable deadline at which the lack of the
-information being available and the delay to processing becomes significant and may need to be escalated.
+The fix contains a timestamp (the ``forDay`` field) that identifies the version of the data being requested. Since
+there can be an arbitrary delay between a fix being requested via ``query`` and the signature being requested via
+``sign``, this timestamp allows the Oracle to know which, potentially historical, value it is being asked to sign for.  This is an
+important technique for continuously varying data.
 
 Hiding transaction data from the oracle
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Because the transaction is sent to the oracle for signing, ordinarily the oracle would be able to see the entire contents
 of that transaction including the inputs, output contract states and all the commands, not just the one (in this case)
-relevant command.  This is an obvious privacy leak for the other participants.  We currently solve this with
-``FilteredTransaction``-s and the use of Merkle Trees.  These reveal only the necessary parts of the transaction to the
-oracle but still allow it to sign it by providing the Merkle hashes for the remaining parts.  See :doc:`merkle-trees` for
-more details.
+relevant command.  This is an obvious privacy leak for the other participants.  We currently solve this using a
+``FilteredTransaction``, which implements a Merkle Tree.  These reveal only the necessary parts of the transaction to the
+oracle but still allow it to sign it by providing the Merkle hashes for the remaining parts.  See :doc:`key-concepts-oracles`
+for more details.
 
 Pay-per-play oracles
 ~~~~~~~~~~~~~~~~~~~~
@@ -143,7 +141,7 @@ Because the signature covers the transaction, and transactions may end up being
 is independently checkable. However, this approach can still be useful when the data itself costs money, because the act
 of issuing the signature in the first place can be charged for (e.g. by requiring the submission of a fresh
 ``Cash.State`` that has been re-assigned to a key owned by the oracle service). Because the signature covers the
-*transaction* and not only the *fact*, this allows for a kind of weak pseudo-DRM over data feeds. Whilst a smart
+*transaction* and not only the *fact*, this allows for a kind of weak pseudo-DRM over data feeds. Whilst a
 contract could in theory include a transaction parsing and signature checking library, writing a contract in this way
 would be conclusive evidence of intent to disobey the rules of the service (*res ipsa loquitur*). In an environment
 where parties are legally identifiable, usage of such a contract would by itself be sufficient to trigger some sort of
@@ -156,24 +154,12 @@ Implement the core classes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The key is to implement your oracle in a similar way to the ``NodeInterestRates.Oracle`` outline we gave above with
-both ``query`` and ``sign`` methods.  Typically you would want one class that encapsulates the parameters to the ``query``
-method (``FixOf`` above), and a ``CommandData`` implementation (``Fix`` above) that encapsulates both an instance of
+both a ``query`` and a ``sign`` method.  Typically you would want one class that encapsulates the parameters to the ``query``
+method (``FixOf``, above), and a ``CommandData`` implementation (``Fix``, above) that encapsulates both an instance of
 that parameter class and an instance of whatever the result of the ``query`` is (``BigDecimal`` above).
 
-The ``NodeInterestRates.Oracle`` allows querying for multiple ``Fix``-es but that is not necessary and is
-provided for the convenience of callers who might need multiple and can do it all in one query request.  Likewise
-the *deadline* functionality is optional and can be avoided initially.
-
-Let's see what parameters we pass to the constructor of this oracle.
-
-.. sourcecode:: kotlin
-
-   class Oracle(val identity: Party, private val signingKey: PublicKey, val clock: Clock) = TODO()
-
-Here we see the oracle needs to have its own identity, so it can check which transaction commands it is expected to
-sign for, and also needs the PublicKey portion of its signing key. Later this PublicKey will be passed to the KeyManagementService
-to identify the internal PrivateKey used for transaction signing.
-The clock is used for the deadline functionality which we will not discuss further here.
+The ``NodeInterestRates.Oracle`` allows querying for multiple ``Fix`` objects but that is not necessary and is
+provided for the convenience of callers who need multiple fixes and want to be able to do it all in one query request.
 
 Assuming you have a data source and can query it, it should be very easy to implement your ``query`` method and the
 parameter and ``CommandData`` classes.
@@ -184,16 +170,17 @@ Let's see how the ``sign`` method for ``NodeInterestRates.Oracle`` is written:
    :language: kotlin
    :start-after: DOCSTART 1
    :end-before: DOCEND 1
+   :dedent: 8
 
 Here we can see that there are several steps:
 
 1. Ensure that the transaction we have been sent is indeed valid and passes verification, even though we cannot see all
-   of it.
+   of it
 2. Check that we only received commands as expected, and each of those commands expects us to sign for them and is of
-   the expected type (``Fix`` here).
+   the expected type (``Fix`` here)
 3. Iterate over each of the commands we identified in the last step and check that the data they represent matches
    exactly our data source.  The final step, assuming we have got this far, is to generate a signature for the
-   transaction and return it.
+   transaction and return it
 
 Binding to the network
 ~~~~~~~~~~~~~~~~~~~~~~
@@ -209,6 +196,7 @@ done:
    :language: kotlin
    :start-after: DOCSTART 3
    :end-before: DOCEND 3
+   :dedent: 4
 
 The Corda node scans for any class with this annotation and initialises them. The only requirement is that the class provide
 a constructor with a single parameter of type ``ServiceHub``.
@@ -217,9 +205,10 @@ a constructor with a single parameter of type ``ServiceHub``.
    :language: kotlin
    :start-after: DOCSTART 2
    :end-before: DOCEND 2
+   :dedent: 4
 
 These two flows leverage the oracle to provide the querying and signing operations. They get reference to the oracle,
-which will have already been initialised by the node, using ``ServiceHub.cordappProvider``. Both flows are annotated with
+which will have already been initialised by the node, using ``ServiceHub.cordaService``. Both flows are annotated with
 ``@InitiatedBy``. This tells the node which initiating flow (which are discussed in the next section) they are meant to
 be executed with.
 
@@ -227,17 +216,18 @@ Providing sub-flows for querying and signing
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 We mentioned the client sub-flow briefly above.  They are the mechanism that clients, in the form of other flows, will
-interact with your oracle.  Typically there will be one for querying and one for signing.  Let's take a look at
+use to interact with your oracle.  Typically there will be one for querying and one for signing.  Let's take a look at
 those for ``NodeInterestRates.Oracle``.
 
 .. literalinclude:: ../../samples/irs-demo/src/main/kotlin/net/corda/irs/flows/RatesFixFlow.kt
    :language: kotlin
    :start-after: DOCSTART 1
    :end-before: DOCEND 1
+   :dedent: 4
 
 You'll note that the ``FixSignFlow`` requires a ``FilterTransaction`` instance which includes only ``Fix`` commands.
-You can find a further explanation of this in :doc:`merkle-trees`. Below you will see how to build such transaction with
-hidden fields.
+You can find a further explanation of this in :doc:`key-concepts-oracles`. Below you will see how to build such a
+transaction with hidden fields.
 
 .. _filtering_ref:
 
@@ -252,16 +242,16 @@ called ``RatesFixFlow``.  Here's the ``call`` method of that flow.
    :language: kotlin
    :start-after: DOCSTART 2
    :end-before: DOCEND 2
+   :dedent: 4
 
 As you can see, this:
 
-1. Queries the oracle for the fact using the client sub-flow for querying from above.
-2. Does some quick validation.
-3. Adds the command to the transaction containing the fact to be signed for by the oracle.
-4. Calls an extension point that allows clients to generate output states based on the fact from the oracle.
-5. Builds filtered transaction based on filtering function extended from ``RatesFixFlow``.
-6. Requests the signature from the oracle using the client sub-flow for signing from above.
-7. Adds the signature returned from the oracle.
+1. Queries the oracle for the fact using the client sub-flow for querying defined above
+2. Does some quick validation
+3. Adds the command to the transaction containing the fact to be signed for by the oracle
+4. Calls an extension point that allows clients to generate output states based on the fact from the oracle
+5. Builds filtered transaction based on filtering function extended from ``RatesFixFlow``
+6. Requests the signature from the oracle using the client sub-flow for signing from above
 
 Here's an example of it in action from ``FixingFlow.Fixer``.
 
@@ -269,6 +259,7 @@ Here's an example of it in action from ``FixingFlow.Fixer``.
    :language: kotlin
    :start-after: DOCSTART 1
    :end-before: DOCEND 1
+   :dedent: 4
 
 .. note::
     When overriding be careful when making the sub-class an anonymous or inner class (object declarations in Kotlin),
@@ -279,6 +270,6 @@ Testing
 -------
 
 When unit testing, we make use of the ``MockNetwork`` which allows us to create ``MockNode`` instances. A ``MockNode``
-is a simplified node suitable for tests. One feature that isn't available (and which is not suitable in unit testing
+is a simplified node suitable for tests. One feature that isn't available (and which is not suitable for unit testing
 anyway) is the node's ability to scan and automatically install oracles it finds in the CorDapp jars. Instead, when
 working with ``MockNode``, use the ``installCordaService`` method to manually install the oracle on the relevant node.
\ No newline at end of file
diff --git a/docs/source/running-a-notary.rst b/docs/source/running-a-notary.rst
index 81ade65043..32b62359a8 100644
--- a/docs/source/running-a-notary.rst
+++ b/docs/source/running-a-notary.rst
@@ -6,9 +6,10 @@ At present we have several prototype notary implementations:
 1. ``SimpleNotaryService`` (single node) -- commits the provided transaction input states without any validation.
 2. ``ValidatingNotaryService`` (single node) -- retrieves and validates the whole transaction history
    (including the given transaction) before committing.
-3. ``RaftValidatingNotaryService`` (distributed) -- functionally equivalent to ``ValidatingNotaryService``, but stores
+3. ``RaftNonValidatingNotaryService`` (distributed) -- functionally equivalent to ``SimpleNotaryService``, but stores
    the committed states in a distributed collection replicated and persisted in a Raft cluster. For the consensus layer
-   we are using the `Copycat <http://atomix.io/copycat/>`_ framework.
+   we are using the `Copycat <http://atomix.io/copycat/>`_ framework
+4. ``RaftValidatingNotaryService`` (distributed) -- as above, but performs validation on the transactions received
 
 To have a node run a notary service, you need to set appropriate configuration values before starting it
 (see :doc:`corda-configuration-file` for reference).
@@ -25,5 +26,5 @@ For ``ValidatingNotaryService``, it is:
 
   extraAdvertisedServiceIds : [ "net.corda.notary.validating" ]
 
-Setting up a ``RaftValidatingNotaryService`` is currently slightly more involved and is not recommended for prototyping
-purposes. There is work in progress to simplify it. To see it in action, however, you can try out the :ref:`notary-demo`.
+Setting up a Raft notary is currently slightly more involved and is not recommended for prototyping purposes. There is
+work in progress to simplify it. To see it in action, however, you can try out the :ref:`notary-demo`.
diff --git a/docs/source/tutorial-attachments.rst b/docs/source/tutorial-attachments.rst
index 09a2736b38..7047cfb959 100644
--- a/docs/source/tutorial-attachments.rst
+++ b/docs/source/tutorial-attachments.rst
@@ -68,57 +68,22 @@ RPC, which returns both a snapshot and an observable of changes. The observable
 transaction the node verifies is retrieved. That transaction is checked to see if it has the expected attachment
 and if so, printed out.
 
-.. sourcecode:: kotlin
+.. container:: codeset
 
-   fun recipient(rpc: CordaRPCOps) {
-       println("Waiting to receive transaction ...")
-       val stx = rpc.verifiedTransactions().second.toBlocking().first()
-       val wtx = stx.tx
-       if (wtx.attachments.isNotEmpty()) {
-           assertEquals(PROSPECTUS_HASH, wtx.attachments.first())
-           require(rpc.attachmentExists(PROSPECTUS_HASH))
-           println("File received - we're happy!\n\nFinal transaction is:\n\n${Emoji.renderIfSupported(wtx)}")
-       } else {
-           println("Error: no attachments found in ${wtx.id}")
-       }
-   }
+    .. literalinclude:: ../../samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt
+        :language: kotlin
+        :start-after: DOCSTART 1
+        :end-before: DOCEND 1
 
 The sender correspondingly builds a transaction with the attachment, then calls ``FinalityFlow`` to complete the
 transaction and send it to the recipient node:
 
-.. sourcecode:: kotlin
-
-   fun sender(rpc: CordaRPCOps) {
-       // Get the identity key of the other side (the recipient).
-       val otherSide: Party = rpc.wellKnownPartyFromName("Bank B")!!
-
-       // Make sure we have the file in storage
-       // TODO: We should have our own demo file, not share the trader demo file
-       if (!rpc.attachmentExists(PROSPECTUS_HASH)) {
-           Thread.currentThread().contextClassLoader.getResourceAsStream("bank-of-london-cp.jar").use {
-               val id = rpc.uploadAttachment(it)
-               assertEquals(PROSPECTUS_HASH, id)
-           }
-       }
-
-       // Create a trivial transaction that just passes across the attachment - in normal cases there would be
-       // inputs, outputs and commands that refer to this attachment.
-       val ptx = TransactionBuilder(notary = null)
-       require(rpc.attachmentExists(PROSPECTUS_HASH))
-       ptx.addAttachment(PROSPECTUS_HASH)
-       // TODO: Add a dummy state and specify a notary, so that the tx hash is randomised each time and the demo can be repeated.
-
-       // Despite not having any states, we have to have at least one signature on the transaction
-       ptx.signWith(ALICE_KEY)
-
-       // Send the transaction to the other recipient
-       val stx = ptx.toSignedTransaction()
-       println("Sending ${stx.id}")
-       val protocolHandle = rpc.startFlow(::FinalityFlow, stx, setOf(otherSide))
-       protocolHandle.progress.subscribe(::println)
-       protocolHandle.returnValue.toBlocking().first()
-   }
+.. container:: codeset
 
+    .. literalinclude:: ../../samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt
+        :language: kotlin
+        :start-after: DOCSTART 2
+        :end-before: DOCEND 2
 
 This side is a bit more complex. Firstly it looks up its counterparty by name in the network map. Then, if the node
 doesn't already have the attachment in its storage, we upload it from a JAR resource and check the hash was what
diff --git a/docs/source/tutorial-building-transactions.rst b/docs/source/tutorial-building-transactions.rst
index 3a7586dbb9..d7011e57f4 100644
--- a/docs/source/tutorial-building-transactions.rst
+++ b/docs/source/tutorial-building-transactions.rst
@@ -18,67 +18,54 @@ of a flow.
 The Basic Lifecycle Of Transactions
 -----------------------------------
 
-Transactions in Corda are constructed in stages and contain a number of
-elements. In particular a transaction’s core data structure is the
-``net.corda.core.transactions.WireTransaction``, which is usually
-manipulated via a
-``net.corda.core.transactions.TransactionBuilder`` and contains:
+Transactions in Corda contain a number of elements:
 
 1. A set of Input state references that will be consumed by the final
-accepted transaction.
+   accepted transaction
 
 2. A set of Output states to create/replace the consumed states and thus
-become the new latest versions of data on the ledger.
+   become the new latest versions of data on the ledger
 
 3. A set of ``Attachment`` items which can contain legal documents, contract
-code, or private encrypted sections as an extension beyond the native
-contract states.
+   code, or private encrypted sections as an extension beyond the native
+   contract states
 
-4. A set of ``Command`` items which give a context to the type of ledger
-transition that is encoded in the transaction. Also each command has an
-associated set of signer keys, which will be required to sign the
-transaction.
+4. A set of ``Command`` items which indicate the type of ledger
+   transition that is encoded in the transaction. Each command also has an
+   associated set of signer keys, which will be required to sign the
+   transaction
 
-5. A signers list, which is populated by the ``TransactionBuilder`` to
-be the union of the signers on the individual Command objects.
+5. A signers list, which is the union of the signers on the individual
+   Command objects
 
-6. A notary identity to specify the Notary node which is tracking the
-state consumption. (If the input states are registered with different
-notary nodes the flow will have to insert additional ``NotaryChange``
-transactions to migrate the states across to a consistent notary node,
-before being allowed to mutate any states.)
+6. A notary identity to specify which notary node is tracking the
+   state consumption (if the transaction's input states are registered with different
+   notary nodes the flow will have to insert additional ``NotaryChange``
+   transactions to migrate the states across to a consistent notary node
+   before being allowed to mutate any states)
 
-7. Optionally a timestamp that can used in the Notary to time bound the
-period in which the proposed transaction stays valid.
+7. Optionally a timestamp that can used by the notary to bound the
+   period during which the proposed transaction can be committed to the
+   ledger
 
-Typically, the ``WireTransaction`` should be regarded as a proposal and
-may need to be exchanged back and forth between parties before it can be
-fully populated. This is an immediate consequence of the Corda privacy
-model, which means that the input states are likely to be unknown to the
-other node.
+A transaction is built by populating a ``TransactionBuilder``. Typically,
+the ``TransactionBuilder`` will need to be exchanged back and forth between
+parties before it is fully populated. This is an immediate consequence of
+the Corda privacy model, in which the input states are likely to be unknown
+to the other node.
 
-Once the proposed data is fully populated the flow code should freeze
-the ``WireTransaction`` and form a ``SignedTransaction``. This is key to
-the ledger agreement process, as once a flow has attached a node’s
-signature it has stated that all details of the transaction are
-acceptable to it. A flow should take care not to attach signatures to
-intermediate data, which might be maliciously used to construct a
-different ``SignedTransaction``. For instance in a foreign exchange
-scenario we shouldn't send a ``SignedTransaction`` with only our sell
-side populated as that could be used to take the money without the
-expected return of the other currency. Also, it is best practice for
-flows to receive back the ``TransactionSignature`` of other parties
-rather than a full ``SignedTransaction`` objects, because otherwise we
-have to separately check that this is still the same
+Once the builder is fully populated, the flow should freeze the ``TransactionBuilder`` by signing it to create a
+``SignedTransaction``. This is key to the ledger agreement process - once a flow has attached a node’s signature to a
+transaction, it has effectively stated that it accepts all the details of the transaction.
+
+It is best practice for flows to receive back the ``TransactionSignature`` of other parties rather than a full
+``SignedTransaction`` objects, because otherwise we have to separately check that this is still the same
 ``SignedTransaction`` and not a malicious substitute.
 
-The final stage of committing the transaction to the ledger is to
-notarise the ``SignedTransaction``, distribute this to all appropriate
-parties and record the data into the ledger. These actions are best
-delegated to the ``FinalityFlow``, rather than calling the individual
-steps manually. However, do note that the final broadcast to the other
-nodes is asynchronous, so care must be used in unit testing to
-correctly await the Vault updates.
+The final stage of committing the transaction to the ledger is to notarise the ``SignedTransaction``, distribute it to
+all appropriate parties and record the data into the ledger. These actions are best delegated to the ``FinalityFlow``,
+rather than calling the individual steps manually. However, do note that the final broadcast to the other nodes is
+asynchronous, so care must be used in unit testing to correctly await the vault updates.
 
 Gathering Inputs
 ----------------
@@ -87,39 +74,36 @@ One of the first steps to forming a transaction is gathering the set of
 input references. This process will clearly vary according to the nature
 of the business process being captured by the smart contract and the
 parameterised details of the request. However, it will generally involve
-searching the Vault via the ``VaultService`` interface on the
+searching the vault via the ``VaultService`` interface on the
 ``ServiceHub`` to locate the input states.
 
 To give a few more specific details consider two simplified real world
-scenarios. First, a basic foreign exchange Cash transaction. This
+scenarios. First, a basic foreign exchange cash transaction. This
 transaction needs to locate a set of funds to exchange. A flow
 modelling this is implemented in ``FxTransactionBuildTutorial.kt``.
-Second, a simple business model in which parties manually accept, or
-reject each other's trade proposals which is implemented in
+Second, a simple business model in which parties manually accept or
+reject each other's trade proposals, which is implemented in
 ``WorkflowTransactionBuildTutorial.kt``. To run and explore these
-examples using the IntelliJ IDE one can run/step the respective unit
+examples using the IntelliJ IDE one can run/step through the respective unit
 tests in ``FxTransactionBuildTutorialTest.kt`` and
 ``WorkflowTransactionBuildTutorialTest.kt``, which drive the flows as
 part of a simulated in-memory network of nodes.
 
-.. |nbsp| unicode:: 0xA0
-    :trim:
-
 .. note:: Before creating the IntelliJ run configurations for these unit tests
     go to Run -> Edit |nbsp| Configurations -> Defaults -> JUnit, add
-    ``-javaagent:lib/quasar.jar -Dco.paralleluniverse.fibers.verifyInstrumentation``
+    ``-javaagent:lib/quasar.jar``
     to the VM options, and set Working directory to ``$PROJECT_DIR$``
     so that the ``Quasar`` instrumentation is correctly configured.
 
-For the Cash transaction let’s assume the cash resources are using the 
-standard ``CashState`` in the ``:financial`` Gradle module. The Cash 
+For the cash transaction, let’s assume we are using the
+standard ``CashState`` in the ``:financial`` Gradle module. The ``Cash``
 contract uses ``FungibleAsset`` states to model holdings of 
-interchangeable assets and allow the split/merge and summing of 
+interchangeable assets and allow the splitting, merging and summing of
 states to meet a contractual obligation. We would normally use the 
 ``Cash.generateSpend`` method to gather the required
-amount of cash into a ``TransactionBuilder``, set the outputs and move 
-command. However, to elucidate more clearly example flow code is shown 
-here that will manually carry out the inputs queries by specifying relevant
+amount of cash into a ``TransactionBuilder``, set the outputs and generate the ``Move``
+command. However, to make things clearer, the example flow code shown
+here will manually carry out the input queries by specifying relevant
 query criteria filters to the ``tryLockFungibleStatesForSpending`` method
 of the ``VaultService``.
 
@@ -128,14 +112,11 @@ of the ``VaultService``.
     :start-after: DOCSTART 1
     :end-before: DOCEND 1
 
-As a foreign exchange transaction we expect an exchange of two
-currencies, so we will also require a set of input states from the other
-counterparty. However, the Corda privacy model means we do not know the
-other node’s states. Our flow must therefore negotiate with the other
-node for them to carry out a similar query and populate the inputs (See
-the ``ForeignExchangeFlow`` for more details of the exchange). Having
-identified a set of Input ``StateRef`` items we can then create the
-output as discussed below.
+This is a foreign exchange transaction, so we expect another set of input states of another currency from a
+counterparty. However, the Corda privacy model means we are not aware of the other node’s states. Our flow must
+therefore ask the other node to carry out a similar query and return the additional inputs to the transaction (see the
+``ForeignExchangeFlow`` for more details of the exchange). We now have all the required input ``StateRef`` items, and
+can turn to gathering the outputs.
 
 For the trade approval flow we need to implement a simple workflow
 pattern. We start by recording the unconfirmed trade details in a state
@@ -167,6 +148,7 @@ the ``VaultService`` as follows:
     :language: kotlin
     :start-after: DOCSTART 1
     :end-before: DOCEND 1
+    :dedent: 8
 
 Generating Commands
 -------------------
@@ -187,7 +169,7 @@ environment the ``Contract.verify``, transaction is the only allowed to
 use the content of the transaction to decide validity.
 
 Another essential requirement for commands is that the correct set of
-``CompositeKeys`` are added to the Command on the builder, which will be
+``PublicKey`` objects are added to the ``Command`` on the builder, which will be
 used to form the set of required signers on the final validated
 transaction. These must correctly align with the expectations of the
 ``Contract.verify`` method, which should be written to defensively check
@@ -200,7 +182,7 @@ exchange of assets.
 Generating Outputs
 ------------------
 
-Having located a set of ``StateAndRefs`` as the transaction inputs, the
+Having located a ``StateAndRefs`` set as the transaction inputs, the
 flow has to generate the output states. Typically, this is a simple call
 to the Kotlin ``copy`` method to modify the few fields that will
 transitioned in the transaction. The contract code may provide a
@@ -210,7 +192,7 @@ usually sufficient, especially as it is expected that we wish to preserve
 the ``linearId`` between state revisions, so that Vault queries can find
 the latest revision.
 
-For fungible contract states such as ``Cash`` it is common to distribute
+For fungible contract states such as ``cash`` it is common to distribute
 and split the total amount e.g. to produce a remaining balance output
 state for the original owner when breaking up a large amount input
 state. Remember that the result of a successful transaction is always to
@@ -221,36 +203,39 @@ the total cash. For example from the demo code:
     :language: kotlin
     :start-after: DOCSTART 2
     :end-before: DOCEND 2
+    :dedent: 4
 
-Building the WireTransaction
-----------------------------
+Building the SignedTransaction
+------------------------------
 
-Having gathered all the ingredients for the transaction we now need to
-use a ``TransactionBuilder`` to construct the full ``WireTransaction``.
-The initial ``TransactionBuilder`` should be created by calling the
-``TransactionBuilder`` method. At this point the
-Notary to associate with the states should be recorded. Then we keep
-adding inputs, outputs, commands and attachments to fill the
-transaction. Examples of this process are:
+Having gathered all the components for the transaction we now need to use a ``TransactionBuilder`` to construct the
+full ``SignedTransaction``. We instantiate a ``TransactionBuilder`` and provide a notary that will be associated with
+the output states. Then we keep adding inputs, outputs, commands and attachments to complete the transaction.
+
+Once the transaction is fully formed, we call ``ServiceHub.signInitialTransaction`` to sign the ``TransactionBuilder``
+and convert it into a ``SignedTransaction``.
+
+Examples of this process are:
 
 .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/WorkflowTransactionBuildTutorial.kt
     :language: kotlin
     :start-after: DOCSTART 2
     :end-before: DOCEND 2
+    :dedent: 8
 
 .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/FxTransactionBuildTutorial.kt
     :language: kotlin
     :start-after: DOCSTART 3
     :end-before: DOCEND 3
+    :dedent: 4
 
 Completing the SignedTransaction
 --------------------------------
 
-Having created an initial ``WireTransaction`` and converted this to an
-initial ``SignedTransaction`` the process of verifying and forming a
-full ``SignedTransaction`` begins and then completes with the
+Having created an initial ``TransactionBuilder`` and converted this to a ``SignedTransaction``, the process of
+verifying and forming a full ``SignedTransaction`` begins and then completes with the
 notarisation. In practice this is a relatively stereotypical process,
-because assuming the ``WireTransaction`` is correctly constructed the
+because assuming the ``SignedTransaction`` is correctly constructed the
 verification should be immediate. However, it is also important to
 recheck the business details of any data received back from an external
 node, because a malicious party could always modify the contents before
@@ -263,12 +248,11 @@ of the transaction has not been altered by the remote parties.
 
 The typical code therefore checks the received ``SignedTransaction``
 using the ``verifySignaturesExcept`` method, excluding itself, the
-notary and any other parties yet to apply their signature. The contents of the
-``WireTransaction`` inside the ``SignedTransaction`` should be fully
+notary and any other parties yet to apply their signature. The contents of the ``SignedTransaction`` should be fully
 verified further by expanding with ``toLedgerTransaction`` and calling
 ``verify``. Further context specific and business checks should then be
 made, because the ``Contract.verify`` is not allowed to access external
-context. For example the flow may need to check that the parties are the
+context. For example, the flow may need to check that the parties are the
 right ones, or that the ``Command`` present on the transaction is as
 expected for this specific flow. An example of this from the demo code is:
 
@@ -276,6 +260,7 @@ expected for this specific flow. An example of this from the demo code is:
     :language: kotlin
     :start-after: DOCSTART 3
     :end-before: DOCEND 3
+    :dedent: 8
 
 After verification the remote flow will return its signature to the
 originator. The originator should apply that signature to the starting
@@ -284,18 +269,15 @@ originator. The originator should apply that signature to the starting
 Committing the Transaction
 --------------------------
 
-Once all the party signatures are applied to the SignedTransaction the
-final step is notarisation. This involves calling ``NotaryFlow.Client``
-to confirm the transaction, consume the inputs and return its confirming
-signature. Then the flow should ensure that all nodes end with all
-signatures and that they call ``ServiceHub.recordTransactions``. The
-code for this is standardised in the ``FinalityFlow``, or more explicitly
-an example is:
+Once all the signatures are applied to the ``SignedTransaction``, the
+final steps are notarisation and ensuring that all nodes record the fully-signed transaction. The
+code for this is standardised in the ``FinalityFlow``:
 
 .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/WorkflowTransactionBuildTutorial.kt
     :language: kotlin
     :start-after: DOCSTART 4
     :end-before: DOCEND 4
+    :dedent: 8
 
 Partially Visible Transactions
 ------------------------------
@@ -307,12 +289,12 @@ a regulator, but does not wish to share that with the other trading
 partner. The tear-off/Merkle tree support in Corda allows flows to send
 portions of the full transaction to restrict visibility to remote
 parties. To do this one can use the
-``WireTransaction.buildFilteredTransaction`` extension method to produce
+``SignedTransaction.buildFilteredTransaction`` extension method to produce
 a ``FilteredTransaction``. The elements of the ``SignedTransaction``
 which we wish to be hide will be replaced with their secure hash. The
-overall transaction txid is still provable from the
+overall transaction id is still provable from the
 ``FilteredTransaction`` preventing change of the private data, but we do
 not expose that data to the other node directly. A full example of this
 can be found in the ``NodeInterestRates`` Oracle code from the
 ``irs-demo`` project which interacts with the ``RatesFixFlow`` flow.
-Also, refer to the :doc:`merkle-trees` documentation.
+Also, refer to the :doc:`merkle-trees` documentation.
\ No newline at end of file
diff --git a/docs/source/tutorial-clientrpc-api.rst b/docs/source/tutorial-clientrpc-api.rst
index 0181e0778b..aa49889b4f 100644
--- a/docs/source/tutorial-clientrpc-api.rst
+++ b/docs/source/tutorial-clientrpc-api.rst
@@ -3,58 +3,58 @@
 Using the client RPC API
 ========================
 
-In this tutorial we will build a simple command line utility that connects to a node, creates some Cash transactions and
-meanwhile dumps the transaction graph to the standard output. We will then put some simple visualisation on top. For an
-explanation on how the RPC works see :doc:`clientrpc`.
+In this tutorial we will build a simple command line utility that connects to a node, creates some cash transactions
+and dumps the transaction graph to the standard output. We will then put some simple visualisation on top. For an
+explanation on how RPC works in Corda see :doc:`clientrpc`.
 
 We start off by connecting to the node itself. For the purposes of the tutorial we will use the Driver to start up a notary
-and a node that issues/exits and moves Cash around for herself. To authenticate we will use the certificates of the nodes
-directly.
+and a Alice node that can issue, move and exit cash.
 
-Note how we configure the node to create a user that has permission to start the CashFlow.
+Here's how we configure the node to create a user that has the permissions to start the ``CashIssueFlow``,
+``CashPaymentFlow``, and ``CashExitFlow``:
 
 .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
     :language: kotlin
     :start-after: START 1
     :end-before: END 1
 
-Now we can connect to the node itself using a valid RPC login. We login using the configured user.
+Now we can connect to the node itself using a valid RPC user login and start generating transactions in a different
+thread using ``generateTransactions`` (to be defined later):
 
 .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
     :language: kotlin
     :start-after: START 2
     :end-before: END 2
+    :dedent: 8
 
-We start generating transactions in a different thread (``generateTransactions`` to be defined later) using ``proxy``,
-which exposes the full RPC interface of the node:
+``proxy`` exposes the full RPC interface of the node:
 
 .. literalinclude:: ../../core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
     :language: kotlin
     :start-after: interface CordaRPCOps
     :end-before: }
 
-.. warning:: This API is evolving and will continue to grow as new functionality and features added to Corda are made
-   available to RPC clients.
-
-The one we need in order to dump the transaction graph is ``verifiedTransactions``. The type signature tells us that the
-RPC will return a list of transactions and an Observable stream. This is a general pattern, we query some data and the
-node will return the current snapshot and future updates done to it. Observables are described in further detail in
-:doc:`clientrpc`
+The RPC operation we need in order to dump the transaction graph is ``internalVerifiedTransactionsFeed``. The type
+signature tells us that the RPC operation will return a list of transactions and an ``Observable`` stream. This is a
+general pattern, we query some data and the node will return the current snapshot and future updates done to it.
+Observables are described in further detail in :doc:`clientrpc`
 
 .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
     :language: kotlin
     :start-after: START 3
     :end-before: END 3
+    :dedent: 8
 
-The graph will be defined by nodes and edges between them. Each node represents a transaction and edges represent
-output-input relations. For now let's just print ``NODE <txhash>`` for the former and ``EDGE <txhash> <txhash>`` for the
-latter.
+The graph will be defined as follows:
+
+* Each transaction is a vertex, represented by printing ``NODE <txhash>``
+* Each input-output relationship is an edge, represented by prining ``EDGE <txhash> <txhash>``
 
 .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
     :language: kotlin
     :start-after: START 4
     :end-before: END 4
-
+    :dedent: 8
 
 Now we just need to create the transactions themselves!
 
@@ -65,17 +65,16 @@ Now we just need to create the transactions themselves!
 
 We utilise several RPC functions here to query things like the notaries in the node cluster or our own vault. These RPC
 functions also return ``Observable`` objects so that the node can send us updated values. However, we don't need updates
-here and so we mark these observables as ``notUsed``. (As a rule, you should always either subscribe to an ``Observable``
-or mark it as not used. Failing to do this will leak resources in the node.)
+here and so we mark these observables as ``notUsed`` (as a rule, you should always either subscribe to an ``Observable``
+or mark it as not used. Failing to do so will leak resources in the node).
 
 Then in a loop we generate randomly either an Issue, a Pay or an Exit transaction.
 
-The RPC we need to initiate a Cash transaction is ``startFlowDynamic`` which may start an arbitrary flow, given sufficient
-permissions to do so. We won't use this function directly, but rather a type-safe wrapper around it ``startFlow`` that
-type-checks the arguments for us.
+The RPC we need to initiate a cash transaction is ``startFlow`` which starts an arbitrary flow given sufficient
+permissions to do so.
 
 Finally we have everything in place: we start a couple of nodes, connect to them, and start creating transactions while
-listening on successfully created ones, which are dumped to the console. We just need to run it!:
+listening on successfully created ones, which are dumped to the console. We just need to run it!
 
 .. code-block:: text
 
@@ -84,12 +83,13 @@ listening on successfully created ones, which are dumped to the console. We just
     # Start it
     ./docs/source/example-code/build/install/docs/source/example-code/bin/client-rpc-tutorial Print
 
-Now let's try to visualise the transaction graph. We will use a graph drawing library called graphstream_
+Now let's try to visualise the transaction graph. We will use a graph drawing library called graphstream_.
 
 .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
     :language: kotlin
     :start-after: START 5
     :end-before: END 5
+    :dedent: 8
 
 If we run the client with ``Visualise`` we should see a simple random graph being drawn as new transactions are being created.
 
@@ -106,11 +106,9 @@ requests or responses with the Corda node.  Here's an example of both ways you c
 
 See more on plugins in :doc:`running-a-node`.
 
-.. warning:: We will be replacing the use of Kryo in the serialization framework and so additional changes here are likely.
-
 Security
 --------
-RPC credentials associated with a Client must match the permission set configured on the server Node.
+RPC credentials associated with a Client must match the permission set configured on the server node.
 This refers to both authentication (username and password) and role-based authorisation (a permissioned set of RPC operations an
 authenticated user is entitled to run).
 
@@ -161,5 +159,5 @@ You can then deploy and launch the nodes (Notary and Alice) as follows:
 With regards to the start flow RPCs, there is an extra layer of security whereby the flow to be executed has to be
 annotated with ``@StartableByRPC``. Flows without this annotation cannot execute using RPC.
 
-See more on security in :doc:`secure-coding-guidelines`,  node configuration in :doc:`corda-configuration-file` and
-Cordformation in :doc:`running-a-node`.
+See more on security in :doc:`secure-coding-guidelines`, node configuration in :doc:`corda-configuration-file` and
+Cordformation in :doc:`running-a-node`.
\ No newline at end of file
diff --git a/docs/source/tutorial-contract.rst b/docs/source/tutorial-contract.rst
index 2aca2177f7..11e6ef0755 100644
--- a/docs/source/tutorial-contract.rst
+++ b/docs/source/tutorial-contract.rst
@@ -32,26 +32,16 @@ This lifecycle for commercial paper is illustrated in the diagram below:
 
 .. image:: resources/contract-cp.png
 
-Where to put your code
-----------------------
-
-A CorDapp is a collection of contracts, state definitions, flows and other ways to extend the Corda platform.
-To create one you would typically clone the CorDapp template project ("cordapp-template"), which provides an example
-structure for the code. Alternatively you can just create a Java-style project as normal, with your choice of build
-system (Maven, Gradle, etc), then add a dependency on ``net.corda.core:0.X`` where X is the milestone number you are
-depending on. The core module defines the base classes used in this tutorial.
-
 Starting the commercial paper class
 -----------------------------------
 
 A smart contract is a class that implements the ``Contract`` interface. This can be either implemented directly, as done
 here, or by subclassing an abstract contract such as ``OnLedgerAsset``. The heart of any contract in Corda is the
-``verify()`` function, which determined whether any given transaction is valid. This example shows how to write a
-``verify()`` function from scratch.
+``verify`` function, which determines whether a given transaction is valid. This example shows how to write a
+``verify`` function from scratch.
 
-You can see the full Kotlin version of this contract in the code as ``CommercialPaperLegacy``. The code in this
-tutorial is available in both Kotlin and Java. You can quickly switch between them to get a feeling for how
-Kotlin syntax works.
+The code in this tutorial is available in both Kotlin and Java. You can quickly switch between them to get a feeling
+for Kotlin's syntax.
 
 .. container:: codeset
 
@@ -72,13 +62,8 @@ Kotlin syntax works.
           }
       }
 
-Every contract must have at least a ``verify()`` method.
-
-.. note:: In the future there will be a way to bind legal contract prose to a smart contract implementation,
-          that may take precedence over the code in case of a dispute.
-
-The verify method returns nothing. This is intentional: the function either completes correctly, or throws an exception,
-in which case the transaction is rejected.
+Every contract must have at least a ``verify`` method. The verify method returns nothing. This is intentional: the
+function either completes correctly, or throws an exception, in which case the transaction is rejected.
 
 So far, so simple. Now we need to define the commercial paper *state*, which represents the fact of ownership of a
 piece of issued paper.
@@ -90,111 +75,21 @@ A state is a class that stores data that is checked by the contract. A commercia
 
 .. image:: resources/contract-cp-state.png
 
-
 .. container:: codeset
 
-   .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
+        :language: kotlin
+        :start-after: DOCSTART 1
+        :end-before: DOCEND 1
 
-      data class State(
-              val issuance: PartyAndReference,
-              override val owner: AbstractParty,
-              val faceValue: Amount<Issued<Currency>>,
-              val maturityDate: Instant
-      ) : OwnableState {
-          override val contract = "net.corda.finance.contracts.CommercialPaper"
-          override val participants = listOf(owner)
-
-          fun withoutOwner() = copy(owner = AnonymousParty(NullPublicKey))
-          override fun withNewOwner(newOwner: AbstractParty) = Pair(Commands.Move(), copy(owner = newOwner))
-      }
-
-   .. sourcecode:: java
-
-      public static class State implements OwnableState {
-          private PartyAndReference issuance;
-          private AbstractParty owner;
-          private Amount<Issued<Currency>> faceValue;
-          private Instant maturityDate;
-
-          public State() {
-          }  // For serialization
-
-          public State(PartyAndReference issuance, PublicKey owner, Amount<Issued<Currency>> faceValue,
-                       Instant maturityDate) {
-              this.issuance = issuance;
-              this.owner = owner;
-              this.faceValue = faceValue;
-              this.maturityDate = maturityDate;
-          }
-
-          public State copy() {
-              return new State(this.issuance, this.owner, this.faceValue, this.maturityDate);
-          }
-
-          @NotNull
-          @Override
-          public Pair<CommandData, OwnableState> withNewOwner(@NotNull AbstractParty newOwner) {
-              return new Pair<>(new Commands.Move(), new State(this.issuance, newOwner, this.faceValue, this.maturityDate));
-          }
-
-          public PartyAndReference getIssuance() {
-              return issuance;
-          }
-
-          public AbstractParty getOwner() {
-              return owner;
-          }
-
-          public Amount<Issued<Currency>> getFaceValue() {
-              return faceValue;
-          }
-
-          public Instant getMaturityDate() {
-              return maturityDate;
-          }
-
-          @NotNull
-          @Override
-          public Contract getContract() {
-              return new JavaCommercialPaper();
-          }
-
-          @Override
-          public boolean equals(Object o) {
-              if (this == o) return true;
-              if (o == null || getClass() != o.getClass()) return false;
-
-              State state = (State) o;
-
-              if (issuance != null ? !issuance.equals(state.issuance) : state.issuance != null) return false;
-              if (owner != null ? !owner.equals(state.owner) : state.owner != null) return false;
-              if (faceValue != null ? !faceValue.equals(state.faceValue) : state.faceValue != null) return false;
-              return !(maturityDate != null ? !maturityDate.equals(state.maturityDate) : state.maturityDate != null);
-          }
-
-          @Override
-          public int hashCode() {
-              int result = issuance != null ? issuance.hashCode() : 0;
-              result = 31 * result + (owner != null ? owner.hashCode() : 0);
-              result = 31 * result + (faceValue != null ? faceValue.hashCode() : 0);
-              result = 31 * result + (maturityDate != null ? maturityDate.hashCode() : 0);
-              return result;
-          }
-
-          @NotNull
-          @Override
-          public List<AbstractParty> getParticipants() {
-              return ImmutableList.of(this.owner);
-          }
-      }
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/State.java
+        :language: java
+        :start-after: DOCSTART 1
+        :end-before: DOCEND 1
 
 
 We define a class that implements the ``ContractState`` interface.
 
-The ``ContractState`` interface requires us to provide a ``getContract`` method that returns an instance of the
-contract class itself. In future, this may change to support dynamic loading of contracts with versioning
-and signing constraints, but for now this is how it's written.
-
 We have four fields in our state:
 
 * ``issuance``, a reference to a specific piece of commercial paper issued by some party.
@@ -234,39 +129,17 @@ Let's define a few commands now:
 
 .. container:: codeset
 
-   .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
+        :language: kotlin
+        :start-after: DOCSTART 2
+        :end-before: DOCEND 2
+        :dedent: 4
 
-      interface Commands : CommandData {
-          class Move : TypeOnlyCommandData(), Commands
-          class Redeem : TypeOnlyCommandData(), Commands
-          class Issue : TypeOnlyCommandData(), Commands
-      }
-
-
-   .. sourcecode:: java
-
-      public static class Commands implements core.contract.Command {
-          public static class Move extends Commands {
-              @Override
-              public boolean equals(Object obj) {
-                  return obj instanceof Move;
-              }
-          }
-
-          public static class Redeem extends Commands {
-              @Override
-              public boolean equals(Object obj) {
-                  return obj instanceof Redeem;
-              }
-          }
-
-          public static class Issue extends Commands {
-              @Override
-              public boolean equals(Object obj) {
-                  return obj instanceof Issue;
-              }
-          }
-      }
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/CommercialPaper.java
+        :language: java
+        :start-after: DOCSTART 2
+        :end-before: DOCEND 2
+        :dedent: 4
 
 We define a simple grouping interface or static class, this gives us a type that all our commands have in common,
 then we go ahead and create three commands: ``Move``, ``Redeem``, ``Issue``. ``TypeOnlyCommandData`` is a helpful utility
@@ -287,22 +160,17 @@ run two contracts one time each: Cash and CommercialPaper.
 
 .. container:: codeset
 
-   .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
+        :language: kotlin
+        :start-after: DOCSTART 3
+        :end-before: DOCEND 3
+        :dedent: 4
 
-      override fun verify(tx: LedgerTransaction) {
-          // Group by everything except owner: any modification to the CP at all is considered changing it fundamentally.
-          val groups = tx.groupStates(State::withoutOwner)
-
-          // There are two possible things that can be done with this CP. The first is trading it. The second is redeeming
-          // it for cash on or after the maturity date.
-          val command = tx.commands.requireSingleCommand<CommercialPaper.Commands>()
-
-   .. sourcecode:: java
-
-      @Override
-      public void verify(LedgerTransaction tx) {
-          List<InOutGroup<State, State>> groups = tx.groupStates(State.class, State::withoutOwner);
-          CommandWithParties<Command> cmd = requireSingleCommand(tx.getCommands(), Commands.class);
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/CommercialPaper.java
+        :language: java
+        :start-after: DOCSTART 3
+        :end-before: DOCEND 3
+        :dedent: 4
 
 We start by using the ``groupStates`` method, which takes a type and a function. State grouping is a way of ensuring
 your contract can handle multiple unrelated states of the same type in the same transaction, which is needed for
@@ -312,8 +180,6 @@ The second line does what the code suggests: it searches for a command object th
 ``CommercialPaper.Commands`` supertype, and either returns it, or throws an exception if there's zero or more than one
 such command.
 
-.. _state_ref:
-
 Using state groups
 ------------------
 
@@ -362,12 +228,12 @@ Here are some code examples:
    .. sourcecode:: kotlin
 
       // Type of groups is List<InOutGroup<State, Pair<PartyReference, Currency>>>
-      val groups = tx.groupStates() { it: Cash.State -> Pair(it.deposit, it.amount.currency) }
-      for ((inputs, outputs, key) in groups) {
-          // Either inputs or outputs could be empty.
-          val (deposit, currency) = key
+      val groups = tx.groupStates { it: Cash.State -> it.amount.token }
+        for ((inputs, outputs, key) in groups) {
+            // Either inputs or outputs could be empty.
+            val (deposit, currency) = key
 
-          ...
+            ...
       }
 
    .. sourcecode:: java
@@ -414,101 +280,37 @@ in equals and hashCode.
 
 Checking the requirements
 -------------------------
-
 After extracting the command and the groups, we then iterate over each group and verify it meets the required business
 logic.
 
 .. container:: codeset
 
-   .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
+        :language: kotlin
+        :start-after: DOCSTART 4
+        :end-before: DOCEND 4
+        :dedent: 8
 
-      val timeWindow: TimeWindow? = tx.timeWindow
-
-      for ((inputs, outputs, key) in groups) {
-          when (command.value) {
-              is Commands.Move -> {
-                  val input = inputs.single()
-                  requireThat {
-                      "the transaction is signed by the owner of the CP" using (input.owner.owningKey in command.signers)
-                      "the state is propagated" using (outputs.size == 1)
-                      // Don't need to check anything else, as if outputs.size == 1 then the output is equal to
-                      // the input ignoring the owner field due to the grouping.
-                  }
-              }
-
-              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 time = timeWindow?.fromTime ?: throw IllegalArgumentException("Redemptions must be timestamped")
-                  requireThat {
-                      "the paper must have matured" using (time >= input.maturityDate)
-                      "the received amount equals the face value" using (received == input.faceValue)
-                      "the paper must be destroyed" using outputs.isEmpty()
-                      "the transaction is signed by the owner of the CP" using (input.owner.owningKey in command.signers)
-                  }
-              }
-
-              is Commands.Issue -> {
-                  val output = outputs.single()
-                  val time = timeWindow?.untilTime ?: throw IllegalArgumentException("Issuances must be timestamped")
-                  requireThat {
-                      // Don't allow people to issue commercial paper under other entities identities.
-                      "output states are issued by a command signer" using (output.issuance.party.owningKey in command.signers)
-                      "output values sum to more than the inputs" using (output.faceValue.quantity > 0)
-                      "the maturity date is not in the past" using (time < output.maturityDate)
-                      // Don't allow an existing CP state to be replaced by this issuance.
-                      "can't reissue an existing state" by inputs.isEmpty()
-                  }
-              }
-
-              else -> throw IllegalArgumentException("Unrecognised command")
-          }
-      }
-
-   .. sourcecode:: java
-
-      Timestamp time = tx.getTimestamp();   // Can be null/missing.
-      for (InOutGroup<State> group : groups) {
-          List<State> inputs = group.getInputs();
-          List<State> outputs = group.getOutputs();
-
-          // For now do not allow multiple pieces of CP to trade in a single transaction. Study this more!
-          State input = single(filterIsInstance(inputs, State.class));
-
-          checkState(cmd.getSigners().contains(input.getOwner()), "the transaction is signed by the owner of the CP");
-
-          if (cmd.getValue() instanceof JavaCommercialPaper.Commands.Move) {
-              checkState(outputs.size() == 1, "the state is propagated");
-              // Don't need to check anything else, as if outputs.size == 1 then the output is equal to
-              // the input ignoring the owner field due to the grouping.
-          } else if (cmd.getValue() instanceof JavaCommercialPaper.Commands.Redeem) {
-              TimeWindow timeWindow = tx.getTimeWindow();
-              Instant time = null == timeWindow
-                       ? null
-                       : timeWindow.getUntilTime();
-              Amount<Issued<Currency>> received = CashKt.sumCashBy(tx.getOutputs(), input.getOwner());
-
-              checkState(received.equals(input.getFaceValue()), "received amount equals the face value");
-              checkState(time != null && !time.isBefore(input.getMaturityDate(), "the paper must have matured");
-              checkState(outputs.isEmpty(), "the paper must be destroyed");
-          } else if (cmd.getValue() instanceof JavaCommercialPaper.Commands.Issue) {
-              // .. etc .. (see Kotlin for full definition)
-          }
-      }
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/CommercialPaper.java
+        :language: java
+        :start-after: DOCSTART 4
+        :end-before: DOCEND 4
+        :dedent: 8
 
 This loop is the core logic of the contract.
 
 The first line simply gets the timestamp out of the transaction. Timestamping of transactions is optional, so a time
 may be missing here. We check for it being null later.
 
-.. note:: In future timestamping may be mandatory for all transactions.
-
 .. warning:: In the Kotlin version as long as we write a comparison with the transaction time first the compiler will
    verify we didn't forget to check if it's missing. Unfortunately due to the need for smooth Java interop, this
    check won't happen if we write e.g. ``someDate > time``, it has to be ``time < someDate``. So it's good practice to
    always write the transaction timestamp first.
 
+Next, we take one of three paths, depending on what the type of the command object is.
+
+**If the command is a ``Move`` command:**
+
 The first line (first three lines in Java) impose a requirement that there be a single piece of commercial paper in
 this group. We do not allow multiple units of CP to be split or merged even if they are owned by the same owner. The
 ``single()`` method is a static *extension method* defined by the Kotlin standard library: given a list, it throws an
@@ -520,23 +322,23 @@ behind the scenes, the code compiles to the same bytecodes.
 Next, we check that the transaction was signed by the public key that's marked as the current owner of the commercial
 paper. Because the platform has already verified all the digital signatures before the contract begins execution,
 all we have to do is verify that the owner's public key was one of the keys that signed the transaction. The Java code
-is straightforward: we are simply using the ``Preconditions.checkState`` method from Guava. The Kotlin version looks a little odd: we have a *requireThat* construct that looks like it's
-built into the language. In fact *requireThat* is an ordinary function provided by the platform's contract API. Kotlin
-supports the creation of *domain specific languages* through the intersection of several features of the language, and
-we use it here to support the natural listing of requirements. To see what it compiles down to, look at the Java version.
-Each ``"string" using (expression)`` statement inside a ``requireThat`` turns into an assertion that the given expression is
-true, with an ``IllegalStateException`` being thrown that contains the string if not. It's just another way to write out a regular
-assertion, but with the English-language requirement being put front and center.
+is straightforward: we are simply using the ``Preconditions.checkState`` method from Guava. The Kotlin version looks a
+little odd: we have a *requireThat* construct that looks like it's built into the language. In fact *requireThat* is an
+ordinary function provided by the platform's contract API. Kotlin supports the creation of *domain specific languages*
+through the intersection of several features of the language, and we use it here to support the natural listing of
+requirements. To see what it compiles down to, look at the Java version. Each ``"string" using (expression)`` statement
+inside a ``requireThat`` turns into an assertion that the given expression is true, with an ``IllegalStateException``
+being thrown that contains the string if not. It's just another way to write out a regular assertion, but with the
+English-language requirement being put front and center.
 
-Next, we take one of two paths, depending on what the type of the command object is.
+Next, we simply verify that the output state is actually present: a move is not allowed to delete the CP from the ledger.
+The grouping logic already ensured that the details are identical and haven't been changed, save for the public key of
+the owner.
 
-If the command is a ``Move`` command, then we simply verify that the output state is actually present: a move is not
-allowed to delete the CP from the ledger. The grouping logic already ensured that the details are identical and haven't
-been changed, save for the public key of the owner.
+**If the command is a ``Redeem`` command, then the requirements are more complex:**
 
-If the command is a ``Redeem`` command, then the requirements are more complex:
-
-1. We want to see that the face value of the CP is being moved as a cash claim against some party, that is, the
+1. We still check there is a CP input state.
+2. We want to see that the face value of the CP is being moved as a cash claim against some party, that is, the
    issuer of the CP is really paying back the face value.
 2. The transaction must be happening after the maturity date.
 3. The commercial paper must *not* be propagated by this transaction: it must be deleted, by the group having no
@@ -551,8 +353,9 @@ represented in the outputs! So we can see that this contract imposes a limitatio
 transaction: you are not allowed to move currencies in the same transaction that the CP does not involve. This
 limitation could be addressed with better APIs, if it were to be a real limitation.
 
-Finally, we support an ``Issue`` command, to create new instances of commercial paper on the ledger. It likewise
-enforces various invariants upon the issuance.
+**Finally, we support an ``Issue`` command, to create new instances of commercial paper on the ledger.**
+
+It likewise enforces various invariants upon the issuance, such as, there must be one output CP state, for instance.
 
 This contract is simple and does not implement all the business logic a real commercial paper lifecycle
 management program would. For instance, there is no logic requiring a signature from the issuer for redemption:
@@ -577,7 +380,6 @@ error message.
 
 Testing contracts with this domain specific language is covered in the separate tutorial, :doc:`tutorial-test-dsl`.
 
-
 Adding a generation API to your contract
 ----------------------------------------
 
@@ -602,13 +404,11 @@ a method to wrap up the issuance process:
 
 .. container:: codeset
 
-   .. sourcecode:: kotlin
-
-      fun generateIssue(issuance: PartyAndReference, faceValue: Amount<Issued<Currency>>, maturityDate: Instant,
-                        notary: Party): TransactionBuilder {
-          val state = State(issuance, issuance.party, faceValue, maturityDate)
-          return TransactionBuilder(notary = notary).withItems(state, Command(Commands.Issue(), issuance.party.owningKey))
-      }
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
+        :language: kotlin
+        :start-after: DOCSTART 5
+        :end-before: DOCEND 5
+        :dedent: 4
 
 We take a reference that points to the issuing party (i.e. the caller) and which can contain any internal
 bookkeeping/reference numbers that we may require. The reference field is an ideal place to put (for example) a
@@ -625,12 +425,33 @@ outputs and commands to it and is designed to be passed around, potentially betw
 The function we define creates a ``CommercialPaper.State`` object that mostly just uses the arguments we were given,
 but it fills out the owner field of the state to be the same public key as the issuing party.
 
+We then combine the ``CommercialPaper.State`` object with a reference to the ``CommercialPaper`` contract, which is
+defined inside the contract itself
+
+.. container:: codeset
+
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
+        :language: kotlin
+        :start-after: DOCSTART 8
+        :end-before: DOCEND 8
+        :dedent: 4
+
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/contract/CommercialPaper.java
+        :language: java
+        :start-after: DOCSTART 1
+        :end-before: DOCEND 1
+        :dedent: 4
+
+This value, which is the fully qualified class name of the contract, tells the Corda platform where to find the contract
+code that should be used to validate a transaction containing an output state of this contract type. Typically the contract
+code will be included in the transaction as an attachment (see :doc:`tutorial-attachments`).
+
 The returned partial transaction has a ``Command`` object as a parameter. This is a container for any object
 that implements the ``CommandData`` interface, along with a list of keys that are expected to sign this transaction. In this case,
 issuance requires that the issuing party sign, so we put the key of the party there.
 
 The ``TransactionBuilder`` has a convenience ``withItems`` method that takes a variable argument list. You can pass in
-any ``StateAndRef`` (input), ``ContractState`` (output) or ``Command`` objects and it'll build up the transaction
+any ``StateAndRef`` (input), ``StateAndContract`` (output) or ``Command`` objects and it'll build up the transaction
 for you.
 
 There's one final thing to be aware of: we ask the caller to select a *notary* that controls this state and
@@ -643,13 +464,11 @@ What about moving the paper, i.e. reassigning ownership to someone else?
 
 .. container:: codeset
 
-   .. sourcecode:: kotlin
-
-      fun generateMove(tx: TransactionBuilder, paper: StateAndRef<State>, newOwner: AbstractParty) {
-          tx.addInputState(paper)
-          tx.addOutputState(paper.state.data.withOwner(newOwner))
-          tx.addCommand(Command(Commands.Move(), paper.state.data.owner.owningKey))
-      }
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
+        :language: kotlin
+        :start-after: DOCSTART 6
+        :end-before: DOCEND 6
+        :dedent: 4
 
 Here, the method takes a pre-existing ``TransactionBuilder`` and adds to it. This is correct because typically
 you will want to combine a sale of CP atomically with the movement of some other asset, such as cash. So both
@@ -668,15 +487,11 @@ Finally, we can do redemption.
 
 .. container:: codeset
 
-   .. sourcecode:: kotlin
-
-      @Throws(InsufficientBalanceException::class)
-      fun generateRedeem(tx: TransactionBuilder, paper: StateAndRef<State>, services: ServiceHub) {
-          // Add the cash movement using the states in our vault.
-          Cash.generateSpend(services, tx, paper.state.data.faceValue.withoutIssuer(), paper.state.data.owner)
-          tx.addInputState(paper)
-          tx.addCommand(Command(Commands.Redeem(), paper.state.data.owner.owningKey))
-      }
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
+        :language: kotlin
+        :start-after: DOCSTART 7
+        :end-before: DOCEND 7
+        :dedent: 4
 
 Here we can see an example of composing contracts together. When an owner wishes to redeem the commercial paper, the
 issuer (i.e. the caller) must gather cash from its vault and send the face value to the owner of the paper.
@@ -747,15 +562,14 @@ Encumbrances
 
 All contract states may be *encumbered* by up to one other state, which we call an **encumbrance**.
 
-The encumbrance state, if present, forces additional controls over the encumbered state, since the encumbrance state contract
-will also be verified during the execution of the transaction. For example, a contract state could be encumbered
-with a time-lock contract state; the state is then only processable in a transaction that verifies that the time
-specified in the encumbrance time-lock has passed.
+The encumbrance state, if present, forces additional controls over the encumbered state, since the encumbrance state
+contract will also be verified during the execution of the transaction. For example, a contract state could be
+encumbered with a time-lock contract state; the state is then only processable in a transaction that verifies that the
+time specified in the encumbrance time-lock has passed.
 
-The encumbered state refers to its encumbrance by index, and the referred encumbrance state
-is an output state in a particular position on the same transaction that created the encumbered state. Note that an
-encumbered state that is being consumed must have its encumbrance consumed in the same transaction, otherwise the
-transaction is not valid.
+The encumbered state refers to its encumbrance by index, and the referred encumbrance state is an output state in a
+particular position on the same transaction that created the encumbered state. Note that an encumbered state that is
+being consumed must have its encumbrance consumed in the same transaction, otherwise the transaction is not valid.
 
 The encumbrance reference is optional in the ``ContractState`` interface:
 
diff --git a/docs/source/tutorial-integration-testing.rst b/docs/source/tutorial-integration-testing.rst
index 0cbed18a15..f2e410d347 100644
--- a/docs/source/tutorial-integration-testing.rst
+++ b/docs/source/tutorial-integration-testing.rst
@@ -4,14 +4,14 @@ Integration testing
 Integration testing involves bringing up nodes locally and testing
 invariants about them by starting flows and inspecting their state.
 
-In this tutorial we will bring up three nodes Alice, Bob and a
-Notary. Alice will issue Cash to Bob, then Bob will send this Cash
+In this tutorial we will bring up three nodes - Alice, Bob and a
+notary. Alice will issue cash to Bob, then Bob will send this cash
 back to Alice. We will see how to test some simple deterministic and
 nondeterministic invariants in the meantime.
 
-(Note that this example where Alice is self-issuing Cash is purely for
-demonstration purposes, in reality Cash would be issued by a bank and
-subsequently passed around.)
+.. note:: This example where Alice is self-issuing cash is purely for
+   demonstration purposes, in reality, cash would be issued by a bank
+   and subsequently passed around.
 
 In order to spawn nodes we will use the Driver DSL. This DSL allows
 one to start up node processes from code. It manages a network map
@@ -21,53 +21,55 @@ service and safe shutting down of nodes in the background.
     :language: kotlin
     :start-after: START 1
     :end-before: END 1
+    :dedent: 8
 
-The above code creates a ``User`` permissioned to start the
-``CashFlow`` protocol. It then starts up Alice and Bob with this user,
-allowing us to later connect to the nodes.
+The above code starts three nodes:
 
-Then the notary is started up. Note that we need to add
-``ValidatingNotaryService`` as an advertised service in order for this
-node to serve notary functionality. This is also where flows added in
-plugins should be specified. Note also that we won't connect to the
-notary directly, so there's no need to pass in the test ``User``.
+* Alice, who has user permissions to start the ``CashIssueFlow`` and
+  ``CashPaymentFlow`` flows
+* Bob, who only has user permissions to start the ``CashPaymentFlow``
+* A notary that offers a ``ValidatingNotaryService``. We won't connect
+  to the notary directly, so there's no need to provide a ``User``
 
 The ``startNode`` function returns a future that completes once the
 node is fully started. This allows starting of the nodes to be
 parallel. We wait on these futures as we need the information
-returned; their respective ``NodeHandles`` s. After getting the handles we
-wait for both parties to register with the network map to ensure we don't
-have race conditions with network map registration.
+returned; their respective ``NodeHandles`` s.
 
 .. literalinclude:: example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
     :language: kotlin
     :start-after: START 2
     :end-before: END 2
+    :dedent: 12
 
-Next we connect to Alice and Bob respectively from the test process
-using the test user we created. Then we establish RPC links that allow
-us to start flows and query state.
+After getting the handles we wait for both parties to register with
+the network map to ensure we don't have race conditions with network
+map registration. Next we connect to Alice and Bob respectively from
+the test process using the test user we created. Then we establish RPC
+links that allow us to start flows and query state.
 
 .. literalinclude:: example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
     :language: kotlin
     :start-after: START 3
     :end-before: END 3
+    :dedent: 12
 
 We will be interested in changes to Alice's and Bob's vault, so we
 query a stream of vault updates from each.
 
-Now that we're all set up we can finally get some Cash action going!
+Now that we're all set up we can finally get some cash action going!
 
 .. literalinclude:: example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
     :language: kotlin
     :start-after: START 4
     :end-before: END 4
+    :dedent: 12
 
 The first loop creates 10 threads, each starting a ``CashFlow`` flow
 on the Alice node. We specify that we want to issue ``i`` dollars to
-Bob, using the Notary as the notary responsible for notarising the
+Bob, setting our notary as the notary responsible for notarising the
 created states. Note that no notarisation will occur yet as we're not
-spending any states, only entering new ones to the ledger.
+spending any states, only creating new ones on the ledger.
 
 We started the flows from different threads for the sake of the
 tutorial, to demonstrate how to test non-determinism, which is what
@@ -76,20 +78,22 @@ the ``expectEvents`` block does.
 The Expect DSL allows ordering constraints to be checked on a stream
 of events. The above code specifies that we are expecting 10 updates
 to be emitted on the ``bobVaultUpdates`` stream in unspecified order
-(this is what the ``parallel`` construct does). We specify a
+(this is what the ``parallel`` construct does). We specify an
 (otherwise optional) ``match`` predicate to identify specific updates
 we are interested in, which we then print.
 
 If we run the code written so far we should see 4 nodes starting up
-(Alice,Bob,Notary + implicit Network Map service), then 10 logs of Bob
-receiving 1,2,...10 dollars from Alice in some unspecified order.
+(Alice, Bob, the notary and an implicit Network Map service), then
+10 logs of Bob receiving 1,2,...10 dollars from Alice in some unspecified
+order.
 
-Next we want Bob to send this Cash back to Alice.
+Next we want Bob to send this cash back to Alice.
 
 .. literalinclude:: example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
     :language: kotlin
     :start-after: START 5
     :end-before: END 5
+    :dedent: 12
 
 This time we'll do it sequentially. We make Bob pay 1,2,..10 dollars
 to Alice in order. We make sure that a the ``CashFlow`` has finished
@@ -109,8 +113,7 @@ To run the complete test you can open
 ``example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt``
 from IntelliJ and run the test, or alternatively use gradle:
 
-
 .. sourcecode:: bash
 
      # Run example-code integration tests
-     ./gradlew docs/source/example-code:integrationTest -i
+     ./gradlew docs/source/example-code:integrationTest -i
\ No newline at end of file
diff --git a/docs/source/tutorial-tear-offs.rst b/docs/source/tutorial-tear-offs.rst
index 12a1ec8512..80d8395112 100644
--- a/docs/source/tutorial-tear-offs.rst
+++ b/docs/source/tutorial-tear-offs.rst
@@ -1,39 +1,32 @@
 Transaction tear-offs
 =====================
 
-Example of usage
-----------------
-Let’s focus on a code example. We want to construct a transaction with commands containing interest rate fix data as in:
-:doc:`oracles`. After construction of a partial transaction, with included ``Fix`` commands in it, we want to send it
-to the Oracle for checking and signing. To do so we need to specify which parts of the transaction are going to be
-revealed. That can be done by constructing filtering function over fields of ``WireTransaction`` of type ``(Any) ->
-Boolean``.
+Suppose we want to construct a transaction that includes commands containing interest rate fix data as in
+:doc:`oracles`. Before sending the transaction to the oracle to obtain its signature, we need to filter out every part
+of the transaction except for the ``Fix`` commands.
+
+To do so, we need to create a filtering function that specifies which fields of the transaction should be included.
+Each field will only be included if the filtering function returns `true` when the field is passed in as input.
 
 .. container:: codeset
 
-   .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt
+        :language: kotlin
+        :start-after: DOCSTART 1
+        :end-before: DOCEND 1
+        :dedent: 4
 
-        val partialTx = ...
-        val oracle: Party = ...
-        fun filtering(elem: Any): Boolean {
-                return when (elem) {
-                    is Command -> oracleParty.owningKey in elem.signers && elem.value is Fix
-                    else -> false
-                }
-        }
-
-Assuming that we already assembled partialTx with some commands and know the identity of Oracle service, we construct
-filtering function over commands - ``filtering``. It performs type checking and filters only ``Fix`` commands as in
-IRSDemo example. Then we can construct ``FilteredTransaction``:
+We can now use our filtering function to construct a ``FilteredTransaction``:
 
 .. container:: codeset
 
-   .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt
+        :language: kotlin
+        :start-after: DOCSTART 2
+        :end-before: DOCEND 2
+        :dedent: 4
 
-        val wtx: WireTransaction = partialTx.toWireTransaction()
-        val ftx: FilteredTransaction = wtx.buildFilteredTransaction(filtering)
-
-In the Oracle example this step takes place in ``RatesFixFlow`` by overriding ``filtering`` function, see:
+In the Oracle example this step takes place in ``RatesFixFlow`` by overriding the ``filtering`` function. See
 :ref:`filtering_ref`.
 
 Both ``WireTransaction`` and ``FilteredTransaction`` inherit from ``TraversableTransaction``, so access to the
@@ -42,45 +35,25 @@ transaction components is exactly the same. Note that unlike ``WireTransaction``
 
 .. container:: codeset
 
-   .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt
+        :language: kotlin
+        :start-after: DOCSTART 3
+        :end-before: DOCEND 3
+        :dedent: 4
 
-        // Direct access to included commands, inputs, outputs, attachments etc.
-        val cmds: List<Command> = ftx.commands
-        val ins: List<StateRef> = ftx.inputs
-        val timeWindow: TimeWindow? = ftx.timeWindow
-        ...
+The following code snippet is taken from ``NodeInterestRates.kt`` and implements a signing part of an Oracle.
 
 .. literalinclude:: ../../samples/irs-demo/src/main/kotlin/net/corda/irs/api/NodeInterestRates.kt
     :language: kotlin
     :start-after: DOCSTART 1
     :end-before: DOCEND 1
-
-Above code snippet is taken from ``NodeInterestRates.kt`` file and implements a signing part of an Oracle. You can
-check only leaves using ``ftx.checkWithFun { check(it) }`` and then verify obtained ``FilteredTransaction`` to see
-if its data belongs to ``WireTransaction`` with provided ``id``. All you need is the root hash
-of the full transaction:
-
-.. container:: codeset
-
-   .. sourcecode:: kotlin
-
-        if (!ftx.verify(merkleRoot)){
-                throw MerkleTreeException("Rate Fix Oracle: Couldn't verify partial Merkle tree.")
-        }
-
-Or combine the two steps together:
-
-.. container:: codeset
-
-   .. sourcecode:: kotlin
-
-        ftx.verifyWithFunction(merkleRoot, ::check)
+    :dedent: 8
 
 .. note:: The way the ``FilteredTransaction`` is constructed ensures that after signing of the root hash it's impossible
-to add or remove components (leaves). However, it can happen that having transaction with multiple commands one party
-reveals only subset of them to the Oracle. As signing is done now over the Merkle root hash, the service signs all
-commands of given type, even though it didn't see all of them. In the case however where all of the commands should be
-visible to an Oracle, one can type ``ftx.checkAllComponentsVisible(COMMANDS_GROUP)`` before invoking ``ftx.verify``.
-``checkAllComponentsVisible`` is using a sophisticated underlying partial Merkle tree check to guarantee that all of
-the components of a particular group that existed in the original ``WireTransaction`` are included in the received
-``FilteredTransaction``.
+   to add or remove components (leaves). However, it can happen that having transaction with multiple commands one party
+   reveals only subset of them to the Oracle. As signing is done now over the Merkle root hash, the service signs all
+   commands of given type, even though it didn't see all of them. In the case however where all of the commands should be
+   visible to an Oracle, one can type ``ftx.checkAllComponentsVisible(COMMANDS_GROUP)`` before invoking ``ftx.verify``.
+   ``checkAllComponentsVisible`` is using a sophisticated underlying partial Merkle tree check to guarantee that all of
+   the components of a particular group that existed in the original ``WireTransaction`` are included in the received
+   ``FilteredTransaction``.
\ No newline at end of file
diff --git a/docs/source/tutorial-test-dsl.rst b/docs/source/tutorial-test-dsl.rst
index 2eb870c781..8bfbab79b0 100644
--- a/docs/source/tutorial-test-dsl.rst
+++ b/docs/source/tutorial-test-dsl.rst
@@ -52,27 +52,17 @@ We will start with defining helper function that returns a ``CommercialPaper`` s
 
 .. container:: codeset
 
-    .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+        :language: kotlin
+        :start-after: DOCSTART 1
+        :end-before: DOCEND 1
+        :dedent: 4
 
-        fun getPaper(): ICommercialPaperState = CommercialPaper.State(
-            issuance = MEGA_CORP.ref(123),
-            owner = MEGA_CORP,
-            faceValue = 1000.DOLLARS `issued by` MEGA_CORP.ref(123),
-            maturityDate = TEST_TX_TIME + 7.days
-        )
-
-    .. sourcecode:: java
-
-        private final OpaqueBytes defaultRef = new OpaqueBytes(new byte[]{123});
-
-        private ICommercialPaperState getPaper() {
-            return new JavaCommercialPaper.State(
-                getMEGA_CORP().ref(defaultRef),
-                getMEGA_CORP(),
-                issuedBy(DOLLARS(1000), getMEGA_CORP().ref(defaultRef)),
-                getTEST_TX_TIME().plus(7, ChronoUnit.DAYS)
-            );
-        }
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
+        :language: java
+        :start-after: DOCSTART 1
+        :end-before: DOCEND 1
+        :dedent: 4
 
 It's a ``CommercialPaper`` issued by ``MEGA_CORP`` with face value of $1000 and maturity date in 7 days.
 
@@ -87,7 +77,7 @@ Let's add a ``CommercialPaper`` transaction:
             val inState = getPaper()
             ledger {
                 transaction {
-                    input(inState)
+                    input(CommercialPaper.CP_PROGRAM_ID) { inState }
                 }
             }
         }
@@ -129,65 +119,33 @@ last line of ``transaction``:
 
 .. container:: codeset
 
-    .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+        :language: kotlin
+        :start-after: DOCSTART 2
+        :end-before: DOCEND 2
+        :dedent: 4
 
-        @Test
-        fun simpleCP() {
-            val inState = getPaper()
-            ledger {
-                transaction {
-                    input(inState)
-                    this.verifies()
-                }
-            }
-        }
-
-    .. sourcecode:: java
-
-        @Test
-        public void simpleCP() {
-            ICommercialPaperState inState = getPaper();
-            ledger(l -> {
-                l.transaction(tx -> {
-                    tx.input(inState);
-                    return tx.verifies();
-                });
-                return Unit.INSTANCE;
-            });
-        }
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
+        :language: java
+        :start-after: DOCSTART 2
+        :end-before: DOCEND 2
+        :dedent: 4
 
 Let's take a look at a transaction that fails.
 
 .. container:: codeset
 
-    .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+        :language: kotlin
+        :start-after: DOCSTART 3
+        :end-before: DOCEND 3
+        :dedent: 4
 
-        @Test
-        fun simpleCPMove() {
-            val inState = getPaper()
-            ledger {
-                transaction {
-                    input(inState)
-                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                    this.verifies()
-                }
-            }
-        }
-
-    .. sourcecode:: java
-
-        @Test
-        public void simpleCPMove() {
-            ICommercialPaperState inState = getPaper();
-            ledger(l -> {
-                l.transaction(tx -> {
-                    tx.input(inState);
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
-                    return tx.verifies();
-                });
-                return Unit.INSTANCE;
-            });
-        }
+            .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
+:language: java
+                :start-after: DOCSTART 3
+                :end-before: DOCEND 3
+                :dedent: 4
 
 When run, that code produces the following error:
 
@@ -206,71 +164,33 @@ However we can specify that this is an intended behaviour by changing ``this.ver
 
 .. container:: codeset
 
-    .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+        :language: kotlin
+        :start-after: DOCSTART 4
+        :end-before: DOCEND 4
+        :dedent: 4
 
-        @Test
-        fun simpleCPMoveFails() {
-            val inState = getPaper()
-            ledger {
-                transaction {
-                    input(inState)
-                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                    this `fails with` "the state is propagated"
-                }
-            }
-        }
-
-    .. sourcecode:: java
-
-        @Test
-        public void simpleCPMoveFails() {
-            ICommercialPaperState inState = getPaper();
-            ledger(l -> {
-                l.transaction(tx -> {
-                    tx.input(inState);
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
-                    return tx.failsWith("the state is propagated");
-                });
-                return Unit.INSTANCE;
-            });
-        }
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
+        :language: java
+        :start-after: DOCSTART 4
+        :end-before: DOCEND 4
+        :dedent: 4
 
 We can continue to build the transaction until it ``verifies``:
 
 .. container:: codeset
 
-    .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+        :language: kotlin
+        :start-after: DOCSTART 5
+        :end-before: DOCEND 5
+        :dedent: 4
 
-        @Test
-        fun simpleCPMoveSuccess() {
-            val inState = getPaper()
-            ledger {
-                transaction {
-                    input(inState)
-                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                    this `fails with` "the state is propagated"
-                    output(CommercialPaper.CP_PROGRAM_ID, "alice's paper") { inState `owned by` ALICE_PUBKEY }
-                    this.verifies()
-                }
-            }
-        }
-
-    .. sourcecode:: java
-
-        @Test
-        public void simpleCPMoveSuccess() {
-            ICommercialPaperState inState = getPaper();
-            ledger(l -> {
-                l.transaction(tx -> {
-                    tx.input(inState);
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
-                    tx.failsWith("the state is propagated");
-                    tx.output(CommercialPaper.CP_PROGRAM_ID, "alice's paper", inState.withOwner(getALICE_PUBKEY()));
-                    return tx.verifies();
-                });
-                return Unit.INSTANCE;
-            });
-        }
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
+        :language: java
+        :start-after: DOCSTART 5
+        :end-before: DOCEND 5
+        :dedent: 4
 
 ``output`` specifies that we want the input state to be transferred to ``ALICE`` and ``command`` adds the
 ``Move`` command itself, signed by the current owner of the input state, ``MEGA_CORP_PUBKEY``.
@@ -283,45 +203,17 @@ What should we do if we wanted to test what happens when the wrong party signs t
 
 .. container:: codeset
 
-    .. sourcecode:: kotlin
-
-        @Test
-        fun `simple issuance with tweak`() {
-            ledger {
-                transaction {
-                    output(CommercialPaper.CP_PROGRAM_ID, "paper") { getPaper() } // Some CP is issued onto the ledger by MegaCorp.
-                    tweak {
-                        command(DUMMY_PUBKEY_1) { CommercialPaper.Commands.Issue() }
-                        timestamp(TEST_TX_TIME)
-                        this `fails with` "output states are issued by a command signer"
-                    }
-                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
-                    timestamp(TEST_TX_TIME)
-                    this.verifies()
-                }
-            }
-        }
-
-    .. sourcecode:: java
-
-        @Test
-        public void simpleIssuanceWithTweak() {
-            ledger(l -> {
-                l.transaction(tx -> {
-                    tx.output(CommercialPaper.CP_PROGRAM_ID, "paper", getPaper()); // Some CP is issued onto the ledger by MegaCorp.
-                    tx.tweak(tw -> {
-                        tw.command(getDUMMY_PUBKEY_1(), new JavaCommercialPaper.Commands.Issue());
-                        tw.timestamp(getTEST_TX_TIME());
-                        return tw.failsWith("output states are issued by a command signer");
-                    });
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
-                    tx.timestamp(getTEST_TX_TIME());
-                    return tx.verifies();
-                });
-                return Unit.INSTANCE;
-            });
-        }
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+        :language: kotlin
+        :start-after: DOCSTART 6
+        :end-before: DOCEND 6
+        :dedent: 4
 
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
+        :language: java
+        :start-after: DOCSTART 6
+        :end-before: DOCEND 6
+        :dedent: 4
 
 ``tweak`` creates a local copy of the transaction. This makes possible to locally "ruin" the transaction while not
 modifying the original one, allowing testing of different error conditions.
@@ -332,39 +224,17 @@ ledger with a single transaction:
 
 .. container:: codeset
 
-    .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+        :language: kotlin
+        :start-after: DOCSTART 7
+        :end-before: DOCEND 7
+        :dedent: 4
 
-        @Test
-        fun `simple issuance with tweak and top level transaction`() {
-            transaction {
-                output(CommercialPaper.CP_PROGRAM_ID, "paper") { getPaper() } // Some CP is issued onto the ledger by MegaCorp.
-                tweak {
-                    command(DUMMY_PUBKEY_1) { CommercialPaper.Commands.Issue() }
-                    timestamp(TEST_TX_TIME)
-                    this `fails with` "output states are issued by a command signer"
-                }
-                command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
-                timestamp(TEST_TX_TIME)
-                this.verifies()
-            }
-        }
-
-    .. sourcecode:: java
-
-        @Test
-        public void simpleIssuanceWithTweakTopLevelTx() {
-            transaction(tx -> {
-                tx.output(CommercialPaper.CP_PROGRAM_ID, "paper", getPaper()); // Some CP is issued onto the ledger by MegaCorp.
-                tx.tweak(tw -> {
-                    tw.command(getDUMMY_PUBKEY_1(), new JavaCommercialPaper.Commands.Issue());
-                    tw.timestamp(getTEST_TX_TIME());
-                    return tw.failsWith("output states are issued by a command signer");
-                });
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
-                tx.timestamp(getTEST_TX_TIME());
-                return tx.verifies();
-            });
-        }
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
+        :language: java
+        :start-after: DOCSTART 7
+        :end-before: DOCEND 7
+        :dedent: 4
 
 Chaining transactions
 ---------------------
@@ -373,72 +243,17 @@ Now that we know how to define a single transaction, let's look at how to define
 
 .. container:: codeset
 
-    .. sourcecode:: kotlin
-
-        @Test
-        fun `chain commercial paper`() {
-            val issuer = MEGA_CORP.ref(123)
-
-            ledger {
-                unverifiedTransaction {
-                    output(Cash.CP_PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE_PUBKEY)
-                }
-
-                // Some CP is issued onto the ledger by MegaCorp.
-                transaction("Issuance") {
-                    output(CommercialPaper.CP_PROGRAM_ID, "paper") { getPaper() }
-                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
-                    timestamp(TEST_TX_TIME)
-                    this.verifies()
-                }
-
-
-                transaction("Trade") {
-                    input("paper")
-                    input("alice's $900")
-                    output(Cash.CP_PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP_PUBKEY }
-                    output(CommercialPaper.CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>() `owned by` ALICE_PUBKEY }
-                    command(ALICE_PUBKEY) { Cash.Commands.Move() }
-                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                    this.verifies()
-                }
-            }
-        }
-
-    .. sourcecode:: java
-
-        @Test
-        public void chainCommercialPaper() {
-            PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
-            ledger(l -> {
-                l.unverifiedTransaction(tx -> {
-                            tx.output(Cash.CP_PROGRAM_ID, "alice's $900",
-                                    new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE_PUBKEY(), null));
-                            return Unit.INSTANCE;
-                        });
-
-                // Some CP is issued onto the ledger by MegaCorp.
-                l.transaction("Issuance", tx -> {
-                    tx.output(CommercialPaper.CP_PROGRAM_ID, "paper", getPaper());
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
-                    tx.timestamp(getTEST_TX_TIME());
-                    return tx.verifies();
-                });
-
-                l.transaction("Trade", tx -> {
-                    tx.input("paper");
-                    tx.input("alice's $900");
-                    tx.output(Cash.CP_PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP_PUBKEY(), null));
-                    JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
-                    tx.output(CommercialPaper.CP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE_PUBKEY()));
-                    tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
-                    return tx.verifies();
-                });
-                return Unit.INSTANCE;
-            });
-        }
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+        :language: kotlin
+        :start-after: DOCSTART 8
+        :end-before: DOCEND 8
+        :dedent: 4
 
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
+        :language: java
+        :start-after: DOCSTART 8
+        :end-before: DOCEND 8
+        :dedent: 4
 
 In this example we declare that ``ALICE`` has $900 but we don't care where from. For this we can use
 ``unverifiedTransaction``. Note how we don't need to specify ``this.verifies()``.
@@ -455,182 +270,31 @@ To do so let's create a simple example that uses the same input twice:
 
 .. container:: codeset
 
-    .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+        :language: kotlin
+        :start-after: DOCSTART 9
+        :end-before: DOCEND 9
+        :dedent: 4
 
-        @Test
-        fun `chain commercial paper double spend`() {
-            val issuer = MEGA_CORP.ref(123)
-            ledger {
-                unverifiedTransaction {
-                    output(Cash.CP_PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE_PUBKEY)
-                }
-
-                // Some CP is issued onto the ledger by MegaCorp.
-                transaction("Issuance") {
-                    output(CommercialPaper.CP_PROGRAM_ID, "paper") { getPaper() }
-                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
-                    timestamp(TEST_TX_TIME)
-                    this.verifies()
-                }
-
-                transaction("Trade") {
-                    input("paper")
-                    input("alice's $900")
-                    output(Cash.CP_PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP_PUBKEY }
-                    output(CommercialPaper.CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>() `owned by` ALICE_PUBKEY }
-                    command(ALICE_PUBKEY) { Cash.Commands.Move() }
-                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                    this.verifies()
-                }
-
-                transaction {
-                    input("paper")
-                    // We moved a paper to another pubkey.
-                    output(CommercialPaper.CP_PROGRAM_ID, "bob's paper") { "paper".output<ICommercialPaperState>() `owned by` BOB_PUBKEY }
-                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                    this.verifies()
-                }
-
-                this.fails()
-            }
-        }
-
-    .. sourcecode:: java
-
-        @Test
-        public void chainCommercialPaperDoubleSpend() {
-            PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
-            ledger(l -> {
-                l.unverifiedTransaction(tx -> {
-                    tx.output(Cash.CP_PROGRAM_ID, "alice's $900",
-                            new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE_PUBKEY(), null));
-                    return Unit.INSTANCE;
-                });
-
-                // Some CP is issued onto the ledger by MegaCorp.
-                l.transaction("Issuance", tx -> {
-                    tx.output(CommercialPaper.CP_PROGRAM_ID, "paper", getPaper());
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
-                    tx.timestamp(getTEST_TX_TIME());
-                    return tx.verifies();
-                });
-
-                l.transaction("Trade", tx -> {
-                    tx.input("paper");
-                    tx.input("alice's $900");
-                    tx.output(Cash.CP_PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP_PUBKEY(), null));
-                    JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
-                    tx.output(CommercialPaper.CP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE_PUBKEY()));
-                    tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
-                    return tx.verifies();
-                });
-
-                l.transaction(tx -> {
-                    tx.input("paper");
-                    JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
-                    // We moved a paper to other pubkey.
-                    tx.output(CommercialPaper.CP_PROGRAM_ID, "bob's paper", inputPaper.withOwner(getBOB_PUBKEY()));
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
-                    return tx.verifies();
-                });
-                l.fails();
-                return Unit.INSTANCE;
-            });
-        }
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
+        :language: java
+        :start-after: DOCSTART 9
+        :end-before: DOCEND 9
+        :dedent: 4
 
 The transactions ``verifies()`` individually, however the state was spent twice! That's why we need the global ledger
 verification (``this.fails()`` at the end). As in previous examples we can use ``tweak`` to create a local copy of the whole ledger:
 
 .. container:: codeset
 
-    .. sourcecode:: kotlin
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+        :language: kotlin
+        :start-after: DOCSTART 10
+        :end-before: DOCEND 10
+        :dedent: 4
 
-        @Test
-        fun `chain commercial tweak`() {
-            val issuer = MEGA_CORP.ref(123)
-            ledger {
-                unverifiedTransaction {
-                    output(Cash.CP_PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE_PUBKEY)
-                }
-
-                // Some CP is issued onto the ledger by MegaCorp.
-                transaction("Issuance") {
-                    output(CommercialPaper.CP_PROGRAM_ID, "paper") { getPaper() }
-                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
-                    timestamp(TEST_TX_TIME)
-                    this.verifies()
-                }
-
-                transaction("Trade") {
-                    input("paper")
-                    input("alice's $900")
-                    output(Cash.CP_PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP_PUBKEY }
-                    output(CommercialPaper.CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>() `owned by` ALICE_PUBKEY }
-                    command(ALICE_PUBKEY) { Cash.Commands.Move() }
-                    command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                    this.verifies()
-                }
-
-                tweak {
-                    transaction {
-                        input("paper")
-                        // We moved a paper to another pubkey.
-                        output(CommercialPaper.CP_PROGRAM_ID, "bob's paper") { "paper".output<ICommercialPaperState>() `owned by` BOB_PUBKEY }
-                        command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                        this.verifies()
-                    }
-                    this.fails()
-                }
-
-                this.verifies()
-            }
-        }
-
-    .. sourcecode:: java
-
-        @Test
-        public void chainCommercialPaperTweak() {
-            PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
-            ledger(l -> {
-                l.unverifiedTransaction(tx -> {
-                    tx.output(Cash.CP_PROGRAM_ID, "alice's $900",
-                            new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE_PUBKEY(), null));
-                    return Unit.INSTANCE;
-                });
-
-                // Some CP is issued onto the ledger by MegaCorp.
-                l.transaction("Issuance", tx -> {
-                    tx.output(CommercialPaper.CP_PROGRAM_ID, "paper", getPaper());
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
-                    tx.timestamp(getTEST_TX_TIME());
-                    return tx.verifies();
-                });
-
-                l.transaction("Trade", tx -> {
-                    tx.input("paper");
-                    tx.input("alice's $900");
-                    tx.output(Cash.CP_PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP_PUBKEY(), null));
-                    JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
-                    tx.output(CommercialPaper.CP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE_PUBKEY()));
-                    tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
-                    return tx.verifies();
-                });
-
-                l.tweak(lw -> {
-                    lw.transaction(tx -> {
-                        tx.input("paper");
-                        JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
-                        // We moved a paper to another pubkey.
-                        tx.output(CommercialPaper.CP_PROGRAM_ID, "bob's paper", inputPaper.withOwner(getBOB_PUBKEY()));
-                        tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
-                        return tx.verifies();
-                    });
-                    lw.fails();
-                    return Unit.INSTANCE;
-                });
-                l.verifies();
-                return Unit.INSTANCE;
-            });
-        }
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
+        :language: java
+        :start-after: DOCSTART 10
+        :end-before: DOCEND 10
+        :dedent: 4
\ No newline at end of file
diff --git a/docs/source/tutorials-index.rst b/docs/source/tutorials-index.rst
index f9ffad2dd3..c0b1a5af14 100644
--- a/docs/source/tutorials-index.rst
+++ b/docs/source/tutorials-index.rst
@@ -15,7 +15,6 @@ Tutorials
    flow-state-machines
    flow-testing
    running-a-notary
-   using-a-notary
    oracles
    tutorial-tear-offs
    tutorial-attachments
diff --git a/docs/source/using-a-notary.rst b/docs/source/using-a-notary.rst
deleted file mode 100644
index d37d05809d..0000000000
--- a/docs/source/using-a-notary.rst
+++ /dev/null
@@ -1,138 +0,0 @@
-Using a notary service
-----------------------
-
-This tutorial describes how to assign a notary to a newly issued state, and how to get a transaction notarised by
-obtaining a signature of the required notary. It assumes some familiarity with *flows* and how to write them, as described
-in :doc:`flow-state-machines`.
-
-Assigning a notary
-==================
-
-The first step is to choose a notary and obtain its identity. Identities of all notaries on the network are kept by
-the :ref:`network-map-service`. The network map cache exposes two methods for obtaining a notary:
-
-.. sourcecode:: kotlin
-
-    /**
-     * Gets a notary identity by the given name.
-     */
-    fun getNotary(name: String): Party?
-
-    /**
-     * Returns a notary identity advertised by any of the nodes on the network (chosen at random)
-     *
-     * @param type Limits the result to notaries of the specified type (optional)
-     */
-    fun getAnyNotary(type: ServiceType? = null): Party?
-
-Currently notaries can only be differentiated by name and type, but in the future the network map service will be
-able to provide more metadata, such as location or legal identities of the nodes operating it.
-
-Now, let's say we want to issue an asset and assign it to a notary named "Notary A".
-The first step is to obtain the notary identity -- ``Party``:
-
-.. sourcecode:: kotlin
-
-    val ourNotary: Party = serviceHub.networkMapCache.getNotary("Notary A")
-
-Then we initialise the transaction builder:
-
-.. sourcecode:: kotlin
-
-    val builder: TransactionBuilder = TransactionBuilder(notary = ourNotary)
-
-For any output state we add to this transaction builder, ``ourNotary`` will be assigned as its notary.
-Next we create a state object and assign ourselves as the owner. For this example we'll use a
-``DummyContract.State``, which is a simple state that just maintains an integer and can change ownership.
-
-.. sourcecode:: kotlin
-
-   val myIdentity = serviceHub.chooseIdentity()
-   val state = DummyContract.SingleOwnerState(magicNumber = 42, owner = myIdentity.owningKey)
-
-Then we add the state as the transaction output along with the relevant command. The state will automatically be assigned
-to our previously specified "Notary A".
-
-.. sourcecode:: kotlin
-
-   builder.addOutputState(state)
-   val createCommand = DummyContract.Commands.Create()
-   builder.addCommand(Command(createCommand, myIdentity))
-
-We then sign the transaction, build and record it to our transaction storage:
-
-.. sourcecode:: kotlin
-
-   val mySigningKey: PublicKey = serviceHub.chooseIdentity().owningKey
-   val issueTransaction = serviceHub.toSignedTransaction(issueTransaction, mySigningKey)
-   serviceHub.recordTransactions(issueTransaction)
-
-The transaction is recorded and we now have a state (asset) in possession that we can transfer to someone else. Note
-that the issuing transaction does not need to be notarised, as it doesn't consume any input states.
-
-Notarising a transaction
-========================
-
-Following our example for the previous section, let's say we now want to transfer our issued state to Alice.
-
-First we obtain a reference to the state, which will be the input to our "move" transaction:
-
-.. sourcecode:: kotlin
-
-    val stateRef = StateRef(txhash = issueTransaction.id, index = 0)
-
-Then we create a new state -- a copy of our state but with the owner set to Alice. This is a bit more involved so
-we just use a helper that handles it for us. We also assume that we already have the ``Party`` for Alice, ``aliceParty``.
-
-.. sourcecode:: kotlin
-
-    val inputState = StateAndRef(state, stateRef)
-    val moveTransactionBuilder = DummyContract.withNewOwnerAndAmount(inputState, newOwner = aliceParty.owningKey)
-
-The ``DummyContract.withNewOwnerAndAmount()`` method will a new transaction builder with our old state as the input, a new state
-with Alice as the owner, and a relevant contract command for "move".
-
-Again we sign the transaction, and build it:
-
-.. sourcecode:: kotlin
-
-   // We build it and add our default identity signature without checking if all signatures are present,
-   // Note we know that the notary signature is missing, so thie SignedTransaction is still partial.
-   val moveTransaction = serviceHub.toSignedTransaction(moveTransactionBuilder)
-
-Next we need to obtain a signature from the notary for the transaction to be valid. Prior to signing, the notary will
-commit our old (input) state so it cannot be used again.
-
-To manually obtain a signature from a notary we can run the ``NotaryFlow.Client`` flow. The flow will work out
-which notary needs to be called based on the input states (and the timestamp command, if it's present).
-
-.. sourcecode:: kotlin
-
-    // The subFlow() helper is available within the context of a Flow
-    val notarySignature: DigitalSignature = subFlow(NotaryFlow.Client(moveTransaction))
-
-.. note:: If our input state has already been consumed in another transaction, then ``NotaryFlow`` with throw a ``NotaryException``
-   containing the conflict details:
-
-   .. sourcecode:: kotlin
-
-        /** Specifies the consuming transaction for the conflicting input state */
-        data class Conflict(val stateHistory: Map<StateRef, ConsumingTx>)
-
-        /**
-        * Specifies the transaction id, the position of the consumed state in the inputs, and
-        * the caller identity requesting the commit
-        */
-        data class ConsumingTx(val id: SecureHash, val inputIndex: Int, val requestingParty: Party)
-
-   Conflict handling and resolution is currently the responsibility of the flow author.
-
-Note that instead of calling the notary directly, we would normally call ``FinalityFlow`` passing in the ``SignedTransaction``
-(including signatures from the participants) and a list of participants to notify. The flow will request a notary signature
-if needed, record the notarised transaction, and then send a copy of the transaction to all participants for them to store.
-``FinalityFlow`` delegates to ``NotaryFlow.Client`` followed by ``BroadcastTransactionFlow`` to do the
-actual work of notarising and broadcasting the transaction. For example:
-
-.. sourcecode:: kotlin
-
-    subFlow(FinalityFlow(moveTransaction, setOf(aliceParty))
diff --git a/finance/src/main/java/net/corda/finance/contracts/JavaCommercialPaper.java b/finance/src/main/java/net/corda/finance/contracts/JavaCommercialPaper.java
index 468d1919c8..02bf2bbd45 100644
--- a/finance/src/main/java/net/corda/finance/contracts/JavaCommercialPaper.java
+++ b/finance/src/main/java/net/corda/finance/contracts/JavaCommercialPaper.java
@@ -32,7 +32,7 @@ import static net.corda.core.contracts.ContractsDSL.requireThat;
  */
 @SuppressWarnings("unused")
 public class JavaCommercialPaper implements Contract {
-    static final String JCP_PROGRAM_ID = "net.corda.finance.contracts.JavaCommercialPaper";
+    public static final String JCP_PROGRAM_ID = "net.corda.finance.contracts.JavaCommercialPaper";
 
     @SuppressWarnings("unused")
     public static class State implements OwnableState, ICommercialPaperState {
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt b/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
index 13248bd58e..1079beeccc 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
@@ -29,12 +29,16 @@ import java.util.*
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+// DOCSTART 1
 /** A [FixOf] identifies the question side of a fix: what day, tenor and type of fix ("LIBOR", "EURIBOR" etc) */
 @CordaSerializable
 data class FixOf(val name: String, val forDay: LocalDate, val ofTenor: Tenor)
+// DOCEND 1
 
+// DOCSTART 2
 /** A [Fix] represents a named interest rate, on a given day, for a given duration. It can be embedded in a tx. */
 data class Fix(val of: FixOf, val value: BigDecimal) : CommandData
+// DOCEND 2
 
 /** Represents a textual expression of e.g. a formula */
 @CordaSerializable
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 833d1bec1c..17313ec688 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
@@ -74,6 +74,7 @@ fun main(args: Array<String>) {
 }
 
 /** An in memory test zip attachment of at least numOfClearBytes size, will be used. */
+// DOCSTART 2
 fun sender(rpc: CordaRPCOps, numOfClearBytes: Int = 1024) { // default size 1K.
     val (inputStream, hash) = InputStreamAndHash.createInMemoryTestZip(numOfClearBytes, 0)
     val executor = Executors.newScheduledThreadPool(2)
@@ -105,6 +106,7 @@ private fun sender(rpc: CordaRPCOps, inputStream: InputStream, hash: SecureHash.
     val stx = flowHandle.returnValue.getOrThrow()
     println("Sent ${stx.id}")
 }
+// DOCEND 2
 
 @StartableByRPC
 class AttachmentDemoFlow(private val otherSide: Party,
@@ -132,6 +134,7 @@ class AttachmentDemoFlow(private val otherSide: Party,
     }
 }
 
+// DOCSTART 1
 fun recipient(rpc: CordaRPCOps, webPort: Int) {
     println("Waiting to receive transaction ...")
     val stx = rpc.internalVerifiedTransactionsFeed().updates.toBlocking().first()
@@ -170,6 +173,7 @@ fun recipient(rpc: CordaRPCOps, webPort: Int) {
         println("Error: no attachments found in ${wtx.id}")
     }
 }
+// DOCEND 1
 
 private fun printHelp(parser: OptionParser) {
     println("""
diff --git a/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRS.kt b/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRS.kt
index 8070d86f29..097a33c5e8 100644
--- a/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRS.kt
+++ b/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRS.kt
@@ -609,6 +609,7 @@ class InterestRateSwap : Contract {
         override val participants: List<AbstractParty>
             get() = listOf(fixedLeg.fixedRatePayer, floatingLeg.floatingRatePayer)
 
+        // DOCSTART 1
         override fun nextScheduledActivity(thisStateRef: StateRef, flowLogicRefFactory: FlowLogicRefFactory): ScheduledActivity? {
             val nextFixingOf = nextFixingOf() ?: return null
 
@@ -616,6 +617,7 @@ class InterestRateSwap : Contract {
             val instant = suggestInterestRateAnnouncementTimeWindow(index = nextFixingOf.name, source = floatingLeg.indexSource, date = nextFixingOf.forDay).fromTime!!
             return ScheduledActivity(flowLogicRefFactory.create(FixingFlow.FixingRoleDecider::class.java, thisStateRef), instant)
         }
+        // DOCEND 1
 
         override fun generateAgreement(notary: Party): TransactionBuilder {
             return InterestRateSwap().generateAgreement(floatingLeg, fixedLeg, calculation, common, oracle, notary)

From 2a1a9c9d2009b87898e8f0bda41772e16b80143b Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Mon, 2 Oct 2017 09:08:59 +0100
Subject: [PATCH 054/185] Updates hello world tutorials for v1.0.

---
 docs/source/hello-world-contract.rst     |   6 +-
 docs/source/hello-world-flow.rst         |  34 ++++++----
 docs/source/hello-world-running.rst      |  77 ++++++++++++---------
 docs/source/hello-world-state.rst        |  24 +------
 docs/source/resources/tutorial-state.png | Bin 196921 -> 159954 bytes
 docs/source/tut-two-party-flow.rst       |  82 ++++++++++++++---------
 6 files changed, 124 insertions(+), 99 deletions(-)

diff --git a/docs/source/hello-world-contract.rst b/docs/source/hello-world-contract.rst
index d5e4de152f..7e367ff7eb 100644
--- a/docs/source/hello-world-contract.rst
+++ b/docs/source/hello-world-contract.rst
@@ -41,7 +41,8 @@ Just as every Corda state must implement the ``ContractState`` interface, every
 
 You can read about function declarations in Kotlin `here <https://kotlinlang.org/docs/reference/functions.html>`_.
 
-We can see that ``Contract`` expresses its constraints through a ``verify`` function that takes a transaction as input, and:
+We can see that ``Contract`` expresses its constraints through a ``verify`` function that takes a transaction as input,
+and:
 
   * Throws an ``IllegalArgumentException`` if it rejects the transaction proposal
   * Returns silently if it accepts the transaction proposal
@@ -118,7 +119,6 @@ Let's write a contract that enforces these constraints. We'll do this by modifyi
         import net.corda.core.contracts.CommandData;
         import net.corda.core.contracts.Contract;
         import net.corda.core.transactions.LedgerTransaction;
-        import net.corda.core.crypto.SecureHash;
         import net.corda.core.identity.Party;
 
         import static net.corda.core.contracts.ContractsDSL.requireSingleCommand;
@@ -258,7 +258,5 @@ We've now written an ``IOUContract`` constraining the evolution of each ``IOUSta
 * The ``IOUState`` created by the issuance transaction must have a non-negative value, and the lender and borrower
   must be different entities
 
-Before we move on, make sure you go back and modify ``IOUState`` to point to the new ``IOUContract`` class.
-
 The final step in the creation of our CorDapp will be to write the ``IOUFlow`` that will allow a node to orchestrate
 the creation of a new ``IOUState`` on the ledger, while only sharing information on a need-to-know basis.
diff --git a/docs/source/hello-world-flow.rst b/docs/source/hello-world-flow.rst
index e3bd8db52b..351888fd0a 100644
--- a/docs/source/hello-world-flow.rst
+++ b/docs/source/hello-world-flow.rst
@@ -59,15 +59,20 @@ with the following:
             /** The flow logic is encapsulated within the call() method. */
             @Suspendable
             override fun call() {
-                val notary = serviceHub.networkMapCache.getAnyNotary()
+                // We retrieve the notary identity from the network map.
+                val notary = serviceHub.networkMapCache.notaryIdentities[0]
 
                 // We create a transaction builder
                 val txBuilder = TransactionBuilder(notary = notary)
 
+                // We create the transaction components.
+                val outputState = IOUState(iouValue, ourIdentity, otherParty)
+                val outputContract = IOUContract::class.jvmName
+                val outputContractAndState = StateAndContract(outputState, outputContract)
+                val cmd = Command(IOUContract.Create(), ourIdentity.owningKey)
+
                 // We add the items to the builder.
-                val state = IOUState(iouValue, me, otherParty)
-                val cmd = Command(IOUContract.Create(), me.owningKey)
-                txBuilder.withItems(state, cmd)
+                txBuilder.withItems(outputContractAndState, cmd)
 
                 // Verifying the transaction.
                 txBuilder.verify(serviceHub)
@@ -88,6 +93,7 @@ with the following:
         import com.template.contract.IOUContract;
         import com.template.state.IOUState;
         import net.corda.core.contracts.Command;
+        import net.corda.core.contracts.StateAndContract;
         import net.corda.core.flows.*;
         import net.corda.core.identity.Party;
         import net.corda.core.transactions.SignedTransaction;
@@ -121,17 +127,21 @@ with the following:
             @Suspendable
             @Override
             public Void call() throws FlowException {
-                // We retrieve the required identities from the network map.
-                final Party notary = getServiceHub().getNetworkMapCache().getAnyNotary(null);
+                // We retrieve the notary identity from the network map.
+                final Party notary = getServiceHub().getNetworkMapCache().getNotaryIdentities().get(0);
 
                 // We create a transaction builder.
                 final TransactionBuilder txBuilder = new TransactionBuilder();
                 txBuilder.setNotary(notary);
 
+                // We create the transaction components.
+                IOUState outputState = new IOUState(iouValue, getOurIdentity(), otherParty);
+                String outputContract = IOUContract.class.getName();
+                StateAndContract outputContractAndState = new StateAndContract(outputState, outputContract);
+                Command cmd = new Command<>(new IOUContract.Create(), getOurIdentity().getOwningKey());
+
                 // We add the items to the builder.
-                IOUState state = new IOUState(iouValue, me, otherParty);
-                Command cmd = new Command(new IOUContract.Create(), me.getOwningKey());
-                txBuilder.withItems(state, cmd);
+                txBuilder.withItems(outputContractAndState, cmd);
 
                 // Verifying the transaction.
                 txBuilder.verify(getServiceHub());
@@ -200,7 +210,7 @@ the following transaction:
 
 So we'll need the following:
 
-* The output ``IOUState``
+* The output ``IOUState`` and its associated contract
 * A ``Create`` command listing the IOU's lender as a signer
 
 The command we use pairs the ``IOUContract.Create`` command defined earlier with our public key. Including this command
@@ -208,8 +218,8 @@ in the transaction makes us one of the transaction's required signers.
 
 We add these items to the transaction using the ``TransactionBuilder.withItems`` method, which takes a ``vararg`` of:
 
-* ``ContractState`` or ``TransactionState`` objects, which are added to the builder as output states
-* ``StateRef`` objects (references to the outputs of previous transactions), which are added to the builder as input
+* ``StateAndContract`` or ``TransactionState`` objects, which are added to the builder as output states
+* ``StateAndRef`` objects (references to the outputs of previous transactions), which are added to the builder as input
   state references
 * ``Command`` objects, which are added to the builder as commands
 * ``SecureHash`` objects, which are added to the builder as attachments
diff --git a/docs/source/hello-world-running.rst b/docs/source/hello-world-running.rst
index 6bc74a3117..7bf00e4771 100644
--- a/docs/source/hello-world-running.rst
+++ b/docs/source/hello-world-running.rst
@@ -25,30 +25,30 @@ Let's take a look at the nodes we're going to deploy. Open the project's ``build
 
         task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
             directory "./build/nodes"
-            networkMap "O=Controller,OU=corda,L=London,C=UK"
+            networkMap "O=Controller,L=London,C=GB"
             node {
-                name "O=Controller,OU=corda,L=London,C=UK"
+                name "O=Controller,L=London,C=GB"
                 advertisedServices = ["corda.notary.validating"]
                 p2pPort 10002
                 rpcPort 10003
-                cordapps = []
+                cordapps = ["net.corda:corda-finance:$corda_release_version"]
             }
             node {
-                name "CN=NodeA,O=NodeA,L=London,C=UK"
+                name "O=PartyA,L=London,C=GB"
                 advertisedServices = []
                 p2pPort 10005
                 rpcPort 10006
                 webPort 10007
-                cordapps = []
+                cordapps = ["net.corda:corda-finance:$corda_release_version"]
                 rpcUsers = [[ user: "user1", "password": "test", "permissions": []]]
             }
             node {
-                name "CN=NodeB,O=NodeB,L=New York,C=US"
+                name "O=PartyB,L=New York,C=US"
                 advertisedServices = []
                 p2pPort 10008
                 rpcPort 10009
                 webPort 10010
-                cordapps = []
+                cordapps = ["net.corda:corda-finance:$corda_release_version"]
                 rpcUsers = [[ user: "user1", "password": "test", "permissions": []]]
             }
         }
@@ -111,57 +111,72 @@ Now that our nodes are running, let's order one of them to create an IOU by kick
 app, we'd generally provide a web API sitting on top of our node. Here, for simplicity, we'll be interacting with the
 node via its built-in CRaSH shell.
 
-Go to the terminal window displaying the CRaSH shell of Node A. Typing ``help`` will display a list of the available
+Go to the terminal window displaying the CRaSH shell of PartyA. Typing ``help`` will display a list of the available
 commands.
 
-We want to create an IOU of 100 with Node B. We start the ``IOUFlow`` by typing:
+We want to create an IOU of 100 with PartyB. We start the ``IOUFlow`` by typing:
 
 .. container:: codeset
 
     .. code-block:: java
 
-        start IOUFlow arg0: 99, arg1: "NodeB"
+        start IOUFlow arg0: 99, arg1: "O=PartyB,L=New York,C=US"
 
     .. code-block:: kotlin
 
-        start IOUFlow iouValue: 99, otherParty: "NodeB"
+        start IOUFlow iouValue: 99, otherParty: "O=PartyB,L=New York,C=US"
 
-Node A and Node B will automatically agree an IOU. If the flow worked, it should have led to the recording of a new IOU
-in the vaults of both Node A and Node B.
+PartyA and PartyB will automatically agree an IOU. If the flow worked, it should have led to the recording of a new IOU
+in the vaults of both PartyA and PartyB.
 
 We can check the flow has worked by using an RPC operation to check the contents of each node's vault. Typing ``run``
 will display a list of the available commands. We can examine the contents of a node's vault by running:
 
-.. code:: python
+.. container:: codeset
 
-     run vaultAndUpdates
+    .. code-block:: java
 
-And we can also examine a node's transaction storage, by running:
+        run vaultQuery contractStateType: com.template.state.IOUState
+
+    .. code-block:: kotlin
+
+        run vaultQuery contractStateType: com.template.IOUState
+
+The vaults of PartyA and PartyB should both display the following output:
 
 .. code:: python
 
-     run verifiedTransactions
-
-The vaults of Node A and Node B should both display the following output:
-
-.. code:: python
-
-    first:
+    states:
     - state:
         data:
           value: 99
-          lender: "CN=NodeA,O=NodeA,L=London,C=GB"
-          borrower: "CN=NodeB,O=NodeB,L=New York,C=US"
-          contract: {}
+          lender: "C=GB,L=London,O=PartyA"
+          borrower: "C=US,L=New York,O=PartyB"
           participants:
-          - "CN=NodeA,O=NodeA,L=London,C=GB"
-          - "CN=NodeB,O=NodeB,L=New York,C=US"
-        notary: "O=Controller,OU=corda,L=London,C=GB,OU=corda.notary.validating"
+          - "C=GB,L=London,O=PartyA"
+          - "C=US,L=New York,O=PartyB"
+        contract: "com.template.contract.IOUContract"
+        notary: "C=GB,L=London,O=Controller,CN=corda.notary.validating"
         encumbrance: null
+        constraint:
+          attachmentId: "F578320232CAB87BB1E919F3E5DB9D81B7346F9D7EA6D9155DC0F7BA8E472552"
       ref:
-        txhash: "656A1BF64D5AEEC6F6C944E287F34EF133336F5FC2C5BFB9A0BFAE25E826125F"
+        txhash: "5CED068E790A347B0DD1C6BB5B2B463406807F95E080037208627565E6A2103B"
         index: 0
-    second: "(observable)"
+    statesMetadata:
+    - ref:
+        txhash: "5CED068E790A347B0DD1C6BB5B2B463406807F95E080037208627565E6A2103B"
+        index: 0
+      contractStateClassName: "com.template.state.IOUState"
+      recordedTime: 1506415268.875000000
+      consumedTime: null
+      status: "UNCONSUMED"
+      notary: "C=GB,L=London,O=Controller,CN=corda.notary.validating"
+      lockId: null
+      lockUpdateTime: 1506415269.548000000
+    totalStatesAvailable: -1
+    stateTypes: "UNCONSUMED"
+    otherResults: []
 
 Conclusion
 ----------
diff --git a/docs/source/hello-world-state.rst b/docs/source/hello-world-state.rst
index 1677e3276a..dbcbe7c4b7 100644
--- a/docs/source/hello-world-state.rst
+++ b/docs/source/hello-world-state.rst
@@ -20,9 +20,6 @@ defined as follows:
     .. code-block:: kotlin
 
         interface ContractState {
-            // The contract that imposes constraints on how this state can evolve over time.
-            val contract: Contract
-
             // The list of entities considered to have a stake in this state.
             val participants: List<AbstractParty>
         }
@@ -38,13 +35,10 @@ If you do want to dive into Kotlin, there's an official
 `getting started guide <https://kotlinlang.org/docs/tutorials/>`_, and a series of
 `Kotlin Koans <https://kotlinlang.org/docs/tutorials/koans.html>`_.
 
-We can see that the ``ContractState`` interface declares two properties:
+We can see that the ``ContractState`` interface has a single field, ``participants``. ``participants`` is a list of
+the entities for which this state is relevant.
 
-* ``contract``: the contract controlling transactions involving this state
-* ``participants``: the list of entities that have to approve state changes such as changing the state's notary or
-  upgrading the state's contract
-
-Beyond this, our state is free to define any properties, methods, helpers or inner classes it requires to accurately
+Beyond this, our state is free to define any fields, methods, helpers or inner classes it requires to accurately
 represent a given class of shared facts on the ledger.
 
 ``ContractState`` also has several child interfaces that you may wish to implement depending on your state, such as
@@ -74,7 +68,6 @@ define an ``IOUState``:
         class IOUState(val value: Int,
                        val lender: Party,
                        val borrower: Party) : ContractState {
-            override val contract = "net.corda.contract.TemplateContract"
             override val participants get() = listOf(lender, borrower)
         }
 
@@ -83,7 +76,6 @@ define an ``IOUState``:
         package com.template.state;
 
         import com.google.common.collect.ImmutableList;
-        import com.template.contract.TemplateContract;
         import net.corda.core.contracts.ContractState;
         import net.corda.core.identity.AbstractParty;
         import net.corda.core.identity.Party;
@@ -94,7 +86,6 @@ define an ``IOUState``:
             private final int value;
             private final Party lender;
             private final Party borrower;
-            private final TemplateContract contract = new TemplateContract();
 
             public IOUState(int value, Party lender, Party borrower) {
                 this.value = value;
@@ -114,12 +105,6 @@ define an ``IOUState``:
                 return borrower;
             }
 
-            @Override
-            // TODO: Once we've defined IOUContract, come back and update this.
-            public TemplateContract getContract() {
-                return contract;
-            }
-
             @Override
             public List<AbstractParty> getParticipants() {
                 return ImmutableList.of(lender, borrower);
@@ -141,9 +126,6 @@ We've made the following changes:
 
   * Actions such as changing a state's contract or notary will require approval from all the ``participants``
 
-We've left ``IOUState``'s contract as ``TemplateContract`` for now. We'll update this once we've defined the
-``IOUContract``.
-
 Progress so far
 ---------------
 We've defined an ``IOUState`` that can be used to represent IOUs as shared facts on the ledger. As we've seen, states in
diff --git a/docs/source/resources/tutorial-state.png b/docs/source/resources/tutorial-state.png
index 11b0a0d385805999bf2330e8185e319e4a5c88d9..d621277ba9441bd8c6379d7ab2992f11bf8fa9e3 100644
GIT binary patch
literal 159954
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
V2TrtKTLb=`J8gI>|Abw@{{R}X!3zKY

literal 196921
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
RNq@nAGLrHVndkIx{9o3bjg9~S

diff --git a/docs/source/tut-two-party-flow.rst b/docs/source/tut-two-party-flow.rst
index 9837f600c8..84acdb6f7c 100644
--- a/docs/source/tut-two-party-flow.rst
+++ b/docs/source/tut-two-party-flow.rst
@@ -29,10 +29,14 @@ In ``IOUFlow.java``/``IOUFlow.kt``, update ``IOUFlow.call`` as follows:
 
         ...
 
+        // We create the transaction components.
+        val outputState = IOUState(iouValue, ourIdentity, otherParty)
+        val outputContract = IOUContract::class.jvmName
+        val outputContractAndState = StateAndContract(outputState, outputContract)
+        val cmd = Command(IOUContract.Create(), listOf(ourIdentity.owningKey, otherParty.owningKey))
+
         // We add the items to the builder.
-        val state = IOUState(iouValue, me, otherParty)
-        val cmd = Command(IOUContract.Create(), listOf(me.owningKey, otherParty.owningKey))
-        txBuilder.withItems(state, cmd)
+        txBuilder.withItems(outputContractAndState, cmd)
 
         // Verifying the transaction.
         txBuilder.verify(serviceHub)
@@ -40,9 +44,11 @@ In ``IOUFlow.java``/``IOUFlow.kt``, update ``IOUFlow.call`` as follows:
         // Signing the transaction.
         val signedTx = serviceHub.signInitialTransaction(txBuilder)
 
-        // Obtaining the counterparty's signature
-        val otherSession = initiateFlow(otherParty)
-        val fullySignedTx = subFlow(CollectSignaturesFlow(signedTx, setOf(otherSession), CollectSignaturesFlow.tracker()))
+        // Creating a session with the other party.
+        val otherpartySession = initiateFlow(otherParty)
+
+        // Obtaining the counterparty's signature.
+        val fullySignedTx = subFlow(CollectSignaturesFlow(signedTx, listOf(otherpartySession), CollectSignaturesFlow.tracker()))
 
         // Finalising the transaction.
         subFlow(FinalityFlow(fullySignedTx))
@@ -58,11 +64,15 @@ In ``IOUFlow.java``/``IOUFlow.kt``, update ``IOUFlow.call`` as follows:
 
         ...
 
+        // We create the transaction components.
+        IOUState outputState = new IOUState(iouValue, getOurIdentity(), otherParty);
+        String outputContract = IOUContract.class.getName();
+        StateAndContract outputContractAndState = new StateAndContract(outputState, outputContract);
+        List<PublicKey> requiredSigners = ImmutableList.of(getOurIdentity().getOwningKey(), otherParty.getOwningKey());
+        Command cmd = new Command<>(new IOUContract.Create(), requiredSigners);
+
         // We add the items to the builder.
-        IOUState state = new IOUState(iouValue, me, otherParty);
-        List<PublicKey> requiredSigners = ImmutableList.of(me.getOwningKey(), otherParty.getOwningKey());
-        Command cmd = new Command(new IOUContract.Create(), requiredSigners);
-        txBuilder.withItems(state, cmd);
+        txBuilder.withItems(outputContractAndState, cmd);
 
         // Verifying the transaction.
         txBuilder.verify(getServiceHub());
@@ -70,20 +80,34 @@ In ``IOUFlow.java``/``IOUFlow.kt``, update ``IOUFlow.call`` as follows:
         // Signing the transaction.
         final SignedTransaction signedTx = getServiceHub().signInitialTransaction(txBuilder);
 
-        // Obtaining the counterparty's signature
-        final FlowSession otherSession = initiateFlow(otherParty)
-        final SignedTransaction fullySignedTx = subFlow(new CollectSignaturesFlow(signedTx, Collections.singleton(otherSession), CollectSignaturesFlow.Companion.tracker()));
+        // Creating a session with the other party.
+        FlowSession otherpartySession = initiateFlow(otherParty);
+
+        // Obtaining the counterparty's signature.
+        SignedTransaction fullySignedTx = subFlow(new CollectSignaturesFlow(
+                signedTx, ImmutableList.of(otherpartySession), CollectSignaturesFlow.tracker()));
 
         // Finalising the transaction.
-        subFlow(new FinalityFlow(fullySignedTx));
+        subFlow(new FinalityFlow(signedTx));
 
         return null;
 
 To make the borrower a required signer, we simply add the borrower's public key to the list of signers on the command.
 
-``CollectSignaturesFlow``, meanwhile, takes a transaction signed by the flow initiator, and returns a transaction
-signed by all the transaction's other required signers. We then pass this fully-signed transaction into
-``FinalityFlow``.
+We now need to communicate with the borrower to request their signature. Whenever you want to communicate with another
+party in the context of a flow, you first need to establish a flow session with them. If the counterparty has a
+``FlowLogic`` registered to respond to the ``FlowLogic`` initiating the session, a session will be established. All
+communication between the two ``FlowLogic`` instances will then place as part of this session.
+
+Once we have a session with the borrower, we gather the borrower's signature using ``CollectSignaturesFlow``, which
+takes:
+
+* A transaction signed by the flow initiator
+* A list of flow-sessions between the flow initiator and the required signers
+
+And returns a transaction signed by all the required signers.
+
+We then pass this fully-signed transaction into ``FinalityFlow``.
 
 Creating the borrower's flow
 ----------------------------
@@ -101,10 +125,10 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
         ...
 
         @InitiatedBy(IOUFlow::class)
-        class IOUFlowResponder(val otherPartySession: FlowSession) : FlowLogic<Unit>() {
+        class IOUFlowResponder(val otherPartyFlow: FlowSession) : FlowLogic<Unit>() {
             @Suspendable
             override fun call() {
-                val signTransactionFlow = object : SignTransactionFlow(otherPartySession, SignTransactionFlow.tracker()) {
+                val signTransactionFlow = object : SignTransactionFlow(otherPartyFlow, SignTransactionFlow.tracker()) {
                     override fun checkTransaction(stx: SignedTransaction) = requireThat {
                         val output = stx.tx.outputs.single().data
                         "This must be an IOU transaction." using (output is IOUState)
@@ -124,11 +148,7 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
         import co.paralleluniverse.fibers.Suspendable;
         import com.template.state.IOUState;
         import net.corda.core.contracts.ContractState;
-        import net.corda.core.flows.FlowException;
-        import net.corda.core.flows.FlowLogic;
-        import net.corda.core.flows.FlowSession;
-        import net.corda.core.flows.InitiatedBy;
-        import net.corda.core.flows.SignTransactionFlow;
+        import net.corda.core.flows.*;
         import net.corda.core.transactions.SignedTransaction;
         import net.corda.core.utilities.ProgressTracker;
 
@@ -136,18 +156,18 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
 
         @InitiatedBy(IOUFlow.class)
         public class IOUFlowResponder extends FlowLogic<Void> {
-            private final FlowSession otherPartySession;
+            private final FlowSession otherPartyFlow;
 
-            public IOUFlowResponder(FlowSession otherPartySession) {
-                this.otherPartySession = otherPartySession;
+            public IOUFlowResponder(FlowSession otherPartyFlow) {
+                this.otherPartyFlow = otherPartyFlow;
             }
 
             @Suspendable
             @Override
             public Void call() throws FlowException {
-                class SignTxFlow extends SignTransactionFlow {
-                    private signTxFlow(FlowSession otherPartySession, ProgressTracker progressTracker) {
-                        super(otherPartySession, progressTracker);
+                class signTxFlow extends SignTransactionFlow {
+                    private signTxFlow(FlowSession otherPartyFlow, ProgressTracker progressTracker) {
+                        super(otherPartyFlow, progressTracker);
                     }
 
                     @Override
@@ -162,7 +182,7 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
                     }
                 }
 
-                subFlow(new SignTxFlow(otherPartySession, SignTransactionFlow.Companion.tracker()));
+                subFlow(new signTxFlow(otherPartyFlow, SignTransactionFlow.Companion.tracker()));
 
                 return null;
             }

From f9614123968035cb325c6de0b84cf2718643f399 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Mon, 2 Oct 2017 09:09:16 +0100
Subject: [PATCH 055/185] Fixes a formatting issue.

---
 docs/source/key-concepts-contract-constraints.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/source/key-concepts-contract-constraints.rst b/docs/source/key-concepts-contract-constraints.rst
index 6c3e536264..5518e45ff6 100644
--- a/docs/source/key-concepts-contract-constraints.rst
+++ b/docs/source/key-concepts-contract-constraints.rst
@@ -15,7 +15,7 @@ A typical constraint is the hash of the CorDapp JAR that contains the contract a
 include constraints that require specific signers of the JAR, or both the signer and the hash. Constraints can be
 specified when constructing a transaction; if unspecified, an automatic constraint is used.
 
-``TransactionState``s have a ``constraint`` field that represents that state's attachment constraint. When a party
+A ``TransactionState`` has a ``constraint`` field that represents that state's attachment constraint. When a party
 constructs a ``TransactionState`` without specifying the constraint parameter a default value
 (``AutomaticHashConstraint``) is used. This default will be automatically resolved to a specific
 ``HashAttachmentConstraint`` that contains the hash of the attachment which contains the contract of that
@@ -80,8 +80,8 @@ attachment JAR. This allows for trusting of attachments from trusted entities.
 Limitations
 -----------
 
-``AttachmentConstraint``s are verified by running the ``AttachmentConstraint.isSatisfiedBy`` method. When this is called
-it is provided only the relevant attachment by the transaction that is verifying it.
+An ``AttachmentConstraint`` is verified by running the ``AttachmentConstraint.isSatisfiedBy`` method. When this is
+called it is provided only the relevant attachment by the transaction that is verifying it.
 
 Testing
 -------

From 33e8105a2987bfe2ceafcdeb93f454cd5def584d Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Mon, 2 Oct 2017 10:50:39 +0100
Subject: [PATCH 056/185] CORDA-649: Second attempt to make
 PersistentNetworkMapCacheTest more stable (#1738)

---
 build.gradle                                  |  1 -
 node/build.gradle                             |  1 -
 .../network/PersistentNetworkMapCacheTest.kt  | 11 ++++-----
 .../kotlin/net/corda/testing/Eventually.kt    | 24 +++++++++++++++++++
 4 files changed, 29 insertions(+), 8 deletions(-)
 create mode 100644 testing/test-utils/src/main/kotlin/net/corda/testing/Eventually.kt

diff --git a/build.gradle b/build.gradle
index 63cce612c6..96cd49c445 100644
--- a/build.gradle
+++ b/build.gradle
@@ -27,7 +27,6 @@ buildscript {
     ext.jersey_version = '2.25'
     ext.jolokia_version = '2.0.0-M3'
     ext.assertj_version = '3.6.1'
-    ext.kotlintest_version = '2.0.5'
     ext.slf4j_version = '1.7.25'
     ext.log4j_version = '2.7'
     ext.bouncycastle_version = constants.getProperty("bouncycastleVersion")
diff --git a/node/build.gradle b/node/build.gradle
index bcdc43d571..276efe01df 100644
--- a/node/build.gradle
+++ b/node/build.gradle
@@ -127,7 +127,6 @@ dependencies {
     // Unit testing helpers.
     testCompile "junit:junit:$junit_version"
     testCompile "org.assertj:assertj-core:${assertj_version}"
-    testCompile "io.kotlintest:kotlintest:${kotlintest_version}"
     testCompile project(':test-utils')
     testCompile project(':client:jfx')
     testCompile project(':finance')
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
index 4da002b539..465fb72229 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
@@ -1,8 +1,6 @@
 package net.corda.node.services.network
 
 import co.paralleluniverse.fibers.Suspendable
-import io.kotlintest.eventually
-import io.kotlintest.milliseconds
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.FlowSession
 import net.corda.core.flows.InitiatedBy
@@ -17,8 +15,8 @@ import net.corda.testing.*
 import net.corda.testing.node.NodeBasedTest
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Before
-import org.junit.Ignore
 import org.junit.Test
+import java.time.Duration
 import kotlin.test.assertEquals
 import kotlin.test.assertFails
 import kotlin.test.assertTrue
@@ -114,7 +112,6 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
         assertFails { startNode(CHARLIE.name, noNetworkMap = true).getOrThrow(2.seconds) }
     }
 
-    @Ignore("Unstable test that needs more work")
     @Test
     fun `new node joins network without network map started`() {
 
@@ -146,9 +143,11 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
 
         // This is prediction of the longest time it will take to get the cluster into a stable state such that further
         // testing can be performed upon it
-        val maxInstabilityInterval = BRIDGE_RETRY_MS * allTheStartedNodesPopulation.size * 2
+        val maxInstabilityInterval = BRIDGE_RETRY_MS * allTheStartedNodesPopulation.size * 30
+        logger.info("Instability interval is set to: $maxInstabilityInterval ms")
 
-        eventually(maxInstabilityInterval.milliseconds) {
+        // TODO: Re-visit this sort of re-try for stable cluster once network map redesign is finished.
+        eventually<AssertionError, Unit>(Duration.ofMillis(maxInstabilityInterval)) {
             logger.info("Checking connectivity")
             checkConnectivity(listOf(otherNodes[0], nms)) // Checks connectivity from A to NMS.
             logger.info("Loading caches")
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/Eventually.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/Eventually.kt
new file mode 100644
index 0000000000..b3a4588609
--- /dev/null
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/Eventually.kt
@@ -0,0 +1,24 @@
+package net.corda.testing
+
+import java.time.Duration
+
+/**
+ * Ideas borrowed from "io.kotlintest" with some improvements made
+ * This is meant for use from Kotlin code use only mainly due to it's inline/reified nature
+ */
+inline fun <reified E : Throwable, R>eventually(duration: Duration, f: () -> R): R {
+    val end = System.nanoTime() + duration.toNanos()
+    var times = 0
+    while (System.nanoTime() < end) {
+        try {
+            return f()
+        } catch (e: Throwable) {
+            when(e) {
+                is E -> {}// ignore and continue
+                else -> throw e // unexpected exception type - rethrow
+            }
+        }
+        times++
+    }
+    throw AssertionError("Test failed after $duration; attempted $times times")
+}
\ No newline at end of file

From 0ec75f009779c1c0d1b2479079b05c8a81114523 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Mon, 2 Oct 2017 14:53:33 +0100
Subject: [PATCH 057/185] Fixes java-docs breaking typo.

---
 .../kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt b/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt
index 9ef8101bdd..c38368aaf6 100644
--- a/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt
@@ -20,8 +20,8 @@ import java.util.*
 class ResolveTransactionsFlow(private val txHashes: Set<SecureHash>,
                               private val otherSide: FlowSession) : FlowLogic<List<SignedTransaction>>() {
     /**
-     * Resolves and validates the dependencies of the specified [signedTransaction]. Fetches the attachments, but does
-     * *not* validate or store the [signedTransaction] itself.
+     * Resolves and validates the dependencies of the specified [SignedTransaction]. Fetches the attachments, but does
+     * *not* validate or store the [SignedTransaction] itself.
      *
      * @return a list of verified [SignedTransaction] objects, in a depth-first order.
      */

From ef9b54327ada1c4a3bd6cfaae09fc8088cbfb6e6 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Mon, 2 Oct 2017 15:01:19 +0100
Subject: [PATCH 058/185] Checking out the latest milestone will no longer be
 required.

---
 docs/source/getting-set-up.rst       |  7 -------
 docs/source/hello-world-template.rst |  8 +-------
 docs/source/troubleshooting.rst      |  7 -------
 docs/source/tutorial-cordapp.rst     | 10 ----------
 4 files changed, 1 insertion(+), 31 deletions(-)

diff --git a/docs/source/getting-set-up.rst b/docs/source/getting-set-up.rst
index 7a9b09b140..95bb99bfc9 100644
--- a/docs/source/getting-set-up.rst
+++ b/docs/source/getting-set-up.rst
@@ -76,8 +76,6 @@ Download a sample project
 1. Open a command prompt
 2. Clone the CorDapp example repo by running ``git clone https://github.com/corda/cordapp-example``
 3. Move into the cordapp-example folder by running ``cd cordapp-example``
-4. Retrieve a list of all the releases by running ``git branch -a --list``
-5. Check out the latest milestone release by running ``git checkout release-MX`` (where "X" is the latest milestone)
 
 Run from the command prompt
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -125,8 +123,6 @@ Download a sample project
 1. Open a terminal
 2. Clone the CorDapp example repo by running ``git clone https://github.com/corda/cordapp-example``
 3. Move into the cordapp-example folder by running ``cd cordapp-example``
-4. Retrieve a list of all the releases by running ``git branch -a --list``
-5. Check out the latest milestone release by running ``git checkout release-MX`` (where "X" is the latest milestone)
 
 Run from the terminal
 ^^^^^^^^^^^^^^^^^^^^^
@@ -165,9 +161,6 @@ And a simple example CorDapp for you to explore basic concepts is available here
 
 You can clone these repos to your local machine by running the command ``git clone [repo URL]``.
 
-By default, these repos will be on the unstable ``master`` branch. You should check out the latest milestone release
-instead by running ``git checkout release-MX`` (where “X” is the latest milestone).
-
 Next steps
 ----------
 The best way to check that everything is working fine is by taking a deeper look at the
diff --git a/docs/source/hello-world-template.rst b/docs/source/hello-world-template.rst
index acb131dc6f..5a6e3920a1 100644
--- a/docs/source/hello-world-template.rst
+++ b/docs/source/hello-world-template.rst
@@ -22,7 +22,7 @@ Downloading the template
 ------------------------
 Open a terminal window in the directory where you want to download the CorDapp template, and run the following commands:
 
-.. code-block:: text
+.. code-block:: bash
 
     # Clone the template from GitHub:
     git clone https://github.com/corda/cordapp-template-java.git ; cd cordapp-template-java
@@ -31,12 +31,6 @@ Open a terminal window in the directory where you want to download the CorDapp t
 
     git clone https://github.com/corda/cordapp-template-kotlin.git ; cd cordapp-template-kotlin
 
-    # Retrieve a list of the stable Milestone branches using:
-    git branch -a --list *release-M*
-
-    # Check out the Milestone branch with the latest version number:
-    git checkout release-M[*version number*] ; git pull
-
 Template structure
 ------------------
 We can write our CorDapp in either Java or Kotlin, and will be providing the code in both languages throughout. To
diff --git a/docs/source/troubleshooting.rst b/docs/source/troubleshooting.rst
index 434cdbe579..a07980119c 100644
--- a/docs/source/troubleshooting.rst
+++ b/docs/source/troubleshooting.rst
@@ -1,13 +1,6 @@
 Troubleshooting
 ===============
 
-Milestone releases
-------------------
-
-When you clone the corda or cordapp-template repos, they will default to the master branch. The master branch is being continuously developed upon, and its features may not align with the state of Corda as described in the docs. Additionally, the master branch of the CorDapp template may break in response to changes in the main corda repo.
-
-When developing on Corda, you should always check out the latest milestone (i.e. stable) branch instead. For example, to check out milestone 0, you'd run ``git checkout release-M0``.
-
 Java issues
 -----------
 
diff --git a/docs/source/tutorial-cordapp.rst b/docs/source/tutorial-cordapp.rst
index 3eec271545..ed203a66e5 100644
--- a/docs/source/tutorial-cordapp.rst
+++ b/docs/source/tutorial-cordapp.rst
@@ -36,16 +36,6 @@ We need to download the example CorDapp from GitHub.
 
 * Change directories to the freshly cloned repo: ``cd cordapp-example``
 
-* We want to work off the latest Milestone release
-
-  * To enumerate all the Milestone releases, run: ``git tag``
-
-  * Check out the latest (highest-numbered) Milestone release using: ``git checkout [tag_name]``
-
-    Where ``tag_name`` is the name of the tag you wish to checkout
-
-  * Gradle will grab all the required dependencies for you from `Maven <https://bintray.com/r3/corda>`_
-
 .. note:: If you wish to build off the latest, unstable version of the codebase, follow the instructions in
    :doc:`building against Master <building-against-master>` instead.
 

From 383eb2bef8e930baf780130fe45aa9d8d00bbdd7 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Mon, 2 Oct 2017 15:59:31 +0100
Subject: [PATCH 059/185] CORDA-540: Fix to make IRS demo code pass in AMQP
 mode (#1769)

* CORDA-540: Do not use concrete instance of an ArrayList as wire representation of it may be different

* CORDA-540: Make data structures suitable for AMQP serialization

* CORDA-540: Use "name" instead of "toString()"

Classes like "net.corda.finance.contracts.DayCountBasisDay" override "toString()" which leads to error behaviour
---
 .../nodeapi/internal/serialization/amqp/EnumSerializer.kt    | 4 ++--
 .../src/main/kotlin/net/corda/irs/contract/IRSUtils.kt       | 5 +++--
 .../src/main/kotlin/net/corda/irs/flows/RatesFixFlow.kt      | 4 +---
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumSerializer.kt
index 6ac728783c..a9e6d04cd4 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumSerializer.kt
@@ -30,9 +30,9 @@ class EnumSerializer(declaredType: Type, declaredClass: Class<*>, factory: Seria
     override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): Any {
         val enumName = (obj as List<*>)[0] as String
         val enumOrd = obj[1] as Int
-        val fromOrd = type.asClass()!!.enumConstants[enumOrd]
+        val fromOrd = type.asClass()!!.enumConstants[enumOrd] as Enum<*>?
 
-        if (enumName != fromOrd?.toString()) {
+        if (enumName != fromOrd?.name) {
             throw NotSerializableException("Deserializing obj as enum $type with value $enumName.$enumOrd but "
                     + "ordinality has changed")
         }
diff --git a/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt b/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt
index b8950ee871..fb7e367a3c 100644
--- a/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt
+++ b/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt
@@ -22,9 +22,9 @@ open class RatioUnit(val value: BigDecimal) { // TODO: Discuss this type
 }
 
 /**
- * A class to reprecent a percentage in an unambiguous way.
+ * A class to represent a percentage in an unambiguous way.
  */
-open class PercentageRatioUnit(percentageAsString: String) : RatioUnit(BigDecimal(percentageAsString).divide(BigDecimal("100"))) {
+open class PercentageRatioUnit(val percentageAsString: String) : RatioUnit(BigDecimal(percentageAsString).divide(BigDecimal("100"))) {
     override fun toString() = value.times(BigDecimal(100)).toString() + "%"
 }
 
@@ -39,6 +39,7 @@ val String.percent: PercentageRatioUnit get() = PercentageRatioUnit(this)
  * Parent of the Rate family. Used to denote fixed rates, floating rates, reference rates etc.
  */
 @JsonIgnoreProperties(ignoreUnknown = true)
+@CordaSerializable
 open class Rate(val ratioUnit: RatioUnit? = null) {
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
diff --git a/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/RatesFixFlow.kt b/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/RatesFixFlow.kt
index c2370a8ddf..4f148f01f6 100644
--- a/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/RatesFixFlow.kt
+++ b/samples/irs-demo/src/main/kotlin/net/corda/irs/flows/RatesFixFlow.kt
@@ -5,7 +5,6 @@ import net.corda.core.crypto.TransactionSignature
 import net.corda.core.crypto.isFulfilledBy
 import net.corda.core.flows.FlowException
 import net.corda.core.flows.FlowLogic
-import net.corda.core.flows.FlowSession
 import net.corda.core.flows.InitiatingFlow
 import net.corda.core.identity.Party
 import net.corda.core.serialization.CordaSerializable
@@ -17,7 +16,6 @@ import net.corda.finance.contracts.Fix
 import net.corda.finance.contracts.FixOf
 import net.corda.irs.flows.RatesFixFlow.FixOutOfRange
 import java.math.BigDecimal
-import java.util.*
 import java.util.function.Predicate
 
 // This code is unit tested in NodeInterestRates.kt
@@ -100,7 +98,7 @@ open class RatesFixFlow(protected val tx: TransactionBuilder,
         override fun call(): Fix {
             val oracleSession = initiateFlow(oracle)
             // TODO: add deadline to receive
-            val resp = oracleSession.sendAndReceive<ArrayList<Fix>>(QueryRequest(listOf(fixOf)))
+            val resp = oracleSession.sendAndReceive<List<Fix>>(QueryRequest(listOf(fixOf)))
 
             return resp.unwrap {
                 val fix = it.first()

From 12982b30346685b0d4289555e017217ca8c145ca Mon Sep 17 00:00:00 2001
From: Andrzej Cichocki <andrzej.cichocki@r3.com>
Date: Mon, 2 Oct 2017 15:59:55 +0100
Subject: [PATCH 060/185] Move dbCloser to MockNode, the only thing that uses
 it. (#1512)

---
 .../src/main/kotlin/net/corda/node/internal/AbstractNode.kt | 6 +-----
 .../src/main/kotlin/net/corda/testing/node/MockNode.kt      | 6 ++++++
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index ea492d2a64..b0293ed838 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -146,7 +146,6 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
     protected lateinit var network: MessagingService
     protected val runOnStop = ArrayList<() -> Any?>()
     protected lateinit var database: CordaPersistence
-    protected var dbCloser: (() -> Any?)? = null
     lateinit var cordappProvider: CordappProviderImpl
     protected val cordappLoader by lazy { makeCordappLoader() }
 
@@ -476,10 +475,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
             database.transaction {
                 log.info("Connected to ${database.dataSource.connection.metaData.databaseProductName} database.")
             }
-            this.database::close.let {
-                dbCloser = it
-                runOnStop += it
-            }
+            runOnStop += database::close
             return database.transaction {
                 insideTransaction()
             }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index 63dd79f8d8..9ef99e42e8 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -241,6 +241,12 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
         // It is used from the network visualiser tool.
         @Suppress("unused") val place: WorldMapLocation get() = findMyLocation()!!
 
+        private var dbCloser: (() -> Any?)? = null
+        override fun <T> initialiseDatabasePersistence(insideTransaction: () -> T) = super.initialiseDatabasePersistence {
+            dbCloser = database::close
+            insideTransaction()
+        }
+
         fun disableDBCloseOnStop() {
             runOnStop.remove(dbCloser)
         }

From 9a1601144834672bd7448489e0011f37cc7521e5 Mon Sep 17 00:00:00 2001
From: Rick Parker <rick.parker@r3.com>
Date: Fri, 29 Sep 2017 15:45:19 +0100
Subject: [PATCH 061/185] * Move CompositeSignaturesWithKeys into
 net.corda.core.crypto package. * Rename and move CordaPluginRegistry to
 reflect its real purpose now. * Docs: docsite improvements * Remove
 discussion of webserver from 'writing a cordapp' page. * Fixup some flow
 docs. * Add a couple more package descriptions. * Review comments - always
 apply default whitelist and no longer load it via ServiceLoader * Added
 wording about renaming services resource file

---
 .../kotlin/net/corda/core/cordapp/Cordapp.kt  |  6 +--
 .../corda/core/crypto/CompositeSignature.kt   |  1 -
 .../CompositeSignaturesWithKeys.kt            |  3 +-
 .../core/internal/cordapp/CordappImpl.kt      |  6 +--
 .../corda/core/node/CordaPluginRegistry.kt    | 19 ---------
 .../SerializationCustomization.kt             |  6 ---
 .../serialization/SerializationWhitelist.kt   | 16 ++++++++
 .../corda/core/crypto/CompositeKeyTests.kt    |  3 +-
 docs/packages.md                              |  8 ++--
 docs/source/changelog.rst                     |  8 ++--
 .../net/corda/docs/ClientRpcTutorial.kt       | 15 +++----
 docs/source/flow-state-machines.rst           | 37 ++---------------
 docs/source/writing-cordapps.rst              | 40 +------------------
 .../contracts/isolated/IsolatedPlugin.kt      |  5 ---
 .../net.corda.core.node.CordaPluginRegistry   |  1 -
 .../serialization/AMQPSerializationScheme.kt  | 17 +++-----
 .../serialization/CordaClassResolver.kt       |  2 +-
 .../serialization/DefaultKryoCustomizer.kt    | 19 ++++++---
 .../serialization/DefaultWhitelist.kt         | 16 +++-----
 .../KryoSerializationCustomization.kt         | 17 --------
 .../net.corda.core.node.CordaPluginRegistry   |  2 -
 .../net/corda/node/internal/AbstractNode.kt   |  7 ++--
 .../net/corda/node/internal/NodeStartup.kt    |  8 +---
 .../node/internal/cordapp/CordappLoader.kt    |  9 +++--
 .../internal/cordapp/CordappLoaderTest.kt     |  2 -
 ...webserver.services.WebServerPluginRegistry |  1 -
 .../net/corda/vega/plugin/SimmPlugin.kt       |  4 +-
 .../corda/vega/plugin/SimmPluginRegistry.kt   | 39 ++++++++----------
 .../net.corda.core.node.CordaPluginRegistry   |  2 -
 ....core.serialization.SerializationWhitelist |  1 +
 .../kotlin/net/corda/testing/node/MockNode.kt | 26 +++++++-----
 31 files changed, 114 insertions(+), 232 deletions(-)
 rename core/src/main/kotlin/net/corda/core/crypto/{composite => }/CompositeSignaturesWithKeys.kt (81%)
 delete mode 100644 core/src/main/kotlin/net/corda/core/node/CordaPluginRegistry.kt
 delete mode 100644 core/src/main/kotlin/net/corda/core/serialization/SerializationCustomization.kt
 create mode 100644 core/src/main/kotlin/net/corda/core/serialization/SerializationWhitelist.kt
 delete mode 100644 finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedPlugin.kt
 delete mode 100644 finance/isolated/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry
 delete mode 100644 node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/KryoSerializationCustomization.kt
 delete mode 100644 node-api/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry
 delete mode 100644 samples/simm-valuation-demo/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry
 create mode 100644 samples/simm-valuation-demo/src/main/resources/META-INF/services/net.corda.core.serialization.SerializationWhitelist

diff --git a/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt b/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
index ea9557d7c9..32c011866e 100644
--- a/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
+++ b/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
@@ -1,8 +1,8 @@
 package net.corda.core.cordapp
 
 import net.corda.core.flows.FlowLogic
-import net.corda.core.node.CordaPluginRegistry
 import net.corda.core.schemas.MappedSchema
+import net.corda.core.serialization.SerializationWhitelist
 import net.corda.core.serialization.SerializeAsToken
 import java.net.URL
 
@@ -19,7 +19,7 @@ import java.net.URL
  * @property rpcFlows List of RPC initiable flows classes
  * @property schedulableFlows List of flows startable by the scheduler
  * @property servies List of RPC services
- * @property plugins List of Corda plugin registries
+ * @property serializationWhitelists List of Corda plugin registries
  * @property customSchemas List of custom schemas
  * @property jarPath The path to the JAR for this CorDapp
  */
@@ -30,7 +30,7 @@ interface Cordapp {
     val rpcFlows: List<Class<out FlowLogic<*>>>
     val schedulableFlows: List<Class<out FlowLogic<*>>>
     val services: List<Class<out SerializeAsToken>>
-    val plugins: List<CordaPluginRegistry>
+    val serializationWhitelists: List<SerializationWhitelist>
     val customSchemas: Set<MappedSchema>
     val jarPath: URL
     val cordappClasses: List<String>
diff --git a/core/src/main/kotlin/net/corda/core/crypto/CompositeSignature.kt b/core/src/main/kotlin/net/corda/core/crypto/CompositeSignature.kt
index 8317a11a64..b359e31991 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/CompositeSignature.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/CompositeSignature.kt
@@ -1,6 +1,5 @@
 package net.corda.core.crypto
 
-import net.corda.core.crypto.composite.CompositeSignaturesWithKeys
 import net.corda.core.serialization.deserialize
 import java.io.ByteArrayOutputStream
 import java.security.*
diff --git a/core/src/main/kotlin/net/corda/core/crypto/composite/CompositeSignaturesWithKeys.kt b/core/src/main/kotlin/net/corda/core/crypto/CompositeSignaturesWithKeys.kt
similarity index 81%
rename from core/src/main/kotlin/net/corda/core/crypto/composite/CompositeSignaturesWithKeys.kt
rename to core/src/main/kotlin/net/corda/core/crypto/CompositeSignaturesWithKeys.kt
index f9c8da8ab3..0ea62b1f0e 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/composite/CompositeSignaturesWithKeys.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/CompositeSignaturesWithKeys.kt
@@ -1,6 +1,5 @@
-package net.corda.core.crypto.composite
+package net.corda.core.crypto
 
-import net.corda.core.crypto.TransactionSignature
 import net.corda.core.serialization.CordaSerializable
 
 /**
diff --git a/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt b/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
index 8cfda77d42..e03e83f92c 100644
--- a/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
@@ -2,8 +2,8 @@ package net.corda.core.internal.cordapp
 
 import net.corda.core.cordapp.Cordapp
 import net.corda.core.flows.FlowLogic
-import net.corda.core.node.CordaPluginRegistry
 import net.corda.core.schemas.MappedSchema
+import net.corda.core.serialization.SerializationWhitelist
 import net.corda.core.serialization.SerializeAsToken
 import java.io.File
 import java.net.URL
@@ -14,7 +14,7 @@ data class CordappImpl(
         override val rpcFlows: List<Class<out FlowLogic<*>>>,
         override val schedulableFlows: List<Class<out FlowLogic<*>>>,
         override val services: List<Class<out SerializeAsToken>>,
-        override val plugins: List<CordaPluginRegistry>,
+        override val serializationWhitelists: List<SerializationWhitelist>,
         override val customSchemas: Set<MappedSchema>,
         override val jarPath: URL) : Cordapp {
     override val name: String = File(jarPath.toURI()).name.removeSuffix(".jar")
@@ -24,5 +24,5 @@ data class CordappImpl(
      *
      * TODO: Also add [SchedulableFlow] as a Cordapp class
      */
-    override val cordappClasses = ((rpcFlows + initiatedFlows + services + plugins.map { javaClass }).map { it.name } + contractClassNames)
+    override val cordappClasses = ((rpcFlows + initiatedFlows + services + serializationWhitelists.map { javaClass }).map { it.name } + contractClassNames)
 }
diff --git a/core/src/main/kotlin/net/corda/core/node/CordaPluginRegistry.kt b/core/src/main/kotlin/net/corda/core/node/CordaPluginRegistry.kt
deleted file mode 100644
index 600f548a80..0000000000
--- a/core/src/main/kotlin/net/corda/core/node/CordaPluginRegistry.kt
+++ /dev/null
@@ -1,19 +0,0 @@
-package net.corda.core.node
-
-import net.corda.core.serialization.SerializationCustomization
-
-/**
- * Implement this interface on a class advertised in a META-INF/services/net.corda.core.node.CordaPluginRegistry file
- * to extend a Corda node with additional application services.
- */
-abstract class CordaPluginRegistry {
-    /**
-     * Optionally whitelist types for use in object serialization, as we lock down the types that can be serialized.
-     *
-     * For example, if you add a new [net.corda.core.contracts.ContractState] it needs to be whitelisted.  You can do that
-     * either by adding the [net.corda.core.serialization.CordaSerializable] annotation or via this method.
-     **
-     * @return true if you register types, otherwise you will be filtered out of the list of plugins considered in future.
-     */
-    open fun customizeSerialization(custom: SerializationCustomization): Boolean = false
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/net/corda/core/serialization/SerializationCustomization.kt b/core/src/main/kotlin/net/corda/core/serialization/SerializationCustomization.kt
deleted file mode 100644
index 91c5dea265..0000000000
--- a/core/src/main/kotlin/net/corda/core/serialization/SerializationCustomization.kt
+++ /dev/null
@@ -1,6 +0,0 @@
-package net.corda.core.serialization
-
-interface SerializationCustomization {
-    fun addToWhitelist(vararg types: Class<*>)
-}
-
diff --git a/core/src/main/kotlin/net/corda/core/serialization/SerializationWhitelist.kt b/core/src/main/kotlin/net/corda/core/serialization/SerializationWhitelist.kt
new file mode 100644
index 0000000000..0c2be0c16b
--- /dev/null
+++ b/core/src/main/kotlin/net/corda/core/serialization/SerializationWhitelist.kt
@@ -0,0 +1,16 @@
+package net.corda.core.serialization
+
+/**
+ * Provide a subclass of this via the [java.util.ServiceLoader] mechanism to be able to whitelist types for
+ * serialisation that you cannot otherwise annotate. The name of the class must appear in a text file on the
+ * classpath under the path META-INF/services/net.corda.core.serialization.SerializationWhitelist
+ */
+interface SerializationWhitelist {
+    /**
+     * Optionally whitelist types for use in object serialization, as we lock down the types that can be serialized.
+     *
+     * For example, if you add a new [net.corda.core.contracts.ContractState] it needs to be whitelisted.  You can do that
+     * either by adding the [net.corda.core.serialization.CordaSerializable] annotation or via this method.
+     */
+    val whitelist: List<Class<*>>
+}
\ No newline at end of file
diff --git a/core/src/test/kotlin/net/corda/core/crypto/CompositeKeyTests.kt b/core/src/test/kotlin/net/corda/core/crypto/CompositeKeyTests.kt
index 0b7c6187e9..80124d722d 100644
--- a/core/src/test/kotlin/net/corda/core/crypto/CompositeKeyTests.kt
+++ b/core/src/test/kotlin/net/corda/core/crypto/CompositeKeyTests.kt
@@ -1,13 +1,12 @@
 package net.corda.core.crypto
 
 import net.corda.core.crypto.CompositeKey.NodeAndWeight
-import net.corda.core.crypto.composite.CompositeSignaturesWithKeys
 import net.corda.core.identity.CordaX500Name
+import net.corda.core.internal.cert
 import net.corda.core.internal.declaredField
 import net.corda.core.internal.div
 import net.corda.core.serialization.serialize
 import net.corda.core.utilities.OpaqueBytes
-import net.corda.core.internal.cert
 import net.corda.core.utilities.toBase58String
 import net.corda.node.utilities.*
 import net.corda.testing.TestDependencyInjectionBase
diff --git a/docs/packages.md b/docs/packages.md
index 2c2090e790..eb039e5237 100644
--- a/docs/packages.md
+++ b/docs/packages.md
@@ -24,6 +24,10 @@ RPC client interface to Corda, for use both by user-facing client and integratio
 
 Internal, do not use. These APIs and implementations which are currently being revised and are subject to future change.
 
+# Package net.corda.core
+
+Exception types and some utilities for working with observables and futures.
+
 # Package net.corda.core.cordapp
 
 This package contains the interface to CorDapps from within a node. A CorDapp can access its own context by using
@@ -60,10 +64,6 @@ processes such as handling fixing of interest rate swaps.
 
 Data classes which model different forms of identity (potentially with supporting evidence) for legal entities and services.
 
-# Package net.corda.core.internal
-
-Internal, do not use. These APIs and implementations which are currently being revised and are subject to future change.
-
 # Package net.corda.core.messaging
 
 Data types used by the Corda messaging layer to manage state of messaging and sessions between nodes.
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index c32cc9913a..696507c047 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -65,9 +65,11 @@ Release 1.0
 * About half of the code in test-utils has been moved to a new module ``node-driver``,
   and the test scope modules are now located in a ``testing`` directory.
 
-* Removed `requireSchemas` CordaPluginRegistry configuration item.
-  Custom schemas are now automatically located using classpath scanning for deployed CorDapps.
-  Improved support for testing custom schemas in MockNode and MockServices using explicit registration.
+* CordaPluginRegistry has been renamed to SerializationWhitelist and moved to the net.corda.core.serialization
+  package. The API for whitelisting types that can't be annotated was slightly simplified. This class used to contain
+  many things, but as we switched to annotations and classpath scanning over time it hollowed out until this was
+  the only functionality left.  You also need to rename your services resource file to the new class name.
+  An associated property on ``MockNode`` was renamed from ``testPluginRegistries`` to ``testSerializationWhitelists``.
 
 * Contract Upgrades: deprecated RPC authorisation / deauthorisation API calls in favour of equivalent flows in ContractUpgradeFlow.
   Implemented contract upgrade persistence using JDBC backed persistent map.
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
index bc21a3b5f2..bf6b46be6e 100644
--- a/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
@@ -4,9 +4,8 @@ import net.corda.core.contracts.Amount
 import net.corda.core.messaging.CordaRPCOps
 import net.corda.core.messaging.startFlow
 import net.corda.core.messaging.vaultQueryBy
-import net.corda.core.node.CordaPluginRegistry
 import net.corda.core.serialization.CordaSerializable
-import net.corda.core.serialization.SerializationCustomization
+import net.corda.core.serialization.SerializationWhitelist
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.getOrThrow
@@ -16,9 +15,9 @@ import net.corda.finance.flows.CashExitFlow
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.User
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.ALICE
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.driver.driver
@@ -142,12 +141,8 @@ data class ExampleRPCValue(val foo: String)
 @CordaSerializable
 data class ExampleRPCValue2(val bar: Int)
 
-class ExampleRPCCordaPluginRegistry : CordaPluginRegistry() {
-    override fun customizeSerialization(custom: SerializationCustomization): Boolean {
-        // Add classes like this.
-        custom.addToWhitelist(ExampleRPCValue::class.java)
-        // You should return true, otherwise your plugin will be ignored for registering classes with Kryo.
-        return true
-    }
+class ExampleRPCSerializationWhitelist : SerializationWhitelist {
+    // Add classes like this.
+    override val whitelist = listOf(ExampleRPCValue::class.java)
 }
 // END 7
diff --git a/docs/source/flow-state-machines.rst b/docs/source/flow-state-machines.rst
index bc7e484ae1..c0946f07a6 100644
--- a/docs/source/flow-state-machines.rst
+++ b/docs/source/flow-state-machines.rst
@@ -277,40 +277,9 @@ will propagate to the other side. Any other exception will not propagate.
 
 Taking a step back, we mentioned that the other side has to accept the session request for there to be a communication
 channel. A node accepts a session request if it has registered the flow type (the fully-qualified class name) that is
-making the request - each session initiation includes the initiating flow type. The registration is done by a CorDapp
-which has made available the particular flow communication, using ``PluginServiceHub.registerServiceFlow``. This method
-specifies a flow factory for generating the counter-flow to any given initiating flow. If this registration doesn't exist
-then no further communication takes place and the initiating flow ends with an exception.
-
-Going back to our buyer and seller flows, we need a way to initiate communication between the two. This is typically done
-with one side started manually using the ``startFlowDynamic`` RPC and this initiates the counter-flow on the other side.
-In this case it doesn't matter which flow is the initiator and which is the initiated. If we choose the seller side as
-the initiator then the buyer side would need to register their flow, perhaps with something like:
-
-.. container:: codeset
-
-   .. sourcecode:: kotlin
-
-        class TwoPartyTradeFlowPlugin : CordaPluginRegistry() {
-            override val servicePlugins = listOf(Function(TwoPartyTradeFlowService::Service))
-        }
-
-        object TwoPartyTradeFlowService {
-            class Service(services: PluginServiceHub) {
-                init {
-                    services.registerServiceFlow(TwoPartyTradeFlow.Seller::class.java) {
-                        TwoPartyTradeFlow.Buyer(
-                            it,
-                            notary = services.networkMapCache.notaryIdentities[0].party,
-                            acceptablePrice = TODO(),
-                            typeToBuy = TODO())
-                    }
-                }
-            }
-        }
-
-This is telling the buyer node to fire up an instance of ``TwoPartyTradeFlow.Buyer`` (the code in the lambda) when
-they receive a message from the initiating seller side of the flow (``TwoPartyTradeFlow.Seller::class.java``).
+making the request - each session initiation includes the initiating flow type. The *initiated* (server) flow must name the
+*initiating* (client) flow using the ``@InitiatedBy`` annotation and passing the class name that will be starting the
+flow session as the annotation parameter.
 
 .. _subflows:
 
diff --git a/docs/source/writing-cordapps.rst b/docs/source/writing-cordapps.rst
index 9200cb8fe5..55eda0e091 100644
--- a/docs/source/writing-cordapps.rst
+++ b/docs/source/writing-cordapps.rst
@@ -44,7 +44,7 @@ The ``src`` directory of the Template CorDapp, where we define our CorDapp's sou
     │   └── resources
     │       ├── META-INF
     │       │   └── services
-    │       │       ├── net.corda.core.node.CordaPluginRegistry
+    │       │       ├── net.corda.core.serialization.SerializationWhitelist
     │       │       └── net.corda.webserver.services.WebServerPluginRegistry
     │       ├── certificates
     │       │   ├── sslkeystore.jks
@@ -58,40 +58,4 @@ The ``src`` directory of the Template CorDapp, where we define our CorDapp's sou
             └── com
                 └── template
                     └── contract
-                        └── TemplateTests.java
-
-Defining plugins
-----------------
-Your CorDapp may need to define two types of plugins:
-
-* ``CordaPluginRegistry`` subclasses, which define additional serializable classes
-* ``WebServerPluginRegistry`` subclasses, which define the APIs and static web content served by your CorDapp
-
-The fully-qualified class path of each ``CordaPluginRegistry`` subclass must then be added to the
-``net.corda.core.node.CordaPluginRegistry`` file in the CorDapp's ``resources/META-INF/services`` folder. Meanwhile,
-the fully-qualified class path of each ``WebServerPluginRegistry`` subclass must be added to the
-``net.corda.webserver.services.WebServerPluginRegistry`` file, again in the CorDapp's ``resources/META-INF/services``
-folder.
-
-The ``CordaPluginRegistry`` class defines the following:
-
-* ``customizeSerialization``, which can be overridden to provide a list of the classes to be whitelisted for object
-  serialisation, over and above those tagged with the ``@CordaSerializable`` annotation. See :doc:`serialization`
-
-The ``WebServerPluginRegistry`` class defines the following:
-
-* ``webApis``, which can be overridden to return a list of JAX-RS annotated REST access classes. These classes will be
-  constructed by the bundled web server and must have a single argument constructor taking a ``CordaRPCOps`` object.
-  This will allow the API to communicate with the node process via the RPC interface. These web APIs will not be
-  available if the bundled web server is not started
-
-* ``staticServeDirs``, which can be overridden to map static web content to virtual paths and allow simple web demos to
-  be distributed within the CorDapp jars. This static content will not be available if the bundled web server is not
-  started
-
-* ``customizeJSONSerialization``, which can be overridden to register custom JSON serializers if required by the REST api.
-
-  * The static web content itself should be placed inside the ``src/main/resources`` directory
-
-To learn about how to use gradle to build your cordapp against Corda and generate an artifact please read
-:doc:`cordapp-build-systems`.
\ No newline at end of file
+                        └── TemplateTests.java
\ No newline at end of file
diff --git a/finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedPlugin.kt b/finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedPlugin.kt
deleted file mode 100644
index 61e0288d88..0000000000
--- a/finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedPlugin.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-package net.corda.finance.contracts.isolated
-
-import net.corda.core.node.CordaPluginRegistry
-
-class IsolatedPlugin : CordaPluginRegistry()
\ No newline at end of file
diff --git a/finance/isolated/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry b/finance/isolated/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry
deleted file mode 100644
index 759dc08195..0000000000
--- a/finance/isolated/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry
+++ /dev/null
@@ -1 +0,0 @@
-net.corda.finance.contracts.isolated.IsolatedPlugin
\ No newline at end of file
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AMQPSerializationScheme.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AMQPSerializationScheme.kt
index 6368a416a0..bbc3be72a8 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AMQPSerializationScheme.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AMQPSerializationScheme.kt
@@ -2,7 +2,6 @@
 
 package net.corda.nodeapi.internal.serialization
 
-import net.corda.core.node.CordaPluginRegistry
 import net.corda.core.serialization.*
 import net.corda.core.utilities.ByteSequence
 import net.corda.nodeapi.internal.serialization.amqp.AmqpHeaderV1_0
@@ -14,12 +13,6 @@ import java.util.concurrent.ConcurrentHashMap
 
 val AMQP_ENABLED get() = SerializationDefaults.P2P_CONTEXT.preferredSerializationVersion == AmqpHeaderV1_0
 
-class AMQPSerializationCustomization(val factory: SerializerFactory) : SerializationCustomization {
-    override fun addToWhitelist(vararg types: Class<*>) {
-        factory.addToWhitelist(*types)
-    }
-}
-
 fun SerializerFactory.addToWhitelist(vararg types: Class<*>) {
     require(types.toSet().size == types.size) {
         val duplicates = types.toMutableList()
@@ -33,12 +26,12 @@ fun SerializerFactory.addToWhitelist(vararg types: Class<*>) {
 
 abstract class AbstractAMQPSerializationScheme : SerializationScheme {
     internal companion object {
-        private val pluginRegistries: List<CordaPluginRegistry> by lazy {
-            ServiceLoader.load(CordaPluginRegistry::class.java, this::class.java.classLoader).toList()
+        private val serializationWhitelists: List<SerializationWhitelist> by lazy {
+            ServiceLoader.load(SerializationWhitelist::class.java, this::class.java.classLoader).toList() + DefaultWhitelist
         }
 
         fun registerCustomSerializers(factory: SerializerFactory) {
-            factory.apply {
+            with(factory) {
                 register(net.corda.nodeapi.internal.serialization.amqp.custom.PublicKeySerializer)
                 register(net.corda.nodeapi.internal.serialization.amqp.custom.ThrowableSerializer(this))
                 register(net.corda.nodeapi.internal.serialization.amqp.custom.X500NameSerializer)
@@ -67,8 +60,8 @@ abstract class AbstractAMQPSerializationScheme : SerializationScheme {
                 register(net.corda.nodeapi.internal.serialization.amqp.custom.BitSetSerializer(this))
                 register(net.corda.nodeapi.internal.serialization.amqp.custom.EnumSetSerializer(this))
             }
-            val customizer = AMQPSerializationCustomization(factory)
-            pluginRegistries.forEach { it.customizeSerialization(customizer) }
+            for (whitelistProvider in serializationWhitelists)
+                factory.addToWhitelist(*whitelistProvider.whitelist.toTypedArray())
         }
     }
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
index 45f98cbda9..91573ed24e 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
@@ -168,7 +168,7 @@ class GlobalTransientClassWhiteList(val delegate: ClassWhitelist) : MutableClass
 }
 
 /**
- * A whitelist that can be customised via the [net.corda.core.node.CordaPluginRegistry], since implements [MutableClassWhitelist].
+ * A whitelist that can be customised via the [net.corda.core.node.SerializationWhitelist], since implements [MutableClassWhitelist].
  */
 class TransientClassWhiteList(val delegate: ClassWhitelist) : MutableClassWhitelist, ClassWhitelist by delegate {
     val whitelist: MutableSet<String> = Collections.synchronizedSet(mutableSetOf())
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt
index 75274a810d..d4a6f11ee2 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt
@@ -15,7 +15,7 @@ import net.corda.core.contracts.ContractAttachment
 import net.corda.core.contracts.PrivacySalt
 import net.corda.core.crypto.CompositeKey
 import net.corda.core.identity.PartyAndCertificate
-import net.corda.core.node.CordaPluginRegistry
+import net.corda.core.serialization.SerializationWhitelist
 import net.corda.core.serialization.SerializeAsToken
 import net.corda.core.serialization.SerializedBytes
 import net.corda.core.transactions.NotaryChangeWireTransaction
@@ -49,8 +49,8 @@ import java.util.*
 import kotlin.collections.ArrayList
 
 object DefaultKryoCustomizer {
-    private val pluginRegistries: List<CordaPluginRegistry> by lazy {
-        ServiceLoader.load(CordaPluginRegistry::class.java, this.javaClass.classLoader).toList()
+    private val serializationWhitelists: List<SerializationWhitelist> by lazy {
+        ServiceLoader.load(SerializationWhitelist::class.java, this.javaClass.classLoader).toList() + DefaultWhitelist
     }
 
     fun customize(kryo: Kryo): Kryo {
@@ -122,8 +122,17 @@ object DefaultKryoCustomizer {
             register(java.lang.invoke.SerializedLambda::class.java)
             register(ClosureSerializer.Closure::class.java, CordaClosureBlacklistSerializer)
 
-            val customization = KryoSerializationCustomization(this)
-            pluginRegistries.forEach { it.customizeSerialization(customization) }
+            for (whitelistProvider in serializationWhitelists) {
+                val types = whitelistProvider.whitelist
+                require(types.toSet().size == types.size) {
+                    val duplicates = types.toMutableList()
+                    types.toSet().forEach { duplicates -= it }
+                    "Cannot add duplicate classes to the whitelist ($duplicates)."
+                }
+                for (type in types) {
+                    ((kryo.classResolver as? CordaClassResolver)?.whitelist as? MutableClassWhitelist)?.add(type)
+                }
+            }
         }
     }
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultWhitelist.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultWhitelist.kt
index c602698ade..8a5cdbcaa3 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultWhitelist.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultWhitelist.kt
@@ -1,8 +1,7 @@
 package net.corda.nodeapi.internal.serialization
 
 import com.esotericsoftware.kryo.KryoException
-import net.corda.core.node.CordaPluginRegistry
-import net.corda.core.serialization.SerializationCustomization
+import net.corda.core.serialization.SerializationWhitelist
 import net.corda.core.utilities.NetworkHostAndPort
 import org.apache.activemq.artemis.api.core.SimpleString
 import rx.Notification
@@ -12,10 +11,9 @@ import java.util.*
 /**
  * NOTE: We do not whitelist [HashMap] or [HashSet] since they are unstable under serialization.
  */
-class DefaultWhitelist : CordaPluginRegistry() {
-    override fun customizeSerialization(custom: SerializationCustomization): Boolean {
-        custom.apply {
-            addToWhitelist(Array<Any>(0, {}).javaClass,
+object DefaultWhitelist : SerializationWhitelist {
+    override val whitelist =
+            listOf(Array<Any>(0, {}).javaClass,
                     Notification::class.java,
                     Notification.Kind::class.java,
                     ArrayList::class.java,
@@ -60,8 +58,6 @@ class DefaultWhitelist : CordaPluginRegistry() {
                     java.util.LinkedHashMap::class.java,
                     BitSet::class.java,
                     OnErrorNotImplementedException::class.java,
-                    StackTraceElement::class.java)
-        }
-        return true
-    }
+                    StackTraceElement::class.java
+            )
 }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/KryoSerializationCustomization.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/KryoSerializationCustomization.kt
deleted file mode 100644
index 993a2dad02..0000000000
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/KryoSerializationCustomization.kt
+++ /dev/null
@@ -1,17 +0,0 @@
-package net.corda.nodeapi.internal.serialization
-
-import com.esotericsoftware.kryo.Kryo
-import net.corda.core.serialization.SerializationCustomization
-
-class KryoSerializationCustomization(val kryo: Kryo) : SerializationCustomization {
-    override fun addToWhitelist(vararg types: Class<*>) {
-        require(types.toSet().size == types.size) {
-            val duplicates = types.toMutableList()
-            types.toSet().forEach { duplicates -= it }
-            "Cannot add duplicate classes to the whitelist ($duplicates)."
-        }
-        for (type in types) {
-            ((kryo.classResolver as? CordaClassResolver)?.whitelist as? MutableClassWhitelist)?.add(type)
-        }
-    }
-}
\ No newline at end of file
diff --git a/node-api/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry b/node-api/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry
deleted file mode 100644
index 6a4ca5dcd5..0000000000
--- a/node-api/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry
+++ /dev/null
@@ -1,2 +0,0 @@
-# Register a ServiceLoader service extending from net.corda.core.node.CordaPluginRegistry
-net.corda.nodeapi.internal.serialization.DefaultWhitelist
\ No newline at end of file
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index b0293ed838..f0711e97a7 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -23,12 +23,12 @@ import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.CordaRPCOps
 import net.corda.core.messaging.RPCOps
 import net.corda.core.messaging.SingleMessageRecipient
-import net.corda.core.node.CordaPluginRegistry
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.ServiceHub
 import net.corda.core.node.services.*
 import net.corda.core.node.services.NetworkMapCache.MapChange
 import net.corda.core.schemas.MappedSchema
+import net.corda.core.serialization.SerializationWhitelist
 import net.corda.core.serialization.SerializeAsToken
 import net.corda.core.serialization.SingletonSerializeAsToken
 import net.corda.core.transactions.SignedTransaction
@@ -70,7 +70,6 @@ import net.corda.node.utilities.*
 import net.corda.node.utilities.AddOrRemove.ADD
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.nodeapi.internal.ServiceType
-import net.corda.nodeapi.internal.serialization.DefaultWhitelist
 import org.apache.activemq.artemis.utils.ReusableLatch
 import org.slf4j.Logger
 import rx.Observable
@@ -160,8 +159,8 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         CordaX500Name.build(cert.subjectX500Principal).copy(commonName = null)
     }
 
-    open val pluginRegistries: List<CordaPluginRegistry> by lazy {
-        cordappProvider.cordapps.flatMap { it.plugins } + DefaultWhitelist()
+    open val serializationWhitelists: List<SerializationWhitelist> by lazy {
+        cordappProvider.cordapps.flatMap { it.serializationWhitelists }
     }
 
     /** Set to non-null once [start] has been successfully called. */
diff --git a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
index 9fd82c83d0..d180abaa41 100644
--- a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
@@ -7,12 +7,12 @@ import net.corda.core.internal.*
 import net.corda.core.internal.concurrent.thenMatch
 import net.corda.core.utilities.loggerFor
 import net.corda.node.*
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.config.FullNodeConfiguration
 import net.corda.node.services.transactions.bftSMaRtSerialFilter
 import net.corda.node.shell.InteractiveShell
 import net.corda.node.utilities.registration.HTTPNetworkRegistrationService
 import net.corda.node.utilities.registration.NetworkRegistrationHelper
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.nodeapi.internal.addShutdownHook
 import org.fusesource.jansi.Ansi
 import org.fusesource.jansi.AnsiConsole
@@ -264,12 +264,6 @@ open class NodeStartup(val args: Array<String>) {
             if (it.isNotEmpty()) Node.printBasicNodeInfo("Providing additional services", it.joinToString())
         }
         Node.printBasicNodeInfo("Loaded CorDapps", node.cordappProvider.cordapps.map { it.name }.joinToString())
-        val plugins = node.pluginRegistries
-                .map { it.javaClass.name }
-                .filterNot { it.startsWith("net.corda.node.") || it.startsWith("net.corda.core.") || it.startsWith("net.corda.nodeapi.") }
-                .map { it.substringBefore('$') }
-        if (plugins.isNotEmpty())
-            Node.printBasicNodeInfo("Loaded plugins", plugins.joinToString())
     }
 
     open fun drawBanner(versionInfo: VersionInfo) {
diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
index bb98afbe43..1449a32fb8 100644
--- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
@@ -8,12 +8,13 @@ import net.corda.core.cordapp.Cordapp
 import net.corda.core.flows.*
 import net.corda.core.internal.*
 import net.corda.core.internal.cordapp.CordappImpl
-import net.corda.core.node.CordaPluginRegistry
 import net.corda.core.node.services.CordaService
 import net.corda.core.schemas.MappedSchema
+import net.corda.core.serialization.SerializationWhitelist
 import net.corda.core.serialization.SerializeAsToken
 import net.corda.core.utilities.loggerFor
 import net.corda.node.internal.classloading.requireAnnotation
+import net.corda.nodeapi.internal.serialization.DefaultWhitelist
 import java.io.File
 import java.io.FileOutputStream
 import java.lang.reflect.Modifier
@@ -222,10 +223,10 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
         return (scanResult.getNamesOfClassesImplementing(Contract::class.java) + scanResult.getNamesOfClassesImplementing(UpgradedContract::class.java)).distinct()
     }
 
-    private fun findPlugins(cordappJarPath: URL): List<CordaPluginRegistry> {
-        return ServiceLoader.load(CordaPluginRegistry::class.java, URLClassLoader(arrayOf(cordappJarPath), appClassLoader)).toList().filter {
+    private fun findPlugins(cordappJarPath: URL): List<SerializationWhitelist> {
+        return ServiceLoader.load(SerializationWhitelist::class.java, URLClassLoader(arrayOf(cordappJarPath), appClassLoader)).toList().filter {
             cordappJarPath == it.javaClass.protectionDomain.codeSource.location
-        }
+        } + DefaultWhitelist // Always add the DefaultWhitelist to the whitelist for an app.
     }
 
     private fun findCustomSchemas(scanResult: ScanResult): Set<MappedSchema> {
diff --git a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
index 806b7ac929..e333595f35 100644
--- a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
+++ b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
@@ -55,8 +55,6 @@ class CordappLoaderTest {
         assertThat(actualCordapp.rpcFlows).isEmpty()
         assertThat(actualCordapp.schedulableFlows).isEmpty()
         assertThat(actualCordapp.services).isEmpty()
-        assertThat(actualCordapp.plugins).hasSize(1)
-        assertThat(actualCordapp.plugins.first().javaClass.name).isEqualTo("net.corda.finance.contracts.isolated.IsolatedPlugin")
         assertThat(actualCordapp.jarPath).isEqualTo(isolatedJAR)
     }
 
diff --git a/samples/irs-demo/src/test/resources/META-INF/services/net.corda.webserver.services.WebServerPluginRegistry b/samples/irs-demo/src/test/resources/META-INF/services/net.corda.webserver.services.WebServerPluginRegistry
index 3f23b14e6a..d19d0b4b92 100644
--- a/samples/irs-demo/src/test/resources/META-INF/services/net.corda.webserver.services.WebServerPluginRegistry
+++ b/samples/irs-demo/src/test/resources/META-INF/services/net.corda.webserver.services.WebServerPluginRegistry
@@ -1,3 +1,2 @@
-# Register a ServiceLoader service extending from net.corda.core.node.CordaPluginRegistry
 net.corda.irs.plugin.IRSPlugin
 net.corda.irs.plugin.IRSDemoPlugin
\ No newline at end of file
diff --git a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/plugin/SimmPlugin.kt b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/plugin/SimmPlugin.kt
index 270f15e57e..daf4cdcb07 100644
--- a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/plugin/SimmPlugin.kt
+++ b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/plugin/SimmPlugin.kt
@@ -1,7 +1,7 @@
 package net.corda.vega.plugin
 
 import com.fasterxml.jackson.databind.ObjectMapper
-import net.corda.core.node.CordaPluginRegistry
+import net.corda.core.serialization.SerializationWhitelist
 import net.corda.finance.plugin.registerFinanceJSONMappers
 import net.corda.vega.api.PortfolioApi
 import net.corda.webserver.services.WebServerPluginRegistry
@@ -9,7 +9,7 @@ import java.util.function.Function
 
 /**
  * [SimmService] is the object that makes available the flows and services for the Simm agreement / evaluation flow.
- * It is loaded via discovery - see [CordaPluginRegistry].
+ * It is loaded via discovery - see [SerializationWhitelist].
  * It is also the object that enables a human usable web service for demo purpose
  * It is loaded via discovery see [WebServerPluginRegistry].
  */
diff --git a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/plugin/SimmPluginRegistry.kt b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/plugin/SimmPluginRegistry.kt
index 2cbd235203..626de57761 100644
--- a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/plugin/SimmPluginRegistry.kt
+++ b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/plugin/SimmPluginRegistry.kt
@@ -10,35 +10,30 @@ import com.opengamma.strata.market.curve.CurveName
 import com.opengamma.strata.market.param.CurrencyParameterSensitivities
 import com.opengamma.strata.market.param.CurrencyParameterSensitivity
 import com.opengamma.strata.market.param.TenorDateParameterMetadata
-import net.corda.core.node.CordaPluginRegistry
-import net.corda.core.serialization.SerializationCustomization
+import net.corda.core.serialization.SerializationWhitelist
 import net.corda.vega.analytics.CordaMarketData
 import net.corda.vega.analytics.InitialMarginTriple
 import net.corda.webserver.services.WebServerPluginRegistry
 
 /**
  * [SimmService] is the object that makes available the flows and services for the Simm agreement / evaluation flow.
- * It is loaded via discovery - see [CordaPluginRegistry].
+ * It is loaded via discovery - see [SerializationWhitelist].
  * It is also the object that enables a human usable web service for demo purpose
  * It is loaded via discovery see [WebServerPluginRegistry].
  */
-class SimmPluginRegistry : CordaPluginRegistry() {
-    override fun customizeSerialization(custom: SerializationCustomization): Boolean {
-        custom.apply {
-            // OpenGamma classes.
-            addToWhitelist(MultiCurrencyAmount::class.java,
-                    Ordering.natural<Comparable<Any>>().javaClass,
-                    CurrencyAmount::class.java,
-                    Currency::class.java,
-                    InitialMarginTriple::class.java,
-                    CordaMarketData::class.java,
-                    CurrencyParameterSensitivities::class.java,
-                    CurrencyParameterSensitivity::class.java,
-                    DoubleArray::class.java,
-                    CurveName::class.java,
-                    TenorDateParameterMetadata::class.java,
-                    Tenor::class.java)
-        }
-        return true
-    }
+class SimmPluginRegistry : SerializationWhitelist {
+    override val whitelist = listOf(
+            MultiCurrencyAmount::class.java,
+            Ordering.natural<Comparable<Any>>().javaClass,
+            CurrencyAmount::class.java,
+            Currency::class.java,
+            InitialMarginTriple::class.java,
+            CordaMarketData::class.java,
+            CurrencyParameterSensitivities::class.java,
+            CurrencyParameterSensitivity::class.java,
+            DoubleArray::class.java,
+            CurveName::class.java,
+            TenorDateParameterMetadata::class.java,
+            Tenor::class.java
+    )
 }
diff --git a/samples/simm-valuation-demo/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry b/samples/simm-valuation-demo/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry
deleted file mode 100644
index e2faa7858d..0000000000
--- a/samples/simm-valuation-demo/src/main/resources/META-INF/services/net.corda.core.node.CordaPluginRegistry
+++ /dev/null
@@ -1,2 +0,0 @@
-# Register a ServiceLoader service extending from net.corda.core.node.CordaPluginRegistry
-net.corda.vega.plugin.SimmPluginRegistry
diff --git a/samples/simm-valuation-demo/src/main/resources/META-INF/services/net.corda.core.serialization.SerializationWhitelist b/samples/simm-valuation-demo/src/main/resources/META-INF/services/net.corda.core.serialization.SerializationWhitelist
new file mode 100644
index 0000000000..78b86947ec
--- /dev/null
+++ b/samples/simm-valuation-demo/src/main/resources/META-INF/services/net.corda.core.serialization.SerializationWhitelist
@@ -0,0 +1 @@
+net.corda.vega.plugin.SimmPluginRegistry
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index 9ef99e42e8..446c4dc09d 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -15,26 +15,32 @@ import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.MessageRecipients
 import net.corda.core.messaging.RPCOps
 import net.corda.core.messaging.SingleMessageRecipient
-import net.corda.core.node.CordaPluginRegistry
-import net.corda.core.node.services.*
+import net.corda.core.node.services.IdentityService
+import net.corda.core.node.services.KeyManagementService
+import net.corda.core.node.services.NetworkMapCache
+import net.corda.core.node.services.NotaryService
+import net.corda.core.serialization.SerializationWhitelist
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.loggerFor
 import net.corda.finance.utils.WorldMapLocation
 import net.corda.node.internal.AbstractNode
 import net.corda.node.internal.StartedNode
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.identity.PersistentIdentityService
 import net.corda.node.services.keys.E2ETestKeyManagementService
 import net.corda.node.services.messaging.MessagingService
 import net.corda.node.services.network.InMemoryNetworkMapService
 import net.corda.node.services.network.NetworkMapService
-import net.corda.node.services.transactions.*
+import net.corda.node.services.transactions.BFTNonValidatingNotaryService
+import net.corda.node.services.transactions.BFTSMaRt
+import net.corda.node.services.transactions.InMemoryTransactionVerifierService
+import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.node.utilities.AffinityExecutor
 import net.corda.node.utilities.AffinityExecutor.ServiceAffinityExecutor
 import net.corda.node.utilities.CertificateAndKeyPair
+import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.nodeapi.internal.ServiceType
 import net.corda.testing.*
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
 import org.apache.activemq.artemis.utils.ReusableLatch
@@ -231,11 +237,11 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
 
         override fun myAddresses() = emptyList<NetworkHostAndPort>()
 
-        // Allow unit tests to modify the plugin list before the node start,
-        // so they don't have to ServiceLoad test plugins into all unit tests.
-        val testPluginRegistries by lazy { super.pluginRegistries.toMutableList() }
-        override val pluginRegistries: List<CordaPluginRegistry>
-            get() = testPluginRegistries
+        // Allow unit tests to modify the serialization whitelist list before the node start,
+        // so they don't have to ServiceLoad test whitelists into all unit tests.
+        val testSerializationWhitelists by lazy { super.serializationWhitelists.toMutableList() }
+        override val serializationWhitelists: List<SerializationWhitelist>
+            get() = testSerializationWhitelists
 
         // This does not indirect through the NodeInfo object so it can be called before the node is started.
         // It is used from the network visualiser tool.

From 831df4bc3d6e3e7a956ad6990dbca01634a29ed5 Mon Sep 17 00:00:00 2001
From: Mike Hearn <mike@r3.com>
Date: Mon, 2 Oct 2017 11:42:18 +0100
Subject: [PATCH 062/185] Minor: print a deprecation warning when the web
 server starts.

---
 webserver/src/main/kotlin/net/corda/webserver/WebServer.kt | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/webserver/src/main/kotlin/net/corda/webserver/WebServer.kt b/webserver/src/main/kotlin/net/corda/webserver/WebServer.kt
index 25388e96c1..44dc37ad3a 100644
--- a/webserver/src/main/kotlin/net/corda/webserver/WebServer.kt
+++ b/webserver/src/main/kotlin/net/corda/webserver/WebServer.kt
@@ -36,6 +36,9 @@ fun main(args: Array<String>) {
 
     System.setProperty("log-path", (cmdlineOptions.baseDirectory / "logs/web").toString())
     val log = LoggerFactory.getLogger("Main")
+    println("This Corda-specific web server is deprecated and will be removed in future.")
+    println("Please switch to a regular web framework like Spring, J2EE or Play Framework.")
+    println()
     println("Logs can be found in ${System.getProperty("log-path")}")
 
     val conf = try {

From efc85f8555bc646012e6dea740fdc1b10788e708 Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Mon, 2 Oct 2017 16:29:06 +0100
Subject: [PATCH 063/185] Added current API to CI directory (#1772)

---
 .ci/api-current.txt | 3276 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 3276 insertions(+)
 create mode 100644 .ci/api-current.txt

diff --git a/.ci/api-current.txt b/.ci/api-current.txt
new file mode 100644
index 0000000000..f90125cf32
--- /dev/null
+++ b/.ci/api-current.txt
@@ -0,0 +1,3276 @@
+public class net.corda.core.CordaException extends java.lang.Exception implements net.corda.core.CordaThrowable
+  public <init>()
+  public <init>(String)
+  public <init>(String, String, Throwable)
+  public <init>(String, Throwable)
+  public void addSuppressed(Throwable[])
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public Throwable getCause()
+  @org.jetbrains.annotations.Nullable public String getMessage()
+  @org.jetbrains.annotations.Nullable public String getOriginalExceptionClassName()
+  @org.jetbrains.annotations.Nullable public String getOriginalMessage()
+  public int hashCode()
+  public void setCause(Throwable)
+  public void setMessage(String)
+  public void setOriginalExceptionClassName(String)
+##
+public class net.corda.core.CordaRuntimeException extends java.lang.RuntimeException implements net.corda.core.CordaThrowable
+  public <init>(String)
+  public <init>(String, String, Throwable)
+  public <init>(String, Throwable)
+  public void addSuppressed(Throwable[])
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public Throwable getCause()
+  @org.jetbrains.annotations.Nullable public String getMessage()
+  @org.jetbrains.annotations.Nullable public String getOriginalExceptionClassName()
+  @org.jetbrains.annotations.Nullable public String getOriginalMessage()
+  public int hashCode()
+  public void setCause(Throwable)
+  public void setMessage(String)
+  public void setOriginalExceptionClassName(String)
+##
+public interface net.corda.core.CordaThrowable
+  public abstract void addSuppressed(Throwable[])
+  @org.jetbrains.annotations.Nullable public abstract String getOriginalExceptionClassName()
+  @org.jetbrains.annotations.Nullable public abstract String getOriginalMessage()
+  public abstract void setCause(Throwable)
+  public abstract void setMessage(String)
+  public abstract void setOriginalExceptionClassName(String)
+##
+public final class net.corda.core.Utils extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.concurrent.CordaFuture toFuture(rx.Observable)
+  @org.jetbrains.annotations.NotNull public static final rx.Observable toObservable(net.corda.core.concurrent.CordaFuture)
+##
+public final class net.corda.core.concurrent.ConcurrencyUtils extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.concurrent.CordaFuture firstOf(net.corda.core.concurrent.CordaFuture[], kotlin.jvm.functions.Function1)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.concurrent.CordaFuture firstOf(net.corda.core.concurrent.CordaFuture[], org.slf4j.Logger, kotlin.jvm.functions.Function1)
+  public static final Object match(concurrent.Future, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1)
+  @org.jetbrains.annotations.NotNull public static final String shortCircuitedTaskFailedMessage = "Short-circuited task failed:"
+##
+public interface net.corda.core.concurrent.CordaFuture extends java.util.concurrent.Future
+  public abstract void then(kotlin.jvm.functions.Function1)
+  @org.jetbrains.annotations.NotNull public abstract concurrent.CompletableFuture toCompletableFuture()
+##
+public final class net.corda.core.contracts.AlwaysAcceptAttachmentConstraint extends java.lang.Object implements net.corda.core.contracts.AttachmentConstraint
+  public boolean isSatisfiedBy(net.corda.core.contracts.Attachment)
+  public static final net.corda.core.contracts.AlwaysAcceptAttachmentConstraint INSTANCE
+##
+public final class net.corda.core.contracts.Amount extends java.lang.Object implements java.lang.Comparable
+  public <init>(long, Object)
+  public <init>(long, java.math.BigDecimal, Object)
+  public int compareTo(net.corda.core.contracts.Amount)
+  public final long component1()
+  @org.jetbrains.annotations.NotNull public final java.math.BigDecimal component2()
+  @org.jetbrains.annotations.NotNull public final Object component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount copy(long, java.math.BigDecimal, Object)
+  public boolean equals(Object)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object, java.math.RoundingMode)
+  @org.jetbrains.annotations.NotNull public final java.math.BigDecimal getDisplayTokenSize()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.math.BigDecimal getDisplayTokenSize(Object)
+  public final long getQuantity()
+  @org.jetbrains.annotations.NotNull public final Object getToken()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount minus(net.corda.core.contracts.Amount)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.Amount parseCurrency(String)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount plus(net.corda.core.contracts.Amount)
+  @org.jetbrains.annotations.NotNull public final List splitEvenly(int)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.Nullable public static final net.corda.core.contracts.Amount sumOrNull(Iterable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.Amount sumOrThrow(Iterable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.Amount sumOrZero(Iterable, Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount times(int)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount times(long)
+  @org.jetbrains.annotations.NotNull public final java.math.BigDecimal toDecimal()
+  @org.jetbrains.annotations.NotNull public String toString()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.Amount zero(Object)
+  public static final net.corda.core.contracts.Amount$Companion Companion
+##
+public static final class net.corda.core.contracts.Amount$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object, java.math.RoundingMode)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final java.math.BigDecimal getDisplayTokenSize(Object)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount parseCurrency(String)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.Nullable public final net.corda.core.contracts.Amount sumOrNull(Iterable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount sumOrThrow(Iterable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount sumOrZero(Iterable, Object)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount zero(Object)
+##
+public final class net.corda.core.contracts.AmountTransfer extends java.lang.Object
+  public <init>(long, Object, Object, Object)
+  @org.jetbrains.annotations.NotNull public final List apply(List, Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AmountTransfer copy(long, Object, Object, Object)
+  public boolean equals(Object)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object, java.math.RoundingMode)
+  @org.jetbrains.annotations.NotNull public final Object getDestination()
+  public final long getQuantityDelta()
+  @org.jetbrains.annotations.NotNull public final Object getSource()
+  @org.jetbrains.annotations.NotNull public final Object getToken()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public final List novate(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AmountTransfer plus(net.corda.core.contracts.AmountTransfer)
+  @org.jetbrains.annotations.NotNull public final java.math.BigDecimal toDecimal()
+  @org.jetbrains.annotations.NotNull public String toString()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.AmountTransfer zero(Object, Object, Object)
+  public static final net.corda.core.contracts.AmountTransfer$Companion Companion
+##
+public static final class net.corda.core.contracts.AmountTransfer$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object, java.math.RoundingMode)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AmountTransfer zero(Object, Object, Object)
+##
+public interface net.corda.core.contracts.Attachment extends net.corda.core.contracts.NamedByHash
+  public abstract void extractFile(String, java.io.OutputStream)
+  @org.jetbrains.annotations.NotNull public abstract List getSigners()
+  @org.jetbrains.annotations.NotNull public abstract java.io.InputStream open()
+  @org.jetbrains.annotations.NotNull public abstract jar.JarInputStream openAsJAR()
+##
+public interface net.corda.core.contracts.AttachmentConstraint
+  public abstract boolean isSatisfiedBy(net.corda.core.contracts.Attachment)
+##
+public final class net.corda.core.contracts.AttachmentResolutionException extends net.corda.core.flows.FlowException
+  public <init>(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getHash()
+##
+public final class net.corda.core.contracts.AutomaticHashConstraint extends java.lang.Object implements net.corda.core.contracts.AttachmentConstraint
+  public boolean isSatisfiedBy(net.corda.core.contracts.Attachment)
+  public static final net.corda.core.contracts.AutomaticHashConstraint INSTANCE
+##
+public final class net.corda.core.contracts.Command extends java.lang.Object
+  public <init>(net.corda.core.contracts.CommandData, java.security.PublicKey)
+  public <init>(net.corda.core.contracts.CommandData, List)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.CommandData component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Command copy(net.corda.core.contracts.CommandData, List)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final List getSigners()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.CommandData getValue()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public final class net.corda.core.contracts.CommandAndState extends java.lang.Object
+  public <init>(net.corda.core.contracts.CommandData, net.corda.core.contracts.OwnableState)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.CommandData component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.OwnableState component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.CommandAndState copy(net.corda.core.contracts.CommandData, net.corda.core.contracts.OwnableState)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.CommandData getCommand()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.OwnableState getOwnableState()
+  public int hashCode()
+  public String toString()
+##
+public interface net.corda.core.contracts.CommandData
+##
+public final class net.corda.core.contracts.CommandWithParties extends java.lang.Object
+  public <init>(List, List, net.corda.core.contracts.CommandData)
+  @org.jetbrains.annotations.NotNull public final List component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.CommandData component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.CommandWithParties copy(List, List, net.corda.core.contracts.CommandData)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final List getSigners()
+  @org.jetbrains.annotations.NotNull public final List getSigningParties()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.CommandData getValue()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.contracts.ComponentGroupEnum extends java.lang.Enum
+  protected <init>(String, int)
+  public static net.corda.core.contracts.ComponentGroupEnum valueOf(String)
+  public static net.corda.core.contracts.ComponentGroupEnum[] values()
+##
+public interface net.corda.core.contracts.Contract
+  public abstract void verify(net.corda.core.transactions.LedgerTransaction)
+##
+public final class net.corda.core.contracts.ContractAttachment extends java.lang.Object implements net.corda.core.contracts.Attachment
+  public <init>(net.corda.core.contracts.Attachment, String)
+  public void extractFile(String, java.io.OutputStream)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Attachment getAttachment()
+  @org.jetbrains.annotations.NotNull public final String getContract()
+  @org.jetbrains.annotations.NotNull public net.corda.core.crypto.SecureHash getId()
+  @org.jetbrains.annotations.NotNull public List getSigners()
+  @org.jetbrains.annotations.NotNull public java.io.InputStream open()
+  @org.jetbrains.annotations.NotNull public jar.JarInputStream openAsJAR()
+##
+public interface net.corda.core.contracts.ContractState
+  @org.jetbrains.annotations.NotNull public abstract List getParticipants()
+##
+public final class net.corda.core.contracts.ContractsDSL extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.CommandWithParties requireSingleCommand(Collection, Class)
+  public static final Object requireThat(kotlin.jvm.functions.Function1)
+##
+public interface net.corda.core.contracts.FungibleAsset extends net.corda.core.contracts.OwnableState
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.Amount getAmount()
+  @org.jetbrains.annotations.NotNull public abstract Collection getExitKeys()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.FungibleAsset withNewOwnerAndAmount(net.corda.core.contracts.Amount, net.corda.core.identity.AbstractParty)
+##
+public final class net.corda.core.contracts.HashAttachmentConstraint extends java.lang.Object implements net.corda.core.contracts.AttachmentConstraint
+  public <init>(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.HashAttachmentConstraint copy(net.corda.core.crypto.SecureHash)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getAttachmentId()
+  public int hashCode()
+  public boolean isSatisfiedBy(net.corda.core.contracts.Attachment)
+  public String toString()
+##
+public final class net.corda.core.contracts.InsufficientBalanceException extends net.corda.core.flows.FlowException
+  public <init>(net.corda.core.contracts.Amount)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount getAmountMissing()
+##
+public final class net.corda.core.contracts.Issued extends java.lang.Object
+  public <init>(net.corda.core.contracts.PartyAndReference, Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.PartyAndReference component1()
+  @org.jetbrains.annotations.NotNull public final Object component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Issued copy(net.corda.core.contracts.PartyAndReference, Object)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.PartyAndReference getIssuer()
+  @org.jetbrains.annotations.NotNull public final Object getProduct()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public @interface net.corda.core.contracts.LegalProseReference
+  public abstract String uri()
+##
+public interface net.corda.core.contracts.LinearState extends net.corda.core.contracts.ContractState
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.UniqueIdentifier getLinearId()
+##
+public interface net.corda.core.contracts.MoveCommand extends net.corda.core.contracts.CommandData
+  @org.jetbrains.annotations.Nullable public abstract Class getContract()
+##
+public interface net.corda.core.contracts.NamedByHash
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.SecureHash getId()
+##
+public interface net.corda.core.contracts.OwnableState extends net.corda.core.contracts.ContractState
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.identity.AbstractParty getOwner()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.CommandAndState withNewOwner(net.corda.core.identity.AbstractParty)
+##
+public final class net.corda.core.contracts.PartyAndReference extends java.lang.Object
+  public <init>(net.corda.core.identity.AbstractParty, net.corda.core.utilities.OpaqueBytes)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.AbstractParty component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.OpaqueBytes component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.PartyAndReference copy(net.corda.core.identity.AbstractParty, net.corda.core.utilities.OpaqueBytes)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.AbstractParty getParty()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.OpaqueBytes getReference()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public final class net.corda.core.contracts.PrivacySalt extends net.corda.core.utilities.OpaqueBytes
+  public <init>()
+  public <init>(byte[])
+##
+public final class net.corda.core.contracts.Requirements extends java.lang.Object
+  public final void using(String, boolean)
+  public static final net.corda.core.contracts.Requirements INSTANCE
+##
+public interface net.corda.core.contracts.SchedulableState extends net.corda.core.contracts.ContractState
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.contracts.ScheduledActivity nextScheduledActivity(net.corda.core.contracts.StateRef, net.corda.core.flows.FlowLogicRefFactory)
+##
+public interface net.corda.core.contracts.Scheduled
+  @org.jetbrains.annotations.NotNull public abstract java.time.Instant getScheduledAt()
+##
+public final class net.corda.core.contracts.ScheduledActivity extends java.lang.Object implements net.corda.core.contracts.Scheduled
+  public <init>(net.corda.core.flows.FlowLogicRef, java.time.Instant)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowLogicRef component1()
+  @org.jetbrains.annotations.NotNull public final java.time.Instant component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ScheduledActivity copy(net.corda.core.flows.FlowLogicRef, java.time.Instant)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowLogicRef getLogicRef()
+  @org.jetbrains.annotations.NotNull public java.time.Instant getScheduledAt()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.contracts.ScheduledStateRef extends java.lang.Object implements net.corda.core.contracts.Scheduled
+  public <init>(net.corda.core.contracts.StateRef, java.time.Instant)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateRef component1()
+  @org.jetbrains.annotations.NotNull public final java.time.Instant component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ScheduledStateRef copy(net.corda.core.contracts.StateRef, java.time.Instant)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateRef getRef()
+  @org.jetbrains.annotations.NotNull public java.time.Instant getScheduledAt()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.contracts.SourceAndAmount extends java.lang.Object
+  public <init>(Object, net.corda.core.contracts.Amount, Object)
+  @org.jetbrains.annotations.NotNull public final Object component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount component2()
+  @org.jetbrains.annotations.Nullable public final Object component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.SourceAndAmount copy(Object, net.corda.core.contracts.Amount, Object)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount getAmount()
+  @org.jetbrains.annotations.Nullable public final Object getRef()
+  @org.jetbrains.annotations.NotNull public final Object getSource()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.contracts.StateAndContract extends java.lang.Object
+  public <init>(net.corda.core.contracts.ContractState, String)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ContractState component1()
+  @org.jetbrains.annotations.NotNull public final String component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateAndContract copy(net.corda.core.contracts.ContractState, String)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final String getContract()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ContractState getState()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.contracts.StateAndRef extends java.lang.Object
+  public <init>(net.corda.core.contracts.TransactionState, net.corda.core.contracts.StateRef)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.TransactionState component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateRef component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateAndRef copy(net.corda.core.contracts.TransactionState, net.corda.core.contracts.StateRef)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateRef getRef()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.TransactionState getState()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.contracts.StateRef extends java.lang.Object
+  public <init>(net.corda.core.crypto.SecureHash, int)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component1()
+  public final int component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateRef copy(net.corda.core.crypto.SecureHash, int)
+  public boolean equals(Object)
+  public final int getIndex()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getTxhash()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public final class net.corda.core.contracts.Structures extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash hash(net.corda.core.contracts.ContractState)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.Amount withoutIssuer(net.corda.core.contracts.Amount)
+##
+public abstract class net.corda.core.contracts.TimeWindow extends java.lang.Object
+  public <init>()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.TimeWindow between(java.time.Instant, java.time.Instant)
+  public abstract boolean contains(java.time.Instant)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.TimeWindow fromOnly(java.time.Instant)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.TimeWindow fromStartAndDuration(java.time.Instant, java.time.Duration)
+  @org.jetbrains.annotations.Nullable public abstract java.time.Instant getFromTime()
+  @org.jetbrains.annotations.Nullable public abstract java.time.Instant getMidpoint()
+  @org.jetbrains.annotations.Nullable public abstract java.time.Instant getUntilTime()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.TimeWindow untilOnly(java.time.Instant)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.TimeWindow withTolerance(java.time.Instant, java.time.Duration)
+  public static final net.corda.core.contracts.TimeWindow$Companion Companion
+##
+public static final class net.corda.core.contracts.TimeWindow$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.TimeWindow between(java.time.Instant, java.time.Instant)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.TimeWindow fromOnly(java.time.Instant)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.TimeWindow fromStartAndDuration(java.time.Instant, java.time.Duration)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.TimeWindow untilOnly(java.time.Instant)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.TimeWindow withTolerance(java.time.Instant, java.time.Duration)
+##
+public interface net.corda.core.contracts.TokenizableAssetInfo
+  @org.jetbrains.annotations.NotNull public abstract java.math.BigDecimal getDisplayTokenSize()
+##
+public final class net.corda.core.contracts.TransactionResolutionException extends net.corda.core.flows.FlowException
+  public <init>(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getHash()
+##
+public final class net.corda.core.contracts.TransactionState extends java.lang.Object
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer, net.corda.core.contracts.AttachmentConstraint)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ContractState component1()
+  @org.jetbrains.annotations.NotNull public final String component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party component3()
+  @org.jetbrains.annotations.Nullable public final Integer component4()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AttachmentConstraint component5()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.TransactionState copy(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer, net.corda.core.contracts.AttachmentConstraint)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AttachmentConstraint getConstraint()
+  @org.jetbrains.annotations.NotNull public final String getContract()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ContractState getData()
+  @org.jetbrains.annotations.Nullable public final Integer getEncumbrance()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party getNotary()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.contracts.TransactionStateKt extends java.lang.Object
+##
+public abstract class net.corda.core.contracts.TransactionVerificationException extends net.corda.core.flows.FlowException
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getTxId()
+##
+public static final class net.corda.core.contracts.TransactionVerificationException$ContractConstraintRejection extends net.corda.core.contracts.TransactionVerificationException
+  public <init>(net.corda.core.crypto.SecureHash, String)
+##
+public static final class net.corda.core.contracts.TransactionVerificationException$ContractCreationError extends net.corda.core.contracts.TransactionVerificationException
+  public <init>(net.corda.core.crypto.SecureHash, String, Throwable)
+##
+public static final class net.corda.core.contracts.TransactionVerificationException$ContractRejection extends net.corda.core.contracts.TransactionVerificationException
+  public <init>(net.corda.core.crypto.SecureHash, net.corda.core.contracts.Contract, Throwable)
+##
+public static final class net.corda.core.contracts.TransactionVerificationException$Direction extends java.lang.Enum
+  protected <init>(String, int)
+  public static net.corda.core.contracts.TransactionVerificationException$Direction valueOf(String)
+  public static net.corda.core.contracts.TransactionVerificationException$Direction[] values()
+##
+public static final class net.corda.core.contracts.TransactionVerificationException$DuplicateInputStates extends net.corda.core.contracts.TransactionVerificationException
+  public <init>(net.corda.core.crypto.SecureHash, net.corda.core.utilities.NonEmptySet)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.NonEmptySet getDuplicates()
+##
+public static final class net.corda.core.contracts.TransactionVerificationException$InvalidNotaryChange extends net.corda.core.contracts.TransactionVerificationException
+  public <init>(net.corda.core.crypto.SecureHash)
+##
+public static final class net.corda.core.contracts.TransactionVerificationException$MissingAttachmentRejection extends net.corda.core.contracts.TransactionVerificationException
+  public <init>(net.corda.core.crypto.SecureHash, String)
+##
+public static final class net.corda.core.contracts.TransactionVerificationException$MoreThanOneNotary extends net.corda.core.contracts.TransactionVerificationException
+  public <init>(net.corda.core.crypto.SecureHash)
+##
+public static final class net.corda.core.contracts.TransactionVerificationException$NotaryChangeInWrongTransactionType extends net.corda.core.contracts.TransactionVerificationException
+  public <init>(net.corda.core.crypto.SecureHash, net.corda.core.identity.Party, net.corda.core.identity.Party)
+##
+public static final class net.corda.core.contracts.TransactionVerificationException$SignersMissing extends net.corda.core.contracts.TransactionVerificationException
+  public <init>(net.corda.core.crypto.SecureHash, List)
+##
+public static final class net.corda.core.contracts.TransactionVerificationException$TransactionMissingEncumbranceException extends net.corda.core.contracts.TransactionVerificationException
+  public <init>(net.corda.core.crypto.SecureHash, int, net.corda.core.contracts.TransactionVerificationException$Direction)
+##
+public abstract class net.corda.core.contracts.TypeOnlyCommandData extends java.lang.Object implements net.corda.core.contracts.CommandData
+  public <init>()
+  public boolean equals(Object)
+  public int hashCode()
+##
+public final class net.corda.core.contracts.UniqueIdentifier extends java.lang.Object implements java.lang.Comparable
+  public <init>()
+  public <init>(String, UUID)
+  public int compareTo(net.corda.core.contracts.UniqueIdentifier)
+  @org.jetbrains.annotations.Nullable public final String component1()
+  @org.jetbrains.annotations.NotNull public final UUID component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.UniqueIdentifier copy(String, UUID)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public final String getExternalId()
+  @org.jetbrains.annotations.NotNull public final UUID getId()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+  public static final net.corda.core.contracts.UniqueIdentifier$Companion Companion
+##
+public static final class net.corda.core.contracts.UniqueIdentifier$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.UniqueIdentifier fromString(String)
+##
+public interface net.corda.core.contracts.UpgradedContract extends net.corda.core.contracts.Contract
+  @org.jetbrains.annotations.NotNull public abstract String getLegacyContract()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.ContractState upgrade(net.corda.core.contracts.ContractState)
+##
+public interface net.corda.core.cordapp.Cordapp
+  @org.jetbrains.annotations.NotNull public abstract List getContractClassNames()
+  @org.jetbrains.annotations.NotNull public abstract List getCordappClasses()
+  @org.jetbrains.annotations.NotNull public abstract Set getCustomSchemas()
+  @org.jetbrains.annotations.NotNull public abstract List getInitiatedFlows()
+  @org.jetbrains.annotations.NotNull public abstract java.net.URL getJarPath()
+  @org.jetbrains.annotations.NotNull public abstract String getName()
+  @org.jetbrains.annotations.NotNull public abstract List getPlugins()
+  @org.jetbrains.annotations.NotNull public abstract List getRpcFlows()
+  @org.jetbrains.annotations.NotNull public abstract List getSchedulableFlows()
+  @org.jetbrains.annotations.NotNull public abstract List getServices()
+##
+public final class net.corda.core.cordapp.CordappContext extends java.lang.Object
+  public <init>(net.corda.core.cordapp.Cordapp, net.corda.core.crypto.SecureHash, ClassLoader)
+  @org.jetbrains.annotations.Nullable public final net.corda.core.crypto.SecureHash getAttachmentId()
+  @org.jetbrains.annotations.NotNull public final ClassLoader getClassLoader()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.cordapp.Cordapp getCordapp()
+##
+public interface net.corda.core.cordapp.CordappProvider
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.cordapp.CordappContext getAppContext()
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.crypto.SecureHash getContractAttachmentID(String)
+##
+public class net.corda.core.crypto.AddressFormatException extends java.lang.IllegalArgumentException
+  public <init>()
+  public <init>(String)
+##
+public class net.corda.core.crypto.Base58 extends java.lang.Object
+  public <init>()
+  public static byte[] decode(String)
+  public static byte[] decodeChecked(String)
+  public static java.math.BigInteger decodeToBigInteger(String)
+  public static String encode(byte[])
+##
+public final class net.corda.core.crypto.CompositeKey extends java.lang.Object implements java.security.PublicKey
+  public final void checkValidity()
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public String getAlgorithm()
+  @org.jetbrains.annotations.NotNull public final List getChildren()
+  @org.jetbrains.annotations.NotNull public byte[] getEncoded()
+  @org.jetbrains.annotations.NotNull public String getFormat()
+  @org.jetbrains.annotations.NotNull public final Set getLeafKeys()
+  public final int getThreshold()
+  public int hashCode()
+  public final boolean isFulfilledBy(Iterable)
+  public final boolean isFulfilledBy(java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public String toString()
+  public static final net.corda.core.crypto.CompositeKey$Companion Companion
+  @org.jetbrains.annotations.NotNull public static final String KEY_ALGORITHM = "COMPOSITE"
+##
+public static final class net.corda.core.crypto.CompositeKey$Builder extends java.lang.Object
+  public <init>()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.CompositeKey$Builder addKey(java.security.PublicKey, int)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.CompositeKey$Builder addKeys(List)
+  @org.jetbrains.annotations.NotNull public final java.security.PublicKey build(Integer)
+##
+public static final class net.corda.core.crypto.CompositeKey$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final java.security.PublicKey getInstance(org.bouncycastle.asn1.ASN1Primitive)
+  @org.jetbrains.annotations.NotNull public final java.security.PublicKey getInstance(byte[])
+##
+public static final class net.corda.core.crypto.CompositeKey$NodeAndWeight extends org.bouncycastle.asn1.ASN1Object implements java.lang.Comparable
+  public <init>(java.security.PublicKey, int)
+  public int compareTo(net.corda.core.crypto.CompositeKey$NodeAndWeight)
+  @org.jetbrains.annotations.NotNull public final java.security.PublicKey component1()
+  public final int component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.CompositeKey$NodeAndWeight copy(java.security.PublicKey, int)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final java.security.PublicKey getNode()
+  public final int getWeight()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public org.bouncycastle.asn1.ASN1Primitive toASN1Primitive()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public final class net.corda.core.crypto.CompositeKeyFactory extends java.security.KeyFactorySpi
+  public <init>()
+  @org.jetbrains.annotations.NotNull protected java.security.PrivateKey engineGeneratePrivate(java.security.spec.KeySpec)
+  @org.jetbrains.annotations.Nullable protected java.security.PublicKey engineGeneratePublic(java.security.spec.KeySpec)
+  @org.jetbrains.annotations.NotNull protected java.security.spec.KeySpec engineGetKeySpec(java.security.Key, Class)
+  @org.jetbrains.annotations.NotNull protected java.security.Key engineTranslateKey(java.security.Key)
+##
+public final class net.corda.core.crypto.CompositeSignature extends java.security.Signature
+  public <init>()
+  @kotlin.Deprecated @org.jetbrains.annotations.NotNull protected Object engineGetParameter(String)
+  protected void engineInitSign(java.security.PrivateKey)
+  protected void engineInitVerify(java.security.PublicKey)
+  @kotlin.Deprecated protected void engineSetParameter(String, Object)
+  protected void engineSetParameter(java.security.spec.AlgorithmParameterSpec)
+  @org.jetbrains.annotations.NotNull protected byte[] engineSign()
+  protected void engineUpdate(byte)
+  protected void engineUpdate(byte[], int, int)
+  protected boolean engineVerify(byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.Provider$Service getService(java.security.Provider)
+  public static final net.corda.core.crypto.CompositeSignature$Companion Companion
+  @org.jetbrains.annotations.NotNull public static final String SIGNATURE_ALGORITHM = "COMPOSITESIG"
+##
+public static final class net.corda.core.crypto.CompositeSignature$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final java.security.Provider$Service getService(java.security.Provider)
+##
+public static final class net.corda.core.crypto.CompositeSignature$State extends java.lang.Object
+  public <init>(java.io.ByteArrayOutputStream, net.corda.core.crypto.CompositeKey)
+  @org.jetbrains.annotations.NotNull public final java.io.ByteArrayOutputStream component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.CompositeKey component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.CompositeSignature$State copy(java.io.ByteArrayOutputStream, net.corda.core.crypto.CompositeKey)
+  public final boolean engineVerify(byte[])
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final java.io.ByteArrayOutputStream getBuffer()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.CompositeKey getVerifyKey()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.crypto.CordaObjectIdentifier extends java.lang.Object
+  @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final org.bouncycastle.asn1.ASN1ObjectIdentifier COMPOSITE_KEY
+  @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final org.bouncycastle.asn1.ASN1ObjectIdentifier COMPOSITE_SIGNATURE
+  public static final net.corda.core.crypto.CordaObjectIdentifier INSTANCE
+##
+public final class net.corda.core.crypto.CordaSecurityProvider extends java.security.Provider
+  public <init>()
+  public static final net.corda.core.crypto.CordaSecurityProvider$Companion Companion
+  @org.jetbrains.annotations.NotNull public static final String PROVIDER_NAME = "Corda"
+##
+public static final class net.corda.core.crypto.CordaSecurityProvider$Companion extends java.lang.Object
+##
+public final class net.corda.core.crypto.Crypto extends java.lang.Object
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.PrivateKey decodePrivateKey(String, byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.PrivateKey decodePrivateKey(net.corda.core.crypto.SignatureScheme, byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.PrivateKey decodePrivateKey(byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.PublicKey decodePublicKey(String, byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.PublicKey decodePublicKey(net.corda.core.crypto.SignatureScheme, byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.PublicKey decodePublicKey(byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.KeyPair deriveKeyPair(java.security.PrivateKey, byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.KeyPair deriveKeyPair(net.corda.core.crypto.SignatureScheme, java.security.PrivateKey, byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.KeyPair deriveKeyPairFromEntropy(java.math.BigInteger)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.KeyPair deriveKeyPairFromEntropy(net.corda.core.crypto.SignatureScheme, java.math.BigInteger)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final byte[] doSign(String, java.security.PrivateKey, byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.TransactionSignature doSign(java.security.KeyPair, net.corda.core.crypto.SignableData)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final byte[] doSign(java.security.PrivateKey, byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final byte[] doSign(net.corda.core.crypto.SignatureScheme, java.security.PrivateKey, byte[])
+  @kotlin.jvm.JvmStatic public static final boolean doVerify(String, java.security.PublicKey, byte[], byte[])
+  @kotlin.jvm.JvmStatic public static final boolean doVerify(java.security.PublicKey, byte[], byte[])
+  @kotlin.jvm.JvmStatic public static final boolean doVerify(net.corda.core.crypto.SecureHash, net.corda.core.crypto.TransactionSignature)
+  @kotlin.jvm.JvmStatic public static final boolean doVerify(net.corda.core.crypto.SignatureScheme, java.security.PublicKey, byte[], byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.Provider findProvider(String)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme findSignatureScheme(String)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme findSignatureScheme(java.security.PrivateKey)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme findSignatureScheme(java.security.PublicKey)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme findSignatureScheme(org.bouncycastle.asn1.x509.AlgorithmIdentifier)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final java.security.KeyPair generateKeyPair()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.KeyPair generateKeyPair(String)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final java.security.KeyPair generateKeyPair(net.corda.core.crypto.SignatureScheme)
+  @kotlin.jvm.JvmStatic public static final boolean isSupportedSignatureScheme(net.corda.core.crypto.SignatureScheme)
+  @kotlin.jvm.JvmStatic public static final boolean isValid(java.security.PublicKey, byte[], byte[])
+  @kotlin.jvm.JvmStatic public static final boolean isValid(net.corda.core.crypto.SecureHash, net.corda.core.crypto.TransactionSignature)
+  @kotlin.jvm.JvmStatic public static final boolean isValid(net.corda.core.crypto.SignatureScheme, java.security.PublicKey, byte[], byte[])
+  @kotlin.jvm.JvmStatic public static final boolean publicKeyOnCurve(net.corda.core.crypto.SignatureScheme, java.security.PublicKey)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final List supportedSignatureSchemes()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.PrivateKey toSupportedPrivateKey(java.security.PrivateKey)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.PublicKey toSupportedPublicKey(java.security.PublicKey)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.PublicKey toSupportedPublicKey(org.bouncycastle.asn1.x509.SubjectPublicKeyInfo)
+  @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme COMPOSITE_KEY
+  @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme DEFAULT_SIGNATURE_SCHEME
+  @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme ECDSA_SECP256K1_SHA256
+  @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme ECDSA_SECP256R1_SHA256
+  @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme EDDSA_ED25519_SHA512
+  public static final net.corda.core.crypto.Crypto INSTANCE
+  @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme RSA_SHA256
+  @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final org.bouncycastle.asn1.DLSequence SHA512_256
+  @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme SPHINCS256_SHA256
+##
+public final class net.corda.core.crypto.CryptoUtils extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public static final Set byKeys(Iterable)
+  @org.jetbrains.annotations.NotNull public static final java.security.PrivateKey component1(java.security.KeyPair)
+  @org.jetbrains.annotations.NotNull public static final java.security.PublicKey component2(java.security.KeyPair)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash componentHash(net.corda.core.crypto.SecureHash, net.corda.core.utilities.OpaqueBytes)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash componentHash(net.corda.core.utilities.OpaqueBytes, net.corda.core.contracts.PrivacySalt, int, int)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash$SHA256 computeNonce(net.corda.core.contracts.PrivacySalt, int, int)
+  public static final boolean containsAny(java.security.PublicKey, Iterable)
+  @org.jetbrains.annotations.NotNull public static final java.security.KeyPair entropyToKeyPair(java.math.BigInteger)
+  @org.jetbrains.annotations.NotNull public static final java.security.KeyPair generateKeyPair()
+  @org.jetbrains.annotations.NotNull public static final Set getKeys(java.security.PublicKey)
+  public static final boolean isFulfilledBy(java.security.PublicKey, Iterable)
+  public static final boolean isFulfilledBy(java.security.PublicKey, java.security.PublicKey)
+  public static final boolean isValid(java.security.PublicKey, byte[], net.corda.core.crypto.DigitalSignature)
+  @org.jetbrains.annotations.NotNull public static final java.security.SecureRandom newSecureRandom()
+  public static final long random63BitValue()
+  @org.jetbrains.annotations.NotNull public static final byte[] secureRandomBytes(int)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash serializedHash(Object)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.TransactionSignature sign(java.security.KeyPair, net.corda.core.crypto.SignableData)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.DigitalSignature$WithKey sign(java.security.KeyPair, net.corda.core.utilities.OpaqueBytes)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.DigitalSignature$WithKey sign(java.security.KeyPair, byte[])
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.DigitalSignature sign(java.security.PrivateKey, byte[])
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.DigitalSignature$WithKey sign(java.security.PrivateKey, byte[], java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public static final String toStringShort(java.security.PublicKey)
+  public static final boolean verify(java.security.KeyPair, byte[], byte[])
+  public static final boolean verify(java.security.PublicKey, byte[], net.corda.core.crypto.DigitalSignature)
+  public static final boolean verify(java.security.PublicKey, byte[], byte[])
+##
+public class net.corda.core.crypto.DigitalSignature extends net.corda.core.utilities.OpaqueBytes
+  public <init>(byte[])
+##
+public static class net.corda.core.crypto.DigitalSignature$WithKey extends net.corda.core.crypto.DigitalSignature
+  public <init>(java.security.PublicKey, byte[])
+  @org.jetbrains.annotations.NotNull public final java.security.PublicKey getBy()
+  public final boolean isValid(byte[])
+  public final boolean verify(net.corda.core.utilities.OpaqueBytes)
+  public final boolean verify(byte[])
+##
+public abstract class net.corda.core.crypto.MerkleTree extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.SecureHash getHash()
+  public static final net.corda.core.crypto.MerkleTree$Companion Companion
+##
+public static final class net.corda.core.crypto.MerkleTree$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.MerkleTree getMerkleTree(List)
+##
+public static final class net.corda.core.crypto.MerkleTree$Leaf extends net.corda.core.crypto.MerkleTree
+  public <init>(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.MerkleTree$Leaf copy(net.corda.core.crypto.SecureHash)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.crypto.SecureHash getHash()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.crypto.MerkleTree$Node extends net.corda.core.crypto.MerkleTree
+  public <init>(net.corda.core.crypto.SecureHash, net.corda.core.crypto.MerkleTree, net.corda.core.crypto.MerkleTree)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.MerkleTree component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.MerkleTree component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.MerkleTree$Node copy(net.corda.core.crypto.SecureHash, net.corda.core.crypto.MerkleTree, net.corda.core.crypto.MerkleTree)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.crypto.SecureHash getHash()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.MerkleTree getLeft()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.MerkleTree getRight()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.crypto.MerkleTreeException extends net.corda.core.CordaException
+  public <init>(String)
+  @org.jetbrains.annotations.NotNull public final String getReason()
+##
+public final class net.corda.core.crypto.NullKeys extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.AnonymousParty getNULL_PARTY()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.TransactionSignature getNULL_SIGNATURE()
+  public static final net.corda.core.crypto.NullKeys INSTANCE
+##
+public static final class net.corda.core.crypto.NullKeys$NullPublicKey extends java.lang.Object implements java.security.PublicKey, java.lang.Comparable
+  public int compareTo(java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public String getAlgorithm()
+  @org.jetbrains.annotations.NotNull public byte[] getEncoded()
+  @org.jetbrains.annotations.NotNull public String getFormat()
+  @org.jetbrains.annotations.NotNull public String toString()
+  public static final net.corda.core.crypto.NullKeys$NullPublicKey INSTANCE
+##
+public final class net.corda.core.crypto.PartialMerkleTree extends java.lang.Object
+  public <init>(net.corda.core.crypto.PartialMerkleTree$PartialTree)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.PartialMerkleTree$PartialTree getRoot()
+  public final boolean verify(net.corda.core.crypto.SecureHash, List)
+  public static final net.corda.core.crypto.PartialMerkleTree$Companion Companion
+##
+public static final class net.corda.core.crypto.PartialMerkleTree$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.PartialMerkleTree build(net.corda.core.crypto.MerkleTree, List)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash rootAndUsedHashes(net.corda.core.crypto.PartialMerkleTree$PartialTree, List)
+##
+public abstract static class net.corda.core.crypto.PartialMerkleTree$PartialTree extends java.lang.Object
+##
+public static final class net.corda.core.crypto.PartialMerkleTree$PartialTree$IncludedLeaf extends net.corda.core.crypto.PartialMerkleTree$PartialTree
+  public <init>(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.PartialMerkleTree$PartialTree$IncludedLeaf copy(net.corda.core.crypto.SecureHash)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getHash()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.crypto.PartialMerkleTree$PartialTree$Leaf extends net.corda.core.crypto.PartialMerkleTree$PartialTree
+  public <init>(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.PartialMerkleTree$PartialTree$Leaf copy(net.corda.core.crypto.SecureHash)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getHash()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.crypto.PartialMerkleTree$PartialTree$Node extends net.corda.core.crypto.PartialMerkleTree$PartialTree
+  public <init>(net.corda.core.crypto.PartialMerkleTree$PartialTree, net.corda.core.crypto.PartialMerkleTree$PartialTree)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.PartialMerkleTree$PartialTree component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.PartialMerkleTree$PartialTree component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.PartialMerkleTree$PartialTree$Node copy(net.corda.core.crypto.PartialMerkleTree$PartialTree, net.corda.core.crypto.PartialMerkleTree$PartialTree)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.PartialMerkleTree$PartialTree getLeft()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.PartialMerkleTree$PartialTree getRight()
+  public int hashCode()
+  public String toString()
+##
+public abstract class net.corda.core.crypto.SecureHash extends net.corda.core.utilities.OpaqueBytes
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash$SHA256 hashConcat(net.corda.core.crypto.SecureHash)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash$SHA256 parse(String)
+  @org.jetbrains.annotations.NotNull public final String prefixChars(int)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash$SHA256 randomSHA256()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash$SHA256 sha256(String)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash$SHA256 sha256(byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash$SHA256 sha256Twice(byte[])
+  @org.jetbrains.annotations.NotNull public String toString()
+  public static final net.corda.core.crypto.SecureHash$Companion Companion
+##
+public static final class net.corda.core.crypto.SecureHash$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash$SHA256 getAllOnesHash()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash$SHA256 getZeroHash()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash$SHA256 parse(String)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash$SHA256 randomSHA256()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash$SHA256 sha256(String)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash$SHA256 sha256(byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash$SHA256 sha256Twice(byte[])
+##
+public static final class net.corda.core.crypto.SecureHash$SHA256 extends net.corda.core.crypto.SecureHash
+  public <init>(byte[])
+##
+public final class net.corda.core.crypto.SecureHashKt extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash$SHA256 sha256(net.corda.core.utilities.OpaqueBytes)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SecureHash$SHA256 sha256(byte[])
+##
+public final class net.corda.core.crypto.SignableData extends java.lang.Object
+  public <init>(net.corda.core.crypto.SecureHash, net.corda.core.crypto.SignatureMetadata)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SignatureMetadata component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SignableData copy(net.corda.core.crypto.SecureHash, net.corda.core.crypto.SignatureMetadata)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SignatureMetadata getSignatureMetadata()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getTxId()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.crypto.SignatureMetadata extends java.lang.Object
+  public <init>(int, int)
+  public final int component1()
+  public final int component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SignatureMetadata copy(int, int)
+  public boolean equals(Object)
+  public final int getPlatformVersion()
+  public final int getSchemeNumberID()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.crypto.SignatureScheme extends java.lang.Object
+  public <init>(int, String, org.bouncycastle.asn1.x509.AlgorithmIdentifier, List, String, String, String, java.security.spec.AlgorithmParameterSpec, Integer, String)
+  public final int component1()
+  @org.jetbrains.annotations.NotNull public final String component10()
+  @org.jetbrains.annotations.NotNull public final String component2()
+  @org.jetbrains.annotations.NotNull public final org.bouncycastle.asn1.x509.AlgorithmIdentifier component3()
+  @org.jetbrains.annotations.NotNull public final List component4()
+  @org.jetbrains.annotations.NotNull public final String component5()
+  @org.jetbrains.annotations.NotNull public final String component6()
+  @org.jetbrains.annotations.NotNull public final String component7()
+  @org.jetbrains.annotations.Nullable public final java.security.spec.AlgorithmParameterSpec component8()
+  @org.jetbrains.annotations.Nullable public final Integer component9()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SignatureScheme copy(int, String, org.bouncycastle.asn1.x509.AlgorithmIdentifier, List, String, String, String, java.security.spec.AlgorithmParameterSpec, Integer, String)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public final java.security.spec.AlgorithmParameterSpec getAlgSpec()
+  @org.jetbrains.annotations.NotNull public final String getAlgorithmName()
+  @org.jetbrains.annotations.NotNull public final List getAlternativeOIDs()
+  @org.jetbrains.annotations.NotNull public final String getDesc()
+  @org.jetbrains.annotations.Nullable public final Integer getKeySize()
+  @org.jetbrains.annotations.NotNull public final String getProviderName()
+  @org.jetbrains.annotations.NotNull public final String getSchemeCodeName()
+  public final int getSchemeNumberID()
+  @org.jetbrains.annotations.NotNull public final String getSignatureName()
+  @org.jetbrains.annotations.NotNull public final org.bouncycastle.asn1.x509.AlgorithmIdentifier getSignatureOID()
+  public int hashCode()
+  public String toString()
+##
+public class net.corda.core.crypto.SignedData extends java.lang.Object
+  public <init>(net.corda.core.serialization.SerializedBytes, net.corda.core.crypto.DigitalSignature$WithKey)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializedBytes getRaw()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.DigitalSignature$WithKey getSig()
+  @org.jetbrains.annotations.NotNull public final Object verified()
+  protected void verifyData(Object)
+##
+public final class net.corda.core.crypto.TransactionSignature extends net.corda.core.crypto.DigitalSignature
+  public <init>(byte[], java.security.PublicKey, net.corda.core.crypto.SignatureMetadata)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final java.security.PublicKey getBy()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SignatureMetadata getSignatureMetadata()
+  public int hashCode()
+  public final boolean isValid(net.corda.core.crypto.SecureHash)
+  public final boolean verify(net.corda.core.crypto.SecureHash)
+##
+public final class net.corda.core.crypto.composite.CompositeSignaturesWithKeys extends java.lang.Object
+  public <init>(List)
+  @org.jetbrains.annotations.NotNull public final List component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.composite.CompositeSignaturesWithKeys copy(List)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final List getSigs()
+  public int hashCode()
+  public String toString()
+  public static final net.corda.core.crypto.composite.CompositeSignaturesWithKeys$Companion Companion
+##
+public static final class net.corda.core.crypto.composite.CompositeSignaturesWithKeys$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.composite.CompositeSignaturesWithKeys getEMPTY()
+##
+public abstract class net.corda.core.flows.AbstractStateReplacementFlow extends java.lang.Object
+  public <init>()
+##
+public abstract static class net.corda.core.flows.AbstractStateReplacementFlow$Acceptor extends net.corda.core.flows.FlowLogic
+  public <init>(net.corda.core.flows.FlowSession)
+  public <init>(net.corda.core.flows.FlowSession, net.corda.core.utilities.ProgressTracker)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.Nullable public Void call()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowSession getInitiatingSession()
+  @org.jetbrains.annotations.NotNull public net.corda.core.utilities.ProgressTracker getProgressTracker()
+  protected abstract void verifyProposal(net.corda.core.transactions.SignedTransaction, net.corda.core.flows.AbstractStateReplacementFlow$Proposal)
+  public static final net.corda.core.flows.AbstractStateReplacementFlow$Acceptor$Companion Companion
+##
+public static final class net.corda.core.flows.AbstractStateReplacementFlow$Acceptor$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker tracker()
+##
+public static final class net.corda.core.flows.AbstractStateReplacementFlow$Acceptor$Companion$APPROVING extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.AbstractStateReplacementFlow$Acceptor$Companion$APPROVING INSTANCE
+##
+public static final class net.corda.core.flows.AbstractStateReplacementFlow$Acceptor$Companion$VERIFYING extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.AbstractStateReplacementFlow$Acceptor$Companion$VERIFYING INSTANCE
+##
+public abstract static class net.corda.core.flows.AbstractStateReplacementFlow$Instigator extends net.corda.core.flows.FlowLogic
+  public <init>(net.corda.core.contracts.StateAndRef, Object, net.corda.core.utilities.ProgressTracker)
+  @org.jetbrains.annotations.NotNull protected abstract net.corda.core.flows.AbstractStateReplacementFlow$UpgradeTx assembleTx()
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public net.corda.core.contracts.StateAndRef call()
+  public final Object getModification()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateAndRef getOriginalState()
+  @org.jetbrains.annotations.NotNull public List getParticipantSessions()
+  @org.jetbrains.annotations.NotNull public net.corda.core.utilities.ProgressTracker getProgressTracker()
+  public static final net.corda.core.flows.AbstractStateReplacementFlow$Instigator$Companion Companion
+##
+public static final class net.corda.core.flows.AbstractStateReplacementFlow$Instigator$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker tracker()
+##
+public static final class net.corda.core.flows.AbstractStateReplacementFlow$Instigator$Companion$NOTARY extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.AbstractStateReplacementFlow$Instigator$Companion$NOTARY INSTANCE
+##
+public static final class net.corda.core.flows.AbstractStateReplacementFlow$Instigator$Companion$SIGNING extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.AbstractStateReplacementFlow$Instigator$Companion$SIGNING INSTANCE
+##
+public static final class net.corda.core.flows.AbstractStateReplacementFlow$Proposal extends java.lang.Object
+  public <init>(net.corda.core.contracts.StateRef, Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateRef component1()
+  public final Object component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.AbstractStateReplacementFlow$Proposal copy(net.corda.core.contracts.StateRef, Object)
+  public boolean equals(Object)
+  public final Object getModification()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateRef getStateRef()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.flows.AbstractStateReplacementFlow$UpgradeTx extends java.lang.Object
+  public <init>(net.corda.core.transactions.SignedTransaction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.AbstractStateReplacementFlow$UpgradeTx copy(net.corda.core.transactions.SignedTransaction)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction getStx()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.flows.AppContext extends java.lang.Object
+  public <init>(List)
+  @org.jetbrains.annotations.NotNull public final List component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.AppContext copy(List)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final List getAttachments()
+  @org.jetbrains.annotations.NotNull public final ClassLoader getClassLoader()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.flows.CollectSignatureFlow extends net.corda.core.flows.FlowLogic
+  public <init>(net.corda.core.transactions.SignedTransaction, net.corda.core.flows.FlowSession, List)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public List call()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction getPartiallySignedTx()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowSession getSession()
+  @org.jetbrains.annotations.NotNull public final List getSigningKeys()
+##
+public final class net.corda.core.flows.CollectSignaturesFlow extends net.corda.core.flows.FlowLogic
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.transactions.SignedTransaction, Collection)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.transactions.SignedTransaction, Collection, Iterable)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.transactions.SignedTransaction, Collection, Iterable, net.corda.core.utilities.ProgressTracker)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.transactions.SignedTransaction, Collection, net.corda.core.utilities.ProgressTracker)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public net.corda.core.transactions.SignedTransaction call()
+  @org.jetbrains.annotations.Nullable public final Iterable getMyOptionalKeys()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction getPartiallySignedTx()
+  @org.jetbrains.annotations.NotNull public net.corda.core.utilities.ProgressTracker getProgressTracker()
+  @org.jetbrains.annotations.NotNull public final Collection getSessionsToCollectFrom()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ProgressTracker tracker()
+  public static final net.corda.core.flows.CollectSignaturesFlow$Companion Companion
+##
+public static final class net.corda.core.flows.CollectSignaturesFlow$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker tracker()
+##
+public static final class net.corda.core.flows.CollectSignaturesFlow$Companion$COLLECTING extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.CollectSignaturesFlow$Companion$COLLECTING INSTANCE
+##
+public static final class net.corda.core.flows.CollectSignaturesFlow$Companion$VERIFYING extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.CollectSignaturesFlow$Companion$VERIFYING INSTANCE
+##
+public final class net.corda.core.flows.ContractUpgradeFlow extends java.lang.Object
+  public static final net.corda.core.flows.ContractUpgradeFlow INSTANCE
+##
+public static final class net.corda.core.flows.ContractUpgradeFlow$Authorise extends net.corda.core.flows.FlowLogic
+  public <init>(net.corda.core.contracts.StateAndRef, Class)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.Nullable public Void call()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateAndRef getStateAndRef()
+##
+public static final class net.corda.core.flows.ContractUpgradeFlow$Deauthorise extends net.corda.core.flows.FlowLogic
+  public <init>(net.corda.core.contracts.StateRef)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.Nullable public Void call()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateRef getStateRef()
+##
+public static final class net.corda.core.flows.ContractUpgradeFlow$Initiate extends net.corda.core.flows.AbstractStateReplacementFlow$Instigator
+  public <init>(net.corda.core.contracts.StateAndRef, Class)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull protected net.corda.core.flows.AbstractStateReplacementFlow$UpgradeTx assembleTx()
+##
+public abstract class net.corda.core.flows.DataVendingFlow extends net.corda.core.flows.FlowLogic
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.Nullable public Void call()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowSession getOtherSideSession()
+  @org.jetbrains.annotations.NotNull public final Object getPayload()
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull protected net.corda.core.utilities.UntrustworthyData sendPayloadAndReceiveDataRequest(net.corda.core.flows.FlowSession, Object)
+  @co.paralleluniverse.fibers.Suspendable protected void verifyDataRequest(net.corda.core.internal.FetchDataFlow$Request$Data)
+##
+public final class net.corda.core.flows.FinalityFlow extends net.corda.core.flows.FlowLogic
+  public <init>(net.corda.core.transactions.SignedTransaction)
+  public <init>(net.corda.core.transactions.SignedTransaction, Set)
+  public <init>(net.corda.core.transactions.SignedTransaction, Set, net.corda.core.utilities.ProgressTracker)
+  public <init>(net.corda.core.transactions.SignedTransaction, net.corda.core.utilities.ProgressTracker)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public net.corda.core.transactions.SignedTransaction call()
+  @org.jetbrains.annotations.NotNull public net.corda.core.utilities.ProgressTracker getProgressTracker()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction getTransaction()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ProgressTracker tracker()
+  public static final net.corda.core.flows.FinalityFlow$Companion Companion
+##
+public static final class net.corda.core.flows.FinalityFlow$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker tracker()
+##
+public static final class net.corda.core.flows.FinalityFlow$Companion$BROADCASTING extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.FinalityFlow$Companion$BROADCASTING INSTANCE
+##
+public static final class net.corda.core.flows.FinalityFlow$Companion$NOTARISING extends net.corda.core.utilities.ProgressTracker$Step
+  @org.jetbrains.annotations.NotNull public net.corda.core.utilities.ProgressTracker childProgressTracker()
+  public static final net.corda.core.flows.FinalityFlow$Companion$NOTARISING INSTANCE
+##
+public class net.corda.core.flows.FlowException extends net.corda.core.CordaException
+  public <init>()
+  public <init>(String)
+  public <init>(String, Throwable)
+  public <init>(Throwable)
+##
+public final class net.corda.core.flows.FlowInfo extends java.lang.Object
+  public <init>(int, String)
+  public final int component1()
+  @org.jetbrains.annotations.NotNull public final String component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowInfo copy(int, String)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final String getAppName()
+  public final int getFlowVersion()
+  public int hashCode()
+  public String toString()
+##
+public abstract class net.corda.core.flows.FlowInitiator extends java.lang.Object implements java.security.Principal
+##
+public static final class net.corda.core.flows.FlowInitiator$Peer extends net.corda.core.flows.FlowInitiator
+  public <init>(net.corda.core.identity.Party)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowInitiator$Peer copy(net.corda.core.identity.Party)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public String getName()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party getParty()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.flows.FlowInitiator$RPC extends net.corda.core.flows.FlowInitiator
+  public <init>(String)
+  @org.jetbrains.annotations.NotNull public final String component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowInitiator$RPC copy(String)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public String getName()
+  @org.jetbrains.annotations.NotNull public final String getUsername()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.flows.FlowInitiator$Scheduled extends net.corda.core.flows.FlowInitiator
+  public <init>(net.corda.core.contracts.ScheduledStateRef)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ScheduledStateRef component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowInitiator$Scheduled copy(net.corda.core.contracts.ScheduledStateRef)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public String getName()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ScheduledStateRef getScheduledState()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.flows.FlowInitiator$Shell extends net.corda.core.flows.FlowInitiator
+  @org.jetbrains.annotations.NotNull public String getName()
+  public static final net.corda.core.flows.FlowInitiator$Shell INSTANCE
+##
+public abstract class net.corda.core.flows.FlowLogic extends java.lang.Object
+  public <init>()
+  @co.paralleluniverse.fibers.Suspendable public abstract Object call()
+  public final void checkFlowPermission(String, Map)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.Nullable public final net.corda.core.flows.FlowStackSnapshot flowStackSnapshot()
+  @kotlin.Deprecated @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowInfo getFlowInfo(net.corda.core.identity.Party)
+  @org.jetbrains.annotations.NotNull public final org.slf4j.Logger getLogger()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party getOurIdentity()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.PartyAndCertificate getOurIdentityAndCert()
+  @org.jetbrains.annotations.Nullable public net.corda.core.utilities.ProgressTracker getProgressTracker()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StateMachineRunId getRunId()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.ServiceHub getServiceHub()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.internal.FlowStateMachine getStateMachine()
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowSession initiateFlow(net.corda.core.identity.Party)
+  @co.paralleluniverse.fibers.Suspendable public final void persistFlowStackSnapshot()
+  @kotlin.Deprecated @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public net.corda.core.utilities.UntrustworthyData receive(Class, net.corda.core.identity.Party)
+  public final void recordAuditEvent(String, String, Map)
+  @kotlin.Deprecated @co.paralleluniverse.fibers.Suspendable public void send(net.corda.core.identity.Party, Object)
+  @kotlin.Deprecated @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public net.corda.core.utilities.UntrustworthyData sendAndReceive(Class, net.corda.core.identity.Party, Object)
+  public final void setStateMachine(net.corda.core.internal.FlowStateMachine)
+  @co.paralleluniverse.fibers.Suspendable public Object subFlow(net.corda.core.flows.FlowLogic)
+  @org.jetbrains.annotations.Nullable public final net.corda.core.messaging.DataFeed track()
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction waitForLedgerCommit(net.corda.core.crypto.SecureHash)
+##
+public interface net.corda.core.flows.FlowLogicRef
+##
+public interface net.corda.core.flows.FlowLogicRefFactory
+##
+public abstract class net.corda.core.flows.FlowSession extends java.lang.Object
+  public <init>()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.identity.Party getCounterparty()
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public abstract net.corda.core.flows.FlowInfo getCounterpartyFlowInfo()
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public abstract net.corda.core.utilities.UntrustworthyData receive(Class)
+  @co.paralleluniverse.fibers.Suspendable public abstract void send(Object)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public abstract net.corda.core.utilities.UntrustworthyData sendAndReceive(Class, Object)
+##
+public final class net.corda.core.flows.FlowStackSnapshot extends java.lang.Object
+  public <init>(java.time.Instant, String, List)
+  @org.jetbrains.annotations.NotNull public final java.time.Instant component1()
+  @org.jetbrains.annotations.NotNull public final String component2()
+  @org.jetbrains.annotations.NotNull public final List component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowStackSnapshot copy(java.time.Instant, String, List)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final String getFlowClass()
+  @org.jetbrains.annotations.NotNull public final List getStackFrames()
+  @org.jetbrains.annotations.NotNull public final java.time.Instant getTime()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.flows.FlowStackSnapshot$Frame extends java.lang.Object
+  public <init>(StackTraceElement, List)
+  @org.jetbrains.annotations.NotNull public final StackTraceElement component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowStackSnapshot$Frame copy(StackTraceElement, List)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final List getStackObjects()
+  @org.jetbrains.annotations.NotNull public final StackTraceElement getStackTraceElement()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public final class net.corda.core.flows.IllegalFlowLogicException extends java.lang.IllegalArgumentException
+  public <init>(Class, String)
+##
+public @interface net.corda.core.flows.InitiatedBy
+  public abstract Class value()
+##
+public @interface net.corda.core.flows.InitiatingFlow
+  public abstract int version()
+##
+public final class net.corda.core.flows.NotaryChangeFlow extends net.corda.core.flows.AbstractStateReplacementFlow$Instigator
+  public <init>(net.corda.core.contracts.StateAndRef, net.corda.core.identity.Party, net.corda.core.utilities.ProgressTracker)
+  @org.jetbrains.annotations.NotNull protected net.corda.core.flows.AbstractStateReplacementFlow$UpgradeTx assembleTx()
+##
+public abstract class net.corda.core.flows.NotaryError extends java.lang.Object
+##
+public static final class net.corda.core.flows.NotaryError$Conflict extends net.corda.core.flows.NotaryError
+  public <init>(net.corda.core.crypto.SecureHash, net.corda.core.crypto.SignedData)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SignedData component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.NotaryError$Conflict copy(net.corda.core.crypto.SecureHash, net.corda.core.crypto.SignedData)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SignedData getConflict()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getTxId()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public static final class net.corda.core.flows.NotaryError$TimeWindowInvalid extends net.corda.core.flows.NotaryError
+  public static final net.corda.core.flows.NotaryError$TimeWindowInvalid INSTANCE
+##
+public static final class net.corda.core.flows.NotaryError$TransactionInvalid extends net.corda.core.flows.NotaryError
+  public <init>(Throwable)
+  @org.jetbrains.annotations.NotNull public final Throwable component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.NotaryError$TransactionInvalid copy(Throwable)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final Throwable getCause()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public static final class net.corda.core.flows.NotaryError$WrongNotary extends net.corda.core.flows.NotaryError
+  public static final net.corda.core.flows.NotaryError$WrongNotary INSTANCE
+##
+public final class net.corda.core.flows.NotaryException extends net.corda.core.flows.FlowException
+  public <init>(net.corda.core.flows.NotaryError)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.NotaryError getError()
+##
+public final class net.corda.core.flows.NotaryFlow extends java.lang.Object
+  public <init>()
+##
+public static class net.corda.core.flows.NotaryFlow$Client extends net.corda.core.flows.FlowLogic
+  public <init>(net.corda.core.transactions.SignedTransaction)
+  public <init>(net.corda.core.transactions.SignedTransaction, net.corda.core.utilities.ProgressTracker)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public List call()
+  @org.jetbrains.annotations.NotNull public net.corda.core.utilities.ProgressTracker getProgressTracker()
+  public static final net.corda.core.flows.NotaryFlow$Client$Companion Companion
+##
+public static final class net.corda.core.flows.NotaryFlow$Client$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker tracker()
+##
+public static final class net.corda.core.flows.NotaryFlow$Client$Companion$REQUESTING extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.NotaryFlow$Client$Companion$REQUESTING INSTANCE
+##
+public static final class net.corda.core.flows.NotaryFlow$Client$Companion$VALIDATING extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.NotaryFlow$Client$Companion$VALIDATING INSTANCE
+##
+public abstract static class net.corda.core.flows.NotaryFlow$Service extends net.corda.core.flows.FlowLogic
+  public <init>(net.corda.core.flows.FlowSession, net.corda.core.node.services.TrustedAuthorityNotaryService)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.Nullable public Void call()
+  @co.paralleluniverse.fibers.Suspendable protected final void checkNotary(net.corda.core.identity.Party)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowSession getOtherSideSession()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.TrustedAuthorityNotaryService getService()
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public abstract net.corda.core.flows.TransactionParts receiveAndVerifyTx()
+##
+public final class net.corda.core.flows.ReceiveStateAndRefFlow extends net.corda.core.flows.FlowLogic
+  public <init>(net.corda.core.flows.FlowSession)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public List call()
+##
+public final class net.corda.core.flows.ReceiveTransactionFlow extends net.corda.core.flows.FlowLogic
+  public <init>(net.corda.core.flows.FlowSession)
+  public <init>(net.corda.core.flows.FlowSession, boolean)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public net.corda.core.transactions.SignedTransaction call()
+##
+public @interface net.corda.core.flows.SchedulableFlow
+##
+public class net.corda.core.flows.SendStateAndRefFlow extends net.corda.core.flows.DataVendingFlow
+  public <init>(net.corda.core.flows.FlowSession, List)
+##
+public class net.corda.core.flows.SendTransactionFlow extends net.corda.core.flows.DataVendingFlow
+  public <init>(net.corda.core.flows.FlowSession, net.corda.core.transactions.SignedTransaction)
+##
+public abstract class net.corda.core.flows.SignTransactionFlow extends net.corda.core.flows.FlowLogic
+  public <init>(net.corda.core.flows.FlowSession, net.corda.core.utilities.ProgressTracker)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public net.corda.core.transactions.SignedTransaction call()
+  @co.paralleluniverse.fibers.Suspendable protected abstract void checkTransaction(net.corda.core.transactions.SignedTransaction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowSession getOtherSideSession()
+  @org.jetbrains.annotations.NotNull public net.corda.core.utilities.ProgressTracker getProgressTracker()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ProgressTracker tracker()
+  public static final net.corda.core.flows.SignTransactionFlow$Companion Companion
+##
+public static final class net.corda.core.flows.SignTransactionFlow$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker tracker()
+##
+public static final class net.corda.core.flows.SignTransactionFlow$Companion$RECEIVING extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.SignTransactionFlow$Companion$RECEIVING INSTANCE
+##
+public static final class net.corda.core.flows.SignTransactionFlow$Companion$SIGNING extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.SignTransactionFlow$Companion$SIGNING INSTANCE
+##
+public static final class net.corda.core.flows.SignTransactionFlow$Companion$VERIFYING extends net.corda.core.utilities.ProgressTracker$Step
+  public static final net.corda.core.flows.SignTransactionFlow$Companion$VERIFYING INSTANCE
+##
+public final class net.corda.core.flows.StackFrameDataToken extends java.lang.Object
+  public <init>(String)
+  @org.jetbrains.annotations.NotNull public final String component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StackFrameDataToken copy(String)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final String getClassName()
+  public int hashCode()
+  public String toString()
+##
+public @interface net.corda.core.flows.StartableByRPC
+##
+public final class net.corda.core.flows.StateMachineRunId extends java.lang.Object
+  public <init>(UUID)
+  @org.jetbrains.annotations.NotNull public final UUID component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StateMachineRunId copy(UUID)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final UUID getUuid()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+  public static final net.corda.core.flows.StateMachineRunId$Companion Companion
+##
+public static final class net.corda.core.flows.StateMachineRunId$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StateMachineRunId createRandom()
+##
+public class net.corda.core.flows.StateReplacementException extends net.corda.core.flows.FlowException
+  @kotlin.jvm.JvmOverloads public <init>()
+  @kotlin.jvm.JvmOverloads public <init>(String)
+  @kotlin.jvm.JvmOverloads public <init>(String, Throwable)
+##
+public final class net.corda.core.flows.TransactionParts extends java.lang.Object
+  public <init>(net.corda.core.crypto.SecureHash, List, net.corda.core.contracts.TimeWindow, net.corda.core.identity.Party)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.contracts.TimeWindow component3()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.identity.Party component4()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.TransactionParts copy(net.corda.core.crypto.SecureHash, List, net.corda.core.contracts.TimeWindow, net.corda.core.identity.Party)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getId()
+  @org.jetbrains.annotations.NotNull public final List getInputs()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.identity.Party getNotary()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.contracts.TimeWindow getTimestamp()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.flows.UnexpectedFlowEndException extends net.corda.core.CordaRuntimeException
+  public <init>(String)
+  public <init>(String, Throwable)
+##
+public abstract class net.corda.core.identity.AbstractParty extends java.lang.Object
+  public <init>(java.security.PublicKey)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final java.security.PublicKey getOwningKey()
+  public int hashCode()
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.CordaX500Name nameOrNull()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.PartyAndReference ref(net.corda.core.utilities.OpaqueBytes)
+##
+public final class net.corda.core.identity.AnonymousParty extends net.corda.core.identity.AbstractParty
+  public <init>(java.security.PublicKey)
+  @org.jetbrains.annotations.Nullable public net.corda.core.identity.CordaX500Name nameOrNull()
+  @org.jetbrains.annotations.NotNull public net.corda.core.contracts.PartyAndReference ref(net.corda.core.utilities.OpaqueBytes)
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public final class net.corda.core.identity.CordaX500Name extends java.lang.Object
+  public <init>(String, String, String)
+  public <init>(String, String, String, String)
+  public <init>(String, String, String, String, String, String)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.identity.CordaX500Name build(javax.security.auth.x500.X500Principal)
+  @org.jetbrains.annotations.Nullable public final String component1()
+  @org.jetbrains.annotations.Nullable public final String component2()
+  @org.jetbrains.annotations.NotNull public final String component3()
+  @org.jetbrains.annotations.NotNull public final String component4()
+  @org.jetbrains.annotations.Nullable public final String component5()
+  @org.jetbrains.annotations.NotNull public final String component6()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.CordaX500Name copy(String, String, String, String, String, String)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public final String getCommonName()
+  @org.jetbrains.annotations.NotNull public final String getCountry()
+  @org.jetbrains.annotations.NotNull public final String getLocality()
+  @org.jetbrains.annotations.NotNull public final String getOrganisation()
+  @org.jetbrains.annotations.Nullable public final String getOrganisationUnit()
+  @org.jetbrains.annotations.Nullable public final String getState()
+  @org.jetbrains.annotations.NotNull public final javax.security.auth.x500.X500Principal getX500Principal()
+  public int hashCode()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.identity.CordaX500Name parse(String)
+  @org.jetbrains.annotations.NotNull public String toString()
+  public static final net.corda.core.identity.CordaX500Name$Companion Companion
+  public static final int LENGTH_COUNTRY = 2
+  public static final int MAX_LENGTH_COMMON_NAME = 64
+  public static final int MAX_LENGTH_LOCALITY = 64
+  public static final int MAX_LENGTH_ORGANISATION = 128
+  public static final int MAX_LENGTH_ORGANISATION_UNIT = 64
+  public static final int MAX_LENGTH_STATE = 64
+##
+public static final class net.corda.core.identity.CordaX500Name$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.identity.CordaX500Name build(javax.security.auth.x500.X500Principal)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.identity.CordaX500Name parse(String)
+##
+public final class net.corda.core.identity.IdentityUtils extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public static final Map excludeHostNode(net.corda.core.node.ServiceHub, Map)
+  @org.jetbrains.annotations.NotNull public static final Map excludeNotary(Map, net.corda.core.transactions.SignedTransaction)
+  @org.jetbrains.annotations.NotNull public static final Map groupAbstractPartyByWellKnownParty(net.corda.core.node.ServiceHub, Collection)
+  @org.jetbrains.annotations.NotNull public static final Map groupAbstractPartyByWellKnownParty(net.corda.core.node.ServiceHub, Collection, boolean)
+  @org.jetbrains.annotations.NotNull public static final Map groupPublicKeysByWellKnownParty(net.corda.core.node.ServiceHub, Collection)
+  @org.jetbrains.annotations.NotNull public static final Map groupPublicKeysByWellKnownParty(net.corda.core.node.ServiceHub, Collection, boolean)
+##
+public final class net.corda.core.identity.Party extends net.corda.core.identity.AbstractParty
+  public <init>(java.security.cert.X509Certificate)
+  public <init>(net.corda.core.identity.CordaX500Name, java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.AnonymousParty anonymise()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.CordaX500Name getName()
+  @org.jetbrains.annotations.NotNull public net.corda.core.identity.CordaX500Name nameOrNull()
+  @org.jetbrains.annotations.NotNull public net.corda.core.contracts.PartyAndReference ref(net.corda.core.utilities.OpaqueBytes)
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public final class net.corda.core.identity.PartyAndCertificate extends java.lang.Object
+  public <init>(java.security.cert.CertPath)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party component1()
+  @org.jetbrains.annotations.NotNull public final java.security.cert.X509Certificate component2()
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final java.security.cert.CertPath getCertPath()
+  @org.jetbrains.annotations.NotNull public final java.security.cert.X509Certificate getCertificate()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.CordaX500Name getName()
+  @org.jetbrains.annotations.NotNull public final java.security.PublicKey getOwningKey()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party getParty()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+  @org.jetbrains.annotations.NotNull public final java.security.cert.PKIXCertPathValidatorResult verify(java.security.cert.TrustAnchor)
+##
+public interface net.corda.core.messaging.AllPossibleRecipients extends net.corda.core.messaging.MessageRecipients
+##
+public interface net.corda.core.messaging.CordaRPCOps extends net.corda.core.messaging.RPCOps
+  public abstract void addVaultTransactionNote(net.corda.core.crypto.SecureHash, String)
+  public abstract boolean attachmentExists(net.corda.core.crypto.SecureHash)
+  public abstract void clearNetworkMapCache()
+  @org.jetbrains.annotations.NotNull public abstract java.time.Instant currentNodeTime()
+  public abstract int getProtocolVersion()
+  @org.jetbrains.annotations.NotNull public abstract Iterable getVaultTransactionNotes(net.corda.core.crypto.SecureHash)
+  @kotlin.Deprecated @net.corda.core.messaging.RPCReturnsObservables @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed internalVerifiedTransactionsFeed()
+  @kotlin.Deprecated @org.jetbrains.annotations.NotNull public abstract List internalVerifiedTransactionsSnapshot()
+  @net.corda.core.messaging.RPCReturnsObservables @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed networkMapFeed()
+  @org.jetbrains.annotations.NotNull public abstract List networkMapSnapshot()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.NodeInfo nodeInfo()
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.node.NodeInfo nodeInfoFromParty(net.corda.core.identity.AbstractParty)
+  @org.jetbrains.annotations.NotNull public abstract List notaryIdentities()
+  @org.jetbrains.annotations.NotNull public abstract java.io.InputStream openAttachment(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public abstract Set partiesFromName(String, boolean)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party partyFromKey(java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public abstract List registeredFlows()
+  @net.corda.core.messaging.RPCReturnsObservables @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed stateMachineRecordedTransactionMappingFeed()
+  @org.jetbrains.annotations.NotNull public abstract List stateMachineRecordedTransactionMappingSnapshot()
+  @net.corda.core.messaging.RPCReturnsObservables @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed stateMachinesFeed()
+  @org.jetbrains.annotations.NotNull public abstract List stateMachinesSnapshot()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.SecureHash uploadAttachment(java.io.InputStream)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$Page vaultQuery(Class)
+  @net.corda.core.messaging.RPCReturnsObservables @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$Page vaultQueryBy(net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.PageSpecification, net.corda.core.node.services.vault.Sort, Class)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$Page vaultQueryByCriteria(net.corda.core.node.services.vault.QueryCriteria, Class)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$Page vaultQueryByWithPagingSpec(Class, net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.PageSpecification)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$Page vaultQueryByWithSorting(Class, net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.Sort)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed vaultTrack(Class)
+  @net.corda.core.messaging.RPCReturnsObservables @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed vaultTrackBy(net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.PageSpecification, net.corda.core.node.services.vault.Sort, Class)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed vaultTrackByCriteria(Class, net.corda.core.node.services.vault.QueryCriteria)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed vaultTrackByWithPagingSpec(Class, net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.PageSpecification)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed vaultTrackByWithSorting(Class, net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.Sort)
+  @net.corda.core.messaging.RPCReturnsObservables @org.jetbrains.annotations.NotNull public abstract net.corda.core.concurrent.CordaFuture waitUntilNetworkReady()
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party wellKnownPartyFromAnonymous(net.corda.core.identity.AbstractParty)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party wellKnownPartyFromX500Name(net.corda.core.identity.CordaX500Name)
+##
+public final class net.corda.core.messaging.CordaRPCOpsKt extends java.lang.Object
+##
+public final class net.corda.core.messaging.DataFeed extends java.lang.Object
+  public <init>(Object, rx.Observable)
+  public final Object component1()
+  @org.jetbrains.annotations.NotNull public final rx.Observable component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.messaging.DataFeed copy(Object, rx.Observable)
+  public boolean equals(Object)
+  public final Object getSnapshot()
+  @org.jetbrains.annotations.NotNull public final rx.Observable getUpdates()
+  public int hashCode()
+  public String toString()
+##
+public interface net.corda.core.messaging.FlowHandle extends java.lang.AutoCloseable
+  public abstract void close()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.flows.StateMachineRunId getId()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.concurrent.CordaFuture getReturnValue()
+##
+public final class net.corda.core.messaging.FlowHandleImpl extends java.lang.Object implements net.corda.core.messaging.FlowHandle
+  public <init>(net.corda.core.flows.StateMachineRunId, net.corda.core.concurrent.CordaFuture)
+  public void close()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StateMachineRunId component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.concurrent.CordaFuture component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.messaging.FlowHandleImpl copy(net.corda.core.flows.StateMachineRunId, net.corda.core.concurrent.CordaFuture)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.flows.StateMachineRunId getId()
+  @org.jetbrains.annotations.NotNull public net.corda.core.concurrent.CordaFuture getReturnValue()
+  public int hashCode()
+  public String toString()
+##
+public interface net.corda.core.messaging.FlowProgressHandle extends net.corda.core.messaging.FlowHandle
+  public abstract void close()
+  @org.jetbrains.annotations.NotNull public abstract rx.Observable getProgress()
+##
+public final class net.corda.core.messaging.FlowProgressHandleImpl extends java.lang.Object implements net.corda.core.messaging.FlowProgressHandle
+  public <init>(net.corda.core.flows.StateMachineRunId, net.corda.core.concurrent.CordaFuture, rx.Observable)
+  public void close()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StateMachineRunId component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.concurrent.CordaFuture component2()
+  @org.jetbrains.annotations.NotNull public final rx.Observable component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.messaging.FlowProgressHandleImpl copy(net.corda.core.flows.StateMachineRunId, net.corda.core.concurrent.CordaFuture, rx.Observable)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.flows.StateMachineRunId getId()
+  @org.jetbrains.annotations.NotNull public rx.Observable getProgress()
+  @org.jetbrains.annotations.NotNull public net.corda.core.concurrent.CordaFuture getReturnValue()
+  public int hashCode()
+  public String toString()
+##
+public interface net.corda.core.messaging.MessageRecipientGroup extends net.corda.core.messaging.MessageRecipients
+##
+public interface net.corda.core.messaging.MessageRecipients
+##
+public interface net.corda.core.messaging.RPCOps
+  public abstract int getProtocolVersion()
+##
+public @interface net.corda.core.messaging.RPCReturnsObservables
+##
+public interface net.corda.core.messaging.SingleMessageRecipient extends net.corda.core.messaging.MessageRecipients
+##
+public final class net.corda.core.messaging.StateMachineInfo extends java.lang.Object
+  public <init>(net.corda.core.flows.StateMachineRunId, String, net.corda.core.flows.FlowInitiator, net.corda.core.messaging.DataFeed)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StateMachineRunId component1()
+  @org.jetbrains.annotations.NotNull public final String component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowInitiator component3()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.messaging.DataFeed component4()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.messaging.StateMachineInfo copy(net.corda.core.flows.StateMachineRunId, String, net.corda.core.flows.FlowInitiator, net.corda.core.messaging.DataFeed)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final String getFlowLogicClassName()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StateMachineRunId getId()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.FlowInitiator getInitiator()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.messaging.DataFeed getProgressTrackerStepAndUpdates()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public final class net.corda.core.messaging.StateMachineTransactionMapping extends java.lang.Object
+  public <init>(net.corda.core.flows.StateMachineRunId, net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StateMachineRunId component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.messaging.StateMachineTransactionMapping copy(net.corda.core.flows.StateMachineRunId, net.corda.core.crypto.SecureHash)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StateMachineRunId getStateMachineRunId()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getTransactionId()
+  public int hashCode()
+  public String toString()
+##
+public abstract class net.corda.core.messaging.StateMachineUpdate extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.flows.StateMachineRunId getId()
+##
+public static final class net.corda.core.messaging.StateMachineUpdate$Added extends net.corda.core.messaging.StateMachineUpdate
+  public <init>(net.corda.core.messaging.StateMachineInfo)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.messaging.StateMachineInfo component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.messaging.StateMachineUpdate$Added copy(net.corda.core.messaging.StateMachineInfo)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.flows.StateMachineRunId getId()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.messaging.StateMachineInfo getStateMachineInfo()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.messaging.StateMachineUpdate$Removed extends net.corda.core.messaging.StateMachineUpdate
+  public <init>(net.corda.core.flows.StateMachineRunId, net.corda.core.utilities.Try)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StateMachineRunId component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.Try component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.messaging.StateMachineUpdate$Removed copy(net.corda.core.flows.StateMachineRunId, net.corda.core.utilities.Try)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.flows.StateMachineRunId getId()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.Try getResult()
+  public int hashCode()
+  public String toString()
+##
+public abstract class net.corda.core.node.CordaPluginRegistry extends java.lang.Object
+  public <init>()
+  public boolean customizeSerialization(net.corda.core.serialization.SerializationCustomization)
+##
+public final class net.corda.core.node.NodeInfo extends java.lang.Object
+  public <init>(List, List, int, long)
+  @org.jetbrains.annotations.NotNull public final List component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  public final int component3()
+  public final long component4()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.NodeInfo copy(List, List, int, long)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final List getAddresses()
+  @org.jetbrains.annotations.NotNull public final List getLegalIdentities()
+  @org.jetbrains.annotations.NotNull public final List getLegalIdentitiesAndCerts()
+  public final int getPlatformVersion()
+  public final long getSerial()
+  public int hashCode()
+  public final boolean isLegalIdentity(net.corda.core.identity.Party)
+  public String toString()
+##
+public interface net.corda.core.node.ServiceHub extends net.corda.core.node.ServicesForResolution
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.transactions.SignedTransaction addSignature(net.corda.core.transactions.SignedTransaction)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.transactions.SignedTransaction addSignature(net.corda.core.transactions.SignedTransaction, java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializeAsToken cordaService(Class)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.TransactionSignature createSignature(net.corda.core.transactions.FilteredTransaction)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.TransactionSignature createSignature(net.corda.core.transactions.FilteredTransaction, java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.TransactionSignature createSignature(net.corda.core.transactions.SignedTransaction)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.TransactionSignature createSignature(net.corda.core.transactions.SignedTransaction, java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public abstract java.time.Clock getClock()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.ContractUpgradeService getContractUpgradeService()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.KeyManagementService getKeyManagementService()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.NodeInfo getMyInfo()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.NetworkMapCache getNetworkMapCache()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.TransactionVerifierService getTransactionVerifierService()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.TransactionStorage getValidatedTransactions()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.VaultService getVaultService()
+  @org.jetbrains.annotations.NotNull public abstract java.sql.Connection jdbcSession()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.TransactionState loadState(net.corda.core.contracts.StateRef)
+  public abstract void recordTransactions(Iterable)
+  public abstract void recordTransactions(boolean, Iterable)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.transactions.SignedTransaction signInitialTransaction(net.corda.core.transactions.TransactionBuilder)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.transactions.SignedTransaction signInitialTransaction(net.corda.core.transactions.TransactionBuilder, Iterable)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.transactions.SignedTransaction signInitialTransaction(net.corda.core.transactions.TransactionBuilder, java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.StateAndRef toStateAndRef(net.corda.core.contracts.StateRef)
+##
+public interface net.corda.core.node.ServicesForResolution
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.AttachmentStorage getAttachments()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.cordapp.CordappProvider getCordappProvider()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.IdentityService getIdentityService()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.TransactionState loadState(net.corda.core.contracts.StateRef)
+##
+public interface net.corda.core.node.services.AttachmentStorage
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.SecureHash importAttachment(java.io.InputStream)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.contracts.Attachment openAttachment(net.corda.core.crypto.SecureHash)
+##
+public final class net.corda.core.node.services.AttachmentStorageKt extends java.lang.Object
+##
+public interface net.corda.core.node.services.ContractUpgradeService
+  @org.jetbrains.annotations.Nullable public abstract String getAuthorisedContractUpgrade(net.corda.core.contracts.StateRef)
+  public abstract void removeAuthorisedContractUpgrade(net.corda.core.contracts.StateRef)
+  public abstract void storeAuthorisedContractUpgrade(net.corda.core.contracts.StateRef, Class)
+##
+public @interface net.corda.core.node.services.CordaService
+##
+public interface net.corda.core.node.services.IdentityService
+  public abstract void assertOwnership(net.corda.core.identity.Party, net.corda.core.identity.AnonymousParty)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.PartyAndCertificate certificateFromKey(java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public abstract Iterable getAllIdentities()
+  @org.jetbrains.annotations.NotNull public abstract java.security.cert.CertStore getCaCertStore()
+  @org.jetbrains.annotations.NotNull public abstract java.security.cert.TrustAnchor getTrustAnchor()
+  @org.jetbrains.annotations.NotNull public abstract java.security.cert.X509Certificate getTrustRoot()
+  @org.jetbrains.annotations.NotNull public abstract Set partiesFromName(String, boolean)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party partyFromKey(java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.identity.Party requireWellKnownPartyFromAnonymous(net.corda.core.identity.AbstractParty)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.PartyAndCertificate verifyAndRegisterIdentity(net.corda.core.identity.PartyAndCertificate)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party wellKnownPartyFromAnonymous(net.corda.core.contracts.PartyAndReference)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party wellKnownPartyFromAnonymous(net.corda.core.identity.AbstractParty)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party wellKnownPartyFromX500Name(net.corda.core.identity.CordaX500Name)
+##
+public interface net.corda.core.node.services.KeyManagementService
+  @org.jetbrains.annotations.NotNull public abstract Iterable filterMyKeys(Iterable)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public abstract java.security.PublicKey freshKey()
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public abstract net.corda.core.identity.PartyAndCertificate freshKeyAndCert(net.corda.core.identity.PartyAndCertificate, boolean)
+  @org.jetbrains.annotations.NotNull public abstract Set getKeys()
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.TransactionSignature sign(net.corda.core.crypto.SignableData, java.security.PublicKey)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.DigitalSignature$WithKey sign(byte[], java.security.PublicKey)
+##
+public interface net.corda.core.node.services.NetworkMapCache
+  public abstract void clearNetworkMapCache()
+  @org.jetbrains.annotations.NotNull public abstract List getAllNodes()
+  @org.jetbrains.annotations.NotNull public abstract rx.Observable getChanged()
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.node.NodeInfo getNodeByAddress(net.corda.core.utilities.NetworkHostAndPort)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.node.NodeInfo getNodeByLegalIdentity(net.corda.core.identity.AbstractParty)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.node.NodeInfo getNodeByLegalName(net.corda.core.identity.CordaX500Name)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.concurrent.CordaFuture getNodeReady()
+  @org.jetbrains.annotations.NotNull public abstract List getNodesByLegalIdentityKey(java.security.PublicKey)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party getNotary(net.corda.core.identity.CordaX500Name)
+  @org.jetbrains.annotations.NotNull public abstract List getNotaryIdentities()
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.node.services.PartyInfo getPartyInfo(net.corda.core.identity.Party)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party getPeerByLegalName(net.corda.core.identity.CordaX500Name)
+  public abstract boolean isNotary(net.corda.core.identity.Party)
+  public abstract boolean isValidatingNotary(net.corda.core.identity.Party)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed track()
+##
+public abstract static class net.corda.core.node.services.NetworkMapCache$MapChange extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.NodeInfo getNode()
+##
+public static final class net.corda.core.node.services.NetworkMapCache$MapChange$Added extends net.corda.core.node.services.NetworkMapCache$MapChange
+  public <init>(net.corda.core.node.NodeInfo)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.NodeInfo component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.NetworkMapCache$MapChange$Added copy(net.corda.core.node.NodeInfo)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.node.NodeInfo getNode()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.NetworkMapCache$MapChange$Modified extends net.corda.core.node.services.NetworkMapCache$MapChange
+  public <init>(net.corda.core.node.NodeInfo, net.corda.core.node.NodeInfo)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.NodeInfo component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.NodeInfo component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.NetworkMapCache$MapChange$Modified copy(net.corda.core.node.NodeInfo, net.corda.core.node.NodeInfo)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.node.NodeInfo getNode()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.NodeInfo getPreviousNode()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.NetworkMapCache$MapChange$Removed extends net.corda.core.node.services.NetworkMapCache$MapChange
+  public <init>(net.corda.core.node.NodeInfo)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.NodeInfo component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.NetworkMapCache$MapChange$Removed copy(net.corda.core.node.NodeInfo)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.node.NodeInfo getNode()
+  public int hashCode()
+  public String toString()
+##
+public abstract class net.corda.core.node.services.NotaryService extends net.corda.core.serialization.SingletonSerializeAsToken
+  public <init>()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.flows.FlowLogic createServiceFlow(net.corda.core.flows.FlowSession)
+  @org.jetbrains.annotations.NotNull public abstract java.security.PublicKey getNotaryIdentityKey()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.ServiceHub getServices()
+  public abstract void start()
+  public abstract void stop()
+##
+public abstract class net.corda.core.node.services.PartyInfo extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.identity.Party getParty()
+##
+public static final class net.corda.core.node.services.PartyInfo$DistributedNode extends net.corda.core.node.services.PartyInfo
+  public <init>(net.corda.core.identity.Party)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.PartyInfo$DistributedNode copy(net.corda.core.identity.Party)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.identity.Party getParty()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.PartyInfo$SingleNode extends net.corda.core.node.services.PartyInfo
+  public <init>(net.corda.core.identity.Party, List)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.PartyInfo$SingleNode copy(net.corda.core.identity.Party, List)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final List getAddresses()
+  @org.jetbrains.annotations.NotNull public net.corda.core.identity.Party getParty()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.node.services.StatesNotAvailableException extends net.corda.core.flows.FlowException
+  public <init>(String, Throwable)
+  @org.jetbrains.annotations.Nullable public Throwable getCause()
+  @org.jetbrains.annotations.Nullable public String getMessage()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public final class net.corda.core.node.services.TimeWindowChecker extends java.lang.Object
+  public <init>()
+  public <init>(java.time.Clock)
+  @org.jetbrains.annotations.NotNull public final java.time.Clock getClock()
+  public final boolean isValid(net.corda.core.contracts.TimeWindow)
+##
+public interface net.corda.core.node.services.TransactionStorage
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.transactions.SignedTransaction getTransaction(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public abstract rx.Observable getUpdates()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed track()
+##
+public interface net.corda.core.node.services.TransactionVerifierService
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.concurrent.CordaFuture verify(net.corda.core.transactions.LedgerTransaction)
+##
+public abstract class net.corda.core.node.services.TrustedAuthorityNotaryService extends net.corda.core.node.services.NotaryService
+  public <init>()
+  public final void commitInputStates(List, net.corda.core.crypto.SecureHash, net.corda.core.identity.Party)
+  @org.jetbrains.annotations.NotNull protected org.slf4j.Logger getLog()
+  @org.jetbrains.annotations.NotNull protected abstract net.corda.core.node.services.TimeWindowChecker getTimeWindowChecker()
+  @org.jetbrains.annotations.NotNull protected abstract net.corda.core.node.services.UniquenessProvider getUniquenessProvider()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.TransactionSignature sign(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.DigitalSignature$WithKey sign(byte[])
+  public final void validateTimeWindow(net.corda.core.contracts.TimeWindow)
+##
+public final class net.corda.core.node.services.UniquenessException extends net.corda.core.CordaException
+  public <init>(net.corda.core.node.services.UniquenessProvider$Conflict)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.UniquenessProvider$Conflict getError()
+##
+public interface net.corda.core.node.services.UniquenessProvider
+  public abstract void commit(List, net.corda.core.crypto.SecureHash, net.corda.core.identity.Party)
+##
+public static final class net.corda.core.node.services.UniquenessProvider$Conflict extends java.lang.Object
+  public <init>(Map)
+  @org.jetbrains.annotations.NotNull public final Map component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.UniquenessProvider$Conflict copy(Map)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final Map getStateHistory()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.UniquenessProvider$ConsumingTx extends java.lang.Object
+  public <init>(net.corda.core.crypto.SecureHash, int, net.corda.core.identity.Party)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component1()
+  public final int component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.UniquenessProvider$ConsumingTx copy(net.corda.core.crypto.SecureHash, int, net.corda.core.identity.Party)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getId()
+  public final int getInputIndex()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party getRequestingParty()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.node.services.UnknownAnonymousPartyException extends net.corda.core.CordaException
+  public <init>(String)
+##
+public final class net.corda.core.node.services.Vault extends java.lang.Object
+  public <init>(Iterable)
+  @org.jetbrains.annotations.NotNull public final Iterable getStates()
+  public static final net.corda.core.node.services.Vault$Companion Companion
+##
+public static final class net.corda.core.node.services.Vault$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$Update getNoNotaryUpdate()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$Update getNoUpdate()
+##
+public static final class net.corda.core.node.services.Vault$Page extends java.lang.Object
+  public <init>(List, List, long, net.corda.core.node.services.Vault$StateStatus, List)
+  @org.jetbrains.annotations.NotNull public final List component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  public final long component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$StateStatus component4()
+  @org.jetbrains.annotations.NotNull public final List component5()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$Page copy(List, List, long, net.corda.core.node.services.Vault$StateStatus, List)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final List getOtherResults()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$StateStatus getStateTypes()
+  @org.jetbrains.annotations.NotNull public final List getStates()
+  @org.jetbrains.annotations.NotNull public final List getStatesMetadata()
+  public final long getTotalStatesAvailable()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.Vault$StateMetadata extends java.lang.Object
+  public <init>(net.corda.core.contracts.StateRef, String, java.time.Instant, java.time.Instant, net.corda.core.node.services.Vault$StateStatus, net.corda.core.identity.AbstractParty, String, java.time.Instant)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateRef component1()
+  @org.jetbrains.annotations.NotNull public final String component2()
+  @org.jetbrains.annotations.NotNull public final java.time.Instant component3()
+  @org.jetbrains.annotations.Nullable public final java.time.Instant component4()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$StateStatus component5()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.identity.AbstractParty component6()
+  @org.jetbrains.annotations.Nullable public final String component7()
+  @org.jetbrains.annotations.Nullable public final java.time.Instant component8()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$StateMetadata copy(net.corda.core.contracts.StateRef, String, java.time.Instant, java.time.Instant, net.corda.core.node.services.Vault$StateStatus, net.corda.core.identity.AbstractParty, String, java.time.Instant)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public final java.time.Instant getConsumedTime()
+  @org.jetbrains.annotations.NotNull public final String getContractStateClassName()
+  @org.jetbrains.annotations.Nullable public final String getLockId()
+  @org.jetbrains.annotations.Nullable public final java.time.Instant getLockUpdateTime()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.identity.AbstractParty getNotary()
+  @org.jetbrains.annotations.NotNull public final java.time.Instant getRecordedTime()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateRef getRef()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$StateStatus getStatus()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.Vault$StateStatus extends java.lang.Enum
+  protected <init>(String, int)
+  public static net.corda.core.node.services.Vault$StateStatus valueOf(String)
+  public static net.corda.core.node.services.Vault$StateStatus[] values()
+##
+public static final class net.corda.core.node.services.Vault$Update extends java.lang.Object
+  public <init>(Set, Set, UUID, net.corda.core.node.services.Vault$UpdateType)
+  @org.jetbrains.annotations.NotNull public final Set component1()
+  @org.jetbrains.annotations.NotNull public final Set component2()
+  @org.jetbrains.annotations.Nullable public final UUID component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$UpdateType component4()
+  public final boolean containsType(Class, net.corda.core.node.services.Vault$StateStatus)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$Update copy(Set, Set, UUID, net.corda.core.node.services.Vault$UpdateType)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final Set getConsumed()
+  @org.jetbrains.annotations.Nullable public final UUID getFlowId()
+  @org.jetbrains.annotations.NotNull public final Set getProduced()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$UpdateType getType()
+  public int hashCode()
+  public final boolean isEmpty()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$Update plus(net.corda.core.node.services.Vault$Update)
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public static final class net.corda.core.node.services.Vault$UpdateType extends java.lang.Enum
+  protected <init>(String, int)
+  public static net.corda.core.node.services.Vault$UpdateType valueOf(String)
+  public static net.corda.core.node.services.Vault$UpdateType[] values()
+##
+public final class net.corda.core.node.services.VaultQueryException extends net.corda.core.flows.FlowException
+  public <init>(String)
+##
+public interface net.corda.core.node.services.VaultService
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$Page _queryBy(net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.PageSpecification, net.corda.core.node.services.vault.Sort, Class)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed _trackBy(net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.PageSpecification, net.corda.core.node.services.vault.Sort, Class)
+  public abstract void addNoteToTransaction(net.corda.core.crypto.SecureHash, String)
+  @org.jetbrains.annotations.NotNull public abstract rx.Observable getRawUpdates()
+  @org.jetbrains.annotations.NotNull public abstract Iterable getTransactionNotes(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public abstract rx.Observable getUpdates()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$Page queryBy(Class)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$Page queryBy(Class, net.corda.core.node.services.vault.QueryCriteria)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$Page queryBy(Class, net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.PageSpecification)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$Page queryBy(Class, net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.PageSpecification, net.corda.core.node.services.vault.Sort)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$Page queryBy(Class, net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.Sort)
+  public abstract void softLockRelease(UUID, net.corda.core.utilities.NonEmptySet)
+  public abstract void softLockReserve(UUID, net.corda.core.utilities.NonEmptySet)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed trackBy(Class)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed trackBy(Class, net.corda.core.node.services.vault.QueryCriteria)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed trackBy(Class, net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.PageSpecification)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed trackBy(Class, net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.PageSpecification, net.corda.core.node.services.vault.Sort)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed trackBy(Class, net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.Sort)
+  @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public abstract List tryLockFungibleStatesForSpending(UUID, net.corda.core.node.services.vault.QueryCriteria, net.corda.core.contracts.Amount, Class)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.concurrent.CordaFuture whenConsumed(net.corda.core.contracts.StateRef)
+##
+public final class net.corda.core.node.services.VaultServiceKt extends java.lang.Object
+##
+public final class net.corda.core.node.services.vault.AggregateFunctionType extends java.lang.Enum
+  protected <init>(String, int)
+  public static net.corda.core.node.services.vault.AggregateFunctionType valueOf(String)
+  public static net.corda.core.node.services.vault.AggregateFunctionType[] values()
+##
+public final class net.corda.core.node.services.vault.BinaryComparisonOperator extends java.lang.Enum implements net.corda.core.node.services.vault.Operator
+  protected <init>(String, int)
+  public static net.corda.core.node.services.vault.BinaryComparisonOperator valueOf(String)
+  public static net.corda.core.node.services.vault.BinaryComparisonOperator[] values()
+##
+public final class net.corda.core.node.services.vault.BinaryLogicalOperator extends java.lang.Enum implements net.corda.core.node.services.vault.Operator
+  protected <init>(String, int)
+  public static net.corda.core.node.services.vault.BinaryLogicalOperator valueOf(String)
+  public static net.corda.core.node.services.vault.BinaryLogicalOperator[] values()
+##
+public final class net.corda.core.node.services.vault.Builder extends java.lang.Object
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression avg(reflect.Field)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression avg(reflect.Field, List)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression avg(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression avg(kotlin.reflect.KProperty1, List, net.corda.core.node.services.vault.Sort$Direction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$Between between(Comparable, Comparable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression between(reflect.Field, Comparable, Comparable)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression between(kotlin.reflect.KProperty1, Comparable, Comparable)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$BinaryComparison compare(net.corda.core.node.services.vault.BinaryComparisonOperator, Comparable)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression comparePredicate(reflect.Field, net.corda.core.node.services.vault.BinaryComparisonOperator, Comparable)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression comparePredicate(kotlin.reflect.KProperty1, net.corda.core.node.services.vault.BinaryComparisonOperator, Comparable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression count(reflect.Field)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression count(kotlin.reflect.KProperty1)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$EqualityComparison equal(Object)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression equal(reflect.Field, Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression equal(kotlin.reflect.KProperty1, Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression functionPredicate(reflect.Field, net.corda.core.node.services.vault.ColumnPredicate, List, net.corda.core.node.services.vault.Sort$Direction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression functionPredicate(kotlin.reflect.KProperty1, net.corda.core.node.services.vault.ColumnPredicate, List, net.corda.core.node.services.vault.Sort$Direction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$BinaryComparison greaterThan(Comparable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression greaterThan(reflect.Field, Comparable)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression greaterThan(kotlin.reflect.KProperty1, Comparable)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$BinaryComparison greaterThanOrEqual(Comparable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression greaterThanOrEqual(reflect.Field, Comparable)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression greaterThanOrEqual(kotlin.reflect.KProperty1, Comparable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression in(reflect.Field, Collection)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$CollectionExpression in(Collection)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression in(kotlin.reflect.KProperty1, Collection)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression isNull(reflect.Field)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression isNull(kotlin.reflect.KProperty1)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$BinaryComparison lessThan(Comparable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression lessThan(reflect.Field, Comparable)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression lessThan(kotlin.reflect.KProperty1, Comparable)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$BinaryComparison lessThanOrEqual(Comparable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression lessThanOrEqual(reflect.Field, Comparable)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression lessThanOrEqual(kotlin.reflect.KProperty1, Comparable)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression like(reflect.Field, String)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression like(kotlin.reflect.KProperty1, String)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression max(reflect.Field)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression max(reflect.Field, List)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression max(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression max(kotlin.reflect.KProperty1, List, net.corda.core.node.services.vault.Sort$Direction)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression min(reflect.Field)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression min(reflect.Field, List)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression min(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression min(kotlin.reflect.KProperty1, List, net.corda.core.node.services.vault.Sort$Direction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$EqualityComparison notEqual(Object)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression notEqual(reflect.Field, Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression notEqual(kotlin.reflect.KProperty1, Object)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression notIn(reflect.Field, Collection)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$CollectionExpression notIn(Collection)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression notIn(kotlin.reflect.KProperty1, Collection)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression notLike(reflect.Field, String)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression notLike(kotlin.reflect.KProperty1, String)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression notNull(reflect.Field)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression notNull(kotlin.reflect.KProperty1)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression predicate(reflect.Field, net.corda.core.node.services.vault.ColumnPredicate)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression predicate(kotlin.reflect.KProperty1, net.corda.core.node.services.vault.ColumnPredicate)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression sum(reflect.Field)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression sum(reflect.Field, List)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression sum(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression sum(kotlin.reflect.KProperty1, List, net.corda.core.node.services.vault.Sort$Direction)
+  public static final net.corda.core.node.services.vault.Builder INSTANCE
+##
+public final class net.corda.core.node.services.vault.CollectionOperator extends java.lang.Enum implements net.corda.core.node.services.vault.Operator
+  protected <init>(String, int)
+  public static net.corda.core.node.services.vault.CollectionOperator valueOf(String)
+  public static net.corda.core.node.services.vault.CollectionOperator[] values()
+##
+public final class net.corda.core.node.services.vault.Column extends java.lang.Object
+  public <init>(String, Class)
+  public <init>(reflect.Field)
+  public <init>(kotlin.reflect.KProperty1)
+  @org.jetbrains.annotations.NotNull public final Class getDeclaringClass()
+  @org.jetbrains.annotations.NotNull public final String getName()
+##
+public abstract class net.corda.core.node.services.vault.ColumnPredicate extends java.lang.Object
+##
+public static final class net.corda.core.node.services.vault.ColumnPredicate$AggregateFunction extends net.corda.core.node.services.vault.ColumnPredicate
+  public <init>(net.corda.core.node.services.vault.AggregateFunctionType)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.AggregateFunctionType component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$AggregateFunction copy(net.corda.core.node.services.vault.AggregateFunctionType)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.AggregateFunctionType getType()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.ColumnPredicate$Between extends net.corda.core.node.services.vault.ColumnPredicate
+  public <init>(Comparable, Comparable)
+  @org.jetbrains.annotations.NotNull public final Comparable component1()
+  @org.jetbrains.annotations.NotNull public final Comparable component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$Between copy(Comparable, Comparable)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final Comparable getRightFromLiteral()
+  @org.jetbrains.annotations.NotNull public final Comparable getRightToLiteral()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.ColumnPredicate$BinaryComparison extends net.corda.core.node.services.vault.ColumnPredicate
+  public <init>(net.corda.core.node.services.vault.BinaryComparisonOperator, Comparable)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.BinaryComparisonOperator component1()
+  @org.jetbrains.annotations.NotNull public final Comparable component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$BinaryComparison copy(net.corda.core.node.services.vault.BinaryComparisonOperator, Comparable)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.BinaryComparisonOperator getOperator()
+  @org.jetbrains.annotations.NotNull public final Comparable getRightLiteral()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.ColumnPredicate$CollectionExpression extends net.corda.core.node.services.vault.ColumnPredicate
+  public <init>(net.corda.core.node.services.vault.CollectionOperator, Collection)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CollectionOperator component1()
+  @org.jetbrains.annotations.NotNull public final Collection component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$CollectionExpression copy(net.corda.core.node.services.vault.CollectionOperator, Collection)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CollectionOperator getOperator()
+  @org.jetbrains.annotations.NotNull public final Collection getRightLiteral()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.ColumnPredicate$EqualityComparison extends net.corda.core.node.services.vault.ColumnPredicate
+  public <init>(net.corda.core.node.services.vault.EqualityComparisonOperator, Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.EqualityComparisonOperator component1()
+  public final Object component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$EqualityComparison copy(net.corda.core.node.services.vault.EqualityComparisonOperator, Object)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.EqualityComparisonOperator getOperator()
+  public final Object getRightLiteral()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.ColumnPredicate$Likeness extends net.corda.core.node.services.vault.ColumnPredicate
+  public <init>(net.corda.core.node.services.vault.LikenessOperator, String)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.LikenessOperator component1()
+  @org.jetbrains.annotations.NotNull public final String component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$Likeness copy(net.corda.core.node.services.vault.LikenessOperator, String)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.LikenessOperator getOperator()
+  @org.jetbrains.annotations.NotNull public final String getRightLiteral()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.ColumnPredicate$NullExpression extends net.corda.core.node.services.vault.ColumnPredicate
+  public <init>(net.corda.core.node.services.vault.NullOperator)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.NullOperator component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$NullExpression copy(net.corda.core.node.services.vault.NullOperator)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.NullOperator getOperator()
+  public int hashCode()
+  public String toString()
+##
+public abstract class net.corda.core.node.services.vault.CriteriaExpression extends java.lang.Object
+##
+public static final class net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression extends net.corda.core.node.services.vault.CriteriaExpression
+  public <init>(net.corda.core.node.services.vault.Column, net.corda.core.node.services.vault.ColumnPredicate, List, net.corda.core.node.services.vault.Sort$Direction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.Column component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate component2()
+  @org.jetbrains.annotations.Nullable public final List component3()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.node.services.vault.Sort$Direction component4()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression copy(net.corda.core.node.services.vault.Column, net.corda.core.node.services.vault.ColumnPredicate, List, net.corda.core.node.services.vault.Sort$Direction)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.Column getColumn()
+  @org.jetbrains.annotations.Nullable public final List getGroupByColumns()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.node.services.vault.Sort$Direction getOrderBy()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate getPredicate()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.CriteriaExpression$BinaryLogical extends net.corda.core.node.services.vault.CriteriaExpression
+  public <init>(net.corda.core.node.services.vault.CriteriaExpression, net.corda.core.node.services.vault.CriteriaExpression, net.corda.core.node.services.vault.BinaryLogicalOperator)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.BinaryLogicalOperator component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$BinaryLogical copy(net.corda.core.node.services.vault.CriteriaExpression, net.corda.core.node.services.vault.CriteriaExpression, net.corda.core.node.services.vault.BinaryLogicalOperator)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression getLeft()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.BinaryLogicalOperator getOperator()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression getRight()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression extends net.corda.core.node.services.vault.CriteriaExpression
+  public <init>(net.corda.core.node.services.vault.Column, net.corda.core.node.services.vault.ColumnPredicate)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.Column component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression copy(net.corda.core.node.services.vault.Column, net.corda.core.node.services.vault.ColumnPredicate)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.Column getColumn()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate getPredicate()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.CriteriaExpression$Not extends net.corda.core.node.services.vault.CriteriaExpression
+  public <init>(net.corda.core.node.services.vault.CriteriaExpression)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$Not copy(net.corda.core.node.services.vault.CriteriaExpression)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression getExpression()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.node.services.vault.EqualityComparisonOperator extends java.lang.Enum implements net.corda.core.node.services.vault.Operator
+  protected <init>(String, int)
+  public static net.corda.core.node.services.vault.EqualityComparisonOperator valueOf(String)
+  public static net.corda.core.node.services.vault.EqualityComparisonOperator[] values()
+##
+public interface net.corda.core.node.services.vault.IQueryCriteriaParser
+  @org.jetbrains.annotations.NotNull public abstract Collection parse(net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.Sort)
+  @org.jetbrains.annotations.NotNull public abstract Collection parseAnd(net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.QueryCriteria)
+  @org.jetbrains.annotations.NotNull public abstract Collection parseCriteria(net.corda.core.node.services.vault.QueryCriteria$CommonQueryCriteria)
+  @org.jetbrains.annotations.NotNull public abstract Collection parseCriteria(net.corda.core.node.services.vault.QueryCriteria$FungibleAssetQueryCriteria)
+  @org.jetbrains.annotations.NotNull public abstract Collection parseCriteria(net.corda.core.node.services.vault.QueryCriteria$LinearStateQueryCriteria)
+  @org.jetbrains.annotations.NotNull public abstract Collection parseCriteria(net.corda.core.node.services.vault.QueryCriteria$VaultCustomQueryCriteria)
+  @org.jetbrains.annotations.NotNull public abstract Collection parseCriteria(net.corda.core.node.services.vault.QueryCriteria$VaultQueryCriteria)
+  @org.jetbrains.annotations.NotNull public abstract Collection parseOr(net.corda.core.node.services.vault.QueryCriteria, net.corda.core.node.services.vault.QueryCriteria)
+##
+public final class net.corda.core.node.services.vault.LikenessOperator extends java.lang.Enum implements net.corda.core.node.services.vault.Operator
+  protected <init>(String, int)
+  public static net.corda.core.node.services.vault.LikenessOperator valueOf(String)
+  public static net.corda.core.node.services.vault.LikenessOperator[] values()
+##
+public final class net.corda.core.node.services.vault.NullOperator extends java.lang.Enum implements net.corda.core.node.services.vault.Operator
+  protected <init>(String, int)
+  public static net.corda.core.node.services.vault.NullOperator valueOf(String)
+  public static net.corda.core.node.services.vault.NullOperator[] values()
+##
+public interface net.corda.core.node.services.vault.Operator
+##
+public final class net.corda.core.node.services.vault.PageSpecification extends java.lang.Object
+  public <init>()
+  public <init>(int, int)
+  public final int component1()
+  public final int component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.PageSpecification copy(int, int)
+  public boolean equals(Object)
+  public final int getPageNumber()
+  public final int getPageSize()
+  public int hashCode()
+  public final boolean isDefault()
+  public String toString()
+##
+public abstract class net.corda.core.node.services.vault.QueryCriteria extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria and(net.corda.core.node.services.vault.QueryCriteria)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria or(net.corda.core.node.services.vault.QueryCriteria)
+  @org.jetbrains.annotations.NotNull public abstract Collection visit(net.corda.core.node.services.vault.IQueryCriteriaParser)
+##
+public abstract static class net.corda.core.node.services.vault.QueryCriteria$CommonQueryCriteria extends net.corda.core.node.services.vault.QueryCriteria
+  public <init>()
+  @org.jetbrains.annotations.Nullable public abstract Set getContractStateTypes()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.Vault$StateStatus getStatus()
+  @org.jetbrains.annotations.NotNull public Collection visit(net.corda.core.node.services.vault.IQueryCriteriaParser)
+##
+public static final class net.corda.core.node.services.vault.QueryCriteria$FungibleAssetQueryCriteria extends net.corda.core.node.services.vault.QueryCriteria$CommonQueryCriteria
+  @kotlin.jvm.JvmOverloads public <init>()
+  @kotlin.jvm.JvmOverloads public <init>(List)
+  @kotlin.jvm.JvmOverloads public <init>(List, List)
+  @kotlin.jvm.JvmOverloads public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate)
+  @kotlin.jvm.JvmOverloads public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List)
+  @kotlin.jvm.JvmOverloads public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List, List)
+  @kotlin.jvm.JvmOverloads public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List, List, net.corda.core.node.services.Vault$StateStatus)
+  @kotlin.jvm.JvmOverloads public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List, List, net.corda.core.node.services.Vault$StateStatus, Set)
+  @org.jetbrains.annotations.Nullable public final List component1()
+  @org.jetbrains.annotations.Nullable public final List component2()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.node.services.vault.ColumnPredicate component3()
+  @org.jetbrains.annotations.Nullable public final List component4()
+  @org.jetbrains.annotations.Nullable public final List component5()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$StateStatus component6()
+  @org.jetbrains.annotations.Nullable public final Set component7()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria$FungibleAssetQueryCriteria copy(List, List, net.corda.core.node.services.vault.ColumnPredicate, List, List, net.corda.core.node.services.Vault$StateStatus, Set)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public Set getContractStateTypes()
+  @org.jetbrains.annotations.Nullable public final List getIssuer()
+  @org.jetbrains.annotations.Nullable public final List getIssuerRef()
+  @org.jetbrains.annotations.Nullable public final List getOwner()
+  @org.jetbrains.annotations.Nullable public final List getParticipants()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.node.services.vault.ColumnPredicate getQuantity()
+  @org.jetbrains.annotations.NotNull public net.corda.core.node.services.Vault$StateStatus getStatus()
+  public int hashCode()
+  public String toString()
+  @org.jetbrains.annotations.NotNull public Collection visit(net.corda.core.node.services.vault.IQueryCriteriaParser)
+##
+public static final class net.corda.core.node.services.vault.QueryCriteria$LinearStateQueryCriteria extends net.corda.core.node.services.vault.QueryCriteria$CommonQueryCriteria
+  @kotlin.jvm.JvmOverloads public <init>()
+  @kotlin.jvm.JvmOverloads public <init>(List)
+  @kotlin.jvm.JvmOverloads public <init>(List, List)
+  @kotlin.jvm.JvmOverloads public <init>(List, List, List)
+  @kotlin.jvm.JvmOverloads public <init>(List, List, List, net.corda.core.node.services.Vault$StateStatus)
+  @kotlin.jvm.JvmOverloads public <init>(List, List, List, net.corda.core.node.services.Vault$StateStatus, Set)
+  public <init>(List, List, net.corda.core.node.services.Vault$StateStatus, Set)
+  @org.jetbrains.annotations.Nullable public final List component1()
+  @org.jetbrains.annotations.Nullable public final List component2()
+  @org.jetbrains.annotations.Nullable public final List component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$StateStatus component4()
+  @org.jetbrains.annotations.Nullable public final Set component5()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria$LinearStateQueryCriteria copy(List, List, List, net.corda.core.node.services.Vault$StateStatus, Set)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public Set getContractStateTypes()
+  @org.jetbrains.annotations.Nullable public final List getExternalId()
+  @org.jetbrains.annotations.Nullable public final List getParticipants()
+  @org.jetbrains.annotations.NotNull public net.corda.core.node.services.Vault$StateStatus getStatus()
+  @org.jetbrains.annotations.Nullable public final List getUuid()
+  public int hashCode()
+  public String toString()
+  @org.jetbrains.annotations.NotNull public Collection visit(net.corda.core.node.services.vault.IQueryCriteriaParser)
+##
+public static final class net.corda.core.node.services.vault.QueryCriteria$SoftLockingCondition extends java.lang.Object
+  public <init>(net.corda.core.node.services.vault.QueryCriteria$SoftLockingType, List)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria$SoftLockingType component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria$SoftLockingCondition copy(net.corda.core.node.services.vault.QueryCriteria$SoftLockingType, List)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final List getLockIds()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria$SoftLockingType getType()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.QueryCriteria$SoftLockingType extends java.lang.Enum
+  protected <init>(String, int)
+  public static net.corda.core.node.services.vault.QueryCriteria$SoftLockingType valueOf(String)
+  public static net.corda.core.node.services.vault.QueryCriteria$SoftLockingType[] values()
+##
+public static final class net.corda.core.node.services.vault.QueryCriteria$TimeCondition extends java.lang.Object
+  public <init>(net.corda.core.node.services.vault.QueryCriteria$TimeInstantType, net.corda.core.node.services.vault.ColumnPredicate)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria$TimeInstantType component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria$TimeCondition copy(net.corda.core.node.services.vault.QueryCriteria$TimeInstantType, net.corda.core.node.services.vault.ColumnPredicate)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate getPredicate()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria$TimeInstantType getType()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.QueryCriteria$TimeInstantType extends java.lang.Enum
+  protected <init>(String, int)
+  public static net.corda.core.node.services.vault.QueryCriteria$TimeInstantType valueOf(String)
+  public static net.corda.core.node.services.vault.QueryCriteria$TimeInstantType[] values()
+##
+public static final class net.corda.core.node.services.vault.QueryCriteria$VaultCustomQueryCriteria extends net.corda.core.node.services.vault.QueryCriteria$CommonQueryCriteria
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.vault.CriteriaExpression)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.vault.CriteriaExpression, net.corda.core.node.services.Vault$StateStatus)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.vault.CriteriaExpression, net.corda.core.node.services.Vault$StateStatus, Set)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$StateStatus component2()
+  @org.jetbrains.annotations.Nullable public final Set component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria$VaultCustomQueryCriteria copy(net.corda.core.node.services.vault.CriteriaExpression, net.corda.core.node.services.Vault$StateStatus, Set)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public Set getContractStateTypes()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression getExpression()
+  @org.jetbrains.annotations.NotNull public net.corda.core.node.services.Vault$StateStatus getStatus()
+  public int hashCode()
+  public String toString()
+  @org.jetbrains.annotations.NotNull public Collection visit(net.corda.core.node.services.vault.IQueryCriteriaParser)
+##
+public static final class net.corda.core.node.services.vault.QueryCriteria$VaultQueryCriteria extends net.corda.core.node.services.vault.QueryCriteria$CommonQueryCriteria
+  @kotlin.jvm.JvmOverloads public <init>()
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus, Set)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List, List)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List, List, net.corda.core.node.services.vault.QueryCriteria$SoftLockingCondition)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List, List, net.corda.core.node.services.vault.QueryCriteria$SoftLockingCondition, net.corda.core.node.services.vault.QueryCriteria$TimeCondition)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$StateStatus component1()
+  @org.jetbrains.annotations.Nullable public final Set component2()
+  @org.jetbrains.annotations.Nullable public final List component3()
+  @org.jetbrains.annotations.Nullable public final List component4()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.node.services.vault.QueryCriteria$SoftLockingCondition component5()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.node.services.vault.QueryCriteria$TimeCondition component6()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.QueryCriteria$VaultQueryCriteria copy(net.corda.core.node.services.Vault$StateStatus, Set, List, List, net.corda.core.node.services.vault.QueryCriteria$SoftLockingCondition, net.corda.core.node.services.vault.QueryCriteria$TimeCondition)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public Set getContractStateTypes()
+  @org.jetbrains.annotations.Nullable public final List getNotary()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.node.services.vault.QueryCriteria$SoftLockingCondition getSoftLockingCondition()
+  @org.jetbrains.annotations.Nullable public final List getStateRefs()
+  @org.jetbrains.annotations.NotNull public net.corda.core.node.services.Vault$StateStatus getStatus()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.node.services.vault.QueryCriteria$TimeCondition getTimeCondition()
+  public int hashCode()
+  public String toString()
+  @org.jetbrains.annotations.NotNull public Collection visit(net.corda.core.node.services.vault.IQueryCriteriaParser)
+##
+public final class net.corda.core.node.services.vault.QueryCriteriaUtils extends java.lang.Object
+  public static final Object builder(kotlin.jvm.functions.Function1)
+  @org.jetbrains.annotations.NotNull public static final String getColumnName(net.corda.core.node.services.vault.Column)
+  @org.jetbrains.annotations.NotNull public static final Class resolveEnclosingObjectFromColumn(net.corda.core.node.services.vault.Column)
+  @org.jetbrains.annotations.NotNull public static final Class resolveEnclosingObjectFromExpression(net.corda.core.node.services.vault.CriteriaExpression)
+  public static final int DEFAULT_PAGE_NUM = 1
+  public static final int DEFAULT_PAGE_SIZE = 200
+  public static final int MAX_PAGE_SIZE = 2147483647
+##
+public final class net.corda.core.node.services.vault.Sort extends java.lang.Object
+  public <init>(Collection)
+  @org.jetbrains.annotations.NotNull public final Collection component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.Sort copy(Collection)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final Collection getColumns()
+  public int hashCode()
+  public String toString()
+##
+public static interface net.corda.core.node.services.vault.Sort$Attribute
+##
+public static final class net.corda.core.node.services.vault.Sort$CommonStateAttribute extends java.lang.Enum implements net.corda.core.node.services.vault.Sort$Attribute
+  protected <init>(String, int, String, String)
+  @org.jetbrains.annotations.Nullable public final String getAttributeChild()
+  @org.jetbrains.annotations.NotNull public final String getAttributeParent()
+  public static net.corda.core.node.services.vault.Sort$CommonStateAttribute valueOf(String)
+  public static net.corda.core.node.services.vault.Sort$CommonStateAttribute[] values()
+##
+public static final class net.corda.core.node.services.vault.Sort$Direction extends java.lang.Enum
+  protected <init>(String, int)
+  public static net.corda.core.node.services.vault.Sort$Direction valueOf(String)
+  public static net.corda.core.node.services.vault.Sort$Direction[] values()
+##
+public static final class net.corda.core.node.services.vault.Sort$FungibleStateAttribute extends java.lang.Enum implements net.corda.core.node.services.vault.Sort$Attribute
+  protected <init>(String, int, String)
+  @org.jetbrains.annotations.NotNull public final String getAttributeName()
+  public static net.corda.core.node.services.vault.Sort$FungibleStateAttribute valueOf(String)
+  public static net.corda.core.node.services.vault.Sort$FungibleStateAttribute[] values()
+##
+public static final class net.corda.core.node.services.vault.Sort$LinearStateAttribute extends java.lang.Enum implements net.corda.core.node.services.vault.Sort$Attribute
+  protected <init>(String, int, String)
+  @org.jetbrains.annotations.NotNull public final String getAttributeName()
+  public static net.corda.core.node.services.vault.Sort$LinearStateAttribute valueOf(String)
+  public static net.corda.core.node.services.vault.Sort$LinearStateAttribute[] values()
+##
+public static final class net.corda.core.node.services.vault.Sort$SortColumn extends java.lang.Object
+  public <init>(net.corda.core.node.services.vault.SortAttribute, net.corda.core.node.services.vault.Sort$Direction)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.SortAttribute component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.Sort$Direction component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.Sort$SortColumn copy(net.corda.core.node.services.vault.SortAttribute, net.corda.core.node.services.vault.Sort$Direction)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.Sort$Direction getDirection()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.SortAttribute getSortAttribute()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.Sort$VaultStateAttribute extends java.lang.Enum implements net.corda.core.node.services.vault.Sort$Attribute
+  protected <init>(String, int, String)
+  @org.jetbrains.annotations.NotNull public final String getAttributeName()
+  public static net.corda.core.node.services.vault.Sort$VaultStateAttribute valueOf(String)
+  public static net.corda.core.node.services.vault.Sort$VaultStateAttribute[] values()
+##
+public abstract class net.corda.core.node.services.vault.SortAttribute extends java.lang.Object
+##
+public static final class net.corda.core.node.services.vault.SortAttribute$Custom extends net.corda.core.node.services.vault.SortAttribute
+  public <init>(Class, String)
+  @org.jetbrains.annotations.NotNull public final Class component1()
+  @org.jetbrains.annotations.NotNull public final String component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.SortAttribute$Custom copy(Class, String)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final Class getEntityStateClass()
+  @org.jetbrains.annotations.NotNull public final String getEntityStateColumnName()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.node.services.vault.SortAttribute$Standard extends net.corda.core.node.services.vault.SortAttribute
+  public <init>(net.corda.core.node.services.vault.Sort$Attribute)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.Sort$Attribute component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.SortAttribute$Standard copy(net.corda.core.node.services.vault.Sort$Attribute)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.Sort$Attribute getAttribute()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.schemas.CommonSchema extends java.lang.Object
+  public static final net.corda.core.schemas.CommonSchema INSTANCE
+##
+public final class net.corda.core.schemas.CommonSchemaV1 extends net.corda.core.schemas.MappedSchema
+  public static final net.corda.core.schemas.CommonSchemaV1 INSTANCE
+##
+public static class net.corda.core.schemas.CommonSchemaV1$FungibleState extends net.corda.core.schemas.PersistentState
+  public <init>(Set, net.corda.core.identity.AbstractParty, long, net.corda.core.identity.AbstractParty, byte[])
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.AbstractParty getIssuer()
+  @org.jetbrains.annotations.NotNull public final byte[] getIssuerRef()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.AbstractParty getOwner()
+  @org.jetbrains.annotations.Nullable public final Set getParticipants()
+  public final long getQuantity()
+  public final void setIssuer(net.corda.core.identity.AbstractParty)
+  public final void setIssuerRef(byte[])
+  public final void setOwner(net.corda.core.identity.AbstractParty)
+  public final void setParticipants(Set)
+  public final void setQuantity(long)
+##
+public static class net.corda.core.schemas.CommonSchemaV1$LinearState extends net.corda.core.schemas.PersistentState
+  public <init>(Set, String, UUID)
+  public <init>(net.corda.core.contracts.UniqueIdentifier, Set)
+  @org.jetbrains.annotations.Nullable public final String getExternalId()
+  @org.jetbrains.annotations.Nullable public final Set getParticipants()
+  @org.jetbrains.annotations.NotNull public final UUID getUuid()
+  public final void setExternalId(String)
+  public final void setParticipants(Set)
+  public final void setUuid(UUID)
+##
+public class net.corda.core.schemas.MappedSchema extends java.lang.Object
+  public <init>(Class, int, Iterable)
+  @org.jetbrains.annotations.NotNull public final Iterable getMappedTypes()
+  @org.jetbrains.annotations.NotNull public final String getName()
+  public final int getVersion()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public final class net.corda.core.schemas.NodeInfoSchema extends java.lang.Object
+  public static final net.corda.core.schemas.NodeInfoSchema INSTANCE
+##
+public final class net.corda.core.schemas.NodeInfoSchemaV1 extends net.corda.core.schemas.MappedSchema
+  public static final net.corda.core.schemas.NodeInfoSchemaV1 INSTANCE
+##
+public static final class net.corda.core.schemas.NodeInfoSchemaV1$DBHostAndPort extends java.lang.Object
+  public <init>()
+  public <init>(net.corda.core.schemas.NodeInfoSchemaV1$PKHostAndPort)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.schemas.NodeInfoSchemaV1$DBHostAndPort copy(net.corda.core.schemas.NodeInfoSchemaV1$PKHostAndPort)
+  public boolean equals(Object)
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.NetworkHostAndPort toHostAndPort()
+  public String toString()
+  public static final net.corda.core.schemas.NodeInfoSchemaV1$DBHostAndPort$Companion Companion
+##
+public static final class net.corda.core.schemas.NodeInfoSchemaV1$DBHostAndPort$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.schemas.NodeInfoSchemaV1$DBHostAndPort fromHostAndPort(net.corda.core.utilities.NetworkHostAndPort)
+##
+public static final class net.corda.core.schemas.NodeInfoSchemaV1$DBPartyAndCertificate extends java.lang.Object
+  public <init>()
+  public <init>(String, String, byte[], boolean, Set)
+  public <init>(net.corda.core.identity.PartyAndCertificate, boolean)
+  @org.jetbrains.annotations.NotNull public final String component1()
+  @org.jetbrains.annotations.NotNull public final String component2()
+  @org.jetbrains.annotations.NotNull public final byte[] component3()
+  public final boolean component4()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.schemas.NodeInfoSchemaV1$DBPartyAndCertificate copy(String, String, byte[], boolean, Set)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final String getName()
+  @org.jetbrains.annotations.NotNull public final String getOwningKey()
+  @org.jetbrains.annotations.NotNull public final byte[] getPartyCertBinary()
+  public int hashCode()
+  public final boolean isMain()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.PartyAndCertificate toLegalIdentityAndCert()
+  public String toString()
+##
+public static final class net.corda.core.schemas.NodeInfoSchemaV1$PKHostAndPort extends java.lang.Object implements java.io.Serializable
+  public <init>()
+  public <init>(String, Integer)
+  @org.jetbrains.annotations.Nullable public final String component1()
+  @org.jetbrains.annotations.Nullable public final Integer component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.schemas.NodeInfoSchemaV1$PKHostAndPort copy(String, Integer)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public final String getHost()
+  @org.jetbrains.annotations.Nullable public final Integer getPort()
+  public int hashCode()
+  public String toString()
+##
+public static final class net.corda.core.schemas.NodeInfoSchemaV1$PersistentNodeInfo extends java.lang.Object
+  public <init>()
+  public <init>(int, List, List, int, long)
+  @org.jetbrains.annotations.NotNull public final List getAddresses()
+  public final int getId()
+  @org.jetbrains.annotations.NotNull public final List getLegalIdentitiesAndCerts()
+  public final int getPlatformVersion()
+  public final long getSerial()
+  public final void setId(int)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.NodeInfo toNodeInfo()
+##
+public class net.corda.core.schemas.PersistentState extends java.lang.Object implements net.corda.core.schemas.StatePersistable
+  public <init>()
+  public <init>(net.corda.core.schemas.PersistentStateRef)
+  @org.jetbrains.annotations.Nullable public final net.corda.core.schemas.PersistentStateRef getStateRef()
+  public final void setStateRef(net.corda.core.schemas.PersistentStateRef)
+##
+public final class net.corda.core.schemas.PersistentStateRef extends java.lang.Object implements java.io.Serializable
+  public <init>()
+  public <init>(String, Integer)
+  public <init>(net.corda.core.contracts.StateRef)
+  @org.jetbrains.annotations.Nullable public final String component1()
+  @org.jetbrains.annotations.Nullable public final Integer component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.schemas.PersistentStateRef copy(String, Integer)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.Nullable public final Integer getIndex()
+  @org.jetbrains.annotations.Nullable public final String getTxId()
+  public int hashCode()
+  public final void setIndex(Integer)
+  public final void setTxId(String)
+  public String toString()
+##
+public interface net.corda.core.schemas.QueryableState extends net.corda.core.contracts.ContractState
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.schemas.PersistentState generateMappedObject(net.corda.core.schemas.MappedSchema)
+  @org.jetbrains.annotations.NotNull public abstract Iterable supportedSchemas()
+##
+public interface net.corda.core.schemas.StatePersistable
+##
+public interface net.corda.core.serialization.ClassWhitelist
+  public abstract boolean hasListed(Class)
+##
+public @interface net.corda.core.serialization.CordaSerializable
+##
+public @interface net.corda.core.serialization.DeprecatedConstructorForDeserialization
+  public abstract int version()
+##
+public final class net.corda.core.serialization.MissingAttachmentsException extends net.corda.core.CordaException
+  public <init>(List)
+  @org.jetbrains.annotations.NotNull public final List getIds()
+##
+public final class net.corda.core.serialization.SerializationAPIKt extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.serialization.SerializedBytes serialize(Object, net.corda.core.serialization.SerializationFactory, net.corda.core.serialization.SerializationContext)
+##
+public interface net.corda.core.serialization.SerializationContext
+  @org.jetbrains.annotations.NotNull public abstract ClassLoader getDeserializationClassLoader()
+  public abstract boolean getObjectReferencesEnabled()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.utilities.ByteSequence getPreferredSerializationVersion()
+  @org.jetbrains.annotations.NotNull public abstract Map getProperties()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializationContext$UseCase getUseCase()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.ClassWhitelist getWhitelist()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializationContext withAttachmentsClassLoader(List)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializationContext withClassLoader(ClassLoader)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializationContext withPreferredSerializationVersion(net.corda.core.utilities.ByteSequence)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializationContext withProperty(Object, Object)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializationContext withWhitelisted(Class)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializationContext withoutReferences()
+##
+public static final class net.corda.core.serialization.SerializationContext$UseCase extends java.lang.Enum
+  protected <init>(String, int)
+  public static net.corda.core.serialization.SerializationContext$UseCase valueOf(String)
+  public static net.corda.core.serialization.SerializationContext$UseCase[] values()
+##
+public interface net.corda.core.serialization.SerializationCustomization
+##
+public final class net.corda.core.serialization.SerializationDefaults extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializationContext getCHECKPOINT_CONTEXT()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializationContext getP2P_CONTEXT()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializationContext getRPC_CLIENT_CONTEXT()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializationContext getRPC_SERVER_CONTEXT()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializationFactory getSERIALIZATION_FACTORY()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializationContext getSTORAGE_CONTEXT()
+  public final void setCHECKPOINT_CONTEXT(net.corda.core.serialization.SerializationContext)
+  public final void setP2P_CONTEXT(net.corda.core.serialization.SerializationContext)
+  public final void setRPC_CLIENT_CONTEXT(net.corda.core.serialization.SerializationContext)
+  public final void setRPC_SERVER_CONTEXT(net.corda.core.serialization.SerializationContext)
+  public final void setSERIALIZATION_FACTORY(net.corda.core.serialization.SerializationFactory)
+  public final void setSTORAGE_CONTEXT(net.corda.core.serialization.SerializationContext)
+  public static final net.corda.core.serialization.SerializationDefaults INSTANCE
+##
+public abstract class net.corda.core.serialization.SerializationFactory extends java.lang.Object
+  public <init>()
+  public final Object asCurrent(kotlin.jvm.functions.Function1)
+  @org.jetbrains.annotations.NotNull public abstract Object deserialize(net.corda.core.utilities.ByteSequence, Class, net.corda.core.serialization.SerializationContext)
+  @org.jetbrains.annotations.Nullable public final net.corda.core.serialization.SerializationContext getCurrentContext()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializationContext getDefaultContext()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializedBytes serialize(Object, net.corda.core.serialization.SerializationContext)
+  public final Object withCurrentContext(net.corda.core.serialization.SerializationContext, kotlin.jvm.functions.Function0)
+  public static final net.corda.core.serialization.SerializationFactory$Companion Companion
+##
+public static final class net.corda.core.serialization.SerializationFactory$Companion extends java.lang.Object
+  @org.jetbrains.annotations.Nullable public final net.corda.core.serialization.SerializationFactory getCurrentFactory()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializationFactory getDefaultFactory()
+##
+public interface net.corda.core.serialization.SerializationToken
+  @org.jetbrains.annotations.NotNull public abstract Object fromToken(net.corda.core.serialization.SerializeAsTokenContext)
+##
+public interface net.corda.core.serialization.SerializeAsToken
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializationToken toToken(net.corda.core.serialization.SerializeAsTokenContext)
+##
+public interface net.corda.core.serialization.SerializeAsTokenContext
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.ServiceHub getServiceHub()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializeAsToken getSingleton(String)
+  public abstract void putSingleton(net.corda.core.serialization.SerializeAsToken)
+##
+public final class net.corda.core.serialization.SerializedBytes extends net.corda.core.utilities.OpaqueBytes
+  public <init>(byte[])
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getHash()
+##
+public final class net.corda.core.serialization.SingletonSerializationToken extends java.lang.Object implements net.corda.core.serialization.SerializationToken
+  @org.jetbrains.annotations.NotNull public net.corda.core.serialization.SerializeAsToken fromToken(net.corda.core.serialization.SerializeAsTokenContext)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SingletonSerializationToken registerWithContext(net.corda.core.serialization.SerializeAsTokenContext, net.corda.core.serialization.SerializeAsToken)
+  public static final net.corda.core.serialization.SingletonSerializationToken$Companion Companion
+##
+public static final class net.corda.core.serialization.SingletonSerializationToken$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SingletonSerializationToken singletonSerializationToken(Class)
+##
+public abstract class net.corda.core.serialization.SingletonSerializeAsToken extends java.lang.Object implements net.corda.core.serialization.SerializeAsToken
+  public <init>()
+  @org.jetbrains.annotations.NotNull public net.corda.core.serialization.SingletonSerializationToken toToken(net.corda.core.serialization.SerializeAsTokenContext)
+##
+public abstract class net.corda.core.transactions.BaseTransaction extends java.lang.Object implements net.corda.core.contracts.NamedByHash
+  public <init>()
+  protected void checkBaseInvariants()
+  @org.jetbrains.annotations.NotNull public final List filterOutRefs(Class, function.Predicate)
+  @org.jetbrains.annotations.NotNull public final List filterOutputs(Class, function.Predicate)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateAndRef findOutRef(Class, function.Predicate)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ContractState findOutput(Class, function.Predicate)
+  @org.jetbrains.annotations.NotNull public abstract List getInputs()
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party getNotary()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ContractState getOutput(int)
+  @org.jetbrains.annotations.NotNull public final List getOutputStates()
+  @org.jetbrains.annotations.NotNull public abstract List getOutputs()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateAndRef outRef(int)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateAndRef outRef(net.corda.core.contracts.ContractState)
+  @org.jetbrains.annotations.NotNull public final List outRefsOfType(Class)
+  @org.jetbrains.annotations.NotNull public final List outputsOfType(Class)
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public class net.corda.core.transactions.ComponentGroup extends java.lang.Object
+  public <init>(int, List)
+  @org.jetbrains.annotations.NotNull public List getComponents()
+  public int getGroupIndex()
+##
+public final class net.corda.core.transactions.ComponentVisibilityException extends net.corda.core.CordaException
+  public <init>(net.corda.core.crypto.SecureHash, String)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getId()
+  @org.jetbrains.annotations.NotNull public final String getReason()
+##
+public abstract class net.corda.core.transactions.CoreTransaction extends net.corda.core.transactions.BaseTransaction
+  public <init>()
+  @org.jetbrains.annotations.NotNull public abstract List getInputs()
+##
+public final class net.corda.core.transactions.FilteredComponentGroup extends net.corda.core.transactions.ComponentGroup
+  public <init>(int, List, List, net.corda.core.crypto.PartialMerkleTree)
+  public final int component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  @org.jetbrains.annotations.NotNull public final List component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.PartialMerkleTree component4()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.FilteredComponentGroup copy(int, List, List, net.corda.core.crypto.PartialMerkleTree)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public List getComponents()
+  public int getGroupIndex()
+  @org.jetbrains.annotations.NotNull public final List getNonces()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.PartialMerkleTree getPartialMerkleTree()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.transactions.FilteredTransaction extends net.corda.core.transactions.TraversableTransaction
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.transactions.FilteredTransaction buildFilteredTransaction(net.corda.core.transactions.WireTransaction, function.Predicate)
+  public final void checkAllComponentsVisible(net.corda.core.contracts.ComponentGroupEnum)
+  public final boolean checkWithFun(kotlin.jvm.functions.Function1)
+  @org.jetbrains.annotations.NotNull public final List getFilteredComponentGroups()
+  @org.jetbrains.annotations.NotNull public final List getGroupHashes()
+  @org.jetbrains.annotations.NotNull public net.corda.core.crypto.SecureHash getId()
+  public final void verify()
+  public static final net.corda.core.transactions.FilteredTransaction$Companion Companion
+##
+public static final class net.corda.core.transactions.FilteredTransaction$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.FilteredTransaction buildFilteredTransaction(net.corda.core.transactions.WireTransaction, function.Predicate)
+##
+public final class net.corda.core.transactions.FilteredTransactionVerificationException extends net.corda.core.CordaException
+  public <init>(net.corda.core.crypto.SecureHash, String)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getId()
+  @org.jetbrains.annotations.NotNull public final String getReason()
+##
+public abstract class net.corda.core.transactions.FullTransaction extends net.corda.core.transactions.BaseTransaction
+  public <init>()
+  protected void checkBaseInvariants()
+  @org.jetbrains.annotations.NotNull public abstract List getInputs()
+##
+public final class net.corda.core.transactions.LedgerTransaction extends net.corda.core.transactions.FullTransaction
+  public <init>(List, List, List, List, net.corda.core.crypto.SecureHash, net.corda.core.identity.Party, net.corda.core.contracts.TimeWindow, net.corda.core.contracts.PrivacySalt)
+  @org.jetbrains.annotations.NotNull public final List commandsOfType(Class)
+  @org.jetbrains.annotations.NotNull public final List component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  @org.jetbrains.annotations.NotNull public final List component3()
+  @org.jetbrains.annotations.NotNull public final List component4()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component5()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.identity.Party component6()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.contracts.TimeWindow component7()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.PrivacySalt component8()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.LedgerTransaction copy(List, List, List, List, net.corda.core.crypto.SecureHash, net.corda.core.identity.Party, net.corda.core.contracts.TimeWindow, net.corda.core.contracts.PrivacySalt)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final List filterCommands(Class, function.Predicate)
+  @org.jetbrains.annotations.NotNull public final List filterInRefs(Class, function.Predicate)
+  @org.jetbrains.annotations.NotNull public final List filterInputs(Class, function.Predicate)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Command findCommand(Class, function.Predicate)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateAndRef findInRef(Class, function.Predicate)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ContractState findInput(Class, function.Predicate)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Attachment getAttachment(int)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Attachment getAttachment(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public final List getAttachments()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Command getCommand(int)
+  @org.jetbrains.annotations.NotNull public final List getCommands()
+  @org.jetbrains.annotations.NotNull public net.corda.core.crypto.SecureHash getId()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ContractState getInput(int)
+  @org.jetbrains.annotations.NotNull public final List getInputStates()
+  @org.jetbrains.annotations.NotNull public List getInputs()
+  @org.jetbrains.annotations.Nullable public net.corda.core.identity.Party getNotary()
+  @org.jetbrains.annotations.NotNull public List getOutputs()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.PrivacySalt getPrivacySalt()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.contracts.TimeWindow getTimeWindow()
+  @org.jetbrains.annotations.NotNull public final List groupStates(Class, kotlin.jvm.functions.Function1)
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.StateAndRef inRef(int)
+  @org.jetbrains.annotations.NotNull public final List inRefsOfType(Class)
+  @org.jetbrains.annotations.NotNull public final List inputsOfType(Class)
+  public String toString()
+  public final void verify()
+##
+public static final class net.corda.core.transactions.LedgerTransaction$InOutGroup extends java.lang.Object
+  public <init>(List, List, Object)
+  @org.jetbrains.annotations.NotNull public final List component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  @org.jetbrains.annotations.NotNull public final Object component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.LedgerTransaction$InOutGroup copy(List, List, Object)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final Object getGroupingKey()
+  @org.jetbrains.annotations.NotNull public final List getInputs()
+  @org.jetbrains.annotations.NotNull public final List getOutputs()
+  public int hashCode()
+  public String toString()
+##
+public final class net.corda.core.transactions.MissingContractAttachments extends net.corda.core.flows.FlowException
+  public <init>(List)
+  @org.jetbrains.annotations.NotNull public final List getStates()
+##
+public final class net.corda.core.transactions.NotaryChangeLedgerTransaction extends net.corda.core.transactions.FullTransaction implements net.corda.core.transactions.TransactionWithSignatures
+  public <init>(List, net.corda.core.identity.Party, net.corda.core.identity.Party, net.corda.core.crypto.SecureHash, List)
+  public void checkSignaturesAreValid()
+  @org.jetbrains.annotations.NotNull public final List component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash component4()
+  @org.jetbrains.annotations.NotNull public final List component5()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.NotaryChangeLedgerTransaction copy(List, net.corda.core.identity.Party, net.corda.core.identity.Party, net.corda.core.crypto.SecureHash, List)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.crypto.SecureHash getId()
+  @org.jetbrains.annotations.NotNull public List getInputs()
+  @org.jetbrains.annotations.NotNull public List getKeyDescriptions(Set)
+  @org.jetbrains.annotations.NotNull public Set getMissingSigners()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party getNewNotary()
+  @org.jetbrains.annotations.NotNull public net.corda.core.identity.Party getNotary()
+  @org.jetbrains.annotations.NotNull public List getOutputs()
+  @org.jetbrains.annotations.NotNull public Set getRequiredSigningKeys()
+  @org.jetbrains.annotations.NotNull public List getSigs()
+  public int hashCode()
+  public String toString()
+  public void verifyRequiredSignatures()
+##
+public final class net.corda.core.transactions.NotaryChangeWireTransaction extends net.corda.core.transactions.CoreTransaction
+  public <init>(List, net.corda.core.identity.Party, net.corda.core.identity.Party)
+  @org.jetbrains.annotations.NotNull public final List component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party component3()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.NotaryChangeWireTransaction copy(List, net.corda.core.identity.Party, net.corda.core.identity.Party)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.crypto.SecureHash getId()
+  @org.jetbrains.annotations.NotNull public List getInputs()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party getNewNotary()
+  @org.jetbrains.annotations.NotNull public net.corda.core.identity.Party getNotary()
+  @org.jetbrains.annotations.NotNull public List getOutputs()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.NotaryChangeLedgerTransaction resolve(net.corda.core.node.ServiceHub, List)
+  public String toString()
+##
+public final class net.corda.core.transactions.SignedTransaction extends java.lang.Object implements net.corda.core.transactions.TransactionWithSignatures
+  public <init>(net.corda.core.serialization.SerializedBytes, List)
+  public <init>(net.corda.core.transactions.CoreTransaction, List)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.FilteredTransaction buildFilteredTransaction(function.Predicate)
+  public void checkSignaturesAreValid()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializedBytes component1()
+  @org.jetbrains.annotations.NotNull public final List component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction copy(net.corda.core.serialization.SerializedBytes, List)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.crypto.SecureHash getId()
+  @org.jetbrains.annotations.NotNull public final List getInputs()
+  @org.jetbrains.annotations.NotNull public ArrayList getKeyDescriptions(Set)
+  @org.jetbrains.annotations.NotNull public Set getMissingSigners()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.identity.Party getNotary()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.NotaryChangeWireTransaction getNotaryChangeTx()
+  @org.jetbrains.annotations.NotNull public Set getRequiredSigningKeys()
+  @org.jetbrains.annotations.NotNull public List getSigs()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.WireTransaction getTx()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializedBytes getTxBits()
+  public int hashCode()
+  public final boolean isNotaryChangeTransaction()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction plus(Collection)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction plus(net.corda.core.crypto.TransactionSignature)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.NotaryChangeLedgerTransaction resolveNotaryChangeTransaction(net.corda.core.node.ServiceHub)
+  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.LedgerTransaction toLedgerTransaction(net.corda.core.node.ServiceHub)
+  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.LedgerTransaction toLedgerTransaction(net.corda.core.node.ServiceHub, boolean)
+  @org.jetbrains.annotations.NotNull public String toString()
+  @kotlin.jvm.JvmOverloads public final void verify(net.corda.core.node.ServiceHub)
+  @kotlin.jvm.JvmOverloads public final void verify(net.corda.core.node.ServiceHub, boolean)
+  public void verifyRequiredSignatures()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction withAdditionalSignature(java.security.KeyPair, net.corda.core.crypto.SignatureMetadata)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction withAdditionalSignature(net.corda.core.crypto.TransactionSignature)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction withAdditionalSignatures(Iterable)
+  public static final net.corda.core.transactions.SignedTransaction$Companion Companion
+##
+public static final class net.corda.core.transactions.SignedTransaction$SignaturesMissingException extends java.security.SignatureException implements net.corda.core.CordaThrowable, net.corda.core.contracts.NamedByHash
+  public <init>(Set, List, net.corda.core.crypto.SecureHash)
+  public void addSuppressed(Throwable[])
+  @org.jetbrains.annotations.NotNull public final List getDescriptions()
+  @org.jetbrains.annotations.NotNull public net.corda.core.crypto.SecureHash getId()
+  @org.jetbrains.annotations.NotNull public final Set getMissing()
+  @org.jetbrains.annotations.Nullable public String getOriginalExceptionClassName()
+  @org.jetbrains.annotations.Nullable public String getOriginalMessage()
+  public void setCause(Throwable)
+  public void setMessage(String)
+  public void setOriginalExceptionClassName(String)
+##
+public class net.corda.core.transactions.TransactionBuilder extends java.lang.Object
+  public <init>()
+  public <init>(net.corda.core.identity.Party)
+  public <init>(net.corda.core.identity.Party, UUID, List, List, List, List, net.corda.core.contracts.TimeWindow, net.corda.core.contracts.PrivacySalt)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addAttachment(net.corda.core.crypto.SecureHash)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addCommand(net.corda.core.contracts.Command)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addCommand(net.corda.core.contracts.CommandData, List)
+  @org.jetbrains.annotations.NotNull public net.corda.core.transactions.TransactionBuilder addInputState(net.corda.core.contracts.StateAndRef)
+  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String)
+  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.contracts.AttachmentConstraint)
+  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party)
+  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer)
+  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer, net.corda.core.contracts.AttachmentConstraint)
+  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.TransactionState)
+  @org.jetbrains.annotations.NotNull public final List attachments()
+  @org.jetbrains.annotations.NotNull public final List commands()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder copy()
+  @org.jetbrains.annotations.NotNull protected final List getAttachments()
+  @org.jetbrains.annotations.NotNull protected final List getCommands()
+  @org.jetbrains.annotations.NotNull protected final List getInputs()
+  @org.jetbrains.annotations.NotNull public final UUID getLockId()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.identity.Party getNotary()
+  @org.jetbrains.annotations.NotNull protected final List getOutputs()
+  @org.jetbrains.annotations.NotNull protected final net.corda.core.contracts.PrivacySalt getPrivacySalt()
+  @org.jetbrains.annotations.Nullable protected final net.corda.core.contracts.TimeWindow getWindow()
+  @org.jetbrains.annotations.NotNull public final List inputStates()
+  @org.jetbrains.annotations.NotNull public final List outputStates()
+  public final void setLockId(UUID)
+  public final void setNotary(net.corda.core.identity.Party)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder setPrivacySalt(net.corda.core.contracts.PrivacySalt)
+  protected final void setPrivacySalt(net.corda.core.contracts.PrivacySalt)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder setTimeWindow(java.time.Instant, java.time.Duration)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder setTimeWindow(net.corda.core.contracts.TimeWindow)
+  protected final void setWindow(net.corda.core.contracts.TimeWindow)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.LedgerTransaction toLedgerTransaction(net.corda.core.node.ServiceHub)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction toSignedTransaction(net.corda.core.node.services.KeyManagementService, java.security.PublicKey, net.corda.core.crypto.SignatureMetadata, net.corda.core.node.ServicesForResolution)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.WireTransaction toWireTransaction(net.corda.core.node.ServicesForResolution)
+  public final void verify(net.corda.core.node.ServiceHub)
+##
+public interface net.corda.core.transactions.TransactionWithSignatures extends net.corda.core.contracts.NamedByHash
+  public abstract void checkSignaturesAreValid()
+  @org.jetbrains.annotations.NotNull public abstract List getKeyDescriptions(Set)
+  @org.jetbrains.annotations.NotNull public abstract Set getMissingSigners()
+  @org.jetbrains.annotations.NotNull public abstract Set getRequiredSigningKeys()
+  @org.jetbrains.annotations.NotNull public abstract List getSigs()
+  public abstract void verifyRequiredSignatures()
+##
+public abstract class net.corda.core.transactions.TraversableTransaction extends net.corda.core.transactions.CoreTransaction
+  public <init>(List)
+  @org.jetbrains.annotations.NotNull public final List getAttachments()
+  @org.jetbrains.annotations.NotNull public final List getAvailableComponentGroups()
+  @org.jetbrains.annotations.NotNull public final List getCommands()
+  @org.jetbrains.annotations.NotNull public List getComponentGroups()
+  @org.jetbrains.annotations.NotNull public List getInputs()
+  @org.jetbrains.annotations.Nullable public net.corda.core.identity.Party getNotary()
+  @org.jetbrains.annotations.NotNull public List getOutputs()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.contracts.TimeWindow getTimeWindow()
+##
+public final class net.corda.core.transactions.WireTransaction extends net.corda.core.transactions.TraversableTransaction
+  @kotlin.Deprecated public <init>(List, List, List, List, net.corda.core.identity.Party, net.corda.core.contracts.TimeWindow, net.corda.core.contracts.PrivacySalt)
+  public <init>(List, net.corda.core.contracts.PrivacySalt)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.FilteredTransaction buildFilteredTransaction(function.Predicate)
+  public final void checkSignature(net.corda.core.crypto.TransactionSignature)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public net.corda.core.crypto.SecureHash getId()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.MerkleTree getMerkleTree()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.PrivacySalt getPrivacySalt()
+  @org.jetbrains.annotations.NotNull public final Set getRequiredSigningKeys()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.LedgerTransaction toLedgerTransaction(kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1, kotlin.jvm.functions.Function1)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.LedgerTransaction toLedgerTransaction(net.corda.core.node.ServicesForResolution)
+  @org.jetbrains.annotations.NotNull public String toString()
+  public static final net.corda.core.transactions.WireTransaction$Companion Companion
+##
+public static final class net.corda.core.transactions.WireTransaction$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final List createComponentGroups(List, List, List, List, net.corda.core.identity.Party, net.corda.core.contracts.TimeWindow)
+##
+public final class net.corda.core.utilities.ByteArrays extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public static final byte[] parseAsHex(String)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ByteSequence sequence(byte[], int, int)
+  @org.jetbrains.annotations.NotNull public static final String toHexString(byte[])
+##
+public abstract class net.corda.core.utilities.ByteSequence extends java.lang.Object implements java.lang.Comparable
+  public int compareTo(net.corda.core.utilities.ByteSequence)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence copy()
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public abstract byte[] getBytes()
+  public abstract int getOffset()
+  public abstract int getSize()
+  public int hashCode()
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ByteSequence of(byte[])
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ByteSequence of(byte[], int)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ByteSequence of(byte[], int, int)
+  @org.jetbrains.annotations.NotNull public final java.io.ByteArrayInputStream open()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence subSequence(int, int)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence take(int)
+  @org.jetbrains.annotations.NotNull public String toString()
+  public static final net.corda.core.utilities.ByteSequence$Companion Companion
+##
+public static final class net.corda.core.utilities.ByteSequence$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence of(byte[])
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence of(byte[], int)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence of(byte[], int, int)
+##
+public final class net.corda.core.utilities.EncodingUtils extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public static final byte[] base58ToByteArray(String)
+  @org.jetbrains.annotations.NotNull public static final String base58ToRealString(String)
+  @org.jetbrains.annotations.NotNull public static final String base58toBase64(String)
+  @org.jetbrains.annotations.NotNull public static final String base58toHex(String)
+  @org.jetbrains.annotations.NotNull public static final byte[] base64ToByteArray(String)
+  @org.jetbrains.annotations.NotNull public static final String base64ToRealString(String)
+  @org.jetbrains.annotations.NotNull public static final String base64toBase58(String)
+  @org.jetbrains.annotations.NotNull public static final String base64toHex(String)
+  @org.jetbrains.annotations.NotNull public static final String hexToBase58(String)
+  @org.jetbrains.annotations.NotNull public static final String hexToBase64(String)
+  @org.jetbrains.annotations.NotNull public static final byte[] hexToByteArray(String)
+  @org.jetbrains.annotations.NotNull public static final String hexToRealString(String)
+  @org.jetbrains.annotations.NotNull public static final java.security.PublicKey parsePublicKeyBase58(String)
+  @org.jetbrains.annotations.NotNull public static final String toBase58(byte[])
+  @org.jetbrains.annotations.NotNull public static final String toBase58String(java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public static final String toBase64(byte[])
+  @org.jetbrains.annotations.NotNull public static final String toHex(byte[])
+  @org.jetbrains.annotations.NotNull public static final byte[] toSHA256Bytes(java.security.PublicKey)
+##
+public final class net.corda.core.utilities.KotlinUtilsKt extends java.lang.Object
+  public static final void debug(org.slf4j.Logger, kotlin.jvm.functions.Function0)
+  public static final int exactAdd(int, int)
+  public static final long exactAdd(long, long)
+  @org.jetbrains.annotations.NotNull public static final java.time.Duration getDays(int)
+  @org.jetbrains.annotations.NotNull public static final java.time.Duration getHours(int)
+  @org.jetbrains.annotations.NotNull public static final java.time.Duration getMillis(int)
+  @org.jetbrains.annotations.NotNull public static final java.time.Duration getMinutes(int)
+  public static final Object getOrThrow(concurrent.Future, java.time.Duration)
+  @org.jetbrains.annotations.NotNull public static final java.time.Duration getSeconds(int)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.NonEmptySet toNonEmptySet(Collection)
+  public static final void trace(org.slf4j.Logger, kotlin.jvm.functions.Function0)
+  @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.PropertyDelegate transient(kotlin.jvm.functions.Function0)
+##
+public final class net.corda.core.utilities.NetworkHostAndPort extends java.lang.Object
+  public <init>(String, int)
+  @org.jetbrains.annotations.NotNull public final String component1()
+  public final int component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.NetworkHostAndPort copy(String, int)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final String getHost()
+  public final int getPort()
+  public int hashCode()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.NetworkHostAndPort parse(String)
+  @org.jetbrains.annotations.NotNull public String toString()
+  public static final net.corda.core.utilities.NetworkHostAndPort$Companion Companion
+  @org.jetbrains.annotations.NotNull public static final String INVALID_PORT_FORMAT = "Invalid port: %s"
+  @org.jetbrains.annotations.NotNull public static final String MISSING_PORT_FORMAT = "Missing port: %s"
+  @org.jetbrains.annotations.NotNull public static final String UNPARSEABLE_ADDRESS_FORMAT = "Unparseable address: %s"
+##
+public static final class net.corda.core.utilities.NetworkHostAndPort$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.NetworkHostAndPort parse(String)
+##
+public final class net.corda.core.utilities.NonEmptySet extends java.lang.Object implements kotlin.jvm.internal.markers.KMappedMarker, java.util.Set
+  public boolean add(Object)
+  public boolean addAll(Collection)
+  public void clear()
+  public boolean contains(Object)
+  public boolean containsAll(Collection)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.NonEmptySet copyOf(Collection)
+  public boolean equals(Object)
+  public void forEach(function.Consumer)
+  public int getSize()
+  public int hashCode()
+  public final Object head()
+  public boolean isEmpty()
+  @org.jetbrains.annotations.NotNull public Iterator iterator()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.NonEmptySet of(Object)
+  @org.jetbrains.annotations.NotNull public stream.Stream parallelStream()
+  public boolean remove(Object)
+  public boolean removeAll(Collection)
+  public boolean retainAll(Collection)
+  @org.jetbrains.annotations.NotNull public Spliterator spliterator()
+  @org.jetbrains.annotations.NotNull public stream.Stream stream()
+  public Object[] toArray()
+  public Object[] toArray(Object[])
+  @org.jetbrains.annotations.NotNull public String toString()
+  public static final net.corda.core.utilities.NonEmptySet$Companion Companion
+##
+public static final class net.corda.core.utilities.NonEmptySet$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.NonEmptySet copyOf(Collection)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.NonEmptySet of(Object)
+##
+public static final class net.corda.core.utilities.NonEmptySet$iterator$1 extends java.lang.Object implements java.util.Iterator, kotlin.jvm.internal.markers.KMappedMarker
+  public boolean hasNext()
+  public Object next()
+  public void remove()
+##
+public class net.corda.core.utilities.OpaqueBytes extends net.corda.core.utilities.ByteSequence
+  public <init>(byte[])
+  @org.jetbrains.annotations.NotNull public byte[] getBytes()
+  public int getOffset()
+  public int getSize()
+  public static final net.corda.core.utilities.OpaqueBytes$Companion Companion
+##
+public static final class net.corda.core.utilities.OpaqueBytes$Companion extends java.lang.Object
+##
+public final class net.corda.core.utilities.OpaqueBytesSubSequence extends net.corda.core.utilities.ByteSequence
+  public <init>(byte[], int, int)
+  @org.jetbrains.annotations.NotNull public byte[] getBytes()
+  public int getOffset()
+  public int getSize()
+##
+public final class net.corda.core.utilities.ProgressTracker extends java.lang.Object
+  public final void endWithError(Throwable)
+  @org.jetbrains.annotations.NotNull public final List getAllSteps()
+  @org.jetbrains.annotations.NotNull public final rx.Observable getChanges()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.utilities.ProgressTracker getChildProgressTracker(net.corda.core.utilities.ProgressTracker$Step)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Step getCurrentStep()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Step getCurrentStepRecursive()
+  public final boolean getHasEnded()
+  @org.jetbrains.annotations.Nullable public final net.corda.core.utilities.ProgressTracker getParent()
+  public final int getStepIndex()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Step[] getSteps()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker getTopLevelTracker()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Step nextStep()
+  public final void setChildProgressTracker(net.corda.core.utilities.ProgressTracker$Step, net.corda.core.utilities.ProgressTracker)
+  public final void setCurrentStep(net.corda.core.utilities.ProgressTracker$Step)
+##
+public abstract static class net.corda.core.utilities.ProgressTracker$Change extends java.lang.Object
+##
+public static final class net.corda.core.utilities.ProgressTracker$Change$Position extends net.corda.core.utilities.ProgressTracker$Change
+  public <init>(net.corda.core.utilities.ProgressTracker, net.corda.core.utilities.ProgressTracker$Step)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Step component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Change$Position copy(net.corda.core.utilities.ProgressTracker, net.corda.core.utilities.ProgressTracker$Step)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Step getNewStep()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker getTracker()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public static final class net.corda.core.utilities.ProgressTracker$Change$Rendering extends net.corda.core.utilities.ProgressTracker$Change
+  public <init>(net.corda.core.utilities.ProgressTracker, net.corda.core.utilities.ProgressTracker$Step)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Step component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Change$Rendering copy(net.corda.core.utilities.ProgressTracker, net.corda.core.utilities.ProgressTracker$Step)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Step getOfStep()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker getTracker()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public static final class net.corda.core.utilities.ProgressTracker$Change$Structural extends net.corda.core.utilities.ProgressTracker$Change
+  public <init>(net.corda.core.utilities.ProgressTracker, net.corda.core.utilities.ProgressTracker$Step)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Step component2()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Change$Structural copy(net.corda.core.utilities.ProgressTracker, net.corda.core.utilities.ProgressTracker$Step)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker$Step getParent()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ProgressTracker getTracker()
+  public int hashCode()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public static final class net.corda.core.utilities.ProgressTracker$DONE extends net.corda.core.utilities.ProgressTracker$Step
+  public boolean equals(Object)
+  public static final net.corda.core.utilities.ProgressTracker$DONE INSTANCE
+##
+public static class net.corda.core.utilities.ProgressTracker$Step extends java.lang.Object
+  public <init>(String)
+  @org.jetbrains.annotations.Nullable public net.corda.core.utilities.ProgressTracker childProgressTracker()
+  @org.jetbrains.annotations.NotNull public rx.Observable getChanges()
+  @org.jetbrains.annotations.NotNull public Map getExtraAuditData()
+  @org.jetbrains.annotations.NotNull public String getLabel()
+##
+public static final class net.corda.core.utilities.ProgressTracker$UNSTARTED extends net.corda.core.utilities.ProgressTracker$Step
+  public boolean equals(Object)
+  public static final net.corda.core.utilities.ProgressTracker$UNSTARTED INSTANCE
+##
+public interface net.corda.core.utilities.PropertyDelegate
+  public abstract Object getValue(Object, kotlin.reflect.KProperty)
+##
+public abstract class net.corda.core.utilities.Try extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.Try combine(net.corda.core.utilities.Try, kotlin.jvm.functions.Function2)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.Try flatMap(kotlin.jvm.functions.Function1)
+  public abstract Object getOrThrow()
+  public abstract boolean isFailure()
+  public abstract boolean isSuccess()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.Try map(kotlin.jvm.functions.Function1)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.Try on(kotlin.jvm.functions.Function0)
+  public static final net.corda.core.utilities.Try$Companion Companion
+##
+public static final class net.corda.core.utilities.Try$Companion extends java.lang.Object
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.Try on(kotlin.jvm.functions.Function0)
+##
+public static final class net.corda.core.utilities.Try$Failure extends net.corda.core.utilities.Try
+  public <init>(Throwable)
+  @org.jetbrains.annotations.NotNull public final Throwable component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.Try$Failure copy(Throwable)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final Throwable getException()
+  public Object getOrThrow()
+  public int hashCode()
+  public boolean isFailure()
+  public boolean isSuccess()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public static final class net.corda.core.utilities.Try$Success extends net.corda.core.utilities.Try
+  public <init>(Object)
+  public final Object component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.Try$Success copy(Object)
+  public boolean equals(Object)
+  public Object getOrThrow()
+  public final Object getValue()
+  public int hashCode()
+  public boolean isFailure()
+  public boolean isSuccess()
+  @org.jetbrains.annotations.NotNull public String toString()
+##
+public final class net.corda.core.utilities.UntrustworthyData extends java.lang.Object
+  public <init>(Object)
+  public final Object getFromUntrustedWorld()
+  @co.paralleluniverse.fibers.Suspendable public final Object unwrap(net.corda.core.utilities.UntrustworthyData$Validator)
+##
+public static interface net.corda.core.utilities.UntrustworthyData$Validator extends java.io.Serializable
+  @co.paralleluniverse.fibers.Suspendable public abstract Object validate(Object)
+##
+public final class net.corda.core.utilities.UntrustworthyDataKt extends java.lang.Object
+  public static final Object unwrap(net.corda.core.utilities.UntrustworthyData, kotlin.jvm.functions.Function1)
+##
+public interface net.corda.core.utilities.VariablePropertyDelegate extends net.corda.core.utilities.PropertyDelegate
+  public abstract void setValue(Object, kotlin.reflect.KProperty, Object)
+##
+public final class net.corda.client.jackson.JacksonSupport extends java.lang.Object
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createDefaultMapper(net.corda.core.messaging.CordaRPCOps)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createDefaultMapper(net.corda.core.messaging.CordaRPCOps, com.fasterxml.jackson.core.JsonFactory)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createDefaultMapper(net.corda.core.messaging.CordaRPCOps, com.fasterxml.jackson.core.JsonFactory, boolean)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createInMemoryMapper(net.corda.core.node.services.IdentityService)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createInMemoryMapper(net.corda.core.node.services.IdentityService, com.fasterxml.jackson.core.JsonFactory)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createInMemoryMapper(net.corda.core.node.services.IdentityService, com.fasterxml.jackson.core.JsonFactory, boolean)
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createNonRpcMapper()
+  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createNonRpcMapper(com.fasterxml.jackson.core.JsonFactory)
+  @org.jetbrains.annotations.NotNull public final com.fasterxml.jackson.databind.Module getCordaModule()
+  public static final net.corda.client.jackson.JacksonSupport INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$AmountDeserializer extends com.fasterxml.jackson.databind.JsonDeserializer
+  @org.jetbrains.annotations.NotNull public net.corda.core.contracts.Amount deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
+  public static final net.corda.client.jackson.JacksonSupport$AmountDeserializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$AmountSerializer extends com.fasterxml.jackson.databind.JsonSerializer
+  public void serialize(net.corda.core.contracts.Amount, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider)
+  public static final net.corda.client.jackson.JacksonSupport$AmountSerializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$AnonymousPartyDeserializer extends com.fasterxml.jackson.databind.JsonDeserializer
+  @org.jetbrains.annotations.NotNull public net.corda.core.identity.AnonymousParty deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
+  public static final net.corda.client.jackson.JacksonSupport$AnonymousPartyDeserializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$AnonymousPartySerializer extends com.fasterxml.jackson.databind.JsonSerializer
+  public void serialize(net.corda.core.identity.AnonymousParty, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider)
+  public static final net.corda.client.jackson.JacksonSupport$AnonymousPartySerializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$CordaX500NameDeserializer extends com.fasterxml.jackson.databind.JsonDeserializer
+  @org.jetbrains.annotations.NotNull public net.corda.core.identity.CordaX500Name deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
+  public static final net.corda.client.jackson.JacksonSupport$CordaX500NameDeserializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$CordaX500NameSerializer extends com.fasterxml.jackson.databind.JsonSerializer
+  public void serialize(net.corda.core.identity.CordaX500Name, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider)
+  public static final net.corda.client.jackson.JacksonSupport$CordaX500NameSerializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$IdentityObjectMapper extends com.fasterxml.jackson.databind.ObjectMapper implements net.corda.client.jackson.JacksonSupport$PartyObjectMapper
+  public <init>(net.corda.core.node.services.IdentityService, com.fasterxml.jackson.core.JsonFactory, boolean)
+  public final boolean getFuzzyIdentityMatch()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.IdentityService getIdentityService()
+  @org.jetbrains.annotations.NotNull public Set partiesFromName(String)
+  @org.jetbrains.annotations.Nullable public net.corda.core.identity.Party partyFromKey(java.security.PublicKey)
+  @org.jetbrains.annotations.Nullable public net.corda.core.identity.Party wellKnownPartyFromX500Name(net.corda.core.identity.CordaX500Name)
+##
+public static final class net.corda.client.jackson.JacksonSupport$NoPartyObjectMapper extends com.fasterxml.jackson.databind.ObjectMapper implements net.corda.client.jackson.JacksonSupport$PartyObjectMapper
+  public <init>(com.fasterxml.jackson.core.JsonFactory)
+  @org.jetbrains.annotations.NotNull public Void partiesFromName(String)
+  @org.jetbrains.annotations.Nullable public net.corda.core.identity.Party partyFromKey(java.security.PublicKey)
+  @org.jetbrains.annotations.Nullable public net.corda.core.identity.Party wellKnownPartyFromX500Name(net.corda.core.identity.CordaX500Name)
+##
+public static final class net.corda.client.jackson.JacksonSupport$NodeInfoDeserializer extends com.fasterxml.jackson.databind.JsonDeserializer
+  @org.jetbrains.annotations.NotNull public net.corda.core.node.NodeInfo deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
+  public static final net.corda.client.jackson.JacksonSupport$NodeInfoDeserializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$NodeInfoSerializer extends com.fasterxml.jackson.databind.JsonSerializer
+  public void serialize(net.corda.core.node.NodeInfo, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider)
+  public static final net.corda.client.jackson.JacksonSupport$NodeInfoSerializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$OpaqueBytesDeserializer extends com.fasterxml.jackson.databind.JsonDeserializer
+  @org.jetbrains.annotations.NotNull public net.corda.core.utilities.OpaqueBytes deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
+  public static final net.corda.client.jackson.JacksonSupport$OpaqueBytesDeserializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$OpaqueBytesSerializer extends com.fasterxml.jackson.databind.JsonSerializer
+  public void serialize(net.corda.core.utilities.OpaqueBytes, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider)
+  public static final net.corda.client.jackson.JacksonSupport$OpaqueBytesSerializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$PartyDeserializer extends com.fasterxml.jackson.databind.JsonDeserializer
+  @org.jetbrains.annotations.NotNull public net.corda.core.identity.Party deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
+  public static final net.corda.client.jackson.JacksonSupport$PartyDeserializer INSTANCE
+##
+public static interface net.corda.client.jackson.JacksonSupport$PartyObjectMapper
+  @org.jetbrains.annotations.NotNull public abstract Set partiesFromName(String)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party partyFromKey(java.security.PublicKey)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party wellKnownPartyFromX500Name(net.corda.core.identity.CordaX500Name)
+##
+public static final class net.corda.client.jackson.JacksonSupport$PartySerializer extends com.fasterxml.jackson.databind.JsonSerializer
+  public void serialize(net.corda.core.identity.Party, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider)
+  public static final net.corda.client.jackson.JacksonSupport$PartySerializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$PublicKeyDeserializer extends com.fasterxml.jackson.databind.JsonDeserializer
+  @org.jetbrains.annotations.NotNull public java.security.PublicKey deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
+  public static final net.corda.client.jackson.JacksonSupport$PublicKeyDeserializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$PublicKeySerializer extends com.fasterxml.jackson.databind.JsonSerializer
+  public void serialize(java.security.PublicKey, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider)
+  public static final net.corda.client.jackson.JacksonSupport$PublicKeySerializer INSTANCE
+##
+public static final class net.corda.client.jackson.JacksonSupport$RpcObjectMapper extends com.fasterxml.jackson.databind.ObjectMapper implements net.corda.client.jackson.JacksonSupport$PartyObjectMapper
+  public <init>(net.corda.core.messaging.CordaRPCOps, com.fasterxml.jackson.core.JsonFactory, boolean)
+  public final boolean getFuzzyIdentityMatch()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.messaging.CordaRPCOps getRpc()
+  @org.jetbrains.annotations.NotNull public Set partiesFromName(String)
+  @org.jetbrains.annotations.Nullable public net.corda.core.identity.Party partyFromKey(java.security.PublicKey)
+  @org.jetbrains.annotations.Nullable public net.corda.core.identity.Party wellKnownPartyFromX500Name(net.corda.core.identity.CordaX500Name)
+##
+public static final class net.corda.client.jackson.JacksonSupport$SecureHashDeserializer extends com.fasterxml.jackson.databind.JsonDeserializer
+  public <init>()
+  @org.jetbrains.annotations.NotNull public net.corda.core.crypto.SecureHash deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
+##
+public static final class net.corda.client.jackson.JacksonSupport$SecureHashSerializer extends com.fasterxml.jackson.databind.JsonSerializer
+  public void serialize(net.corda.core.crypto.SecureHash, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider)
+  public static final net.corda.client.jackson.JacksonSupport$SecureHashSerializer INSTANCE
+##
+public abstract static class net.corda.client.jackson.JacksonSupport$SignedTransactionMixin extends java.lang.Object
+  public <init>()
+  @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.SecureHash getId()
+  @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.NotNull public abstract List getInputs()
+  @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party getNotary()
+  @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.NotNull public abstract net.corda.core.transactions.NotaryChangeWireTransaction getNotaryChangeTx()
+  @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.NotNull public abstract Set getRequiredSigningKeys()
+  @com.fasterxml.jackson.annotation.JsonProperty @org.jetbrains.annotations.NotNull protected abstract List getSigs()
+  @com.fasterxml.jackson.annotation.JsonProperty @org.jetbrains.annotations.NotNull protected abstract net.corda.core.transactions.CoreTransaction getTransaction()
+  @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.NotNull public abstract net.corda.core.transactions.WireTransaction getTx()
+  @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializedBytes getTxBits()
+##
+public static final class net.corda.client.jackson.JacksonSupport$ToStringSerializer extends com.fasterxml.jackson.databind.JsonSerializer
+  public void serialize(Object, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider)
+  public static final net.corda.client.jackson.JacksonSupport$ToStringSerializer INSTANCE
+##
+public abstract static class net.corda.client.jackson.JacksonSupport$WireTransactionMixin extends java.lang.Object
+  public <init>()
+  @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.NotNull public abstract List getAvailableComponentHashes()
+  @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.NotNull public abstract List getAvailableComponents()
+  @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.NotNull public abstract net.corda.core.crypto.MerkleTree getMerkleTree()
+  @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.NotNull public abstract List getOutputStates()
+##
+public class net.corda.client.jackson.StringToMethodCallParser extends java.lang.Object
+  @kotlin.jvm.JvmOverloads public <init>(Class)
+  @kotlin.jvm.JvmOverloads public <init>(Class, com.fasterxml.jackson.databind.ObjectMapper)
+  public <init>(kotlin.reflect.KClass)
+  @org.jetbrains.annotations.NotNull public final Map getAvailableCommands()
+  @org.jetbrains.annotations.NotNull protected final com.google.common.collect.Multimap getMethodMap()
+  @org.jetbrains.annotations.NotNull public final Map getMethodParamNames()
+  @org.jetbrains.annotations.NotNull public List paramNamesFromConstructor(reflect.Constructor)
+  @org.jetbrains.annotations.NotNull public List paramNamesFromMethod(reflect.Method)
+  @org.jetbrains.annotations.NotNull public final net.corda.client.jackson.StringToMethodCallParser$ParsedMethodCall parse(Object, String)
+  @org.jetbrains.annotations.NotNull public final Object[] parseArguments(String, List, String)
+  public static final net.corda.client.jackson.StringToMethodCallParser$Companion Companion
+##
+public static final class net.corda.client.jackson.StringToMethodCallParser$Companion extends java.lang.Object
+##
+public final class net.corda.client.jackson.StringToMethodCallParser$ParsedMethodCall extends java.lang.Object implements java.util.concurrent.Callable
+  public <init>(net.corda.client.jackson.StringToMethodCallParser, Object, reflect.Method, Object[])
+  @org.jetbrains.annotations.Nullable public Object call()
+  @org.jetbrains.annotations.NotNull public final Object[] getArgs()
+  @org.jetbrains.annotations.NotNull public final reflect.Method getMethod()
+  @org.jetbrains.annotations.Nullable public final Object invoke()
+##
+public static class net.corda.client.jackson.StringToMethodCallParser$UnparseableCallException extends net.corda.core.CordaException
+  public <init>(String, Throwable)
+##
+public static final class net.corda.client.jackson.StringToMethodCallParser$UnparseableCallException$FailedParse extends net.corda.client.jackson.StringToMethodCallParser$UnparseableCallException
+  public <init>(Exception)
+##
+public static final class net.corda.client.jackson.StringToMethodCallParser$UnparseableCallException$MissingParameter extends net.corda.client.jackson.StringToMethodCallParser$UnparseableCallException
+  public <init>(String, String, String)
+  @org.jetbrains.annotations.NotNull public final String getParamName()
+##
+public static final class net.corda.client.jackson.StringToMethodCallParser$UnparseableCallException$ReflectionDataMissing extends net.corda.client.jackson.StringToMethodCallParser$UnparseableCallException
+  public <init>(String, int)
+##
+public static final class net.corda.client.jackson.StringToMethodCallParser$UnparseableCallException$TooManyParameters extends net.corda.client.jackson.StringToMethodCallParser$UnparseableCallException
+  public <init>(String, String)
+##
+public static final class net.corda.client.jackson.StringToMethodCallParser$UnparseableCallException$UnknownMethod extends net.corda.client.jackson.StringToMethodCallParser$UnparseableCallException
+  public <init>(String)
+  @org.jetbrains.annotations.NotNull public final String getMethodName()
+##
+public final class net.corda.client.rpc.CordaRPCClient extends java.lang.Object
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.utilities.NetworkHostAndPort)
+  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.utilities.NetworkHostAndPort, net.corda.client.rpc.CordaRPCClientConfiguration)
+  @org.jetbrains.annotations.NotNull public final net.corda.client.rpc.CordaRPCConnection start(String, String)
+  public final Object use(String, String, kotlin.jvm.functions.Function1)
+##
+public final class net.corda.client.rpc.CordaRPCClientConfiguration extends java.lang.Object
+  public <init>(java.time.Duration)
+  @org.jetbrains.annotations.NotNull public final java.time.Duration component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.client.rpc.CordaRPCClientConfiguration copy(java.time.Duration)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final java.time.Duration getConnectionMaxRetryInterval()
+  public int hashCode()
+  public String toString()
+  public static final net.corda.client.rpc.CordaRPCClientConfiguration$Companion Companion
+  @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final net.corda.client.rpc.CordaRPCClientConfiguration DEFAULT
+##
+public static final class net.corda.client.rpc.CordaRPCClientConfiguration$Companion extends java.lang.Object
+##
+public final class net.corda.client.rpc.CordaRPCConnection extends java.lang.Object implements net.corda.client.rpc.RPCConnection
+  public <init>(net.corda.client.rpc.RPCConnection)
+  public void close()
+  public void forceClose()
+  @org.jetbrains.annotations.NotNull public net.corda.core.messaging.CordaRPCOps getProxy()
+  public int getServerProtocolVersion()
+  public void notifyServerAndClose()
+##
+public final class net.corda.client.rpc.PermissionException extends net.corda.core.CordaRuntimeException
+  public <init>(String)
+##
+public interface net.corda.client.rpc.RPCConnection extends java.io.Closeable
+  public abstract void forceClose()
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.RPCOps getProxy()
+  public abstract int getServerProtocolVersion()
+  public abstract void notifyServerAndClose()
+##
+public class net.corda.client.rpc.RPCException extends net.corda.core.CordaRuntimeException
+  public <init>(String)
+  public <init>(String, Throwable)
+##
+public @interface net.corda.client.rpc.RPCSinceVersion
+  public abstract int version()
+##
+public final class net.corda.client.rpc.UtilsKt extends java.lang.Object
+  public static final void notUsed(rx.Observable)
+##

From 659b447362898ca6d42d4a9f712c6b53cfef4d60 Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Fri, 29 Sep 2017 17:18:06 +0100
Subject: [PATCH 064/185] V1 tests and fixes for the ContractConstraints work
 (#1739)

* V1 tests and fixes for the ContractConstraints work

* More fixes.
---
 .../net/corda/core/flows/FlowLogicRef.kt      | 14 +---
 .../contracts/isolated/IsolatedDummyFlow.kt   |  2 +-
 .../node/services/AttachmentLoadingTests.kt   | 83 ++++++++++++-------
 .../net/corda/node/internal/AbstractNode.kt   |  9 +-
 .../statemachine/FlowLogicRefFactoryImpl.kt   | 13 +--
 .../statemachine/StateMachineManager.kt       | 12 ++-
 6 files changed, 73 insertions(+), 60 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/flows/FlowLogicRef.kt b/core/src/main/kotlin/net/corda/core/flows/FlowLogicRef.kt
index 3f9996c081..0b90909180 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FlowLogicRef.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FlowLogicRef.kt
@@ -24,16 +24,4 @@ class IllegalFlowLogicException(type: Class<*>, msg: String) : IllegalArgumentEx
  */
 // TODO: align this with the existing [FlowRef] in the bank-side API (probably replace some of the API classes)
 @CordaSerializable
-interface FlowLogicRef
-
-
-/**
- * This is just some way to track what attachments need to be in the class loader, but may later include some app
- * properties loaded from the attachments.  And perhaps the authenticated user for an API call?
- */
-@CordaSerializable
-data class AppContext(val attachments: List<SecureHash>) {
-    // TODO: build a real [AttachmentsClassLoader] etc
-    val classLoader: ClassLoader
-        get() = this.javaClass.classLoader
-}
+interface FlowLogicRef
\ No newline at end of file
diff --git a/finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedDummyFlow.kt b/finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedDummyFlow.kt
index 855c06cea4..97c35c2af3 100644
--- a/finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedDummyFlow.kt
+++ b/finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedDummyFlow.kt
@@ -31,4 +31,4 @@ class IsolatedDummyFlow {
             stx.verify(serviceHub)
         }
     }
-}
\ No newline at end of file
+}
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
index 353203e557..0d6bc46545 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@@ -1,10 +1,12 @@
 package net.corda.node.services
 
 import net.corda.client.rpc.RPCException
+import net.corda.core.concurrent.CordaFuture
 import net.corda.core.contracts.Contract
 import net.corda.core.contracts.PartyAndReference
 import net.corda.core.cordapp.CordappProvider
 import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.UnexpectedFlowEndException
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.internal.concurrent.transpose
@@ -16,12 +18,18 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.loggerFor
+import net.corda.node.internal.StartedNode
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
+import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.User
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.DUMMY_BANK_A
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.TestDependencyInjectionBase
+import net.corda.testing.driver.DriverDSL
+import net.corda.testing.driver.DriverDSLExposedInterface
+import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.driver
 import net.corda.testing.node.MockServices
 import net.corda.testing.resetTestSerialization
@@ -30,6 +38,8 @@ import org.junit.Before
 import org.junit.Test
 import java.net.URLClassLoader
 import java.nio.file.Files
+import java.sql.Driver
+import kotlin.test.assertFails
 import kotlin.test.assertFailsWith
 
 class AttachmentLoadingTests : TestDependencyInjectionBase() {
@@ -45,6 +55,13 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
         val logger = loggerFor<AttachmentLoadingTests>()
         val isolatedJAR = AttachmentLoadingTests::class.java.getResource("isolated.jar")!!
         val ISOLATED_CONTRACT_ID = "net.corda.finance.contracts.isolated.AnotherDummyContract"
+
+        val bankAName = CordaX500Name("BankA", "Zurich", "CH")
+        val bankBName = CordaX500Name("BankB", "Zurich", "CH")
+        val notaryName = CordaX500Name("Notary", "Zurich", "CH")
+        val flowInitiatorClass =
+                Class.forName("net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Initiator", true, URLClassLoader(arrayOf(isolatedJAR)))
+                        .asSubclass(FlowLogic::class.java)
     }
 
     private lateinit var services: Services
@@ -75,40 +92,42 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
     @Test
     fun `test that attachments retrieved over the network are not used for code`() {
         driver(initialiseSerialization = false) {
-            val bankAName = CordaX500Name("BankA", "Zurich", "CH")
-            val bankBName = CordaX500Name("BankB", "Zurich", "CH")
-            // Copy the app jar to the first node. The second won't have it.
-            val path = (baseDirectory(bankAName.toString()) / "plugins").createDirectories() / "isolated.jar"
-            logger.info("Installing isolated jar to $path")
-            isolatedJAR.openStream().buffered().use { input ->
-                Files.newOutputStream(path).buffered().use { output ->
-                    input.copyTo(output)
-                }
-            }
+            installIsolatedCordappTo(bankAName)
+            val (bankA, bankB, _) = createTwoNodesAndNotary()
 
-            val admin = User("admin", "admin", permissions = setOf("ALL"))
-            val (bankA, bankB) = listOf(
-                    startNode(providedName = bankAName, rpcUsers = listOf(admin)),
-                    startNode(providedName = bankBName, rpcUsers = listOf(admin))
-            ).transpose().getOrThrow()   // Wait for all nodes to start up.
-
-            val clazz =
-                    Class.forName("net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Initiator", true, URLClassLoader(arrayOf(isolatedJAR)))
-                            .asSubclass(FlowLogic::class.java)
-
-            try {
-                bankA.rpcClientToNode().start("admin", "admin").use { rpc ->
-                    val proxy = rpc.proxy
-                    val party = proxy.wellKnownPartyFromX500Name(bankBName)!!
-
-                    assertFailsWith<RPCException>("net.corda.client.rpc.RPCException: net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Initiator") {
-                        proxy.startFlowDynamic(clazz, party).returnValue.getOrThrow()
-                    }
-                }
-            } finally {
-                bankA.stop()
-                bankB.stop()
+            assertFailsWith<UnexpectedFlowEndException>("Party C=CH,L=Zurich,O=BankB rejected session request: Don't know net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Initiator") {
+                bankA.rpc.startFlowDynamic(flowInitiatorClass, bankB.nodeInfo.legalIdentities.first()).returnValue.getOrThrow()
             }
         }
     }
+
+    @Test
+    fun `tests that if the attachment is loaded on both sides already that a flow can run`() {
+        driver(initialiseSerialization = false) {
+            installIsolatedCordappTo(bankAName)
+            installIsolatedCordappTo(bankBName)
+            val (bankA, bankB, _) = createTwoNodesAndNotary()
+            bankA.rpc.startFlowDynamic(flowInitiatorClass, bankB.nodeInfo.legalIdentities.first()).returnValue.getOrThrow()
+        }
+    }
+
+    private fun DriverDSLExposedInterface.installIsolatedCordappTo(nodeName: CordaX500Name) {
+        // Copy the app jar to the first node. The second won't have it.
+        val path = (baseDirectory(nodeName.toString()) / "plugins").createDirectories() / "isolated.jar"
+        logger.info("Installing isolated jar to $path")
+        isolatedJAR.openStream().buffered().use { input ->
+            Files.newOutputStream(path).buffered().use { output ->
+                input.copyTo(output)
+            }
+        }
+    }
+
+    private fun DriverDSLExposedInterface.createTwoNodesAndNotary(): List<NodeHandle> {
+        val adminUser = User("admin", "admin", permissions = setOf("ALL"))
+        return listOf(
+                startNode(providedName = bankAName, rpcUsers = listOf(adminUser)),
+                startNode(providedName = bankBName, rpcUsers = listOf(adminUser)),
+                startNode(providedName = notaryName, rpcUsers = listOf(adminUser), advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
+        ).transpose().getOrThrow()   // Wait for all nodes to start up.
+    }
 }
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index f0711e97a7..9aacb16a83 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -58,10 +58,7 @@ import net.corda.node.services.persistence.DBTransactionStorage
 import net.corda.node.services.persistence.NodeAttachmentService
 import net.corda.node.services.schema.HibernateObserver
 import net.corda.node.services.schema.NodeSchemaService
-import net.corda.node.services.statemachine.FlowStateMachineImpl
-import net.corda.node.services.statemachine.StateMachineManager
-import net.corda.node.services.statemachine.appName
-import net.corda.node.services.statemachine.flowVersionAndInitiatingClass
+import net.corda.node.services.statemachine.*
 import net.corda.node.services.transactions.*
 import net.corda.node.services.upgrade.ContractUpgradeServiceImpl
 import net.corda.node.services.vault.NodeVaultService
@@ -190,7 +187,8 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
                     checkpointStorage,
                     serverThread,
                     database,
-                    busyNodeLatch)
+                    busyNodeLatch,
+                    cordappLoader.appClassLoader)
 
             smm.tokenizableServices.addAll(tokenizableServices)
 
@@ -213,6 +211,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
             registerCordappFlows()
             _services.rpcFlows += cordappProvider.cordapps.flatMap { it.rpcFlows }
             registerCustomSchemas(cordappProvider.cordapps.flatMap { it.customSchemas }.toSet())
+            FlowLogicRefFactoryImpl.classloader = cordappLoader.appClassLoader
 
             runOnStop += network::stop
             StartedNodeImpl(this, _services, info, checkpointStorage, smm, attachments, inNodeNetworkMapService, network, database, rpcOps)
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowLogicRefFactoryImpl.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowLogicRefFactoryImpl.kt
index 6d16a94db5..a3c36fa3a4 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowLogicRefFactoryImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowLogicRefFactoryImpl.kt
@@ -2,6 +2,7 @@ package net.corda.node.services.statemachine
 
 import net.corda.core.internal.VisibleForTesting
 import com.google.common.primitives.Primitives
+import net.corda.core.cordapp.CordappContext
 import net.corda.core.flows.*
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.serialization.SingletonSerializeAsToken
@@ -17,7 +18,7 @@ import kotlin.reflect.jvm.javaType
  * The internal concrete implementation of the FlowLogicRef marker interface.
  */
 @CordaSerializable
-data class FlowLogicRefImpl internal constructor(val flowLogicClassName: String, val appContext: AppContext, val args: Map<String, Any?>) : FlowLogicRef
+data class FlowLogicRefImpl internal constructor(val flowLogicClassName: String, val args: Map<String, Any?>) : FlowLogicRef
 
 /**
  * A class for conversion to and from [FlowLogic] and [FlowLogicRef] instances.
@@ -32,6 +33,9 @@ data class FlowLogicRefImpl internal constructor(val flowLogicClassName: String,
  * in response to a potential malicious use or buggy update to an app etc.
  */
 object FlowLogicRefFactoryImpl : SingletonSerializeAsToken(), FlowLogicRefFactory {
+    // TODO: Replace with a per app classloader/cordapp provider/cordapp loader - this will do for now
+    var classloader = javaClass.classLoader
+
     override fun create(flowClass: Class<out FlowLogic<*>>, vararg args: Any?): FlowLogicRef {
         if (!flowClass.isAnnotationPresent(SchedulableFlow::class.java)) {
             throw IllegalFlowLogicException(flowClass, "because it's not a schedulable flow")
@@ -73,17 +77,14 @@ object FlowLogicRefFactoryImpl : SingletonSerializeAsToken(), FlowLogicRefFactor
      */
     @VisibleForTesting
     internal fun createKotlin(type: Class<out FlowLogic<*>>, args: Map<String, Any?>): FlowLogicRef {
-        // TODO: we need to capture something about the class loader or "application context" into the ref,
-        //       perhaps as some sort of ThreadLocal style object.  For now, just create an empty one.
-        val appContext = AppContext(emptyList())
         // Check we can find a constructor and populate the args to it, but don't call it
         createConstructor(type, args)
-        return FlowLogicRefImpl(type.name, appContext, args)
+        return FlowLogicRefImpl(type.name, args)
     }
 
     fun toFlowLogic(ref: FlowLogicRef): FlowLogic<*> {
         if (ref !is FlowLogicRefImpl) throw IllegalFlowLogicException(ref.javaClass, "FlowLogicRef was not created via correct FlowLogicRefFactory interface")
-        val klass = Class.forName(ref.flowLogicClassName, true, ref.appContext.classLoader).asSubclass(FlowLogic::class.java)
+        val klass = Class.forName(ref.flowLogicClassName, true, classloader).asSubclass(FlowLogic::class.java)
         return createConstructor(klass, ref.args)()
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
index 11c3d219bc..28e2c58958 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
@@ -77,7 +77,8 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
                           val checkpointStorage: CheckpointStorage,
                           val executor: AffinityExecutor,
                           val database: CordaPersistence,
-                          private val unfinishedFibers: ReusableLatch = ReusableLatch()) {
+                          private val unfinishedFibers: ReusableLatch = ReusableLatch(),
+                          private val classloader: ClassLoader = javaClass.classLoader) {
 
     inner class FiberScheduler : FiberExecutorScheduler("Same thread scheduler", executor)
 
@@ -377,7 +378,12 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
             updateCheckpoint(fiber)
             session to initiatedFlowFactory
         } catch (e: SessionRejectException) {
-            logger.warn("${e.logMessage}: $sessionInit")
+            // TODO: Handle this more gracefully
+            try {
+                logger.warn("${e.logMessage}: $sessionInit")
+            } catch (e: Throwable) {
+                logger.warn("Problematic session init message during logging", e)
+            }
             sendSessionReject(e.rejectMessage)
             return
         } catch (e: Exception) {
@@ -400,7 +406,7 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
 
     private fun getInitiatedFlowFactory(sessionInit: SessionInit): InitiatedFlowFactory<*> {
         val initiatingFlowClass = try {
-            Class.forName(sessionInit.initiatingFlowClass).asSubclass(FlowLogic::class.java)
+            Class.forName(sessionInit.initiatingFlowClass, true, classloader).asSubclass(FlowLogic::class.java)
         } catch (e: ClassNotFoundException) {
             throw SessionRejectException("Don't know ${sessionInit.initiatingFlowClass}")
         } catch (e: ClassCastException) {

From fee156cc4a8f22f9357a5188f1aa87033de9aba5 Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Sat, 30 Sep 2017 13:10:58 +0100
Subject: [PATCH 065/185] Added a contract constraints section to the key
 concepts doc. (#1704)

Documentation for contract constraints.

Added to index.

Review fixes round 1.

More review fixes.

Review fixes.

Explained package contents.

review fixes.

Addressed RGB's final review comments.

Updated source code type to 'java'
---
 docs/packages.md                                  | 12 ++++++------
 docs/source/key-concepts-contract-constraints.rst |  6 +++---
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/docs/packages.md b/docs/packages.md
index eb039e5237..9186dea33a 100644
--- a/docs/packages.md
+++ b/docs/packages.md
@@ -28,12 +28,6 @@ Internal, do not use. These APIs and implementations which are currently being r
 
 Exception types and some utilities for working with observables and futures.
 
-# Package net.corda.core.cordapp
-
-This package contains the interface to CorDapps from within a node. A CorDapp can access its own context by using
-the CordappProvider.getAppContext() class. These classes are not intended to be constructed manually and no interface
-to do this will be provided. 
-
 # Package net.corda.core.concurrent
 
 Provides a simplified [java.util.concurrent.Future] class that allows registration of a callback to execute when the future
@@ -47,6 +41,12 @@ with [Contract], or see the examples in [net.corda.finance.contracts].
 Corda smart contracts are a combination of state held on the distributed ledger, and verification logic which defines
 which transformations of state are valid.
 
+# Package net.corda.core.cordapp
+
+This package contains the interface to CorDapps from within a node. A CorDapp can access it's own context by using
+the CordappProvider.getAppContext() class. These classes are not intended to be constructed manually and no interface
+to do this will be provided. 
+
 # Package net.corda.core.crypto
 
 Cryptography data and utility classes used for signing, verifying, key management and data integrity checks.
diff --git a/docs/source/key-concepts-contract-constraints.rst b/docs/source/key-concepts-contract-constraints.rst
index 5518e45ff6..6c3e536264 100644
--- a/docs/source/key-concepts-contract-constraints.rst
+++ b/docs/source/key-concepts-contract-constraints.rst
@@ -15,7 +15,7 @@ A typical constraint is the hash of the CorDapp JAR that contains the contract a
 include constraints that require specific signers of the JAR, or both the signer and the hash. Constraints can be
 specified when constructing a transaction; if unspecified, an automatic constraint is used.
 
-A ``TransactionState`` has a ``constraint`` field that represents that state's attachment constraint. When a party
+``TransactionState``s have a ``constraint`` field that represents that state's attachment constraint. When a party
 constructs a ``TransactionState`` without specifying the constraint parameter a default value
 (``AutomaticHashConstraint``) is used. This default will be automatically resolved to a specific
 ``HashAttachmentConstraint`` that contains the hash of the attachment which contains the contract of that
@@ -80,8 +80,8 @@ attachment JAR. This allows for trusting of attachments from trusted entities.
 Limitations
 -----------
 
-An ``AttachmentConstraint`` is verified by running the ``AttachmentConstraint.isSatisfiedBy`` method. When this is
-called it is provided only the relevant attachment by the transaction that is verifying it.
+``AttachmentConstraint``s are verified by running the ``AttachmentConstraint.isSatisfiedBy`` method. When this is called
+it is provided only the relevant attachment by the transaction that is verifying it.
 
 Testing
 -------

From ed06443ce29cae112b44a24cae99c650c418fddf Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Sun, 1 Oct 2017 22:26:01 +0100
Subject: [PATCH 066/185] Update Readme (#1756)

* Update Readme

Minor tweaks to Readme -- consistent capitalisation and more descriptive list of features (also reordered to put the important things first)

* Copied master readme.

* Update Readme

Minor tweaks to Readme -- consistent capitalisation and more descriptive list of features (also reordered to put the important things first)
---
 README.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 25b9d8e2e5..efa598a1f5 100644
--- a/README.md
+++ b/README.md
@@ -8,25 +8,25 @@ Corda is a decentralised database system in which nodes trust each other as litt
 
 ## Features
 
-* A P2P network of nodes
-* Smart contracts
-* Flow framework
-* "Notary" infrastructure to validate uniqueness of transactions
-* Written as a platform for distributed apps called CorDapps
+* Smart contracts that can be written in Java and other JVM languages
+* Flow framework to manage communication and negotiation between participants
+* Peer-to-peer network of nodes
+* "Notary" infrastructure to validate uniqueness and sequencing of transactions without global broadcast
+* Enables the development and deployment of distributed apps called CorDapps
 * Written in [Kotlin](https://kotlinlang.org), targeting the JVM
 
 ## Getting started
 
-1. Read the [Getting started](https://docs.corda.net/getting-set-up.html) documentation
-2. Run the [example CorDapp](https://docs.corda.net/tutorial-cordapp.html)
+1. Read the [Getting Started](https://docs.corda.net/getting-set-up.html) documentation
+2. Run the [Example CorDapp](https://docs.corda.net/tutorial-cordapp.html)
 3. Read about Corda's [Key Concepts](https://docs.corda.net/key-concepts.html)
 3. Follow the [Hello, World! tutorial](https://docs.corda.net/hello-world-index.html)
 
 ## Useful links
 
-* [Project website](https://corda.net)
+* [Project Website](https://corda.net)
 * [Documentation](https://docs.corda.net)
-* [Slack channel](https://slack.corda.net/)
+* [Slack Channel](https://slack.corda.net/)
 * [Stack Overflow tag](https://stackoverflow.com/questions/tagged/corda)
 * [Forum](https://discourse.corda.net)
 * [Meetups](https://www.meetup.com/pro/corda/)

From 655f2be8b36eddf8255604e823cda6471060409b Mon Sep 17 00:00:00 2001
From: Clinton Alexander <admin@clintonio.com>
Date: Mon, 2 Oct 2017 16:12:19 +0100
Subject: [PATCH 067/185] Fixed flaky test

---
 .../kotlin/net/corda/node/services/AttachmentLoadingTests.kt  | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
index 0d6bc46545..ecbe731158 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@@ -124,10 +124,12 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
 
     private fun DriverDSLExposedInterface.createTwoNodesAndNotary(): List<NodeHandle> {
         val adminUser = User("admin", "admin", permissions = setOf("ALL"))
-        return listOf(
+        val nodes = listOf(
                 startNode(providedName = bankAName, rpcUsers = listOf(adminUser)),
                 startNode(providedName = bankBName, rpcUsers = listOf(adminUser)),
                 startNode(providedName = notaryName, rpcUsers = listOf(adminUser), advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
         ).transpose().getOrThrow()   // Wait for all nodes to start up.
+        nodes.forEach { it.rpc.waitUntilNetworkReady() }
+        return nodes
     }
 }

From 2d53859745d92e4921a33d2c176e1e4aeb658ec3 Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Thu, 28 Sep 2017 18:30:17 +0100
Subject: [PATCH 068/185] Fixes bugs with contract constraints (#1696)

* Added schedulable flows to cordapp scanning

Fixed a bug where the core flows are included in every cordapp. Added a test to prove the scheduled flows are loaded correctly. Added scheduled flow support to cordapp.

Renabled broken test.

Fixed test to prove cordapps aren't retreived from network.

Review fixes.

Fixed a test issue caused by gradle having slightly different paths to IntelliJ

* Fixed test for real this time.
---
 .../contracts/isolated/IsolatedDummyFlow.kt   |   1 +
 .../nodeapi/internal/serialization/Kryo.kt    |   2 +-
 .../net/corda/node/services/isolated.jar      | Bin 12477 -> 12672 bytes
 .../internal/cordapp/CordappLoaderTest.kt     |   2 ++
 4 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedDummyFlow.kt b/finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedDummyFlow.kt
index 97c35c2af3..a065b49c43 100644
--- a/finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedDummyFlow.kt
+++ b/finance/isolated/src/main/kotlin/net/corda/finance/contracts/isolated/IsolatedDummyFlow.kt
@@ -9,6 +9,7 @@ import net.corda.core.identity.Party
  * loaded or blocked.
  */
 class IsolatedDummyFlow {
+    @StartableByRPC
     @InitiatingFlow
     class Initiator(val toWhom: Party) : FlowLogic<Unit>() {
         @Suspendable
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
index 06820db6c2..82234df40b 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
@@ -521,7 +521,7 @@ object LoggerSerializer : Serializer<Logger>() {
 object ClassSerializer : Serializer<Class<*>>() {
     override fun read(kryo: Kryo, input: Input, type: Class<Class<*>>): Class<*> {
         val className = input.readString()
-        return Class.forName(className)
+        return Class.forName(className, true, kryo.classLoader)
     }
 
     override fun write(kryo: Kryo, output: Output, clazz: Class<*>) {
diff --git a/node/src/integration-test/resources/net/corda/node/services/isolated.jar b/node/src/integration-test/resources/net/corda/node/services/isolated.jar
index b1dfc71dac4cce43d4ba4bdb48c7b448d8ee1293..05544ab868067c1082eb80574f69c6dad2604b51 100644
GIT binary patch
delta 5714
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

delta 5498
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
CvIQ#u

diff --git a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
index e333595f35..628077d8c1 100644
--- a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
+++ b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
@@ -55,6 +55,8 @@ class CordappLoaderTest {
         assertThat(actualCordapp.rpcFlows).isEmpty()
         assertThat(actualCordapp.schedulableFlows).isEmpty()
         assertThat(actualCordapp.services).isEmpty()
+        assertThat(actualCordapp.serializationWhitelists).hasSize(1)
+        assertThat(actualCordapp.serializationWhitelists.first().javaClass.name).isEqualTo("net.corda.finance.contracts.isolated.IsolatedPlugin")
         assertThat(actualCordapp.jarPath).isEqualTo(isolatedJAR)
     }
 

From 9e5d8044b4bf4e6cfe31d29837849c57c80981d0 Mon Sep 17 00:00:00 2001
From: Clinton Alexander <admin@clintonio.com>
Date: Mon, 2 Oct 2017 17:59:01 +0100
Subject: [PATCH 069/185] Fixed test broken by merge.

---
 .../kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
index 628077d8c1..f2352d475d 100644
--- a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
+++ b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
@@ -56,7 +56,7 @@ class CordappLoaderTest {
         assertThat(actualCordapp.schedulableFlows).isEmpty()
         assertThat(actualCordapp.services).isEmpty()
         assertThat(actualCordapp.serializationWhitelists).hasSize(1)
-        assertThat(actualCordapp.serializationWhitelists.first().javaClass.name).isEqualTo("net.corda.finance.contracts.isolated.IsolatedPlugin")
+        assertThat(actualCordapp.serializationWhitelists.first().javaClass.name).isEqualTo("net.corda.nodeapi.internal.serialization.DefaultWhitelist")
         assertThat(actualCordapp.jarPath).isEqualTo(isolatedJAR)
     }
 

From 1e7474d08edf90574e746b10602c6fd41f7f0f3c Mon Sep 17 00:00:00 2001
From: cburlinchon <31621751+cburlinchon@users.noreply.github.com>
Date: Tue, 3 Oct 2017 10:00:56 +0100
Subject: [PATCH 070/185] Use latest crash shell which fixes error when using
 multiple commands or hitting keys accidentally (#1729)

---
 node/build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/node/build.gradle b/node/build.gradle
index 276efe01df..10bd5877ff 100644
--- a/node/build.gradle
+++ b/node/build.gradle
@@ -157,7 +157,7 @@ dependencies {
     compile "io.netty:netty-all:$netty_version"
 
     // CRaSH: An embeddable monitoring and admin shell with support for adding new commands written in Groovy.
-    compile("com.github.corda.crash:crash.shell:9d242da2a10e686f33a3aefc69e4768824ad0716") {
+    compile("com.github.corda.crash:crash.shell:d5da86ba1b38e9c33af2a621dd15ba286307bec4") {
         exclude group: "org.slf4j", module: "slf4j-jdk14"
     }
 

From 24b773eec1e90a988da1ec36c97d5d65c9f2a737 Mon Sep 17 00:00:00 2001
From: Clinton Alexander <admin@clintonio.com>
Date: Mon, 2 Oct 2017 18:47:10 +0100
Subject: [PATCH 071/185] Added new API check script and API version

---
 .ci/api-current.txt      | 47 +++++++++++++++-------------------------
 .ci/check-api-changes.sh | 17 +++++++++++++++
 2 files changed, 34 insertions(+), 30 deletions(-)
 create mode 100644 .ci/check-api-changes.sh

diff --git a/.ci/api-current.txt b/.ci/api-current.txt
index f90125cf32..6d69bc4289 100644
--- a/.ci/api-current.txt
+++ b/.ci/api-current.txt
@@ -462,9 +462,9 @@ public interface net.corda.core.cordapp.Cordapp
   @org.jetbrains.annotations.NotNull public abstract List getInitiatedFlows()
   @org.jetbrains.annotations.NotNull public abstract java.net.URL getJarPath()
   @org.jetbrains.annotations.NotNull public abstract String getName()
-  @org.jetbrains.annotations.NotNull public abstract List getPlugins()
   @org.jetbrains.annotations.NotNull public abstract List getRpcFlows()
   @org.jetbrains.annotations.NotNull public abstract List getSchedulableFlows()
+  @org.jetbrains.annotations.NotNull public abstract List getSerializationWhitelists()
   @org.jetbrains.annotations.NotNull public abstract List getServices()
 ##
 public final class net.corda.core.cordapp.CordappContext extends java.lang.Object
@@ -564,6 +564,19 @@ public static final class net.corda.core.crypto.CompositeSignature$State extends
   public int hashCode()
   public String toString()
 ##
+public final class net.corda.core.crypto.CompositeSignaturesWithKeys extends java.lang.Object
+  public <init>(List)
+  @org.jetbrains.annotations.NotNull public final List component1()
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.CompositeSignaturesWithKeys copy(List)
+  public boolean equals(Object)
+  @org.jetbrains.annotations.NotNull public final List getSigs()
+  public int hashCode()
+  public String toString()
+  public static final net.corda.core.crypto.CompositeSignaturesWithKeys$Companion Companion
+##
+public static final class net.corda.core.crypto.CompositeSignaturesWithKeys$Companion extends java.lang.Object
+  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.CompositeSignaturesWithKeys getEMPTY()
+##
 public final class net.corda.core.crypto.CordaObjectIdentifier extends java.lang.Object
   @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final org.bouncycastle.asn1.ASN1ObjectIdentifier COMPOSITE_KEY
   @kotlin.jvm.JvmField @org.jetbrains.annotations.NotNull public static final org.bouncycastle.asn1.ASN1ObjectIdentifier COMPOSITE_SIGNATURE
@@ -839,19 +852,6 @@ public final class net.corda.core.crypto.TransactionSignature extends net.corda.
   public final boolean isValid(net.corda.core.crypto.SecureHash)
   public final boolean verify(net.corda.core.crypto.SecureHash)
 ##
-public final class net.corda.core.crypto.composite.CompositeSignaturesWithKeys extends java.lang.Object
-  public <init>(List)
-  @org.jetbrains.annotations.NotNull public final List component1()
-  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.composite.CompositeSignaturesWithKeys copy(List)
-  public boolean equals(Object)
-  @org.jetbrains.annotations.NotNull public final List getSigs()
-  public int hashCode()
-  public String toString()
-  public static final net.corda.core.crypto.composite.CompositeSignaturesWithKeys$Companion Companion
-##
-public static final class net.corda.core.crypto.composite.CompositeSignaturesWithKeys$Companion extends java.lang.Object
-  @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.composite.CompositeSignaturesWithKeys getEMPTY()
-##
 public abstract class net.corda.core.flows.AbstractStateReplacementFlow extends java.lang.Object
   public <init>()
 ##
@@ -912,16 +912,6 @@ public static final class net.corda.core.flows.AbstractStateReplacementFlow$Upgr
   public int hashCode()
   public String toString()
 ##
-public final class net.corda.core.flows.AppContext extends java.lang.Object
-  public <init>(List)
-  @org.jetbrains.annotations.NotNull public final List component1()
-  @org.jetbrains.annotations.NotNull public final net.corda.core.flows.AppContext copy(List)
-  public boolean equals(Object)
-  @org.jetbrains.annotations.NotNull public final List getAttachments()
-  @org.jetbrains.annotations.NotNull public final ClassLoader getClassLoader()
-  public int hashCode()
-  public String toString()
-##
 public final class net.corda.core.flows.CollectSignatureFlow extends net.corda.core.flows.FlowLogic
   public <init>(net.corda.core.transactions.SignedTransaction, net.corda.core.flows.FlowSession, List)
   @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public List call()
@@ -1495,10 +1485,6 @@ public static final class net.corda.core.messaging.StateMachineUpdate$Removed ex
   public int hashCode()
   public String toString()
 ##
-public abstract class net.corda.core.node.CordaPluginRegistry extends java.lang.Object
-  public <init>()
-  public boolean customizeSerialization(net.corda.core.serialization.SerializationCustomization)
-##
 public final class net.corda.core.node.NodeInfo extends java.lang.Object
   public <init>(List, List, int, long)
   @org.jetbrains.annotations.NotNull public final List component1()
@@ -2462,8 +2448,6 @@ public static final class net.corda.core.serialization.SerializationContext$UseC
   public static net.corda.core.serialization.SerializationContext$UseCase valueOf(String)
   public static net.corda.core.serialization.SerializationContext$UseCase[] values()
 ##
-public interface net.corda.core.serialization.SerializationCustomization
-##
 public final class net.corda.core.serialization.SerializationDefaults extends java.lang.Object
   @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializationContext getCHECKPOINT_CONTEXT()
   @org.jetbrains.annotations.NotNull public final net.corda.core.serialization.SerializationContext getP2P_CONTEXT()
@@ -2496,6 +2480,9 @@ public static final class net.corda.core.serialization.SerializationFactory$Comp
 public interface net.corda.core.serialization.SerializationToken
   @org.jetbrains.annotations.NotNull public abstract Object fromToken(net.corda.core.serialization.SerializeAsTokenContext)
 ##
+public interface net.corda.core.serialization.SerializationWhitelist
+  @org.jetbrains.annotations.NotNull public abstract List getWhitelist()
+##
 public interface net.corda.core.serialization.SerializeAsToken
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.serialization.SerializationToken toToken(net.corda.core.serialization.SerializeAsTokenContext)
 ##
diff --git a/.ci/check-api-changes.sh b/.ci/check-api-changes.sh
new file mode 100644
index 0000000000..a4273b9429
--- /dev/null
+++ b/.ci/check-api-changes.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+echo "Starting API Diff"
+
+apiCurrent=./api-current.txt
+if [ ! -f $apiCurrent ]; then
+   echo "Missing $apiCurrent file - cannot check API diff. Please rebase or add it to this release or ensure working dir is .ci/"
+   exit -1
+fi
+
+diffContents=`diff -u $apiCurrent ../build/api/api-corda-*.txt`
+echo "Diff contents: " 
+echo "$diffContents"
+removals=`echo "$diffContents" | grep "^-" | wc -l`
+echo "Number of API removals/changes: "$removals
+echo "Exiting with exit code" $removals
+exit $removals
\ No newline at end of file

From 457f95f1881dc5894c48addf8e00376def42642c Mon Sep 17 00:00:00 2001
From: Shams Asari <shams.asari@r3.com>
Date: Tue, 3 Oct 2017 09:38:12 +0100
Subject: [PATCH 072/185] Removed the network map service type as it's no
 longer needed.

The absence or presence of the networkMapService config is what determines if a node is the network map or not.
---
 .../kotlin/net/corda/core/flows/AttachmentTests.kt |  5 ++---
 .../serialization/AttachmentSerializationTest.kt   |  5 ++---
 .../kotlin/net/corda/docs/CustomVaultQueryTest.kt  |  7 +++----
 .../corda/docs/FxTransactionBuildTutorialTest.kt   |  3 +--
 .../docs/WorkflowTransactionBuildTutorialTest.kt   |  3 +--
 .../net/corda/nodeapi/internal/ServiceType.kt      |  1 -
 .../corda/node/services/BFTNotaryServiceTests.kt   |  3 +--
 .../kotlin/net/corda/node/internal/AbstractNode.kt |  5 +----
 .../kotlin/net/corda/node/internal/NodeStartup.kt  | 14 ++++++--------
 .../node/services/config/NodeConfiguration.kt      | 13 +++++++------
 .../node/services/network/NetworkMapService.kt     |  3 ---
 .../kotlin/net/corda/node/CordaRPCOpsImplTest.kt   |  9 ++++-----
 .../corda/node/messaging/InMemoryMessagingTests.kt | 10 ++++------
 .../net/corda/node/services/NotaryChangeTests.kt   |  3 +--
 .../node/services/events/ScheduledFlowTests.kt     |  3 +--
 .../network/AbstractNetworkMapServiceTest.kt       | 11 +++--------
 .../node/services/network/NetworkMapCacheTest.kt   |  6 ++----
 .../services/statemachine/FlowFrameworkTests.kt    |  3 +--
 .../services/transactions/NotaryServiceTests.kt    |  4 +---
 .../transactions/ValidatingNotaryServiceTests.kt   |  9 +++------
 .../net/corda/netmap/simulation/Simulation.kt      | 12 +++++-------
 .../net/corda/testing/FlowStackSnapshotTest.kt     |  3 +--
 .../main/kotlin/net/corda/testing/driver/Driver.kt |  4 +---
 .../main/kotlin/net/corda/testing/node/MockNode.kt |  2 +-
 .../kotlin/net/corda/testing/node/NodeBasedTest.kt |  7 +++----
 .../net/corda/demobench/model/InstallFactory.kt    |  4 +---
 .../net/corda/demobench/model/NodeController.kt    |  3 ---
 27 files changed, 56 insertions(+), 99 deletions(-)

diff --git a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
index dd5f1e6783..bf5c6af06f 100644
--- a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
@@ -11,7 +11,6 @@ import net.corda.core.messaging.SingleMessageRecipient
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.config.NodeConfiguration
-import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.persistence.NodeAttachmentService
 import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.node.utilities.DatabaseTransactionManager
@@ -45,7 +44,7 @@ class AttachmentTests {
         mockNet.stopNodes()
     }
 
-    fun fakeAttachment(): ByteArray {
+    private fun fakeAttachment(): ByteArray {
         val bs = ByteArrayOutputStream()
         val js = JarOutputStream(bs)
         js.putNextEntry(ZipEntry("file1.txt"))
@@ -127,7 +126,7 @@ class AttachmentTests {
                     override fun start() = super.start().apply { attachments.checkAttachmentsOnLoad = false }
                 }
             }
-        }, advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(SimpleNotaryService.type)))
+        }, advertisedServices = *arrayOf(ServiceInfo(SimpleNotaryService.type)))
         val bobNode = mockNet.createNode(aliceNode.network.myAddress, legalName = BOB.name)
 
         // Ensure that registration was successful before progressing any further
diff --git a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
index 5692f69722..37183b1fd8 100644
--- a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
+++ b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
@@ -14,11 +14,10 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.unwrap
 import net.corda.node.internal.InitiatedFlowFactory
 import net.corda.node.internal.StartedNode
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.config.NodeConfiguration
-import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.persistence.NodeAttachmentService
 import net.corda.node.utilities.DatabaseTransactionManager
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.MockNetwork
 import org.junit.After
@@ -70,7 +69,7 @@ class AttachmentSerializationTest {
     @Before
     fun setUp() {
         mockNet = MockNetwork()
-        server = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type))
+        server = mockNet.createNode()
         client = mockNet.createNode(server.network.myAddress)
         client.internals.disableDBCloseOnStop() // Otherwise the in-memory database may disappear (taking the checkpoint with it) while we reboot the client.
         mockNet.runNetwork()
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
index c8a8c89fc6..3105f151cb 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
@@ -7,11 +7,10 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.finance.*
 import net.corda.finance.contracts.getCashBalances
 import net.corda.finance.flows.CashIssueFlow
-import net.corda.node.internal.StartedNode
 import net.corda.finance.schemas.CashSchemaV1
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.network.NetworkMapService
+import net.corda.node.internal.StartedNode
 import net.corda.node.services.transactions.ValidatingNotaryService
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import org.junit.After
@@ -36,7 +35,7 @@ class CustomVaultQueryTest {
         notaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
                 overrideServices = mapOf(notaryService to DUMMY_NOTARY_KEY),
-                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), notaryService))
+                advertisedServices = *arrayOf(notaryService))
         nodeA = mockNet.createPartyNode(notaryNode.network.myAddress)
         nodeB = mockNet.createPartyNode(notaryNode.network.myAddress)
 
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
index 15c16c32b1..4548af15a3 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
@@ -9,7 +9,6 @@ import net.corda.finance.contracts.getCashBalances
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.schemas.CashSchemaV1
 import net.corda.node.internal.StartedNode
-import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
@@ -34,7 +33,7 @@ class FxTransactionBuildTutorialTest {
         notaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
                 overrideServices = mapOf(notaryService to DUMMY_NOTARY_KEY),
-                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), notaryService))
+                advertisedServices = *arrayOf(notaryService))
         nodeA = mockNet.createPartyNode(notaryNode.network.myAddress)
         nodeB = mockNet.createPartyNode(notaryNode.network.myAddress)
         nodeA.internals.registerCustomSchemas(setOf(CashSchemaV1))
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
index 831e8db3fb..4242dd79e3 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
@@ -9,7 +9,6 @@ import net.corda.core.node.services.vault.QueryCriteria
 import net.corda.core.toFuture
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
-import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
@@ -39,7 +38,7 @@ class WorkflowTransactionBuildTutorialTest {
         notaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
                 overrideServices = mapOf(Pair(notaryService, DUMMY_NOTARY_KEY)),
-                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), notaryService))
+                advertisedServices = *arrayOf(notaryService))
         nodeA = mockNet.createPartyNode(notaryNode.network.myAddress)
         nodeB = mockNet.createPartyNode(notaryNode.network.myAddress)
         nodeA.internals.registerInitiatedFlow(RecordCompletionFlow::class.java)
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/ServiceType.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/ServiceType.kt
index 65cdf86820..7ec0a1ce8f 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/ServiceType.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/ServiceType.kt
@@ -27,7 +27,6 @@ class ServiceType private constructor(val id: String) {
             }
 
         val notary: ServiceType = corda.getSubType("notary")
-        val networkMap: ServiceType = corda.getSubType("network_map")
 
         fun parse(id: String): ServiceType = ServiceType(id)
 
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt
index a28f1e3a9c..97859a5cdb 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt
@@ -18,7 +18,6 @@ import net.corda.core.utilities.Try
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.config.BFTSMaRtConfiguration
-import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.transactions.BFTNonValidatingNotaryService
 import net.corda.node.services.transactions.minClusterSize
 import net.corda.node.services.transactions.minCorrectReplicas
@@ -42,7 +41,7 @@ class BFTNotaryServiceTests {
     }
 
     private val mockNet = MockNetwork()
-    private val node = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type))
+    private val node = mockNet.createNode()
 
     @After
     fun stopNodes() {
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 9aacb16a83..3e9ef56ae4 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -484,7 +484,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
 
     private fun makeNetworkServices(tokenizableServices: MutableList<Any>) {
         val serviceTypes = advertisedServices.map { it.type }
-        inNodeNetworkMapService = if (NetworkMapService.type in serviceTypes) makeNetworkMapService() else NullNetworkMapService
+        inNodeNetworkMapService = if (configuration.networkMapService == null) makeNetworkMapService() else NullNetworkMapService
         val notaryServiceType = serviceTypes.singleOrNull { it.isNotary() }
         if (notaryServiceType != null) {
             val service = makeCoreNotaryService(notaryServiceType)
@@ -526,9 +526,6 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
      * updates) if one has been supplied.
      */
     protected open fun registerWithNetworkMap(): CordaFuture<Unit> {
-        require(networkMapAddress != null || NetworkMapService.type in advertisedServices.map { it.type }) {
-            "Initial network map address must indicate a node that provides a network map service"
-        }
         val address: SingleMessageRecipient = networkMapAddress ?:
                 network.getAddressOfParty(PartyInfo.SingleNode(services.myInfo.legalIdentitiesAndCerts.first().party, info.addresses)) as SingleMessageRecipient
         // Register for updates, even if we're the one running the network map.
diff --git a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
index d180abaa41..51cc7b454b 100644
--- a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
@@ -73,7 +73,7 @@ open class NodeStartup(val args: Array<String>) {
             cmdlineOptions.baseDirectory.createDirectories()
             startNode(conf, versionInfo, startTime, cmdlineOptions)
         } catch (e: Exception) {
-            if (e.message?.startsWith("Unknown named curve:") ?: false) {
+            if (e.message?.startsWith("Unknown named curve:") == true) {
                 logger.error("Exception during node startup - ${e.message}. " +
                         "This is a known OpenJDK issue on some Linux distributions, please use OpenJDK from zulu.org or Oracle JDK.")
             } else
@@ -150,13 +150,12 @@ open class NodeStartup(val args: Array<String>) {
     }
 
     open protected fun loadConfigFile(cmdlineOptions: CmdLineOptions): FullNodeConfiguration {
-        val conf = try {
-            cmdlineOptions.loadConfig()
+        try {
+            return cmdlineOptions.loadConfig()
         } catch (e: ConfigException) {
             println("Unable to load the configuration file: ${e.rootCause.message}")
             exitProcess(2)
         }
-        return conf
     }
 
     open protected fun banJavaSerialisation(conf: FullNodeConfiguration) {
@@ -167,13 +166,12 @@ open class NodeStartup(val args: Array<String>) {
         // Manifest properties are only available if running from the corda jar
         fun manifestValue(name: String): String? = if (Manifests.exists(name)) Manifests.read(name) else null
 
-        val versionInfo = VersionInfo(
+        return VersionInfo(
                 manifestValue("Corda-Platform-Version")?.toInt() ?: 1,
                 manifestValue("Corda-Release-Version") ?: "Unknown",
                 manifestValue("Corda-Revision") ?: "Unknown",
                 manifestValue("Corda-Vendor") ?: "Unknown"
         )
-        return versionInfo
     }
 
     private fun enforceSingleNodeIsRunning(baseDirectory: Path) {
@@ -260,10 +258,10 @@ open class NodeStartup(val args: Array<String>) {
     }
 
     private fun printPluginsAndServices(node: Node) {
-        node.configuration.extraAdvertisedServiceIds.filter { it.startsWith("corda.notary.") || it.startsWith("corda.network_map") }.let {
+        node.configuration.extraAdvertisedServiceIds.filter { it.startsWith("corda.notary.") }.let {
             if (it.isNotEmpty()) Node.printBasicNodeInfo("Providing additional services", it.joinToString())
         }
-        Node.printBasicNodeInfo("Loaded CorDapps", node.cordappProvider.cordapps.map { it.name }.joinToString())
+        Node.printBasicNodeInfo("Loaded CorDapps", node.cordappProvider.cordapps.joinToString { it.name })
     }
 
     open fun drawBanner(versionInfo: VersionInfo) {
diff --git a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
index 7d500b2202..cbaa194aad 100644
--- a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
+++ b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
@@ -3,12 +3,11 @@ package net.corda.node.services.config
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.node.internal.NetworkMapInfo
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.messaging.CertificateChainCheckPolicy
-import net.corda.node.services.network.NetworkMapService
 import net.corda.nodeapi.User
 import net.corda.nodeapi.config.NodeSSLConfiguration
 import net.corda.nodeapi.config.OldConfig
+import net.corda.nodeapi.internal.ServiceInfo
 import java.net.URL
 import java.nio.file.Path
 import java.util.*
@@ -22,6 +21,10 @@ interface NodeConfiguration : NodeSSLConfiguration {
     // myLegalName should be only used in the initial network registration, we should use the name from the certificate instead of this.
     // TODO: Remove this so we don't accidentally use this identity in the code?
     val myLegalName: CordaX500Name
+    /**
+     * If null then configure the node to run as the netwok map service, otherwise use this to connect to the network map
+     * service.
+     */
     val networkMapService: NetworkMapInfo?
     val minimumPlatformVersion: Int
     val emailAddress: String
@@ -93,12 +96,10 @@ data class FullNodeConfiguration(
     }
 
     fun calculateServices(): Set<ServiceInfo> {
-        val advertisedServices = extraAdvertisedServiceIds
+        return extraAdvertisedServiceIds
                 .filter(String::isNotBlank)
                 .map { ServiceInfo.parse(it) }
-                .toMutableSet()
-        if (networkMapService == null) advertisedServices += ServiceInfo(NetworkMapService.type)
-        return advertisedServices
+                .toSet()
     }
 }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt b/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt
index 3e9d3984ae..966d537954 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt
@@ -19,7 +19,6 @@ import net.corda.core.serialization.deserialize
 import net.corda.core.serialization.serialize
 import net.corda.core.utilities.debug
 import net.corda.core.utilities.loggerFor
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.node.services.api.AbstractNodeService
 import net.corda.node.services.api.ServiceHubInternal
 import net.corda.node.services.messaging.MessageHandlerRegistration
@@ -72,8 +71,6 @@ interface NetworkMapService {
         const val PUSH_TOPIC = "platform.network_map.push"
         // Base topic for messages acknowledging pushed updates
         const val PUSH_ACK_TOPIC = "platform.network_map.push_ack"
-
-        val type = ServiceType.networkMap
     }
 
     data class FetchMapRequest(val subscribe: Boolean,
diff --git a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
index ecd2e604d0..8fae3f60cc 100644
--- a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
+++ b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
@@ -1,6 +1,7 @@
 package net.corda.node
 
 import co.paralleluniverse.fibers.Suspendable
+import net.corda.client.rpc.PermissionException
 import net.corda.core.contracts.Amount
 import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.Issued
@@ -24,14 +25,12 @@ import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.internal.CordaRPCOpsImpl
 import net.corda.node.internal.StartedNode
+import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
 import net.corda.node.services.messaging.CURRENT_RPC_CONTEXT
 import net.corda.node.services.messaging.RpcContext
-import net.corda.node.services.network.NetworkMapService
-import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.transactions.SimpleNotaryService
-import net.corda.client.rpc.PermissionException
 import net.corda.nodeapi.User
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
@@ -68,7 +67,7 @@ class CordaRPCOpsImplTest {
         setCordappPackages("net.corda.finance.contracts.asset")
 
         mockNet = MockNetwork()
-        val networkMap = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type))
+        val networkMap = mockNet.createNode()
         aliceNode = mockNet.createNode(networkMapAddress = networkMap.network.myAddress)
         notaryNode = mockNet.createNode(advertisedServices = ServiceInfo(SimpleNotaryService.type), networkMapAddress = networkMap.network.myAddress)
         rpc = CordaRPCOpsImpl(aliceNode.services, aliceNode.smm, aliceNode.database)
diff --git a/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt b/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt
index 95c26319c2..e949ca11d2 100644
--- a/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt
+++ b/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt
@@ -1,10 +1,8 @@
 package net.corda.node.messaging
 
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.messaging.Message
 import net.corda.node.services.messaging.TopicStringValidator
 import net.corda.node.services.messaging.createMessage
-import net.corda.node.services.network.NetworkMapService
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.resetTestSerialization
 import org.junit.After
@@ -49,7 +47,7 @@ class InMemoryMessagingTests {
 
     @Test
     fun basics() {
-        val node1 = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type))
+        val node1 = mockNet.createNode()
         val node2 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
         val node3 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
 
@@ -78,7 +76,7 @@ class InMemoryMessagingTests {
 
     @Test
     fun broadcast() {
-        val node1 = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type))
+        val node1 = mockNet.createNode()
         val node2 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
         val node3 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
 
@@ -97,9 +95,9 @@ class InMemoryMessagingTests {
      */
     @Test
     fun `skip unhandled messages`() {
-        val node1 = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type))
+        val node1 = mockNet.createNode()
         val node2 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
-        var received: Int = 0
+        var received = 0
 
         node1.network.addMessageHandler("valid_message") { _, _ ->
             received++
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 024445b343..e1a560c1ca 100644
--- a/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
@@ -12,7 +12,6 @@ import net.corda.core.transactions.WireTransaction
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.seconds
 import net.corda.node.internal.StartedNode
-import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
@@ -42,7 +41,7 @@ class NotaryChangeTests {
         mockNet = MockNetwork()
         oldNotaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
-                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(ValidatingNotaryService.type)))
+                advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type)))
         clientNodeA = mockNet.createNode(networkMapAddress = oldNotaryNode.network.myAddress)
         clientNodeB = mockNet.createNode(networkMapAddress = oldNotaryNode.network.myAddress)
         newNotaryNode = mockNet.createNode(networkMapAddress = oldNotaryNode.network.myAddress, advertisedServices = ServiceInfo(ValidatingNotaryService.type))
diff --git a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
index 072fd74a05..9e4215a814 100644
--- a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
@@ -15,7 +15,6 @@ import net.corda.core.node.services.vault.SortAttribute
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
-import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.statemachine.StateMachineManager
 import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.internal.ServiceInfo
@@ -98,7 +97,7 @@ class ScheduledFlowTests {
         mockNet = MockNetwork(threadPerNode = true)
         notaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
-                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(ValidatingNotaryService.type)))
+                advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type)))
         val a = mockNet.createUnstartedNode(notaryNode.network.myAddress)
         val b = mockNet.createUnstartedNode(notaryNode.network.myAddress)
 
diff --git a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
index 7b133c965f..403a149183 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
@@ -7,7 +7,6 @@ import net.corda.core.node.NodeInfo
 import net.corda.core.serialization.deserialize
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.messaging.MessagingService
 import net.corda.node.services.messaging.send
@@ -25,12 +24,8 @@ import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.node.utilities.AddOrRemove
 import net.corda.node.utilities.AddOrRemove.ADD
 import net.corda.node.utilities.AddOrRemove.REMOVE
-import net.corda.testing.ALICE
-import net.corda.testing.BOB
-import net.corda.testing.CHARLIE
-import net.corda.testing.DUMMY_MAP
-import net.corda.testing.chooseIdentity
-import net.corda.testing.chooseIdentityAndCert
+import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
 import org.assertj.core.api.Assertions.assertThat
@@ -58,7 +53,7 @@ abstract class AbstractNetworkMapServiceTest<out S : AbstractNetworkMapService>
         mapServiceNode = mockNet.createNode(
                 nodeFactory = nodeFactory,
                 legalName = DUMMY_MAP.name,
-                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(SimpleNotaryService.type)))
+                advertisedServices = *arrayOf(ServiceInfo(SimpleNotaryService.type)))
         alice = mockNet.createNode(mapServiceNode.network.myAddress, nodeFactory = nodeFactory, legalName = ALICE.name)
         mockNet.runNetwork()
         lastSerial = System.currentTimeMillis()
diff --git a/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt b/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
index 01a65de71e..2baba6ff3c 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
@@ -2,10 +2,8 @@ package net.corda.node.services.network
 
 import net.corda.core.node.services.NetworkMapCache
 import net.corda.core.utilities.getOrThrow
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.ALICE
 import net.corda.testing.BOB
-import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.MockNetwork
 import org.assertj.core.api.Assertions.assertThat
@@ -40,8 +38,8 @@ class NetworkMapCacheTest {
     @Test
     fun `key collision`() {
         val entropy = BigInteger.valueOf(24012017L)
-        val aliceNode = mockNet.createNode(nodeFactory = MockNetwork.DefaultFactory, legalName = ALICE.name, entropyRoot = entropy, advertisedServices = ServiceInfo(NetworkMapService.type))
-        val bobNode = mockNet.createNode(nodeFactory = MockNetwork.DefaultFactory, legalName = BOB.name, entropyRoot = entropy, advertisedServices = ServiceInfo(NetworkMapService.type))
+        val aliceNode = mockNet.createNode(nodeFactory = MockNetwork.DefaultFactory, legalName = ALICE.name, entropyRoot = entropy)
+        val bobNode = mockNet.createNode(nodeFactory = MockNetwork.DefaultFactory, legalName = BOB.name, entropyRoot = entropy)
         assertEquals(aliceNode.info.chooseIdentity(), bobNode.info.chooseIdentity())
 
         mockNet.runNetwork()
diff --git a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
index a08230d9ff..0d832f164a 100644
--- a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
@@ -31,7 +31,6 @@ import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.internal.InitiatedFlowFactory
 import net.corda.node.internal.StartedNode
-import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.persistence.checkpoints
 import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.internal.ServiceInfo
@@ -79,7 +78,7 @@ class FlowFrameworkTests {
     fun start() {
         setCordappPackages("net.corda.finance.contracts", "net.corda.testing.contracts")
         mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
-        node1 = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type))
+        node1 = mockNet.createNode()
         node2 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
 
         mockNet.runNetwork()
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
index 7e4781ba30..eac332f7f6 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
@@ -14,10 +14,8 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.seconds
 import net.corda.node.internal.StartedNode
 import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.network.NetworkMapService
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
-import net.corda.testing.getDefaultNotary
 import net.corda.testing.node.MockNetwork
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.After
@@ -40,7 +38,7 @@ class NotaryServiceTests {
         mockNet = MockNetwork()
         notaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
-                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(SimpleNotaryService.type)))
+                advertisedServices = *arrayOf(ServiceInfo(SimpleNotaryService.type)))
         clientNode = mockNet.createNode(notaryNode.network.myAddress)
         mockNet.runNetwork() // Clear network map registration messages
         notaryNode.internals.ensureRegistered()
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
index 52a2165960..4de1dfba75 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
@@ -10,16 +10,13 @@ import net.corda.core.flows.NotaryException
 import net.corda.core.flows.NotaryFlow
 import net.corda.core.identity.Party
 import net.corda.core.transactions.SignedTransaction
-import net.corda.core.utilities.getOrThrow
 import net.corda.core.transactions.TransactionBuilder
+import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.issueInvalidState
-import net.corda.node.services.network.NetworkMapService
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
-import net.corda.testing.dummyCommand
-import net.corda.testing.getDefaultNotary
 import net.corda.testing.node.MockNetwork
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.After
@@ -41,7 +38,7 @@ class ValidatingNotaryServiceTests {
         mockNet = MockNetwork()
         notaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
-                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(ValidatingNotaryService.type))
+                advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type))
         )
         clientNode = mockNet.createNode(notaryNode.network.myAddress)
         mockNet.runNetwork() // Clear network map registration messages
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
index 6ba3f19e18..faec432e7b 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
@@ -2,19 +2,18 @@ package net.corda.netmap.simulation
 
 import net.corda.core.flows.FlowLogic
 import net.corda.core.identity.CordaX500Name
-import net.corda.finance.utils.CityDatabase
-import net.corda.finance.utils.WorldMapLocation
 import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.SingleMessageRecipient
 import net.corda.core.utilities.ProgressTracker
+import net.corda.finance.utils.CityDatabase
+import net.corda.finance.utils.WorldMapLocation
 import net.corda.irs.api.NodeInterestRates
 import net.corda.node.internal.StartedNode
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.node.services.config.NodeConfiguration
-import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.statemachine.StateMachineManager
 import net.corda.node.services.transactions.SimpleNotaryService
+import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.nodeapi.internal.ServiceType
 import net.corda.testing.DUMMY_MAP
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.DUMMY_REGULATOR
@@ -92,7 +91,6 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
                             advertisedServices: Set<ServiceInfo>, id: Int, overrideServices: Map<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): SimulatedNode {
-            require(advertisedServices.containsType(NetworkMapService.type))
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
                     myLegalName = DUMMY_MAP.name)
@@ -153,7 +151,7 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
 
     val mockNet = MockNetwork(networkSendManuallyPumped, runAsync)
     // This one must come first.
-    val networkMap = mockNet.createNode(nodeFactory = NetworkMapNodeFactory, advertisedServices = ServiceInfo(NetworkMapService.type))
+    val networkMap = mockNet.createNode(nodeFactory = NetworkMapNodeFactory)
     val notary = mockNet.createNode(networkMap.network.myAddress, nodeFactory = NotaryNodeFactory, advertisedServices = ServiceInfo(SimpleNotaryService.type))
     val regulators = listOf(mockNet.createUnstartedNode(networkMap.network.myAddress, nodeFactory = RegulatorFactory))
     val ratesOracle = mockNet.createUnstartedNode(networkMap.network.myAddress, nodeFactory = RatesOracleFactory)
diff --git a/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt b/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
index 33d682f2b4..15c8fb4c77 100644
--- a/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
+++ b/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
@@ -9,7 +9,6 @@ import net.corda.core.internal.read
 import net.corda.core.messaging.startFlow
 import net.corda.core.serialization.CordaSerializable
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.User
 import net.corda.nodeapi.internal.ServiceInfo
@@ -297,7 +296,7 @@ class FlowStackSnapshotTest {
         val notaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
                 overrideServices = mapOf(notaryService to DUMMY_NOTARY_KEY),
-                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), notaryService))
+                advertisedServices = *arrayOf(notaryService))
         val node = mockNet.createPartyNode(notaryNode.network.myAddress)
         node.internals.registerInitiatedFlow(DummyFlow::class.java)
         node.services.startFlow(FlowStackSnapshotSerializationTestingFlow()).resultFuture.get()
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
index 64645569a4..15fd43b655 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
@@ -830,9 +830,7 @@ class DriverDSL(
                         "rpcAddress" to rpcAddress.toString(),
                         "rpcUsers" to defaultRpcUserList,
                         "p2pAddress" to dedicatedNetworkMapAddress.toString(),
-                        "useTestClock" to useTestClock,
-                        "extraAdvertisedServiceIds" to listOf(ServiceInfo(NetworkMapService.type).toString())
-                )
+                        "useTestClock" to useTestClock)
         )
         return startNodeInternal(config, webAddress, startInProcess, maximumHeapSize)
     }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index 446c4dc09d..ea351fe8f1 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -400,7 +400,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                          overrideServices: Map<ServiceInfo, KeyPair>? = null,
                          serviceName: CordaX500Name? = null): StartedNode<MockNode> {
         return createNode(networkMapAddress, legalName = legalName, overrideServices = overrideServices,
-                advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(ValidatingNotaryService.type, serviceName)))
+                advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type, serviceName)))
     }
 
     // Convenience method for Java
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
index ce703de814..2a126e5d21 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
@@ -8,17 +8,16 @@ import net.corda.core.internal.div
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.Node
 import net.corda.node.internal.StartedNode
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.node.services.config.ConfigHelper
 import net.corda.node.services.config.FullNodeConfiguration
 import net.corda.node.services.config.configOf
 import net.corda.node.services.config.plus
-import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.transactions.RaftValidatingNotaryService
 import net.corda.node.utilities.ServiceIdentityGenerator
 import net.corda.nodeapi.User
 import net.corda.nodeapi.config.parseAs
+import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.nodeapi.internal.ServiceType
 import net.corda.testing.DUMMY_MAP
 import net.corda.testing.TestDependencyInjectionBase
 import net.corda.testing.driver.addressMustNotBeBoundFuture
@@ -91,7 +90,7 @@ abstract class NodeBasedTest : TestDependencyInjectionBase() {
                             rpcUsers: List<User> = emptyList(),
                             configOverrides: Map<String, Any> = emptyMap()): StartedNode<Node> {
         check(_networkMapNode == null || _networkMapNode!!.info.legalIdentitiesAndCerts.first().name == legalName)
-        return startNodeInternal(legalName, platformVersion, advertisedServices + ServiceInfo(NetworkMapService.type), rpcUsers, configOverrides).apply {
+        return startNodeInternal(legalName, platformVersion, advertisedServices, rpcUsers, configOverrides).apply {
             _networkMapNode = this
         }
     }
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
index ef4e59d91a..4d8876b2ed 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
@@ -3,8 +3,6 @@ package net.corda.demobench.model
 import com.typesafe.config.Config
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.utilities.NetworkHostAndPort
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import tornadofx.*
 import java.io.IOException
 import java.nio.file.Files
@@ -54,7 +52,7 @@ class InstallFactory : Controller() {
     }
 
     private fun Config.parseExtraServices(path: String): MutableList<String> {
-        val services = serviceController.services.values.toSortedSet() + ServiceInfo(ServiceType.networkMap).toString()
+        val services = serviceController.services.values.toSortedSet()
         return this.getStringList(path)
                 .filter { !it.isNullOrEmpty() }
                 .map { svc ->
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
index f6479308c2..367f04b847 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
@@ -3,8 +3,6 @@ package net.corda.demobench.model
 import net.corda.core.identity.CordaX500Name
 import net.corda.demobench.plugin.PluginController
 import net.corda.demobench.pty.R3Pty
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import tornadofx.*
 import java.io.IOException
 import java.lang.management.ManagementFactory
@@ -100,7 +98,6 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
         if (hasNetworkMap()) {
             config.networkMap = networkMapConfig
         } else {
-            config.extraServices.add(ServiceInfo(ServiceType.networkMap).toString())
             networkMapConfig = config
             log.info("Network map provided by: ${config.legalName}")
         }

From c87e1045eb98cba66aaf0d882823e124042e2cc3 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Tue, 3 Oct 2017 11:47:53 +0100
Subject: [PATCH 073/185] CORDA-540: Perform schema verification (#1672)

---
 .../amqp/DeserializationInput.kt              |  2 +-
 .../serialization/ListsSerializationTest.kt   | 24 +++++++++++++++----
 2 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt
index af7fcb3f81..648f11eeae 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt
@@ -60,7 +60,7 @@ class DeserializationInput(internal val serializerFactory: SerializerFactory) {
             deserializeAndReturnEnvelope(bytes, T::class.java)
 
     @Throws(NotSerializableException::class)
-    private fun getEnvelope(bytes: ByteSequence): Envelope {
+    internal fun getEnvelope(bytes: ByteSequence): Envelope {
         // Check that the lead bytes match expected header
         val headerSize = AmqpHeaderV1_0.size
         if (bytes.take(headerSize) != AmqpHeaderV1_0) {
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
index 176f7468a0..c392c8819e 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
@@ -4,8 +4,12 @@ import com.esotericsoftware.kryo.Kryo
 import com.esotericsoftware.kryo.util.DefaultClassResolver
 import net.corda.core.serialization.*
 import net.corda.node.services.statemachine.SessionData
+import net.corda.nodeapi.internal.serialization.amqp.DeserializationInput
+import net.corda.nodeapi.internal.serialization.amqp.Envelope
+import net.corda.nodeapi.internal.serialization.amqp.SerializerFactory
 import net.corda.testing.TestDependencyInjectionBase
 import net.corda.testing.amqpSpecific
+import net.corda.testing.kryoSpecific
 import org.assertj.core.api.Assertions
 import org.junit.Assert.*
 import org.junit.Test
@@ -17,6 +21,13 @@ import java.util.*
 class ListsSerializationTest : TestDependencyInjectionBase() {
     private companion object {
         val javaEmptyListClass = Collections.emptyList<Any>().javaClass
+
+        fun<T : Any> verifyEnvelope(serBytes: SerializedBytes<T>, envVerBody: (Envelope) -> Unit) =
+            amqpSpecific<ListsSerializationTest>("AMQP specific envelope verification") {
+                val context = SerializationFactory.defaultFactory.defaultContext
+                val envelope = DeserializationInput(SerializerFactory(context.whitelist, context.deserializationClassLoader)).getEnvelope(serBytes)
+                envVerBody(envelope)
+            }
     }
 
     @Test
@@ -43,7 +54,7 @@ class ListsSerializationTest : TestDependencyInjectionBase() {
     }
 
     @Test
-    fun `check empty list serialises as Java emptyList`() {
+    fun `check empty list serialises as Java emptyList`() = kryoSpecific<ListsSerializationTest>("Kryo specific test"){
         val nameID = 0
         val serializedForm = emptyList<Int>().serialize()
         val output = ByteArrayOutputStream().apply {
@@ -83,14 +94,19 @@ class ListsSerializationTest : TestDependencyInjectionBase() {
         payload.add(Child(1))
         payload.add(Child(2))
         val container = CovariantContainer(payload)
-        assertEqualAfterRoundTripSerialization(container)
-    }
 
+        fun verifyEnvelopeBody(envelope: Envelope) {
+            envelope.schema.types.single { typeNotation -> typeNotation.name == java.util.List::class.java.name + "<?>" }
+        }
+
+        assertEqualAfterRoundTripSerialization(container, {bytes -> verifyEnvelope(bytes, ::verifyEnvelopeBody)})
+    }
 }
 
-internal inline fun<reified T : Any> assertEqualAfterRoundTripSerialization(obj: T) {
+internal inline fun<reified T : Any> assertEqualAfterRoundTripSerialization(obj: T, noinline streamValidation: ((SerializedBytes<T>) -> Unit)? = null) {
 
     val serializedForm: SerializedBytes<T> = obj.serialize()
+    streamValidation?.invoke(serializedForm)
     val deserializedInstance = serializedForm.deserialize()
 
     assertEquals(obj, deserializedInstance)

From f03699d1a3e3e4f3a4be821f25851589ad5459a5 Mon Sep 17 00:00:00 2001
From: Mike Hearn <mike@r3.com>
Date: Tue, 3 Oct 2017 11:57:12 +0100
Subject: [PATCH 074/185] Docs: more package descriptions and take
 non-stabilised APIs out of the docs build. (#1774)

---
 docs/build.gradle |  7 ++++--
 docs/packages.md  | 63 ++++++++++++++++++++++++++++++++++++-----------
 2 files changed, 53 insertions(+), 17 deletions(-)

diff --git a/docs/build.gradle b/docs/build.gradle
index 6112f63647..542cc7380f 100644
--- a/docs/build.gradle
+++ b/docs/build.gradle
@@ -9,7 +9,9 @@ dokka {
     moduleName = 'corda'
     outputDirectory = file("${rootProject.rootDir}/docs/build/html/api/kotlin")
     processConfigurations = ['compile']
-    sourceDirs = files('../core/src/main/kotlin', '../client/jfx/src/main/kotlin', '../client/mock/src/main/kotlin', '../client/rpc/src/main/kotlin', '../node-api/src/main/kotlin', '../finance/src/main/kotlin', '../client/jackson/src/main/kotlin', '../testing/node-driver/src/main/kotlin', '../testing/test-utils/src/main/kotlin')
+    // TODO: Re-add '../testing/node-driver/src/main/kotlin', '../testing/test-utils/src/main/kotlin' when they're API stable
+    // TODO: Add '../client/jfx/src/main/kotlin' and '../client/mock/src/main/kotlin' if we decide to make them into public API
+    sourceDirs = files('../core/src/main/kotlin', '../client/rpc/src/main/kotlin', '../finance/src/main/kotlin', '../client/jackson/src/main/kotlin')
     includes = ['packages.md']
     jdkVersion = 8
 
@@ -29,7 +31,8 @@ task dokkaJavadoc(type: org.jetbrains.dokka.gradle.DokkaTask) {
     outputFormat = "javadoc"
     outputDirectory = file("${rootProject.rootDir}/docs/build/html/api/javadoc")
     processConfigurations = ['compile']
-    sourceDirs = files('../core/src/main/kotlin', '../client/jfx/src/main/kotlin', '../client/mock/src/main/kotlin', '../client/rpc/src/main/kotlin', '../node-api/src/main/kotlin', '../finance/src/main/kotlin', '../client/jackson/src/main/kotlin', '../testing/node-driver/src/main/kotlin', '../testing/test-utils/src/main/kotlin')
+    // TODO: Make this a copy of the list above programmatically.
+    sourceDirs = files('../core/src/main/kotlin', '../client/rpc/src/main/kotlin', '../finance/src/main/kotlin', '../client/jackson/src/main/kotlin')
     includes = ['packages.md']
     jdkVersion = 8
 
diff --git a/docs/packages.md b/docs/packages.md
index 9186dea33a..7331383ccc 100644
--- a/docs/packages.md
+++ b/docs/packages.md
@@ -3,19 +3,6 @@
 Utilities and serialisers for working with JSON representations of basic types. This adds Jackson support for
 the java.time API, some core types, and Kotlin data classes.
 
-# Package net.corda.client.jfx.model
-
-Data models for binding data feeds from Corda nodes into a JavaFX user interface, by presenting the data as [javafx.beans.Observable]
-types.
-
-# Package net.corda.client.jfx.utils
-
-Utility classes (i.e. data classes) used by the Corda JavaFX client.
-
-# Package net.corda.client.mock
-
-Tools used by the client to produce mock data for testing purposes.
-
 # Package net.corda.client.rpc
 
 RPC client interface to Corda, for use both by user-facing client and integration with external systems.
@@ -99,12 +86,58 @@ actual states rather than state references).
 
 Corda utility classes, providing a broad range of functionality to help implement both Corda nodes and CorDapps.
 
+
 # Package net.corda.finance
 
-The finance module is a CorDapp containing sample cash and obligation contracts, as well as providing several
-useful data types such as [Amount].
+Some simple testing utilities like pre-defined top-level values for common currencies. Mostly useful for
+writing unit tests in Kotlin.
+
+WARNING: NOT API STABLE.
 
 # Package net.corda.finance.utils
 
 A collection of utilities for summing financial states, for example, summing obligations to get total debts.
 
+WARNING: NOT API STABLE.
+
+# Package net.corda.finance.contracts
+
+Various types for common financial concepts like day roll conventions, fixes, etc. 
+
+WARNING: NOT API STABLE.
+
+# net.corda.finance.contracts.asset
+
+Cash states, obligations and commodities. 
+
+WARNING: NOT API STABLE. 
+
+# net.corda.finance.contracts.asset.cash.selection
+
+Provisional support for pluggable cash selectors, needed for different database backends. 
+
+WARNING: NOT API STABLE. 
+
+# net.corda.finance.contracts.math
+
+Splines and interpolation.
+
+WARNING: NOT API STABLE. 
+
+# net.corda.finance.flows
+
+Cash payments and issuances. Two party "delivery vs payment" atomic asset swaps.
+
+WARNING: NOT API STABLE. 
+
+# net.corda.finance.plugin
+
+JSON/Jackson plugin for business calendars.
+
+WARNING: NOT API STABLE.
+
+# net.corda.finance.schemas
+
+JPA (Java Persistence Architecture) schemas for the financial state types.
+
+WARNING: NOT API STABLE.
\ No newline at end of file

From c570f8c6eb9a63da17894338b97385f78c9d9f6b Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Tue, 3 Oct 2017 12:10:52 +0100
Subject: [PATCH 075/185] Fail the API check for lines starting with a single
 '-'. (#1787)

---
 .ci/check-api-changes.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
 mode change 100644 => 100755 .ci/check-api-changes.sh

diff --git a/.ci/check-api-changes.sh b/.ci/check-api-changes.sh
old mode 100644
new mode 100755
index a4273b9429..dd7d8efd60
--- a/.ci/check-api-changes.sh
+++ b/.ci/check-api-changes.sh
@@ -11,7 +11,7 @@ fi
 diffContents=`diff -u $apiCurrent ../build/api/api-corda-*.txt`
 echo "Diff contents: " 
 echo "$diffContents"
-removals=`echo "$diffContents" | grep "^-" | wc -l`
+removals=`echo "$diffContents" | grep "^-\s" | wc -l`
 echo "Number of API removals/changes: "$removals
 echo "Exiting with exit code" $removals
-exit $removals
\ No newline at end of file
+exit $removals

From 55af4d211faf7d42c05cd4b64ae6d2e8ba2a387f Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Tue, 3 Oct 2017 12:51:55 +0100
Subject: [PATCH 076/185] Derive working directory for API check from location
 of script. (#1789)

---
 .ci/check-api-changes.sh | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/.ci/check-api-changes.sh b/.ci/check-api-changes.sh
index dd7d8efd60..e2bd6afddc 100755
--- a/.ci/check-api-changes.sh
+++ b/.ci/check-api-changes.sh
@@ -2,13 +2,15 @@
 
 echo "Starting API Diff"
 
-apiCurrent=./api-current.txt
+APIHOME=$(dirname $0)
+
+apiCurrent=$APIHOME/api-current.txt
 if [ ! -f $apiCurrent ]; then
-   echo "Missing $apiCurrent file - cannot check API diff. Please rebase or add it to this release or ensure working dir is .ci/"
+   echo "Missing $apiCurrent file - cannot check API diff. Please rebase or add it to this release"
    exit -1
 fi
 
-diffContents=`diff -u $apiCurrent ../build/api/api-corda-*.txt`
+diffContents=`diff -u $apiCurrent $APIHOME/../build/api/api-corda-*.txt`
 echo "Diff contents: " 
 echo "$diffContents"
 removals=`echo "$diffContents" | grep "^-\s" | wc -l`

From ba9e2f01bb4305c4490d9ca76a13f70362e00a50 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Tue, 3 Oct 2017 14:28:10 +0100
Subject: [PATCH 077/185] Improve API page wording (#1788)

---
 docs/source/api-index.rst | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/docs/source/api-index.rst b/docs/source/api-index.rst
index 76e1689b89..d229c040ad 100644
--- a/docs/source/api-index.rst
+++ b/docs/source/api-index.rst
@@ -52,11 +52,12 @@ developers using them until we are able to graduate them into the public API:
 We hope to graduate the node-driver, test-utils and confidential-identities modules in the next feature release
 after 1.0. The bulk of the Corda API is found in the core module. Other modules should be assumed to be fully internal.
 
-The web server module will be removed in future: you should build web frontends for CorDapps using standard frameworks
+The web server module will be removed in future: you should build web front-ends for CorDapps using standard frameworks
 like Spring Boot, J2EE, Play, etc.
 
-Code that falls into the following package namespaces are for internal use only and not public. In a future release the
-node will not load any CorDapp which uses them.
+Code that falls into the following packages namespaces are for internal use only and not for public use:
 
 * Any package in the ``net.corda`` namespace which contains ``.internal``
-* ``net.corda.node``
\ No newline at end of file
+* ``net.corda.node``
+
+In the future releases the node upon starting up will reject any CorDapps which uses classes from these packages.
\ No newline at end of file

From 4fa63d07ddf6c6768efc0876de7bdc2ca9d8e2d6 Mon Sep 17 00:00:00 2001
From: josecoll <jose.coll@r3cev.com>
Date: Tue, 3 Oct 2017 14:29:47 +0100
Subject: [PATCH 078/185] Update build label to 1.1-SNAPSHOT (#1598)

---
 build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index 96cd49c445..47fc8ef7e6 100644
--- a/build.gradle
+++ b/build.gradle
@@ -4,7 +4,7 @@ buildscript {
     file("$projectDir/constants.properties").withInputStream { constants.load(it) }
 
     // Our version: bump this on release.
-    ext.corda_release_version = "0.16-SNAPSHOT"
+    ext.corda_release_version = "1.1-SNAPSHOT"
     // Increment this on any release that changes public APIs anywhere in the Corda platform
     // TODO This is going to be difficult until we have a clear separation throughout the code of what is public and what is internal
     ext.corda_platform_version = 1

From e6e3c29d748382bf8dcd8246ef806eea8b285d6f Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Tue, 3 Oct 2017 14:31:36 +0100
Subject: [PATCH 079/185] Fixed a few instances of waitUntilNetworkReady() to
 fix flaky tests. (#1785)

---
 .../net/corda/node/services/AttachmentLoadingTests.kt      | 2 +-
 .../kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt      | 4 ++--
 .../main/kotlin/net/corda/bank/api/BankOfCordaClientApi.kt | 2 +-
 .../main/kotlin/net/corda/explorer/ExplorerSimulation.kt   | 7 +++----
 4 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
index ecbe731158..27c9a3d08a 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@@ -129,7 +129,7 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
                 startNode(providedName = bankBName, rpcUsers = listOf(adminUser)),
                 startNode(providedName = notaryName, rpcUsers = listOf(adminUser), advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
         ).transpose().getOrThrow()   // Wait for all nodes to start up.
-        nodes.forEach { it.rpc.waitUntilNetworkReady() }
+        nodes.forEach { it.rpc.waitUntilNetworkReady().getOrThrow() }
         return nodes
     }
 }
diff --git a/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt b/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt
index 33a36ec75f..157b2c0fd6 100644
--- a/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt
+++ b/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt
@@ -33,8 +33,8 @@ class BankOfCordaRPCClientTest {
             // Big Corporation RPC Client
             val bigCorpClient = nodeBigCorporation.rpcClientToNode()
             val bigCorpProxy = bigCorpClient.start("bigCorpCFO", "password2").proxy
-            bocProxy.waitUntilNetworkReady()
-            bigCorpProxy.waitUntilNetworkReady()
+            bocProxy.waitUntilNetworkReady().getOrThrow()
+            bigCorpProxy.waitUntilNetworkReady().getOrThrow()
 
             // Register for Bank of Corda Vault updates
             val criteria = QueryCriteria.VaultQueryCriteria(status = Vault.StateStatus.ALL)
diff --git a/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/api/BankOfCordaClientApi.kt b/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/api/BankOfCordaClientApi.kt
index 455c090973..a50e99b727 100644
--- a/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/api/BankOfCordaClientApi.kt
+++ b/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/api/BankOfCordaClientApi.kt
@@ -36,7 +36,7 @@ class BankOfCordaClientApi(val hostAndPort: NetworkHostAndPort) {
         // TODO: privileged security controls required
         client.start("bankUser", "test").use { connection ->
             val rpc = connection.proxy
-            rpc.waitUntilNetworkReady()
+            rpc.waitUntilNetworkReady().getOrThrow()
 
             // Resolve parties via RPC
             val issueToParty = rpc.wellKnownPartyFromX500Name(params.issueToPartyName)
diff --git a/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt b/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt
index 11026a819c..706d5e3649 100644
--- a/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt
+++ b/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt
@@ -132,10 +132,9 @@ class ExplorerSimulation(val options: OptionSet) {
                 issuerNodeGBP.nodeInfo.legalIdentities.first() to issuerRPCGBP,
                 issuerNodeUSD.nodeInfo.legalIdentities.first() to issuerRPCUSD))
 
-        aliceRPC.waitUntilNetworkReady()
-        bobRPC.waitUntilNetworkReady()
-        issuerRPCGBP.waitUntilNetworkReady()
-        issuerRPCUSD.waitUntilNetworkReady()
+        listOf(aliceRPC, bobRPC, issuerRPCGBP, issuerRPCUSD).map {
+            it.waitUntilNetworkReady().getOrThrow()
+        }
     }
 
     private fun startSimulation(eventGenerator: EventGenerator, maxIterations: Int) {

From e2bb14da8ebb094a8663f651c98c75c67d837972 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Tue, 3 Oct 2017 15:07:34 +0100
Subject: [PATCH 080/185] CORDA-540: AMQP specific fixes in "node-api" project
 (#1765)

---
 .../net/corda/core/crypto/CompositeKeyTests.kt       |  2 +-
 .../internal/serialization/SerializationScheme.kt    |  4 ++--
 .../nodeapi/internal/AttachmentsClassLoaderTests.kt  |  3 +--
 .../internal/serialization/ListsSerializationTest.kt |  6 +++---
 .../internal/serialization/MapsSerializationTest.kt  |  6 +++---
 .../internal/serialization/SetsSerializationTest.kt  |  3 ++-
 .../main/kotlin/net/corda/testing/CoreTestUtils.kt   | 12 +++++++-----
 7 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/core/src/test/kotlin/net/corda/core/crypto/CompositeKeyTests.kt b/core/src/test/kotlin/net/corda/core/crypto/CompositeKeyTests.kt
index 80124d722d..0c65317b44 100644
--- a/core/src/test/kotlin/net/corda/core/crypto/CompositeKeyTests.kt
+++ b/core/src/test/kotlin/net/corda/core/crypto/CompositeKeyTests.kt
@@ -216,7 +216,7 @@ class CompositeKeyTests : TestDependencyInjectionBase() {
     }
 
     @Test()
-    fun `composite key validation with graph cycle detection`() = kryoSpecific<CompositeKeyTests>("Cycle exists in the object graph which is not currently supported in AMQP mode") {
+    fun `composite key validation with graph cycle detection`() = kryoSpecific("Cycle exists in the object graph which is not currently supported in AMQP mode") {
         val key1 = CompositeKey.Builder().addKeys(alicePublicKey, bobPublicKey).build() as CompositeKey
         val key2 = CompositeKey.Builder().addKeys(alicePublicKey, key1).build() as CompositeKey
         val key3 = CompositeKey.Builder().addKeys(alicePublicKey, key2).build() as CompositeKey
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
index 648d6e5817..ca6c4c5292 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
@@ -27,7 +27,7 @@ import java.util.concurrent.ExecutionException
 
 val attachmentsClassLoaderEnabledPropertyName = "attachments.class.loader.enabled"
 
-object NotSupportedSeralizationScheme : SerializationScheme {
+object NotSupportedSerializationScheme : SerializationScheme {
     private fun doThrow(): Nothing = throw UnsupportedOperationException("Serialization scheme not supported.")
 
     override fun canDeserializeVersion(byteSequence: ByteSequence, target: SerializationContext.UseCase): Boolean = doThrow()
@@ -107,7 +107,7 @@ open class SerializationFactoryImpl : SerializationFactory() {
             registeredSchemes
                     .filter { scheme -> scheme.canDeserializeVersion(it.first, it.second) }
                     .forEach { return@computeIfAbsent it }
-            NotSupportedSeralizationScheme
+            NotSupportedSerializationScheme
         }
     }
 
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
index 9d756a8812..e51a974936 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
@@ -5,7 +5,6 @@ import com.nhaarman.mockito_kotlin.whenever
 import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
 import net.corda.core.internal.declaredField
-import net.corda.core.internal.toLedgerTransaction
 import net.corda.core.internal.toWireTransaction
 import net.corda.core.node.ServiceHub
 import net.corda.core.node.services.AttachmentStorage
@@ -302,7 +301,7 @@ class AttachmentsClassLoaderTests : TestDependencyInjectionBase() {
 
     @Test
     fun `test deserialize of WireTransaction where contract cannot be found`() {
-        kryoSpecific<AttachmentsClassLoaderTests>("Kryo verifies/loads attachments on deserialization, whereas AMQP currently does not") {
+        kryoSpecific("Kryo verifies/loads attachments on deserialization, whereas AMQP currently does not") {
             ClassLoaderForTests().use { child ->
                 val contractClass = Class.forName(ISOLATED_CONTRACT_CLASS_NAME, true, child)
                 val contract = contractClass.newInstance() as DummyContractBackdoor
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
index c392c8819e..f8d281392b 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
@@ -23,7 +23,7 @@ class ListsSerializationTest : TestDependencyInjectionBase() {
         val javaEmptyListClass = Collections.emptyList<Any>().javaClass
 
         fun<T : Any> verifyEnvelope(serBytes: SerializedBytes<T>, envVerBody: (Envelope) -> Unit) =
-            amqpSpecific<ListsSerializationTest>("AMQP specific envelope verification") {
+            amqpSpecific("AMQP specific envelope verification") {
                 val context = SerializationFactory.defaultFactory.defaultContext
                 val envelope = DeserializationInput(SerializerFactory(context.whitelist, context.deserializationClassLoader)).getEnvelope(serBytes)
                 envVerBody(envelope)
@@ -54,7 +54,7 @@ class ListsSerializationTest : TestDependencyInjectionBase() {
     }
 
     @Test
-    fun `check empty list serialises as Java emptyList`() = kryoSpecific<ListsSerializationTest>("Kryo specific test"){
+    fun `check empty list serialises as Java emptyList`() = kryoSpecific("Kryo specific test"){
         val nameID = 0
         val serializedForm = emptyList<Int>().serialize()
         val output = ByteArrayOutputStream().apply {
@@ -71,7 +71,7 @@ class ListsSerializationTest : TestDependencyInjectionBase() {
     data class WrongPayloadType(val payload: ArrayList<Int>)
 
     @Test
-    fun `check throws for forbidden declared type`() = amqpSpecific<ListsSerializationTest>("Such exceptions are not expected in Kryo mode.") {
+    fun `check throws for forbidden declared type`() = amqpSpecific("Such exceptions are not expected in Kryo mode.") {
         val payload = ArrayList<Int>()
         payload.add(1)
         payload.add(2)
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/MapsSerializationTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/MapsSerializationTest.kt
index 6f97a39892..9788885420 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/MapsSerializationTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/MapsSerializationTest.kt
@@ -22,7 +22,7 @@ class MapsSerializationTest : TestDependencyInjectionBase() {
     }
 
     @Test
-    fun `check EmptyMap serialization`() = amqpSpecific<MapsSerializationTest>("kotlin.collections.EmptyMap is not enabled for Kryo serialization") {
+    fun `check EmptyMap serialization`() = amqpSpecific("kotlin.collections.EmptyMap is not enabled for Kryo serialization") {
         assertEqualAfterRoundTripSerialization(emptyMap<Any, Any>())
     }
 
@@ -41,7 +41,7 @@ class MapsSerializationTest : TestDependencyInjectionBase() {
     data class WrongPayloadType(val payload: HashMap<String, String>)
 
     @Test
-    fun `check throws for forbidden declared type`() = amqpSpecific<ListsSerializationTest>("Such exceptions are not expected in Kryo mode.") {
+    fun `check throws for forbidden declared type`() = amqpSpecific("Such exceptions are not expected in Kryo mode.") {
         val payload = HashMap<String, String>(smallMap)
         val wrongPayloadType = WrongPayloadType(payload)
         Assertions.assertThatThrownBy { wrongPayloadType.serialize() }
@@ -64,7 +64,7 @@ class MapsSerializationTest : TestDependencyInjectionBase() {
     }
 
     @Test
-    fun `check empty map serialises as Java emptyMap`() = kryoSpecific<MapsSerializationTest>("Specifically checks Kryo serialization") {
+    fun `check empty map serialises as Java emptyMap`() = kryoSpecific("Specifically checks Kryo serialization") {
         val nameID = 0
         val serializedForm = emptyMap<Int, Int>().serialize()
         val output = ByteArrayOutputStream().apply {
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SetsSerializationTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SetsSerializationTest.kt
index c1c5ea05dd..4a652a7521 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SetsSerializationTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SetsSerializationTest.kt
@@ -5,6 +5,7 @@ import com.esotericsoftware.kryo.util.DefaultClassResolver
 import net.corda.core.serialization.serialize
 import net.corda.node.services.statemachine.SessionData
 import net.corda.testing.TestDependencyInjectionBase
+import net.corda.testing.kryoSpecific
 import org.junit.Assert.*
 import org.junit.Test
 import java.io.ByteArrayOutputStream
@@ -39,7 +40,7 @@ class SetsSerializationTest : TestDependencyInjectionBase() {
     }
 
     @Test
-    fun `check empty set serialises as Java emptySet`() {
+    fun `check empty set serialises as Java emptySet`() = kryoSpecific("Checks Kryo header properties") {
         val nameID = 0
         val serializedForm = emptySet<Int>().serialize()
         val output = ByteArrayOutputStream().apply {
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
index bedda6486b..5bec1a4aeb 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
@@ -146,13 +146,15 @@ fun getTestPartyAndCertificate(name: CordaX500Name, publicKey: PublicKey, trustR
     return getTestPartyAndCertificate(Party(name, publicKey), trustRoot)
 }
 
-inline fun <reified T : Any> kryoSpecific(reason: String, function: () -> Unit) = if(!AMQP_ENABLED) {
+@Suppress("unused")
+inline fun <reified T : Any> T.kryoSpecific(reason: String, function: () -> Unit) = if(!AMQP_ENABLED) {
     function()
 } else {
     loggerFor<T>().info("Ignoring Kryo specific test, reason: $reason" )
 }
 
-inline fun <reified T : Any> amqpSpecific(reason: String, function: () -> Unit) = if(AMQP_ENABLED) {
+@Suppress("unused")
+inline fun <reified T : Any> T.amqpSpecific(reason: String, function: () -> Unit) = if(AMQP_ENABLED) {
     function()
 } else {
     loggerFor<T>().info("Ignoring AMQP specific test, reason: $reason" )
@@ -169,15 +171,15 @@ fun ServiceHub.getDefaultNotary(): Party = networkMapCache.notaryIdentities.firs
 
 /**
  * Set the package to scan for cordapps - this overrides the default behaviour of scanning the cordapps directory
- * @param packageName A package name that you wish to scan for cordapps
+ * @param packageNames A package name that you wish to scan for cordapps
  */
 fun setCordappPackages(vararg packageNames: String) {
     CordappLoader.testPackages = packageNames.toList()
 }
 
 /**
- * Unsets the default overriding behaviour of [setCordappPackage]
+ * Unsets the default overriding behaviour of [setCordappPackages]
  */
 fun unsetCordappPackages() {
     CordappLoader.testPackages = emptyList()
-}
+}
\ No newline at end of file

From 97731bcaafabeca2536d868b5940d749d8c4a06b Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Tue, 3 Oct 2017 15:33:20 +0100
Subject: [PATCH 081/185] Add README for our automated API check. (#1793)

* Add README for our automated API check.
* Mention that the Corda Release Manager is expected to update the API file.
---
 .ci/README.md | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 .ci/README.md

diff --git a/.ci/README.md b/.ci/README.md
new file mode 100644
index 0000000000..62b9669242
--- /dev/null
+++ b/.ci/README.md
@@ -0,0 +1,11 @@
+# !! DO NOT MODIFY THE API FILE IN THIS DIRECTORY !!
+
+The `api-current.txt` file contains a summary of Corda's current public APIs,
+as generated by the `api-scanner` Gradle plugin. (See [here](../gradle-plugins/api-scanner/README.md) for a detailed description of this plugin.) It will be regenerated and the copy in this repository updated by the Release Manager with
+each new Corda release. It will not be modified otherwise except under special circumstances that will require extra approval.
+
+Deleting or changing the existing Corda APIs listed in `api-current.txt` may
+break developers' CorDapps in the next Corda release! Please remember that we
+have committed to API Stability for CorDapps.
+
+# !! DO NOT MODIFY THE API FILE IN THIS DIRECTORY !!

From eb0e2535ed20a8c2f31159be9deb0eb027148382 Mon Sep 17 00:00:00 2001
From: Alberto Arri <30873160+al-r3@users.noreply.github.com>
Date: Tue, 3 Oct 2017 15:43:50 +0100
Subject: [PATCH 082/185] [CORDA-442] Make cordformation serialize NodeInfos to
 disk during deployment. (#1546)

Initial PR for https://r3-cev.atlassian.net/projects/CORDA/issues/CORDA-442

Allow for cordformation not to specify which node is the network map.
When that happens Cordformation will start each node and make it serialize its NodeInfo to disk.
This make 'depolyNodes' slower. On my machine for the traderDemo it's ~25s

PersistentNetworkMapCache will load files from disk at startup.
Additionally nodeinfos are loaded in the networkMapCache only if they're newer than the currently known version.
---
 constants.properties                          |  2 +-
 docs/source/changelog.rst                     |  6 ++
 .../java/net/corda/cordform/CordformNode.java |  5 ++
 .../groovy/net/corda/plugins/Cordform.groovy  | 65 +++++++++++---
 .../main/kotlin/net/corda/node/ArgsParser.kt  |  9 +-
 .../net/corda/node/internal/AbstractNode.kt   | 25 +++++-
 .../kotlin/net/corda/node/internal/Node.kt    |  5 ++
 .../net/corda/node/internal/NodeStartup.kt    | 20 +++--
 .../services/network/NodeInfoSerializer.kt    | 85 +++++++++++++++++++
 .../network/PersistentNetworkMapCache.kt      | 21 +++--
 .../kotlin/net/corda/node/ArgsParserTest.kt   |  9 +-
 .../network/NodeInfoSerializerTest.kt         | 67 +++++++++++++++
 12 files changed, 286 insertions(+), 33 deletions(-)
 create mode 100644 node/src/main/kotlin/net/corda/node/services/network/NodeInfoSerializer.kt
 create mode 100644 node/src/test/kotlin/net/corda/node/services/network/NodeInfoSerializerTest.kt

diff --git a/constants.properties b/constants.properties
index a9ce732db8..286d4dbc1c 100644
--- a/constants.properties
+++ b/constants.properties
@@ -1,4 +1,4 @@
-gradlePluginsVersion=1.0.1
+gradlePluginsVersion=1.1.0
 kotlinVersion=1.1.50
 guavaVersion=21.0
 bouncycastleVersion=1.57
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index 696507c047..d02e2d8f62 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -7,6 +7,12 @@ from the previous milestone release.
 UNRELEASED
 ----------
 
+* ``Cordform`` and node identity generation
+  * Cordform may not specify a value for ``NetworkMap``, when that happens, during the task execution the following happens:
+    1. Each node is started and its signed serialized NodeInfo is written to disk in the node base directory.
+    2. Every serialized ``NodeInfo`` above is copied in every other node "additional-node-info" folder under the NodeInfo folder.
+  * Nodes read all the nodes stored in ``additional-node-info`` when the ``NetworkMapService`` starts up.
+
 * ``Cordapp`` now has a name field for identifying CorDapps and all CorDapp names are printed to console at startup.
 
 * Enums now respsect the whitelist applied to the Serializer factory serializing / deserializing them. If the enum isn't
diff --git a/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java b/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
index 9175bead2f..d219c52281 100644
--- a/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
+++ b/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
@@ -9,6 +9,11 @@ import java.util.List;
 import java.util.Map;
 
 public class CordformNode implements NodeDefinition {
+    /**
+     * Path relative to the running node where the serialized NodeInfos are stored.
+     */
+    public static final String NODE_INFO_DIRECTORY = "additional-node-infos";
+
     protected static final String DEFAULT_HOST = "localhost";
 
     /**
diff --git a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordform.groovy b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordform.groovy
index 98668d85af..7bfd9e0f0d 100644
--- a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordform.groovy
+++ b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordform.groovy
@@ -3,6 +3,7 @@ package net.corda.plugins
 import static org.gradle.api.tasks.SourceSet.MAIN_SOURCE_SET_NAME
 import net.corda.cordform.CordformContext
 import net.corda.cordform.CordformDefinition
+import net.corda.cordform.CordformNode
 import org.apache.tools.ant.filters.FixCrLfFilter
 import org.bouncycastle.asn1.x500.X500Name
 import org.gradle.api.DefaultTask
@@ -61,8 +62,8 @@ class Cordform extends DefaultTask {
      * @return A node instance.
      */
     private Node getNodeByName(String name) {
-        for(Node node : nodes) {
-            if(node.name == name) {
+        for (Node node : nodes) {
+            if (node.name == name) {
                 return node
             }
         }
@@ -109,10 +110,14 @@ class Cordform extends DefaultTask {
      */
     @TaskAction
     void build() {
-        String networkMapNodeName
+        String networkMapNodeName = initializeConfigurationAndGetNetworkMapNodeName()
+        installRunScript()
+        finalizeConfiguration(networkMapNodeName)
+    }
+
+    private initializeConfigurationAndGetNetworkMapNodeName() {
         if (null != definitionClass) {
             def cd = loadCordformDefinition()
-            networkMapNodeName = cd.networkMapNodeName.toString()
             cd.nodeConfigurers.each { nc ->
                 node { Node it ->
                     nc.accept it
@@ -124,21 +129,55 @@ class Cordform extends DefaultTask {
                     project.projectDir.toPath().resolve(getNodeByName(nodeName).nodeDir.toPath())
                 }
             }
+            return cd.networkMapNodeName.toString()
         } else {
-            networkMapNodeName = this.networkMapNodeName
             nodes.each {
                 it.rootDir directory
             }
+            return this.networkMapNodeName
         }
-        installRunScript()
-        def networkMapNode = getNodeByName(networkMapNodeName)
-        if (networkMapNode == null)
-            throw new IllegalStateException("The networkMap property refers to a node that isn't configured ($networkMapNodeName)")
-        nodes.each {
-            if(it != networkMapNode) {
-                it.networkMapAddress(networkMapNode.getP2PAddress(), networkMapNodeName)
+    }
+
+    private finalizeConfiguration(String networkMapNodeName) {
+        Node networkMapNode = getNodeByName(networkMapNodeName)
+        if (networkMapNode == null) {
+            nodes.each {
+                it.build()
+            }
+            generateNodeInfos()
+            logger.info("Starting without networkMapNode, this an experimental feature")
+        } else {
+            nodes.each {
+                if (it != networkMapNode) {
+                    it.networkMapAddress(networkMapNode.getP2PAddress(), networkMapNodeName)
+                }
+                it.build()
+            }
+        }
+    }
+
+    Path fullNodePath(Node node) {
+        return project.projectDir.toPath().resolve(node.nodeDir.toPath())
+    }
+
+    private generateNodeInfos() {
+        nodes.each { Node node ->
+            def process = new ProcessBuilder("java", "-jar", Node.NODEJAR_NAME, "--just-generate-node-info")
+                    .directory(fullNodePath(node).toFile())
+                    .redirectErrorStream(true)
+                    .start()
+                    .waitFor()
+        }
+        for (source in nodes) {
+            for (destination in nodes) {
+                if (source.nodeDir != destination.nodeDir) {
+                    project.copy {
+                        from fullNodePath(source).toString()
+                        include 'nodeInfo-*'
+                        into fullNodePath(destination).resolve(Node.NODE_INFO_DIRECTORY).toString()
+                    }
+                }
             }
-            it.build()
         }
     }
 }
diff --git a/node/src/main/kotlin/net/corda/node/ArgsParser.kt b/node/src/main/kotlin/net/corda/node/ArgsParser.kt
index 1527beec44..db175ea2b7 100644
--- a/node/src/main/kotlin/net/corda/node/ArgsParser.kt
+++ b/node/src/main/kotlin/net/corda/node/ArgsParser.kt
@@ -34,6 +34,8 @@ class ArgsParser {
     private val noLocalShellArg = optionParser.accepts("no-local-shell", "Do not start the embedded shell locally.")
     private val isRegistrationArg = optionParser.accepts("initial-registration", "Start initial node registration with Corda network to obtain certificate from the permissioning server.")
     private val isVersionArg = optionParser.accepts("version", "Print the version and exit")
+    private val justGenerateNodeInfoArg = optionParser.accepts("just-generate-node-info",
+            "Perform the node start-up task necessary to generate its nodeInfo, save it to disk, then quit")
     private val helpArg = optionParser.accepts("help").forHelp()
 
     fun parse(vararg args: String): CmdLineOptions {
@@ -50,7 +52,9 @@ class ArgsParser {
         val isVersion = optionSet.has(isVersionArg)
         val noLocalShell = optionSet.has(noLocalShellArg)
         val sshdServer = optionSet.has(sshdServerArg)
-        return CmdLineOptions(baseDirectory, configFile, help, loggingLevel, logToConsole, isRegistration, isVersion, noLocalShell, sshdServer)
+        val justGenerateNodeInfo = optionSet.has(justGenerateNodeInfoArg)
+        return CmdLineOptions(baseDirectory, configFile, help, loggingLevel, logToConsole, isRegistration, isVersion,
+                noLocalShell, sshdServer, justGenerateNodeInfo)
     }
 
     fun printHelp(sink: PrintStream) = optionParser.printHelpOn(sink)
@@ -64,7 +68,8 @@ data class CmdLineOptions(val baseDirectory: Path,
                           val isRegistration: Boolean,
                           val isVersion: Boolean,
                           val noLocalShell: Boolean,
-                          val sshdServer: Boolean) {
+                          val sshdServer: Boolean,
+                          val justGenerateNodeInfo : Boolean) {
     fun loadConfig() = ConfigHelper
                 .loadConfig(baseDirectory, configFile)
                 .parseAs<FullNodeConfiguration>()
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 3e9ef56ae4..55f72dc451 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -169,20 +169,36 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         return CordaRPCOpsImpl(services, smm, database)
     }
 
-    open fun start(): StartedNode<AbstractNode> {
-        require(started == null) { "Node has already been started" }
+    private fun saveOwnNodeInfo() {
+        NodeInfoSerializer().saveToFile(configuration.baseDirectory, info, services.keyManagementService)
+    }
+
+    private fun initCertificate() {
         if (configuration.devMode) {
             log.warn("Corda node is running in dev mode.")
             configuration.configureWithDevSSLCertificate()
         }
         validateKeystore()
+    }
 
+    open fun generateNodeInfo() {
+        check(started == null) { "Node has already been started" }
+        initCertificate()
+        log.info("Generating nodeInfo ...")
+        initialiseDatabasePersistence {
+            makeServices()
+            saveOwnNodeInfo()
+        }
+    }
+
+    open fun start(): StartedNode<AbstractNode> {
+        check(started == null) { "Node has already been started" }
+        initCertificate()
         log.info("Node starting up ...")
-
         // Do all of this in a database transaction so anything that might need a connection has one.
         val startedImpl = initialiseDatabasePersistence {
             val tokenizableServices = makeServices()
-
+            saveOwnNodeInfo()
             smm = StateMachineManager(services,
                     checkpointStorage,
                     serverThread,
@@ -391,6 +407,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
                 services.transactionVerifierService, services.validatedTransactions, services.contractUpgradeService,
                 services, cordappProvider, this)
         makeNetworkServices(tokenizableServices)
+
         return tokenizableServices
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt
index 689ef67e20..7a183e2894 100644
--- a/node/src/main/kotlin/net/corda/node/internal/Node.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt
@@ -310,6 +310,11 @@ open class Node(override val configuration: FullNodeConfiguration,
     private val _startupComplete = openFuture<Unit>()
     val startupComplete: CordaFuture<Unit> get() = _startupComplete
 
+    override fun generateNodeInfo() {
+        initialiseSerialization()
+        super.generateNodeInfo()
+    }
+
     override fun start(): StartedNode<Node> {
         if (initialiseSerialization) {
             initialiseSerialization()
diff --git a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
index 51cc7b454b..6413daa3ee 100644
--- a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
@@ -92,18 +92,24 @@ open class NodeStartup(val args: Array<String>) {
 
     open protected fun startNode(conf: FullNodeConfiguration, versionInfo: VersionInfo, startTime: Long, cmdlineOptions: CmdLineOptions) {
         val advertisedServices = conf.calculateServices()
-        val node = createNode(conf, versionInfo, advertisedServices).start()
-        printPluginsAndServices(node.internals)
-        node.internals.nodeReadyFuture.thenMatch({
+        val node = createNode(conf, versionInfo, advertisedServices)
+        if (cmdlineOptions.justGenerateNodeInfo) {
+            // Perform the minimum required start-up logic to be able to write a nodeInfo to disk
+            node.generateNodeInfo()
+            return
+        }
+        val startedNode = node.start()
+        printPluginsAndServices(startedNode.internals)
+        startedNode.internals.nodeReadyFuture.thenMatch({
             val elapsed = (System.currentTimeMillis() - startTime) / 10 / 100.0
-            val name = node.info.legalIdentitiesAndCerts.first().name.organisation
+            val name = startedNode.info.legalIdentitiesAndCerts.first().name.organisation
             Node.printBasicNodeInfo("Node for \"$name\" started up and registered in $elapsed sec")
 
             // Don't start the shell if there's no console attached.
             val runShell = !cmdlineOptions.noLocalShell && System.console() != null
-            node.internals.startupComplete.then {
+            startedNode.internals.startupComplete.then {
                 try {
-                    InteractiveShell.startShell(cmdlineOptions.baseDirectory, runShell, cmdlineOptions.sshdServer, node)
+                    InteractiveShell.startShell(cmdlineOptions.baseDirectory, runShell, cmdlineOptions.sshdServer, startedNode)
                 } catch(e: Throwable) {
                     logger.error("Shell failed to start", e)
                 }
@@ -112,7 +118,7 @@ open class NodeStartup(val args: Array<String>) {
         {
             th -> logger.error("Unexpected exception during registration", th)
         })
-        node.internals.run()
+        startedNode.internals.run()
     }
 
     open protected fun logStartupInfo(versionInfo: VersionInfo, cmdlineOptions: CmdLineOptions, conf: FullNodeConfiguration) {
diff --git a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoSerializer.kt b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoSerializer.kt
new file mode 100644
index 0000000000..925f393b7a
--- /dev/null
+++ b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoSerializer.kt
@@ -0,0 +1,85 @@
+package net.corda.node.services.network
+
+import net.corda.cordform.CordformNode
+import net.corda.core.crypto.SecureHash
+import net.corda.core.crypto.SignedData
+import net.corda.core.internal.createDirectories
+import net.corda.core.internal.div
+import net.corda.core.internal.isDirectory
+import net.corda.core.node.NodeInfo
+import net.corda.core.node.services.KeyManagementService
+import net.corda.core.serialization.deserialize
+import net.corda.core.serialization.serialize
+import net.corda.core.utilities.ByteSequence
+import net.corda.core.utilities.loggerFor
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+
+/**
+ * Class containing the logic to serialize and de-serialize a [NodeInfo] to disk and reading it back.
+ */
+class NodeInfoSerializer {
+
+    companion object {
+        val logger = loggerFor<NodeInfoSerializer>()
+    }
+
+    /**
+     * Saves the given [NodeInfo] to a path.
+     * The node is 'encoded' as a SignedData<NodeInfo>, signed with the owning key of its first identity.
+     * The name of the written file will be "nodeInfo-" followed by the hash of the content. The hash in the filename
+     * is used so that one can freely copy these files without fearing to overwrite another one.
+     *
+     * @param path the path where to write the file, if non-existent it will be created.
+     * @param nodeInfo the NodeInfo to serialize.
+     * @param keyManager a KeyManagementService used to sign the NodeInfo data.
+     */
+    fun saveToFile(path: Path, nodeInfo: NodeInfo, keyManager: KeyManagementService) {
+        try {
+            path.createDirectories()
+            val serializedBytes = nodeInfo.serialize()
+            val regSig = keyManager.sign(serializedBytes.bytes, nodeInfo.legalIdentities.first().owningKey)
+            val signedData = SignedData(serializedBytes, regSig)
+            val file = (path / ("nodeInfo-" + SecureHash.sha256(serializedBytes.bytes).toString())).toFile()
+            file.writeBytes(signedData.serialize().bytes)
+        } catch (e : Exception) {
+            logger.warn("Couldn't write node info to file: $e")
+        }
+    }
+
+    /**
+     * Loads all the files contained in a given path and returns the deserialized [NodeInfo]s.
+     * Signatures are checked before returning a value.
+     *
+     * @param nodePath the node base path. NodeInfo files are searched for in nodePath/[NODE_INFO_FOLDER]
+     * @return a list of [NodeInfo]s
+     */
+    fun loadFromDirectory(nodePath: Path): List<NodeInfo> {
+        val result = mutableListOf<NodeInfo>()
+        val nodeInfoDirectory = nodePath / CordformNode.NODE_INFO_DIRECTORY
+        if (!nodeInfoDirectory.isDirectory()) {
+            logger.info("$nodeInfoDirectory isn't a Directory, not loading NodeInfo from files")
+            return result
+        }
+        for (path in Files.list(nodeInfoDirectory)) {
+            val file = path.toFile()
+            if (file.isFile) {
+                try {
+                    logger.info("Reading NodeInfo from file: $file")
+                    val nodeInfo = loadFromFile(file)
+                    result.add(nodeInfo)
+                } catch (e: Exception) {
+                    logger.error("Exception parsing NodeInfo from file. $file" , e)
+                }
+            }
+        }
+        logger.info("Succesfully read ${result.size} NodeInfo files.")
+        return result
+    }
+
+    private fun loadFromFile(file: File): NodeInfo {
+        val signedData = ByteSequence.of(file.readBytes()).deserialize<SignedData<NodeInfo>>()
+        return signedData.verified()
+    }
+}
\ No newline at end of file
diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
index 400db60ef3..f2f5e8396c 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
@@ -1,11 +1,11 @@
 package net.corda.node.services.network
 
 import net.corda.core.concurrent.CordaFuture
+import net.corda.core.internal.bufferUntilSubscribed
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.internal.VisibleForTesting
-import net.corda.core.internal.bufferUntilSubscribed
 import net.corda.core.internal.concurrent.map
 import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.messaging.DataFeed
@@ -88,9 +88,17 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
         }
 
     init {
+        loadFromFiles()
         serviceHub.database.transaction { loadFromDB() }
     }
 
+    private fun loadFromFiles() {
+        logger.info("Loading network map from files..")
+        for (node in NodeInfoSerializer().loadFromDirectory(serviceHub.configuration.baseDirectory)) {
+            addNode(node)
+        }
+    }
+
     override fun getPartyInfo(party: Party): PartyInfo? {
         val nodes = serviceHub.database.transaction { queryByIdentityKey(party.owningKey) }
         if (nodes.size == 1 && nodes[0].isLegalIdentity(party)) {
@@ -159,6 +167,12 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
     override fun addNode(node: NodeInfo) {
         logger.info("Adding node with info: $node")
         synchronized(_changed) {
+            registeredNodes[node.legalIdentities.first().owningKey]?.let {
+                if (it.serial > node.serial) {
+                    logger.info("Discarding older nodeInfo for ${node.legalIdentities.first().name}")
+                    return
+                }
+            }
             val previousNode = registeredNodes.put(node.legalIdentities.first().owningKey, node) // TODO hack... we left the first one as special one
             if (previousNode == null) {
                 logger.info("No previous node found")
@@ -225,8 +239,6 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
         }
 
     private fun processRegistration(reg: NodeRegistration) {
-        // TODO: Implement filtering by sequence number, so we only accept changes that are
-        // more recent than the latest change we've processed.
         when (reg.type) {
             AddOrRemove.ADD -> addNode(reg.node)
             AddOrRemove.REMOVE -> removeNode(reg.node)
@@ -263,8 +275,7 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
                     logger.info("Loaded node info: $nodeInfo")
                     val publicKey = parsePublicKeyBase58(nodeInfo.legalIdentitiesAndCerts.single { it.isMain }.owningKey)
                     val node = nodeInfo.toNodeInfo()
-                    registeredNodes.put(publicKey, node)
-                    changePublisher.onNext(MapChange.Added(node)) // Redeploy bridges after reading from DB on startup.
+                    addNode(node)
                     _loadDBSuccess = true // This is used in AbstractNode to indicate that node is ready.
                 } catch (e: Exception) {
                     logger.warn("Exception parsing network map from the database.", e)
diff --git a/node/src/test/kotlin/net/corda/node/ArgsParserTest.kt b/node/src/test/kotlin/net/corda/node/ArgsParserTest.kt
index 94b09c11c5..94d798c4e2 100644
--- a/node/src/test/kotlin/net/corda/node/ArgsParserTest.kt
+++ b/node/src/test/kotlin/net/corda/node/ArgsParserTest.kt
@@ -23,7 +23,8 @@ class ArgsParserTest {
                 isRegistration = false,
                 isVersion = false,
                 noLocalShell = false,
-                sshdServer = false))
+                sshdServer = false,
+                justGenerateNodeInfo = false))
     }
 
     @Test
@@ -117,4 +118,10 @@ class ArgsParserTest {
         val cmdLineOptions = parser.parse("--version")
         assertThat(cmdLineOptions.isVersion).isTrue()
     }
+
+    @Test
+    fun `generate node infos`() {
+        val cmdLineOptions = parser.parse("--just-generate-node-info")
+        assertThat(cmdLineOptions.justGenerateNodeInfo).isTrue()
+    }
 }
diff --git a/node/src/test/kotlin/net/corda/node/services/network/NodeInfoSerializerTest.kt b/node/src/test/kotlin/net/corda/node/services/network/NodeInfoSerializerTest.kt
new file mode 100644
index 0000000000..6fe8ea6a28
--- /dev/null
+++ b/node/src/test/kotlin/net/corda/node/services/network/NodeInfoSerializerTest.kt
@@ -0,0 +1,67 @@
+package net.corda.node.services.network
+
+import net.corda.cordform.CordformNode
+import net.corda.core.internal.div
+import net.corda.core.node.NodeInfo
+import net.corda.core.node.services.KeyManagementService
+import net.corda.node.services.identity.InMemoryIdentityService
+import net.corda.testing.*
+import net.corda.testing.node.MockKeyManagementService
+import net.corda.testing.node.NodeBasedTest
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.nio.charset.Charset
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.contentOf
+
+class NodeInfoSerializerTest : NodeBasedTest() {
+
+    @Rule @JvmField var folder = TemporaryFolder()
+
+    lateinit var keyManagementService: KeyManagementService
+
+    // Object under test
+    val nodeInfoSerializer = NodeInfoSerializer()
+
+    companion object {
+        val nodeInfoFileRegex = Regex("nodeInfo\\-.*")
+        val nodeInfo = NodeInfo(listOf(), listOf(getTestPartyAndCertificate(ALICE)), 0, 0)
+    }
+
+    @Before
+    fun start() {
+        val identityService = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        keyManagementService = MockKeyManagementService(identityService, ALICE_KEY)
+    }
+
+    @Test
+    fun `save a NodeInfo`() {
+        nodeInfoSerializer.saveToFile(folder.root.toPath(), nodeInfo, keyManagementService)
+
+        assertEquals(1, folder.root.list().size)
+        val fileName = folder.root.list()[0]
+        assertTrue(fileName.matches(nodeInfoFileRegex))
+        val file = (folder.root.path / fileName).toFile()
+        // Just check that something is written, another tests verifies that the written value can be read back.
+        assertThat(contentOf(file)).isNotEmpty()
+    }
+
+    @Test
+    fun `load an empty Directory`() {
+        assertEquals(0, nodeInfoSerializer.loadFromDirectory(folder.root.toPath()).size)
+    }
+
+    @Test
+    fun `load a non empty Directory`() {
+        val nodeInfoFolder = folder.newFolder(CordformNode.NODE_INFO_DIRECTORY)
+        nodeInfoSerializer.saveToFile(nodeInfoFolder.toPath(), nodeInfo, keyManagementService)
+        val nodeInfos = nodeInfoSerializer.loadFromDirectory(folder.root.toPath())
+
+        assertEquals(1, nodeInfos.size)
+        assertEquals(nodeInfo, nodeInfos.first())
+    }
+}

From ab7507db69d8b841dde4bc3840f3fc578f5ca54c Mon Sep 17 00:00:00 2001
From: Andrzej Cichocki <andrzej.cichocki@r3.com>
Date: Tue, 3 Oct 2017 16:30:17 +0100
Subject: [PATCH 083/185] CORDA-599 Remove unnecessary laziness (#1517)

---
 .../net/corda/node/internal/AbstractNode.kt   | 22 +++++++++----------
 .../kotlin/net/corda/node/internal/Node.kt    |  6 ++---
 .../persistence/HibernateConfiguration.kt     |  5 ++---
 .../corda/node/utilities/CordaPersistence.kt  | 12 +++++-----
 .../persistence/DBTransactionStorageTests.kt  |  6 +----
 .../persistence/HibernateConfigurationTest.kt |  3 +--
 .../services/schema/HibernateObserverTests.kt |  3 +--
 .../kotlin/net/corda/testing/node/MockNode.kt |  3 ++-
 .../net/corda/testing/node/MockServices.kt    |  5 ++---
 .../net/corda/testing/node/SimpleNode.kt      |  2 +-
 10 files changed, 30 insertions(+), 37 deletions(-)

diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 55f72dc451..3472db31b4 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -185,8 +185,9 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         check(started == null) { "Node has already been started" }
         initCertificate()
         log.info("Generating nodeInfo ...")
-        initialiseDatabasePersistence {
-            makeServices()
+        val schemaService = NodeSchemaService()
+        initialiseDatabasePersistence(schemaService) {
+            makeServices(schemaService)
             saveOwnNodeInfo()
         }
     }
@@ -195,9 +196,10 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         check(started == null) { "Node has already been started" }
         initCertificate()
         log.info("Node starting up ...")
+        val schemaService = NodeSchemaService()
         // Do all of this in a database transaction so anything that might need a connection has one.
-        val startedImpl = initialiseDatabasePersistence {
-            val tokenizableServices = makeServices()
+        val startedImpl = initialiseDatabasePersistence(schemaService) {
+            val tokenizableServices = makeServices(schemaService)
             saveOwnNodeInfo()
             smm = StateMachineManager(services,
                     checkpointStorage,
@@ -391,10 +393,10 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
      * Builds node internal, advertised, and plugin services.
      * Returns a list of tokenizable services to be added to the serialisation context.
      */
-    private fun makeServices(): MutableList<Any> {
+    private fun makeServices(schemaService: SchemaService): MutableList<Any> {
         checkpointStorage = DBCheckpointStorage()
         cordappProvider = CordappProviderImpl(cordappLoader)
-        _services = ServiceHubInternalImpl()
+        _services = ServiceHubInternalImpl(schemaService)
         attachments = NodeAttachmentService(services.monitoringService.metrics)
         cordappProvider.start(attachments)
         legalIdentity = obtainIdentity()
@@ -482,10 +484,10 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
     // Specific class so that MockNode can catch it.
     class DatabaseConfigurationException(msg: String) : CordaException(msg)
 
-    protected open fun <T> initialiseDatabasePersistence(insideTransaction: () -> T): T {
+    protected open fun <T> initialiseDatabasePersistence(schemaService: SchemaService, insideTransaction: () -> T): T {
         val props = configuration.dataSourceProperties
         if (props.isNotEmpty()) {
-            this.database = configureDatabase(props, configuration.database, { _services.schemaService }, createIdentityService = { _services.identityService })
+            this.database = configureDatabase(props, configuration.database, schemaService, { _services.identityService })
             // Now log the vendor string as this will also cause a connection to be tested eagerly.
             database.transaction {
                 log.info("Connected to ${database.dataSource.connection.metaData.databaseProductName} database.")
@@ -689,15 +691,13 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
 
     protected open fun generateKeyPair() = cryptoGenerateKeyPair()
 
-    private inner class ServiceHubInternalImpl : ServiceHubInternal, SingletonSerializeAsToken() {
-
+    private inner class ServiceHubInternalImpl(override val schemaService: SchemaService) : ServiceHubInternal, SingletonSerializeAsToken() {
         override val rpcFlows = ArrayList<Class<out FlowLogic<*>>>()
         override val stateMachineRecordedTransactionMapping = DBTransactionMappingStorage()
         override val auditService = DummyAuditService()
         override val monitoringService = MonitoringService(MetricRegistry())
         override val validatedTransactions = makeTransactionStorage()
         override val transactionVerifierService by lazy { makeTransactionVerifierService() }
-        override val schemaService by lazy { NodeSchemaService() }
         override val networkMapCache by lazy { PersistentNetworkMapCache(this) }
         override val vaultService by lazy { NodeVaultService(this, database.hibernateConfig) }
         override val contractUpgradeService by lazy { ContractUpgradeServiceImpl() }
diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt
index 7a183e2894..31cb1cb27f 100644
--- a/node/src/main/kotlin/net/corda/node/internal/Node.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt
@@ -15,11 +15,11 @@ import net.corda.core.node.ServiceHub
 import net.corda.core.serialization.SerializationDefaults
 import net.corda.core.utilities.*
 import net.corda.node.VersionInfo
-import net.corda.node.internal.cordapp.CordappProviderImpl
 import net.corda.node.serialization.KryoServerSerializationScheme
 import net.corda.node.serialization.NodeClock
 import net.corda.node.services.RPCUserService
 import net.corda.node.services.RPCUserServiceImpl
+import net.corda.node.services.api.SchemaService
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.config.FullNodeConfiguration
 import net.corda.node.services.messaging.ArtemisMessagingServer
@@ -287,7 +287,7 @@ open class Node(override val configuration: FullNodeConfiguration,
      * This is not using the H2 "automatic mixed mode" directly but leans on many of the underpinnings.  For more details
      * on H2 URLs and configuration see: http://www.h2database.com/html/features.html#database_url
      */
-    override fun <T> initialiseDatabasePersistence(insideTransaction: () -> T): T {
+    override fun <T> initialiseDatabasePersistence(schemaService: SchemaService, insideTransaction: () -> T): T {
         val databaseUrl = configuration.dataSourceProperties.getProperty("dataSource.url")
         val h2Prefix = "jdbc:h2:file:"
         if (databaseUrl != null && databaseUrl.startsWith(h2Prefix)) {
@@ -304,7 +304,7 @@ open class Node(override val configuration: FullNodeConfiguration,
                 printBasicNodeInfo("Database connection url is", "jdbc:h2:$url/node")
             }
         }
-        return super.initialiseDatabasePersistence(insideTransaction)
+        return super.initialiseDatabasePersistence(schemaService, insideTransaction)
     }
 
     private val _startupComplete = openFuture<Unit>()
diff --git a/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt
index cbec0c793c..73d8f77dff 100644
--- a/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt
+++ b/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt
@@ -24,7 +24,7 @@ import java.sql.Connection
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
 
-class HibernateConfiguration(createSchemaService: () -> SchemaService, private val databaseProperties: Properties, private val createIdentityScervice: () -> IdentityService) {
+class HibernateConfiguration(val schemaService: SchemaService, private val databaseProperties: Properties, private val createIdentityService: () -> IdentityService) {
     companion object {
         val logger = loggerFor<HibernateConfiguration>()
     }
@@ -33,7 +33,6 @@ class HibernateConfiguration(createSchemaService: () -> SchemaService, private v
     private val sessionFactories = ConcurrentHashMap<Set<MappedSchema>, SessionFactory>()
 
     private val transactionIsolationLevel = parserTransactionIsolationLevel(databaseProperties.getProperty("transactionIsolationLevel") ?:"")
-    var schemaService = createSchemaService()
 
     init {
         logger.info("Init HibernateConfiguration for schemas: ${schemaService.schemaOptions.keys}")
@@ -86,7 +85,7 @@ class HibernateConfiguration(createSchemaService: () -> SchemaService, private v
                 }
             })
             // register custom converters
-            applyAttributeConverter(AbstractPartyToX500NameAsStringConverter(createIdentityScervice))
+            applyAttributeConverter(AbstractPartyToX500NameAsStringConverter(createIdentityService))
             // Register a tweaked version of `org.hibernate.type.MaterializedBlobType` that truncates logged messages.
             // to avoid OOM when large blobs might get logged.
             applyBasicType(CordaMaterializedBlobType, CordaMaterializedBlobType.name)
diff --git a/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt b/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
index de78ac1071..c1d6d8d0b7 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
@@ -23,13 +23,13 @@ import java.util.concurrent.CopyOnWriteArrayList
 const val NODE_DATABASE_PREFIX = "node_"
 
 //HikariDataSource implements Closeable which allows CordaPersistence to be Closeable
-class CordaPersistence(var dataSource: HikariDataSource, private var createSchemaService: () -> SchemaService,
+class CordaPersistence(var dataSource: HikariDataSource, private val schemaService: SchemaService,
                        private val createIdentityService: ()-> IdentityService, databaseProperties: Properties): Closeable {
     var transactionIsolationLevel = parserTransactionIsolationLevel(databaseProperties.getProperty("transactionIsolationLevel"))
 
    val hibernateConfig: HibernateConfiguration by lazy {
         transaction {
-            HibernateConfiguration(createSchemaService, databaseProperties, createIdentityService)
+            HibernateConfiguration(schemaService, databaseProperties, createIdentityService)
         }
    }
 
@@ -40,8 +40,8 @@ class CordaPersistence(var dataSource: HikariDataSource, private var createSchem
     }
 
     companion object {
-        fun connect(dataSource: HikariDataSource, createSchemaService: () -> SchemaService, createIdentityService: () -> IdentityService, databaseProperties: Properties): CordaPersistence {
-            return CordaPersistence(dataSource, createSchemaService, createIdentityService, databaseProperties).apply {
+        fun connect(dataSource: HikariDataSource, schemaService: SchemaService, createIdentityService: () -> IdentityService, databaseProperties: Properties): CordaPersistence {
+            return CordaPersistence(dataSource, schemaService, createIdentityService, databaseProperties).apply {
                 DatabaseTransactionManager(this)
             }
         }
@@ -107,10 +107,10 @@ class CordaPersistence(var dataSource: HikariDataSource, private var createSchem
     }
 }
 
-fun configureDatabase(dataSourceProperties: Properties, databaseProperties: Properties?, createSchemaService: () -> SchemaService = { NodeSchemaService() }, createIdentityService: () -> IdentityService): CordaPersistence {
+fun configureDatabase(dataSourceProperties: Properties, databaseProperties: Properties?, schemaService: SchemaService = NodeSchemaService(), createIdentityService: () -> IdentityService): CordaPersistence {
     val config = HikariConfig(dataSourceProperties)
     val dataSource = HikariDataSource(config)
-    val persistence = CordaPersistence.connect(dataSource, createSchemaService, createIdentityService, databaseProperties ?: Properties())
+    val persistence = CordaPersistence.connect(dataSource, schemaService, createIdentityService, databaseProperties ?: Properties())
 
     // Check not in read-only mode.
     persistence.transaction {
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
index 4ea017461d..e13460aea9 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
@@ -42,11 +42,7 @@ class DBTransactionStorageTests : TestDependencyInjectionBase() {
     fun setUp() {
         LogHelper.setLevel(PersistentUniquenessProvider::class)
         val dataSourceProps = makeTestDataSourceProperties()
-
-        val createSchemaService = { NodeSchemaService() }
-
-        database = configureDatabase(dataSourceProps, makeTestDatabaseProperties(), createSchemaService, ::makeTestIdentityService)
-
+        database = configureDatabase(dataSourceProps, makeTestDatabaseProperties(), NodeSchemaService(), ::makeTestIdentityService)
         database.transaction {
 
             services = object : MockServices(BOB_KEY) {
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
index a5ac113dc6..79c4650c61 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
@@ -77,8 +77,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
         issuerServices = MockServices(DUMMY_CASH_ISSUER_KEY, BOB_KEY, BOC_KEY)
         val dataSourceProps = makeTestDataSourceProperties()
         val defaultDatabaseProperties = makeTestDatabaseProperties()
-        val createSchemaService = { NodeSchemaService() }
-        database = configureDatabase(dataSourceProps, defaultDatabaseProperties, createSchemaService, ::makeTestIdentityService)
+        database = configureDatabase(dataSourceProps, defaultDatabaseProperties, NodeSchemaService(), ::makeTestIdentityService)
         database.transaction {
             hibernateConfig = database.hibernateConfig
             services = object : MockServices(BOB_KEY, BOC_KEY, DUMMY_NOTARY_KEY) {
diff --git a/node/src/test/kotlin/net/corda/node/services/schema/HibernateObserverTests.kt b/node/src/test/kotlin/net/corda/node/services/schema/HibernateObserverTests.kt
index 7472b66b02..44fc3cb47b 100644
--- a/node/src/test/kotlin/net/corda/node/services/schema/HibernateObserverTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/schema/HibernateObserverTests.kt
@@ -70,8 +70,7 @@ class HibernateObserverTests {
                 return parent
             }
         }
-        val database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), { schemaService }, createIdentityService = ::makeTestIdentityService)
-
+        val database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), schemaService, createIdentityService = ::makeTestIdentityService)
         @Suppress("UNUSED_VARIABLE")
         val observer = HibernateObserver(rawUpdatesPublisher, database.hibernateConfig)
         database.transaction {
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index ea351fe8f1..92a40391b5 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -26,6 +26,7 @@ import net.corda.core.utilities.loggerFor
 import net.corda.finance.utils.WorldMapLocation
 import net.corda.node.internal.AbstractNode
 import net.corda.node.internal.StartedNode
+import net.corda.node.services.api.SchemaService
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.identity.PersistentIdentityService
 import net.corda.node.services.keys.E2ETestKeyManagementService
@@ -248,7 +249,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
         @Suppress("unused") val place: WorldMapLocation get() = findMyLocation()!!
 
         private var dbCloser: (() -> Any?)? = null
-        override fun <T> initialiseDatabasePersistence(insideTransaction: () -> T) = super.initialiseDatabasePersistence {
+        override fun <T> initialiseDatabasePersistence(schemaService: SchemaService, insideTransaction: () -> T) = super.initialiseDatabasePersistence(schemaService) {
             dbCloser = database::close
             insideTransaction()
         }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
index 7338a6c68f..367dcad228 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
@@ -100,9 +100,8 @@ open class MockServices(cordappPackages: List<String> = emptyList(), vararg val
                                             cordappPackages: List<String> = emptyList()): Pair<CordaPersistence, MockServices> {
             val dataSourceProps = makeTestDataSourceProperties()
             val databaseProperties = makeTestDatabaseProperties()
-            val createSchemaService = { NodeSchemaService(customSchemas) }
             val identityServiceRef: IdentityService by lazy { createIdentityService() }
-            val database = configureDatabase(dataSourceProps, databaseProperties, createSchemaService, { identityServiceRef })
+            val database = configureDatabase(dataSourceProps, databaseProperties, NodeSchemaService(customSchemas), { identityServiceRef })
             val mockService = database.transaction {
                 object : MockServices(cordappPackages, *(keys.toTypedArray())) {
                     override val identityService: IdentityService = database.transaction { identityServiceRef }
@@ -158,7 +157,7 @@ open class MockServices(cordappPackages: List<String> = emptyList(), vararg val
 
     lateinit var hibernatePersister: HibernateObserver
 
-    fun makeVaultService(hibernateConfig: HibernateConfiguration = HibernateConfiguration( { NodeSchemaService() }, makeTestDatabaseProperties(), { identityService })): VaultService {
+    fun makeVaultService(hibernateConfig: HibernateConfiguration = HibernateConfiguration(NodeSchemaService(), makeTestDatabaseProperties(), { identityService })): VaultService {
         val vaultService = NodeVaultService(this, hibernateConfig)
         hibernatePersister = HibernateObserver(vaultService.rawUpdates, hibernateConfig)
         return vaultService
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/SimpleNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/SimpleNode.kt
index 726b0c5202..cfb1e3a29d 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/SimpleNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/SimpleNode.kt
@@ -37,7 +37,7 @@ class SimpleNode(val config: NodeConfiguration, val address: NetworkHostAndPort
     val monitoringService = MonitoringService(MetricRegistry())
     val identity: KeyPair = generateKeyPair()
     val identityService: IdentityService = InMemoryIdentityService(trustRoot = trustRoot)
-    val database: CordaPersistence = configureDatabase(config.dataSourceProperties, config.database, { NodeSchemaService() }, { InMemoryIdentityService(trustRoot = trustRoot) })
+    val database: CordaPersistence = configureDatabase(config.dataSourceProperties, config.database, NodeSchemaService(), { InMemoryIdentityService(trustRoot = trustRoot) })
     val keyService: KeyManagementService = E2ETestKeyManagementService(identityService, setOf(identity))
     val executor = ServiceAffinityExecutor(config.myLegalName.organisation, 1)
     // TODO: We should have a dummy service hub rather than change behaviour in tests

From dd3d8ba626523e379b8888177ca19f2e377d0c42 Mon Sep 17 00:00:00 2001
From: josecoll <jose.coll@r3cev.com>
Date: Tue, 3 Oct 2017 17:32:11 +0100
Subject: [PATCH 084/185] Merge release-v1 onto master (mostly documentation
 changes) (#1797)

* Updated corda release version to 1.0.0.RC2 (#1641)

* Fixed Simm Valuation Demo Test and enable serializabe java 8 lambdas. (#1655)

* [CORDA-624] Node Explorer on Issuing cash throws MissingContractAttachements exception (#1656)

(cherry picked from commit 27fea4d)

* BIGINT fix for H2 coin selection. (#1658)

* BIGINT fix for H2 coin selection.

* Review feedback

* CORDA-637 Node Explorer shows Network Map Service in Cash Issue dropdown (#1665)

* [CORDA-637] Node Explorer shows Network Map Service in Cash Issue dropdown

* add TODO to remove the hack

* Declare this internal message string as "const". (#1676)

* Merge "A variety of small fixes" into the 1.0 release branch (#1673)

* Minor: improve javadocs in NodeInfo

* Minor: use package descriptions in Kotlin build of api docs too, not just javadocs.

* RPC: make RPCConnection non-internal, as it's a core API. Move docs around so they're on public API not internal API.

* Add an IntelliJ scope that covers the currently supported Corda API.

This is useful when used in combination with the "Highlight public
declarations with missing KDoc" inspection.

* Ironic: upgrade the version of the Gradle plugin that checks for upgraded versions of things.

It had broken due being incompatible with the new versions of Gradle
itself.

* Docs: flesh out javadocs on ServiceHub

* Docs: add @suppress to a few things that were polluting the Dokka docs.

* Docs: mention RPC access in NodeInfo javadoc

* IRS Fixes to bring UI closer to declared financial types (#1662)

* Made problematic CordaRPCClient c'tor private (with internal bridge methods) and added correct c'tors for public use. (#1653)

initialiseSerialization param has also been removed.

* Fixing flow snapshot feature (#1685)

* Fix validating notary flow to handle notary change transactions properly. (#1687)

Add a notary change test for checking longer chains involving both regular and notary change transactions.

* Unification of VaultQuery And VaultService APIs (into single VaultService interface) to simplify node bootstrapping and usability. (#1677) (#1688)

* Identity documentation (#1620)

* Sketch initial identity docs

* Restructure confidential identity docs to better fit structure

* Split confidential identities into API and concepts

* Further expansion on basic identity conceptS

* Merge Party type into api-identity.rst

* Address feedback on written content

* Rework inline code with literalinclude

* Start addressing feedback from Richard

* Clarify use of "counterparty"

* Address comments on key concepts

* Correct back to US english

* Clarify distribution/publishing of identities

* Update changelog around confidential identities

* CORDA-642 Notary demo documentation fixes (#1682)

* Notary demo documentation fixes.

* One of the tables is prefixed.

* CORDA-641: A temporary fix for contract upgrade transactions (#1700)

* A temporary fix for contract upgrade transactions:
during LedgerTransaction verification run the right logic based on whether
it contains the UpgradeCommand.

* Move ContractUpgradeFlowTest away from createSomeNodes()

* Remove assembleBareTx as it's not used

* Update corda version tag to 1.0.0-RC3 (#1705)

* Hide SerializationContext from public API on TransactionBuilder (#1707)

* Hide SerializationContext from public API on TransactionBuilder

(cherry picked from commit 6ff7b7e)

* Hide SerializationContext from public API on TransactionBuilder

(cherry picked from commit 6ff7b7e)

* Address feedback on confidential identities docs (#1701)

* Address minor comments on confidential identities docs

* Expand on implementation details of confidential identities

* Cleanup

* Clarify details of the data blob in the swap identites flow

* Add that certificate path is not made public for confidential identities

* FlowSession docs (#1693)

* FlowSession docs (#1660)

* FlowSession docs

* PR comments

* Milder example flow name

* Fixes bugs with contract constraints (#1696)

* Added schedulable flows to cordapp scanning

Fixed a bug where the core flows are included in every cordapp. Added a test to prove the scheduled flows are loaded correctly. Added scheduled flow support to cordapp.

Renabled broken test.

Fixed test to prove cordapps aren't retreived from network.

Review fixes.

Fixed a test issue caused by gradle having slightly different paths to IntelliJ

* Fixed test for real this time.

* Consistent use of CordaException and CordaRuntimeException (#1710)

* Custom exceptions in corda, should either derive from an appropriate closely related java exception, or CordaException, or CordaRuntimeException. They should not inherit just from Exception, or RuntimeException.

Handle PR comments

Add nicer constructors to CordaException and CordaRuntimeException

* Fix ambiguous defaulted constructor

* Add @suppress (#1725)

* Git-ignore Node Explorer config. (#1709)

* add message warning windows users they might need to manually kill explorer demo nodes started by gradle (#1717) (#1726)

* Misc documentation fixes (#1694)

(cherry picked from commit 592896f)

* Document -parameters compiler arg for Java CorDapps. (#1712)

* Correct non-anonymous two party trade flow (#1731)

* Parameterize TwoPartyTradeFlowTests to confirm deanonymised functionality works.
* Correct handling of counterparty using well known identity in TWoPartyTradeFlow

* CORDA-594 - SIMM Demo doc update (#1723) (#1735)

* CORDA-594 - SIMM Demo doc update

For V1 write a series of JSON / curl commands a user can follow to run
the demo

* Review Comments

* Updated the rationale behind as to why SIMM was introduced.

* typo

* Cordapps now have a name field. (#1664)

Corrected cordapp name generation.

Added changelog entry.

* Small API fixes against M16 (#1737)

* Move CompositeSignaturesWithKeys into net.corda.core.crypto package.

(cherry picked from commit 8f29562)

* Rename and move CordaPluginRegistry to reflect its real purpose now.
Simplify serialization code a bit.

(cherry picked from commit e2ecd3a)

* Docs: docsite improvements

* Remove discussion of webserver from 'writing a cordapp' page.
* Fixup some flow docs.
* Add a couple more package descriptions.

(cherry picked from commit 2aedc43)

* Review comments

(cherry picked from commit ba1d007)

* Review comments - always apply default whitelist and no longer load it via ServiceLoader

(cherry picked from commit 7d4d7bb)

* Added wording about renaming services resource file

* Update corda version tag to 1.0.0-RC4 (#1734)

* Update corda version tag to 1.0.0-RC3

* Update corda version tag to 1.0.0-RC4

* Update build.gradle

* V1 tests and fixes for the ContractConstraints work (#1739)

* V1 tests and fixes for the ContractConstraints work

* More fixes.

* Added a contract constraints section to the key concepts doc. (#1704)

Documentation for contract constraints.

Added to index.

Review fixes round 1.

More review fixes.

Review fixes.

Explained package contents.

review fixes.

Addressed RGB's final review comments.

Updated source code type to 'java'

* Fixes dead links. (#1749)

* Update gradle plugins version to 1.0.0 (#1753)

* Update Readme (#1756)

* Update Readme

Minor tweaks to Readme -- consistent capitalisation and more descriptive list of features (also reordered to put the important things first)

* Copied master readme.

* Update Readme

Minor tweaks to Readme -- consistent capitalisation and more descriptive list of features (also reordered to put the important things first)

* Fixes .rst formatting. (#1751)

* Updates tutorials. (#1649)

* Updates tutorials.

* Addresses review comments.

* Tutorial refresh for v1.0 and moving of code into separate files. (#1758)

* Moves code sections in tutorials to code files.

* Removes wallet references.

* Updates repo layout doc.

* Removes remaining cordapp-tutorial references, replaced with cordapp-example.

* Fixes broken link.

* Misc docs fixes.

* Refreshes the ServiceHub and rpc ops api pages.

* Updates the cheat sheet.

* Updates cookbooks.

* Refreshes the running-a-notary tutorial.

* Updates flow-testing tutorial

* Updates tear-offs tutorial.

* Refreshes integration-testing tutorial.

* Updates to contract tutorial and accompanying code to bring inline with V1 release.

* Refreshes contract-upgrade tutorial.

* Fixed broken code sample in "writing a contract" and updated contracts dsl.

* Added contract ref to java code. Fixed broken rst markup.

* Updates transaction-building tutorial.

* Updates the client-rpc and flow-state-machines tutorials.

* Updates the oracles tutorial.

* Amended country in X500 names from "UK" to "GB"

* Update FlowCookbook.kt

* Amended cheatsheet. Minor update on contract upgrades tutoraial.

* Added `extraCordappPackagesToScan` to node driver.

* Changes to match new function signature.

* Update to reflect change in location of cash contract name.

* CORDA-670: Correct scanned packages in network visualiser (#1763)

* Add CorDapp dependency of IRS to network visualiser

* Set CorDapp directories

* Checking out the latest milestone will no longer be required. (#1761)

* Updated documentation indices (#1754)

* Update documentation indices.

* Reference a moveable tag for V1 docs.
Remove redundant warning text.

* Reverted proposed usage of new docs release tag

* Minor: print a deprecation warning when the web server starts. (#1767)

* Release and upgrade notes for V1.0 (#1736)

* Release and upgrade notes for V1.0

* Update changelog.rst

* Update changelog.rst

* Formatting.

* Incorporating review feedback from KB and MN.

* "guarantee" instead of "promise"

* Updated with final review comments from KB and RGB.

* Updated upgrade notes to describe migration from removed CordaPluginRegistry.

* Minor clarification.

* Minor updates following final RGB feedback.

* Kat's further pedantic feedback

* Minor changes following feedback from KB.

* Incorporating review feedback from MH.

* killed 'patent-pending'

* Made the visualiser into a regular JVM module - not a CorDapp. (#1771)

* Docs: more package descriptions and take non-stabilised APIs out of the docs build. (#1775)

* Update corda version tag to 1.0.0

* Updated release notes to fix minor typos (#1779)

Fixed bold type on simplified annotation driven scanning bullet and added bold type to module name bullets

* Fixed drop down.. probably. (#1780)

* fixed formatting for release notes. (#1782)

* Improve API page wording (#1784)

* Removed "unreleased" sections from the release notes and change log.

* Merge remote-tracking branch 'origin/release-V1' into colljos-merge-v1-docs

# Conflicts:
#	build.gradle
#	client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt
#	client/rpc/src/main/kotlin/net/corda/client/rpc/CordaRPCClient.kt
#	client/rpc/src/main/kotlin/net/corda/client/rpc/PermissionException.kt
#	constants.properties
#	core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
#	core/src/test/kotlin/net/corda/core/contracts/DummyContractV2Tests.kt
#	core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
#	docs/source/api-flows.rst
#	docs/source/api-index.rst
#	docs/source/changelog.rst
#	docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
#	docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
#	docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/contract/TutorialContract.kt
#	docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
#	docs/source/hello-world-state.rst
#	docs/source/key-concepts-contract-constraints.rst
#	docs/source/serialization.rst
#	docs/source/tut-two-party-flow.rst
#	docs/source/tutorial-tear-offs.rst
#	node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
#	node-api/src/test/java/net/corda/nodeapi/internal/serialization/ForbiddenLambdaSerializationTests.java
#	node-api/src/test/java/net/corda/nodeapi/internal/serialization/LambdaCheckpointSerializationTest.java
#	node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
#	node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt
#	node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
#	node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
#	node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
#	samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt
#	samples/trader-demo/src/main/kotlin/net/corda/traderdemo/TraderDemo.kt
#	testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
#	testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
#	testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
#	webserver/src/main/kotlin/net/corda/webserver/internal/NodeWebServer.kt
---
 .gitignore                                    |   3 +
 build.gradle                                  |   2 +-
 .../client/jfx/model/NetworkIdentityModel.kt  |   5 +-
 .../client/jfx/model/NodeMonitorModel.kt      |   4 +-
 .../kotlin/net/corda/core/flows/FlowLogic.kt  |   4 +
 .../net/corda/core/flows/FlowSession.kt       |   4 +-
 docs/source/_static/versions                  |   1 +
 docs/source/api-core-types.rst                |  14 -
 docs/source/api-flows.rst                     |  93 ++++-
 docs/source/api-identity.rst                  | 129 +++++++
 docs/source/api-index.rst                     |   1 +
 docs/source/changelog.rst                     |  80 ++--
 docs/source/deploying-a-node.rst              |  10 +-
 .../java/net/corda/docs/FlowCookbookJava.java |   3 +-
 .../kotlin/net/corda/docs/FlowCookbook.kt     |   3 +-
 .../net/corda/docs/LaunchSpaceshipFlow.kt     |  99 +++++
 docs/source/index.rst                         |   3 -
 .../key-concepts-contract-constraints.rst     |   4 +-
 docs/source/key-concepts-identity.rst         |  78 ++++
 docs/source/key-concepts.rst                  |   1 +
 docs/source/release-notes.rst                 | 105 +++++-
 docs/source/release-process-index.rst         |   2 +
 docs/source/resources/signatureMetadata.png   | Bin 0 -> 18666 bytes
 docs/source/resources/subTreesPrivacy.png     | Bin 0 -> 105835 bytes
 docs/source/running-the-demos.rst             |  13 +-
 docs/source/serialization.rst                 |   8 +-
 docs/source/shell.rst                         |   4 +
 docs/source/troubleshooting.rst               |   5 +
 docs/source/tut-two-party-flow.rst            |  24 +-
 docs/source/tutorial-tear-offs.rst            |   9 +-
 docs/source/upgrade-notes.rst                 | 349 ++++++++++++++++++
 .../corda/finance/flows/TwoPartyDealFlow.kt   |   2 +
 .../corda/finance/flows/TwoPartyTradeFlow.kt  |   6 +-
 .../node/services/AttachmentLoadingTests.kt   |   9 +-
 .../node/messaging/TwoPartyTradeFlowTests.kt  |  15 +-
 samples/network-visualiser/build.gradle       |  10 +-
 .../net/corda/netmap/simulation/Simulation.kt |   2 +
 .../corda/testing/contracts/DummyContract.kt  |   4 +-
 38 files changed, 980 insertions(+), 128 deletions(-)
 create mode 100644 docs/source/api-identity.rst
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/LaunchSpaceshipFlow.kt
 create mode 100644 docs/source/key-concepts-identity.rst
 create mode 100644 docs/source/resources/signatureMetadata.png
 create mode 100644 docs/source/resources/subTreesPrivacy.png
 create mode 100644 docs/source/upgrade-notes.rst

diff --git a/.gitignore b/.gitignore
index 67dc614169..ae3bd7f4de 100644
--- a/.gitignore
+++ b/.gitignore
@@ -88,6 +88,9 @@ docs/virtualenv/
 # bft-smart
 **/config/currentView
 
+# Node Explorer
+/tools/explorer/conf/CordaExplorer.properties
+
 # vim
 *.swp
 *.swn
diff --git a/build.gradle b/build.gradle
index 47fc8ef7e6..acee113b33 100644
--- a/build.gradle
+++ b/build.gradle
@@ -40,7 +40,7 @@ buildscript {
     ext.jopt_simple_version = '5.0.2'
     ext.jansi_version = '1.14'
     ext.hibernate_version = '5.2.6.Final'
-    ext.h2_version = '1.4.194'
+    ext.h2_version = '1.4.194' // Update docs if renamed or removed.
     ext.rxjava_version = '1.2.4'
     ext.dokka_version = '0.9.14'
     ext.eddsa_version = '0.2.0'
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NetworkIdentityModel.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NetworkIdentityModel.kt
index 15cf636622..9ff83660aa 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NetworkIdentityModel.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NetworkIdentityModel.kt
@@ -42,7 +42,10 @@ class NetworkIdentityModel {
     }.map { it?.party }.filterNotNull()
 
     val notaryNodes: ObservableList<NodeInfo> = notaries.map { rpcProxy.value?.nodeInfoFromParty(it) }.filterNotNull()
-    val parties: ObservableList<NodeInfo> = networkIdentities.filtered { it.legalIdentities.all { it !in notaries } }
+    val parties: ObservableList<NodeInfo> = networkIdentities
+            .filtered { it.legalIdentities.all { it !in notaries } }
+            // TODO: REMOVE THIS HACK WHEN NETWORK MAP REDESIGN WORK IS COMPLETED.
+            .filtered { it.legalIdentities.all { it.name.organisation != "Network Map Service" } }
     val myIdentity = rpcProxy.map { it?.nodeInfo()?.legalIdentitiesAndCerts?.first()?.party }
 
     fun partyFromPublicKey(publicKey: PublicKey): ObservableValue<NodeInfo?> = identityCache[publicKey]
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt
index 9bece5edcc..9a4da742b0 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt
@@ -57,8 +57,8 @@ class NodeMonitorModel {
      */
     fun register(nodeHostAndPort: NetworkHostAndPort, username: String, password: String) {
         val client = CordaRPCClient(
-                hostAndPort = nodeHostAndPort,
-                configuration = CordaRPCClientConfiguration.DEFAULT.copy(
+                 nodeHostAndPort,
+                 CordaRPCClientConfiguration.DEFAULT.copy(
                         connectionMaxRetryInterval = 10.seconds
                 )
         )
diff --git a/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt b/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
index 9145ae4baa..fd2c144d9e 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
@@ -55,6 +55,10 @@ abstract class FlowLogic<out T> {
      */
     val serviceHub: ServiceHub get() = stateMachine.serviceHub
 
+    /**
+     * Creates a communication session with [party]. Subsequently you may send/receive using this session object. Note
+     * that this function does not communicate in itself, the counter-flow will be kicked off by the first send/receive.
+     */
     @Suspendable
     fun initiateFlow(party: Party): FlowSession = stateMachine.initiateFlow(party, flowUsedForSessions)
 
diff --git a/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt b/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
index 7effaa9f52..07e4b49d33 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
@@ -6,8 +6,8 @@ import net.corda.core.utilities.UntrustworthyData
 
 /**
  *
- * A [FlowSession] is a handle on a communication sequence between two flows. It is used to send and receive messages
- *   between flows.
+ * A [FlowSession] is a handle on a communication sequence between two paired flows, possibly running on separate nodes.
+ *   It is used to send and receive messages between the flows as well as to query information about the counter-flow.
  *
  * There are two ways of obtaining such a session:
  *
diff --git a/docs/source/_static/versions b/docs/source/_static/versions
index 4110e2dfd6..1152a8e46a 100644
--- a/docs/source/_static/versions
+++ b/docs/source/_static/versions
@@ -8,5 +8,6 @@
 	"https://docs.corda.net/releases/release-M12.1": "M12.1",
 	"https://docs.corda.net/releases/release-M13.0": "M13.0",
 	"https://docs.corda.net/releases/release-M14.0": "M14.0",
+	"https://docs.corda.net/releases/release-V1.0": "V1.0",
 	"https://docs.corda.net/head/": "Master"
 }
diff --git a/docs/source/api-core-types.rst b/docs/source/api-core-types.rst
index e69c5d858d..e7f3c898ee 100644
--- a/docs/source/api-core-types.rst
+++ b/docs/source/api-core-types.rst
@@ -20,20 +20,6 @@ Any object that needs to be identified by its hash should implement the ``NamedB
 ``SecureHash`` is a sealed class that only defines a single subclass, ``SecureHash.SHA256``. There are utility methods
 to create and parse ``SecureHash.SHA256`` objects.
 
-Party
------
-Identities on the network are represented by ``AbstractParty``. There are two types of ``AbstractParty``:
-
-* ``Party``, identified by a ``PublicKey`` and a ``CordaX500Name``
-
-* ``AnonymousParty``, identified by a ``PublicKey``
-
-For example, in a transaction sent to your node as part of a chain of custody it is important you can convince yourself
-of the transaction's validity, but equally important that you don't learn anything about who was involved in that
-transaction. In these cases ``AnonymousParty`` should be used. In contrast, for internal processing where extended
-details of a party are required, the ``Party`` class should be used. The identity service provides functionality for
-resolving anonymous parties to full parties.
-
 CompositeKey
 ------------
 Corda supports scenarios where more than one signature is required to authorise a state object transition. For example:
diff --git a/docs/source/api-flows.rst b/docs/source/api-flows.rst
index 99cddf74b2..931aa493df 100644
--- a/docs/source/api-flows.rst
+++ b/docs/source/api-flows.rst
@@ -377,10 +377,11 @@ as it likes, and each party can invoke a different response flow:
         :end-before: DOCEND 6
         :dedent: 12
 
-.. warning:: If you initiate several counter flows from the same ``@InitiatingFlow`` flow then on the receiving side you
-   must be prepared to be initiated by any of the corresponding ``initiateFlow()`` calls! A good way of handling this
-   ambiguity is to send as a first message a "role" message to the initiated flow, indicating which part of the
-   initiating flow the rest of the counter-flow should conform to.
+.. warning:: If you initiate several flows from the same ``@InitiatingFlow`` flow then on the receiving side you must be
+   prepared to be initiated by any of the corresponding ``initiateFlow()`` calls! A good way of handling this ambiguity
+   is to send as a first message a "role" message to the initiated flow, indicating which part of the initiating flow
+   the rest of the counter-flow should conform to. For example send an enum, and on the other side start with a switch
+   statement.
 
 SendAndReceive
 ~~~~~~~~~~~~~~
@@ -426,20 +427,52 @@ Our side of the flow must mirror these calls. We could do this as follows:
         :end-before: DOCEND 8
         :dedent: 12
 
-Porting from the old Party-based API
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Why sessions?
+^^^^^^^^^^^^^
 
 Before ``FlowSession`` s were introduced the send/receive API looked a bit different. They were functions on
 ``FlowLogic`` and took the address ``Party`` as argument. The platform internally maintained a mapping from ``Party`` to
 session, hiding sessions from the user completely.
 
-However we realised that this could introduce subtle bugs and security issues where sends meant for different sessions
-may end up in the same session if the target ``Party`` happens to be the same.
+Although this is a convenient API it introduces subtle issues where a message that was originally meant for a specific
+session may end up in another.
 
-Therefore the session concept is now exposed through ``FlowSession`` which disambiguates which communication sequence a
-message is intended for.
+Consider the following contrived example using the old ``Party`` based API:
 
-In the old API the first ``send`` or ``receive`` to a ``Party`` was the one kicking off the counterflow. This is now
+.. container:: codeset
+
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/LaunchSpaceshipFlow.kt
+        :language: kotlin
+        :start-after: DOCSTART LaunchSpaceshipFlow
+        :end-before: DOCEND LaunchSpaceshipFlow
+
+The intention of the flows is very clear: LaunchSpaceshipFlow asks the president whether a spaceship should be launched.
+It is expecting a boolean reply. The president in return first tells the secretary that they need coffee, which is also
+communicated with a boolean. Afterwards the president replies to the launcher that they don't want to launch.
+
+However the above can go horribly wrong when the ``launcher`` happens to be the same party ``getSecretary`` returns. In
+this case the boolean meant for the secretary will be received by the launcher!
+
+This indicates that ``Party`` is not a good identifier for the communication sequence, and indeed the ``Party`` based
+API may introduce ways for an attacker to fish for information and even trigger unintended control flow like in the
+above case.
+
+Hence we introduced ``FlowSession``, which identifies the communication sequence. With ``FlowSession`` s the above set
+of flows would look like this:
+
+.. container:: codeset
+
+    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/LaunchSpaceshipFlow.kt
+        :language: kotlin
+        :start-after: DOCSTART LaunchSpaceshipFlowCorrect
+        :end-before: DOCEND LaunchSpaceshipFlowCorrect
+
+Note how the president is now explicit about which session it wants to send to.
+
+Porting from the old Party-based API
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In the old API the first ``send`` or ``receive`` to a ``Party`` was the one kicking off the counter-flow. This is now
 explicit in the ``initiateFlow`` function call. To port existing code:
 
 .. container:: codeset
@@ -460,24 +493,28 @@ explicit in the ``initiateFlow`` function call. To port existing code:
 Subflows
 --------
 
-Subflows are pieces of reusable flows that may be run by calling ``FlowLogic.subFlow``.
+Subflows are pieces of reusable flows that may be run by calling ``FlowLogic.subFlow``. There are two broad categories
+of subflows, inlined and initiating ones. The main difference lies in the counter-flow's starting method, initiating
+ones initiate counter-flows automatically, while inlined ones expect some parent counter-flow to run the inlined
+counter-part.
 
 Inlined subflows
 ^^^^^^^^^^^^^^^^
 
-Inlined subflows inherit their calling flow's type when initiating a new session with a counterparty. For example say
+Inlined subflows inherit their calling flow's type when initiating a new session with a counterparty. For example, say
 we have flow A calling an inlined subflow B, which in turn initiates a session with a party. The FlowLogic type used to
-determine which counterflow should be kicked off will be A, not B. Note that this means that the other side of this
-session must therefore be called explicitly in the kicked off flow as well.
+determine which counter-flow should be kicked off will be A, not B. Note that this means that the other side of this
+inlined flow must therefore be implemented explicitly in the kicked off flow as well. This may be done by calling a
+matching inlined counter-flow, or by implementing the other side explicitly in the kicked off parent flow.
 
 An example of such a flow is ``CollectSignaturesFlow``. It has a counter-flow ``SignTransactionFlow`` that isn't
-annotated with ``InitiatedBy``. This is because both of these flows are inlined, the kick-off relationship will be
+annotated with ``InitiatedBy``. This is because both of these flows are inlined; the kick-off relationship will be
 defined by the parent flows calling ``CollectSignaturesFlow`` and ``SignTransactionFlow``.
 
 In the code inlined subflows appear as regular ``FlowLogic`` instances, `without` either of the ``@InitiatingFlow`` or
 ``@InitiatedBy`` annotation.
 
-.. note:: Inlined flows aren't versioned, they inherit their parent flow's version.
+.. note:: Inlined flows aren't versioned; they inherit their parent flow's version.
 
 Initiating subflows
 ^^^^^^^^^^^^^^^^^^^
@@ -493,7 +530,7 @@ Core initiating subflows
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
 Corda-provided initiating subflows are a little different to standard ones as they are versioned together with the
-platform, and their initiated counterflows are registered explicitly, so there is no need for the ``InitiatedBy``
+platform, and their initiated counter-flows are registered explicitly, so there is no need for the ``InitiatedBy``
 annotation.
 
 An example is the ``FinalityFlow``/``FinalityHandler`` flow pair.
@@ -504,8 +541,10 @@ Built-in subflows
 Corda provides a number of built-in flows that should be used for handling common tasks. The most important are:
 
 * ``CollectSignaturesFlow`` (inlined), which should be used to collect a transaction's required signatures
-* ``FinalityFlow`` (initiating), which should be used to notarise and record a transaction
-* ``SendTransactionFlow`` (inlined), which should be used to send a signed transaction if it needed to be resolved on the other side.
+* ``FinalityFlow`` (initiating), which should be used to notarise and record a transaction as well as to broadcast it to
+  all relevant parties
+* ``SendTransactionFlow`` (inlined), which should be used to send a signed transaction if it needed to be resolved on
+  the other side.
 * ``ReceiveTransactionFlow`` (inlined), which should be used receive a signed transaction
 * ``ContractUpgradeFlow`` (initiating), which should be used to change a state's contract
 * ``NotaryChangeFlow`` (initiating), which should be used to change a state's notary
@@ -641,6 +680,20 @@ We can also send and receive a ``StateAndRef`` dependency chain and automaticall
         :end-before: DOCEND 14
         :dedent: 12
 
+Why inlined subflows?
+^^^^^^^^^^^^^^^^^^^^^
+
+Inlined subflows provide a way to share commonly used flow code `while forcing users to create a parent flow`. Take for
+example ``CollectSignaturesFlow``. Say we made it an initiating flow that automatically kicks off
+``SignTransactionFlow`` that signs the transaction. This would mean malicious nodes can just send any old transaction to
+us using ``CollectSignaturesFlow`` and we would automatically sign it!
+
+By making this pair of flows inlined we provide control to the user over whether to sign the transaction or not by
+forcing them to nest it in their own parent flows.
+
+In general if you're writing a subflow the decision of whether you should make it initiating should depend on whether
+the counter-flow needs broader context to achieve its goal.
+
 FlowException
 -------------
 Suppose a node throws an exception while running a flow. Any counterparty flows waiting for a message from the node
diff --git a/docs/source/api-identity.rst b/docs/source/api-identity.rst
new file mode 100644
index 0000000000..270e31bafd
--- /dev/null
+++ b/docs/source/api-identity.rst
@@ -0,0 +1,129 @@
+API: Identity
+=============
+
+.. note:: Before reading this page, you should be familiar with the key concepts of :doc:`key-concepts-identity`.
+
+.. contents::
+
+Party
+-----
+Identities on the network are represented by ``AbstractParty``. There are two types of ``AbstractParty``:
+
+* ``Party``, identified by a ``PublicKey`` and a ``CordaX500Name``
+
+* ``AnonymousParty``, identified by a ``PublicKey``
+
+For example, in a transaction sent to your node as part of a chain of custody it is important you can convince yourself
+of the transaction's validity, but equally important that you don't learn anything about who was involved in that
+transaction. In these cases ``AnonymousParty`` should be used by flows constructing when transaction states and commands.
+In contrast, for internal processing where extended details of a party are required, the ``Party`` class should be used
+instead. The identity service provides functionality for flows to resolve anonymous parties to full parties, dependent
+on the anonymous party's identity having been registered with the node earlier (typically this is handled by
+``SwapIdentitiesFlow`` or ``IdentitySyncFlow``, discussed below).
+
+Party names are held within the ``CordaX500Name`` data class, which enforces the structure of names within Corda, as
+well as ensuring a consistent rendering of the names in plain text.
+
+The support for both Party and AnonymousParty classes in Corda enables sophisticated selective disclosure of identity
+information. For example, it is possible to construct a Transaction using an AnonymousParty, so nobody can learn of your
+involvement by inspection of the transaction, yet prove to specific counterparts that this AnonymousParty actually is
+owned by your well known identity. This disclosure is achieved through the use of the PartyAndCertificate data class
+which can be propagated to those who need to know, and contains the Party's X.509 certificate path to provide proof of
+ownership by a well known identity.
+
+The PartyAndCertificate class is also used in the network map service to represent well known identities, in which
+scenario the certificate path proves its issuance by the Doorman service.
+
+
+Confidential Identities
+-----------------------
+
+Confidential identities are key pairs where the corresponding X.509 certificate (and path) are not made public, so that parties who
+are not involved in the transaction cannot identify its participants. They are owned by a well known identity, which
+must sign the X.509 certificate. Before constructing a new transaction the involved parties must generate and send new
+confidential identities to each other, a process which is managed using ``SwapIdentitiesFlow`` (discussed below). The
+public keys of these confidential identities are then used when generating output states and commands for the transaction.
+
+Where using outputs from a previous transaction in a new transaction, counterparties may need to know who the involved
+parties are. One example is in ``TwoPartyTradeFlow`` which delegates to ``CollectSignaturesFlow`` to gather certificates
+from both parties. ``CollectSignaturesFlow`` requires that a confidential identity of the initiating node has signed
+the transaction, and verifying this requires the receiving node has a copy of the confidential identity for the input
+state. ``IdentitySyncFlow`` can be used to synchronize the confidential identities we have the certificate paths for, in
+a single transaction, to another node.
+
+.. note:: ``CollectSignaturesFlow`` requires that the initiating node has signed the transaction, and as such all nodes
+   providing signatures must recognise the signing key used by the initiating node as being either its well known identity
+   or a confidential identity they have the certificate for.
+
+Swap identities flow
+~~~~~~~~~~~~~~~~~~~~
+
+``SwapIdentitiesFlow`` takes the party to swap identities with in its constructor (the counterparty), and is typically run as a subflow of
+another flow. It returns a mapping from well known identities of the calling flow and our counterparty to the new
+confidential identities; in future this will be extended to handle swapping identities with multiple parties.
+You can see an example of it being used in ``TwoPartyDealFlow.kt``:
+
+.. container:: codeset
+
+    .. literalinclude:: ../../finance/src/main/kotlin/net/corda/finance/flows/TwoPartyDealFlow.kt
+        :language: kotlin
+        :start-after: DOCSTART 2
+        :end-before: DOCEND 2
+
+The swap identities flow goes through the following key steps:
+
+1. Generate a nonce value to form a challenge to the other nodes.
+2. Send nonce value to all counterparties, and receive their nonce values.
+3. Generate a new confidential identity from our well known identity.
+4. Create a data blob containing the new confidential identity (public key, name and X.509 certificate path),
+   and the hash of the nonce values.
+5. Sign the resulting data blob with the confidential identity's private key.
+6. Send the confidential identity and data blob signature to all counterparties, while receiving theirs.
+7. Verify the signatures to ensure that identities were generated by the involved set of parties.
+8. Verify the confidential identities are owned by the expected well known identities.
+9. Store the confidential identities and return them to the calling flow.
+
+This ensures not only that the confidential identity X.509 certificates are signed by the correct well known identities,
+but also that the confidential identity private key is held by the counterparty, and that a party cannot claim ownership
+another party's confidential identities belong to its well known identity.
+
+Identity synchronization flow
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When constructing a transaction whose input states reference confidential identities, it is common for other signing
+entities (counterparties) to require to know which well known identities those confidential identities map to. The
+``IdentitySyncFlow`` handles this process, and you can see an example of its use in ``TwoPartyTradeFlow.kt``:
+
+.. container:: codeset
+
+    .. literalinclude:: ../../finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt
+        :language: kotlin
+        :start-after: DOCSTART 6
+        :end-before: DOCEND 6
+
+The identity synchronization flow goes through the following key steps:
+
+1. Extract participant identities from all input and output states and remove any well known identities. Required signers
+   on commands are currently ignored as they are presumed to be included in the participants on states, or to be well
+   known identities of services (such as an oracle service).
+2. For each counterparty node, send a list of the public keys of the confidential identities, and receive back a list
+   of those the counterparty needs the certificate path for.
+3. Verify the requested list of identities contains only confidential identities in the offered list, and abort otherwise.
+4. Send the requested confidential identities as ``PartyAndCertificate`` instances to the counterparty.
+
+.. note:: ``IdentitySyncFlow`` works on a push basis. The initiating node can only send confidential identities it has
+   the X.509 certificates for, and the remote nodes can only request confidential identities being offered (are
+   referenced in the transaction passed to the initiating flow). There is no standard flow for nodes to collect
+   confidential identities before assembling a transaction, and this is left for individual flows to manage if required.
+
+``IdentitySyncFlow`` will serve all confidential identities in the provided transaction, irrespective of well known
+identity. This is important for more complex transaction cases with 3+ parties, for example:
+
+* Alice is building the transaction, and provides some input state *x* owned by a confidential identity of Alice
+* Bob provides some input state *y* owned by a confidential identity of Bob
+* Charlie provides some input state *z* owned by a confidential identity of Charlie
+
+Alice may know all of the confidential identities ahead of time, but Bob not know about Charlie's and vice-versa.
+The assembled transaction therefore has three input states *x*, *y* and *z*, for which only Alice possesses certificates
+for all confidential identities. ``IdentitySyncFlow`` must send not just Alice's confidential identity but also any other
+identities in the transaction to the Bob and Charlie.
diff --git a/docs/source/api-index.rst b/docs/source/api-index.rst
index d229c040ad..c3486e4cea 100644
--- a/docs/source/api-index.rst
+++ b/docs/source/api-index.rst
@@ -12,6 +12,7 @@ This section describes the APIs that are available for the development of CorDap
    api-vault-query
    api-transactions
    api-flows
+   api-identity
    api-service-hub
    api-rpc
    api-core-types
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index d02e2d8f62..0012e64902 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -19,6 +19,8 @@ UNRELEASED
   either annotated with the @CordaSerializable annotation or explicitly whitelisted then a NotSerializableException is
   thrown.
 
+.. _changelog_v1:
+
 Release 1.0
 -----------
 
@@ -27,36 +29,45 @@ Release 1.0
 
 * Java 8 lambdas now work property with Kryo during check-pointing.
 
+* Java 8 serializable lambdas now work property with Kryo during check-pointing.
+
 * String constants have been marked as ``const`` type in Kotlin, eliminating cases where functions of the form
   ``get<constant name>()`` were created for the Java API. These can now be referenced by their name directly.
 
 * ``FlowLogic`` communication has been extensively rewritten to use functions on ``FlowSession`` as the base for communication
   between nodes.
+
   * Calls to ``send()``, ``receive()`` and ``sendAndReceive()`` on FlowLogic should be replaced with calls
     to the function of the same name on ``FlowSession``. Note that the replacement functions do not take in a destination
     parameter, as this is defined in the session.
   * Initiated flows now take in a ``FlowSession`` instead of ``Party`` in their constructor. If you need to access the
     counterparty identity, it is in the ``counterparty`` property of the flow session.
 
+
 * Added X509EdDSAEngine to intercept and rewrite EdDSA public keys wrapped in X509Key instances. This corrects an issue
   with verifying certificate paths loaded from a Java Keystore where they contain EdDSA keys.
 
-* generateSpend() now creates a new confidential identity for the change address rather than using the identity of the
-  input state owner.
+* Confidential identities are now complete:
+
+   * The identity negotiation flow is now called ``SwapIdentitiesFlow``, renamed from ``TransactionKeyFlow``.
+   * generateSpend() now creates a new confidential identity for the change address rather than using the identity of the
+     input state owner.
+   * Please see the documentation :doc:`key-concepts-identity` and :doc:`api-identity` for more details.
 
 * Remove the legacy web front end from the SIMM demo.
 
 * ``NodeInfo`` and ``NetworkMapCache`` changes:
+
    * Removed ``NodeInfo::legalIdentity`` in preparation for handling of multiple identities. We left list of ``NodeInfo::legalIdentitiesAndCerts``,
-   the first identity still plays a special role of main node identity.
+     the first identity still plays a special role of main node identity.
    * We no longer support advertising services in network map. Removed ``NodeInfo::advertisedServices``, ``serviceIdentities``
-   and ``notaryIdentity``.
+     and ``notaryIdentity``.
    * Removed service methods from ``NetworkMapCache``: ``partyNodes``, ``networkMapNodes``, ``notaryNodes``, ``regulatorNodes``,
-   ``getNodesWithService``, ``getPeersWithService``, ``getRecommended``, ``getNodesByAdvertisedServiceIdentityKey``, ``getAnyNotary``,
-   ``notaryNode``, ``getAnyServiceOfType``. To get all known ``NodeInfo``s call ``allNodes``.
+     ``getNodesWithService``, ``getPeersWithService``, ``getRecommended``, ``getNodesByAdvertisedServiceIdentityKey``, ``getAnyNotary``,
+     ``notaryNode``, ``getAnyServiceOfType``. To get all known ``NodeInfo``'s call ``allNodes``.
    * In preparation for ``NetworkMapService`` redesign and distributing notaries through ``NetworkParameters`` we added
-   ``NetworkMapCache::notaryIdentities`` list to enable to lookup for notary parties known to the network. Related ``CordaRPCOps::notaryIdentities``
-   was introduced. Other special nodes parties like Oracles or Regulators need to be specified directly in CorDapp or flow.
+     ``NetworkMapCache::notaryIdentities`` list to enable to lookup for notary parties known to the network. Related ``CordaRPCOps::notaryIdentities``
+     was introduced. Other special nodes parties like Oracles or Regulators need to be specified directly in CorDapp or flow.
    * Moved ``ServiceType`` and ``ServiceInfo`` to ``net.corda.nodeapi`` package as services are only required on node startup.
 
 * Adding enum support to the class carpenter
@@ -71,7 +82,7 @@ Release 1.0
 * About half of the code in test-utils has been moved to a new module ``node-driver``,
   and the test scope modules are now located in a ``testing`` directory.
 
-* CordaPluginRegistry has been renamed to SerializationWhitelist and moved to the net.corda.core.serialization
+* ``CordaPluginRegistry`` has been renamed to ``SerializationWhitelist`` and moved to the ``net.corda.core.serialization``
   package. The API for whitelisting types that can't be annotated was slightly simplified. This class used to contain
   many things, but as we switched to annotations and classpath scanning over time it hollowed out until this was
   the only functionality left.  You also need to rename your services resource file to the new class name.
@@ -93,10 +104,14 @@ Release 1.0
 * Vault Query fix: filter by multiple issuer names in ``FungibleAssetQueryCriteria``
 
 * Following deprecated methods have been removed:
+
   * In ``DataFeed``
+
     * ``first`` and ``current``, replaced by ``snapshot``
     * ``second`` and ``future``, replaced by ``updates``
+
   * In ``CordaRPCOps``
+
     * ``stateMachinesAndUpdates``, replaced by ``stateMachinesFeed``
     * ``verifiedTransactions``, replaced by ``verifiedTransactionsFeed``
     * ``stateMachineRecordedTransactionMapping``, replaced by ``stateMachineRecordedTransactionMappingFeed``
@@ -106,13 +121,12 @@ Release 1.0
   ``ResolveTransactionsFlow`` has been made internal. Instead merge the receipt of the ``SignedTransaction`` and the subsequent
   sub-flow call to ``ResolveTransactionsFlow`` with a single call to ``ReceiveTransactionFlow``. The flow running on the counterparty
   must use ``SendTransactionFlow`` at the correct place. There is also ``ReceiveStateAndRefFlow`` and ``SendStateAndRefFlow`` for
-  dealing with ``StateAndRef``s.
+  dealing with ``StateAndRef``'s.
 
 * Vault query soft locking enhancements and deprecations
+
   * removed original ``VaultService`` ``softLockedStates` query mechanism.
-  * introduced improved ``SoftLockingCondition`` filterable attribute in ``VaultQueryCriteria`` to enable specification
-    of different soft locking retrieval behaviours (exclusive of soft locked states, soft locked states only, specified
-    by set of lock ids)
+  * introduced improved ``SoftLockingCondition`` filterable attribute in ``VaultQueryCriteria`` to enable specification of different soft locking retrieval behaviours (exclusive of soft locked states, soft locked states only, specified by set of lock ids)
 
 * Trader demo now issues cash and commercial paper directly from the bank node, rather than the seller node self-issuing
   commercial paper but labelling it as if issued by the bank.
@@ -122,7 +136,7 @@ Release 1.0
   If you specifically need well known identities, use the network map, which is the authoritative source of current well
   known identities.
 
-* Currency-related API in ``net.corda.core.contracts.ContractsDSL`` has moved to ```net.corda.finance.CurrencyUtils`.
+* Currency-related API in ``net.corda.core.contracts.ContractsDSL`` has moved to ```net.corda.finance.CurrencyUtils``.
 
 * Remove `IssuerFlow` as it allowed nodes to request arbitrary amounts of cash to be issued from any remote node. Use
   `CashIssueFlow` instead.
@@ -174,15 +188,16 @@ Release 1.0
 
 * The unused ``MetaData`` and ``SignatureType`` in ``crypto`` package have been removed.
 
-* The ``class TransactionSignature(bytes: ByteArray, val by: PublicKey, val signatureMetadata: SignatureMetadata): DigitalSignature(bytes)``
-  class is now utilised Vs the old ``DigitalSignature.WithKey`` for Corda transaction signatures. Practically, it takes
-  the ``signatureMetadata`` as an extra input, in order to support signing both the transaction and the extra metadata.
+* The ``class TransactionSignature(bytes: ByteArray, val by: PublicKey, val signatureMetadata:``
+  ``SignatureMetadata): DigitalSignature(bytes)`` class is now utilised Vs the old ``DigitalSignature.WithKey`` for
+  Corda transaction signatures. Practically, it takes the ``signatureMetadata`` as an extra input, in order to support
+  signing both the transaction and the extra metadata.
 
 * To reflect changes in the signing process, the ``Crypto`` object is now equipped with the:
   ``fun doSign(keyPair: KeyPair, signableData: SignableData): TransactionSignature`` and
   ``fun doVerify(txId: SecureHash, transactionSignature: TransactionSignature): Boolean`` functions.
 
-* ``SerializationCustomization.addToWhitelist()` now accepts multiple classes via varargs.
+* ``SerializationCustomization.addToWhitelist()`` now accepts multiple classes via varargs.
 
 * Two functions to easily sign a ``FilteredTransaction`` have been added to ``ServiceHub``:
   ``createSignature(filteredTransaction: FilteredTransaction, publicKey: PublicKey)`` and
@@ -212,8 +227,8 @@ Release 1.0
 * All of the ``serializedHash`` and ``computeNonce`` functions have been removed from ``MerkleTransaction``.
   The ``serializedHash(x: T)`` and ``computeNonce`` were moved to ``CryptoUtils``.
 
-* Two overloaded methods ``componentHash(opaqueBytes: OpaqueBytes, privacySalt: PrivacySalt, componentGroupIndex: Int,
-  internalIndex: Int): SecureHash`` and ``componentHash(nonce: SecureHash, opaqueBytes: OpaqueBytes): SecureHash`` have
+* Two overloaded methods ``componentHash(opaqueBytes: OpaqueBytes, privacySalt: PrivacySalt,``
+  ``componentGroupIndex: Int, internalIndex: Int): SecureHash`` and ``componentHash(nonce: SecureHash, opaqueBytes: OpaqueBytes): SecureHash`` have
   been added to ``CryptoUtils``. Similarly to ``computeNonce``, they internally use SHA256d for nonce and leaf hash
   computations.
 
@@ -224,24 +239,25 @@ Release 1.0
   ``FilteredTransaction`` now extend ``TraversableTransaction``.
 
 * Two classes, ``ComponentGroup(open val groupIndex: Int, open val components: List<OpaqueBytes>)`` and
-  ``FilteredComponentGroup(override val groupIndex: Int, override val components: List<OpaqueBytes>,
-      val nonces: List<SecureHash>, val partialMerkleTree: PartialMerkleTree): ComponentGroup(groupIndex, components)``
-  have been added, which are properties of the ``WireTransaction`` and ``FilteredTransaction``, respectively.
+  ``FilteredComponentGroup(override val groupIndex: Int, override val components:``
+  ``List<OpaqueBytes>, val nonces: List<SecureHash>, val partialMerkleTree:``
+  ``PartialMerkleTree): ComponentGroup(groupIndex, components)`` have been added, which are properties
+  of the ``WireTransaction`` and ``FilteredTransaction``, respectively.
 
 * ``checkAllComponentsVisible(componentGroupEnum: ComponentGroupEnum)`` is added to ``FilteredTransaction``, a new
   function to check if all components are visible in a specific component-group.
 
 * To allow for backwards compatibility, ``WireTransaction`` and ``FilteredTransaction`` have new fields and
   constructors: ``WireTransaction(componentGroups: List<ComponentGroup>, privacySalt: PrivacySalt = PrivacySalt())``,
-  ``FilteredTransaction private constructor(id: SecureHash,filteredComponentGroups: List<FilteredComponentGroup>,
-      groupHashes: List<SecureHash>``. ``FilteredTransaction`` is still built via
-  ``buildFilteredTransaction(wtx: WireTransaction, filtering: Predicate<Any>).
+  ``FilteredTransaction private constructor(id: SecureHash,filteredComponentGroups:``
+  ``List<FilteredComponentGroup>, groupHashes: List<SecureHash>``. ``FilteredTransaction`` is still built via
+  ``buildFilteredTransaction(wtx: WireTransaction, filtering: Predicate<Any>)``.
 
 * ``FilteredLeaves`` class have been removed and as a result we can directly call the components from
   ``FilteredTransaction``, such as ``ftx.inputs`` Vs the old ``ftx.filteredLeaves.inputs``.
 
 * A new ``ComponentGroupEnum`` is added with the following enum items: ``INPUTS_GROUP``, ``OUTPUTS_GROUP``,
- ``COMMANDS_GROUP``, ``ATTACHMENTS_GROUP``, ``NOTARY_GROUP``, ``TIMEWINDOW_GROUP``.
+  ``COMMANDS_GROUP``, ``ATTACHMENTS_GROUP``, ``NOTARY_GROUP``, ``TIMEWINDOW_GROUP``.
 
 * ``ContractUpgradeFlow.Initiator`` has been renamed to ``ContractUpgradeFlow.Initiate``
 
@@ -250,6 +266,8 @@ Release 1.0
 * Current implementation of SSL in ``CordaRPCClient`` has been removed until we have a better solution which doesn't rely
   on the node's keystore.
 
+.. _changelog_m14:
+
 Milestone 14
 ------------
 
@@ -343,6 +361,8 @@ Milestone 14
 * Added JPA ``AbstractPartyConverter`` to ensure identity schema attributes are persisted securely according to type
   (well known party, resolvable anonymous party, completely anonymous party).
 
+.. _changelog_m13:
+
 Milestone 13
 ------------
 
@@ -422,8 +442,10 @@ support for more currencies to the DemoBench and Explorer tools.
     * Upgraded BouncyCastle to v1.57.
     * Upgraded Requery to v1.3.1.
 
-Milestone 12
-------------
+.. _changelog_m12:
+
+Milestone 12 (First Public Beta)
+--------------------------------
 
 * Quite a few changes have been made to the flow API which should make things simpler when writing CorDapps:
 
diff --git a/docs/source/deploying-a-node.rst b/docs/source/deploying-a-node.rst
index 0517d61c4d..562df5952f 100644
--- a/docs/source/deploying-a-node.rst
+++ b/docs/source/deploying-a-node.rst
@@ -61,6 +61,14 @@ one node as running the network map service, by putting their name in the ``netw
 
 .. warning:: When adding nodes, make sure that there are no port clashes!
 
+If your CorDapp is written in Java, you should also add the following Gradle snippet so that you can pass named arguments to your flows via the Corda shell:
+
+.. sourcecode:: groovy
+
+    tasks.withType(JavaCompile) {
+        options.compilerArgs << "-parameters"
+    }
+
 Any CorDapps defined in the project's source folders are also automatically registered with all the nodes defined in
 ``deployNodes``, even if the CorDapps are not listed in each node's ``cordapps`` entry.
 
@@ -86,4 +94,4 @@ run all the nodes at once. Each node in the ``nodes`` folder has the following s
 
 .. note:: Outside of development environments, do not store your node directories in the build folder.
 
-If you make any changes to your ``deployNodes`` task, you will need to re-run the task to see the changes take effect.
\ No newline at end of file
+If you make any changes to your ``deployNodes`` task, you will need to re-run the task to see the changes take effect.
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
index c9d708540d..1946a2501d 100644
--- a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
+++ b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
@@ -267,8 +267,7 @@ public class FlowCookbookJava {
 
             // We then need to pair our output state with a contract.
             // DOCSTART 47
-            String contractName = "net.corda.testing.contracts.DummyContract";
-            StateAndContract ourOutput = new StateAndContract(ourOutputState, contractName);
+            StateAndContract ourOutput = new StateAndContract(ourOutputState, DummyContract.PROGRAM_ID);
             // DOCEND 47
 
             // Commands pair a ``CommandData`` instance with a list of
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 8aa248f709..1fbee1e1be 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
@@ -255,8 +255,7 @@ class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty:
 
         // We then need to pair our output state with a contract.
         // DOCSTART 47
-        val contractName: String = "net.corda.testing.contracts.DummyContract"
-        val ourOutput: StateAndContract = StateAndContract(ourOutputState, contractName)
+        val  ourOutput: StateAndContract = StateAndContract(ourOutputState, DummyContract.PROGRAM_ID)
         // DOCEND 47
 
         // Commands pair a ``CommandData`` instance with a list of
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/LaunchSpaceshipFlow.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/LaunchSpaceshipFlow.kt
new file mode 100644
index 0000000000..e6826fa213
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/LaunchSpaceshipFlow.kt
@@ -0,0 +1,99 @@
+package net.corda.docs
+
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.FlowSession
+import net.corda.core.flows.InitiatedBy
+import net.corda.core.flows.InitiatingFlow
+import net.corda.core.identity.Party
+import net.corda.core.utilities.unwrap
+
+// DOCSTART LaunchSpaceshipFlow
+@InitiatingFlow
+class LaunchSpaceshipFlow : FlowLogic<Unit>() {
+    @Suspendable
+    override fun call() {
+        val shouldLaunchSpaceship = receive<Boolean>(getPresident()).unwrap { it }
+        if (shouldLaunchSpaceship) {
+            launchSpaceship()
+        }
+    }
+
+    fun launchSpaceship() {
+    }
+
+    fun getPresident(): Party {
+        TODO()
+    }
+}
+
+@InitiatedBy(LaunchSpaceshipFlow::class)
+@InitiatingFlow
+class PresidentSpaceshipFlow(val launcher: Party) : FlowLogic<Unit>() {
+    @Suspendable
+    override fun call() {
+        val needCoffee = true
+        send(getSecretary(), needCoffee)
+        val shouldLaunchSpaceship = false
+        send(launcher, shouldLaunchSpaceship)
+    }
+
+    fun getSecretary(): Party {
+        TODO()
+    }
+}
+
+@InitiatedBy(PresidentSpaceshipFlow::class)
+class SecretaryFlow(val president: Party) : FlowLogic<Unit>() {
+    @Suspendable
+    override fun call() {
+        // ignore
+    }
+}
+// DOCEND LaunchSpaceshipFlow
+
+// DOCSTART LaunchSpaceshipFlowCorrect
+@InitiatingFlow
+class LaunchSpaceshipFlowCorrect : FlowLogic<Unit>() {
+    @Suspendable
+    override fun call() {
+        val presidentSession = initiateFlow(getPresident())
+        val shouldLaunchSpaceship = presidentSession.receive<Boolean>().unwrap { it }
+        if (shouldLaunchSpaceship) {
+            launchSpaceship()
+        }
+    }
+
+    fun launchSpaceship() {
+    }
+
+    fun getPresident(): Party {
+        TODO()
+    }
+}
+
+@InitiatedBy(LaunchSpaceshipFlowCorrect::class)
+@InitiatingFlow
+class PresidentSpaceshipFlowCorrect(val launcherSession: FlowSession) : FlowLogic<Unit>() {
+    @Suspendable
+    override fun call() {
+        val needCoffee = true
+        val secretarySession = initiateFlow(getSecretary())
+        secretarySession.send(needCoffee)
+        val shouldLaunchSpaceship = false
+        launcherSession.send(shouldLaunchSpaceship)
+    }
+
+    fun getSecretary(): Party {
+        TODO()
+    }
+}
+
+@InitiatedBy(PresidentSpaceshipFlowCorrect::class)
+class SecretaryFlowCorrect(val presidentSession: FlowSession) : FlowLogic<Unit>() {
+    @Suspendable
+    override fun call() {
+        // ignore
+    }
+}
+// DOCEND LaunchSpaceshipFlowCorrect
diff --git a/docs/source/index.rst b/docs/source/index.rst
index fab9e1ec77..75f9733f4e 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -1,9 +1,6 @@
 Welcome to Corda !
 ==================
 
-.. warningX:: This build of the docs is from the "|version|" branch, not a milestone release. It may not reflect the
-   current state of the code. `Read the docs for milestone release M12.1 <https://docs.corda.net/releases/release-M12.1/>`_.
-
 `Corda <https://www.corda.net/>`_ is a blockchain-inspired open source distributed ledger platform. If you’d like a
 quick introduction to distributed ledgers and how Corda is different, then watch this short video:
 
diff --git a/docs/source/key-concepts-contract-constraints.rst b/docs/source/key-concepts-contract-constraints.rst
index 6c3e536264..39840924fd 100644
--- a/docs/source/key-concepts-contract-constraints.rst
+++ b/docs/source/key-concepts-contract-constraints.rst
@@ -15,7 +15,7 @@ A typical constraint is the hash of the CorDapp JAR that contains the contract a
 include constraints that require specific signers of the JAR, or both the signer and the hash. Constraints can be
 specified when constructing a transaction; if unspecified, an automatic constraint is used.
 
-``TransactionState``s have a ``constraint`` field that represents that state's attachment constraint. When a party
+A ``TransactionState`` has a ``constraint`` field that represents that state's attachment constraint. When a party
 constructs a ``TransactionState`` without specifying the constraint parameter a default value
 (``AutomaticHashConstraint``) is used. This default will be automatically resolved to a specific
 ``HashAttachmentConstraint`` that contains the hash of the attachment which contains the contract of that
@@ -80,7 +80,7 @@ attachment JAR. This allows for trusting of attachments from trusted entities.
 Limitations
 -----------
 
-``AttachmentConstraint``s are verified by running the ``AttachmentConstraint.isSatisfiedBy`` method. When this is called
+An ``AttachmentConstraint`` is verified by running the ``AttachmentConstraint.isSatisfiedBy`` method. When this is called
 it is provided only the relevant attachment by the transaction that is verifying it.
 
 Testing
diff --git a/docs/source/key-concepts-identity.rst b/docs/source/key-concepts-identity.rst
new file mode 100644
index 0000000000..7f1f9bbcc2
--- /dev/null
+++ b/docs/source/key-concepts-identity.rst
@@ -0,0 +1,78 @@
+Identity
+========
+
+.. topic:: Summary
+
+   * *Identities in Corda can represent legal identities or service identities*
+   * *Identities are attested to by X.509 certificate signed by the Doorman or a well known identity*
+   * *Well known identities are published in the network map*
+   * *Confidential identities are only shared on a need to know basis*
+
+Identities in Corda can represent:
+
+* Legal identity of an organisation
+* Service identity of a network service
+
+Legal identities are used for parties in a transaction, such as the owner of a cash state. Service identities are used
+for those providing transaction-related services, such as notary, or oracle. Service identities are distinct to legal
+identities so that distributed services can exist on nodes owned by different organisations. Such distributed service
+identities are based on ``CompositeKeys``, which describe the valid sets of signers for a signature from the service.
+See :doc:`api-core-types` for more technical detail on composite keys.
+
+Identities are either well known or confidential, depending on whether their X.509 certificate (and corresponding
+certificate path to a trusted root certificate) is published:
+
+* Well known identities are the generally identifiable public key of a legal entity or service, which makes them
+  ill-suited to transactions where confidentiality of participants is required. This certificate is published in the
+  network map service for anyone to access.
+* Confidential identities are only published to those who are involved in transactions with the identity. The public
+  key may be exposed to third parties (for example to the notary service), but distribution of the name and X.509
+  certificate is limited.
+
+Although there are several elements to the Corda transaction privacy model, including ensuring that transactions are
+only shared with those who need to see them, and planned use of Intel SGX, it is important to provide defense in depth against
+privacy breaches. Confidential identities are used to ensure that even if a third party gets access to an unencrypted
+transaction, they cannot identify the participants without additional information.
+
+Name
+----
+
+Identity names are X.500 distinguished names with Corda-specific constraints applied. In order to be compatible with
+other implementations (particularly TLS implementations), we constrain the allowed X.500 attribute types to a subset of
+the minimum supported set for X.509 certificates (specified in RFC 3280), plus the locality attribute:
+
+* organization (O)
+* state (ST)
+* locality (L)
+* country (C)
+* organizational-unit (OU)
+* common name (CN) - used only for service identities
+
+The organisation, locality and country attributes are required, while state, organisational-unit and common name are
+optional. Attributes cannot be be present more than once in the name. The "country" code is strictly restricted to valid
+ISO 3166-1 two letter codes.
+
+Certificates
+------------
+
+Nodes must be able to verify the identity of the owner of a public key, which is achieved using X.509 certificates.
+When first run a node generates a key pair and submits a certificate signing request to the network Doorman service
+(see  :doc:`permissioning`).
+The Doorman service applies appropriate identity checks then issues a certificate to the node, which is used as the
+node certificate authority (CA). From this initial CA certificate the node automatically creates and signs two further
+certificates, a TLS certificate and a signing certificate for the node's well known identity. Finally the node
+builds a node info record containing its address and well known identity, and registers it with the network map service.
+
+From the signing certificate the organisation can create both well known and confidential identities. Use-cases for
+well known identities include clusters of nodes representing a single identity for redundancy purposes, or creating
+identities for organisational units.
+
+It is up to organisations to decide which identities they wish to publish in the network map service, making them
+well known, and which they wish to keep as confidential identities for privacy reasons (typically to avoid exposing
+business sensitive details of transactions). In some cases nodes may also use private network map services in addition
+to the main network map service, for operational reasons. Identities registered with such network maps must be
+considered well known, and it is never appropriate to store confidential identities in a central directory without
+controls applied at the record level to ensure only those who require access to an identity can retrieve its
+certificate.
+
+.. TODO: Revisit once design & use cases of private maps is further fleshed out
\ No newline at end of file
diff --git a/docs/source/key-concepts.rst b/docs/source/key-concepts.rst
index e83d04d093..a252e1a853 100644
--- a/docs/source/key-concepts.rst
+++ b/docs/source/key-concepts.rst
@@ -13,6 +13,7 @@ This section should be read in order:
 
    key-concepts-ecosystem
    key-concepts-ledger
+   key-concepts-identity
    key-concepts-states
    key-concepts-contracts
    key-concepts-contract-constraints
diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst
index 4da3939152..845933db05 100644
--- a/docs/source/release-notes.rst
+++ b/docs/source/release-notes.rst
@@ -5,17 +5,112 @@ Here are release notes for each snapshot release from M9 onwards.
 
 Unreleased
 ----------
+
 Release 1.0
 -----------
+Corda 1.0 is finally here!
 
-* Flow communications API has been redesigned around session based communication.
+This critical step in the Corda journey enables the developer community, clients, and partners to build on Corda with confidence.
+Corda 1.0 is the first released version to provide API stability for Corda application (CorDapp) developers.
+Corda applications will continue to work against this API with each subsequent release of Corda. The public API for Corda
+will only evolve to include new features.
 
-* Merged handling of well known and confidential identities in the identity service.
+As of Corda 1.0, the following modules export public APIs for which we guarantee to maintain backwards compatibility,
+unless an incompatible change is required for security reasons:
 
-* Remove `IssuerFlow` as it allowed nodes to request arbitrary amounts of cash to be issued from any remote node.
+ * **core**: 
+   Contains the bulk of the APIs to be used for building CorDapps: contracts, transactions, flows, identity, node services, 
+   cryptographic libraries, and general utility functions.
 
-* Remove the legacy web front end from the SIMM demo. This was a very early sample, and does not reflect the quality of
-  current Corda code. It may be replaced with a new front end based on a more recent version of AngularJS in a later release.
+ * **client-rpc**: 
+   An RPC client interface to Corda, for use by both UI facing clients and integration with external systems.
+
+ * **client-jackson**: 
+   Utilities and serialisers for working with JSON representations of basic types.
+
+Our extensive testing frameworks will continue to evolve alongside future Corda APIs. As part of our commitment to ease of use and modularity
+we have introduced a new test node driver module to encapsulate all test functionality in support of building standalone node integration 
+tests using our DSL driver. 
+
+Please read :doc:`api-index` for complete details.
+
+.. note:: it may be necessary to recompile applications against future versions of the API until we begin offering
+         `ABI (Application Binary Interface) <https://en.wikipedia.org/wiki/Application_binary_interface>`_ stability as well.
+         We plan to do this soon after this release of Corda.
+
+Significant changes implemented in reaching Corda API stability include:
+
+* **Flow framework**:
+  The Flow framework communications API has been redesigned around session based communication with the introduction of a new 
+  ``FlowSession`` to encapsulate the counterparty information associated with a flow. 
+  All shipped Corda flows have been upgraded to use the new `FlowSession`. Please read :doc:`api-flows` for complete details.
+
+* **Complete API cleanup**:
+  Across the board, all our public interfaces have been thoroughly revised and updated to ensure a productive and intuitive developer experience.
+  Methods and flow naming conventions have been aligned with their semantic use to ease the understanding of CorDapps.
+  In addition, we provide ever more powerful re-usable flows (such as `CollectSignaturesFlow`) to minimize the boiler-plate code developers need to write.
+
+* **Simplified annotation driven scanning**:
+  CorDapp configuration has been made simpler through the removal of explicit configuration items in favour of annotations
+  and classpath scanning. As an example, we have now completely removed the `CordaPluginRegistry` configuration.
+  Contract definitions are no longer required to explicitly define a legal contract reference hash. In their place an
+  optional `LegalProseReference` annotation to specify a URI is used.
+
+* **Java usability**:
+  All code has been updated to enable simple access to static API parameters. Developers no longer need to 
+  call getter methods, and can reference static API variables directly.
+
+In addition to API stability this release encompasses a number of major functional improvements, including:
+
+* **Contract constraints**:
+  Provides a means with which to enforce a specific implementation of a State's verify method during transaction verification.
+  When loading an attachment via the attachment classloader, constraints of a transaction state are checked against the 
+  list of attachment hashes provided, and the attachment is rejected if the constraints are not matched.
+
+* **Signature Metadata support**:
+  Signers now have the ability to add metadata to their digital signatures. Whereas previously a user could only sign the Merkle root of a
+  transaction, it is now possible for extra information to be attached to a signature, such as a platform version
+  and the signature-scheme used.
+
+  .. image:: resources/signatureMetadata.png
+
+* **Backwards compatibility and improvements to core transaction data structures**:
+  A new Merkle tree model has been introduced that utilises sub-Merkle trees per component type. Components of the
+  same type, such as inputs or commands, are grouped together and form their own Merkle tree. Then, the roots of
+  each group are used as leaves in the top-level Merkle tree. This model enables backwards compatibility, in the
+  sense that if new component types are added in the future, old clients will still be able to compute the Merkle root
+  and relay transactions even if they cannot read (deserialise) the new component types. Due to the above,
+  `FilterTransaction` has been made simpler with a structure closer to `WireTransaction`. This has the effect of making the API
+  more user friendly and intuitive for both filtered and unfiltered transactions.
+
+* **Enhanced component privacy**:
+  Corda 1.0 is equipped with a scalable component visibility design based on the above sophisticated
+  sub-tree model and the introduction of nonces per component. Roughly, an initial base-nonce, the "privacy-salt",
+  is used to deterministically generate nonces based on the path of each component in the tree. Because each component
+  is accompanied by a nonce, we protect against brute force attacks, even against low-entropy components. In addition,
+  a new privacy feature is provided that allows non-validating notaries to ensure they see all inputs and if there was a
+  `TimeWindow` in the original transaction. Due to the above, a malicious user cannot selectively hide one or more
+  input states from the notary that would enable her to bypass the double-spending check. The aforementioned
+  functionality could also be applied to Oracles so as to ensure all of the commands are visible to them.
+
+  .. image:: resources/subTreesPrivacy.png
+
+* **Full support for confidential identities**:
+  This includes rework and improvements to the identity service to handle both `well known` and `confidential` identities.
+  This work ships in an experimental module in Corda 1.0, called `confidential-identities`. API stabilisation of confidential
+  identities will occur as we make the integration of this privacy feature into applications even easier for developers.
+
+* **Re-designed network map service**:
+  The foundations for a completely redesigned network map service have been implemented to enable future increased network 
+  scalability and redundancy, support for multiple notaries, and administration of network compatibility zones and business networks.
+
+Finally, please note that the 1.0 release has not yet been security audited.
+
+We have provided a comprehensive :doc:`upgrade-notes` to ease the transition of migrating CorDapps to Corda 1.0
+
+Upgrading to this release is strongly recommended, and you will be safe in the knowledge that core APIs will no longer break.
+
+Thank you to all contributors for this release!
 
 Milestone 14
 ------------
diff --git a/docs/source/release-process-index.rst b/docs/source/release-process-index.rst
index f1c9ea2037..eb81e833f0 100644
--- a/docs/source/release-process-index.rst
+++ b/docs/source/release-process-index.rst
@@ -6,4 +6,6 @@ Release process
 
    release-notes
    changelog
+   upgrade-notes
+   codestyle
    testing
\ No newline at end of file
diff --git a/docs/source/resources/signatureMetadata.png b/docs/source/resources/signatureMetadata.png
new file mode 100644
index 0000000000000000000000000000000000000000..61f0d11e17a25f376ebbefcb534630d92a334ac5
GIT binary patch
literal 18666
zcmce6WmJ?=*XT%>AdMi+00T&gv~<nTLpMl?bVx~xbPq#FBQu0ZmoySm(j9`7G)Onx
z!S}uQ{=avvZ`PVM&ok$oU1!(XXGdzNDL%%d#sdHVkHJcEPyhe}0sx>{;Gm=av0z5h
zqJA)JrB$T?fXaCM8w*U-`y+R#q70yH=-C$Pg~3t@stN%3vH}1>9|3?X)L%iH0Khw5
z0ASl301!<B04QBD8#TpI14SAt+Vc1J_g!6G1_lP(+uOmx!AVI;V`F1WOG{2pPN*qJ
zB=Y3sgo=vl`ue)Iww9ZlTMqT%<1vtawUnQJ-&Be8aXYChzW!E5Mf`-Dk-jTF!bwAA
zyX5m&dSdNI|6o&tBzqewN=hmUA_J%>HwT@QwbK1=aaV2d$#UM(P*PHaMX;BSoW%37
zj_B*ng4#l_?U{_u&Q4^Sqn4HyEiLWOpFgv+v#Sd{(G>3JQ3O4Dt*j^qh`^*(LcQR+
zC>gi|08|+d-$&qgA#eadkryl{t?fOx*Mj?gMRcSf)@$w6velkPp&3I~g8xP9r_1|$
z2W_BFusQFKAiiP$tR$?1CtF~hVr^;y6v+Rf&n8=#UHbdRn$zPkx9Cd0n8~}Wy%p}b
zE!}5pp9-p%Max7M#=X#`rui@}(*rbiyv^tq*68wl?V`7jTXLG#DB5lo@j|70)?uqQ
zdU0zZKKR&9dEQ7Z$};GWgyGlD-_+#dvD*zkBR^K;Q}+l}LN4gOgolZNaXI@KxM@@0
z7#yzQYl;WLx$H&^zpiMP9BrvsG|{v%n6b<UhyYH|X9s1+RScBRPAQX-AG6TacUgcS
zvrsOYz4fjufMNt<BAWS1TqmwyJ!VB)7Euz9`?1KP4qT16b9}T(YO^)m=yCFRi3p9S
zz;yMp&a#&>_<(aG+|2t3JLgSz+#aWvtkcm+K)}Ie=Zs-<xJJt)2!ZgBSQ@}_10^2#
zSwG@}L^6}irQ>ON>Cd{8Qb;8l#<8!E)!|US4=@*Y%`M-1EY5uV2d(q$xt(%a_w(J}
z=;~jIJ2N+6v_N*5JCAPDVIijBij!mCS;bOkf=454{Ger1y3u)IMrRgiw)&gLpMN4;
z*tzp8fukBC@}PIXU(2;*-g$G@$p?u=Wmys0InJp=dc<%IF>dLA4IrqpCY5E7t!0wZ
zQ|TOcB~*<I$Tsxh#Vq<ri&A)4$FkS6GhXi|Gf|yJK5(Vj&zP5bZ(eH0zpA;&+k;CW
zk#SYkY@%n*WI_1}%DC^=q|SY3t!EFx-Wl4l@HnNSwl^TnFs##yHwKWkG7okypyn1G
zH0(76x^4HRgtDSd1<TbCl9SWH+RK}%a^eLx(}`P7(cd=&AlU$s?QP{xM}FiaKoAXe
z|C>a#W$!W&#1vOP_wld|BYdfM<XENAh2eDcoa++D&Y>G5iIbIjg|2t!@k&whO|xnZ
zWe{B=7@SaHu0g53D||Fzw#xXFg&QAlE2yFdKEf(S)w>VI8u$SJ)}Q(`s*C-XtY<e|
ztWZZnQg<V1-@6}6BjrPnu6i>&aQ1Hmqga(&s>5=V!SwUjPqU#NG9S>^i7vSSkk4GY
zL|O($K-=E2DS0Mmx~=!~HK5n7mC4rm9W~pKBMk{=UALX*`m%sbBCD{AyAgt98p~~O
zWH}dce2<~*{uH78M;I)R&_1nM^>4s);Nh^e7K|jL(TpShPsr}kWwu0Mno0V^_w~Sj
z=<A{~&YaFv%BUIfNWVPyR|{W>N;I>{^Q$Cim$&dC%pnuuJi=U!ZFy$tM}J!5+N*+B
z?Lxqxcs$-IoAixPj{Zrkzts={w3yrR&P@1FBL^1_!*{8>KEbW(Vtfn3eUssG9O~V;
z6#L74+_o49UCH6|lgmqFv{)*#YYI<ZFie##tx7iIla&>nsvMIvhi23@R;y$Bm@U7-
z<^_9Wz90)iFgd^MijGAu(#~e%aJ|$45$<VkU2O;WxyHvkhmMV%$>}q!gPT*J@hB1+
zPB>E=iMIY{ZRPt^(08@r4{(jYQYICCL_D9LU>b;{uzNrvL?w%1u%EVhJrT$+Pd&nU
zlL%UbAO-~eKcu@l74mADo^4;gZI0R(p0Jd_*PKqff4tt-?Vje5tu=;QrB>tloPEjs
zw=AUnlZ-TU`1tEeso9*0+(OGQ{m2*?%wv}05L=$f!Kz5}NxcVA`~uDy%UgZmY!)Sw
zMf2AJG$88v(t9ia&6c@*S9aG_u1MZtw^X-v#aUuQLBI9-%d3ut7l@t+CZvC50AaL*
zi;9=d9BDD2wp^_)I$zk&eRqi+p!l5(KTz=n$lzyuDlHsKB32rt3%iuY?SVR+vP!by
zC{Mpk7R&p<j^eh)e6143H2swe*qBkxM}nIaZt{yOpKFXxb=GWr<8gH`{qj1c#VU&q
z$!qeV1mtP_hr&@AyjN|9C%*_z^DcKiG{tHbAGvsHD@6|Ejr6K{e=uyftX;Ug^-Js4
zi=-6nfyyu+y)y@{@4ty=vW`KrjD$g41K?Rafd#>CF%#TgPYARckMTgRGcRE_id671
z;gpUnpscKER$QcTS|YNy8k~pa^0`KMas<t4Oj7opedkHlz)m&uSS}YeX~~PP6C-9u
zS+m%HlXyIkW`2jop8~{Xj*q1J-4k#M<;s`l1YVkr$Ki4PN+9m-VtYA5$VIHEq{ga<
zg<(G@v0ahdg04~|Ud{H#+Kd823w}n+=iN9>k!=oD4k3OLHMRkTHy4(dEJ02j{hE5j
zKN79o1D<U`o)j5;5S6jVE9N|kflIRHFaf(y&}8S?>)I#GT?(|p;M~SKI{Vn;6P@S4
zl*KGE2x;TnROWu$?Py=W0?6(KN&qR<Ce<c~=GHSWCtQ<R0+W7K{8gfGAQKFig9!1R
zn8$XD7V>+JTO1<B)WFgBcD9iMGVyenq69R_D<z&=<5=@QZyx39QMEdAwGLk8FQ?Td
z4(c36U%tGO-%TqZwRc~v4tIUBWs+i%(J8F|ttfq<lPPyt2(qDgH*!+yK&VbOp5+s7
zCO#zP<>OCOo3%t0px~+Qy!-;Q5}f3_o`fAH`n)&$`}u0H=E4V7hVD*_yW-Vdn%=lb
zg3H{SvC|i$3G-DTMb;nAfKBmV^tQ3HCg=c<bl>rt_=wOBML;H+XT9w&88ATjaie33
z6zZ3ptGp9T6I>sDHTgf35dZ+TGHczfs~44&wAWw&pb$bvBtOI(mJR^au^q|65=P)f
zdJ<h2fC?aYU(d+MHt|!d+>bvhbMOEzhQd&h-P~qi#X9T8%rGWEn32gY1o8c7ih;c2
zV-h-`C|W=&j8lO5^IlJYAfUbYiSmZcDIJXjAt0AE`^56g8F;wo)!FeQfEt<>OEPgH
zJ9%Ga4iUfwkIMcrkzG|+Pk;=d9XCO{N$4Y}!%~tFkbA8!<Gpi+9gzY62(CI;iH?0)
zMx~~`vqfZtXyt&QScelcamIurJb=D>1*0}UL*=Xo2H^KXqF_&fECUb_q&krR!}x@H
zcsx-B(WpmpMF#?Y50mxX|9z2VJI;d>#9g7u{uaYVoqE*A_x3bo@rhH^N2&~y+$4pF
z=mBnY(4)fdF1KXQz8JvhuAiPqJ;}dsBtT$fV*Mx}sEM^1h(yiEeayso^X@u!&~<hk
z3yLPiIm2XZnIgB$ioH1z3<r$heV@B34OogLQNjg0UoP*HK9)OBCXj*v-h{K0=hgbA
zl9v@<&yk|&t@%h6Gimr5n9MXz|L_{>VX1p5tl&-9O~r_M4XaU3Ng>dU#tOF`iF)`0
zyOfA)7xuz(bbHlq7~7c&g}`w|xl@isZ5RBSEzwz~?SNSCfus^SE>;m+CYA&ez+8`;
zN=nj*hp(hd5{h_po=l_hP&lB1a;S7m1_GGD-<a}1!QKsZw{JvEKkI0CX@Y|Let99C
z8-Wqj;^L%A2}Nr+6|OJ9|9@ZZnRfbwsnp9{9g>a`#0=pm|0}y?6uP?3^6)2~E$Hu|
zvef^7Sn3mCqdID%N#*5k$Of{@sf_ui49$R<+sRuFT>Sveq>TA_8YNs|e-zskP&XZ`
zBZ^l(EN&(sa37BkO#DXr)Sr=i9tL~wgIrpnMD4f)N-p@I2D(^<z^>3612-RCNT2gz
zZ~t-c!CehIF#bd6wh(HXIBFWDC6F13*EU<~lMol30=qUN0)i|k*C02I>t2*z+lZaE
zwz9Im#)h^#_j0ne<?Z+sSa?rQ$%1pDVuiYZ?;2^8o}QP?egZe)e*x-2`d&tNht?44
zLlnGLbj3}rpdAX4aM=4gI=U`1(XC}Dj?WDGyF2BEU=%#v)<VksXoo@=wr<XnhmI=<
z$Py?&Gzpw#ZDR!fo)D=oXo5lz<44MO_eHds_=o3zuJrbci?RcNcTLFLA7+PAY`4gK
zWT0Hu{eHH#G#<=bgK&t)b=XFQn<%xd+}Wv{+~jn-Z6#UIV!zuACBt_p8J4Ax%wFCv
zEdF`}S|$w0Qtm^3(}f<fuMyW%-j9O4D0g>p_+|GE(44qW@O=o(PRnp|ZibwJffVI6
z@EFMVRQGHDphc8!)yqH-$aXO$NL87sQePkhLf1vVwRgiv{EebM6(;5bV+c-^<XNM8
zH>b2PIyAql>xbmD_BD>kSkdt$`tN?Cf|r1DFFQyX?4-T$7SzD1wWfL3nS!a@x4s^d
zf=+v8{_7hQDkC-kbwhgCX*Yj>2i^S#^<9J*p(8u?#%rXGOapM5jK>1h&|BtOh+Mma
z0Y8+&x<_BT_UHv@H+pFOXH|27{bj4O+)4lWDMe@eJ6waMjaTU9d)tmB$d6$z+&Xfr
zkOsOV9Y!FLA*2kmM|KS?v^%wM^VAx`9N%gYuaLkjm)|55ctrfHweNZ4@Z&uWQ$}4h
z-_FYPvQ(FByOqNiBNUw4#f4$MUm5BD)Zcoe;97lD{Ad87>;82+>BtQX6v>1@nc|x!
z$E130TAAlrQb~?{;d!ng?t=s8XyQ!ebs3Ym{e#V`Zce*iadQmplMj|JO^k%UGem@<
zvTr3I*l)lco?`W`n1~tpcHxXjj9U-xr(j2)I^YA$|2jSn7CNUqdJ1ZVDn*iI;Rm=L
zZ>a4ze=|sc?Qk|6uG|&eyzP3FVurLuNs)A2Nmb}c-jQQib_z_RtGVZi;Hwl6iKzK7
z)a}J<wl#~cmH+`5jWGS`pF3%%pZSdNc2Cuwg}=euh<k<e>1`{2?)&CZyNmp#=}>cP
zy~bhV?3>Au=Bd-YUx5iEF5AzFw-h4XtWI7ig)4r<k6#!2z{LJO1?C$=!Mad8WPO>)
z0Q@Z{qC5Wbqss#Od#o{n_sf+x>?})#q|mB_*+tQHC0vw6aVgq23d$R3(RDC_o>nE3
z_{hmY`CUS1$w3BRKw}(2nbs)BRyahQQMNO}pN|d%3Wh_P9T=sKoKzZ$X`pUW4_JzS
zdDxeo>BV!YF||<fxVu0vB@(WGsz5&Q#vtI{rHfA=yjRgL4<nPHnP=V{YOgi!BJi5<
zXhjZRfD+5Yj$)UNR(c-%tJGeBeO;vG4p~i}%ZYgf$U)5^Hmm_o0A*Aq%bygJMR`Z;
z(L=0|@URV084UTTbl%6EMDo;D(3Qw3dLk4Si3I;yk^b0HZ68sN+T=P6R%cuTIXHY|
zRT=`=l;D16dM<oUC_b!}bT0nuJrmE_$?mIL=e4agi2Xwd%8~LVEygj*_M5kRh&b^e
znE^Zy`L06{DsYLm<~CR8Z?<<C08mlRQQU;g%3Ey^<^81w<Ra61%$kL<AJ(W?#9005
z6M2|p5(ACsqC{>p-u{a^T!afF8bg&io4gOGlDj=fAiN@Hq_kN70u>jqp|J;&D=B~y
zgP|Npc+0nL2}877i-(v=mv~~E5*C=RJsor)f*POeTwAxLsO&Oe89_<pO|1UrOWU^&
zdo&M29bbBtXv!*de6dmSDJ23HRis3gEsgf-;jMzxsN~$zxG?a60BlQDtjO_u3||!b
z(h7<4+I!&S0|Ontm79V8<_pfObx`@M=Z2$5K+8Zc@f@D#M}hfO%(q}9qP_4Cqj%M^
zSOiLz{;k|qX_>ePV0$2GCb^OH?5D(ko)hP+F?8V!n?xw`JP`q|%=JCEClAk-8L()z
zK;<u}t(l43JJP?-kRn0_QMNjx?9XlXum?Dyj+BG^SB<P9D7>^Y0ifa5GB6=Zv?7lw
zs1A10*HB>6$Gf^Vx6;?JVX)Dhl9D#PsO!;9l)$f~7TEtTpYsQsMns3d8t6S}qg=tJ
zY%6<<i-*AQNG<5(YcWn*AYM5O$PqpA9vCA|7qKW~^9l@fhLI}aZgOdkvn1xG;+~Z4
z&bDofJu`Ckf2SCgD7rsJx!-WdtLf%;xq%AGYOp`WCAY>&;=D+UqxVEIM}K=oN%Xcn
z*F=ilJoihG1W>fbes159aSUIx-S50lO<+cr&Mvsjmc4gFmO6h?>Lc2(Htu)b$l8!x
z=a^QJz!Ff(GeBF$r^*1#&EKUE+jB&FMZ-EhkN3luu{cNVSvQ$*LyI9JYXZrLsweHJ
zqhOpLT7`w%WK@E<1BfL?$oTog5ZIGvVs7bW->pVO)34*nGI|;uT;iFME({boO8D!m
z@0(eDq{6<hJDCotYB4TjGw?MS{d5b42XT-6$ZXDL9Vr=BV2tkh^V-e*9jBZ=&rBl;
zMN%{|N^lvT9GDJ9IlmFS9e-YT$Q((E;ow?)Ispiwuv*L+0=~5YCs`7gv{m*&)su_2
z8I0qbXG9MIuVcyGu!nK-UDjFy>Yg()-rR#&pUOa_Hs0{))aKxxU_w;(_jlOZs}j;m
zXWu>pw4z+7T9ps-@an{0^+?+4uT_&-Ex);l0@F|3HsW-v-Z1b|o1KeWjcCOD`O7}s
zp{Jzv@fi+D#Oia^^ZS1j1yxWIw5(||wEgu`Mm?Q<iqxwln(Wn0!z%dwHI8hOg`3Y~
z&?DN;$41YCDZ+1QpKueuc}eWmRu;g6`MNyte*G;AxS0(-mLSOpr4H23@0WKET>g?I
z+Ozr0R?iPSGkI3}Zn!|@MiLFRhw4@rt;1^ZptxHuTDGGbi>qo0`|aJPjByrO)MCNb
zZNj>mp{%=}S91(U;!v}W!`ll66LB{bh4UCp9{Itk+0qv$HLk-yk}(P+ORIjOjnfej
zWPh?$LJu{)47)MfEW&ywESqC`sqiF6K9d|!L8|~7{P-H^#MHrCpvM%`nNYYpI#Knp
zq%0ES4?e)0JW|Or%T5OEHJ&7FpAa0W)FQ2tjN#B99}AXU6GRUa1pH<b5YFx4pQQj}
z8;1s2g%oT@Xnc9>NQ3C0K4~Ze0L+EZLikw;Qb^)=o?=2Ey~p70cBpcHXvg?GYVc*N
zQVraNOc#vXvf}9b4x;Rg4hRCG(XxRNVwNyW8BHB~Fl21^4a&EelS>yta}dg;Mf#C7
zYH#eKU~r7xDLHsFCg>61D+@*5s;?`AkL2ZtBr4Bu3_x@vCwI~+l=cIHCWZ4LnM800
zjdfl&LpVw8n`fo?c&J6%7CzaO#gr#6@UVzy*|YT=XuLVHx;o{a0HkQc3gk_RSkM6#
z__|bt;Voq>L;zuoluvj~g#(Ws%K87ZACV6Re&LQYVUA7CG?|npSKF13=dWrUT}(Z;
zN_qqxcE;<z`-~#X>E<g+)#tJPe`%Yc*WL9A_O-)XKG>5;WQ&}z_kB7cF}~y}!aRN2
z?C(!tgc!*9K%WEDpr0VIs43q7<Z8*e_T$F`7f$QoFyp7&w5sQk(WwJoQ5;Qy%`%X$
z5YW+Xg5+35tm(~a9s<T?B6O50p=`w_^HHtcZ1WEBG>F?`!=8GsDx9jdt=r69Il}So
ztU7?;5?Kv_tU$&)jTnIzI&85=>ST>gfszA6r&?g~VjBD<S(a{*cQO*AAqHqeAwj<N
zJ5R0BsphkHQPJ=FD^3F-a7z%nqC2O)_86QRdxz_F{~?90pL`j{$8x~z*f6G0%wpGm
z@9h`Rd@TzY@j+<9G&Trjh_6C*NahPxANws4VFlla;JhBMn|P`#E?~JWlFftp{p{4@
zWKn2hSjjX@D6PO`j13610_iiQl1%fdh7<A^9ULb!H4IK+$+H~%G5Q3@z>-Y$TOQcA
zAG?j(7?sOwt!g%XTiio$l@k*%20WEt;~wS<ujGHmv@|vR*|VY5L>w*?pbCBJXXa0N
zRP@HYAf+kSAPmQ+p846G9sRWzLHnbM7xr?e6y%(d+815somq{Q-QTg3;#}Yd318ao
zxNzoL&o6PVicPne2N&8?^_UKyR!sA1dr`mLh;n{@0ZBPi+f2U#dwlJhe2-QN@t_n7
zL^6UjC6scVIil2A1Lv+fi%qs={~jt7@sJmpoCMx!q%$tD;|Hak4CM|xq_mFZE!zK`
z^0uG{_yd1ur{7QN(8gV-7K;&|7HL!{zAl!aAoK~BRzwtN!brYL%I?oi+&V^4tpz5p
zH`w$CwreF`TxLBB$L!1Fc1owPk18H!&co4JN@bEJk~Yc=md9o($j|Q49xlimK$>n9
zL_?W|mEi~ZC%qF`B%EoV*bSichKr#0?DB{hj*Pv>qP=5FhJDjfRizNQX2E7IKw~^K
z#%j~%z%R~<WsyM%ALNSdq-2sNgFWWwrL8zkUBv|)({U>eCP4@3_$(wMSPCrH6~d7$
zz3*LNUcMo*WKmgI4i-wx!RQ&=V_2V9E$$G}!}&Nhzt+CiLD-vj|0auDUt{1dEv^yK
zitL6|_6vvAlOZFw+86Nnsx!hqlPwL_%F>cMh{QZ@k9_^OdYKT9=nG-tDpl(k&U)ZT
z*@Cu^Hg*Y&M08;+MaJ+OHVcpf7bgD88g%GECD<oW;>}Gbbmrk;tv^RzJpY`)h=-7Z
zrua^&pcVo-nVkG}d-HvE4s-xHd68O{Y4rzZ&;3OrLBC+)!q+y|9K{lG)On4P$+CAJ
zKUT&iyxQZYYXJFiu^7<XPP-i^T9g9YwMvxNB4Yto39&+-c05uB8$Vn7(<12db5~q_
zCs9qaI+Mv0b+K^i<Hlu1D{RaNTo@&tE0m-UH~+dTJI<ZtHGB1m@+8(;(|{U$_I)8V
zV<VV!{jB}_BU?<d7p?m)29%r#M8p>gJNA&bpghSb*HE|;cE@L@e&|Xn(OAnAezdAV
zN=cPyjGsCq5P!H@>g&W|I9&KDYb=`KI&(Ih+q2>7Q#7ZMFZ+9`ji+xn?JJ(WJFOnh
z0P%K|{pK3!%M{Qi*(RjKNru0@fs-6@TM<R2A`yROsupvelC2wUsl6RL<N}8Eif%9*
z)XG}ZMN}1uG%I&IeXW9HZ2M4<>@a6x*;fp}?4;Ac;4e!e4W=W(!AMDgJr05tc~D;#
zxt6ykY-5=qS=`R=b_n_>qCDvcu=&z;D!2%n4XKZ7a6Y6C8r|mqiR_|X%S(2VhM*lX
zZ^R-$5|NI!^C-*L85Ip|GLqGrg}Y!3q~+7i4(#GH2PS!42;iS!Sx`6~YHup^K$ys#
zHTAr(K51+bl`?;~21Q0Wb87N9Sirx=S}liM`9{SN_OmK!qHh3Bi$^N4OuzcJ!bqTa
z^VQwzpuCC?PcQRGh<{yg{uSm;PF=QXNw4a8m7Yyv^CL2~NvSg!Mnb))icbA<w1Ek$
zheKw78Q+R3v8*V1L|#@j=3Mv&v7CD&{)uIj4IImGq=Ezqyxna8GXia%6pdP{V`f+a
zO=SaCw}RKJ;A=9=l*Br0Kb@(pQ3swqinrMDiw5|S6@Uq*zXVI?s_vWDhq}iLaZ1F2
zzuUe+AXVBG<dr1vgbRJUc3s~Hg<kQTpD!@~tx{f_YJ-vJy;Dopdu@e%IlJ&wy+^%B
zIh=zGhGYGAW?MfgM`yj2OM)oLy2V<PnpSmLiWC2d*>f8Isi!Z(=w$y0owR>~%NaN*
z_y_R@<~b1dN7aJpr#9ld6r%l%bN(n*q0QnX2kk`|ixK0qbY76%(P8>($PpB`ZJM*5
z|Lrni1U~yoP#PplR7Ub>(nr-<6Ed;rM)w5<Q)(cHYt;Hm__|^FM4#vP!Kkhpyx&t5
zUYw6sRq1AnmaOt8HOIEX#WGPCv5`U|etJ<bB)WQ|8<&ieSe#H87%Y*Myc2E)BjLP$
z6Fj2j8dLT569*Sbg?A`NxbQ-N4XLm#nwWB<plT0&dVy1NWFXqx*FHx)C3#<q{A?<0
z*Fxy=wH&Y#Et-h4<h~C|>Cxi)v1RPR27U5M%Z7XYEWsK-EcYPAFvAY4unoRsN7^Uh
zXuTuNj%W6=rF=)5Kf@eoC;$#G+|ge@Vk7<(?n!rY`poCm>4mts<(8Nm6_7tu_`Kb3
zUTDJl#&0E7hs@yV+UJ$)G709+&+%*4gVO3_n#HGp3AtMxHOhhwMN@GrpUQLH54M5c
zt+KTe4x>$R=G+Egqd^B#!U`wWJHB`-z!mzl>#+0cIilIkWyo=-wPm+NVg>jSTN@4X
zLe_ak6LRB#Q%Fa#KvNO4kx|TUIj4~KtnT;LWl7`;i+hH8gt(hsb|#*axgsdCZVZbZ
zmz}uVhLJJSAjWHR_BDcKOO!c9kw42<XopaIEj>Hexh|L%X~kKM!KkP4`-|joq^g$5
zOS19t7vjcen1Uj_aCqF25FnE$j5<X?H%$6jS^shrwa@6NOU}E6M}VxbaRO-m*jmJd
z@tL7cP`FHuMkN)%#Z6Ao)}&N20xECc(5cyIvPlmZA^M8Yo#1nO%WCRvgnfak<HwI)
z6)Asc_yfqK4J-3nWD<z##W(T2HVP&IjDQFZEivn|4ks{XxK8aeUj79D*dm*-fqfKS
zARI^g^Aa?Gs505UG#CqgyzgzATy`EF34)3NE4M98@-1vXq<zDeCQS%WN}Z2TkakK*
z-PIFS(x(W2R*NL7UsP?y1Q5)yi<k?;-QLQ6G<&p3-xrJ@-aSGB@a<hDT_}BGh$eL~
zQ?+7BlaRt-iYC>@8?S-r-7|Y>0~pFIvKbBXjJ(#1dm427gY)^5_fjffT>(<%ypVw@
z`UG~lLp{LN$3R3;XuSLv)TMt9j3f;RIEl(H6+573Q$j}-FoLG?g`u-uIKZt(o7l}!
zi$AE3-!q4Xqf61d*gbaL@U9%z|JZYfYIPCo#J{F{VQ4|?p}-F?=NX}1QQYs-XU7go
zQsn6SJA=-S3)^@k?23Rrll)`%I@ArIMsxl~w%r<)m}d%VR;6}x)M29PEq1FOmb<7^
zWjmO(raGu=Nb8{#pD7R^w*F+$gzW%<I-sk4D*M^j&GHPO_S9Jx`DBS+uC9DHrTyuZ
zN5wL>tBs6z!0xDFyM#0EuF`(;0fDHp$xPMcWh-&l<Ro3<9$q`Ry11+PNdQ$8Z;H%o
zyu^r+{EDzop$ZPt<+S9SuIu}}YHOT{KaRM*knR*$BUEtQe^HC=yKdJ%0?b)xMf!j+
z_S=a_skbWarc7iuSi<-jnG)s5{#58g*cX<OCsBn|JsuxQhxqM`wsmQw;*{cVbpU{L
zQYUu4a>z)=7(Qgyj}PgP<`efmfhW8hO-3O+577n8!d*Yrn#<@vo~Eo;uXu8~ObpPj
z^0z+{++{0u`N*l$31>O-uEr_9V0!lB5xvk~VY?|P^z%^i!NpgN?Ao*0CmbSJJx*V9
z2PT{p5;rbkgHRbsf8zHLGL`XUDAc$+f$;I;)&5n2mzhlrz%fRst-%hmOXTKDkomb4
z!-&y#ZESA^GAp4H40+S`T)cd9_fLn(XZ?z6rsw!>F3p&r!ziVlIopsxcLLNIGm6@=
z(``&e4r=$@A%!F=I*p5Ht+&h60D?yM_uU#F7XzpbRUU3H|2$)O?|^laVTr0<={UTl
zk<P4$NDJ7Nzlu5iWRZvCKfsdsSN^rP_-T0pi85lpUAZITz#*!umbA(g)kJcp@|p@a
zt8IUl<SVt`KeVTgomF53nfd3|{m$uEukk=E9fVaCN+evu!dRSIU-zF~=KW=U`8VU0
zYS)UqR{XShMli`+#Ya%IFZ$Dh>;^F&R<1h*%_Oi`aoR5ai)5Ys^Xy^06K^9jrBs`=
z7A;BaY|()d-Dom}KFuI_5XYB!to1KZUH5$M&RR$>_vk4>f#;3Cr?A3+8Zn3LQV=O}
z9Y<z2B_&;C1SZV~;Ji{Kd03|fDSD@attbBs>O!jM^Jm9zksgj5ZmL3Gt!rc91YBCC
zrQbDTCe;SXDu4+j8r}VM#F{m=ZiyM*ofE%9MiL=T8(0Vo?aD8X`h9cqPM<5#`G(oI
zlqTWFsItHp{ZYXfmyq)(UKT8Mq;;dSk5F>GaiAG%z!hSb9}CVctclf#Km7eb+JGZ7
z1nFMAHQd4`THzZSyWT^DDw}9mP6&RjnQDBmfIT&V*ZA8e3svOP=zcw4(UIO@7J$7A
za~gUaCq8@}cRRWJ7{$TsJVzxUZmjRdWJJ*}O_MwM(-7~p!93mdtcQZ2wx$yef~7X;
z<r~9n|B3w-ywT#eJAvrRnAy%Q$_M@@1nZzA$^Ou+9#6n$HB4o+Y`Iqgy$zA#A%jV)
zkUfb9F-O%&yTVEvS#@xpFrCJq_0%idza6cw7q;%pZNT<_@lbY&YIYo9cNr80qfApv
zf^X1LPD-q1jIH7QKvI#x+xlCG80s=dJFzyF6(UpEP*-;8`?0O<mqFlyzGIMn%lN}q
zFxk`C94k2c9RA=xd7t+J`dSBhnkePPo?R`5l0c{vP2EhXQFbj{E)OT9)GG^hnWqu@
zmd3U8*>r8Hhzv#zC-il>>j5I({iOLf1*)*c@y*fu^>o!E#mFE}mR;(vwVR@Rv5hZL
z#Nwe8z1RN3K}W&d=zHHYH3BSWcEZ^bYr%)HS;5a9=Qr5*I0H_;zl!up9B}l{-yZUy
z2$ZRN+!RWze1HSqRS^0@K$RikJCnbC@j%BDR~quvd}d)98zHpxPSyC)7Q67l2O2)&
z7};%YeZM|s?OD-q@FS>Kye(Ix$E+bJZJSo;`Y!DKyW>DgN9pw{j%s}Y?f#WT{4GXq
zNkocx61%tyBa=_38a%U{82E5SvszatknI1vMy-ivRfq+cL5SP599jDaf$^0U$B4!U
zmoQ_>ZZB<XiTWifE)PFJ$@^>Ac0ldB=l2OA!UFY3(nOdjbj%&QXGc8T5p)M0=f#d1
zh^;vzuS?j{O(h)s_UoDU-uoFHkL-|u+o?*)Jtu*kjw4wjBRGlu`OS5@09RQRy`V%t
z-`M%txrLtNjwp6AOh1OLu)oG`st|SUEtq9?F2!l6p)<Sx)hN-48tfLwTWoIjH3c>r
zX!55W`Z}sGu&^It(VP@QQ~F~xMppa9o?%v}cM{CYy(Qa53i8%Zez-^X;}3ydeTwpm
zX(y%Z8mrqk@@o^>Z1!R$9p8-o8<Z=<RSoJ*mkN)iA^p8(=L41Gd7x?=Tnf#O#Ml(Y
z^JbUZD;}p`>-XPA!g0cXbl7SoTZz@Ner#9_=6k=kBn1&%iP%D|;VU0Z|B~OjTt|xO
zZ31eNQ8704_+rXo^u$K`g?mw0aaghMd~Ms|qG5H{CS0hFGXbWGSlOG28c91>z+KCZ
zGp@^Vw@ScD`w@RpLOxDyTu`ID-DOi80nsoN)=Khpy;X5n{m71Yt$m3Dt%_8Nh_~dF
z(UPFC4zoMA;n|8#%yB6{|J5AgQ`tGM5^}HNJOz9GZQA`duWts4?-`YANW10kah#X&
z2s9hS*|kv#%mdNKR#9Z`UjI^Otw}T@MYT0$L*A4aQD>|cnAT(22?i{1yo;G*=bQvG
z0BI_^uOE1HR_%`^tG+mUS<K|NSF@J(u|Vra!Vc8*F8Z+|bW^Pa`>KSp19yxY*k1Dp
zVTB&){i=>hz-BJDQbE2Uzh!6`Pn_q>f3=4Nr=Ji1mLn(VNC8HAjE6}1DA^VNS>YB+
zqSS|l#%P1uvVvxT%g<q<=z*EV*$!S2%fmAc2xI1rHU2@c;8^I=N89XlM;&yfK3~Ll
ze+T(DKi$!vyC{>M#J{u`ub7O8v9w}UUV9pM6e*e_1SO)wRDYH#sk-Kt*5JN6C58?%
z7}ijUE5(WRnG5*J$D!x`%JflGuTnQ2bajo3BsO*PTSD9mwk&;Qp$P+U2e*6rf%nzD
zfo+0;)g;AIYvz0J4C|+Sr}U><-EJ_ywf?Ovc^N6l)N9<s2V(lq&+PCIWwx&l2VTo(
zZ#3+G$Di0e7{@tmyE-(`1%M2cxqduorJtjTIfK4Rn|LeyB#ur;)bMat*D(bCW~ih+
zs6iMT3pys60CRF}U+Qtf#QJk=nZh>X`;E^u{S!XOj#dd=FT8M&4-O7Km@cMLH<fI7
zF->=OnXO_-*zfQFH`@g3|4x$*4tAz3$QeRJ^A%@-#Oz;@JMEyMZyk{ZDuH*TAdTJ2
z0rZdY2%2&E?(YIfjMRShA=avE8$#wOs4g1XF%XD%48UJ2=56t;m{=dFlBmU7hF)OX
z3KAa=<F>##j&HaZMS_lQ1?h&9DFp)G=lq;W_VrICnHb8<al|JmqK=`N$C|-?AbI8=
z$&q9syDTX%Ay2OY2&7>5#!rKlgYWKl$XXx|JojEDLr&}%yZ$+E!kuwA-hZV~v80%U
zhEC5yeBfMd4EX`&mB{%BBRM>|<v>iIJl9z_Fl5qN6wcyYwdMG+l#{fDh&8M-qM*{R
z4WRqK)GMImI4-^mxjIzsmzGS1zX|@NTyMkrivCcQrn-^_B&=SYf{N<oRDZjodh!0d
zPNOZp028aVt=HcN`k65+rTnLqW@VBWA1g@n=UwD$_-2yMW^rs@<{low+Dj^-y2lly
z58GC>)I*4g#lC&mF~&%nErKoW4oa-+ZR4>k`5BoSx|VbxM3N-PvEZy{-fnQ2ECVsb
zhK@ZaJiUGcHJ54>5>M8@<|gGQ%J%;1B@HpvH%~)~*QJ6vmAxHx%-fAjM)ChEm!f}i
z8Kb6Z8?q@6^-vO9-Lr3I0lMvY2xg3#qslBxmWLA8e)iV<M}nAGx=lg}uvY-k76tZ|
zzW^t1f}*rUjYmSv2*cmcaKGY^Y|5`Nq1wvOcV2ZIyu4p8WEg>`hdYcPO%B>gxhSwf
z#R!Yw;MBrCeHAl1DLvp&;1HYp%MbaBZE8wlrhmo{=a1XEcdr`6-|;(J5ZGp*p$8OW
zt^TNcq|0ph2P2kJ2@HHrPL=j5urk?Yq~p|xjOwqPjy@(7N?%PUgE%D=|1N5u0DEbs
z$_Yd(faCKJ8h>jI2o7d2re%LB1vzU6r_<C*&VO-CfZ3pU;d{S9c6qt4H@A{qi%&3e
z)ua>nh!I$dj^Zx-(qDj`SL6G!-=e~eCH^)g74P&6PXcTz814~0*G43JnKd}Y{Z_*~
z_r(M^uen~Ramn0&G_>gU`mc__Lb=xolPVs8N9Y_T*0V}AcZUDK#ZH8wETB>57aDq)
zeg^6PHpB?H0El;l{4E7l0t8l;^z6SzC5=El*ypT6-NozY9D0sK6P&yiU@!x44;@sz
za$tRUHN8F<me0eJYBsU<=V&?)iO>uVjvPVn)v6RIzOZk-`Wt$FoPrgzLrxVT1j0oi
z{D<@)Wl<`NpV{KObhrt-|8O?w&;^t({)!@hn`nmctBo~|pXesy1jgbKB)~@qq{>9w
zCK`m4`@D|Rv7#q9c+H))NtD3XndR`9va&L|?yMVw?S4+=nzV7n(ao|~oBVs|Q7U0;
zufVnjbPUlBP{z$VOIPmeq3m`l##xOizzPWT->RvnY>-v%JD+~xnAx(9{px_?Z>gp^
z!<Rgk1lXB~8A!AL`<K7GpNITj`1T^!uDlE&++FD4zF)L$*U1LJ{A=vHjpeo-Y$StF
zz9uWMEl`roYnhql{8G?=JM{N^Q#xHpIvG{M9Pc039IvbMrMBT|5VE1l#$^k}H|-B(
zOswJyumNe(=+r83|4wUh9{PiZF3s_=#WewCLZS&If&$z#a;SzBw_EnEUkAphju#$J
zx4VSTH(t-_wh$STUR8P;IPwc)SkQzFeAi)~vhp_@mK0{hsi{X1J8ktc#y5#H$9fZ$
z+~68ILJ)8ek3gl%iYvP>%ZE8RH~o>iHrbvJWI$JAYsyP!MyZv$4K!~3SunswRo^Ee
zpsh0|YY-EwSz`kC=Rc!9GAm=Eoco^WG`xAoeXe~631$E#GBMrXG6#%<^;TXBG$NkM
zEZjly+(366*c+PrH-iUo@r6Z+#d|L{?yWCl%Kc`s7zV&2Sm1w%Q3CmpI^VZ;T^s8_
z-Un)~Pt4q1WJ<pBx6#>Ll57xsrNhuG$iXb%w!}E@X&L<Jvi9RU{-A$$!RWN_RDR$@
zUjwg*h;ajHDs(0%ls)zlt4DPdQF>XqFGSk=oS2a_`B)X_jqiJJ>^X81o!^6yR|g7)
z!rh#EkCR_zqAP)`(a@m~2?UmE7bO_CRF&^jv(}b8E%~RxKUVKIIZhe@uN<G*U$cn4
zVI#7Y4SqC0##H<=oc7<=>~$?v*-1e=G^e09sQwBlWWU>aYv~3EYGBO&_>%-L&iHr~
z0^StZA|4%z{^?A-5~f15`1};<jXZGG(u2f6N5kd7VCbB-yM!8wj2es_ajiK<LkQU?
zxZmb^P52LguufF$6@!VXBR0q&Gk2pKzeDCwm+x!+48=cpj<+>&Q;3vvZXQ6a2`0hr
zodUtm8^H)G_&X%m5TqQ{Jaq%|yi1LS(H$qVsvUA9l{7+E%FESshGp#Z&4UnYV3qEZ
z98VY47c25&!Zoj_+73VK9Enhj9|VTNo0XO}uH7j?AUpz$u%t0tZVA1$@Ue#CCII_C
z<dR=u_O*QV5N=e97GiN>gqKhm*9e$D8mmifm%MO@#5CYZomHddTprms18NX;m*gvf
zJJHZdYxiTltwERPYWXjh%pefc-o-Tce%#33rYc2m$LFU}gjWbxtAHhA$hUT>wM&~K
zNjC}pXB7z-wbS<>;Wa~fNS32!Ycs*Wb%p@XjN!Vs^ZojLp;V|^ZJi<=gm5S}1%`c?
zilLZ|I5*w6i}#Zxsh_^;HmR%Dh{`a|jnXrO&=GO~ALFAuic++UA1CNj$(5a@Zem|1
z#%gSsFIx_&iGgax(O><c@xq0_CpVd~d*Uw#pZieW=VYZwR>5GszhloRPQy_;=&lc{
z+~u`D&VGwEl~Bi$iSyf<$g=MEy_4vNV`cHh7;blv&zhDJ1ks!Dwdm18+qBRw`8rf4
zUsQCLqs*x+usA{4$-{W@=ts{Hr*-d*?)RilCGa>JIt#G*A{z!%ryy)4vrb8HX8utP
zvi>}JeeSjX8;1|M276jMD0I0tK?>ov6MlAcxyn2r(tc{7*x~pQ16qYm$O$Z<qR!44
zSyKZ7Q^;Tz4s4m(>`0c;@Y)kpPKLUI%<pc75nG2YpgINJh6!<%`^XE^M!-aEYm9!C
zG7xWpG*czo#uoB=B77)+V=ifcNvhc|chkQ73x8pdouT<}pSzobC6(LXmjXG%<@A2Y
zRG##u^P8)i%L8kL0kpv0)M1YV(T_q9v(2WPR$_WdiKF}Sds=EE!#Y&Z5-Eb~e|hUn
zhNlb$KfyC4XNDB3#IivrX$e_@(|YGz6nYao&Shn5Sd0FFKJWZ<kRwYKZTyXm1*<;B
zY3hx4*E_@LIY0B@obN(ulEVUT&krTMT*^G=dN&WZeYYm*eM&Q$<}*6MeUX$@7fW05
z@mZqt+r5AX!EgXgivhyQk%^OAG2)ABVbAg;)8G@9t{o;j#>xB>Q_A4q<TG;}JdR(i
zmxUf;AW8+z!$V_k=*umRLm!lnHd6q<u?jAXFEW(<*VyyDC@b*Z1kOKiw80o(>;Q-H
zKh~O{Ca2oOF$fOsRp$rUEqMP&Q4ZN93T_NjU>?i+sP@Vzs$WU4?!`s^Xwh0{ke#-9
zE;AgDfU4l?B6d3FpO#~Xm}K02?lOdsWM?9MLt!umg8U(HUm#JwDl(p0_BfG<{UI!R
zd<;cHPbsBVjdn!emD?-W*;7j?+QbJ@asgS@pBDQ4)liPyWfBBO)?V*%ky+h<^U=_0
zEsEO#*2uk)eVQCRU9G0As9${<Eg-Wh_=V4)*^49+H{UfH_w)Hr2{3w8RyFcimyGI-
zlcp@ha3dGWKOsb810`82WgbL!k>Vn(UJN3vP^nQ)wJrs^Nw;#+PgpD_R-OI%o(VoL
zc5E^gs+&XFY6Qy4AwQV-YLN=V2{I@L#&z5={E85QR;dODf4VT3yR@tVP4Q>g_SMiI
z_g8-QNwPpZ#>Db;rZJ}^sH|)^$<Qc@DKP2wS@BDG_Y&poBW0BOY|_Dfs3b52v6g(K
zY1+LLR&#yeSNHqdTx$9t4VAdPF2JeKF^CqY$V`Y%!``iPrsg&cD+GOM#OT>L-^?Jc
z-};_+K>nmj0O|~5Q-X%B4CT+Ru&y|)@p5$as}a`~n77!hH=PHFG2BK~EWWiZ#6ehn
zqDJM;Y{NOn=Nl>zi4FDf!VUEXgBZ4ZFQzUzYBrwo@p|WXyM9NgJ1PH`wt+$V@p{Vs
zJB=6dIlTa1pA0pngf+h7zVo)(@o~R9Rp+gf+4+;xP_KZ%RyCog9OVW!CyR4fZ{nCg
z?o568@*XAyNh#JeH)mxX-$Lc6aJYEnd3~k$&b0}+PahIV1~24OUH^p3aW773$tcv)
zf9yT<*IR{eQXTKFT9*eul6k|UYu7+!Df`DNWn8jGErLzDGNZwpwk=+0@UgF1eY!WN
zBf7wk)!N0qMP145S~!N$&!)a2Epu~)W%#fVi1|gCjR2Cw4*JYyw|petmd_`TS>j?w
zy%=Nlsov-Nn{$PsLCzk_)~*uq>)Yccwoh#Ct;eK$*)78ckUt(B19E>cTfrPt>A;+$
z;l=EEtTzy{quoaKyqHRfF?*1mOcomYi?iTXWUWRQL<tQK<g?0E{|S!wZZ}ggRJiv_
zzOcE%pKpEcEt%kD!u3Y;UNT~RN%G}~7t2}hQ>fO=#VNL7|B;HN02Jh?;v`Y7N}ulP
zB$Nk~Lji{H-+>d&L7!YrE-^ux)PF(cFINqIxTicL>>WB8pqyf|d!vHm0}~B<%c%NB
zRT4&G5@Oolo9T$Wy!wu;_q6m)fKfyqyZ*kYVD7+1{}0R;<Z8s0Q<!%6;)5Fp%FvFG
zW@D3pRtO|}-LdyRF{Mw;zOO{$&(cP!VRt6Nii>|e-TvCjv8=D=R|4wT_Nu=wqQQ0W
zAB9S#DAsEY3wM_h_|7*@%?v=Z6$ASqXk0uhG74pn1=c*rAN=WVyXD^D*{kBKicm5$
z_VTTUH`m;BOF;}R8D&1_v-+dR`UfbkP<*FihZK`{t)LtR_pAOT^N0}ntePHr#F2f`
z&1ocUR=$J^w88^>8PjcPeMTA%ADuK5A=yUz*C>Ci|EylqQsn;t<D(m1()O@Yd*v-b
zd>{aQL4N#HIr8LX!Em#cd@@{#^uuaXjwRpa3b`9x=ZIxdV(rr~7flVEaPQ_T5UBpV
z=a>QLSedE1QX@7o^_T(pkft+CnhO%E^FSzzDsE16qOf^BywHOlU2=6>-5r%fAxbac
zLd>-?&BOfI8^?BBT_>soKL-4`7IP%;Ct)zxfn{+eurh|EoAG!j>j*uDQXkqW9zg{)
zJnq`qN9`7ZsjL_fDAf4VYku@$;tg3`ZaAu+5{9`=PNn~n{^Fv>&^-5xW6<8Ao=TNK
zU3u>$>iCb3I=qaig6wMBrF7;2MyruJZD|$<B%6#tW%?F1)G-Hq%a0MBKZ%B}<B0B{
z+&$ua|1fBcI!KQ2%{}MUm=tWUBjA+LPkA#RCC;A!<9~^A#wnio1lqNaD}b)n8eInl
zsHRbbN-P?B77}&BdVmv7uFH0v#<Z*TF!G?KCdl>wjL5^wA|vGTl-`qZ2gBhr`sTlD
zL$4xpBsu!(T_@}Q1C@Md-0)fl`WOm*Z5bRqXl*1Z#3jP_o(7+Bk@9HhEm_F(-<kU9
zVq68z!^row#{ZahoI#McKu{g4@CUQbcdhVzeYl}7?(Yv40TpftCBlR_>=_C|S^hiy
zIgX$YuV&5ztC;q91YCr~sSZ)84#T@f=O^^3zaRSsf8|L=JI@48wpu}9W`+7-<)^|t
zvxBXZgwKJ-23xWH;@jhAf00rUPb+uhcP83r6G3n?Z3?P1)le!eL+W{=VXeaxnR3>Z
zV;vlBf_oO)xWkMyagW0n?|L~~^1vP11v-t4&Y@JVl+8A7L(7j@y*<rcbG>s0^vdsB
zfB1zA+kP28t78Xtug~#3Y=V^kcFft2TQG{l2Q=Q4X4SS|(A2m8vJ?zEuk!75UF?Oh
zT?9n-sc`&^i5dzVq(I2I_}84z_K4A5FhylvH&7`DQw7>i``qe@YH*Aj_xE}n{S-5`
z>(Qo#!eFW5L<M{Qc4*>9Npi?k4yrpCENvb9h%ec*<2)4xE9Q9LC3=XY%=KnXT9Iwu
zQZr2<;ip;Lx(RGH$DE~3(i4Pi-fmc3Wt!L;N+g6M%|HYyn6Hm%m7$;M!g%V!J=m1`
zxaGj5hITKB#2zsKMJ6$^7Q3!{3U$NP1x;F$QP$k|S>{>wbhCtq0i@M{z=mY<zRj#p
z=Toc8E5+`Q)u)A@{c_93&%Su}TH5u9mD_5jz#KlcP5o0Djnu|J3a?hzF@oT0+LTn@
zd5iY~mhXBYa?uWJp#cFgK6_<4(4%<U9(Ef8@zX5Mm#u%Gp950}$<|j+tT3#_D3C1C
z`!%NjG%0<eoauMH1ktgu6vS<coXYz$UBf_bwxmrbu|^*Bbo@s=5cHH1+VSJZS0#}|
zg{}dwfF>Ax4VxR%7hVN<)AIrDXBEj?N=a4pmL`{Oo?!5VC72Ehy_&IC#@3Jv5q+g7
zYKuxYSIr^IzhnBuE-6CcR)2;D<VsUdMUvx&;nVBsf$;LAdHHB4KWD+y6yzFkSbcVY
zUQh|_UI(Vy0)t;Fffe2b2ivyrFREN~xgTltLyu%Q<Yb$M-%1|}U9MU~pYbOb`W>yj
zCzURV4|EehRdrgIzs1`r5O&doti{=i+Cx)dspWPBynFv4lVToOdB%()6INN!-ky}E
zwwOG~n1weR+%ueniLKcGL%X>J_wf1SXxzbYAIjtNn}h>Y_0mTrY-%wBLQ6d`y>xIS
zGpjQ>ywVN?ed?pNB&;KgJSJ-!<<`2!#QHLaRTR>+zD?#y|6p)WQ3mHH(bgjA-(p32
zkZmUEW31bfpOa&jBxD!ybA#tTdqZ31YHusl%j(6cjdRjved~l3|7en}jk+`aeg8Cw
z&~L?+scfq5+v=yfmLuN)v&*3WjpqB5R=~6xg9JGPFdbC`vKf1x$gP_CrD;F!pZ|L~
z6962R_=@TzA9dj3O*s4+S-9$pO&|7(>|wXeU#Lz|9(+$<>w&{EG=H2PBCSyV2bO{}
z3d*;l|HsFSQuXK3&Lp!WzgoEXzKKGBnaN@le|>6O**<+78xU0*yT~4F)KT#z`p<N^
zPUul#8|&qlKQKJk%B-vk;CUN`HKJ>MX-TLDRWrlH5*?Pn`{zqh*Er6rYtt-dlg3P!
zjth$i%8GP!28vKI?pD`<V}d2Y7b2I{roCsQ?i~08nSg6lp$z4lv0{FRFbzerjg&ia
zE3kK!$4*HzhpfT6I%4!}wGG0Os?v?WY9;wAfvtmsNzEUan8(uZ;r>*@W(qC++<;M~
zxOC@ar0BGNfKXw%o8#f)-%W5#f;7FMhe8d^e`Cxj1_!@%ME`0*DI$D`an=84CA#i$
zQU>Rd!%tC#%z?LV?`!7-W<%g8tJ{=#58|z;a}46}bcd#kDVpRqHt5?m5tCAoG?n4V
zVJWK7=|%RT5`@Nfsq<Oo;NVjfT$||;yYU1^HvMViUfzbULK02Ho{qbv4sAiINoJDn
z#%F*1%TW>R-5J!}Tx%Y{IpZUBjz9@%-k7V3;I8iXy1)~XI~#wJqyg&zE1vGj9Iu0M
z#n;Zkfl7TTyV*9L{q`{DH{1g7>gv=Njk#3dYMxo8fJTu$WiZNu_N#Ny&|l7B>3@!0
zJ114kU79dvQuJJJGWp@AAaG+ZcyNQTS^45XUCRSR>8wZgElN$s1>4c~RQl!vIL!5C
z7L3u3+_*D_`Wx=#JKMzG`FpzeznyA@e?^_Ce9pAYb5UtE=5um9;a@NNb_6KnyAhGr
zZnsJ@Rn?s8TlL5U@D3E()GmcRs}&sF=!kArqtp6kz6zX`XX?Hj(fzBAkCXydK|URi
z-mZ5IgP{~!v^N`%;7J1P`J3{hmEtn6X??@DiB#u%C%yr7+{h(evBHGDUvDI#&^DBe
zXS9MJp+TWJf-iK`1%g`x+z-PzvRW2r{uY@qK7GRzu2^7{3VV)XEbf2JR#ZYkLG^29
zF=Ll-?Btr+&x9=Iocou(dDe#|d&62=J}jAC`ticPDGLr9$Wl<<npqyX=GW=M($2TD
zyi<5WB^y?odT!va*L1b(yj}jVGUeB*Qcd90#Z}-;o^g)(<~2`G%eJkZ?JY37a^fOU
z<s*ytmoIv^WG`FACB0oa(Ov-w38oV!{o1ki-@_h1!*{oq>~v|H`$EgLeERh8N%t3D
zeDVG2)yJ&)JahlL_9~fm-<mopz~|ZWQ~SW-5X)iXU&{Pkgjt?9<5rB$;genSbSGI<
z&$}(L9k{*PBJ<mHX->_|zSH%eoHps5G5#r4o~73){(GC|L$kTFmc5rt5IOC2d#ccN
zo6K+DU7fw8gj)|4#;V&q{iS@nsOzlis@ShAZw_g0>+KU*y<?^O(iEM%wG)@dRZjag
z|07SG>V0-~tB=cAW^u1z%3W+&m&ws4BQwiAjqQt<ipfgdiKhgQiWHhC@6_GuZ!|eY
z&_q0d^_E-mlIF?NpDQvNy1x3Qq@pRf@I7zltX}<~^Tscy-Z8Uzne>?lVxDD4qrt{X
zpXp0fmN*G)OwcsU__v~Fe$mmbE-uZJ&v^W11S?BsS4x)f%08T|x$#E*#wk-KY@O8M
z=-|dVQ}td#{?XNZTo6_6YZN^@rU?1>KGD!z7{15%@z*Ea?~X5L_|1@;9KI-ki}f^{
zYhp8Sf9C2VpBK%mx%l^oNP_%=ToYA~P{*wrfk8$OxLA%gO^J9Vy3_3Mk43*fY96q2
zxSi3X>&rLG%U{STXcCwDqF;%sniK#3c1#Io*d`xeVsFQKgFQpKw=?7A>wr*GwVMlO
zE$iH_p&BA-@T8L;Vag50(}uG1C%f{<z5L4a^x2QPjk*PGhN(M$)k<)?6*Ep<kh{gr
zC-uOd+O@UUcrU~_h-OHyP3*X0e8_g~+dF~~fwzePZ<btl;{^JaC3ms!o_+r5?!}Cu
z3vwHD9nfftvecjpseN~?4ssU0ImWf?%*JSSN*CZ0ssDoJKlvXy4}UdyxMTyhsFt`!
zl%yn<q*^5xr2;7iBLhQoT?0#9BeM`gQ!7(rD`PWl0|P4qgN=bjJt!J-^HVa@DsgK#
Uz;g<C1`z{;r>mdKI;Vst0MC{YhyVZp

literal 0
HcmV?d00001

diff --git a/docs/source/resources/subTreesPrivacy.png b/docs/source/resources/subTreesPrivacy.png
new file mode 100644
index 0000000000000000000000000000000000000000..3a7dae6110f8d735ee0648caf33e94b0afd919c4
GIT binary patch
literal 105835
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%0DT|or6oc1(R*d@m`)QEC>>Cfs
z?5DfKQ|KCh(3UA`jCHdab`U%O*O}?@+;m0#i+b=2H-}8+OQ;DG_>&Xz{-_&=i6GxY
zDKvzo0B=zhgnAtREObS-g38-_iKf}wsIGv2yW=N+aTXjj>4wl3{~mCCe&De9zXR@%
z0Yw+&Zp&x&v{e!Q{hV}xZe?`t(**)~p+npOz)MrKmQ{vd9hwl5KO-UEFxT>9Ux`9k
z=C({7jH?j9m6;0hp$=(ku$yQG$i?Opu+v3F?}E^+-h$v;#(LohSC05c3vOx#KQSuC
zToL(c-}knBX7kwf8}fSc69Ive7k9BG5cvWURh&np%%c_fB+vrP+Pd(@XFIw4%h>8e
zsE<B8s#;#^-zS0F&#jA;Oyg5WyxJH`3wuj5PIT=o|CE#NCT&H9nGZj3(Se7gdKfx)
zUip3W@k#O>YNB^9|C&jO*3W-gO=~<--ApA1RG*jA(RB31q%Lh6G@}W$1(annjP<zE
zeDJ%<J#?|}4g$2Sfhn_@#~`Y}cj^x42V=4XY3kYa2`U$(Qks3L`}WnF0><7~+q%}<
z6J*IRx~f*2%{WLIy!_Duxr_V1@+{aoLxLWuKzP{h7C)PgJbbu(I!5#6<GP0inzd{L
z3){JNmjNW%LgdHEYO6-POr4_9$vTBfRZ8WANqOmm53JZ$BQxi@=oQdD(_M(lAewX-
z=g?n-?lAfCN1#*hZyG_fZ7K)@(M*^y_OmviJO_s7<pGok-M1Dh)f<`onT=>#%f&e)
zb8CjD8z}p66GLL3OKJ5$5a5*8mN<U!PlFqsMXEwpOM4=Mdi@sV7isQ(PfY9~)10;O
z;q2F=D^J|^wry&@)$<C@Ez?pt*{RK$T1_K-;N1HLUupe1zL&UPyfnQzItMO);s-%r
zqpr_0XTL(43+E&NSqCQlbZy39AsXKm&$_VS2kim)(=pchazy4+F4M`yxqA=M@{`59
z6LB06bJCRqrPdO%L`nNjUUVr38^(bzGTr=~%ztLF=-o)|=Akn1zbZUW))nM)5l)jw
z%%jpia|=8sJcRc?GqWHI{uSz=fc(IR_n%4%2>#tZ!s6(J_rU&r;oUjHwH8!$mNJvR
z(7@F~LC`wnYq!uC&Tkg5C;f<(rb8EzuN-MR8xt<%v_+C>GlhKFC+>{3%H%y6ZNao#
z$*awg>0}@1RqX+$V-2^Y+DYs>3&eaDde!#bdHVizSXQm^;qdbTAP2=uanmwBp%wD|
z@ENjldk~B|0jYb*DfP#w+HAI1)v`y#6@=5B+4cIUmpR_Qvz4F`>JT}^9iD&Hb}eE7
zk^9N=*<>PzgW&+bI@nrdXvTclhL3XD^~k;I0`R42=P|1*^?<NhEBjOL;AyOblIast
zG4VO<?|i=K=C=<V%g&#t-05Zp<)dS-?)}=kt_Cng?IzdSK^CqB{{9RKYC}^oQyN9a
zY^kvalowp)3&KeCzr%?p9*rBpRlYj`G^EAA{j1MXf}cE0idG$Ss1SeGY$eennWMQa
zX2G<U4Vt;Nl;5e|yGAQ+rpok0`!2*fdr|);QSj-W^@Ze|ja51MP)tdoqxkc_=hv*J
z!P!xO>Wch8$v#%~Iiz5e3OVlcyzf=fLp!SQ<c78IQJ8zrv$sAbFLB1*jrp0tR`?V%
zTgSMwy*MIA#qX|%ns^a&{Kc}SFr#)UfBRCpMK<L98&pEQb>zr-SiS((D5hCrxLiv!
zn@jSU<=su<AffP2of$i>>~sZv{u^`?AnM!ARG^xJjF@>qW87e?l;DqFcZCS`8TPEX
z<#Ib)hxy8z2~dP$VVl9^_F6+YrJm~^)C*N2E7bU`QW3o|#$QL7eoi=&{vtVA*(SH?
z$UxH1GkCk}CdMe+dyxJ6L-bQW=iNqdq1tn^nvSJh{ISiez{eemsR@(fstrQ>84TS|
z+779O`A9yfIa|tCnrm<&R1#+IIJ|9V{0Wjnc^b+gGjZbI{(qzt>DGY}-4>DnUuUhT
z!|3r)15t+bv*^#UX=dbwTdtWT@+8O`*(+aHPd8ckp2uU=$_CNxpWW}w%R?ZW+B?%0
zc!J70H)A%W+#}Di+x>+HeG=IG=z=jU6m&^x^|h7sbAzE9X5!b7iBCM~X2&+UhgK5(
zEpN=iz;IkNLl9Ud+?6~|p*A#Vp+0^)Wmn#dOU)Etwd(If{hg4oZWFR+TM4GOwW4TE
zr;J8Vz`q?;J>Kc13$oxb{0z<qR{{>}RA8rWn(J-v$$=6#(_k!`MaS<tZR61PAlCl3
zE_>*9G`l06ez4eJxn!3AelbtD@aMZh2{&I;;zIGP-i$=rua6ZH$`=@`E7Jg#TY$6g
zxrtR?zhwaFV+ip3vr99YUZGCk3PmK;Di#ETL9@-JRxh^)lO`t^Caz7l|KO|C_3Klo
zZxjY0_lL35j&36Sep-fP&`#~201r07`TMgjwp9OK*(SeHEYyi&$K;F=5MES0Kh8q#
zj~$+Np=v?yV=u{&qiRaVpun{0viQv$1;G#>@9&||J~=AYRK7+ow#kdF*BaIM?ava{
zU3OTQtcyj<kEt!}*WNn(f#EegX^o=~;Aw3cB7*^7$7DOxj@#vuLz26*diYA*4lD|`
zWJRgzgxuccv9aFSr8S-nV+M*%YyMSf3*4to*0daYTou3ycA}=62fH{^0=rl3*}vlv
zejikG6((J|V;}dLtXgR5`4~HYwZ-i1Y$3`7$O5`<12d^ywpm1F&F0U&AD*}m%iY8y
zddxifSp&~Zd_B>d#W?WV>i;Z>=e{C=%ITq*0AK4RSfOgF<$C(b+(^5C+GVDG9IkhD
z<>;H~v3NiTU@hNT{2G@<>9hT3(1d9gZdxY?RKFXQD7F?P5>|g8LVwnxoF6W#WS2br
zLO+B4Lz(=+v$&s9n0?+@8Z&P4#G6pq{sG`bV-K$}A%8TOCbGom2**SQHXq3p;w#5c
zXsApBwOyn#6oUS%FZw6jbvrRt1M986C1P+BKx1XjcczzEfa9TxJ?zRAael>l59YLk
zXBFS&I==CBp}CrFa`hR@{-g;fxxydMCG7vjnohdYyF=D1Z*5M`aEJ9smnrw=9R0Z5
zA9&D8dWwDolow3&(^NXib?#2rP^z(Ss73*>reRbaHFInF$xH6oaG>EXZ_Rr;h&QIz
zyAi3ovDA5b9<<Qx=x{T<J>}oOGUEbxpy7FR9Gr!``M0gNxD>!kcp|&raw$Ni3AUu2
zron?6{aw-iY1;JY@=Q$$;wM>Z^JkMZRSd2<S!8|kx%~sseU}xV^V<XKsl!X>EaJ{}
z{D^S@6Q|VPuc;dFsBgs4j1J*m9{JmQlmsexrD?`X&+kVa%n=v#V|D_H5@QaqV3H)q
z3X4C_?A0C>Cmy?XU_!j(Rpmr}dxZPw1Irmha8D3ygz3{W+R3>-C(s#_@I20)x;N9+
zIq|3X!Qj5#soA_a1<Q6dWaXHn94<avEu|o2up=wa+v{y(b#pTaJXt<kHs)B}XVMu0
zhL-2wc5>L)R<yypmUMTx*{D^UL6D371c&|k<wqMBE}!7-0H@dyOtR5$?|`q-jXW>w
z4^yt{_m0LQ!rWH|;~5(qo~tjWO<V<HJ$173jKvplO=2aGl{mz(HRa=lr3ieLa`d%t
zQ=_fdL{Dvbp=XKMjDvWY2ijh3$)7uQ!IXd4)fxT%&RL=lCh9!>iFs-7%e9%Sg^fBB
z6VwP6YDeMNHNMJi7W6&YdLo=j&04ZYkkHW4EOVmS{o2z_?>&8LjeG@n+<}hY*K*}u
z_|?hnLY?Qu<)3v#WwLw$=kLw+gu{-8kME{*nNhAkbv@RMd2P*vf0w>M#tY0t+fPbn
z8$!k3DT}EWdInQ{u>-Ezz!!gMM$rc|i$M3Y1`+pF$HetAGpb)Ua(OGnsFltA(|9gx
z-(VB*lU9--9D0nNqkNX%McBj;a9-Rl#OG`}!(ErZ(r>9|2wa8s$rb&jTTxQAILh+l
zICJJ{9g21A_JlykO31FObdM+tu4ud-1WMdIJxR;L5mE0Wsy19DOV7!0m$yrmH_%r<
z78b<mJaQX$5vz|6W0=Ja*rvS6b0(Pe!Vj`fKAg?HzeFU_E|za#Nb9Z{si)s0Dx-rJ
zS`G&Zx(c>n6OK&f^eA`JnoLiBeE{1ny_qUGN`TM!nur=YQBgAWMLwXh`F0aG6O!AL
z7jnvdJ1T{hn&&A!Pn)N6DQ4W?WXfC-u_<K&r-ro;>yur6%0*c;jsJb48n(bsR_XSg
zj(?j2%v2*cYIdh_g(;7sf!FPP!cNRt42tRhIA6+rnWJ(2oaa?2r~UZ2vRvNn=<P+$
zEHM1VJO_Q8f1Iaaqh4LgmAq+Qc~W~VG?@34q%1Y$gXAHrXymkLV#!s%Lj-f->rb3X
zV`j+wj#&79;TQnhF;{5%;3#sig%=u6r68ThDL!TVgG*naWN>E!ZnGCF<bAj{9j;sm
z^r7%F&D*b?@2RbLkJF0Xi1i$HFVkf{Ju{|p{1$*PS`tY@$&KX~9t`j2>xjXL`!LC3
zQb&1%|2=7I=b#WERL~sRy5H}2vK}R0zdreXz_z=$_wm4vo=b6TP?4utC{%5i+NJP8
z!TxD<G1y(VE|$sw<kM0Xqsk`dz)pszs_T_f)gWus;2~xT`~{>Y-jQ0rW1#%r)k8$B
zcfeKY<acs>HYM~th9ji-J($hz^z7F3BWrYyK5_C;0gpkG(?8)Cdpslc3bu1=J-VG{
z`|@jAOth&_Z)om@>g1?CA$t)&X*ekk(nQxQ7Y?5T>YK62?iIUq_U}P5Yj{6mpKncJ
zNMAk~S8_ZWMzn(`TH27&BtBu-nu?yl=Fr|~Zch`aIC;ga(Cq*#Aub@uIAFB)63p?r
zE$$Y1R@$n{Rvba2{_&7-uWUilsfT4}PZ;?IVji}YAjv}soA@Gc4N+-$8FzpwDI4CQ
z+ig3RKfkoO%sFeNyBQ0GrZ(jD7wDPheT-|8pA%JN9D7|SSLHG!Eg!&9Goi{hgMPVc
z8FT-xMAgRWt98bihpvi+w<ouIA-LhBZ{n;@0+c=)JL2sfmKzdxuRJ(}i=PW9cNvWo
zp~Ra$xV*3AjW=waie^Yf3tsu1U_{m|icKzW$IrtAM%@3WPy4~Vg5Ebp&TSp{x)p7Z
zXDsuV=<h|mL)`Q~IZyS@!ZXj@M;6}}j!9i?-lEMX6s$tFb1u4XDQ^2iPe2GRK)qfP
zm0_6(sZHn2rD$2>Chxlkd$_y@pgpItS8sPxX<v>vo=j_G-I!cg>dx*2fa+^?r;6s5
zynTw~3%sO*@H16*(=0_anUgoNAJO-#xMh90Tq$;|wD^BZHOz0pxJ!mf^^NX>z{~qg
z1p5a@B#8^(U6m<g+hhr;d&MvF2J)onD-OwS-8|OH7E0m=itJ7ocEl6_FqT_filo#H
zcw)i-xaN@4FSG2k)}-JLOJ#D5Y9*N%K;;>%BkInxfLG@rV!=Fk4<DF5aLuG{c3?`&
z2OL}>2EQHv!OMpCP8AC!a><Cp9A4dznZ($4?~-!>$+p5m!&cZe_1r2>N{=lF=eCx6
zf^A}rhZztD+`v(C!2XIe{Epuyf>)c^Alg;UNi&sRhp$6LUb$Op{_*q=$WNR|5*CC1
zP!I4vSD{;*{|%$SvzqexvI-c20Qz!c$i&>fu*%YYy0X{$Ot>3op>s~w1lsqe%<RYV
z(1(NSic#-A3;!c3!pWBR@$Q|W5A(b(RN1he+=!Fng#d^B?`J)!|4o44^DU#;Z=SQ^
z)nvpS`IHfn&jgxU06HGgBtS)M-h=gL1jw(T$Y#W=fcs$b=*%IrV(BJd4zn+Fh)S5S
zZDN~n)bL?j3au$U;0~jsHNkZJL#ES;#T%Ruf#=YGH_QX|DYgdbd8Qz}ruixi(RM9}
zLKtDf^E2e>8~fTU1u(dRn*e*)ID;<e!g<Fo0Ntv+y>2DVn%rmLUrOCctdgz>s&uM_
zRL46|ptiD%;`>HD)hHVe_#BvjXxJW9Ez+(i+*9BN2^nNmfIjo#e9qxfuM(Smf?q=D
zr}+Wbh*IT#46-UaiAD+7wEhAD|8+c#{4TTN6Nh7wD>+t(Ue$^G#>w5PD0hGrP;hn#
zahgk$&IM<)xob6J8QfOc&-91RR$ED({A{BcHKnnpZ}!*tKbd6?x`@b+wNUXC6Emr`
zaGN-?sZ`FrQ>8)zH^00MJ##W#5!F-S$S?B4j01UI{ZL|3tql>C{FG*WwpO!wGfr|T
z{~!qdyDlU<Hi`pZN1!!ZF<i>D&iRA?#9+5T5oZlu$1eYS@97)uVb-gTu;x9kP3(ct
zfv3l3wY~K(5!PIj=K4V3X;ptWAOPtQ5GBb&ocK#&_kN7L@1L_k>`AGCINU%ymMd;@
zCcM8OMf_rxI~jLKKGT04djALsVUrb4(siVW6j1BpC-*%cmj(<=togvEpu&uM@CD$e
z&tp>+U+51s#~j+)o%3<bSlSBYP^pe6lXQCK6IktLbC*`jlW7p#6pU{RyoMa?nFZ0@
z2CiI?N*Hq53-md@DD^v;(xLH?x%7!}rq2IMbfyZuUHPJEq<!PYMesuz!pd-uR_E0q
zaMeIW1$wVp!D;=j-2;8GggWpzyE7juuEDb~hqD~#yco%PDg}*XiIW}k)4Z&r`d%6!
z5`yS`68uig1z5FjzqHi5y8m7{N{Mvoo#+e#dp+a1h))srXw-RFm(6^qw{-xNSani-
zsOz}?*y(Gez<J<=7ULK-OCLpsE%zLk-Kt3E4AYOiSa}UQ;s4ERd6u*HH0h*fRK&;~
z5o@TT9tnahF@fM5eM8(g_vnxgc=|iTr=h^)(vMzeA9;g}{4rIfwhyg2?LB?`B(UN}
zc2lrc@iCNOhLKq8L9%iVMKrv<v9_;9jN)3Jt*#G@nAG?J!iWG>pl8zXtAo((f$UA0
z0n3iw7U?8HZdXZj&p=0~`T9R~)U5k%`3fYdLYI?C{mL$aaSf@*rnGr&8O{BJ3M_o4
z`lUeqn-K6avgVI9JPWcAsqKi4dVoY*#+99EvCE47^?PMV-}*+q-A3Ve!_?E^JTGrS
zSgY}&oW204bAHYJSQux!$ldv~$lwwlaw8P342_MCJEIyC`2~Y-m&H3kSs$$<NaQm*
zLicjQi+Z{8ramJBp8`l*-4vw+2F5UDH(&P&U6-Z`XGyWY9lulSkl1xiGv&g>OCn&S
zq3Y#}W~Z$$Df#@K(e(MBnguK#O}3cGP%|^q>Kpdw>9=xk?1q}&P>uarzN0}?e1dbc
zSQKalj_da5QjNnfLD#`8tel?=lN`?osc+T-eBTZhlIuV|u)TAGby5zKpYyibHgs`d
z9LecTRej=`1AHvT1yZPYG&EQd(&d5-bnDf{Q@{-sub%}3n;a|VQJaz&@>FJ^bVlfU
z?LhWAs;!CYZM;A1WqrW^B;Hiw9oFvr@k=|hmo>l#dQj1NuTnI(eg}K|=R&GAm?)$&
zxh3<SACp=EFYqB<(I4e5=(po6co%N`HLyF8sMdvBkmUjmewGg&{utxWz&bH6Up1~|
zBl}|&`n3N6WyD({2GfiR8a0Qe3U{{=Ae{3~EGSr;<ue2DP&OFA*lXkgdarV^lYODx
z8uRKB5kJowcOmbw(dwHLI?F*!obW=53w-50-;83(dW>qb+2+bF)#$Ntp);CLRH4)N
ziZ1J$HkdNpBZm2ydZ$ZTk;JUl<=3D>s@F8I`dC58&P2Xcb7@fAXyRDsnOKN%Sy}=F
zd&a&n8*Zd`%s@7Eo;Q!8%U~?E5-ev_W^+N&)FiL5yS{d*>&_~z9Nw1K<|HdHow|2|
zX}jGSwf4^JJZ2H}xb&KwGneB_B3=K{ti*A8QoQI_j|~C~F<Uoci+28#LbM_fIzUZB
zQ!}t&cav>h3RLTI8}(fEM8bvd=2dE>0Nv^<B+$D2C}n_5O;2Hb+V#+(5j4DrQ183n
z%E@6Cy_RY##xPeFZaTj$SU?v7#*d%%fSo<D6V?pR+NcVQT{zef&DSik-u7-FM(eUk
z{R#pLGQZszWt&nh#%@)=^b8hFVpJ^jnTji8mXks6om7}(hFVnfSDh?;eQry=FJ0PH
zHp27833$tq!aDIu=B`&mPju4-(nlIrX$~03B?friO|X0c2P%!VCAogIIYQ@yO#yuP
zq}z2L8!F<mlK6ecV8Yba1u1cpCA;dtoKgLS;Q;FOM?dwxgN_)T9XH~6D%mrXoX2E^
zHG4fxtWdmJQb2PK*;CMs_eW_MtNK?3-dG{FYFLtG|5Ji1P6gfcaq(<bHq@z3ob=#Y
z(3{l0IK#C8y}>-j7u`?IhkY%_ni>cwzya!0THP5gS-gMa-8mXk6bcPY8~C<>eXdSX
z*F%)R8cIHIUV1W`E^i%&S!xSBH*nY1>Off6t24(K9g@hnyzAMoJg(H-3V*uY+X7B;
zk|tYgzoD<Whj;#fzc^v4;<m0<U*v-8ub*gYfxnAf_3)GE$B_%v&%DE@3|<puE_esD
zTfM?_+8<5Yk!)%S^fX|xGpd`%LJ!NgKdTq6_7@CG1*b@vZ*h;s_6u4Nj>86>&-4ss
zk)spRjenZ3e&YenLfB*Sb)yjiKTkNOA#In=fjL>|1dH?YII^2)^pvURJ#91cWO8~u
zD2!~7Xwl4Y(LM8<ab>WlDsXUZWM<HGUX0O4_kP9Lw_^JDeZ}CkJ?O@WWxKKHJ&n{5
zkDWs;HriZXP!4s9fWhvs)OWp+UxL6v{CbAR48q;81}7!03Y)8v7LlSCpilAqFA`BY
z-%ZY$V=q-Z5S0pohpagQ-tqf9q#;fE>&TD$X^h+jH9=|+Euu~u{^X8^_mH!{>TxTT
zp|QQ<)Um9IdrtoW&y$tF>Ka8!#i;6gvi!e~y_w0rU8mn}xMwGTV|f$I#3g7uGO+Y5
zdKLE}2^~{aPyIkXIX{S$SF6<ezz{B*+f}6lw%}frJVCgkqu|lbqdJJ`20r@GkC@-L
zTsZ6k)kUP%w0y|Rf7hVqy_wH{USKnyW8DF(Oj#h1`!U7Q1bQ6!u{o=>8)1Fs;s+%n
zSnxK<xtsV{u;iGs2tRD$51Yq=DN0<urtIRa0dJ!x>ld_>Q(=b>OQ2Kjj={VsMXOaX
z*P2OwA!+uQ#+3ODnigAh)(G;q{#7kF?Ho)SLQiY*J4>NZEButiM=v*yf%aFcWiie@
zjrdIl;Ml}b)XX8^tQxDhmCpaXQ@XXm(Ye~Ku{^Y6(z}>eSJ^+lffmSv<+XLA%LU>h
z%S_ajao@w6?xvrf5Xtqc5Hk+0wSoLht^xyDr+u+d@sy#fV8Ny%dG=x5d_0NMbrL}?
zYYw5>0MRdR*t?NfsLki~E<_{ISOmV?$_fB?Uww5onZ!a-^zm!!w8zx<1_MgUVu_8k
zFeUCvj18tC>k~*IStVRQV(mdMcbRGGH$KfKRsH(g^qY^FK@;9?Mk*CMF{wUX@s=3}
zFJeKYL++@lg%CUlJTsllXN<?Q{c&ADabq(Of4de-8RB+v4{Y$A^F3}k1V?24y8b(i
zxP>0-<9ACpyrtF9%Zx5;slA9ZFUvUm`jo7!Rf3w(Dz<#e1ZPe$g@(hM3{6UK59k^4
z)WTZ)`DyofxWWc9SR6RxNbA0<&BeknDo(VEJ$7UHN^xq`IUyY6WB@gxW7QIOR0k2U
zsLs#B8s51k_F4FKizTykc*0)vDJwIzdQuiFfR;dxWS*Pc|N99W=zG(_3KgnuRGT&X
z0l`(%G@kkZB@>7*>c8eO?n-0e76K*oK-lg1nTbyvg{6i|;RjaE%R+#igLF}uL_tG{
zXTDm?cQN}A<EkG=rm=S{#?0cE`5p6Jx1}lnF~2D9wgPSpF^u*+vV>m06rw&+#QhW|
z?a(Iq_>kK>?n7YG5I2EM<0a?%Yt*p)b>?k?GoD9Kfbq4T=t-Alv8YX6(Qp5APvdcN
zyYzPqw25xnRqj-8P-||-{8!aMe}=?u%o}eT;4|$Wu8W1cX#)fjwCRL3hiYvP?oC*|
zwQRzTW_6ezT>pJmFY_Q!MuR|j69TK`x?M+9cLP!A)rgtgN4*b7^|{f~NCx;;;y6Q`
zftdC?U+eT=i@8_Hhk&New=W<>6XbaYBcwNB5mHnO7Q+PkB6UQ-M*;{=Keww0SJla@
zIiE_#jV&xJn3$WJnxP50at9UMR&ZuH5qY;Ni(j-_On-;v?Zg~#9j^0i54s3~ibD}l
za)w`Ccp;&rftZm>_wB{D3{`qch<Ou*Y@~lF6yw@Oz{QR2_$5<)QXzbFpMO}tDSK|1
z24Crlf@g?d`Ff@vJwK?=6A}ZAp@a|f+lqU-{>>X;iGT?g@c)0AUS6XSPL;uRy6(TA
zpAV^c!%SfX2FjPK6i*4lUOxG2VJ;%($wv1?zG8~x`Zd+XMlOSNvSI-E%}n|x@H%OT
z!B0Asd!T7QKWlVzq$Dh8yZXGP+@xZ}*@ynku^wzQPxuU`_qS-a)SB9|e*y$8>OC)f
zzA}0gD^7D;zMFqJC0de_z*iik$q_r;6)rXV`)JdE|7&VzF=3JGAU{f4L-?=sJ(w9P
z^)(W=*nskdRf@sqM}W%u%R#q`&#DlW^yaYbo`sPPaYVN^Ql^G;ipPhk^ERkEfVx6(
zKzN>2WO5#L17^lCfEFeo#<X5w3%ih*-wt0Lq|<KX<geb8lq9)w$84gUO_p%3-SCIq
z-@2h?Uo$Qg(5ZzOm8VKo<{}sT_c6}l)ad&$k-zb0sjhLKq50t-4tZXT{8|-ln15xL
zEg+Qz*2wUjd+D<Eh4lc#$fRH8wWtylf~z=Ou8rnq1I;x_;fzDBG^j7<LU!Y7-~^@h
z%~nu}^GAfQg810P6C9d>lF14Y)_}}B7+=kK@l?CI7*F*uUbt==KJQmiol-7WdP8OZ
zx84g8hWQ1{-UF;%DJ>s<6v~9LrG+CFIkqps8_c%2u!kTvS*bv+vPFdZ9z0;CTajhO
z*I7w1_Qmyfj-Xml2-+?r1H~<RF*!3+dRZ8<c@Da04q;|xo{WD>B6FImjCZrluxXgP
z!Bq+5I!w;!)$B@~RagS<WA96>UGlU|h8?{(8_M>Xa-_Hjh2|4HNyql+gYEqGTWl@$
z2kX0rM|V>%X|3u_fUuZFo32KB-z&??8vA`eaTuAFciGuyNVUq&)lJSdcG=p2T>19m
zaKF|o9e&>3iBuQC8VzM<FHByo<VEBI$dZ|PJ@ZKi3YM|_h#IT32wb>w4ny!H&JF7Q
zMXGY<F1;dCT%k_hxt~J)%WfR2BaDQFzROZmQvMM`02idcL%Zf&D*QUMhyT8rf(n=M
zk8emRl;G(NPJ=Ay6GeW&SLEU??(o|0cCnzl?a5yre`P2(DH(T;AUOY5<puy{DmG9y
za!x-m^ln*Yj$ceujoAJiXCX#PukBjXPL9KDh{COU4|P3W=-7GHlpoV-p92sOD%C(T
zlk}e0rr*&fW6TK)8oO)G*q6!*?gCbOPl3t}3H$9I&KPf+?!g-r{LwaV2%nhMw|Zx~
z5g9hG@da*3V5<#)FJSs{m|Efe5W{$D)%AAkaUpK6wRYv5`c$i))HWiYOm|*_G8r6J
z%WC#qkSyH&lawk<`1cl<0%7attm&=nOJWkoT7#JUxRsBcv)oA~2L5fWshpjQvrd@c
zTb3E)yh94V%QfTHINgkfu&lER4ewyXB!F6hVOr%y+)#6R8#}=Dz98y1nxQM?N@>>~
z6U`AR$w8jV!My*ej9au;>$#UA>K3`tuKi5{pHJP$HIY4Re(mCC*aek#Uc>g$@czBx
zi)eVW{tjr*;=`ZAjT_u~h|oyFS>jj_n_jx-Z0Qbn{}6W^0IT{8@umj4Ng{KD1egC@
zG}*_D+SQZ=5xJV!T*0qqfQK*<ksnS$;-M%Pd%vq=uFUe|U+LJ_bIb8(3ehdn!C`B6
z4vwx8{sgH1m<Ww00DZH0czk|7-vXTMu-x={f8etwb?DCCl4gn)?HvG3z(V9NykOcp
znoU2s+S`X?GTKw%d~|ZjZB(P*9<$4lWLD(dXN3$+B&Z0TKfHJRB5~?b&tYAM@bbd9
zKw-MY#R0k<J9}Hd&>Z(iz5zpv$+(k``?prd6anDu?}HtIp{lCg#Q@iEnj>?$*FUlm
z6{odSpBiv9Y-%;~<DJj{S+DmnQIf8&T~yo`b|sHyaP&QKJHFky@=0s?(3WR>pe3Kx
zFk>nRnv?eY8dCEzBy6q7KRglP%|l^TsQyz07yF37$a??5G1-|06n+~`e`QY}udY)p
zHlOi<xfQ@6<o4j?)L<{^8ir4OJ%kx@)namkJ1nO^y#6E2={gHt>cZ?>xs_@R04!~L
zkH}Q$HObDMCeCBIS6T+?PfGdr%0XW(L&Cn~b|Y)Q<!Xx>0JR|);^XeC3ZMtc-B76M
z7GH9o!_~%G>;#Zz69-beF4ZjGa~T)O8{XeM_?mhl0UQ3$oT7wEIS&7Og!nb({HtGG
z_k}+wq-Cybb_1clkk3HP%;l#`O2(nNFkA+4(A6wC$u&O{oFeS3PBXDJFyQ1r&YM=5
zn}luHeP53d-VxFBF{CA%8ouwJy25A{z%e&6QTrZ*sdv=vR>A)$)-SYXHU069@fY5z
za6`HR%k~&JmfHr@xjWFYUoLKQ-s2vISB)S1wtQg%Z}D%%{ZO(Xz7+c5Mdyp0msBd@
z0V0p1L#CB?uEN6|U@Lp(QA$_F;nV|iYIel}JOtt{Ap}60PqE31O>eNvyMl7IN%6Ec
zXT+GEfQ7x76f<C&_=P6*7Hx&_TFjKPj1|5<IMCvD86|KYc`TDCT@FCmlzF~9klb>4
zwgPTQxWt{2Ta$s(h(`N1dfVqMb5yA%8pIZ)F6iBlFe{mV0{x5rIZ<1`=lgbrlWweA
zr1eT_@EhbPYhO}O&A^tr^k8kcv$L~}%gf7cG&-TiJKUP|TtX+Ep)9tSwNXX_t4l!w
zJ92Vb;r&WtOl$k1>V7ayU2HzwBQ51;)kR1{qH@S>_g*(?X}_+c`Uf%qmze9GnfgIg
zyfMjti9eKwvcqhy_B0Z~@y)%Uf}gQBAW!7ru<sK_4mEl`D37M1KCoq888%i93JLzv
z&Rz-4H8G6awr75H(orIxODZw^QSw_nvVS+c`~QjyL&atYd^EqQMDIrth+lt`rt)T`
z3v7>BedfEGMgvOO-;)(tYD^QHS=?hKZCAi72!vn497@whK9jqO?T=d};Bb}&lz9PX
z)2Yehz>AN>+W4;Btq~odJNuYQXr&ou{=|0rzHn?Jd#6ZB#nm1@(Wqs?oBBgVoNXSK
zSQHQ9Mp>(;x^)h}efo0t_DSum(fhu?$cMb)=5fn%K!OG)U1>z`-rz~xbyVt3+OpK8
z)rWf(iaIXmd1IcgqTmsWW5wAH`AW(}9)+dl)QnHb3u|s4(yw$Dvg3Z0>t0?}WoiAT
zDXYT0-UZ(6?Q1?=yc{Euqrr|B->n``DUx^6ky(ouKIAz2VkD4FMWApj?9q*(B5aW+
zO&LNkG^AXTYN_}5HiHLqo-Z^lOVO^G--&t6D8A|q9Ls0~0S=|afiS-QtUhGKJO72I
z`wiV7PaLf;C`vC1On6Ssc8a=zDF-(6K4|B?9;~Ni6CCiv>a2Q%*JJ-Kg7{+e4@J!3
zl8?<8xJPN~6@zRnCmM8es&4Vic@UYF9=rQjW235`ZKX)OmQhjw9F@01iu)uP4GqnK
zL`udK{O++Ja;1G85`EXZgJTB$pwWVMsial-?7=jNZEU&?J|8-D>iCS-zK)vnm-rXB
zVeKXRdzl&A?6=pBg?2(A*z#1uwLjo{S$is$rw}VL^tE?p@!>G(k4t2O%F$U<&{n&z
zZP~#8s`j?7`S2$n*gl`-=;?5pucEynsaxuDQ?3_DwVb4BGn|kbz%w~*s)9fyiSybA
zs!l(BfL&6{8`JXA#E_O20^Qg2rDUAAo7BToW{+pyuO1$^`7a-xm+Km7bbR|5K>#w&
z*A@f`%_+5rPMkj~2KQU3hH%fpq=I(kpDojo_Nxu(dU6RqZK#n|*-YgnMCPV)B^&$*
z*Z*E*Klm2d1Qu{KcDz8b%;bg4hhws<JNm5^O7xi(%%Wh<7lY=NG!CwAomoMaLTO*6
zZs0SscJ}*naT7ibbC=tHgmoNn174Vy>dVhp4#A0+xRmK%GW{>L7rl#54sqY6f9>z&
z{7@!n7aC|?T{lx*9a((<5YQUtnI{QSKeeW1JU%dB56;Cq@cp&$Pm<RGnUB3|aOXzZ
zYSWi`l}<u_p1-n~7xhc;77K+4|L&XOV;z3ri(u%e+NnH2XLdSP*Q8%B4j5e#m&3Mp
zPTl7<(<%g`=l9k>ns!Idvo_~QXrKcK;!71YUrEG1**=A*(1^O8`MFhxh+*>6f@%JQ
zF{~Ajr_->X>nacipH-fUwwyg8^Ql(}x_tpkx+Q4MhwaxNG7uhjgHxX{CzF0!Ex;B*
zK@DQUKA6X|<EW6uKaInz5OaCXs|1GbXL<3S>Iw|?>_)3;8<ug82BF&Y+~O#ne+%=;
zltO&e-hMCBtTSc*+ez@ndJVWHdUfw7t1ead!}Yrf6vg~G?@%2-2-J!n7hM?^JVK;p
z=DkXrS!4Iu3E}r~;qg6{(^wla9M<(YZPI?Zu_M?p!CrBekW%RShybzJGZsffq#q>9
zVJVMTbl9LoPv*kbTUrYJU(H<WsJ$UwCq#a5`7J=Vq|{!ny|{R_%DK^fmIiPH9gqt%
zCZ7!{kF&fv4iGorxQM)*XTE|kHno_Vl$&`Udtz$-503wsT8-T#^S+<2bgkt;srMgq
zT4q79jCn+#-^C#NNSNWrRo2&YW$o0OY!VkVzW1m(cTGqXb7Lb6T^|>Vvk{IT0WGMK
z(>M&zhrK>T{+cH7s@vPU;st%eOsGxVTSDJ92%N%a{11$SMkN~IL}fgn|Gc7fGoUKM
zgJ!du^jY$32LZ6ao2R0+Vmbjzf<1c=K^o9^`J>{xk^Dor4?82Xy86Bq;JyI)ox_Bi
z@-+r_&GYlAA<IrYliez{EFFw>!<M7}r*R7Bnjm+k^T7;7|En&yHc>tGvRB)8Y>5rn
z(z=@MR#gl;wwk=9%Q5|AV({;i5!5BGiBqg<)a0CiZiLrM;GfC5mwyRsrOD?-lsAM}
zn(&j9GoR0<7s$WiR!PB@@lL3B^$weDKOSux%X27(l1_+wAyk8$*BR_9yx9!r<HrWj
zk2N5U5at^9LYy$sl%$N|ThBUyxERNV(#11Bwqz*B#=HBnf`8MuUR^oDYFKU+JuLg+
zv5*_XC|$PmjQW<(d1OY;$;#HI<cxh4561azxc_9;@0LoL{}!^GqBE=Vw#yu6+3dza
z_O;FDWGv?Lk(>(dN>B+RVn2U7$sbbEJgGI>-%<4&+5{tWD><IQ=~0jC{(1rSU{Gi<
z0q7P&b9t}U<@8a{;-CLqegKaT@_pf&BO=oFbVYXPZiT;0CrBZ##l@+(Nxn{_M`be|
zErlf{Z(YzduiWi4!aAFJJ#s1HSY1;XSDR#3zX8{q9WH;P2zry;H#Lv+(PJEzt4|I<
z8ypN;TlUt9>4z5nYN-+**4!{TJ;FX?Q!r!boBKK=VRQTX#>ezZ2aA^_-6Xd&=N{~A
z&hOhm*K30hhI5EwtTj~#*X~_=hJT)GCTO%h+3`Qt`5)w@_d#cDsTl{q>%OOov+H>Q
zt=1R$)UtmEsO=y+F;M^OT8-htbwz$BX0J*8Q6t9aE@^*V^=;$KW5*>HEu3pZ-iL}D
zc5VGsuQd)oKl+f(ip)jU1pyARo-Z^C4y97E<+{sd3q1&lHa)Ptz;7|F7)kMWU;X$E
zGzgfu;RgG6OdyWGcB)rS>t0QHP4K7t|1G4a7evQ-Bw~zpZZpeoCEj-_Z(^6$faaS|
zZ8cloA{dmj{bJWj_n<Wb$)J%URp@#|squzMjWQy;>2D9I!$5jqmnL{>)-&QIPGUhl
zC`4*b>bh}<6f?<rr34Lme}Gunag$-&kFUDwS!*vEohvA%J#f`!h7591L>r62Rr>==
zx1Z_VKeI|*C=<hF(o~_4@5$FJ8GXjKqb78XhSs%JZe-G__cisu)J(W|PJA!9qi|M{
z%FgrkrGEA{8%@nMDf+XjWl_ktlK0`t)RF#Czb?aCT3e4Xf}Q_1rC&E=qgS5n`q^y+
z>BkA0Fke|zT^P{qDbo5_F2$VV)-ZciJJ0L#v@VK1_<geDc;~W!##`gT>mfBjJ>Dd{
z295%y=umKx`OjKO*v=5Gpp$T~_joK}g&Z3v1Jt)u_V%U>O$dt4gRvDqyN7)k5t)w+
z)>#~BATxeAfC_s}rgi`xWHvOkK`Q8NY{d?7CtADKb-G9-!(bvEem5#}04LQP^xg6u
zqUS$DdJBAx9oYtV&3Ytimb?FA)};#+Ka3Is+_z?*Iy7tU*@&xE8%K?MFq+y}XQR5Z
zcfY_3j;aG_9MQkaCYI%kC1X!zoo6tCA~vgm9WMbpAm0vjw&K}U=A8WCaxTo?0#WXl
z=XXd45WbK`n;Dg2-S^0<=o)hpo$aJsTWO+V-56iy3Gp*c5!d>~@3J3yQ3qkVJIQ3`
zl5nHN)yNmUxP8LKVfa%aD6;)VV&Oo)DQIW6(0n`R+R!puYY}FCz-ZII3TbaWhwjOg
zcH`HhZ?U(1s{W8lT2l^O2ymZM_T?F-w6|%3aKEPDwNtYW;JGic_x+}s=1+oaK1isk
z`2>uFznK|@($1^agvd2<eXW4x5`C2Q|E}|V>Emg5hfagGo)B7wRs~_819u<^T7uH+
z#w2fS3nOLBdkgM}wE>47sVgQK07W|DgVU9xXIi9T6lui|Wzl5MIHB62PE$oUEvL+?
zH{df{pv9Oxr@10j<@plv<Mf$>N%BbcTM?(?@el`7hx+C^Z7*xa-Z*FE1Y_3A*yIeb
z?cn~+%-s?vsIlJEKKSbQ{kb`>Ml*tqcd4L&In3$ekKB`~AbL4)YSfX{_4WQvT{#r_
z3SXoeQ+N60J*2{pe}ZXl5cYjuk*kF$utSp_&4GGiTsJ&4=g>dbQ~{BaZW`REenFNQ
zp+*o{cR%2?qrZizz*=-&Y(3CV+w7AJOlxABOrPN@P3+y|(BeJp>h{SSsmD!tU#>+A
z(MLt(vM9C1b{UR8Zb|ZK$^pTM%La3{=cmyV;rw8)GCOohTws~h@$Kyy&biUeCg`eD
z_66^wd(yPnGDceV>&Cpf<p)=7XF)+QNQIzAm33v%l6QmMt<9jek{(*K#7OY4u0(wP
zTYUN*C1R!m)g`qhEMlRKDgKw4E%WC<G-T3GugO9y3&lA%&2uX1^i!F=gzmYX!)&K$
zgs+!oX0J*OgK?m?a>;l+#dR4z*n8g#J7FLcU{xw2LByJ_;3ipAs-1jxb4O2%&?M=J
z`X?fqK5eZv*7Xpa`3*O&|MtZEMgwPOJx7{^9C6Umg&Nk+Yuk<(w&T<~B$c8M_gNP9
zzp2~o*N&~xS-$-^f8KQeq2JFheQH*t`Wdd==S<S%F#7%HgFm_jtON@gVg*{}6KGz7
zT?{9Ksh$~^XdnMVkAGFjlbtz*YbR^ZQw}~U(#CA%Df>Vyy-Nf>z$mi5y3HDmJ(YT>
zZjv1go5|!z#imPD>e;0g4;z-V4Z0q*+>i56Om1qS*^YeLE5r>GpIM!G%JRG<sqmaT
z%M_0E?X`=(mH$CbQiF_<qh75hLtqVlOC=S<qy$d7^_&>aJ~BQkQ;gPrsiHslMH#1m
zyB%_EjvL19LPTyVyM^djZBS(%R$9pgS6;%q=B-1e+N0cakD<)vBUazOW|u+Eq73Vw
z7KnLF>}f}R71wNksh1HD_?o*fU~0p;<4uZ(WnO2!lXt1DOS)s9m6Q2;!E>fo6ayjo
zbqgYu$lvg}r@EW9fC{yD*vmZS!UdcBhn%2}wR_sLV1YvA#?Ir_ll+CJCCrcI$hn!=
z{~wO7GOW$62e-JpyGwByFx;iM%Wxg8!(rHPcehc7Gkmzam%(s%x3Qu7`hGvTc+w_0
zvF9{*GOO2p!Djv0Z=syz<>ygNpq4Sky%!3+S)v^TB!+r`+IF8+)09l;-pf_3r69VJ
z<<3R5R+tbs-h43oP<Qd3Y{Uk0B2rAd{Hf3$W#NALYU12#^|>h&jeWONXAG)mdJhx+
z$?PrbU&gV9aO;62Yqjl>-uM^M-@<aco5`EDr6&JQ^FbRUr`Ccff@ZeTqWOh_BALwp
zq`xA@z+`9oSO%^=f3cd?2h9o*LG^RjSZb?uD(QVxU6eBF9)ch*QKtEu2m-on-lvte
zBXboF)0VwLbykML)Kz?l^R5ZXd*jR>3^8T~c6&2nGu!txUd|(;?uQ(Aw9uEj2pTCL
zr&jY3x)g6+8ohNfjdEZH-vnkJF3f6YmQjyY_QN#xr>h^`5SOui{lVKg`g>`~lC?gr
zH86~gFHqKdj#Dn$%#w1}D8MC`*g7DyMG=zCQFLf6Py;68pcA4V$1KsTpGA5prJrPN
zP|sj_t+g<q(3l8wQ?nl_4+_tY_&5J~;*=`Xe(rjGVoiNsWX1IK)e9GrP&@qVy)Ni-
z*RtAF55j!YGbrxl9rB+(q{wwUW^TdG!BuortstFBT?kn4_6{#o$DRzmYn>Etth76N
zn-O!E@|4GDyd(yye9#{JN9@`A+WAlrd%NHzf03Gn&6)mJVr;o53=4oQr(w3=%DQzX
zbmK+(teO(U(l3G}z(+g5Exkc9C#3N0m~G>7yNTDwv;{Pseq0XDxV=AQQK>J+{ByEA
z6OKk!301trl4)1pVSXv;3Ps)}X@~)-hWA<ruJnLZzakCkezM{?*uu5rMX%5r@Qswy
zf4ax+YFVhq30T-%wrR}(eu%Asxt#%5`0BXt7aa;|1O|FitA|>;#Xq%~02?zy+)Zkn
zO99bw#_BU0Y}>F<`x@|_ALRB|YiQaMtu6>VMn52^{!h0Gx#p#!fJPVyal^h0+$6+X
z^hoYQ-<r*HC-&=Z0XA@=>Zj_xBhGDM`5DbOu-`}5kM*(*Te69f!1{v>Bn;QYT%?g9
z9=7}`7i}B6Dt>2r?+}+d<t&BA@}hn3nbq-G!#SF5hZ>ec53ifnY77p#hiVv$)kNQx
zb6=HHf`p-_QkaFbYKnQd7}kJ6X!D;BFy#1s#z<$!7sHqZ_#P;NU6W-%z_WjHGBT)w
zecBin_I6Z0WG-$8XfxM-ZxFRF2g?DuMglsS)z|bP>&g@A2D{Bj^}f12S{vXMnTG8V
zQJ%?^mcEYnJ4FxTv<(}UzK_h}tHCSswrZbe^nMF}EF;;}Fpcn(WeEBdqxYs1bNsBN
z&Qp?5HKbLRktn&HhtoS50}^jAxAoG2G<4lQu1$Ph>(WxFm{Q3Yc~Jna4U2Q$Rq2Q-
zvCI4gOZn7P#kuHF?J=;`rP%A6>RF{B?J=6wb({ame}$v4=fE^HmC-v9GL&CpYOi)l
z{RWXx|2M_dSlXPfa2vPQLAm&}(CjsGBJG*vA06!P1iJs}r(7?CU}rAUx#ik&QS_GY
zOm@y-5`e+6y9~Jt4>^8MpiMycTu?}vS`E6<RS)420`u!31UVX8-Sf@KE9iDq_fP(7
z+8;HmT>F$(1^wci>E;w0nBVMd(5wyFF>=C!B9kp`e*qy9@_!Jcw-#g!D6ZmQ9}XkG
zv$luMcWaKE4)RpC4PhKky({iI%EX)xIc+ITEdI=Y_WKu^ZcKfz`de}&Rj8DE163)l
zow|Z9*|>7iporPs+hQYY4x_)}9d^iQ;7a|^KkHutg=`(yS`CbRm|6?=vjk&|R5y$@
zo9JPAMnft*j66Sb!;etwmDrwWJ)5~f%C0F>Gtnfd1_KQ?8!cZB>9MyWcvI$`uFL0z
zPmYG)?Lhv&UKWxOMwJ>)zTJnl*tDIRWe&D3IluXuLve}cqzAo{N<k*&HaLR3;V#4K
z)G|4SS)YP%UmJhDweqwEp2{1iTZ>%WXC2Jj3@#ljj=>Z1r~4s`W<43`jkeCS|KL$4
zI%H^E7Me<qICOHh<FP~PR_ah@wv}Mf2$DEnrD>0U)ea5nCHE@kCtb}S+OKj~#Af5t
zT^gkP+1Qn@q+l$Gj;SBttvamKbliB+y=SPGj<#lQB{#{xHgoveh#xwk{TJ%JRA<ML
zY3N<ZeET5a$mWc>;8m0ei&t|0>Eqx#-hMKg09%gxYPL2C-Q)uDxWHukTA%3Q6fdMi
zM$+fNN$01?lTy()`|02-E^se%01LN8zCbuE_|e_KV57aVI&<|Llanh8>VAOH6QhQ1
z&0lRqE1vFy-{@$ub>_>qkw#mQbs>vc9#x2fhcOEL^EE?IillTGX>DF*J6^j)))+^s
z4Gvci{o^b4SE;QA$5NuV`L!N1cPbIlS~Afr9s4;i*TM#nzwU?D=#k5hmk}nEchxX-
zR(r%fnQ6^`UMtm)IhSHBsJIwpSymAKotOSnIH$?)e1N{g!Ie4+7c2hyDXaa}^ys87
z_H|RR>0UuwEsg2RqV0T^PUU)D9ElPY?}-!L`!D0z>)aDh_)crM%j3L67Z|CoT^g63
zdbO6mxY+M~gnbxXp}{>3Am{bT9t&M^ZV{CU`C=nCt8%9)p?QP6h8yb0{X`zGokq?n
z+nFCP<)7`a6sc_y+|5@0OkN4oSEkJx&+>L{<=s>kkkuN$XVfK&+ai)M<#lZOwIx=|
z;OWu0)v<vu(Y)|)qA03Xz^*{d#vJ5zS-#ZQy<(6d;NFD>6SnF<VF{I&tiC4DuKKZv
z;)`FEu!h#YHmKrIIIik%T4Ov9U%wUqdFAjI_WT`d>jr3BoHu|~GzH|tNzR8&LhD18
z#GC~7$8l@WLeM8aDQywOw+cHE`@TRCbc%@7>4Hnj@iXmvkiP-7f2HlLj5L){gxn)Z
zAoT#Epl$5g!WPFDjB2LQ*w%q<hP>uSic+T3FaGr4TPDt@aVRx^Z}0xh?;3?axkbT{
ze<=lYlX^W0dC1$~2++ouqd^sT7_Lcfh|a2EvUB8m^pB1`$Wc&B-)U+0{CmTiQV91|
zyOoZD2g81-%#WXK6r>U8E>nb@)E_6cMx#;2X;A}DsV=Q&Fy6Ch59D_I5iYx$Nq8EA
zQa3YCGqH7avcF!C{zl~0%q4P8S$4v9T_fPd&)+qWdSNzkrutl51HM?dbkZ+tE{H_L
zA1X`Shj}EjVYWM-a>w?F@d{2B1j`RqK=kKmL`P5+s$R3Mg5nDwr=s;q{YI&E@4rtW
z<jRfZE7%23zg}+Xzjlk3$Nh4MGP}=^_t3S$?b>}`3EFU?W~qkmD>$``QJBW*9Z7v`
z<_W-<@ZcNM;TDook-$px?@w64OWADXv}1D1mHO~7->QaeoC(F$H%xwua8=@zJ&&U9
zb=CiUoOSj2B^1+R^<*es?D?V7`{DKW)n`lGYAT9_^2<^c|Fc#Fv}-$l0r~vC=;vpn
z67a^DdZzXHCvIRB0ZH0n<Pyp@Nh@ll&k#(5M4ZZ%w#dFtE^yyS*F9xEeIuW7oB6?R
zvY->(zlx#h@6i}<D7Y)d+W>c!m-xUDPx6M^cnksmvgyyMgt|RTR?%lYtAl$?hU{Cl
zKInq~xS?Z&^H7cxkAV<JuaA*OQ@MWdd`Qi?Q7R;k#{9jGpvL!u9rEaIG^LR~0U^_V
z!CB!k>^8P-a^X_h`)zJRV={ZYmV5Mps@276epcUTj7^mqr%K1zUr;L}w*G4ui0~7_
zaH7-3DKDlOD>sC`UG)<(Tm_D176gf4J)47e`tAkdIv45xah*_U__78iV6$ac^92VH
z-PRzku+L?5j(!s=?tpG-`cWHF8VwEm$NXvZ=_D;xd23+RC$)7UM+4HA{KRHkh8d=5
zIBz;3|KF#I+QsI68#T#mEuqQ`Iok1S7S{%5+2V5KA%zDpS{Yd^()Q231IWy)XOsuo
zRO#5?O8KyB-m|3Opl5xa$zHCgcm8E{!@I3ewHtoahBg`jLX7lcXoETI>2{8)*Prmn
z|Gs44n<Z|?#1CUn+<Qc=u;<huut|;JIt`zPr5BC3ESvCijGNqi5PF|Rg#E#~ErG6m
z6-%{_Jws{J7jkpP-DWxddKBT?zrh9c2sc{%LeBB7Ar!z>!+F;dl71V&DeAFaEzh^@
zk-&z>jYT>-*7Imwd}9V&-ZAD~E=<wS4|HRP<WOH33yd&TmGffMkkEz?i&pO47vgJo
zf06AtyuST)f5;wfiomyb;HqIEO!l^R&cDCG{5NcVVz?w7d|RsLr_A}HzC9F?xWCVb
z1jHqh6(f`<T+imB!(cUy4}RxG#3pSSCqOrqQ#;r&3POR<@~aOc$sR+krAH`H^wp60
zS+fOSbqYQEY!+X13%u3pUp<t}VYgd#M3Blwz)xH)c5Ext|2!m?;}eCmd?$^t1w)k^
z^ja_{#3^x<-BlFPGQe`<@BH~Y*3r!QAou+htH5}QwKQs4BB`{n9Q;3Q_@}y8-Feke
z-Ohqpx{Fw}Lo9nkvbjrl?2r9y=6IgGCEJloLUGOSWSls<LJbY7n{%XP=l9ez&6_3;
z*~$E8y2il7Q)ovhq?LO@)0}5R|H{|uFW%1oUU~xL?dBIC+O;6^YOVT%BD0cTNXa;t
zikGRJ7VyWkXo++45SAYn6lziBfoP-)CwA<YOb%Penw0L%p?UmC7lu~Tit$M}fH0ft
zAt>)6?hjR6`^mp1g?h1f1~fa3>17WeQk^rfD(GUf8l%JhP$LSe3^#Pk3A(CM6YUL&
zsv-Q^^fgf^Z1~rDR_{+v9(xZ+bmkKAD<*y3@_y=uB&g#6L|zKVWz-fIYwgL6+77<W
zJL>Y1sE}{!hMT6-)*GMVf7*rXP&6Uq8Znt;`2h@}<$l;oaE4nB|Lt`HTgRNDl#|PI
znj0qOD@SC6h#*%I#D5M?i6RPHkIXT^LqYl<i4wOL0}bLKJb+Nhy6J8r;=WTSOloI?
zjii7sOggR9g8F!()hR*a8+_w)^?%RfN+Qm~-2p@J*gf+hJWV44KpYu<pjq0OfVZ^^
z4QT>~%8&`?NYw{eDFVob*TLc7rUtO|3yc_&?aE+-QU2}!bw+hMIS6Ay1by$+U;lfh
z=>{J{3Lun4pBfc7j64?7Xv4NPm=dJ3WxL*i6_^Mm7y-r!X-P+`JJO~Xmcrd)eJU2`
z5=qW*0CT|i&T_;<nM{CL%5?Kr7wR!Lk`GDFGWbgd%G-d%HZl=vE>rVQVe_FNM02YD
z^G(~3&0dR3;4RCUA`@`>5Q@L)Ivhc=nf&|Q0-k9)`q8(i#emL(SOZW+5aI`8Di&}@
zYoN%LH9hHc-E%Ru`gdu3+(WgjL*&zQi1~2fZ7|iSU3G&qV4swh8k?9`G7{73UnlHu
zz%jG6{11HF@T{u*oF;3YKkr?#ufFj7VTf5TPh)x9yhHWPtXM;4h}r#GXhilGiN(&G
z^O`3Vb(=48L>4dwh<m-7J}Kgc4}ADc)0?!UPRBGPzp?xLyH6cS_T#6lhLFxQ1ujgP
z4e?|PzE-+dcQieeM1U|%PW+J3H2Q3ckdwjXf4H4=(%cW92Lc&HKJD~kFHfi$Fv8QF
z_AhH))smdUW1`wmYH@;btKs<JbkUdqRh#hK*s1Em;^z^4fef<jc>h{_#0*IE{mDt!
zyQl&}VEjI8H>Nv9)WB<^-8WjC{}XM+1l%)(z_d%WERC43UQX_$)H*kFe#bm8)oG(_
zR_2VX^_v4i)-2y6qS=PMuPCl9KF_uejbcIcziG%rJ{+7xv;2zIcOPRAh)0i|h!MzH
zn#24gymrbZaMwhQw&+6_m+`dc?NjDL&C=Jh6=qK0`n|Y1t6wK12~`C!(q)iIf&fq<
zz05+NA1uIl5pp}E?UL&9q#j;(W;d!+Tx>hU{<2r)4LfK&Q8fXkKRJz76Ai=Wbdnix
zcc`gyqIU_nfIG>+nHvjc_`|&+s~$!}H!gj4zN@lR<({_Plvm}S7w|Se^i$=^Ktdg*
z3mh|Vp{BCpR7SeMCPTMhs8C8kwx~;0*!P6;P>%JbyPm(1nJv0OFP%cW)eGRSQ-c}r
zZnt3ut<z7L7U5MnS9ZVNX70g&e(^8NoW)$A^|-55dO;LWuErpKsK^cpW3(NRMqvRs
zpo*G4*r@KlIJX~8{}Da^9^y@M7v_h&1-MILg{XM|sn_rTA!^2?Yxui$a^d{$1BGo(
z1OQ4!lT!tH^aY!JnY6G_6zjFB;bm{YTsVLJZ1^wg5PN(GF0NZ9v=4k_k)TKjNXL(8
z_{i016!C!4-&IG+sW%WJG;~Cc5jr;d!JH3UWn}z?>ADEOZNFZF0hbS9FtA<NE)_=v
z2)hYr5u?=rS6&wvk??>R5pHR85yT|Zpfl9H!Ow7g=`pRG?}e0Ezvq2Hnb88=<FFHF
z&dT?<5h(|L?>8^=CwTPjGw*U1o56IoK>=j51W>gzVrh@s&01mFu>y=5oC8iig*N=_
znXKnXlMs3cK=Pzd*!Znc2_T8<^r^7qDN>>R1PHNwXd>niQdY3rviOgTpn>$6Yorwz
zA}?fE@Rd;Du1}|?dph}S@B+I}XI$661%_J7Gxp%hhX6DX^ugvBYk{J~)kGxVY|ndF
zk`H@*R3S>KSFxyeC(HYu0Xyu7AvDSeGH^1>2YUrH)Y#cd8Z7>ewoYGaaRK;ca|HOD
zAt|gsr6OTk5A*$N4#&r`zn8H7jW~oe-9O#`V=sCiLySkAmXPvjxdGC9OK~zqfMoo;
z)13c5xWkW_tzfWJ{NG~)sByGn0#@_O^3&NB$JO4XXgUDNglxjZI{=N6IQ6XI#eg4>
z8zCt}I|t5-1JT?+;$Zs)rO`_igd`#Rh5-1v?W}OqfUwVcxQDm~RREBLnY5##HRvLm
zJLrH4Q7R!;ntpURrP7Fi=I`yGFSDr0-_nzg{*y=!N5817Ml+f?#C}JobH@@vK7J4=
z_$gx08KAh+;QJ-qU$XEtP&7RW=@6#|>phqbAr;8Y2-n+@ik0uV=f(obimH!yCI^@+
z&?yN{QLmu^618)Z+QQlhvco%tDJmyzSSMTn+=N{+@22#GR4Bv4#Wk@X@c}pks&&bn
z(!N0Vs=FJk=R!cSyl=A;zl3)vHe!f9&flnJtX{{G!-qMcD3hPKSZ%=K!N@FOqY^<3
zn(30jE*S~r5VA8_Z>qZ#w|NH(9(Zm<yc0i`hyLI5jGiAUdMO-RY%s6h0j#4RLrs1E
z!lCv3rFe*09UFz0$6?I9`>VUulDvb^#}J)plf;B)k7y{&Fmt*rB^gre0I0x;-FVwE
z#|MlsONvu*=gSA75s#<2jlhNMAiSgg!)PV0r5-tWlVn%fE*|C!EDmL?P7iR)gllxu
zj13eu=N>(!xWI?8WG?)Y_(_yCHtK9pM37+o<MXJ(hba;)1Rx2eNH_n0A==o0E6J$$
zDIGO-6exsKxz|2t6w%5FkqZrQxXXXt_0A7VLuTys&KLgv5H19cDDHrm${`0XcezEx
zzcA_OYb<|p?C5FYsn7LrJhv$ze%O8=8IvqhJ*3CU;4AwkqDLrzq~PH4l=SNiQZb4T
zmER}z)$MIk4Y~Y*whCv<Q6Xz!pN><n;S7uQ2{*rYn1FjF9KZ|jTxs4Wyjudc;_vPz
z_x!kk5K9=S^cU*1ay@LN=mFQKnCqC=k*X*O?C<cicH#YW%!k~U&Hgax{p<J~qk{JK
zhHQiRFC`TglO$#j=bEcnduoFFd!#;oB4-MhWJrg*kuDEf$_KQ*?B(`~(Y{e+ytz_U
z@j@2=h(J+EG%6!1pZDxLms$jSh<z+@)dh8-?2G6UOD_2ED28Z#(FpG1#uhQ?48^iA
z&kbfr^I<K9pT)5;Z8O2*x^0nH5e6Lgxk_EA$<q&=I$AIIE8vu-umip}aAt0p6kB2x
zhp+KaV~hAnhMCVhzDFu0;qq35Im-r=&xdY-3b(pGCUbN(3`YtCh?h0!38|Z3Ce<kM
ziyIY-=p@kX1OPML8@J9GLEZcGeeB0t0F~lyyTk>MDk4Ag$Ims>?v_95fh6!$l4dWY
z|48<hv2Y{_xK2Il4@Dk>jQ}BUKh9(|IiFly21q&x0QAwq{$kDqvU5QFtO6~ltPA%;
zKL8_sPk*rwE0Es_4q-dEJW&vd78z#*eMA=F3be8!nFVJKpu|&q_)MtT6}$84u%n~6
zn@J1`1c2PJ#?+A;3E~r{`A$2&3H_<$ftPfJyZo+Cq{!*TnrH~1nJQNv7|%qsPB!xG
za7mhoS`WhXVFkc@7z9dZhNZaIY;Mw)pe0ws%ZIkHX!(QayzCK7&;Y6tD5su-p%_|d
zTwsge?dG?ra`W^6q`~)i>wPw?4|nG5>n!b*LqYm9>dH23Lt<eisLhIsmoZY8qyUB!
zjxa3~bked2$uDPy{rPYJvR#UVA3m%4g2<AXyTQ;8X&&ouRQdp;-HFEb(*i0w7Lp)K
z08Nw-+(oZV7=~8FMmNi_c-JxR3@U&G?h;ds$bG8^pC15Hyt^T&6(fK2HP@i%5wmd=
zgKC~ag@!Un0n#jZQk58|h3KdZruC%+&(|n~_t8K}5ew(Tii-FIY<d!s{XJl~p~qEM
zy?Z-ip1})ZSrJeY@e>^iuOe{$TWJknew-&9;C@g<?3at9Z<8WITqvy+EDR9msF9u3
zy>#u%31xp7`V3$x)<GDj;#v0lZT|Id@a!ywn;IZQ-d8Os?PD5F#zcPz0xZ}Z(k&?I
z%S6ll!pB-bqyqp*$QS8YK6OhYeUb@x)xLr4A*D%L__5IR6=Vn(BD@Z~y%G4a05A4Y
zmARItIbx6?#Rd=`lL=5CE1rq=*POVz6JiEPQs)sJd?F;wgfB+=Aj{}5I~qPna4Z=h
zY>#*;o!{*1mJP>ER8q*U!5E}!8{N7o+?B73fsF|`#VuMTVh&K|_eNSp)mO3D*pOKs
zDEI<bF3AB8Nz<bd7lar72m}OtbmFe6sk+Ml{^+ec%R>p%{Ty8H&lbn1;rh<M+;BmP
zT!%E4xQHsD4oE7@wS6%-xmbNd9|@#RX3%SS*NXLpcJl#%122(Fm>2I00mQ~sU)>(v
z8$(Xeu(XTAN*0tR71cSU7l0%r>UW{tiYc-o!P>qTmbF#5M+g8G`G^sp<*sOKdXN?T
zZy4!!k<;c7R*LdsE~_#alQIkLP`Ey~>%_}kKFr6W>v>=msqx_1<-bVSp%KtgKqx1p
z-NmX|gW#r!*T^b+5n+^qdob~q!{)pIkwZ(`hZTLc$-TUYMBymDDT?thG98?UxWNPW
zOdjzBNy@J-r#sw;-6Vnq&2WBD%XuD@kdsDImh7}B2*_2GPpnzt%BBB35CC?o>3PjG
z?m1~l?m|dU7QmtO#Kw$bJ&s*E>?lY`W#*tCq5^QU{g`yB5U2f^VK|F3-$`03#Zk*9
z0T{u(M$cRPLkHUBz}3Ni+KZhi`C8;|PLADSzM%Nu$uAeT3<9!gv0QDqvo*Z*SOop@
zElPdbw(|iYg>G%>sn{2(uDh%*BOyv-yX^c+^HAw^`j3buUQo34FDTO2ih&(~Y?{21
zyn~oj8mnH%MhxQayd8`;Vqi9&B|hZTItqCae;&V2B|>EMTa#nvny-+G6h558Nf}`T
zTiDJpKm}g&+IAb8*vN*;cI<c~-bIWE2w=AVzGAeI_~CM*SXqi0+5s8zcrWuGp<;QO
z-gY#~qp!@F6;jBfo5YG6Ox9$nD3npw*hyt>>|P82H&qT=l{Y@337Rn7S*DiGXSeJy
zqvP_l%#>P75(gFdV!S$edCe&0pTV_sWOe5{g*?WGfb7J3<;wa%+E1)thY&qQ1#Q{i
z(pXWfLP!@dNv)p*{-cXe5%tWcJ$uWQPF`=;w=&rt2+f5Da^p6)ZYrAPt9j5ACjt}8
ze_F)qV#a1Cs~OpRQhAd>4tXDcn1k=Tr(~IX{qgkUkOcK$5T>MdnHkvbETOp!31&4w
z%a*_Ql&aAGC?9wjVdk)sPK*lx+%p*@9Ovv^U+>`RlDzZPxT~0%&@^cQWJg>p+pE9I
zDq+r{oHWkwx9TT2L1MW9$rd45|44Xq$XOR)QH9hDzhh4r*}mUo)T)R&AQ=MqNsm{I
zbfb(2wEzp~;^0V*44-<fu`x-K0G2I{h3yvuBoP1ru^sz}y`mcVWC&iNt#YxU+JDK=
zJ@P?$Je3TlNe39ZrIw%q9;O?fcmEkKe*_|?q=Ih&Jz87CJMg)iFaNuke6=wxKqBoR
zcGPd>5@etd?6RUI5Qn0?Z`%vX8|?@z7QrRF=|5PubfTAMF2<keDsJQj6i0Pa(G@hG
zVt+*jvfz$wD_CtDyJgRi4K66LNzwuU9a8e?sd(03`{S-sZ%8~1g-g~D023rFQ}#>Y
z04!~q9O-NN7v&}!w39L$Yh!fI1wb<`4Fi}~*=B=PS_B=`zX8w)lg!b+rvZFm!hboY
zarF;Y*^xcKF*Kfpy|tL5S$mN11t`Ys@1O=*27Qp>Per6r&s7ul#>!`-EI*dw_K`<t
z{3Vqs=-e}al#rb31;-3R?z15aA^IWSt}-K=InwldhU282sr_z=d<_LKmh1q)E7D$p
zF}LuZ&w-_#2r9iWmRAVWN>kg1eeFj=cuAQb-_qA3ZDrJRFy%@Cs9q7Q+ge~RL~~;;
zOi5c}#sC}~UK9-2)c8a)aNU)&D%c?$&9+48y?r%_Y&pDJ{yVAv?p^P5Bqp)z&(ePG
zy_~~+3j{bVDA}77y5ULa@0SPPYj|*|fY?cOc*s>jo9FkIWB?5{S<XOx%UQm*^lFK)
zQhpwGrpinp2?5<n88U~Ac7k7u%jvhgWI<^`b8d>Ac>YRB*>agII5(Umr|vcG6o}Ot
zw<y72B_oz9GbdnBinX8_BiCUn;k{5UN_q!U?)SZMt}WisIf!C3TrpnW_xrDG*}rk|
z)V911Pr8w4z8Jx>$H!H1dTX|9Qm0cHhHN$5C_74n1+yN;A!Onsc7P6UL-r*^{PB3^
z;-`e|(lQf8WTQ2bBo{x-5YA;`{B6tc&no`3_%H{-m#NuWRN>O*#O{c(dpZOP!MPVm
z8GSto`GLh86bTFwhxxr;NIBU8v%!=~dHdLC9s&91O_RBccHvl{ki4QO6JNd|hO6w$
z>r68oVYZ0Yq2_=2(7DPYdAOL+QeA>CCNi+=q%Yj(s5LllS(KI`_YVmmc~q4Xqj}ch
zaFKC=i4%Ne6pA*LH^<AP<H3r?SG&z!K%*Rd_&s}TijLZq&i5MML)yKSzm*U$M@wg>
zlkrEXgaTSc6c-%gB-<*>4G>N?RiOWBVUmJ+#`XO<kEm2}%D=EFHn0nIn_*3OE8ZGq
z8i6X44<KSZGDf|Czz61NQPl{H@t}g4f8>A(NxGU*s8_bpeLY(-D_x0Kot&jwa*~}m
z6`a0Lv{hyf6%SB@!BYHHSw@K3t`awF7UcvZ1T9{fxmNPjK}hABw9p+L5A)b4A9<Et
z`izbGFNDn|LW?dye)bMXEJu^lROY@Aca=0`GdoAk|2To<{2K9t?DZuEJ{X;bde*=<
zr|$PTu^SZ^X<Ej-T@mc&4MqPXJ|7Y}CMGk)2MAJJP!eP^raMc)TJVKK3s{QYHbGz0
z-`~rL9b*}OD~U$g8)ik%7K!`;w%cQWCx1a&S_p&<B2#l1L2ksA`hhn;wmg;>hw?jb
zF83Vq_6EZ`^u0(Q-lY}*!#!hW#LyvrnNMCEelCU|w%%2rlKEDyI=kTlP=J%Dg>ZE#
zDPCytgKfleA6I8E?`C%lb&AZ&7{ceC$z(K}e%8YCL>lrCO;)r}gGCTQ$L@DHeKtK5
zgWG6?@aW6bzY$uY`H3VRJNx|zjJaL*mZ_9Yx6H6{I{p(Ks1ln2Y#-G;!Mi_YH`^?=
zfJfg$oB?73_&<z$$%s=#;l_|Ax6D;0)~lBH%w&LONe8I?RRINVkyDOmJCGUJVNVev
zlD#c006>ndE<{Wh$>u_82ixtizZ=taSWZC#V5Z#EE^HAZ6jqFp=XxS%zsG`+L>%q$
zp!a;<Wl&y@VyXQ?-Kg>p2|<$3_9XU1M0t7~bU^Z{94Lt&!Bn8Et$t%0#E?za&y-U=
zy(~XBe7Fc9w)y}}1ZuA0Pz|FSqS?k6ZjL55#F#;+a<PB0djcy46YYqW9O_Gyr$dO3
z^8a4cGn1P#+d9$rS<ryV@oT1TNr1&D3)WvO4qHbmnxSbYv&h-Rb?^9Kam5S4!~rnQ
zZkYXb@0#1xS9#o0CS4$EQj4M?<k7+irQ8r$cfnJ;f<`yd=Y>;g@5!D6X9A`=*UW2>
z_Fy%X7J6O_NfOOwEJs9D5o`F_Y#cVmO^Dei<$F=ot|y+}L7<?b(~s3cTME8Wkr)~Z
zWpP&eF7M9AEuj+Em+x;`X@6&7G{gfy#zBSfc@v|Vkg1Ch3>zd{FHsa4$2OEIH0m4l
z$899;=XT{@aiC76_6ccP<oDNdb4>f3-T@E8CLP~uj=Jr0ZM14}5m?4n;E025Vhz|M
z`y3|W8VRN_l6VFMEEn{o${~-r#2y%uh@!qeiKq}nC-l{P8XU;Q_TCq4J`P{&cS~*o
z(&<-lcXR@mD)XXoYv!iMDerD%&A8!xuj^b_nbomrBf}_gAkL_ke-A!}b{*HTGZi)?
zNmAV<5=`G+w)S^DX8V_NWsCO1VGW20xRK-2hp{-vCG;s6v1`=!(o0S0S*-#3+_Jxg
zO-)8Phlje(NTvao`zawB76Ax!!$bl8Am3}=7UW0YGB=#4)f`3yv21)KFdDpS;e8(8
zoHd};P2mLY`4<IUDe0oGy*VF)k{8T)(+y}#J4750=~I!Xkl-1=gfgi=O_P4)1+dPb
zB|<@>Ka^ua2*wlHr`Vv}h63?B$<=&yNuI3S)EMamNV%dXf_BB@07dDd29$s|v>(P%
zo#_BaWAo1bv$L8}0XR22!!J3<{YX4r=Hev2qkMDwO1<ylRgoldr2Hr&JC#e8M{VJg
z%=CSO`33F>zT<?gVq?%`WB;FRm-rY+J_bK&2!hY>GMeCXc=WL?!7^0_pg%xNQkn|W
zO?VFfmjb0JH-08k>+kGFG&D@70KS7q0RG60=2|n-C8wNvDo+eX7yTR%)sKPu=6eAN
ztu#}gN;HOOXwCrP3~D#{?Zd<8+F+Wp0AKDekAORRT!=V<KBhqWbH$J4_y^1IPJG~!
zkkJX|2#!kZw6Lvn%rE*;V+uSMDyx4xq|6&0S56!L0zzk+TLpV9rm{Dyd{)wZ7^tLo
z4Wf=aj8^OnS&75Bk0dYRk{OA!cnWN<p}nLk(KZ1}xmB^aXCc?C*_7OUkGQe}&;^G#
zSL9&MV7o3Ty^A1ifueo>6);vZT_D1&UXP^G-7O{g7e4IX5BpFO5q6iy1WznwcSP*`
zUczc`*yV<oJpOf_=uP>jpoVD9#qH@+Ima*kti6k`e*P<0|DJB1y<h&;Z;`4g0p+Bh
z^wD^Iajva!c|JSgW5CR1FWeLYG9WR4M+yPqY5E7u8^ODCx{RhmW&~pxUQdo5UeZw(
zTopfiwX=xzp7B%r99dmprM<g9@5EZTxtrY*lQAMIMka<t$2)<KWik`t8o|#^Beua#
zI002~5!Ycc$tbZ+YGl!#0*PgcvL{WSz3`+Y{=FpGmDyD0MMJA+?%apvS-pyCO3Xf=
z2vPUGpc$f7z=9PPa-$c4sCC8z)AfxZHSrkhJMPy1GT&3vF+KPTJEeGLK^$~TIJUUx
z^IJkQd&^TatS>W)%d7W<77SsRb08>2khT9nqpUzX5@Y%~6Gv_@Y)<=~FNp#-@I3gx
z9>$XTW2tq8bTmUU?F|nmxGTT<M_=)-A<tKF*nhRWc#$LAw#Do*vmhi*p*#(FLQ=^~
zLYyoMUr{LP0e4CWn>K9}Bk`S+{fwJo4Oaot|M5|HuFH+<`>nft@9@yeEyk|F&O|HF
z=j9%wU<ybH_xDwJyRTPN2%RX&d4M4Lgi3oBE}B)&oF??qH~tfwSM#3bu|K+i)z-uR
zHN>%~?mBcy?LRX*_}V9BLTj~wMtSi!k>?3BpwIYwg(=lXe7aiuk9s;u`qKj=$iX_?
zFR_xG1l)yvSERj@@5zNcCM|pa#1J36+={3k<xejAT|ElfIceD0PrV(#r-YpW^2`g6
zP~b<KkCl`Fl1&xOy$)uwoYk)7UqTC7Vzg|v#($@0xt;BPB;NRTd=ImmpyML``f%LN
zD`NHOcJd`dvWJ9khk@93tTbVK^8MfKaikbAW5uq4`_?7xl-cM+yih`55OzGX-Zto9
z2I?!BNB<DuihF-I+pAq;Lh={Q7_x3Cye}6F>C>GkfK)dqP>0~BI3$T_DTEP@xF`z1
zu6iTvxA$lqWO4FJF)Fmog=npQq3O*1PEO?1|5B|Zq<m7q>q>HV1?p~ZC%*-`R=Z`O
z*|Bnd3jt8+S^7|vWnw8I@IWFl#qa6E`t^|_@knMmeERjrPeMMVAO<W6R;S-h@`bT#
zurby-UUpH<+*FKwQvK<NX&W{99VcL$HquA3CKMf0jrjaf0U_LMsPzK!3vuM_EA00I
zXL7kCAnMb@$dvEQvbn%$H~KZW2cmDrY<~VF_0hL~+1%YL_zJEo^$I5*2?d81sfC!0
ze}x2#dgX6y2={4J(@hN_dH!;2m%VC!r?J7?H9RY_r==AthIM7>67G@34|tEPhR-aT
zQvZsH2gs{Xw+U&xWG?h5MuN3@se4PPMM<dbj>Yx0;o*g7=CrE%6up^Ie$k&)q%T_1
zeL%Luz1qxpN7LEcf#qI-BF|vi_B-rumu_p0|FMVN#uYivf9<;+Saxn!LV`Zave%X?
z@8eAM!os;9m%2Jz_XZa-dZj4~+V%l$*S&OA|9bTH=^1MN^dOJ}f);PBKhUDV*VA%+
z-oN6T`P2O-EH|m-T`2QbYzxW-?q<AIKng$2fC4aHeu@em@BZcG#o{^R?`|rg2jwhD
zCwpb_X#ao(#{-uf=-6x@B&UO@W5%E#6SuDK^QW`C{HUfQW6F(ou?ntADN-lAeW#Sd
z+RRu;85!QFst@-5-&7cCP9HJl&sW;SYXHXnYU3r{Nv`BBcIn}9KpOt;Ob%0?VeEbe
zh|2KdQA2X@ocyw1B`t#KC0<t!$8}T$&on47z%i`=0jXvjE1On2n3WI(I~Fep=mHn%
z%KXns0iMW-J#VldZOj8w2%Gw2YKODI(qi<7dyh+&_FdoV@X5t@i9)m0?fN+kN!iNF
zm=ah5=?<jey;w;QJJUxD^dMO^$La@F75nVn<fn6bhGg{pvhp9WU<>^Yr0?5FZnRGb
zYP~YC-ciR)OR(l96}eqw%QIc?9GxYISbydI>Q1D`Oj@R*rpg#Ib@Kqah)+u*R%dK$
zc<-$ur{pf(gTT(Gj{KwJj~H)}98Wqr?_mgOgT)^O#$>OIOWE0im)ObD)TaC3;=VRU
ztJwbzSo_RkTQ@>JOSe*#;D_Ry=OkY+S9Jj-3;v=`267iV%}$b$Y>LVcZ-~8|Jz>1g
zpTOSQHGPfhXL@L8O#XQuQ~G^!wfpUjv4{#bv88Z_B_IsZOe~!<%b4*QsSqU0rj?sM
zD51rZk6`Xb1aW~d>iV;pKwd_<OnJSTr~<7IKuX`>GpcTu>p$%tj>dN|zk#Q?@N@}9
zK$XxBv@#3uMzmVhV7+dNikI}!w+iw@30{XHMJMsTa|6s}U%w9ak_*QMxv@g(1k$Gy
zr=`QV%D%e;$wbFU4o~v0E9`+$r7oyxE#G;a-+6xh^)sHx4r@6nw4?!S+FA<gwrUKw
zy)C*6pbf8E7>(8ZdIX<=Wz<A{YU0BBN&O{sndoQLtv`|ONx@5SHMp9|s_*gpX&mLd
z!X(%6j3QVu7t(2pDh`&X95q2_eD_u^j?$htE9lb^!DNz#;_p#PdZNV%K^gHy8b_Y|
zhNrzAFZ=e$u;dE7^kZVq?EhJ*2eCWK=cDyAElX91j%`xTWXdTw`b0sfa|Y*J6Bf)+
z9;O$ib8^9Yq<1|3GiExd47xB~<-ov*jg2q+%UnES>xs1b>R85Eyl>qAORw2^RTgDO
zEb>}rh@4JYHJa7KwBB}XN}g9(<F7Mj=HKa?)IUm|;}KI8Ux#TP?`y}{x4Y~e;VEbP
z+$L6U>GaVph^Z!e1GX(nc<*kS^C$mW7Q<EXJlCnMy9Fy_)P1T7R;VFVf^<!(kAGo_
z&DVx3>iTja<zn|5D(zDnh8uPNvwmCF2G}Mbzk?uDJX=NI3xc6?zAmW3Jr1;4D=eQ*
zCfMyvkdMKYY51dpikV1kBXo^LU5M7KB(UnNN(1t(5~PaW(+FSX#X>l={0CEZj;pun
z>1Cm)mw73+ECn=OZe0zAb?8E-5BI2JPFlouJzzC@<U0+4ho7h#YR}y0VR&<D0;3J~
zMzL4NCy%~z7?nI#738?~Ed#&4u;Ta0oh%Db&@zb4n}_LCLtjxg#dQ6Hn;ePLP)hiq
zpkwTj!dJ_DG~o*HpF6Os4n#uC>fG$N`d0yJa~B$FEnFTn8w#55EMV504ciGl(}5sM
zh7A?vLXY>YxWXlMx>G3-TxU&Cd9L0KA-8*#?n!XV*HH)Er&L|tE6TA$B+&7PrDOY_
zI&(U@CtSU}500<2!1hM~-{6-xbzH}Do2s1*WhHPW{u(!joRG!>BW30adEO5e!p5J`
zsR~q|G(l?BDjguep!=DwJyX!7at|~XWs~+6Ba8`_cVlu?8`XQiWxNvb>q4@obxv@u
zYUcxA`j(rvrt+}41)V73SO#Qv8o@u(OHUJhVifQXmE=?Fu2DWl!6ub@j*n@7c1;8d
z#6DxbPVSQ_w3tigRznw<s=QFr@+ykA3g1<D$!a3L(}Hk$FD71ILGi=cpgqtlyg2d<
z*|2(o_=!k^M?Ozf%^x*r18?1F&9@WF^869aEMh4+SypSsF|y?vRDLm5lKb{JP1!$@
znpY<>P~oUmzWD3<XJnP+fV!>E-y0G#fGFQZ6GOg*!SDr+hFFFw(-$YIOTFoJAXWLC
z*Bh}T=D|bwDGcAgI>35Q!k>2=6>DvFtnQi)k|XB&0$$y(&%W`RPH-Kw0~lOoe2W<v
zEL!zo>eSEm%CMG3R#n3Ly;gH)lSO?8PzB7K0>5JaVfS$hc?1+wYe1?(K(zy<oKHX4
z-&uT}QqF=BL8LR)8g})!$vsjSu68|D$CvMqKQH%LSHN&{^<cjGkER*ocIQ16VUef$
z!Zw8a`d@ZUiwX-(uRj0g<p_DXzI_qRN#`3e)vJJ3he{upi&C50N@fuKzpG&T^Vsrd
zug7kiTjbH;*;RwNKfF1~e7<xKFo2END6i~J+aP&)h~j68({FH@xYRB9xc2eSbR;O%
zRVr$Qqs^^qiIW~y*?D)cVGqV1MvtGV`A+YlK10wkvMB|B{_F3rmnFg>KHnb=79FOG
zdS)x)wqM;FD}~Hi*5{ho1w=CszSy2Gk>SDmAtVMQnf}6Z*GO<JVJm8iTOw*5H=iZi
zv?94v%vm1yeOPqsX_KmuVM;`rs2PyKzBud><ZxnqU_IXl8mrQkntn`K##{!)y@EV8
zEN3TF{h>ux;(c8x1D`|_6TvaRXb*xkJoBd=%-pa?FYD_B@Z-q%WXrOX1r)`Fv@P@S
zN>|`!<4cYh;Bp(A_^WPW5RgmdokWE0(M{^IFW+2kJ~#apw6sd33pru0LR6J<&di7C
z)<I=Kn4UmWLALs}XzJ(;`#Z9!(dppq-xm7zywronDfACfjgNofe~HiK90(I?rbNS2
zW<rP|u@0);Bk~+lEG@4NxU2L(KAVUbE2>hc%kC+Q%1~h4!=uYQeQ{zy*Df{5^IX<F
zHOvsfS`%&_H!?D5HFK=y|KsuyUC{Pb?N35%p2#a|_xY-MK;>iC!QDgNzO&!0Gp923
zEX}>_N2St%GfwW6xN8X($`+|ESNZKpbv>PBQrGgfWT2+N!TlW43>2(?GW{yaTtoG&
zn}hb0v218$VAxgxHOw9Vm4$2!5tR87<$La9b9W=s@CX>eak4xyC->ZQRmQgJqV1`c
z0B_&?Fp(hh+v<&vAceK&<<N68-p@k{lYA^ya`SjHLdo#UzqookGE5G)<y>7d9@-tu
z+*T=U*Fo)SPl;Adr}^1}>hz~>-5=$AhE3?mN#nlb+hHA$tf;D)7zOOHZZ&BXZMp!U
ze6=cqmz%w!m?rIOK%s$4^C|F=d5T#HY_{}U#(uypkieXbf%>V_2=)Hup5ILM==}cP
z@5InYh7y5`RJ%N^g0fv$*P}NqDlTqHA~#U?kquiWL$xVmCJJ{3K{7E}Ih!zaNKJ5m
z;ODna(kdwjEwVS$otMIR&V;{p8z>bY95gcXq{;=X3StLRK^dn_HDF>!lOCly?pr&x
z4JJqpSh;ui7QL5i+Hl;ryFlmzt~koXnw}O!i#SvFq=RJ3jz?m(#-_AIm-xGZ7R39e
zsjw$_o}Rp9ADJX_Tk_rxnUjRv_D`~LX0SFxSTMc*b%!xQJDW^~?4e^tU4@Qz548hk
zsJ(@!guSfIvz@}a8F)B1vo$V-;j5BycvPdL<R*MOUxv5%=6KZz(2wS3Ml9d^$SYQ7
z_O;-iF?KveTX}3U(3Vjbv}mW4k*TA8D=RTk*uvsKxi*PuW|)z=UOn#EF8$hR>H2Y!
z8M5odr$HZvh2SRv!?}S!!8nHeHTf{I6uEl@Au;XbHkQ*hda$-Lg@!$uSh^x1(b*=&
z>dft#)4ssa94Tl|%<b|F)wTzTWNre>E16~=2-;b<=DVW+9SG=!Dqwk~f-)&x^g9^9
zjN#;?R^l843CkvCy2N=S^t_`_xT}m!>+H1hMdVgpD3kEK*G2Y8`usdfs2v&a3WRt3
z;$fZMc@v>kiyh>3hW9dXIyV}_xWBR@6|9*dd>fRhbE5Zq`9Xdryv5`E+>lXo|3Ftq
zDZ_t7V4)$4E}9O%wBfJ%)Adrx>D(vXsK+y@|EP9SK?&L%<TV_VyRN*`rK)l+nuotC
zp$R14xvSr`Ex$$gZokp0Nxml`Q;Ch<0BK3Jg%_Y2!3GWK%=L~j2Kf>?`*yg$Uv_Wn
z@K9j!Mp)e&LfEihKO(_LAF3EO#HCQ;NoQM#Y*fjQT+X<?{1M-v9O{3d*o{x?J`_H=
z>Mz@=>T-Ft?@ly6XH??r&*_xpC2rbym*}&#tQ+HFp$li?CuyU})vI~@)g*7*&SvLp
zdwY(7^rjvmtSXdFbb%osc25~_#*-Z1ey2)giaBa)Xnv~l%1E?ju}z$np*iwnWMWLy
zT04m!_kTsNZHTMlS1sbGg6h27y{WQqCiNuG>|X430!8b<2a<kk4rk1C467;hxzCCQ
z)(Utk@iv39BSut_%Jb{r?O-DFc?ibumwMD%i`PY=tEtsR^|It7nkim=0jT=Qvr3tf
z`G}BZnsk)CPxW9?V(56F`MsL1TZyA=Gp$W4`UUyzyY;lD9)z$o-c{y6xubFbylCG@
z57EsRSLo_B;Y`ZMV60Uy-gAYus6jmPk<{LG3iNZu6*k}6!CDB%)|PBxoc}yA)PdOR
zRW@1n5F4!!oa@+Y$}LuC2?qJ6vls_7=nr`_Lx!$gd2hOy0_IE%nB;UjCPw&r&$S3=
z^Uyj2y&8ciFJ3vrk77Crpy~Irf>Y|FZuGs=9P2n$+oS+M2tY|zN+&uW9a)8Nr0`Fc
zB<gGwdZa3+<Uftlus130AM(12zuka~FB9cVWlu$lCIDx{GKItY??Fu+gppn?)W0Te
zSzqw%BR|00=eHqL6uOf|uPL?!+R*7>9Q~HH1v69oFB1umq_Q+(Nu9TlNij#I-9rRx
z`+cq7hDDND7fm*cIa>Dmag-Bo>r8(My|E#9-^1Lrd|I51n5{CIarg4Z<&uU^lIVHN
zPlQ#5?7trgZdO7|V?ou>`vcLP-ztl?9S9F(y}p%3YP#;WYJNuJ8rQp*?;MEWv+B%T
z|BXI)i!QX0#w4%dNBwI&D64M@G8}Eaz>M?VYP>*O|NNe<t*Si=v`#G}(hK>+;<Exw
zv)rhWvE}#%PgOT^{(%uzM}`$ODQcoz9fa6LR7qEzAnL%M$~H2HE3FgK2WXiwl~FKH
zTE$IgLMk20%D@Nm-DQ5fv$Egs=~m)3eu%YdRWgvHe;a_EjBfj-Ev`*_y7ae>Tfw%Q
zZw(}_9gn_&C6__^WbHbF8TiL#qVB&$9SlW>Q!h9MrQ!A;ekE3GRe~BLL`zUx-)e&x
z`D-J(oE6uBetU#Ni%ZB{=*O#aW+y$d6aQ=lPDQ$E&CwQqjygYrM%8DHp$e@Fy$t%o
z)_+_)&#G&{1yJ8hofBc7P5Y}B?}vvd?|*_xYI!6BPE61&x7$%xft3^lZF(JiUVpKD
zh);iEB?{^50jZRJq=^&OT0%9g4<Y$TuogG91dj)BF+|8X9r{}q0cjkXe6JW=!td`{
zlxwB~QLf}v&Sl=17NNV-v}Ng>>CpiRD?94gKl%J^$;C%JK}TC0`iEbxu4se25!fYN
zow7S-W7=2>QYGBeI^4TBlV_`@&6Cit*MyvGjbA)#zc-2o7wAZDdK;kkz()8_KZ6&J
zh;KVrE1>!H{Q6fu3deRgyg8IP1zs(%=yyox`$s4Ek{D`}FCmSZS$Oo#BTzjf(voP1
zzx|*WRPOxe+?=?%cSYdeN?Y=!V%Rt?Tji6#K-t>7E<W#*dKj?l#j>RI?dL_Z%V?jS
z1WR@jwS%%RAUXU;I<KPg%8-H<2BYC06S2!y3}w@dazB5$>9lrV%gt++m95c}aFI$K
zmF#LwNJ?PG^m8vKx{X!@1!n6?s^;P({s8DH#)H0%RcI1QJ3As_>&|j2>?)CIxNX_+
zTP^{#G24Nz=Xa%L%BKRNbyd$eyahMyupDMg91)vb1ynV=k!Ymp=W?Ef&6$;<rUdkU
zUmZcyUewyqvG*s@?Wtwg-Z5h-)k)Lu2zc=Kc{Ovvt|$igv-}76^CwxFCT!RuguPcN
zZTe<`jK)kc^aEn|D&0)~-8zBoCd>h2%B)t+>3eAscxW#hn+u}6IrfBsN^I@j>vyOz
zh)oGP1jyemz41HJz!p0cKVVSt^{pE|{R^XqyyfZEjGoqv#TX^W&sx)?Y#+rtadv+w
zUY#zM#6IW+Oty{2;XIorzsU=<0@a6=y;N`OJ&&(s16GA5o+iq;a1Xrh((!J?WUBbJ
zc^9khqwD#p<BYz67X~x(=deq=84}NlUkd8e4?l4T)qyvDUY3G3CT=$>AWC1)EOGbm
zU#WE=77sjI_z!DYER|Zh^r+<u9!*zQ>|*5J>Q>cmnQv*w!904~?A??P^4Z4HpU=gp
zB~rai;5&W<J7@LJqwZ>H62#VEXapvz>$5JVR(8S5sZQiF|2CM|GO|IgfbH*SGuxUJ
zTXT`Zekr)WU$zZ671$Uqzcv3r5mRGV)@)b@?qY)_n4thfVgl;&7Lz~|kw4X={}O#0
z&IkAOAFG)TtcA<KK0V!F-CU;Uj>?Jp#O;jU&pH|9Tvs-JkXE6;Ya+SqPmjk~Z|=Gs
z`WGyJ&`%b$40{@g>_;nWH8}nj!kkAybf@Rt;$q@)B11Nn>F1+$MDpcnn})4t;iKTk
zf{*5^jnqO{@2QUlJHT@OTdrb9dxD-?*8og*__Fkh9f?-V7GHS;vM8A?TY}V!rP|Z3
z&eD2VO_B0z=u>N?QH56Z?v)cgYujD-vdhU`faXBJTzKdgL|r4os%%Ou>)wNiO*-<H
z#RtCa3DFUjN5PtBk<R7uG|MkPZ(VcMKj=D)TP5qr*{n<iRCz7RWt8W1O6R+Hj0T_J
zw^FJfV+F&ko62oJYeN9f%!_i*0$x+k--zn;!!S^^3cQf*$^1)4@ReM-LW`S7YKrs9
zKc={IvLuLToVm=EbkjAa1N=x-W(ON1BH-25-e=eQke_5W9)$yE<TO>0XcLk%vrQcD
zQWNF)Kc3DyD$C}1_#oX~(k%@F(p^e7BHi8H-5`S8bV+x2O5SvLcXv1M<?s8P_b-kd
z+-rAcb~a|`Gu>sWfPXk$s+H}9N~L9pIs~a%DB?$Ld*t(#)3MYP^TU^AWYMjw1YMBS
zWzpBytS=!M+#!jn;~x!m)}ETzl<M%Bsr_)p+P_Nqt%k#r5x%|+HCbs4dKsSAbRbw>
z`=f+sls1|Mdhy`GHaLtZtEYYma49HynL<L(-Qf9DGIbLJBzZOIlv&q@H`DKbqj113
zOuERvs0ld5eY5O<2Ws2ir(|UsWLW#D-?U)<%!HVxeB8K;+7uwv-C)9h?nr`v%Cu$a
z5(lcl^UyT45(B?|?!S2BuJgjfm)8%(iZ_ZAvioEAr#G37rM5^t->YNlBt`AeNJ$ff
z`}Ad|XiC)z*E@eq8h0Bf!8>0(Nqj;9G-PJ?;1^VPZ{>M>8TEOyh<@}<9{s%Ufk-)D
zJgf$4d1>U|x}@}Yn^9b(_;l6ts%UO^ehG!GcG&RcR=TZQn(^?pyZvxmsi5e9=C&d-
zjLbvr2Rx6^w<Mi{tsu_f!13LrOG(BW6S>^Y9C}b8Y%|-+><PVdJSUgmhh%V07BCY<
zHmL6d&3p_c{k$Z(shQ&31&l2yq@~c^k9~_f-Z^@;pawQl;=@jq(fI3Q!q<0$jiI!U
zE|!X?T;>uL1)tq@EuO5J?V>o{0V08N2Jf5iR4;`FN^(VPaa!d}V(YDm=VW-ifM24v
z))}=5{!y+Ucxl{ng$7D~P9wE1A<JE>uz;yMT?NO)%gbPb*2@gO!K_?DMve<f4Ua{i
zczijIg#un+5v(C7bTOA`-fCs1_fv?SDX;BxOr{CKF=73Z8)$){ts`J&{)&(%FsE#?
zfxE#fY&oRSOMTS6fQ8~c8($FP-P(?4QP(*!BoIEh)G>$-^ENKuESCzJcl{<VKjPDC
zs6FHNn#Y#YANY@(t_cD(v6P3*GVk9ylIh7pWw;jp3<Ng$HViyrN%tCarEmiJDYh#t
z@|Y^Lo07Zx0`E-=O3VNfZ0$^J)?I8_r`JDmDdzV(sQq9jYtfsdUOZ-r$EXh(9yh}!
zT{S0cNnghNXAiwn&tCVkfxAWl2xul=Z9$}e)ovG;9q`gt8*tN)N%@ixw?;HGUX@x#
z4UgNJ(kwd%FCpQzq}mgVy?Cibw7>F`uXN$d#)~JexiWYFrGk|~AAvqkDnY*nHGBeH
zGVklG<h$)#Q-R@<@`aokL~e)C(DSpYk;HQ36?W9!tqFf_a5NcmyYBAA;dL<z*73#I
z1+{n1I_}6cxgJswr>1Ipeg*9@tUFHKR44n5wr;vt&|1myExS^`{1Kg-k4Rc)$5jK6
z8|l$mCfBe<anaf!R7|$KVz1&AVbI4%#capIdBa)>hOGO6myo{RzMe}0Eh*n8&pvfN
zd0%3UcjC-ACSn)wi<-`iSeQ&zQC)XdqD7vINo`^!cIrcw@xAZAv`Qr13ZR{Pgil&z
zQq+9rxxYXJtn<oNJTNRKFd|ycvVD<-NtSlZG6Vv=r@<4eeUAi$<<6EAGK-`_F6bgc
zuU+9$Q#)H(D-7ofq~pt%?w;eu4h<L^H8+c~>y0=Co!;-;?BU82iM;uZb@XE0P{WR5
zR+Br$oMq+tMka2y9y|_Ao8FsfyO}LT-|h&Kirmf5JyOPyr&$FYgh_D?@8oy->86E#
zHez%(RK)bLNIqs@3(!X~_En#JjX;T^Tvnr_+gt5xwS#WHVOz#q)XkZz1Ic8UE{@}=
z9nx4$q<rB=2&QzceEmkA7Huo2E3$_z#f()hp_U3mHUurTxG{y1+nPu^mkQq(Nl<hD
zo600U^ZOGF0dH||+lIa8M8N$ak&<2%>L0YZO(eg&LRSVVs`TmO`A=73x|5Vpihid|
zwIihGBrSKgU)Ov7Qfc;=5nh^0SQ_^~ldiulgxbBMb5R43n!3<4Nsc8o?hD@3kz}d6
zIY@KNy&S_RuZtV_raB|g{ppC^ZbgHI7iZVE{2W3@w8XasO)5MEE2o-O9BkX06$Xjh
z-Zx{71DD~qP(hhYt({|s0S7Gb-4z%~FLA}(QCF`lTzRRPgtro}(`s+;lhq13F1APN
zOjD8&?KpG|^`WN~Lwpk0UMOI!A_8%pn0)6=zUGU-@Q>ifc_f89*Idml>P5xFmpQ&q
zG;1bfYoZ@k&)6;O?%JMR@9MR-kxJh9y1tN)V|+HGLm4?-wxHfAN9|0TV{0qlcH=oS
z0JYNhpVRynzZcJ*YnUh@vYf9$jsD?Ezw|Stey~0G<wYxmZw@g;=<kK~+-ZnK8%h14
z$bs9Gu#pGW@@6PfX{s@jx4#6p<%cvv7oO#C$|+4Ze+m$f11(<$WkZFD8vR{?h4DeZ
z*<lp7OP4C}Z(oTs)#m$<=jxLT3WiKgtzf&u;rI?Z;4HrYkPr^n41BLBj#)AGUp(rY
z<xJFmtc;Tk*(~A6a{d&{+4pZPvhA_0M?tJ~kl|VGotAidGOiu4^o|Xam#}>KS`JtD
z;)a_3O^$)w&go%V2g8A->NK&_J{@Wix>cyoOH^?`mIy1i1|v1k10p+Mbx`l;PN>@G
z0}1nfwlg2&%1ARdk-uZ+Pyn@a@FgAwYwU|_E^sg!tICtUcZ)~bvm+Lb+LCN6u+f#5
z>TC0tu0kh|Ev8^N`%V`o1X}a@1}YHDj;CLpUUJ;eFm(WNxNiokDd(GHR14zwv{Gc`
zdL=*juZAff|12GlJI1`?r1L(k@;p4o90QkfOVSDI7N`AuzF0;xKfE!~d|k}?E}ALR
z`Fiye<&f8j#)MKl_*`HAr=q%u6ZAEtsXV!Vb&>S+7zA)-l>2O~n+x2gSnumC)p&Wl
zOMU|l)$w5vrP#{rJSNnA_Up=3#3SLRF=<v+&5x1|-UDb|VGaf%wDKQ$X-s_S`YR+s
z1^F_KaACBqH}#IWK`^Vq;9N#jj|WtDiP(~X?GSFQSK@E<Lk*R!ROzv9%7w{j?h;8-
z-VZvkbsM?@*t8;#;w4CNBBa7gE#t?SfB8`ZgaDbak`|Hu&=>qWLWgZcS2E@374<6p
zNg0RfaXW>737bPKgI)(=kj(Fd_fU_UhetK^w<ETmCM%wr#Se%=U~KeNUe%eJ)thP}
zinB#ib(j-h^0NGD$1MAC8*hT6dPsJw!Yaj(?T+nL<ej;LIk8NZ=kwEJH3-p2iN3Z)
zl?Czo8M)w3cn9h|Vdk%N;8>W<kT|svs@T~PJ@hli3=l!0>;?RJ_8$xcqAP_}J<KIj
zb@NXF6&PA-05e8jgdJFk>Rd-UM5S+4_IB6{w!TR$rU%lG_7@aMtC+22(vN<u#ieuv
zwz+j&+!a}alib8(qTMhijn_)3o`iu=9&TfsJE8I(XkA?|9X5e_cP)9>mo>~4rmXG3
z{G~os*W6U4$<~9+0cO&s7LJqDUL}Zo2>+LUtiOjnwEcZVdN@LIt0(SGS5{m>-Bi^)
zMHN-8XljHs8MvHTL_(<CFPIspoXkj@!M;p`p(R~CLpQP88T6(5jFHnOy}pQgY|NnB
z=;G<qzr{*eaZ<mcV-Q&WFgkmLTUiAX7E#B2R3y$jUHKUHEiSh1`trkXWkR{sJ5%n0
zuL&@RYTgva?6b?FB*W=@8~QZ=OQANE|ASeoHo;S@Uvuwg?X;WhiVBb>1Y-5x^5vyj
zc5L(v6nsJ!Wk9QS>C}tkWg2(1s-25DfSj~VDZzei_O+W!?JsXKAm0Wdt@PUlCkK)1
zGcs-ByH7McqvreDDL}F*0?m$uY12b|Df(@<xePn>TYsJr87tbrS&=Cs5YtH)#W$PO
zXi>@M(JP)61MPVOf#Q~h24QBTxkx(%rDAC(j5a>C)ToWoHRU@aukG^bp1}4dEiF{R
z_j%^`Z>`zV0(*QOlymtR`Nbs(Qi4BiM8(2^FDESF%S{aT>UiI*tD+O4TeN)<+2D(|
zH)3a1`Tw7erytz~nFbaoYj}!-n6J3jQro6(LTX6i=4{gv+uhehYk`Yo)&Wq-jkq=R
zJdRxlbEWh1iTyZC=9@k6Xp*2*I%ZONkYj2L%uZWBnQT6<zCbg89rZ97Nrv$t=%P7f
z!?8ULYYM$cJS*Gf?eBp_q>(R@syHJG!u59KEa4z6IIdXWU3e{Um!s8->!Z=iHu=-5
zkvd0?y8E{^B)B59WM;9l+KDPK$y0lcTy}8mYT$fd=cy|t9z?FP77z1!89Ty_W<T(p
z5rp$N44F)>C{p*=+dsug8+0advFH0o6S~rSNJ%XfY1+jR=FJSND=p;kiqz|HkB`x1
z=bPTe->kanCDqSoZbE63OgL|&taBQc(p1`pG>2u%W8KjiH5vncS;$sLzV8G65{&Q!
zHkv~cbf?9zwZSJpEernnfx`mnY5NI!wU(m_>G@{S$dHY-E8rBO3tF-Otr?mn3)q>`
z8wWaLCxx_h03-I<oPE1vB&=$xqyDS`a*Px83&Km@SVuBk^74ov2cr{bSEyksSxUNS
z9n~Z#)Dc{fj3CwUm82MUdvm)Yt|BqBCVf;(mGl7iVoT5}El=_F%?71)M&GJg3Ql)*
zI{_Etzrv{PPM6dIu*D>CJ{ZxJPEFmFXG`B_<Sd?Fa3#SCXw`TjU*~elY$qVC8Y>{i
ze2ywn{W%+29m4p@Bq|G`Hr>%F4Afkb0OzbcPO(ks3AOTzChrR`mi)lBWr#Jp9eSL)
zC(J|r?<2LYkWVli<gK|&M#~L<{rN2QSV{HwdLNZ<frCt3D&SM5t0owk94n2!Nz9M=
zM3!)%@Zt!eI?3^~6R5G;i#5DiN{puh?#EdlxJ?eS&W9R^*f}dH$TwF44H0RxaFH|c
z_@>d1TH7k-LGt!dmVH5V#T3ebm*oyRxIVk9Is8VRhb=cvzd0|T`qONg_MHxjy$>3v
zu8Nxh3(@AjKlt%i$5aSiJthF8c*I(<KVEVc@WqqcEqsyO@OXh!)?3v5L~`v~!E^i&
zaj}LpC`3I>96=hkjJL%XH3QZtyT^(vw>(N@Noj?Elj4pSd!$QT4`0WyHJHac;(T_f
zdaXB!xry)0d_#SY{dHlBtJ9@7p16(In=k2sv!)VMRm|rg3g!I^^QbsxCP>?>v(xy4
zVWioZ%=)h&5YtZu<xM!G{ueqH1ASJSBC-gOtzlrd<Z%9d+<5@o_2$!6759QWc@`v#
zbJ7d_zU`Oaspza6x-mmqszSEx>o(WdL3xp7FV{9TCcb*&+ypgUYmdT<%W}6VDjSWf
zF-f69;k)ikLlsjK$)$SKb+rRUX^m(Ovr;SkI2Q+@F!i(DeKiisku125lFMvHm&ob-
zf4@dA!sX4%o`erhe>SywF?MT_Wmd)LQ)&O1{F!vHK2gttSde(@so#)63F*$0WdY3}
zHJCF)oj%<<(6Zk1U{Q)YdqDYB-J64~O|1S1D-6}*!m_@__8gB{KB{q)o=J!Lz%wJQ
z%Y}3iAjS|WNw=XRx%tJt4wQ->;3}VgzVIH(s_e0E{pOLm%Gt*b2cayhBqGy{x5B!P
z)MvnlC#G8yd)dAtrZA^D`B7z$^7IIJw1Wk|ul|{saG%OF?pQJuW)VUe+GQ~Wt}Sc!
z$!SvLP?f$$H6~GYCEmJK*`c}2=ch&n?y)+xY~3ASRzd-_O0HT+%*z}ceD6k|oVjVg
zBiC=99MvJ^sDgH96&O&r5&vT32q8}D4A=G3#*c(hWp~W4#l{eh_&I?@LghGvJ(5uC
zX!60}863XuzZaBuKFBGttgBnS-RISYwuTR(=Rb_z+DT(=NLiEBGSYVJk?j;OYwwBy
z5<jC#E_L5Wj5C!Dj^eKk4fG*1{q!=|14mW$HRZ3?lH-_s!})6R4t1lIL}XWM@R4-1
zG%2gD(7INjtvOBcxYQ0=0LIUT^ZV;S9GhlbwdVdEJ=?lobf<0LFNKmnM<gTA?5c_%
zSyB%a*3QTu!<T6d;eLOi)+V^5`DoDZ&3zcNXu`$<L%C16aZP@gnm8yS^LN4eC^7}s
z_13jMM`N<$NuJQP&+qQ7K;@C^!xU;qvMrHuO1L%K_8vDwq~VYe?A$U{$`byQ>0|mc
zxig(s*!J4ksf2X{%`Rh~Vt>?bcocXs9Gc-H90~+cH!@B_f7ICz!3A22BzT9+&P@4O
zOv*jV@M-+vEAR03@!&lu<X9`^VC}ChwkM(X?hbMON^|!y>wSSMu)NW9^t+x-LG!fK
z1vZYj7JlIFZ-ZL{$Ifl@So5fOHE22~1Wv?!52krdrq#PPu%~xp%WlhS-B&66M)+Q2
z5Zpg8=s!i_$*E3Af5C^(+mtC*FF!0Iqueth>@z<XrJFtrPW1Nvd<`k7Z}V%Kk!IC~
zl6638k038QwkscrT!%iLW5@ev3_4=gPczybgJj&42;y)uZM#+!b}M05KTaC-rxIwh
zYD1%~N-=s;8VFRwKt#ue2%@_R&oB<{J?F>%eM%cP1Hm>MnheU(-OHa>rQC^jAAkTo
z@iLK_#R8R+lXwoZM}6+b6O9BRsTj7Yffb@jY#>U~0PZ2RC$bXLOrfIjy5_|<9gHet
zXzTGvsVODk)xrQw+2wahBjmlIt1rJ7se>$x{1FkiR!P)moUoY;@;0sB6wQBG<)cFF
z1zEu!R=c{hz-8{W4k6>Ma~()Q{>5N45}ahal(q_B`@vE&O!Ec4SmxDS+u%r=Wj->H
z|127rTrSj6+y;};<RahX=IdQwHSokU;61VW{ou+=W;yeUKv>_+zxv%JY&~_v1!n{b
zO7$1`g`>cz%ZjMKCZwK&|8Xs{7$~a{h;bcfkO92~y}14)t@GAyXWE8O7Gxv6Q7pBh
zW*HcQX;jcgAoA&zyi~$GHoH*U3+o%yrw0PB4m`UN?>4zTnrOV~t3?!8cG{~D{^-~J
zYB>mDF4&@M`!tIx^!2_i_$6r{?9CFH#t$|4tfXgm$nxUB!Jk>F_~wzj>Ez(>!|Dm-
zM2RGMOB1kqYsTpvklAWc#!OivtkZ+riu2-PGGf8%DudQUBx`Ffyh`ZXTf(3~0)2nP
zRGefq2=|R*$XC2T5acscS_*m(A;H#^ja1bLy&kH(wa4^FMO_K!VDGktNSZIdps;G+
zpQ(hFjr7^>^rCH`AX)+tbN)enbaj>?m_T3Ypd8_FVV$)XtIEpmp{rY|cV30wvR1LK
zXigTz1T!_M=D!vxOR!Sfazore(TC##UzZOC&@^TTDcR`?y$F1lMNhvlSUz&X@?+w)
zdT^3mIdH^FM7xy1haOXrNuqz@XGBTMx)OnL>0jj-yNPHk2%87m;NGcEU{j|5jzKzP
zOob9YPm+qGTKqX%T1u=)+5I8muh<YR5iF!^&*FERDe}}rh(N@n(022b?Wrm=BB1lA
zE=(rB5*)p!#8RU3V%yab`rr7T{>+E|U3j;$#xj-uRW#+kyg_u+Wx`$b!5Q8drA1@Z
z9n<0|#`Z>0Bx56FcVYUN3+3^e$tsx}$RrT{Tj}8(<SyVOUYw9`3^N9sQx|E>_r5O6
zz38g=aQe|lN75iJnqSm?R-Y~FiV0%`siV~0^Y!dCEVS+YA(C@B49FHImoC_z-Y=-_
z^0;qUWX1(RNWsHXoN~K(WpbGLgD6y{j1(4j=$rz=83cpsZ$iij7_<t=q|@KSr`@AF
z5JmgDzjB1Z={u+UvEOMBq9j~A7RND$ARY-jdOWmVB8a#uUbIXK0?i5|&ik_Uy+#xN
zo*jmRXG|3vl$!c%Nfl<;^RnY-q{W7U{>c5&aKndvs2c-phKsh<CkhJ<uYPhUBZHAJ
zklmR^g(U)04?ZN5Zf>pnHYh&=2cgAJ@+dD?2aRN^Pc|F4p%@t_o?uChQA=bk0`m86
zoBY+)N)oCEX^5`GgZPWg@WjXqqu1oH(@HEiJ8%iBwh%SvrYCG3<tG9_bUNASs7qGQ
z&txq)bS(=)%U7Upb>2?ni4Q_&XL%H&YW?slmg}R%pWNg=BP~OI<&9iN>}>zxg*0Z0
zgPx?qr#9@O?786RdTF}V%g9HUF+`wyUhr-o$#sS}>3Fh?*mo3d!xu=bM~DX@?cLGB
zVZL0`3k$A&H<nkP;X8^|z5BA+;-WA3{ltcLK0TbE-05Bnrk=*MvPBLY#&Wx93D}<F
zLL0UEiPC~<i|$I>AeP9Ai(v;TM%DVym)-=<kZ<`B=y~v)YLIsFTNL#U(5|^ZLspVx
zH!2-EK1k9wv$r1?1q!y62v~(6S`OFLmI5PJs2@`Xx(O4^Y*ISf<YwenYdPtj{K>U9
zm{sQ|cjB4yS7k{N;@=Xm=l#|K4di=Rmkq2W_X0r%iylQj3BS+4>KohMFwx_I0xmcr
zq=NG#N`Qi>4gK6QV=L=Z@_{Z(bBoHd`JFBreI;1Fn-l$7J@8OoesljBS8J`mA&f}=
zZT?Fp=*<Ij%&sO_Sv=&Rc9BqPFQHqDi~Ei_%}uPH9Yl8mEhsG&Fd4CUEI!`mb$e6~
z|H0?BM2=^z(Pf`rQN-p_;&&#OY`>bH?LN<IEwctOU}-QSNBS~2v-Z8qokvo`7S?6y
zA$^j4Kk!-3IE}uoD?@<4+D%FG4S)%WtXNcIx!g&XNrEEohFtnC_<|f9@SiEvetqg)
zR)%@)TeytDR#lX-?(ZnLzASk4_AcXl?)QeUhcK(vjmgVZKOU_MPB@kD3iM(%WVo`Q
z(u>M~nf=Q)g$E?jNF+xgM=8QK^YO@$rp_@E%El<dUO3|1G_)gn>ba=|AzDVz7Kn_1
zr{~)rA6_2YU&fQrNISgc!u+_@vZhIALoN&jA-F>swuH5=g&zFg{TALEUn@N*MqIj=
z7ysIh`<b2yxjk^6<bABY{`?0^TnMmGT#>HAM$@-C)Vom15wMUHFd!w(fyhd27>9lB
zl0d<?!3BmhKA+p8>9AOZN^ya_`>eGNPbS_pUys+D`&N$NMt5OQCBX-rnRw1;CqB~3
zTA*uBbdPt_UKPB0?S2{j-PA|m#t6q<)Y;0c_)1+Qou?Aj5Uw$aS_46d3I9<jDexCV
zitO<q(=V+(!_?Zc?SPekg)Z%OZ$+-DBb4yT3J+{~qJl8*HOx}Rxrr2LPoh6K{*4^w
z309j}_xnt+`keGY=e7}%Rn@2s+s<s$=guZ$cHUaOo^4QOe7#^SD0o?netk(zaN7BM
z^1XL|`*fL>hckkESC5AM+U+xw!WH+XN}qR?fI%eSAfbThn+aoe=X_+VUbS<~R<%G?
zTr3x=b^>m~?^Cfv*FSmZA?pNjwE7%V9jp<EPu&?#qW{#Mc7LAPG|#+f)&6w#t?6{F
zrf__a((k%zwUP9<-h&KPVt+o~%Djl82-7!8*Wa5y@4dQ%kLXV~uUfk48t!$!N#E#J
z3-mG<rk^WUVxBbj{&X;)a1YDD18V?^`^h`_r8*`Vp5(>tNA;Zw8B|u^LVzpP;skiv
z4$vVHPR`9vZvf+|zZP2pvk?QM2`eriPH%>tUNGX5)=nzTddEKf0Rx_}!iquC0Pu+X
z&GVfNBQHw`C};+wd<b*zf)1GM-5%xRJ0BaVokYbUtsqXc!cbV@&Sb2iV23Xbb)jyj
z$2FB`HQIPsIy&G2K7OxyFQ~X8G#^MMmr$V8?a(emq4m>1)TP<kMv=(>6vB8adZ2+~
zlFYb^puq=Gx2Phr!UHHwg9ds`ZzYD_imW~U<6&-D(KRoKM**z%YvP}17SqrwB(Y8(
zAEWGJt{xwvq*TxMww>lsY4U9a;}N>NA+jN(Ug5UnajFC5r@rQh&Nq{~b3-4%&Pz7O
zi3zT;0(p$T^2-tCq94`7QU;X$cp6;vGohd9KgpTOsvQ!ZMgP_VrqjGS$QQGt8M-*o
z@~=b=O7r8xz;B=5=UFw6?u}fe=Ti$-mw)xLcw+XTus--ZdN*87Rx2VfcS^_D^cp)1
zVYFfxTi`W)p%+i3B(;M_jZ~gIun$3zH*&wJP&>ui6`YY6PJ$AK;la6iV_HWu#%S}q
zVsWECC=JJdJ)X_d6SBRvpu{mI$IOO#zU~5N_^}ukd&uR!KDx7%kW&A?*^Qbgj8U@)
z25gZjBEDw+;)0HRM}rQCG<20;(UivxEN24gk=q*;KN&U7w#5dd#faVqzVb3KnzEt-
z-;^&Q%Pe}>MPbRSEevc@e|>n2kh&49?i6}=A&adp3+(p|GmT4&WpNY~{Csy;sUfS*
zw=^b|qxSwn)!{dsxz>h>Q*24$j?s<ej~YLU{w`#@h4{VJ1$jS%q-0gL3$dn-X_hj=
zoBxyuq&x)<O9n|=ql%vwKr7W41aA`{E6Bqj?62(4n5BkKq$7ILKKFTJlefKWvY=c^
zE9n+eKR&uM?QI8{YYe@;!~@-+$VzZKdVJt|KRUnXybf@bf;b>oQszH{)--wD>^b<8
zS&f_C<QbFrnMwr3ySJnl?dp<4g)%?SvYxEK5}|AfwvrGSIIM;1R;xy(xbRu2MrH7V
z_v=mJ!(&#ZJKwaz*5v*9TE{CD$Migx-TPZ_mRk|~NCh5(sv@8Fr2T%6SzLV@@=Y37
z8`DWxY~^}8-u7##!f@-&q(atIpp>3&=VSU_GHxlvULh2)(Q(WplYp;8Y#Lq!exMS)
zPjn%y=lr<1;p!Lov>g{)h;`OkT58ri|5;0)jnwRr%iOrG*ASLc|MH~wtc}^G*YP7f
zeGyY4eDCQ<R>)JNqoC__0HA1|&+c5}bZjuaFPIJVI$&YD#5W8(!S351_KcALD(-2+
zXnErzI1Bk9T#F}g7~~ZsydMgM>MxB;K~=|YCxf@Y6W``=*Gc?LoEk#=qtkh>*tvKy
zDUTLdP-n1YFhZOM-hy+w<gZw!uCZ%*bm0rWaA4*^N9Brzc=PL6r?#9uAd^SmlNq|F
z&eG$KS!m<_%?{34v(;Ej^189PYDFl@c4d@kU#;+F^0Go)Hxh(UjLy)76)-Pe>;3%H
zFU3*!<Kgb=K{BCLnesuxa&zgx9h>gz(pkUq2Xbi;>spYzHzZdDeEsGJQj?f2f9`0X
z!-~MS5+*(boEcQN<<L5$EX&eh{eR7ZOy}VylzlFh13Kxl+yY5B5c;;qBiN3>)!W8N
zXS2~%SC<KtFJ8yEVZH_{l3t@>Rf8Yaq~N`YGy)(ao~b@}l%r?@>*QeM>!Ocfrsa9a
zKM@$(P2Y;D9v+4ro4F-4sY;<a7ygmm;`6Hu=Lu}JoeLm-bdTIb;<k0OLE$GUj8sV^
zYMA|F@*0oit&R6rpV2e;!nZ<bA{1!0Knni6^$A`S@PN_?chEDDj|)+EWCWczh^Ats
zbYfItoJ&(q3i`vN@6qVIg(+MFkM8sseI82>_jkVK<<M!LZD*K>xHd#O;d3FxHgDhw
zeAN6hQGm5`V?CpkqSLPgjjR{&atVEFi`tHy5|;~S?p_jx^F`)m@R{(7WepLkDn(c-
za^c=>4i~(Y-`pSXeudGm{*+FIMS#fu5Y>KqknS~4ri%g?*<k**RpaBsj6P`?U}4m*
z%wMLgRP9MsYgXoO0%Bna>Cq(&frleDd2wpp;Of~XGExN;*Ggz5_s7rTpo%j@oie|f
z*bhM)pYIBO!#_>^<%GkTNj2u0E7u%vr70Ez<cb~dt-bxKRUh(MK*!;V*BPPH$uIA`
zHY1iYIH)*yxi1V^LC3H6!&&ZWNK&O-N}dHpiSsQMh_EgIMl8<zM94J)?=|hU^^G17
zKq|^HcF*%}afBTtFwI2EMEyl`lzpIuUAyRhu6!uY_d!_3i{KfY8u+E#l7H+^Mq0^2
z2m|%0&HJ=gxiI)*`5yHz$Va|9J-{~*$IEh^m<A)itg9KA<z6|=Ysaw)F|IxTECB;V
z;YvI(CEv8`pvBeF=P$;+8rhrf?2ICxNHS)$vwbVVyzy39n{rPV^}xZP^c(d^D!{=0
zZFE78Nn&EZ&=hD;<P<?Y`t`ASm7t4uuGc9B5H2~A`dQ2_EB2O6Y%9IYgg%Vs67lBZ
z0b}@&LM8dc%*Q_i;N!@mv0TZ?@#gR(=Y`UipA_`O$U(mumka05KjH~^zF*>4eV>J*
zFM@&;(zoF!KNsrs8ckK#{AUc2ztki~!$xH?1F?OP=<U)2@oVZBhC4L%4LXlLVUZs!
z$Qq&TY`cgakec++M7ob&+6(hO;dD3z-v^0ogiRq-re5}D5ppfN0Y}sBC{3A<y7p`U
zkJhlOM5P%^Gm>mgo$=N3@$lhSeuh1cb+-v^gvYrM=pp4->^up^Q<<tns1rZYFLE?X
zG22yCoEZr7*xKqPbF$LILPGi?%5s`sOK;pzKnf@re5!hkix8u>@6%zUA_V8Xa`aI_
z{37?Lu{_4=JKkvD6H8uX2f$Vl2i2wD!Nb4qc!*KMYw1w3^u+Un0^mg}3I42l3y8wF
z&{m~Q?i~T?F#y(J<PCt;ooxptTS_}q?WBZVmQ}x7gmf=}c?y$&y<kZu1<<0%GD)jk
ziUyMApKeYy|IGYt0$J$)3lu^qLR5}98T<8+Htf~B9)>x27X?3MRkl_LR4kR>YfsC7
z!d59rE6ELaI9>2@!k}X4bMVph?4H)>bEX2S{}-bY_OtFRFoDEV5wu;pz4+dKaKO$_
zG~D=Ch4}f?w9I}(0%yV}Q9)hG#2>S*-$&UMRoVvP)@aI^ffiE!Yr!rRo*J#0>lXe}
zw-ILdSylY<OE>U{AXRT#PHQ}q<k7vp=+m^?HQwBlcC~61oKiHqBYzMb<Ub%V9DqMk
zE)hX-)GdaqE|l8**$(R%1{ULDd=j+k4b_rbTWQ-#V8qNdQHb?!%Ppdxb|LcG;^{za
zA>b5;Hr?n(9{KRU%Z#V4*l@z;Gx4)g>qx6QDe)9eKC7_pW=IMrrD;=+nbdqqgm#SK
z0We=6u7V#9uMk~st<vOZ5&03}14K6A|D<^kWS_?&U@o;g+EW+xxpvdIq-#>OiNl2X
zFn?*6>*^8}{ov|GgLRcvSJ%vaK<nokhd#s%)c=ODYC&j-n|)=<X}kQ1ebEMe(hv?E
zN#*>D7wTbtP%u3uX(eLZ1?x&NSiHx*y-O&!#`yC}{$Kp;KyzS)%w{LP`>pINBDeeN
zXJcZ;xQ7d&HQc(<vCzxJtW-Q=mtqUR!=wJfB&s+=7Qa;J!h>;%86=gk@bwvv=07nK
zAAXnZ4^5??sE0F!r&Xcu)?xeVIxp$6P9SX^8f7IcsGF(u(V|)9c&(mb*eYUA=P%iR
z-zHq;6A7J;#yt)<Z=ICOAJ1Rb=L^nt&K5zSVJL)^9{_fqBy9tC__o8F#C0DnW=v$T
zTy5qpAd3Ev=nMy;bD&15ELmoV<~h}R3TxSyfZrro{XiybM~9aAE6lr%>8DU4HxYM=
z+OZY^Cs|4sLs?aF0K$K!;}zJ!NoZ1>yhytquI~Bz;#p*sPFWSo9K(RbAZG=~D=kWL
zbxAcAewp?A^7XnbT<JF<1*54x?Ei)0ASO~{0^eM7+V)4LWdx{Sb%5*DD(V%n&rPB`
zA8nPfSk?diZ~0!#JE;Wr?t8no^s9b9th7rxV59wC1DI<0Qmwd;DTph>gZwaQ?}x60
z)-nVAm%qY`Hmld$=p|+Ujej9W_32FxO)w_Dk@e};p65>X!^D3x&^!d5SB)~jG(*?2
zbOgR$4MDqBGkPy`155u&UC?AExNUKN8)onzmdQkPdf$J5(B3>5@~_f=qDQe@mKgcc
zuG(OuhJVWgK;mk|DbGFx74HD|hQGK#4kxf0yW3z^EG3uzG=+Y22-N?KZFKXLV&-W_
z-1887$f}MUy*S&_Evq|Bz<gHKQha-l&W<Jyo5xpljibMsa796Gvz?Hs5S~C`02>1J
zKc&fGj1ndwk;durS~mCoi9@I#a$~5)e&8#sR>8EPh|hs*o18d6@Mv>6<R8w4F;<^Q
zHh>c#2jK!78=xS{|4m#J1WuTUp_?hXSyq9_{;i%r@u?lAm@!P!CQQ1yRwN-ts;tcH
z%R5u%)<U;GLyA>|WfjB{KOFt1cuMh$3L1rUSr+1DDR%f3!hDwB>Yla5C)Q!cY#pEE
zLj5>>i&II0jmJ2mXT{s?33659`SXlrovbYxz!MI@gO2}A`_zp?5FdMlAWn%=sn&NQ
zk`b0Sw#Daia05Acc*JSMGCF4X+G?YTH6bk6Q1DM57F*Vkr8#6f8W}kpHw4aqeG$l!
zDAwf~BASwECtowdkDar1<QTZo|E|oICs5ZWOAbOF-mC&M`D*vxB8ZdL^%+I~pbwX!
z(Zu(s|4)&qo14>Ten=dxMp9-)1v!pnC^t^dW)l6w#<nNLeTLGZl`+n<x8yW?Bs4`A
zM`Xo$#2=W<A-UoI2Tz~*J3B+x7p}eQV+N0Lv9fr}N@zpU&*##4Ejaj=6794w!T)*f
zdw7Brn7CbH^zQ^#z>Kk@07vf6)nv_obQ<#i^<v{ww-T>vKdl`i+o)w*+D=A!sF&Hx
z_-Mb*(Jy)*87DJsaHOQ+8A;n+d;ruUPN1!zA$ea6GK~iXM~}U;KI;Fbggx@wsiAPj
zCl1ztJ?zLh-3^QPzRPSi>d@@AB5<x^cay)-mauE+mH})znz{g66!^=ZkJGT2BMATV
zq1+!TML4W2w3WU`$nqC_{9;7qc~xAySA~a&(0A^55Mnqds`AatX$YL_9=e0cU&{Sq
z6)jU{4xrHm_V=K)V-A*Qi+?>E!1Q+r?^g_8>rL&oZ`{TAA@iU)p1JYC*{Nyx6<ZkU
zzcOMOoM-!|^tyzs>`w%7dVt3kqdQ!OWEt)?4+aqmi!Cp4bl;6U6C{4RKBqjK7zQVQ
ziWS8;h?tHh<=Gs;MEi)Gs?kYOFq6VGAy&!`2Wg<c7kDTH597qE2dTQqF)vJ1YiqcN
zaly#ox&;3=qAA`1X^%`xa(tm_oFs27^f5*gHR;$(j1a`ppVPR>&J+_}cE@T%)+(mj
zun-K=#mMOvthJ%IXV+(pfN$~hc9;yui@lHDqqg{bA=%HuV*AnY(ouKz9ir$jLG5$n
zsY1^%IJQTfvc<=vC)R>%!5-o49vCQaVX6@TtB7(*)ygsSkl;4i+X5N%7-tP5f1Vnd
zotD<BQhR1t&_#)n#g+9lEp31Lo)yAAK|JA!()R1hEH(vhQ>Eh$gBLe(qZ2jZUaXBM
zK?`qX<mCK;L3}_u_>pxMW?RJy-x<F|?34XhEw}=O8VqhL%0OG&v4VCd{FLzOQrBw-
zi3dp(f8Ud8AM2H2v!_XPH?G*sbdhd&pR%vI#e@Ik=H5eu-XKS(y1w6^%sbHQLTYpT
zcjlWQN#m*b#OP=_8>#O#Jb{-rA89N%4Fr3rmo&J8%)<z2yCayxa-(IN&ziG?C-qP4
z09d70_N>QQE9@6%8T=)_rcpnJEN0YdBm6pOWmN?=k}EAaqagzrsLF5DR!GH28R3M;
z)6a)7lI@Ssu$SVdtg@T}c7ynX)P@r@z`=4GD~{>dctn)O*H`5F26+U!)uqk+BfI55
z;W|hBsKK_V6d!ZA-VVeBY!VyxjjFjLx*fN?RtEipxBQJ|0~viWpaIw|hm;bsrPTf4
zha=Vj#T<#mF8-<o6E6&BC#MLt(va-m|9B`dtLRV@VVpP^MpcZvY!l-D;t$jOC5_>p
z0i%Op%8raeo7J0jYMtSc&k4@y{K?#_+WGd0M-<H;wcS!;t?2ojAVN*P?eF*+Sxz$|
zMl^d-)g;989EBIFJAU4Gm0wm4N*{9xK5o(>^a3J7xtYV0y2P*q(yM~3206AB%4duj
z*54x8G;5Pq_qKPPZNnfqXfGBmtqB{%ov|GW2a5lSQ!9MF3p&w_Ei;e^=W_tKnq%N<
zjZ^C4UeasCuU;<r#-CiC{{~+!*Y~enrW<Z^ZaeU`RD@io%0iPs1Xa^ud(!7bptPk`
z4oZwLFH$Ki4pgAlgyQ_kyf7URCNYZ}7@oe4n&TJRMpZfO=8yjI<gk5<|Ht^O`%23z
zZ5}FA1^TYPG_?A?$d@d=zZfZ7W?(^#3+KlFmlBFKzLgHTrX$zk7e5G9qv<Po$I4s>
z`Ho+6_=x<DqM9(qoJg8IL!nc;xc$gGN)-LfeAqhJggr@1Q68=8c%)~R<~)5~-`yxk
z%p+P?k#DLm;dnLOO3QnAGIk8^2FeyR=O4K#u?OJ)3itLVwj1d-$|Wfy-{4~Hwv#P5
zOAlz-^?SGWhtnN}DmPYQMEp2xLu+nsZklJ1>9JdSb{JP!oRG5nGrsV;eciCO=X7R6
zvW1K3{?c-N5}O!JanY52K*UNfDhY1zb%c&?Kj0;032*3z5+=Qw8sT@uoyCZY3>dRV
zKK;>RL0sE-D-w-=vNe63s3G<`EwS1`!{`|?m6mqwl|d`*N^!@Vm(kut`lW@XnSC|O
z4bi)`iC8r8N_2nR_hol~?*D*LWHJHFCu5Lp6v6W^$1H4#8Bp#L@GPebG!O}5tfSG{
z-=xTKq1sIh3=7(NqI%O^z7Ak9W4;Q8o6J;1j(&Y~*M0WpU;lyJq`kDiZDXy18grVN
zqniH93MtRY+jZSy+S83Mk5Nwi&}P5=HpLfskaXBc%t5yg<X_7KeEFioaN)=tH&B!c
z(|RgM+GzTO3vm!FcVQl#`FzKX`)@6X|H~!2mKDy#&UgBwcr(FNbnW8NeT|E_eRPtw
zo8`MR$9T9(BAIDY#(2NVSUqtZ?cA!{Q3kEap`yl~35B#5@>a^3Fb1>q`=Z=$nip72
z#Jb65Gz7TzuL(xg;Ir#X^EDb&e_e5G9FXRia+>vGON_&qa>x8}Iwobjp*pV%&bV_c
zzn=&{>G)w{?ETB7Z?-5S$^CZ27}%@d<*;d#KP~R-+0T%lcTKaii-X5;JI-!AGp7_6
zUJ(Gssvhycg;a^&_>hXv4f2EY8B&jk9scgk>U6Y?5Jb?HO7uK@%#mhO!KV}IYJ-qm
z&q(FfnmR4fwTVY}?SxF1rOEXSG(&n8?Imi`^CZ$N3qcpfz~LvN7&C1v-eLRBL$xrA
zA}rjf>Yu2q)=YYqAfG{|BQQzM&3;xV7soN_FYxK@V)K`?Piee9Q{Hh0NT%TUJ?a4}
zPMlvZAji&d&Hc<MKwAUKHfaL;X|@O+J$u^@419LdB(SWU82Rr{#mnk%Np>i|@&Q&9
zA;6-VR=N0el&qS174O5|i$aOvBd{Xyq5Q+r?P6uS_~E#aU(_niglJCSlec{pGfr(;
zN^I11>Gr>SN_}~8Y^~Jf`~uPL{8pXX3iE~!EYrCSX_gyqATP1KZI?zztCBV9-{DiF
zE$6%M-*gjcvYM|uqLOn9vwZZ9&(7d@Sfg9Hv{!Pz%^^|Tm2Gzoodxf@<zA`!v$^|3
z9$&0L#@7>$_LVj#uafw^U;__y`yx&8<E$n;R#P2a{BcaSr9Ty6=Ca+|ObW1CHhJ?i
zKY4}-($uJ0r7fGV06L;Or9Lfo068`q%TBahlcR2m;-oZ3l+A-Ow(erq<uq#8xOnu@
zqkN@!3pwtC_b`cB1VP$`KgZ@}f<C}O9>@vb_Tv*endA}uWjG>^u@Pl3dOnx%*vU*B
zEt&=ob9@)fTwPXi8+CrN4{WkK*pAH;vR~0CCoAR9VLxISa{$mCZenG|IRBh)4Cf+V
zwHdKj_sKP1Lz*zuT%6Y5$H&K>(cA6qxKD3R4;QnB#O>5sYoA^HJpV;u^i^U6bta-2
zEBwt(Z6m+Q@4xYxmZvF|CM8*9d-I>!p7HsPy9{-}7<JyRjJywdcV{(KX;?%NB^{{^
z*Vti@XZ)~RmxckWym(8Di>hzY<BTbHBM~GIvElT_$KqBZj?1I1jbsO6*YW~+R|RHa
zS@yOgy7)j~Q}vq5#>m^7<kU*iT3$IYzN(#Y(`c%SK<AF3mqSr7GoFoqwvaFW^`+5=
z>sm-4_rxgjiQ47#y2zI#=Pe9(sV?&g_zUclcBL))*T*C?0A3Fn#O+!reKVe)AOe>a
zq)rvd<EyY&zRf%ydoTx_?~}1eW{ue9lh;`DrllX7={AYICslC_ybRe(4Ad&U&Jy4T
z!7A*bp2qF^e+-4*DNRUKDs=<$JrsQ~R1H?k?_?rN*t{z&gc^^MKDO^_wFvb2HxsFd
zXvby>Xs_1xH2+i-i7e)!6RaF$==1j16j29d;;ZnxN-Pt6a|?~)Zg1^2*0$gV>Y@GM
z`YM>2!#1<Wi1PAQp}c8C;WbmEiuc#c$*Gc8Z0V5n?{IzQ9t5F@(L?q=bG$av+aGbz
zThP@dA}i>l+E6a_SZr^!C=4AeP&a6AVwMrtrn)hx$s0AMIgjZH4$oA(BsTh3Pt(QU
zn;!=<_0UIgJV##LXg%~JQTNzXNDG8+W^~!ZRhz;6YkA8YF<9A&x~Zv&`$nmafxiG;
z-fAEVqz*mqn=O?<2R$n1N{{d0kO07*Y-z|(`YeodBvx#eDMUf4bcc?jdsGJ%s<X_y
z2p&UDKF=D4AIV71do`x%RkVKXMZU`PnZDt*v_7_|dHZ^L`tDS}P^e^X)(fuXW|I%;
zG{J1Ov$gS#{}`dw)5!}`<|XrN;`JKK`0IB6h&l7|vs2$Edd)tBcM30h<dNNE#1;@K
zdeIalP<DtcY*`|{pxaqI3|h7LW3*B}vk?pSNiqye!t<1Bu;9@+SOqhCa1uL@pa{|D
zCBQPGnyfMMaqZmj8Rz{Rs&pYIy-=v_lVH&bLotoPwQOzT5^2cvY2qmdPI^-QniO8+
zmaEIVHu7$Var;F4$moI)PVtl<;0l1+B!IpPV^rxz`;kL2Z!~~7Ix97Q=2v@Pm&wFZ
zC*2ac*3ZcN!*=-zKEs5Ylt&GmDnEF$OB%U!so&#d4LJ#aSb92@aeHbdG%~7TJQWF$
z#)c7;5(vp5c#s>>TP9)357ZJ2N96?43ox7uSA-N`D)2E0mMpZNkt~x6q-SO(PV-cr
z*MMC+i<`fi*&@r7+;}Xid8X+)u*i%}@e!Ma+P?2e5_A%%%%I^zsnW3>sU1$1p*=`<
z)rIe1IMQa)y19?8Wtdo%gLl^^CcOgg<+#kQxuEC{^e0C<VE(kmrfzg6B$XghmR8Ao
z39d!BaEv@WZEdw21_Am|c$huVkXZKE1*1kT>?l*nlmKPvm{@kCF1HGfHdX5P1Mh4Z
ze%y(u!|&n6zL;N~{K-z@WZ79kP@Ehyj6RD&A3Qk{dC_uAJc9qCOE1H)dz|d7_CcTG
zRqb%$T>r;Rsj{of4gnxiI?;aHRy>R5*4Z>fyo-&k+Wm6xrt#mSShcWfD)JN==cLOi
zgG@fMUliZar8Y_C@5bNE2ich~4uiivgG<4>ssI=}B-Lp*Jf_63F)x0pq2>DWuDp$V
z{71Hlp4!PiRt4#J#hI=2qNgY3mEm1(&gx5N_?^*@odlh4ppKO<#!cJ`3Xo%quTiJd
zy0{6OGWFoVHF<WRlBk6BrH7}x%a561PdlV$HpZpF`Qn$i$JgCMN+Ab<R-7=lL-yZl
zZ{F|ovso4Hw`L4NrZWPU8Y-A-{yf5<sT@g=Zg|wmBpB=q2k|L4>(eZ=Os+BMq#)WE
zd2<!2CS_pMRIPjlBFPwRT>c<yjUAu3<l7a~^ck{Ubec?ru@)rA$K?meyDLf5M1QA#
z3tmC%TP5P^qx-Y^ne@Av9`$=Wqb~A87s7A62=A86L_UMh;B^M&d{wNgGVSWzczP3y
zCA!YftePm-FPCSg&m0vB_xlIhr;&@(UeszoE+Jd@3my3R8x9!NP5=aLs081*vd;Tf
zyiJ&*ebUfmQnP$?B%I<z_QK?skNIa2Lg)fIkg!l{(orAPJg?!^5KV)g<%IriTDX=l
zn<(b0D-O4R84f*$uDUUkJNb-vOft#*Hh9qhyAle$MnyB~>{Sc{u(&RI=gmhSR~{A~
zPi(1v4=GPIqKhrTa0T75s8SwM7OqfgwIR1t3BPlR1`k0NUYUBToy8+jQa{Sn@0PnO
zlM-s4agp*QHbW0vay#=G+B<lQRr{8{8Kvb%b%pnlmglJ^U{Sa6N@F*Wv&2f|@XhTT
zt*nRt%O)HDt_cS86=2Gi3WD)T{C(o6^Q(Qc7M>yQV|P&gE<ld*+V=W)&|5e~n=mI>
zRq@B*lL4W$ii21XqOwc|eLGJ_XRo(Ef<g6j2T5j_mrbKwW$7mzxIHl#K^R{&Kn}%~
zTr1odK$_zE>btN+qGxmTdpx~B`FBQ(xZl<i>3gIqEy6jcrCirry4F}%cPP^t-;YiS
zl$G=MtqaR)VMgUTI|M;T+wrH*0Go@@ZsEK{m2Nh;t*vOK<jwg{feX_EWY=lW?du(p
ze&K_yrqWzVovp$-4v<K@(+{#2y|U6>N}!IR?^x9$;jLQ>VB=pU?Ycfy%s>PSk#;97
z2MDh2?Vb6)hJ+I9jC5GJ+bjE-yxIEG^y{16$Z}2kxbyOD`GUr?wm(ABhz(%hK)P2j
zgwDV2xeJ`+w#^)LkJg?oT2m@f{4lCZY!@&7l~2`huVl-KUB5o2=IP*j_wd5&b8thy
z94J`zQvRS?zOZJqPw3%LIi+)B(iK(OY;@@RtpG^P(9U-=({^2nRPCOYvDLENQnTf&
zq$IcNdMncUSwOq98{5aAdRW|6a8;<2C73B>EOSUf=$cXD%;MHsB(0Etu){;x9n~r@
z-u89=aa%Wkz^VK>Zv~%3F<*9QGVHiLKoCGecu#Qp7yHO<P53=#a2B233SdJh#>`e)
z)vvJ^5&&65WPRu4&v%V5o==)(&)kmZXK+K{#T)gz@%lt0l$Q<@IltM{5gW<3A)OiD
z*h7*h-rLxY9l?TUJg=W|f$VCRAn*MSi=93>=k?dc@)hB8KABtK{M%nuBwaZ@`gH5l
z(zD)oCzRxn|M=-Zis?`6`doQ`|DRa#VPay9{KFsIEXJ{C#Z!UfdeucswH2bL?O)}*
z#>y9%^M^U=?)%pMgsde4#ER9}jZqHT;nMps@bs`Xy3?>bzuFU=(fHBt*FVw$j=<$x
z^%)U%@*39HwIc{~g`zxBr1i2R`-_FL`TT2bsWq(>;eZ;US-R)BcCY={g2j~OU$a2g
z2<(?N1Qyiyu<@Z)-=;NR|D%|z;I>uC#t6K7={MOqoyGgDqfziMh;8pm^lZ;WqG<o{
z;o@Ar(zelVdvl8)DQIMtZ>pM8Q%;Dyvg{vPPetK?hXK2B0ipOBLygYwMEC6#oV4#q
zx9Sk!+3E%NV}$ohC`^{EDGbA^;2HC@iL4mtO4<=66IKl|q4uEBViJRf-KwqQTI4e$
zy#HOVw08cB7=~5V7_YKW0YZ|c2^f+eX6Q}C2-7;})a!of!2v%&Pt2EZyySi)HiAZ=
z6N}H}uyw@-#B%jUTi>b#{E1v!6W(X?b6LbL0ke`lm4jC{{&AGexiP$ANx@;*pF-zv
zN{m<9x5~r_9w;&wAJc!~&6G^lrX`lB?ncZRsHO4@X)-r|hrN-meClA(DW!LbEuI>Q
zl;Md-!^3lPvw%#(yJGxwe$}a{hr?iA6aAj@eUj?=#;YC+S-4tK%nEzn7@`?=<aBaP
z5!FAS%8J2{b4N7H(&5TPWa(PeX%}B)<36hWSNfq-;t%>G@QZxcsk17`6h>4<0oCt;
zQ7i56?TxvSK&?{xp0V_P3$bERJ;)f2)${uDXUP<Y-37nPsjf*+pP&8X3-jxh>NJGu
zotyx9C6F6Pnf~^0c5|~U(U9Qkk#F{hH&G~k?DLCa<@w~SKz}E^0~kh<GGmsbl<m_W
z8MJ^qpOzntHaXIMUURIgq$Sv&z=CsTc_f&HGb-K8RMvH3GCbZ8{raoZ1kKyZVk-tS
z%Pqr@k>C=0(2;XuOZ01PC;cmJ2s5FSnuWu7+iJ;~jfhLhl!-j(%hi^&-Aq(kI-bV4
zZ3mE+N$EblF<Dz@*Y9F_(6@N#L!TB=q@0U&^|4slH`u`w+{rMzG5h266F}jRc}(U1
zbmvQmovD%kv0fGMz0%<8JJH0Lt<yK#alL|q&WUnqLPjHps;QzNj!6?_+5S_tKT0l@
zcIY>bU2T86aFXFg#;-QKw2R-rL;H3HzYuoxOzY*-s&CToDwE9_>Gfvb;^hNC<Y-~H
zWFQap{%gV3HN|gbvy^8CGPRZ@{Hd8J218?slkH4AH+{91cQtx9-2zItcG@hxJlHA4
zd{f#TU?OX#7*!N7D`={}00cNw4LZ$XMk1wrFJcXG(8lz%6hX(c;d}eZ>@Kkk$aHK6
z>^z}cK+4(GGs>LjJ7V&(?J9qK#SqSHq|f1-g&8x>32IDdEB$|ry>(cWO&d6hiHM-m
zA)wN&C?Fu9gh<yeUDA!z0!t}^NC*<Ubm{`TOLr|PAl+Tk4U#K;p2g4i`+n#5p6fdM
z=U(&79dq~0+@q%>B~Opv3cm6}yxl<ciqPhO;B8fvAX#<t4DZBb{Wp9r`^Z~lrm&2J
ztODgZKNi$pE-Vi;qbr;(ciY2pOR0>&!xO#&M%Z5g$HRQd?^fSlTAH=@;1tA4gM<C6
z4}hy`<B2UTNyMGVzHGIfDMHJ_&37E4lvApk9Wa~Yb&0o6OiR9=rt5>f!3*yPoFAL=
z9h|6s?`~gT_G;0j!%(KlU9vmS^)GqlEL$T~xE!_Y88WMG^ib-QZ;CL5aImJ>Af~fE
zH<=LpvL^=0!xdEOK*plc!h3Yhhi)JB^fPZqn=Qqz96ks^R9)WCxmOtdMKC>Y4>2)m
zi1_HF%~Vqnc?r?&033K@ns<GenPpEhngU^3FbpDm3AH|(J=t4;xi7CipF@FUp)bJk
z6h@0Lt3uthD{9A;6>CPx9fxYe!Ual4IL-Io78p+1V(*R*?+dSnG?lclOgoHk4spB3
zOIN)cwLP-c<5AU<;cpiUs*$2;yV8?z_Mq^%3^Mqb4kMwUwkH$+-TN}{fyY1*_S4Y;
zN9S+XlRHyiQBMi|7PKRH?Kiu$DVECB5!!5a!Cg0|puD+v5ZzcGvof<Gc0?GmZ@0J}
zUz2W$xBSEA_Tu}hSOYPGjI;j!(<AijA8S&I=sL6=hZVD10G@$2QJ5U+sZBK0o88oM
z=kYjizb9iDf9cAtO7KcSyM5YMn+OS@6T6)oOe*WfCxK^|UzuQUNPE6;q+2K#C6PD0
z-$|)(6<nWrdEsuBTy{S>WtD>&(CP@Eegfj{7*TsokIc8u%~4okpSDR@;Ahpgx-4Kr
z5(W}l=$O|9a$Gzk(84ZFPD>GzsJ=o<EPMk^NP^mv<`6YBHGz1<3~8BpmKs{o)OFOf
z28s>wE7Y2{nA-G$Q97Uv?l0)wV#bxvw%Jaw-0*~|-J*V(?cya}-c65}kJiA5mhofJ
zd=uSjKQu@_ua^Hfh7Wwi>o0$Ke~*nLopI6oV2@2DJ%^0|?@Isuk8?A7dwa9OhpfK3
z%04Q>7V2~Zy+!Z)hd40aB{wzT4cmRW9^-{^yz~r)6O-$Mv!iK<h3L)^W$S}i;-7uR
zpn5R#oTrB0_=0(RtATuq9}2RZcmvj1X<G0ZSC9MR7PC7WMpf?_W4GAfj0%_V(<Ag9
z*%+Kubd>Z(%%mD$M-}ISf0B#LHnUa8fdz}P;kFv#YYWvz8tV<*cj&|2(B;*ex3zrE
zGZ_Wz)ydO$o`kEtba<Vb=!!Mi&wR$J8b0jZ=o!v=HTH(;W5*(@0vNFS_uva<%nB)w
z_MzSq0*Kz_W$nhFboMH%p7j}U=||c<b{kaek7T}`?E>;ZF-i@o_hy53j+bL<s;|uJ
z{dRyDiYn8_-%##C?(IBZ*At>N9^J$bsHJ)h(||grZ0+qx0}-<}thr@&R(bRw^2_eR
zwAu8$D<;hUdGncSCcmQc4|L~!RAsgKbNC*7wm;isyQ$?v$gZEZjNUr&lKaU6aYa!w
zD`)*@>VqU<mQOMiU}3)ZZm_(@T1Q?Xi%5K6Z?Uvbe%ZYqq(zQp04}eWsIPKjJUiqh
zg74JMk}K|yx_4R>FE_zFzeG}Mx@F70xvi;zD1-!s{=~Goyq4}H5%u(fMVQXvN9Ke<
ztxZ*X<|wx&l65wMCwJfRZ_g$#fL4;n`m^Q2S@<{MTkmh{pE&|LpI!?7+1S)n&l>G?
z2_&c@u4B3xYrvz|M^^PVWY2mlMsj0jz&<QtZ_=&-JK}tq&V^^<ea$1C{7N|1OLkWb
z|AnWV-~nLM-9A6pE6m~GzV;GXTTvw=(nnrh&fCS)k2-I%>knAeg}xL4x){`u%$9H(
zis?<X84Ds_Kj*#-Mc7B3&n=4<gvC6&OUD@o3u13(K#_wz>GN3(CiJxjcLM>JR>bjn
zb+xY8T}wtHxv2)6AqSlBM!wQdSf<_g_#yK|Ap9Do_<WwF4hab)d!RU|X2y+#ZkXTf
z@I>5K<_R%ftkOWq&8>ys0k<<>j}%0<@#_s6ag;OHzE(X(<lc>Y7`N`zMUVA-0Y~p=
z4fsNMIyTBF1=rv{8Z%9Uv}Yi$R*)K^tk4{pf7G-h%1aTsxlXVB0HYvpmO*hT!qwvV
zoXXqHrTV*UQc*FJ&R{Ud@moD}PTt%puj=@3&2wFSvtNN!_)H~34#_f)lvR4Ix>5ct
zxq!Vt6|H&LB<<s9`B?<44te)AbFWTkR5$}#dihq%rn@jC;ENOYRmU=gX>|&9+jrMr
zc(#o%ryt0BKUXu-*E9I_`P2%+$s6FCh0$1W>z2Wkd-eOaVi0=k<e2g@9k-08$6Tns
zY@d#mWG>k!jXZ^Z@c8R0KL;p9#wfy(&Zx6*RmqOrZ#tFsvWkkih_+zCC=>p#<L-_?
zY)wbneQ&c}^m$EY=5b06J{_TPV=}us0_3JFx~dbcs_*fg#{gcLRuS#;VRnhA7nGq7
zPO-fCIlcaAL8Xv9@7+hJ!2Evxjmwlb9#O+fP)|Dp<*yBOb|!O(njr4Gmn3;%B(i_r
z<+YFRW-2?7j6R)K9gscAO9{&FDALROoWp_faZEO&gI7{!fo1)!OAFGV`?duSU1=Aq
z7?TrsKA=c<!Y0(l+#UIs<_1~#1!UwUl5?yDm7hIOHj~d48T5>N@p+;@*)s#BTAU%)
z+xqBCy_MrE)7;~>xxAnSyB=cf)2Q7VX?>M$JpU=)@(Uq)r#$8(pN$?nB3w`FCb^|k
z>wQD9z+YLE*wvH7_9|WWXhH)$Om5~ZmBD)WebOtCsv=>!+2h@+iSE5ysrPM{J&q_%
zx_!`|eMP<9^PoeS!U{EOJufNu(qFUIT`g+{bLswY|LPa|aa5P-Ah%QHR411$Q|TGP
z1ss0JPda82N)ub?%Q~S}J5C=#g~ekzhI;QLTSr!r>mlOvwT~ylp4=mOx1y2<ToWGv
zu8ALyPC1~#h$WA9Voyir3GTy_jQOTPwb6s0R6w`n{-nW`JMBZ^AF}#BYD1?Ba6Q0%
z&rJ57VzlDYD`!|~3)JSq292!&@%E0=cFWn*lnD0;gTX|OKG;f3rQ0M$@U4blPv7*u
zh3%o&7{WwI5ZfiEs3>MGr^GI*b38J<r_nE5;Wyq(>cP_CS0YNH0EyKxLE}-8jG<h>
zAVdqM{Gp(-|0YFsIW(jNgv7N9kL18WTc_LF_be=E@E?`r1#z6#$e!?A1Jjh$2GLhx
zP_B{ga*$o1m}HF_EiMAJ9GKSofEncoSm(J1g-*9%4sy|4clLQENNkw<&OpORv!6u_
zWZAP0ap8CdsX_TA&YPi|VAq@3QJrrHvHO$quMU>U-yMKZecs{olXt<;P7aRWC^GKD
zn7qOElR0+Y{A-x(vfk!&3D~Bl2$Tz@CiF={td<Kh)AL1j<TdPUFO;7oZw}q3qR329
zVGNo!7zAA#1fJ|gt?p&9KX5=cw@8UR;MD*JXi8pj)eJBlDt>mbq9gINC1A|@#<4pG
z#SU-xtJ-Bh0#fFLF9IBFqd!tPLtpukcmIO+TFPx2Bu)d*y?aJoN#zd_2J0+wVmQxA
z<x~fiU}6*I>CteG&O<p~DLa;#Wzkw>=udF293|2GBChYbXVlFnzM=G-By8(@?g*XY
zEaaQ7q72G$57o91QCS?Mk`-THxtDKPh}iR&AAw9U2E=c3fSv5ECn$CARiR(xrtq`Z
zCB~Go*C`zKra;$3S#&9xV5?0gIdyU5u_PF<)k;|js?Wq=Vr||!&JJ-CkbBgC%~v@F
zMATkox~{^}P_&_Od{!SrJV-b_O%4o!K3Dhg-3Lbp^)lRFaAk8;eSe)d$ux(>AIsX7
zW*%g$TKJ`;{D^GeF7&a~PFyFneQ8OUGH94d`}|pLJ^!`6LaR)_FZ0>7tUCNjp<sV9
z!$<7ajP4a2m`ZB)yuB<A?qxF`xvir7?}YGO$xyUhUf-L@n!fpj<Dw$Z(H|KTJFbb<
zY6dG=an9B!Hw@^R(QN)$CGQ-1ax>%WKUxT5BjZ(LD)l1d`N8hK_mjRXAsyj012e16
zM=kCt#A?qVy~92Dn0+bDb?t7dDMMLa<44yLrJc!(-`%9~tFyn#Lu6z<fbLWGpyIwZ
z)U-M4Qefi|dAtz;TDgLaw*SD2|M_Q*I^s6ctZx;Kp_<>2th^4$w+3u8V-OF#ic$p$
zHpr*zoFUmrp8%)x(v!&nMvav4X!NSjv5wU%zRyb+7$OwStpQK-b>43Ljr>4fwMF{W
z*R9<v$>K$q;Ci@0r<?CU%>K<fimdy1c$ZeeRve;e(2AW9)EY>Zc4wUm+#nCiskLAq
z1B}Xmt|Ir+t%^6VDf^o7O54xxs<jMz?(0?{k!t+GtBbGX6C}u8{XhO_DI$M;TqW;q
zz``ube<nTAUab1%p|@LJ3v<QF+7D6MEcNV0Xlq|g<rR{s_a`NRT&I_|tMKsf%>6WX
zAO=Y(hIX};Bi9?nK5>ZNUecxa|C(2RrIt<wwpd*rF7n1zeP?zRjDRG0u1AoY4m3(v
z&Qx)cn+^Z;zByVnw)>mgwcG2}ebsIa(944WVogH_hW<x~?n&{PF~cRLrKtDQ+3lN;
z&t8s$QMM$-+3*_eyx|W-J|i;l<P}P9RR-;&D>rQ~<Ke{;wjaG~?3dig?$R2yKnRSn
z<%xws9UYue#Xp<8)4(ucSA&46<11njoEj&C_(YxxRZ~~S?tPZ{CdA3C|8k$HW<M`m
zSV1hg{Rn8wspIL!s+qBM#66gjOvLv^ly#;wg$vUsKp<LVpd7fXK0eJ<mZj9_?kMEX
z>eM(=#2~WLw{`xG?HV55Bii+&#c;}OsOL^yo6ee2j-~d(&3O9#+0DfAB|&E1&5EfF
ztDLpXL~u(YTpuC4=bRo-3mdj;aQN_hd-Vp)6uyeYQ19h5h^UCs18HA_Oy1VMeQeH0
zaN6zdc7}D@%QpMZ-Y9EB5y~Zd?NAI&;ZecdE{Rh&ug>TB$tIyKegP@jZBzJYkwfiq
z4UF$};dsmEwNJO-1#*-$F7o0(xpJIf9K^7aFo$2Xo{ru70wX$uD_^d3^%bH);Xa$w
ziAL?>#n2?$ulIK%l!M{myZh^@&p<#sXWQc+Y6iPH=w;_qgTiRHpZuvG>ir60CSyWg
zsd5y9mi8TU%JS_Z>W(w?9YXA0_P%*2K9QB+!9_1_2&@qvRdD&#nu{t2S-Xc3x!*y>
z*lOC^+{=%jG3C6j{P~uqEDSOI{lS@uNy!xWh9L+}jRc;tXa=jR(v{PDT~i7lk7&6|
z1nGv_wT1P>41Qvx=qi)myy>T}43t9N1skVhK5B4#JX16cd8Ijqs*f<^cf(2^BlWw3
zb>(aJ-^O?AYx&q5XA|8+;DpzIFqPo2sYzP<MD&MsnFsw~@)uA3$EJ#ya+<N6`A!gs
z6yCCDo&Qv=*GzJU_o41-%}i!P=Qk@=sr4EeiK%yo?$3X1o3W~IMTU<Ej!i0b35L41
zw;V6DSiEwV6AF>?O-wEe5hLHu<gLh4&O9JI2{ZGjx0jI>7w;K=SP<|kJme!ru;;@S
zJiIyuB&m;G*?^qek!vTzZBNJDDf~`*x+=H#38MY{>x<71syM($A~00OX@j!a`d60z
z39&)>z|NMrO~k>Wdw2IH^)CLe0LRe@;0(gJR1`@T`Q)CyfW497_hGK;!-5xqS2vfA
zPM7UcBU}K=@!rt{cM2S*m5-a-ac7tt=r!@jw*BS^-uiT!2v3x7T?n%z6Pdk=HXsjA
zUQ_t7HuHn-8L-=EL#M%Z*i8F9ij=GJX6b8rmr|C7EZ05uaPdKg=?VpSiyf!<CeT99
zuJHMdAhj$t08rg6J!uTXHC`(9D(dybk?1)IYz>pz!dtOH()+YU4nV^yhrvZ6?ECh<
z{xG|ndCDaMdOtH<i)?>;Rj0~}B`*+V99GT)uK_hMDRMj`oAh8iaY_B%Wi+|)y6z$W
zi3)BR-%)=jB9Twn$pW08qr~d=i_N=3*kLOcxu?=K+#`9`pq0E2Pt`1688IJE$LN#p
z6btCR6=9iwz>xRZy9l`bs;|a94jf$i6!~?}zwQoBMpN$+x+0+VJm3)c(Q2t;kDj04
zr~v0m3j3^Fi7hfF^z@rV^x5|jwXN5s57()D+G6uO<~m4s#wcf{#pu~2-jJY_uMywV
z=@B7KedG_!hnFRzkEACmfv&dE@k{y&b-n&vTsr`s8L|-1QbCB{8k8$~P;ajI^g*}M
z)!l`|kVPN8`MLKT%SxB^+ZFi9@E%bnZoEu3p&Jzx*-7NhPg>VS&qB>-Xz(-qr_q>M
zv86WY5cI=>Jqg!R8|o^zuOwZt(%*{V1xj=RJ12ZvoShU3><?}qx~Jkz%BI@HAwOPz
zblm{%4$CX14E>_O$Cy27=lh0^hot~Mqi!(9S7%Y*fPxkjOcUeX42lNNU^KT@L&#q*
z?p~7H)8bgAOR`4S()?a;IYaHW%;;DhSnOez`K*VxuK*Bk{SO4lSmLy=|L=)q|6@5u
z3P;10g3JIXbvxPNVDHovIuLs-SuTnA^yjzx?AU#&_0lr^vdURw><#j0KA*J5=tsug
zP!V}w4}rQD93L7CiWMd3MKQ{6u3FswF9`bGg)VL|B6p&hyRZ9m)%aj<m2BK+*6=G5
z-HK<vg?j?6D&tn~kMHkE#5i<&;2GB$7YNPQetE8bCax$|h`A3&)PJn43!)58ani&(
zm0KU;v3*xdJ^6N|zO||g*(fNOgMJ|q<%CQZ-P)Qweee8;ygc+2oyTz+bN1RYpl33q
zucSjkgq7%jFw$+yN%-wnVQ!0wzMIjCwMi*}vC>cchV!;PzV1TvJx&oN=V5?sdT8*m
zcY&@lisAZQ-i76HFN>95-uZiRI}YWS6@5Nv4!oYv#K<Kt=0v6lJ+!j4OZk4{M;X+r
zx5A!6@Xj3GR_SN0;`>-+&1!h`evC@sJ~!n_<YORH5^b(oW0kA@8ViO}ReGvc!sD!#
zzNLu}xNtuiRKaVmGYM*&IpgOsC9xy(5OZs7>L64W=(vfAWsuorBIPCNCM4kh^dvr!
zV_(uB^r4eo%^M;Q$^Fj^yGypev&%IS>G5BKX?82LohRc?J~n;t<{JMTnIi4QNPQeC
zZm6k5g$E59H9LnSxW(uUqzn(^d$@^*#_m9`OBh;FcvE;D=rX7tjXx>Med~fv2T<zo
zl9hBLS=M<q(PI}!3W~Z!_8Np-+l{>2N+)*blIo?~<0PtSHU{sNvs9YT9lx{G@v&P5
z^9g}hw~JNJrHHq5o(T=NULhV%-sb2{?P`q_Q9y7k*fB?PCfxc}a>%b_u%zL`r=Kui
zMqwNG+|Uh6fVXGlW|gZouh*?Vv@w2j?@+}t6KzoV^e*CP)~)Hq5eC<}*88iy^uR$n
zi<WstQq;#yrk;|}@-)JbqCOg$D=$n)!0{*IB&es{nI;8Bx-VNw1ocAN_ABKe>bcrW
z{r;^;wS=wjIeWU|2PFQW{fYxUCShl1k^-{~IsNVLdxF3Dd6FtVjlN7b5ez-=x;#u}
z#6ieBngC4~9y(1#xM5GStZw*;6-I}sbyDNa2wt?(mEG^l4jeNWxZ2)P?A+IrbhQ#r
z{U!@m`Pi?ardRqQ6%|FU9BGA>JeY%n#_5m|gyg36(;aQG1a4w|u0e%9`I;>!dYF^c
zr0y<ZVP8(OKg{|Vn<@w9@a4^v%UNgEJZlveE6`v?1Mj2Ucp-B+W%3|23Ntv!|J`i8
zAn;9iBW!u5aBo49l99n+l@h_q3b;A%aU{tW@ci__=Qo-5PqFF6|6NRTzcfM*E$dwp
z){|$N1CbF3^M_Igeh==VqAi}VR5nMfIdQx65uE?ZwsoseM?5cbL{xI0+6pam5{=l0
z#@IfX^%(9TkBU-9^f}NmMUlQXToJyTPw#xfb~wzBw7QJv0nbhWjw&KcCCUsKWHvwW
zP}-C0!3&F)xaDQ^pNpGFe(IBgABBn@A5?9P%l2*69v@Jf)VxWLUNnd<H!I#qG!vsQ
zk$qIpcjcCTVXWaV!49lDIIbApAsg+*E7ytlh)M#M%oW>0PRyInD4MBvIMOhhKY~=-
zlnxkDZHl;IaMyF~moG^LwR1gnVacbwAIQEa_XJH2-)8jQ&bPiVRhYnKu}kk*8l>P5
zr(M|%H*~?EIfG2D7^OWwZHj9H0}H$8ugbWVSPMNp>Lv`EYrEyRP`lT2>nI~Xvppi$
z`HbD~vw_~1@}4p(DeE_TKV(ZJxGs(AGfiO@uK$&!$7X}sQ4?vsSz>bLaP(NtWi^|p
zPDcn>Vv4|AW*ZN!zLH2ix<cDNQE;U>eD2W8NuZ-}qs0AM3IZJUdA#&eK4Sy|t1nNV
zG;KqMXo&C}>n)7YAwu8(l|9rjQ1-FkYcoB>oAB%EJ=q(Z(yhAYeo0T-TfPbr6mv5=
zSmsBTA>QSzUybN%DLb;V9tlpYH)?wgZo_In|2Sdcm@X01km8WUWSFb<eL?l$aWH?3
zSt4m5*ed@n0cMt^Ot$fZ@#w<CJUQu@KJs&ppR)tuzYVxax{KddU+Z8|fbT8Lfya$T
z*U&BP^F^uPV~=c;{=T9Ib8cl<A<V4^L}a~NKmNLie_E9{)Km2cPHnU_v9tYJ>9S+{
z4_X?;<1gd!ETvDK7#%d%w41U%6cBKGgokq#oHW45Gp2P}Hy;`}C?y6gXd%CArw&E%
z>FFk7MOs-x&c#RLg;vT4N@EPJM-q((dBroHGoGiMu0bL9YlR6K?|bW8U{~>|LaH`t
zrdo&MHGK=OVeC?Lq2BFmW-ofi?<vw$HYyJD9YMNy7{X_nRLVjt)81%E*THMle0Eqv
z6`mY$WvRV@)yZhF;Thdu4;XwIsY7^*RoSGr(tNe7GjN9{i(P^7hh10((d0~q4Yh~J
zQcSqaTaq8TuO?J1bcMU7z+=&`+J3%f+PsurJ_8N?^#rfZ%aQoIBYm(q-SSyQsK~Ne
z3g{Z2b;8#mNw@M9omZ1x)QfYy30IHcy#h}^xjp#uSUHm7!E)aZeIzyBjoDt|6@0vo
zm;#55dh^L#h3+r>{xpvdZgkzcAY>KN^@t&Sim9h8v^34Y$tIFZ$|??)^@H`ZLQR>m
zaV8Sa*6|DK25_M&K(}hVAw-_{dT_&yt{WF0&qBH$GlWktQ5jL&NlLblq14Xw?>XL$
zAB-G@$6o@Xp}I?-CdWSK<2>i(3v%s5EaJjt>_`;yJ3x}S5j|Hc%ODrdODa`l!iAgB
zZt3~%_9sQZyYM(`He5s%{{lOtG|cy8Bk_hyU_!3hw~a*LE%pN0M-6=HL_i9L_kwhJ
zYHURZu;HZdH{bS`gcc|5cC;`G5a@6dR#POkYN+<VwX2l80StXd+=D6UzwqQ2_{7CQ
zlxQlWQpXDKTaO>w3}%;;Pd>Pcn-l;4oD-nHs;8~Dg{CY=jgLUbR=xUpB6ug$u=aT3
zOL)o@OZRlB(FL~60h>8Vxq$JRum@!hD}9i(D_6wP&)zfD+mfDEoWe3bz;k<PI@B9_
zo<_t#s!v1o<RWlPy)vmQq7PVziaSD3PJwy|%{}YJoL;^*`$~_W-$O<D-S)hFutz}!
z<*oR6=S<6miYq&By$<#YU@VI6=ctG>vNb9I@mMk!hYi5t)+=#N4qpqf%Nkdy{1UME
z)+Rr+Fu|UME9$X#e^)Q|OmRnq$oe`q`KnzhQjfkqSk&8!Q;yVtpIS281enH1?GK~y
zL?~@L&rO`o8s!uC<XztD<&v)OshH+fS<bA43@cXovQgV}m$DOk+s1@r4=2~=57BQX
zT%Ob)3VI$*=%{-87@rSqMGROZv@Og$KFIyRcKYjV>$<3QK^U<3?_^(IEbS45N4sOv
zoOaRkO~-S4rVvaN+u_viA$E*l$d1l?+h|NV%FbGnVSH&0bN)Sk`9UNh{NelQ&R*<7
z&|!(vT5?osuRuV1qvFt8O4axuOTeqxS}gz#b>C7wZ8C8xMrX(Z)2V3`%x@I~xhq5|
z8W%DW#UiFJk6Wy-^tUu8*9iJ%DoyGf-7e!92l4nT9lA4!vBaDF{9aE$`glnCH*;U!
z%aY{(z%l7e9;3@%{~dK0A9x1<gID|qjH}28a>6Fx(KaQm$H!6wVuc8L{T0Dy3N90d
z8$h34(v33fUwxQB-2}UvloG>U)x65Kh;c<hO55fsmuQf~DxncJ;c8MTQkUL-=jEE^
zLSUYPLF4tuWH=C4|AP2BKxb@mDGO)$M15>FL`@>aPfAO&py!pUlAmfCbGiir2-9rD
zrUKov#l#Y({FqyVF&i96vFaSr@5_P&!glIq&jlL5NBg@L+a8|hht3H_skLV2C-*<%
zvY~f)7sA76ZxMUgZo9%+vhjkZBD$@uFGo(lR(F1C?Rq3?>#a?(A~FhT0sv7Ct@to1
zWOlE4EKtS5D|@4Tz=ouFEW_U8`}#iqOrn{g_$N@Wz(U*^$;$Ocs+%}UE?>x1XlYWH
zKv~b!g1IasBIf(>Wb42xg-=^lt2HxtdS=Knp)#O{kzwnU)Js9`lfOve*RNZRx;di>
zI(F)%&-K_PD>zPfC2hb*B?32T{#Wc7?JVwWkrWym{7@_Qk9d`PDEa0?1|dcZqQolC
z1h!+&@M+BH7l4f)b{)D;v^<T4CiB(&m{?z4miNia&{EEm?XgZMT)4}3@PI#xHa6~X
zdq2TVPa0?)v)Op8Y?XQxBgoK?{l$FTJMQ#WB6c^~m=4J3@uK`LbpG4MUaW&G1*?2Y
z6Q`<x6iu9$LsN&t7)>$b<KwEpZ+*HfuQKi0C?xW{s-;AS_Xh5l8d(|3Hx2jpYA&p(
zvm!y`8M5o#BWMszY+E_$>2AL+kD7<Mph=z>>-2MGhXu~95>Bx=1`o_yrl42-xi;kJ
zNhvY5R^9Z%@UZ<clYNkn@DecMr0Uu1!vVQdubDO!r`;%J)dGu<jNQCR?aUBBVL%Tj
z!&c*(u;H_UYx1PZL!_&#%jjQw$S4rXuAk|EEAC!W>|q$?7Kyo!0@;dT9+lxwy=>qK
z)?flwwY~1zCe0uP?|nJ*&Kh=2vss6caQOJvfTAF7d0z!yu)=&yhzt`s^>p}IuXO?{
zpof<sT>RYq1}}x}6)s1<p3z?Hj4S(;Zqhg4rUOgCQoC?pP+ZW67nHX{VO>_iy(zgo
zt`)mQ8g(e1B36CAJBZFREcZG+VwzuXDSTihyX`*11|-YCkL*G*05eW3bwBE%2=pkD
z2-W;s9aD<bxgol{Efy^z3fzz9FHqRnSY1B;rP*qdqojr`Rg4;uALiCX1O++x$0<KV
zVTlC&gUph(urrgTxBD`sBx<3|#RBI^JDld<X(|6m7{wpM+TZm)KR^)ZPLr3YXui~M
z<Oyu;6)UEh9q)Ct9RHFlMRaO^^s0uh%c6L~YHlhb{sV6O$&<&SoXg#Y^Y~l5JkfDl
zi>+5qs8foRwd9gG6t&*`BS`ucX1Nvx&EMBD4r5$o-jYFCFfeZg`rWUXRW3%Bd2%~-
z%TX~LX<mI)&xL8B!biY4gPKUW5<BR3gZw<XT9&mK-*XMEU$XIW$i8r60^ie<!_z8^
zb9(na<x2CgC5~-9ftwWI0<)I`dccYAV(lEAO2%h5MWd$Lv?HbrTxMFc2t1_6$#hDU
zy8&4ZArtWh8dh+>RF*NkqBy9nW>u#6d89oKc+K|wjP!iTX6M0ip@n&2haqMOpVP2*
z$2kU@H(d=JDF+}eljP1V`nBy$eB?!&hM<}RN)jwAV3r}nTVjF%A{o|e_15|Q?neNT
zI@a!S8Ifz|9sbpRb~m}lWik_p58XSL*OqNkks6=#dL_q)Mhl+{fsf8)v-+e&pZIhz
zirMLc<6}<`w$`1o2eRhAjDC~=%=@w<5(l#Bsl9}p<s~+Nqs(YLbSqr3Qh&SO7|7d7
zY&BS?VjJePrwBF4{+WINSu^K%k}#+j2!PY&7os_{_ku?{%f4lP%`+!CdELvWVVoe`
zPMpBruqeK3c{pF|yYucaGbwIsdizemaJB3f?b+b_4!y)&9Am#SrYjqs4vzF<H}}<@
z<{<IaE?c@)0^=Zi;d?2f-nIx?p*&g-`2wM~-r;^MYGk>$-HOBJFUcl&f^?GeCUl~7
z-YuY&Hs>RKe!wVn72dNll_(TjC{#FpggHL}Cm#hJC>Zw1)UNNy*8VuJk+i^h{&)B4
zIYu45teCT=cE7H$ctm(RY#iCDm#@4I^|H2@(||)uc*8n-#V}D*27_`a*AcE;M(*Rn
zx{#i>u-ts%0e?%SIQ@LLqZCM3jbzfB6E^*a)|Yz+M=sz~xM{XYSE-Z`0)VJ!Lt60~
zG`s-cPG84}1YAx6vBTPtb!!S@OhjiR5f3Bky^nIK_OBKmA7Glda_N`de^0Kf%z>;F
zJ`$_WW%K9Kix}Tp{xfsaT5dG$y|l)=z|4>M2n)7sJ7ZWEhpX(NQ)B#qFX^8t%*{Lq
zV#!}MpiB6A&s)^Hh0%RZm2~H3>F6q#h@~06rk4IMHVxY=P&t(82H97x9Uqr#L}AgR
zIK*39=4@_ra?W<}Q{&vvJM$5J{=pa)tB6zk4V*Jv`81+l1zZz7<AC`OS}rjyudRrv
zZTuJuP5h#n->G47p=#D2WD1OFd(_pubE@q3;;sPJMVHPele9fLyyOjsRx>bhU0wFb
zcv$?ZBIetwht056LZPBePiG3Jhe#?k`Kou+6tT<4AWG!@druzZ86_kM%f?uf?m!pk
z2Cs)3HwmQ0e3Ki3`<^U#cD~mb2PI!W__b1Fj*gFM;kyn@{*hV1lNs{!RJU_G6XyX}
zMm|k37>dhV^c@fE4}7VmLKE;eFS5yWe=F-|rVMI1**C`)-6h=#E@ei6U}nHGPlE1b
zoTUU9Ch+MSjXWX1$yE-{xYUaNno>yk2S^hMaiV=Sns=ywZ76q8z$_sQmQ~m$YNF@m
zHN|VF-aR}fKr?c0VHt^Ro5_Ssxd|If81xDVGT3BWKUgNFZwj`PV32KURJK7??8jfp
zDP`BALvN;(DaSkL12o`ShH$pGnA<1urs%pp^WYeM%+<3rlshZ{P6&HpKU2=Juv(1Z
zIQ_+{yGC12U`*KUVo^+7W-uPjeYLaxt5(71<p)3%GkDJj)h`f$Zrn^1*)Dmh%)@mN
ztg29~2Tdcibu^a2B3tvUIU*oTDZ7g(=KMaGefVn}$La5*PLb_h!7ad<L<@u+?kt*c
zXxEyGL)9TuD~=J0{`Yfk4SYVT!-zHJ3=5bMzI4V36l0}4iiO}5gYK{@Qe0U5<ZiXb
z!%$L7I}rY7S*`<b`@N|6HjBl=+qUF|bZnw-hpxtCWDWp^WFzXM9ZOXK>r}iNs!!RW
zV$h-XQv*81Lo^|eLCkBx)j{gGExejzt)DhmM?8i^UUX5$lUBqwY-g_z6yNV&GL~Wc
z!198ruQX)`vwnMY3-wqgv<=?<y^ah?%Cp&JA)~zzXdTlp*(yGTFS1m849}sbAE!6O
zfpBHNacS6!X3WqRVWvA(dmMeXjC66cuq`1tsAV=ukZ3>9mRGh<mz#F{5Wt~Wy6JEZ
zg_U0MF!mKQQ+#n2z43x1?r0T^B0_~UG>6!3g?FmbSDAfsA?^$l%K>En1{9|d3B6!7
zervKxXX2-087{8R&drr`#2vTJO-tffQGXIMBJBmz+@$i?ByC%}De25jtPe`Wd?F2f
z+*v1lTb-wB7n7(AgF5TbeM&kft5987QA>_~iQOt!`<qrH!71W-ZcivLXvOC4;Bm0b
z{gCo0Y>?c-xtAP7D$l_Cv|(Xwn04hQ5A10tjb(E(y05Dh=m_r2T3i-5Xaxk2sTV^3
zAc<)(uv>Y3+I4F6%sI7Npag9ar^hy3EWdd6yHxh8-5&|kl8CE}v&<B9sJJ4{R$EK$
zdAb;6BS8;8Isor<dv2b29x>HGS!<7U?bX^bgv@JZN8Hro1KMy#;0a5qh?=`75F}&1
zG7jB$yJ7wImfCb48{Q!nt*PACp&1BbpX<`6O!)e+y=ydKE9Ge!U!QeCLqIA&PAS>x
zm<BzQYiqK7SEig(I|Z81jX@rB({7z(j)19Go!1!95bpbvT87OcD&kv-=jq&1-!5Rm
zzZt}LPxoo>iW~>EBb6skv73WvL54F^-`bdIrx|eQ(zq;#xXwXk3A$7<$t)m-T<jW9
zJS6p?+FIf*ytidIvC4H6yKV7pDp351q?i|Q9+;HNHY`|cGM%uge7NMpaupY_ux}q&
z645t7Y98k>fzy#w+bUnmr_@o##4e*5P}i$>ZCX)7<9SUgI1RsNqI|ght{<y+c*;CT
zihWjdH_eCPu-2hSuNd2EzA%WcHPe`1>dO&vJI7L5gODTu12x=7f$&FaSNH5xcjo#j
zlQ$xcgFM6M_tD|*vD@)VVBTt(>KhD6ENO1{<m`sW<agOVXKl-3#RVR1i(hP|yPa0N
zNUeco<5VN!r=uA@u2+)>B_dxbN@3_Psta#po050rK@&E)Cuh+!-pabzsimautq(V5
zqpBl-2mGY__3M6?x|VXa)Nm|FMEjlxo$u~*3j+5YNpp@?MR{HJ_Br!D?49i=0FQJf
z<(qlTL8^Tx*^;ui3_vM%a&E0OfF>k4NOH<Haplb*UbNn`EKuxTy|MnPxZ;a3H7+@j
zEX+G8uVuNb^!$AL>sygCOy0>E1!`?~iC0f=qndR;0hU#B{roi!2^l3=jV}o*8f`Ll
zB0cbP64fV#t~nJ!Hy<CcE56JQ`AJkD!VwWlaEwmMI7$rlu-hLYz2>P3Wbpd<M}9a&
z<RxVXU#YVvTv;fkE)ovCNFHOa9;+5sb8ro-1T7x#ifU^6ZgPsJ;ZHlJ?Z*$(908_r
z>2}H8>Y-PvSMzR;J1w2TGp+jz#=s(x=QHNs^EtBTUf459o!_ss`moiYU;S(Ifrit+
z@}vl+#;j#V=)gwDUMFG#w<Jz?4vEAWEqjP0nk?4}6}N?ZD4qvjlgF!celh%?N)5|P
zr9%SQeK|4%k6GBw+D*<{>`6gp@hrF7)tVe6giNOW1-OKfxm3H2i?cdg1p)Xt>Yc+P
z7jca8ai-7ViS)^_(5d|zLwmz>d2U0(q&N8@sE1l*Fpy)^Pj!9*52&qr4e`@!;l}kO
z?>6uCl>DhNy_3x!_GbPpt{6Q%TuU;EJ?M|QZRPkN?L^FLX0x`|gE}p|`s4bv;WwN7
z$|oJrIrHhrf=;=~G9`z0Cn?XDjdZ_ttnt`ER@L&*rp+u8w_XYLrZw|;P_Ly;fnvLG
z&z=8^%=ev`u!cq~zw2-BQS1taGOQN6@-^-_T%1=?#uLoZ*DzvTFmVnKwbOXGKcEF?
zB<-g2&@5~;@hRp76^IDGmQ)<fKn?Z~cy!u5F{h(4S@us8!T+<d1C(ZHenC=1*#c6M
z{q1M=TSrPkK$H^3MK}RdW_Bpjf1C8i?J1Ls3{WY{pb>tv+;!>C&LU76x=wLCAgSj4
zCcAmK|HAj0B@oxf#3`2q*yoGTkW_vJ3Y+RgNsnBX-r+vR`4@!`(s{r8l{@l0PQ}U~
zfL9%N+2h-#GqLYnGx`4nW1sg(8xtn>cQly&on}f}>ZO0h>4ru)Nns_OHxSp9t>l}s
z#`AcYBEIW={^$o?4imtk?$XecbOopoUQ`1g-IZt-gG7V2rmZ1+Rwas)8I5p^O{I1P
z%G+Z-?4$ptB~aZ1NwVIW6#BFM3DBVaW^lA0n=xQrq)@9{r8G`vFPxrh=58oR^>RJz
zdcePaQg6QQ$|}1b0E>sgSKM#`U4x>`&!SA8!lw~kt{xTEMAu4s=<IN4{hy1&$5nYP
z)yKowN9A}{)M10hPQ79UXuy{&R#v)0iVlCLVat~F;om^^*BjFb+xq}PHDuMWYAZ({
zurGpi^6(!^kosoBGjm%o?^=Nf4aL8%QlL@O$n?fTmFZep(~-h@8!V<|tw?brqcMou
z6KH?#{KO2X_!#DqFn(o8C#(AUGEHO*Cr&*Cl5WJyI_9V}fK7G&H`1jZVvg2!hs{x2
zyH&%=p-n{35jX8O#(;9?${k4Q!`uymuT3g%$^I3G;79goWc=YFXkv_iG{dWZ2C6|Q
zTWOyq`~Qh`=-Ww&6Yb>jUuLk0v67Jtv;MmypDpLjhpgG2;Z62t;P$VTsQ%Y}eCk(F
z=iiN#i=G^VjhlC5G*U^jUi!C@e`~_1w5WIg#_d#sKiT|XkL(M#VxV}8N+bRFUz71q
zS=xG;DfM4?g=cyBqFM_`C&|Bw0p8R17j+Oo0}1|3jQ<w30d2ebZ)$<3_@}M`(0}>g
znEj6BPk9!Q^#9-FzbDPnQrC#M(tb<eqI5EuRwaqJVDUd7E*qGLGH)Bj6<kyUQ}JEg
zvM$8rA091|YK2aw)RtQ|hwOSbXB#d4Ez(0@x&_KzSdYK-Sc}~?;oY*2cg98*SpMJR
z_(R`r2!0;j9e$wN4zz%_c;4KlbAzL6^wHf5kQV{P-iO?8={O8&r1R}#6iVs2tn+fr
zezYWT3YcValMi-wvYQ-)UhH=R^1J8%pV9IDbFAaNOGHtvJjtxbD!%s(4LL7ha6v{{
z4nR(Bt=ZJNe`FqSnLr<ST?nvx{GaYe_;iokN~N$Cy4+D59O9dw>x46#Xy)MHkejrR
z{zpylmI?p)gxrL3Lm-_pG{;g0sQJW^xZMz2NGx<O{mYdj2~D+LoIUESU;7F40+Ld9
zEx2{)USv9Ybn<XPqAWA~ubq82)dK@vSa_4S<Hv{g{^)LIE9#wX^VaxDh#E*xu*_Ce
z{o;fOKq)4T6M3Pv&36ip4<c6=Hw}CZOa*Z?O8UX$dOe?8C|HC&{cHE}PXCV2_{j&E
zGGm42PHK-0;s^}?Qb3GP<tNhYaxi@%3m0c%#9f%laUTzmRSGc$zJ)_d0Hk+KnhYQy
z02AI4jm?Wy`G1W)u_u<@<k}Cyv0}8B`=gE%Vn1Huuj_x|yF68Op=TfSP1n=LmG)i&
zCA2EsYSKcMN*+=c))@cz>*Da(-u+#92{)M(du2m69C3orA*0%=lM{N@>rPUCCw_N%
zS&jo|hqI{n-tJi)?Cs-N{G@TUZ^E)Yu9-sg|DH7d{p4hCi>NnE<H3;@ZsB?@i1)hw
za{>q8uiaZp&Y|c*3Fkl}NiN_t#n%<`vP^#4yl@=0l*A^(qD+JQCSB!l{b?e5Z9&P~
z-1{@PE_R}5;XWoWo3;bjZoj+`Dximer%vMm6ju_|E-=mZ$;xvWO{*z9T7~cztT)Y>
zIb9R+q#7zb_&9}mR%MFiO$oQTsOIY2c?>!KJ)2I=OTQJj*%f|W3lP|k{hap7HX{bS
zIA(BGUk@ngI-D821cstFY*XKxEv?jZ{~qqa!=rYSm3j#pTgivJ3hpgr{ZVEidXq9c
zzax74(HCVd7yO#pyD2_M<2%-klZ4>qFB21v?O|Dc>UI`7L|j$#_-`kw17C96*jesa
zS;SbxnEXjNo4K@4mA<*iGccV6;iT7Em=-eal;}KB)cFH03X<1!I&^o#XA;=i1{oFX
zUYR>PS(V7J<vZBf{s~^tOK7Q_Dnv^~PZ11y31pe&5Q&;R)HwAq{j(PsU1w2d7ZNx%
z$!BO1MYMxk)NOagf%8du$o-XdP|AnOAhY46i6$4Q>h>LkS9L<*QtJ%^v6^z~{vLMc
z*J}EX-SkyUE!SfxpI?TBa!hJNTz$HdHh9sWY4u^7w=nLGJ`cop|8tZ~%87CyZ0-2c
z<<vjA1hgL-d++VoO^oc5@z(9V4j29AVUHzerHbC!-rQ7|M9)9j*(R&gg3Z>>Sx|Vb
zZ!ttV*aQ5c9GlIe)nX}sT_eOWP#E@+<vLi*`OzPO?!?gD3J`u(Xwo-1;eWv`F^$vL
z;&RfiMnCvbeLC%3?hE9bE#3w`p+Iw%EE2}`Y$yu=1$ZsIyQ%Lddj9e8S)HD~B?zI&
zMcRshMf^PCS~FhWUs*_-pQ!&MbCT(D!;0K)N21;rlD>;P@MIeAUJAEZa!P=<*>~SY
zs(mJogtpUv8(xe6mzYzF?rhJjo&bl>L@Ia=opVvH_zxM#Rk)Fxh<8vgkF)1=)*Pr}
z%eWrzvPPYuCY8-zQI!co6wYVde<dS6jh8HT5%yfonhFV)Qrje(;aFX$7zriDkmr=G
z&z>aak>(z>1yY%y`-($=Lk$UAJh@$4-#&fh7?j*M9(9&Bcb1TXQE-tu77oVkF{1nY
z(kKg`bWFznkyGjfdmphG)n1Km;0y;KUScoz4fdkf*pn3@9;_rgVMsMa@{D*bxFQr5
zV>R#f{DB;=bH%qzn3(?j9P(%CH(_3dn{?nxi&1{V9t*cCx<ghs00fAc>Lg$|gY{ht
zOu=T`K&{(3fV27xRcdxSpO;1(Cl4X#9xAXYOB=1R9=^B(odS7!H^K9_ymD7+%R9(+
z$z%G#hj}BNocC2y<@OVEpB99A%5B}=uO4*U>^HlyWlt>KaohYtcjIU7$pxa90;akG
za4XV7pptV+a?Lg64EuE45xCUK-0rW0$y>fAoXg>zEG%2$MbVrT&X6wjhFE0iki)|V
zI+i-tn~HjBG0H9C)I_Td+oXoNv6HWYOEX&jYzKB~{m^%2-5fQB11hq7HEYNxW@YpA
zG3i%RkX378Q8t}f6N^XegY1b;i-k0v!aD|cdp&O(B3XzjzF=zGf)yuKf`3kyh2}*R
z5nifrO?<Ma_D$B1_1q)K^%lUQFPXCEEs~bDXRpU_=>Xo~7%$<t2y3QX2z+}?rtCKO
z<L9abaYaTqhEisE1|9<q4YLM&gKPM5CP4x$G3jX=*T$V5&od3^LTZXaCxpAGp-Cl^
zIeY7WHp_~ifdp#_G<CMt{xIil4<mc^10eA~hHnUZaXCcFgnD^#{g%Vhd=E8S{)U8u
z8uD69`&hWal@6owZ77%No*b?mh2y}B?S<EGG&3fi&c7U|NGZnUJJ*QK9SkzgF`baa
zry#4T!WK!9`Gf-SipSWsSMxCQAonuZkOYk5=euu}6(Zsy-ek#`z+LVS<`0H-54<c!
zJHNn71fEiVUs}q{?3Ur7z_H^Ui#u$AAi=4%ni>}ZsHf^2C$&2jXzD66QG?^lLIn*Y
z2t3Tv9y<{kj1F$k!qLlwy@vanhduU{)HB#mc|Y|Y`$GOk1o1|$_SOwT{jub-I0un*
zd2lQozpYUI?6$+bD#AzEY~)Y!IXbl=n4;`;Gn&yBCe)+JjO}!bxHx=a>suzv(FGj3
zmI6z9<7OZJ2_0B|!?+0?>~ocsmGf*I*1P%X1qJihXY9$^$7rFZO!!Y-Zr<zh87@Nx
z&oU~?!8Uad67xAQ@<rFoMkhgV0}YR_sdD7`xm<+fi7~dKB7dU{#b?opMH_dv-$EZz
zscl^^=_*{4*?ceTNi|gn|5)?$W3m{-bPv0cCOkmV{mdPD#1@VZv2rj|b<I?V4QWFP
zin6OsUv;;5Is#pa;0uoo62+5~!Psx#gTe3IvKHhel}fIiT_kH4$3WhF&|T^1#hxV7
zsUnUJewV=Y>4F{)*l5d3rl>!5p}E%wBI;#BLUF-`&|UhPECIiQxBqaJ#%OqARQa|5
z-jB_78t{s0yFGQ4c$H{RuoBvA<JQ6k|7JJO=*!N_;IZIVlp5gef-2i}>E`s^TZ;Z3
zL&4+S_@+AhQh>>5eQ!0E12ahV8ZuBwI9ff+EJD_d=q`kOOm4sVyljqEm}u4~el@X4
ziW_JgoOt6X>5b)jm*n4Y<i!=@#l>&35m-%`c-x84$SEf7sxPu1!h;rR$ACEu3=^Fl
zHmOCJ3?ilmf|HZQK8MvL!#~#=A*qF}a8o_kdti$@whIVeYO?fa4onqN9T5`2Mf!^;
z#6nURu*XxR^VX)4nf2)@8GX;jL~&STe}d+~)hRlA0Fk<gLqzdUMMPv>L9nnM0SCkN
zBzg+Zxy+S~TcYHOoLjF10Dj(zwg1@czLE@oz~G><Cqmof!S_#@=7p#^y02xveY~K_
z;EE)g7DQ~f{8a0p9~8=Mg<AlRnMWGaw~y`&hYCF@{tp9H!dp>$n+tbU<&<EB{eclg
zN!RUp6=5Ag^8L8*;#O@7SE7yG|L}?XI=W9}iehnL@)x{>p&=oJGLY0LO>VqbUfl`?
z!f*j(b$lXrePmyU82WE6pGx5jMgmvB9bV;U@81!-;Y?LUJKPi0^FJTuSGA-VtSN5%
zH=YH)S=pG8kcsEEu~<g9L^@fl?3aI3^6yMDc%fKsK^u=_0_6L8!Q8#)*2L)-dFRCf
z5SxJ6w+Ng)A5e{6(>BRsBlU9ghUOarwIGorOAbsV>LMbfBZT-4Tix8;<QI(kZ(tlI
z3~nn0i90+6LraR*jg8vJsG;5|qe2kE1mqotww|0Ng}lITfw+*8j%UsN+1uO#Q%c9b
z%I8XjmSa#<Md)fDIjvI&sJ{W6utrhfw~K)JfvTYL^d#os!zG*}zVJEL`NYhN&l6Kp
z#F-+k<Vy}b2eRbCbszxbH%9F`#50|ZgNN<?S2T#NmO*c+JbT};LK!1HOBSUdWw>bh
z+t*A7JaLA9G6sHkOuW>u_>8G_ApY%X&0nQq^K905ijy_2pb>A+l>PlXJ{MuY1@th<
z|KvHWjUNjFc^FUYTr_@enBel4ptYj$(#$JvWgWxf*Zv8`?`0aUNhEa=UL*uj4}Miu
zFm=Z=d@07^V%9p+4p;vbS+J1(H?_Ohw8@Qh85B#qNLTUmqU3kpuVCfeih%LX%-XzV
zb`%|r8+akHxQO9mTg2pQpxlVSoZn;pDb|Z<#sAZ7eqYh%jXMF*N?go;NP-Kn)8nR(
zHk;-|X>G6nErZ}ad$oj0^P>#C(556}`JtLm>vQ)VJ?U^FnMhFk#_qRy`CH$ASRa<Z
zs&ydclv|L+eo?NHkP6i=p<P11*JIkaP)<h*bhDpzNzd5m530ZG8yExye-Rxl@6Ws-
z>66i5AM0W4x(t3$w7m_$w--i&Ccjnw3xv2Q&o8^{sNlk9vd^&0ZULR<B(|CkftH&1
zH^uC5yar4L@VnFWtZI0*qDMP23g;n&+5NJ>eAFS=cO#2&?7bLcbntuK!$NjH@vsP|
zznM*Z!3j4}&uE@LC=37u5?8jy!~1DES-IRA2Dk)y0BaYg^3KTCSHE5f7TfMU6`Y^L
zS#97r5AXsU(xb5Z!&Ktye>ejC-@|B>G^d>MB%?pzpA--`-Y<L9PDa)hEp!z9*MH&u
z-qV777WXz%a3G@o-&yW_x3B>AZ{iMiE(pIU3IL;11BW~Nv30S6x_{XT{JDJBWp^*>
zv7uWU{r@oqlj*v&jr6|pr(~9Y#19yL|3~m-8PN;xatpNfMKRzV`_Bl`K0trtAUNIM
ztp^%xO_ivD+{)HzEru@i%!o;^+qh$Az-v9O>Ab|-JgV51`mjUI;Ef(8X(s;A=7&1)
z;kz3TOk#$)$p-fqRO&PTfUIMCCT4;z>Gonym$O7&GvNRsq3!UF@S#w4F*kLGrB`D}
ziBTNaUtCHsb#{gfa$Vn_S>^ILFhBSM_$rAkxg&pxY)Im@&CRqE>}<$=wEyCI@=}KQ
zobp0^o5>pNvNWQ;Ft$Q3J~t@b=;yBHP3><3O2CwOE-eSzv?nuN@C#+bdpDzPN@G{>
zGuW<kBwnVx(0y)~LbYA%HIMnWgCOgh^ty6C9cS$QaFmh8&&Mg}T)(_ZZ<HSp#<0RK
zgHcm_nv1p^n_h@UrL)UCA^hE<I0!VPzx<OvYE6A1QoPWjjJa%+=2_PV!Mx9kMU)xd
z8lO5slekE!-LJ?vhajxU`5Tj!k+YZF3XIX$oYJa{Hv-o^L#6d-m~~`*N`j+=W~Nzm
ztRuK?oaL}qr?t<Izq8>L-_dy9&|rMlyklm7BmtvZ_%=U)&~mP$)Z2y^;!3w}UROv!
zW&P-RjD3mRS*ruHB;@De&U;f*v_1?{*kNu<heT@kM@ywX5g&yWJ<EGMC;3p~`5o5y
zr>`cLyB?K_1l{zapP~89c{WF6DCD@qO*+j}p`hb<+hC`A?B?&W$zS*qHCoxEfjQs1
z2asx_a7SLmcx&>@jpAX7qJc3293${p!aKd_GndF<6A$}+n&=iKtZVlr%68Vw<Gzr0
zL0HAFQs@TM%ihV|@#P<>EWP<L7~ga!Dfnr#$Lu3t>}T#l4D1J2^C0ZrL@c7Mopgyt
zA(wV|>X!#e_ndf<^gVQr63n`gOMA*%eQAGW<?&+RC%r#vnDgn0^0!}MKfEn=@@~kA
zzCqtVbaYpP){QcaD|h;#63miEDsLm@8atNA-fl&(7F+J*bxO9|g>!GjN^i<;zwdEY
z9^m{;U0@h71mAb1uw{?=z}-AH8z0Qc8y@7<IzNu+&{&GMW;SF>in$N7wDv;Ka1nAX
zNH>>^tc<mjqv$TscnA4}C)yQRAR0v33|u#HH$^QuYrdX&A4PhKDlRf(MPkkGSKCo-
za*QTBG-c90Zg&=4Jbu15z%F**=Vh~^ACFdC>g@?qnJza_8uE7;y?i+D<>sMM+M9~Z
zUEIG5?{>SYiKoU_tL?*uIQNtC_Ck#wDtI$=;Vz#67RL|sNK8CJNjHd9;2U2P*RRv4
z*(<C^U@N!w-;2;X4vDp#TIVR+jj~yF`*l%@Ob_<}d=d(c(8@<iqx9Fcf+BZJ&d9?9
zOF8(-&o!1=lP^&dC^Bnk?mW@VLL(%=sQN;wWu#&6>c*{{&tBw-B^N;7QT#u<u{$Ds
zpQ3)IeYDMkz6D;pqo=)F*q)@Gvg4#`Xx7{lKTd4YdfGU_L;J0lz~&0!ITqP=hXlVr
zZQb+!S)lLMl+GQ|$Nt>EyXj-??;~49Rt51+bA4sI)aniJ5YBZ^7ew9#TXLZ0POjp)
zhN-Ia{*=wmF<YVaHYZYmR}0ufO4K>^$oTZm=+G5Gx9@FGoV!c7dAeQNp3(q?O|p+&
zv|81Vn_lfa|7V8lN#pO+dXL}e+Rs-W7i||E8Ft??Fn{KGoyJ>N7u`EI;bXWXr#{%O
z3w+Zm6F=RYJ@eb+Lk3#AwfxymYQIg1T%gGOUPDg*n97N#Q`1&W@ebSm#^r3Ccx$4S
zaL%=lSrgUd+o$CO?S4>a<z91k{}!E(691>wzjXOnRh;BLt;XTsYq!EDYjhWSUCpq+
zI?ZyL)@hUe2Pcg-CGmr|76VIk+1Ebeu7A3>T=F#Z+xF$aNrqKhW~Z*R-=Og{HSUSo
zou}~?z$K>w2VaZIM|3aiJ2xS9CfK>a;#Q$^N>^q5LDtW)>sa1SPS91IcUClBWX=uX
zmNlp`%3q>7g_30i`FDCmFI7{zIk|JA-1#ls6`7Y0F=ub%`?3G@!nL4QGYCX|U~BoO
z_0#^kyJGUR{Q|X|kvVfeyw`b_@5Qg9qa8M}arwPX5#DU~0(YpTtv(X5&RCfFQRtp$
z?=FaLcG9mr@JX_~=b1dmB=fY5xgQ`Q%D`}D+JViFD&C&F<aGM$sfjaFCm!8;zf;yd
z?<ZrbWW_4oV$;+IvgwkMXS_atj?w>?5;ZTkF!U8`w}p=Vf%`GDPOw8<#;`!@*suM^
z?&zF0&Y3I)6`LVevK82B`{V!~+hAz8n6V+VEal<3qX%@4&yISQ7pB8IQKpsc_D_c?
zw>hux+b_50&{>-WtN*@;n#K+u(P3cdaclN1KC^u_-}*|YOGe#CyRRPD_V#juwY<^C
ze)+YMUNf@}Duafbryc)h60QYWjs$EP2t>c#uDvU$z?yAS?ZW*s-c#ka`;@E~h&6Xh
zTJ3fBLBm{i?tfuP_jHP0ID%HwgTSMLx6d~&%{7dxpIk3$EXSw4H4In?3B3_MZ!76I
z)ojC=Z*wLyRt3qq-8dZ9_?-Lmr1fHl9)*Od|BvdNJMHzy`K)K;PlM|-pjit#uGDRO
z?`p?AX?@LoZ<i^XFW2QA(ebzV?-sbUSLbo!o@TQfH{4eRiAB#AjsCE{Mq6;jYuiw%
zV`sdrvvnd&rp*Pr2w2?;uKfGw!4s7v?{!Sf|Nf>e|LgZg$Ej2#^wx<@!qZnDnCKC@
z^7z__kL%6U)f?Zx2QKw6?oPjz-F<ZN%5<m^Ag9D!&J{|0%K0>Nb4QO>ZpzHfpPJ?B
zSIV!{dYW}P{g1YscaGt9;I5r%9@jpChwMOFn>^kgzdBcUi~N7B1Z|^LTRKy>?U%a9
zJQKKuV(HOM>&0>+!<MewyTz^K6{s}=0*+m`@(T|s2kJJh`m!KZF}n9<gU-sJJf9<P
zHfh;DT(~!9&$(3)l?)F3i@t64`&K(yOfj_T#HOP=7HwJM^>(uD`jvB6URtW!R%ja+
zsRmW606Yxm=Qqy-tGO*>Sa11c><{Vf1D<gfA=Y8!p$t4UGw?uiS1SM21l`b;b7!1=
zy6P~u5~R*yU^t<XwSQ{<&of2-eo12MADPyt99?r^qfYnFX<HT2BTpoC8!t$$^jdZ0
z)8vJ>KAd>;<TPu2%FG)l_V*?qJGAi)EMas-gelF}(VIHw$$ghZ*6s)n_3PcXA2$o%
zp0uhY;qCPcM)?(|KXFLwK6H<ZaGHOsP-T+)^w(3B>&k>a9-lsOYm~xj@N^c?JA99G
zts8=X10$>wum8ich(Yj+Ec;#4L>s{4ML<;z=Pq2WE78?v2nF>NKw$1h+v*(Qp3Q3-
z(mSdkDI6j(N{)sAu_3Tv;(z<r?s<jRZtc(o>QOCmjVMV;EJ?LWE=mPb3`Pcq=DG%!
zx<+OphGtgA23Ce9+6D$z1_rklSB9Zz$jwj5OsmALVfDX*uRyNyboFyt=akR{08p^@
Aj{pDw

literal 0
HcmV?d00001

diff --git a/docs/source/running-the-demos.rst b/docs/source/running-the-demos.rst
index 32a99967c6..f9e78737d1 100644
--- a/docs/source/running-the-demos.rst
+++ b/docs/source/running-the-demos.rst
@@ -143,19 +143,18 @@ To run from the command line in Windows:
 To run the BFT SMaRt notary demo, use ``nodesBFT`` instead of ``nodesRaft`` in the path (you will see messages from notary nodes
 trying to communicate each other sometime with connection errors, that's normal). For a single notary node, use ``nodesSingle``.
 
-Notary nodes store consumed states in a replicated commit log, which is backed by a H2 database on each node.
+Distributed notary nodes store consumed states in a replicated commit log, which is backed by a H2 database on each node.
 You can ascertain that the commit log is synchronised across the cluster by accessing and comparing each of the nodes' backing stores
 by using the H2 web console:
 
 - Firstly, download `H2 web console <http://www.h2database.com/html/download.html>`_ (download the "platform-independent zip"),
-  and start it using a script in the extracted folder: ``h2/bin/h2.sh`` (or ``h2\bin\h2`` for Windows)
+  and start it using a script in the extracted folder: ``sh h2/bin/h2.sh`` (or ``h2\bin\h2`` for Windows)
 
 - If you are uncertain as to which version of h2 to install or if you have connectivity issues, refer to ``build.gradle``
-  located in the ``node`` directory and locate the compile step for ``com.h2database``. Use a client of the same
-  major version - even if still in beta.
+  located in the corda directory and locate ``h2_version``. Use a client of the same major version - even if still in beta.
 
 - The H2 web console should start up in a web browser tab. To connect we first need to obtain a JDBC connection string.
-  Each node outputs its connection string in the terminal window as it starts up. In a terminal window where a node is running,
+  Each node outputs its connection string in the terminal window as it starts up. In a terminal window where a **notary** node is running,
   look for the following string:
 
   ``Database connection url is              : jdbc:h2:tcp://10.18.0.150:56736/node``
@@ -163,8 +162,8 @@ by using the H2 web console:
   You can use the string on the right to connect to the h2 database: just paste it into the `JDBC URL` field and click *Connect*.
   You will be presented with a web application that enumerates all the available tables and provides an interface for you to query them using SQL
 
-- The committed states are stored in the ``NOTARY_COMMITTED_STATES`` table. Note that the raw data is not human-readable,
-  but we're only interested in the row count for this demo
+- The committed states are stored in the ``NOTARY_COMMITTED_STATES`` table (for Raft) or ``NODE_BFT_SMART_NOTARY_COMMITTED_STATES`` (for BFT).
+  Note that in the Raft case the raw data is not human-readable, but we're only interested in the row count for this demo
 
 .. _bank-of-corda-demo:
 
diff --git a/docs/source/serialization.rst b/docs/source/serialization.rst
index ca86da886c..92d542dd71 100644
--- a/docs/source/serialization.rst
+++ b/docs/source/serialization.rst
@@ -22,8 +22,8 @@ Classes get onto the whitelist via one of three mechanisms:
 #. Via the ``@CordaSerializable`` annotation.  In order to whitelist a class, this annotation can be present on the
    class itself, on any of the super classes or on any interface implemented by the class or super classes or any
    interface extended by an interface implemented by the class or superclasses.
-#. By returning the class as part of a plugin via the method ``customizeSerialization``.  It's important to return
-   true from this method if you override it, otherwise the plugin will be excluded. See :doc:`writing-cordapps`.
+#. By implementing the ``SerializationWhitelist`` interface and specifying a list of `whitelist` classes.
+   See :doc:`writing-cordapps`.
 #. Via the built in Corda whitelist (see the class ``DefaultWhitelist``).  Whilst this is not user editable, it does list
    common JDK classes that have been whitelisted for your convenience.
 
@@ -39,8 +39,8 @@ It's reproduced here as an example of both ways you can do this for a couple of
    them will automatically be whitelisted.  This includes `Contract`, `ContractState` and `CommandData`.
 
 .. warning:: Java 8 Lambda expressions are not serializable except in flow checkpoints, and then not by default. The syntax to declare a serializable Lambda
-expression that will work with Corda is ``Runnable r = (Runnable & Serializable) () -> System.out.println("Hello World");``, or
-``Callable<String> c = (Callable<String> & Serializable) () -> "Hello World";``.
+   expression that will work with Corda is ``Runnable r = (Runnable & Serializable) () -> System.out.println("Hello World");``, or
+   ``Callable<String> c = (Callable<String> & Serializable) () -> "Hello World";``.
 
 .. warning:: We will be replacing the use of Kryo in the serialization framework and so additional changes here are
    likely.
diff --git a/docs/source/shell.rst b/docs/source/shell.rst
index 5d00d73890..cdddc4548e 100644
--- a/docs/source/shell.rst
+++ b/docs/source/shell.rst
@@ -99,6 +99,10 @@ Nested objects can be created using curly braces, as in ``{ a: 1, b: 2}``. This
 parser is defined for the type you need, for instance, if an API requires a ``Pair<String, Int>``
 which could be represented as ``{ first: foo, second: 123 }``.
 
+.. note:: If your CorDapp is written in Java,
+   named arguments won't work unless you compiled using the ``-parameters`` argument to javac.
+   See :doc:`deploying-a-node` for how to specify it via Gradle.
+
 The same syntax is also used to specify the parameters for RPCs, accessed via the ``run`` command, like this:
 
 ``run registeredFlows``
diff --git a/docs/source/troubleshooting.rst b/docs/source/troubleshooting.rst
index a07980119c..51e60133c4 100644
--- a/docs/source/troubleshooting.rst
+++ b/docs/source/troubleshooting.rst
@@ -23,6 +23,11 @@ Some of the unit tests, and our serialization framework in general, rely on the
 to Java reflection.  Make sure you have specified the ``-parameters`` option to the Java compiler.  We attempt to set this globally
 for gradle and IntelliJ, but it's possible this option is not present in your environment for some reason.
 
+"No matching constructor found: - [arg0: int, arg1: Party]: missing parameter arg0"
+***********************************************************************************
+
+Your CorDapp is written in Java and you haven't specified the ``-parameters`` compiler argument. See :doc:`deploying-a-node` for how it can be done using Gradle.
+
 IDEA issues
 -----------
 
diff --git a/docs/source/tut-two-party-flow.rst b/docs/source/tut-two-party-flow.rst
index 84acdb6f7c..b19630eb32 100644
--- a/docs/source/tut-two-party-flow.rst
+++ b/docs/source/tut-two-party-flow.rst
@@ -125,10 +125,10 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
         ...
 
         @InitiatedBy(IOUFlow::class)
-        class IOUFlowResponder(val otherPartyFlow: FlowSession) : FlowLogic<Unit>() {
+        class IOUFlowResponder(val otherPartySession: FlowSession) : FlowLogic<Unit>() {
             @Suspendable
             override fun call() {
-                val signTransactionFlow = object : SignTransactionFlow(otherPartyFlow, SignTransactionFlow.tracker()) {
+                val signTransactionFlow = object : SignTransactionFlow(otherPartySession, SignTransactionFlow.tracker()) {
                     override fun checkTransaction(stx: SignedTransaction) = requireThat {
                         val output = stx.tx.outputs.single().data
                         "This must be an IOU transaction." using (output is IOUState)
@@ -148,7 +148,11 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
         import co.paralleluniverse.fibers.Suspendable;
         import com.template.state.IOUState;
         import net.corda.core.contracts.ContractState;
-        import net.corda.core.flows.*;
+        import net.corda.core.flows.FlowException;
+        import net.corda.core.flows.FlowLogic;
+        import net.corda.core.flows.FlowSession;
+        import net.corda.core.flows.InitiatedBy;
+        import net.corda.core.flows.SignTransactionFlow;
         import net.corda.core.transactions.SignedTransaction;
         import net.corda.core.utilities.ProgressTracker;
 
@@ -156,18 +160,18 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
 
         @InitiatedBy(IOUFlow.class)
         public class IOUFlowResponder extends FlowLogic<Void> {
-            private final FlowSession otherPartyFlow;
+            private final FlowSession otherPartySession;
 
-            public IOUFlowResponder(FlowSession otherPartyFlow) {
-                this.otherPartyFlow = otherPartyFlow;
+            public IOUFlowResponder(FlowSession otherPartySession) {
+                this.otherPartySession = otherPartySession;
             }
 
             @Suspendable
             @Override
             public Void call() throws FlowException {
-                class signTxFlow extends SignTransactionFlow {
-                    private signTxFlow(FlowSession otherPartyFlow, ProgressTracker progressTracker) {
-                        super(otherPartyFlow, progressTracker);
+                class SignTxFlow extends SignTransactionFlow {
+                    private signTxFlow(FlowSession otherPartySession, ProgressTracker progressTracker) {
+                        super(otherPartySession, progressTracker);
                     }
 
                     @Override
@@ -182,7 +186,7 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
                     }
                 }
 
-                subFlow(new signTxFlow(otherPartyFlow, SignTransactionFlow.Companion.tracker()));
+                subFlow(new SignTxFlow(otherPartySession, SignTransactionFlow.Companion.tracker()));
 
                 return null;
             }
diff --git a/docs/source/tutorial-tear-offs.rst b/docs/source/tutorial-tear-offs.rst
index 80d8395112..fe665bf3bf 100644
--- a/docs/source/tutorial-tear-offs.rst
+++ b/docs/source/tutorial-tear-offs.rst
@@ -49,11 +49,10 @@ The following code snippet is taken from ``NodeInterestRates.kt`` and implements
     :end-before: DOCEND 1
     :dedent: 8
 
-.. note:: The way the ``FilteredTransaction`` is constructed ensures that after signing of the root hash it's impossible
-   to add or remove components (leaves). However, it can happen that having transaction with multiple commands one party
-   reveals only subset of them to the Oracle. As signing is done now over the Merkle root hash, the service signs all
-   commands of given type, even though it didn't see all of them. In the case however where all of the commands should be
-   visible to an Oracle, one can type ``ftx.checkAllComponentsVisible(COMMANDS_GROUP)`` before invoking ``ftx.verify``.
+.. note:: The way the ``FilteredTransaction`` is constructed ensures that after signing of the root hash it's impossible to add or remove
+    components (leaves). However, it can happen that having transaction with multiple commands one party reveals only subset of them to the Oracle.
+    As signing is done now over the Merkle root hash, the service signs all commands of given type, even though it didn't see
+    all of them. In the case however where all of the commands should be visible to an Oracle, one can type ``ftx.checkAllComponentsVisible(COMMANDS_GROUP)`` before invoking ``ftx.verify``.
    ``checkAllComponentsVisible`` is using a sophisticated underlying partial Merkle tree check to guarantee that all of
    the components of a particular group that existed in the original ``WireTransaction`` are included in the received
    ``FilteredTransaction``.
\ No newline at end of file
diff --git a/docs/source/upgrade-notes.rst b/docs/source/upgrade-notes.rst
new file mode 100644
index 0000000000..3f6444d497
--- /dev/null
+++ b/docs/source/upgrade-notes.rst
@@ -0,0 +1,349 @@
+Upgrade notes
+=============
+
+These notes provide helpful instructions to upgrade your Corda Applications (CorDapps) from previous versions, starting
+from our first public Beta (:ref:`Milestone 12 <changelog_m12>`), to :ref:`V1.0 <changelog_v1>`
+
+General
+-------
+Always remember to update the version identifiers in your project gradle file:
+
+.. sourcecode:: shell
+
+    ext.corda_release_version = '1.0.0'
+    ext.corda_gradle_plugins_version = '1.0.0'
+
+It may be necessary to update the version of major dependencies:
+
+.. sourcecode:: shell
+
+    ext.kotlin_version = '1.1.4'
+    ext.quasar_version = '0.7.9'
+
+Please consult the relevant release notes of the release in question. If not specified, you may assume the
+versions you are currently using are still in force.
+
+We also strongly recommend cross referencing with the :doc:`changelog` to confirm changes.
+
+:ref:`Milestone 14 <changelog_m14>`
+------------
+
+Build 
+^^^^^
+
+* MockNetwork has moved.
+
+  A new test driver module dependency needs to be including in your project: `corda-node-driver`. To continue using the
+  mock network for testing, add the following entry to your gradle build file:
+
+.. sourcecode:: shell
+
+  testCompile "net.corda:corda-node-driver:$corda_release_version"
+
+.. note::  you may only need `testCompile "net.corda:corda-test-utils:$corda_release_version"` if not using the Driver DSL.
+
+Configuration
+^^^^^^^^^^^^^
+
+* ``CordaPluginRegistry`` has been removed.
+  The one remaining configuration item ``customizeSerialisation``, which defined a optional whitelist of types for use in
+  object serialization, has been replaced with the ``SerializationWhitelist`` interface which should be implemented to
+  define a list of equivalent whitelisted classes.
+  You will need to rename your services resource file to the new class name:
+  'resources/META-INF/services/net.corda.core.node.CordaPluginRegistry' becomes 'resources/META-INF/services/net.corda.core.serialization.SerializationWhitelist'
+  An associated property on ``MockNode`` was renamed from ``testPluginRegistries`` to ``testSerializationWhitelists``.
+  In general, the ``@CordaSerializable`` annotation is the preferred method for whitelisting as described in :doc:`serialization`
+
+Missing imports
+^^^^^^^^^^^^^^^
+
+Use the automatic imports feature of IntelliJ to intelligently resolve the new imports.
+
+* Missing imports for contract types.
+
+  CommercialPaper and Cash are now contained within the `finance` module, as are associated helpers functions.
+  For example:
+    ``import net.corda.contracts.ICommercialPaperState`` becomes ``import net.corda.finance.contracts.ICommercialPaperState``
+
+    ``import net.corda.contracts.asset.sumCashBy`` becomes ``import net.corda.finance.utils.sumCashBy``
+
+    ``import net.corda.core.contracts.DOLLARS`` becomes ``import net.corda.finance.DOLLARS``
+
+    ``import net.corda.core.contracts.issued by`` becomes ``import net.corda.finance.issued by``
+
+    ``import net.corda.contracts.asset.Cash`` becomes ``import net.corda.finance.contracts.asset.Cash``
+
+* Missing imports for utility functions.
+
+  Many common types and helper methods have been consolidated into `net.corda.core.utilities` package.
+  For example:
+    ``import net.corda.core.crypto.commonName`` becomes ``import net.corda.core.utilities.commonName``
+
+    ``import net.corda.core.crypto.toBase58String`` becomes ``import net.corda.core.utilities.toBase58String``
+
+    ``import net.corda.core.getOrThrow`` becomes ``import net.corda.core.utilities.getOrThrow``
+
+* Missing flow imports.
+
+  In general all reusable library flows are contained within the **core** API `net.corda.core.flows` package.
+  Financial domain library flows are contained within the **finance** module `net.corda.finance.flows` package.
+  Other flows that have moved include:
+
+  ``import net.corda.core.flows.ResolveTransactionsFlow`` becomes ``import net.corda.core.internal.ResolveTransactionsFlow``
+
+Core data structures
+^^^^^^^^^^^^^^^^^^^^
+
+* Missing Contract override.
+
+  The contract interace attribute ``legalContractReference`` has been removed, and replaced by
+  the optional annotation ``@LegalProseReference(uri = "<URI>")``
+
+* Unresolved reference.
+
+  Calls to ``AuthenticatedObject`` are replaced by ``CommandWithParties``
+
+* Overrides nothing: ``isRelevant`` in ``LinearState``.
+
+  Removed the concept of relevancy from ``LinearState``. A ``ContractState``'s relevance to the vault is now resolved
+  internally; the vault will process any transaction from a flow which is not derived from transaction resolution verification.
+  The notion of relevancy is subject to further improvements to enable a developer to control what state the vault thinks
+  are relevant.
+
+* Calls to ``txBuilder.toLedgerTransaction()`` now requires a serviceHub parameter.
+
+  Used by the new Contract Constraints functionality to validate and resolve attachments.   
+
+Flow framework
+^^^^^^^^^^^^^^
+
+* Flow session deprecations
+
+  ``FlowLogic`` communication has been upgraded to use functions on ``FlowSession`` as the base for communication
+  between nodes.
+
+  * Calls to ``send()``, ``receive()`` and ``sendAndReceive()`` on FlowLogic should be replaced with calls
+    to the function of the same name on ``FlowSession``. Note that the replacement functions do not take in a destination
+    parameter, as this is defined in the session.
+
+  * Initiated flows now take in a ``FlowSession`` instead of ``Party`` in their constructor. If you need to access the
+    counterparty identity, it is in the ``counterparty`` property of the flow session.
+
+  See ``FlowSession`` for step by step instructions on porting existing flows to use the new mechanism.
+
+* ``FinalityFlow`` now returns a single ``SignedTransaction``, instead of a ``List<SignedTransaction>``
+
+* ``TransactionKeyFlow`` renamed to ``SwapIdentitiesFlow``
+
+  Note that ``SwapIdentitiesFlow`` must be imported from the *confidential-identities** package ''net.corda.confidential''
+
+Node services (ServiceHub)
+^^^^^^^^^^^^^^
+
+* VaultQueryService: unresolved reference to `vaultQueryService`.
+
+  Replace all references to ``<services>.vaultQueryService`` with ``<services>.vaultService``.
+  Previously there were two vault APIs. Now there is a single unified API with the same functions: ``VaultService``.
+
+* ``serviceHub.myInfo.legalIdentity`` no longer exists; use the ``ourIdentity`` property of the flow instead.
+
+  ``FlowLogic.ourIdentity`` has been introduced as a shortcut for retrieving our identity in a flow
+
+* ``getAnyNotary`` is gone - use ``serviceHub.networkMapCache.notaryIdentities[0]`` instead
+
+   Note: ongoing work to support multiple notary identities is still in progress.
+
+* ``ServiceHub.networkMapUpdates`` is replaced by ``ServiceHub.networkMapFeed``
+
+* ``ServiceHub.partyFromX500Name`` is replaced by ``ServiceHub.wellKnownPartyFromX500Name``
+  Note: A "well known" party is one that isn't anonymous and this change was motivated by the confidential identities work.
+
+RPC Client
+^^^^^^^^^^
+
+* Missing API methods on `CordaRPCOps` interface.
+
+  * Calls to ``verifiedTransactionsFeed()`` and ``verifiedTransactions()`` have been replaced with:
+    ``internalVerifiedTransactionsSnapshot()`` and ``internalVerifiedTransactionsFeed()`` respectively
+
+    This is in preparation for the planned integration of Intel SGX™, which will encrypt the transactions feed.
+    Apps that use this API will not work on encrypted ledgers: you should probably be using the vault query API instead.
+
+  * Accessing the `networkMapCache` via ``services.nodeInfo().legalIdentities`` returns a list of identities.
+    The first element in the list is the Party object referring to a node's single identity.
+
+    This is in preparation for allowing a node to host multiple separate identities in future.
+
+Testing
+^^^^^^^
+
+Please note that `Clauses` have been removed completely as of V1.0. 
+We will be revisiting this capability in a future release.
+
+* CorDapps must be explicitly registered in ``MockNetwork`` unit tests.
+
+  This is done by calling ``setCordappPackages``, an extension helper function in the ``net.corda.testing`` package,
+  on the first line of your `@Before` method. This takes a variable number of `String` arguments which should be the
+  package names of the CorDapps containing the contract verification code you wish to load.
+  You should unset CorDapp packages in your `@After` method by using ``unsetCordappPackages()`` after `stopNodes()`.
+
+* CorDapps must be explicitly registered in ``DriverDSL`` and ``RPCDriverDSL`` integration tests.
+
+  Similarly, you must also register package names of the CorDapps containing the contract verification code you wish to load
+  using the ``extraCordappPackagesToScan: List<String>`` constructor parameter of the driver DSL.
+
+Finance
+^^^^^^^
+
+* `FungibleAsset` interface simplification.
+
+  The ``FungibleAsset`` interface has been made simpler. The ``Commands`` grouping interface
+  that included the ``Move``, ``Issue`` and ``Exit`` interfaces have all been removed, while the ``move`` function has
+  been renamed to ``withNewOwnerAndAmount`` to be consistent with the ``withNewOwner`` function of the ``OwnableState``.
+
+  The following errors may be reported:
+
+  * override nothing (FungibleAsset): `move`
+  * not a subtype of overridden FungibleAsset: `withNewOwner`
+  * no longer need to override `override val contractHash: SecureHash? = null`
+  * need to override `override val contract: Class<out Contract>? = null`
+
+
+Miscellaneous
+^^^^^^^^^^^^^
+
+* ``args[0].parseNetworkHostAndPort()`` becomes ``NetworkHostAndPort.parse(args[0])``
+
+* There is no longer a ``NodeInfo.advertisedServices`` property.
+
+  The concept of advertised services has been removed from Corda. This is because it was vaguely defined and real world
+  apps would not typically select random, unknown counterparties from the network map based on self-declared capabilities.
+  We will introduce a replacement for this functionality, business networks, in a future release.
+
+Gotchas
+^^^^^^^
+
+* Beware to use the correct identity when issuing cash:
+
+  The 3rd parameter to ``CashIssueFlow`` should be the ** notary ** (not the ** node identity **)
+
+
+:ref:`Milestone 13 <changelog_m13>`
+------------
+
+Core data structures
+^^^^^^^^^^^^^^^^^^^^
+
+* `TransactionBuilder` changes.
+
+  Use convenience class ``StateAndContract`` instead of ``TransactionBuilder.withItems()`` for passing
+  around a state and its contract.
+
+* Transaction building DSL changes:
+
+  * now need to explicitly pass the ContractClassName into all inputs and outputs.
+  * `ContractClassName` refers to the class containing the “verifier” method.
+
+* Contract verify method signature change.
+
+  ``override fun verify(tx: TransactionForContract)`` becomes ``override fun verify(tx: LedgerTransaction)``
+
+* No longer need to override Contract ``contract()`` function.
+
+Node services (ServiceHub)
+^^^^^^^^^^^^^
+
+* ServiceHub API method changes.
+
+  ``services.networkMapUpdates().justSnapshot`` becomes ``services.networkMapSnapshot()``
+
+Configuration
+^^^^^^^^^^^^^
+
+* No longer need to define ``CordaPluginRegistry`` and configure ``requiredSchemas``
+
+  Custom contract schemas are automatically detected at startup time by class path scanning.
+  For testing purposes, use the ``SchemaService`` method to register new custom schemas:
+  eg. ``services.schemaService.registerCustomSchemas(setOf(YoSchemaV1))``
+
+Identity
+^^^^^^^^
+
+* Party names are now ``CordaX500Name``, not ``X500Name``
+
+  ``CordaX500Name`` specifies a predefined set of mandatory (organisation, locality, country)
+  and optional fields (commonName, organisationUnit, state) with validation checking.
+  Use new builder CordaX500Name.build(X500Name(target)) or, preferably, explicitly define X500Name parameters using
+  ``CordaX500Name`` constructor.
+
+Testing
+^^^^^^^
+
+* MockNetwork Testing.
+
+  Mock nodes in node tests are now of type ``StartedNode<MockNode>``, rather than ``MockNode``
+  MockNetwork now returns a BasketOf(<StartedNode<MockNode>>)
+  Must call internals on StartedNode to get MockNode:
+    a = nodes.partyNodes[0].internals
+    b = nodes.partyNodes[1].internals
+
+* Host and Port change.
+
+  Use string helper function ``parseNetworkHostAndPort()`` to parse a URL on startup.
+   eg. ``val hostAndPort = args[0].parseNetworkHostAndPort()``
+
+* The node driver parameters for starting a node have been reordered, and the node’s name needs to be given as an
+  ``CordaX500Name``, instead of using ``getX509Name``
+
+
+:ref:`Milestone 12 <changelog_m12>` (First Public Beta)
+-----------------------------------
+
+Core data structures
+^^^^^^^^^^^^^^^^^^^^
+
+* Transaction building
+
+  You no longer need to specify the type of a ``TransactionBuilder`` as ``TransactionType.General``
+  ``TransactionType.General.Builder(notary)`` becomes ``TransactionBuilder(notary)``
+
+Build 
+^^^^^
+
+* Gradle dependency reference changes.
+
+  Module name has changed to include `corda` in the artifacts jar name:
+
+.. sourcecode:: shell
+
+    compile "net.corda:core:$corda_release_version" -> compile "net.corda:corda-core:$corda_release_version"
+    compile "net.corda:finance:$corda_release_version" -> compile "net.corda:corda-finance:$corda_release_version"
+    compile "net.corda:jackson:$corda_release_version" -> compile "net.corda:corda-jackson:$corda_release_version"
+    compile "net.corda:node:$corda_release_version" -> compile "net.corda:corda-node:$corda_release_version"
+    compile "net.corda:rpc:$corda_release_version" -> compile "net.corda:corda-rpc:$corda_release_version"
+
+Node services (ServiceHub)
+^^^^^^^^^^^^^
+
+* ServiceHub API changes.
+
+  ``services.networkMapUpdates()`` becomes ``services.networkMapFeed()``
+  ``services.getCashBalances()`` becomes a helper method within the **finance** module contracts package: ``net.corda.finance.contracts.getCashBalances``
+
+Finance
+^^^^^^^
+
+* Financial asset contracts (Cash, CommercialPaper, Obligations) are now a standalone CorDapp within the **finance** module.
+
+  Need to import from respective package within `finance` module:
+    eg. ``net.corda.finance.contracts.asset.Cash``
+
+  Likewise, need to import associated asset flows from respective package within `finance` module:
+    eg. ``net.corda.finance.flows.CashIssueFlow``
+        ``net.corda.finance.flows.CashIssueAndPaymentFlow``
+        ``net.corda.finance.flows.CashExitFlow``
+
+* Moved ``finance`` gradle project files into a ``net.corda.finance`` package namespace.
+
+  This may require adjusting imports of Cash flow references and also of ``StartFlow`` permission in ``gradle.build`` files.
+  Associated flows (`Cash*Flow`, `TwoPartyTradeFlow`, `TwoPartyDealFlow`) must now be imported from this package.
diff --git a/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyDealFlow.kt b/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyDealFlow.kt
index f87bfb2390..0525cead6a 100644
--- a/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyDealFlow.kt
+++ b/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyDealFlow.kt
@@ -50,12 +50,14 @@ object TwoPartyDealFlow {
         abstract val notaryParty: Party
         abstract val otherSideSession: FlowSession
 
+        // DOCSTART 2
         @Suspendable
         override fun call(): SignedTransaction {
             progressTracker.currentStep = GENERATING_ID
             val txIdentities = subFlow(SwapIdentitiesFlow(otherSideSession.counterparty))
             val anonymousMe = txIdentities[ourIdentity] ?: ourIdentity.anonymise()
             val anonymousCounterparty = txIdentities[otherSideSession.counterparty] ?: otherSideSession.counterparty.anonymise()
+        // DOCEND 2
             progressTracker.currentStep = SENDING_PROPOSAL
             // Make the first message we'll send to kick off the flow.
             val hello = Handshake(payload, anonymousMe, anonymousCounterparty)
diff --git a/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt b/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt
index 47da4a403a..d243792253 100644
--- a/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt
+++ b/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt
@@ -169,6 +169,7 @@ object TwoPartyTradeFlow {
             progressTracker.currentStep = SIGNING
             val (ptx, cashSigningPubKeys) = assembleSharedTX(assetForSale, tradeRequest, buyerAnonymousIdentity)
 
+            // DOCSTART 6
             // Now sign the transaction with whatever keys we need to move the cash.
             val partSignedTx = serviceHub.signInitialTransaction(ptx, cashSigningPubKeys)
 
@@ -180,6 +181,7 @@ object TwoPartyTradeFlow {
             progressTracker.currentStep = COLLECTING_SIGNATURES
             val sellerSignature = subFlow(CollectSignatureFlow(partSignedTx, sellerSession, sellerSession.counterparty.owningKey))
             val twiceSignedTx = partSignedTx + sellerSignature
+            // DOCEND 6
 
             // Notarise and record the transaction.
             progressTracker.currentStep = RECORDING
@@ -202,8 +204,8 @@ object TwoPartyTradeFlow {
 
                 // Register the identity we're about to send payment to. This shouldn't be the same as the asset owner
                 // identity, so that anonymity is enforced.
-                val wellKnownPayToIdentity = serviceHub.identityService.verifyAndRegisterIdentity(it.payToIdentity)
-                require(wellKnownPayToIdentity?.party == sellerSession.counterparty) { "Well known identity to pay to must match counterparty identity" }
+                val wellKnownPayToIdentity = serviceHub.identityService.verifyAndRegisterIdentity(it.payToIdentity) ?: it.payToIdentity
+                require(wellKnownPayToIdentity.party == sellerSession.counterparty) { "Well known identity to pay to must match counterparty identity" }
 
                 if (it.price > acceptablePrice)
                     throw UnacceptablePriceException(it.price)
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
index 27c9a3d08a..fd803ee9ef 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@@ -1,7 +1,5 @@
 package net.corda.node.services
 
-import net.corda.client.rpc.RPCException
-import net.corda.core.concurrent.CordaFuture
 import net.corda.core.contracts.Contract
 import net.corda.core.contracts.PartyAndReference
 import net.corda.core.cordapp.CordappProvider
@@ -18,7 +16,6 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.loggerFor
-import net.corda.node.internal.StartedNode
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
 import net.corda.node.services.transactions.SimpleNotaryService
@@ -27,19 +24,15 @@ import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.DUMMY_BANK_A
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.TestDependencyInjectionBase
-import net.corda.testing.driver.DriverDSL
 import net.corda.testing.driver.DriverDSLExposedInterface
 import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.driver
 import net.corda.testing.node.MockServices
-import net.corda.testing.resetTestSerialization
-import org.junit.Assert.*
+import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Test
 import java.net.URLClassLoader
 import java.nio.file.Files
-import java.sql.Driver
-import kotlin.test.assertFails
 import kotlin.test.assertFailsWith
 
 class AttachmentLoadingTests : TestDependencyInjectionBase() {
diff --git a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
index 30ec451570..4cdcbc42e4 100644
--- a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
@@ -51,6 +51,8 @@ import org.assertj.core.api.Assertions.assertThat
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
 import rx.Observable
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
@@ -69,7 +71,15 @@ import kotlin.test.assertTrue
  *
  * We assume that Alice and Bob already found each other via some market, and have agreed the details already.
  */
-class TwoPartyTradeFlowTests {
+@RunWith(Parameterized::class)
+class TwoPartyTradeFlowTests(val anonymous: Boolean) {
+    companion object {
+        @JvmStatic
+        @Parameterized.Parameters
+        fun data(): Collection<Boolean> {
+            return listOf(true, false)
+        }
+    }
     private lateinit var mockNet: MockNetwork
 
     @Before
@@ -542,8 +552,7 @@ class TwoPartyTradeFlowTests {
     private fun runBuyerAndSeller(notary: Party,
                                   sellerNode: StartedNode<MockNetwork.MockNode>,
                                   buyerNode: StartedNode<MockNetwork.MockNode>,
-                                  assetToSell: StateAndRef<OwnableState>,
-                                  anonymous: Boolean = true): RunResult {
+                                  assetToSell: StateAndRef<OwnableState>): RunResult {
         val buyerFlows: Observable<out FlowLogic<*>> = buyerNode.internals.registerInitiatedFlow(BuyerAcceptor::class.java)
         val firstBuyerFiber = buyerFlows.toFuture().map { it.stateMachine }
         val seller = SellerInitiator(buyerNode.info.chooseIdentity(), notary, assetToSell, 1000.DOLLARS, anonymous)
diff --git a/samples/network-visualiser/build.gradle b/samples/network-visualiser/build.gradle
index 72ba1207c3..bad1295dbc 100644
--- a/samples/network-visualiser/build.gradle
+++ b/samples/network-visualiser/build.gradle
@@ -5,10 +5,10 @@ apply plugin: 'application'
 apply plugin: 'net.corda.plugins.quasar-utils'
 apply plugin: 'us.kirchmeier.capsule'
 
-dependencies {
-    compile project(':samples:irs-demo')
-    compile project(':node-driver')
+// Warning: The network visualiser is not a Cordapp so please do not use it as an example of how
+// to build a cordapp
 
+dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"
     testCompile "junit:junit:$junit_version"
 
@@ -17,8 +17,10 @@ dependencies {
     compile project(path: ":webserver:webcapsule", configuration: 'runtimeArtifacts')
     compile project(':core')
     compile project(':finance')
+    compile project(':node-driver')
+    compile project(':finance')
+    compile project(':samples:irs-demo')
 
-    // Cordapp dependencies
     // GraphStream: For visualisation
     compileOnly "co.paralleluniverse:capsule:$capsule_version"
 }
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
index faec432e7b..47483f7610 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
@@ -21,6 +21,7 @@ import net.corda.testing.node.InMemoryMessagingNetwork
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.TestClock
 import net.corda.testing.node.setTo
+import net.corda.testing.setCordappPackages
 import net.corda.testing.testNodeConfiguration
 import rx.Observable
 import rx.subjects.PublishSubject
@@ -261,6 +262,7 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
     val networkInitialisationFinished = allOf(*mockNet.nodes.map { it.nodeReadyFuture.toCompletableFuture() }.toTypedArray())
 
     fun start(): Future<Unit> {
+        setCordappPackages("net.corda.irs.contract", "net.corda.finance.contract")
         mockNet.startNodes()
         mockNet.registerIdentities()
         // Wait for all the nodes to have finished registering with the network map service.
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyContract.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyContract.kt
index 855994138e..28341e2e92 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyContract.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyContract.kt
@@ -5,11 +5,13 @@ import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.Party
 import net.corda.core.transactions.LedgerTransaction
 import net.corda.core.transactions.TransactionBuilder
-import kotlin.reflect.jvm.jvmName
 
 // The dummy contract doesn't do anything useful. It exists for testing purposes, but has to be serializable
 
 data class DummyContract(val blank: Any? = null) : Contract {
+
+    val PROGRAM_ID = "net.corda.testing.contracts.DummyContract"
+
     interface State : ContractState {
         val magicNumber: Int
     }

From 5b79def79161e68c71ec9da0470390cdfa2a0665 Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Tue, 3 Oct 2017 10:52:57 +0100
Subject: [PATCH 085/185] Add CordaRPCOps.notaryPartyFromX500Name (#1786)

---
 .../main/kotlin/net/corda/core/messaging/CordaRPCOps.kt   | 8 ++++++++
 .../kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt     | 2 ++
 2 files changed, 10 insertions(+)

diff --git a/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt b/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
index 60979b02cb..9fddfead5d 100644
--- a/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
+++ b/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
@@ -256,6 +256,14 @@ interface CordaRPCOps : RPCOps {
     /** Returns the [Party] with the X.500 principal as it's [Party.name]. */
     fun wellKnownPartyFromX500Name(x500Name: CordaX500Name): Party?
 
+    /**
+     * Get a notary identity by name.
+     *
+     * @return the notary identity, or null if there is no notary by that name. Note that this will return null if there
+     * is a peer with that name but they are not a recognised notary service.
+     */
+    fun notaryPartyFromX500Name(x500Name: CordaX500Name): Party?
+
     /**
      * Returns a list of candidate matches for a given string, with optional fuzzy(ish) matching. Fuzzy matching may
      * get smarter with time e.g. to correct spelling errors, so you should not hard-code indexes into the results
diff --git a/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt b/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt
index c902e8964a..08045171c5 100644
--- a/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt
@@ -200,6 +200,8 @@ class CordaRPCOpsImpl(
         }
     }
 
+    override fun notaryPartyFromX500Name(x500Name: CordaX500Name): Party? = services.networkMapCache.getNotary(x500Name)
+
     override fun partiesFromName(query: String, exactMatch: Boolean): Set<Party> {
         return database.transaction {
             services.identityService.partiesFromName(query, exactMatch)

From f5784f718d3c2fb60a67d1218d8a8e1f5927bff0 Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Tue, 3 Oct 2017 10:54:35 +0100
Subject: [PATCH 086/185] Remove database transaction from
 notaryPartyFromX500Name (#1786)

Remove database transaction from notaryPartyFromX500Name as it doesn't touch the database
---
 .../main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt  | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt b/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt
index 08045171c5..ee685466d3 100644
--- a/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/CordaRPCOpsImpl.kt
@@ -176,11 +176,7 @@ class CordaRPCOpsImpl(
 
     override fun currentNodeTime(): Instant = Instant.now(services.clock)
 
-    override fun waitUntilNetworkReady(): CordaFuture<Void?> {
-        return database.transaction {
-            services.networkMapCache.nodeReady
-        }
-    }
+    override fun waitUntilNetworkReady(): CordaFuture<Void?> = services.networkMapCache.nodeReady
 
     override fun wellKnownPartyFromAnonymous(party: AbstractParty): Party? {
         return database.transaction {

From 2ca140d7f78d190b4171f2ba8e9b87555ca9d3ba Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Wed, 4 Oct 2017 08:51:26 +0100
Subject: [PATCH 087/185] CORDA-540: Allow AMQP switch for storage context
 (#1799)

---
 .../persistence/HibernateConfigurationTest.kt     |  7 ++++---
 .../net/corda/testing/SerializationTestHelpers.kt | 15 +++++++--------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
index 79c4650c61..54c7f933c8 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
@@ -10,6 +10,7 @@ import net.corda.core.node.services.Vault
 import net.corda.core.node.services.VaultService
 import net.corda.core.schemas.CommonSchemaV1
 import net.corda.core.schemas.PersistentStateRef
+import net.corda.core.serialization.SerializationDefaults
 import net.corda.core.serialization.deserialize
 import net.corda.core.transactions.SignedTransaction
 import net.corda.finance.DOLLARS
@@ -140,7 +141,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
 
         // execute query
         val queryResults = entityManager.createQuery(criteriaQuery).resultList
-        val coins = queryResults.map { it.contractState.deserialize<TransactionState<Cash.State>>().data }.sumCash()
+        val coins = queryResults.map { it.contractState.deserialize<TransactionState<Cash.State>>(context = SerializationDefaults.STORAGE_CONTEXT).data }.sumCash()
         assertThat(coins.toDecimal() >= BigDecimal("50.00"))
     }
 
@@ -661,7 +662,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
         val queryResults = entityManager.createQuery(criteriaQuery).resultList
 
         queryResults.forEach {
-            val contractState = it.contractState.deserialize<TransactionState<ContractState>>()
+            val contractState = it.contractState.deserialize<TransactionState<ContractState>>(context = SerializationDefaults.STORAGE_CONTEXT)
             val cashState = contractState.data as Cash.State
             println("${it.stateRef} with owner: ${cashState.owner.owningKey.toBase58String()}") }
 
@@ -745,7 +746,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
         // execute query
         val queryResults = entityManager.createQuery(criteriaQuery).resultList
         queryResults.forEach {
-            val contractState = it.contractState.deserialize<TransactionState<ContractState>>()
+            val contractState = it.contractState.deserialize<TransactionState<ContractState>>(context = SerializationDefaults.STORAGE_CONTEXT)
             val cashState = contractState.data as Cash.State
             println("${it.stateRef} with owner ${cashState.owner.owningKey.toBase58String()} and participants ${cashState.participants.map { it.owningKey.toBase58String() }}")
         }
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt
index 73884f6cab..c3f5872cd7 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt
@@ -68,19 +68,18 @@ fun initialiseTestSerialization() {
         registerScheme(AMQPServerSerializationScheme())
     }
 
-    val AMQP_ENABLE_PROP_NAME = "net.corda.testing.amqp.enable"
-    // TODO: Remove these "if" conditions once we fully switched to AMQP
-    (SerializationDefaults.P2P_CONTEXT as TestSerializationContext).delegate = if (java.lang.Boolean.getBoolean(AMQP_ENABLE_PROP_NAME)) {
-        AMQP_P2P_CONTEXT
-    } else {
-        KRYO_P2P_CONTEXT
-    }
+    (SerializationDefaults.P2P_CONTEXT as TestSerializationContext).delegate = if (isAmqpEnabled()) AMQP_P2P_CONTEXT else KRYO_P2P_CONTEXT
     (SerializationDefaults.RPC_SERVER_CONTEXT as TestSerializationContext).delegate = KRYO_RPC_SERVER_CONTEXT
     (SerializationDefaults.RPC_CLIENT_CONTEXT as TestSerializationContext).delegate = KRYO_RPC_CLIENT_CONTEXT
-    (SerializationDefaults.STORAGE_CONTEXT as TestSerializationContext).delegate = KRYO_STORAGE_CONTEXT
+    (SerializationDefaults.STORAGE_CONTEXT as TestSerializationContext).delegate = if (isAmqpEnabled()) AMQP_STORAGE_CONTEXT else KRYO_STORAGE_CONTEXT
     (SerializationDefaults.CHECKPOINT_CONTEXT as TestSerializationContext).delegate = KRYO_CHECKPOINT_CONTEXT
 }
 
+private const val AMQP_ENABLE_PROP_NAME = "net.corda.testing.amqp.enable"
+
+// TODO: Remove usages of this function when we fully switched to AMQP
+private fun isAmqpEnabled(): Boolean = java.lang.Boolean.getBoolean(AMQP_ENABLE_PROP_NAME)
+
 fun resetTestSerialization() {
     (SerializationDefaults.SERIALIZATION_FACTORY as TestSerializationFactory).delegate = null
     (SerializationDefaults.P2P_CONTEXT as TestSerializationContext).delegate = null

From 46532ccbcb6a5084efb9c1ac12a1850c9c34cb5d Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Thu, 5 Oct 2017 09:14:00 +0100
Subject: [PATCH 088/185] Don't repackage well known key types (#1545)

* Don't repackage well known key types when converting keys to a well known type
* Remove custom key serializers
* Remove duplicate serializer registration
---
 .../kotlin/net/corda/core/crypto/Crypto.kt    | 21 ++++++-
 .../serialization/DefaultKryoCustomizer.kt    |  9 ++-
 .../nodeapi/internal/serialization/Kryo.kt    | 60 -------------------
 3 files changed, 23 insertions(+), 67 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt b/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt
index 605b95466c..b6df5e2bc9 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt
@@ -941,7 +941,16 @@ object Crypto {
      * is inappropriate for a supported key factory to produce a private key.
      */
     @JvmStatic
-    fun toSupportedPublicKey(key: PublicKey): PublicKey = decodePublicKey(key.encoded)
+    fun toSupportedPublicKey(key: PublicKey): PublicKey {
+        return when (key) {
+            is BCECPublicKey -> key
+            is BCRSAPublicKey -> key
+            is BCSphincs256PublicKey -> key
+            is EdDSAPublicKey -> key
+            is CompositeKey -> key
+            else -> decodePublicKey(key.encoded)
+        }
+    }
 
     /**
      * Convert a private key to a supported implementation. This can be used to convert a SUN's EC key to an BC key.
@@ -952,5 +961,13 @@ object Crypto {
      * is inappropriate for a supported key factory to produce a private key.
      */
     @JvmStatic
-    fun toSupportedPrivateKey(key: PrivateKey): PrivateKey = decodePrivateKey(key.encoded)
+    fun toSupportedPrivateKey(key: PrivateKey): PrivateKey {
+        return when (key) {
+            is BCECPrivateKey -> key
+            is BCRSAPrivateKey -> key
+            is BCSphincs256PrivateKey -> key
+            is EdDSAPrivateKey -> key
+            else -> decodePrivateKey(key.encoded)
+        }
+    }
 }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt
index d4a6f11ee2..04104533ee 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt
@@ -88,10 +88,10 @@ object DefaultKryoCustomizer {
             register(BufferedInputStream::class.java, InputStreamSerializer)
             register(Class.forName("sun.net.www.protocol.jar.JarURLConnection\$JarURLInputStream"), InputStreamSerializer)
             noReferencesWithin<WireTransaction>()
-            register(ECPublicKeyImpl::class.java, ECPublicKeyImplSerializer)
-            register(EdDSAPublicKey::class.java, Ed25519PublicKeySerializer)
-            register(EdDSAPrivateKey::class.java, Ed25519PrivateKeySerializer)
-            register(CompositeKey::class.java, CompositeKeySerializer)  // Using a custom serializer for compactness
+            register(ECPublicKeyImpl::class.java, PublicKeySerializer)
+            register(EdDSAPublicKey::class.java, PublicKeySerializer)
+            register(EdDSAPrivateKey::class.java, PrivateKeySerializer)
+            register(CompositeKey::class.java, PublicKeySerializer)  // Using a custom serializer for compactness
             // Exceptions. We don't bother sending the stack traces as the client will fill in its own anyway.
             register(Array<StackTraceElement>::class, read = { _, _ -> emptyArray() }, write = { _, _, _ -> })
             // This ensures a NonEmptySetSerializer is constructed with an initial value.
@@ -109,7 +109,6 @@ object DefaultKryoCustomizer {
             register(BCRSAPublicKey::class.java, PublicKeySerializer)
             register(BCSphincs256PrivateKey::class.java, PrivateKeySerializer)
             register(BCSphincs256PublicKey::class.java, PublicKeySerializer)
-            register(sun.security.ec.ECPublicKeyImpl::class.java, PublicKeySerializer)
             register(NotaryChangeWireTransaction::class.java, NotaryChangeWireTransactionSerializer)
             register(PartyAndCertificate::class.java, PartyAndCertificateSerializer)
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
index 82234df40b..2905922460 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
@@ -285,66 +285,6 @@ object SignedTransactionSerializer : Serializer<SignedTransaction>() {
     }
 }
 
-/** For serialising an ed25519 private key */
-@ThreadSafe
-object Ed25519PrivateKeySerializer : Serializer<EdDSAPrivateKey>() {
-    override fun write(kryo: Kryo, output: Output, obj: EdDSAPrivateKey) {
-        check(obj.params == Crypto.EDDSA_ED25519_SHA512.algSpec)
-        output.writeBytesWithLength(obj.seed)
-    }
-
-    override fun read(kryo: Kryo, input: Input, type: Class<EdDSAPrivateKey>): EdDSAPrivateKey {
-        val seed = input.readBytesWithLength()
-        return EdDSAPrivateKey(EdDSAPrivateKeySpec(seed, Crypto.EDDSA_ED25519_SHA512.algSpec as EdDSANamedCurveSpec))
-    }
-}
-
-/** For serialising an ed25519 public key */
-@ThreadSafe
-object Ed25519PublicKeySerializer : Serializer<EdDSAPublicKey>() {
-    override fun write(kryo: Kryo, output: Output, obj: EdDSAPublicKey) {
-        check(obj.params == Crypto.EDDSA_ED25519_SHA512.algSpec)
-        output.writeBytesWithLength(obj.abyte)
-    }
-
-    override fun read(kryo: Kryo, input: Input, type: Class<EdDSAPublicKey>): EdDSAPublicKey {
-        val A = input.readBytesWithLength()
-        return EdDSAPublicKey(EdDSAPublicKeySpec(A, Crypto.EDDSA_ED25519_SHA512.algSpec as EdDSANamedCurveSpec))
-    }
-}
-
-/** For serialising an ed25519 public key */
-@ThreadSafe
-object ECPublicKeyImplSerializer : Serializer<ECPublicKeyImpl>() {
-    override fun write(kryo: Kryo, output: Output, obj: ECPublicKeyImpl) {
-        output.writeBytesWithLength(obj.encoded)
-    }
-
-    override fun read(kryo: Kryo, input: Input, type: Class<ECPublicKeyImpl>): ECPublicKeyImpl {
-        val A = input.readBytesWithLength()
-        val der = DerValue(A)
-        return ECPublicKeyImpl.parse(der) as ECPublicKeyImpl
-    }
-}
-
-// TODO Implement standardized serialization of CompositeKeys. See JIRA issue: CORDA-249.
-@ThreadSafe
-object CompositeKeySerializer : Serializer<CompositeKey>() {
-    override fun write(kryo: Kryo, output: Output, obj: CompositeKey) {
-        output.writeInt(obj.threshold)
-        output.writeInt(obj.children.size)
-        obj.children.forEach { kryo.writeClassAndObject(output, it) }
-    }
-
-    override fun read(kryo: Kryo, input: Input, type: Class<CompositeKey>): CompositeKey {
-        val threshold = input.readInt()
-        val children = readListOfLength<CompositeKey.NodeAndWeight>(kryo, input, minLen = 2)
-        val builder = CompositeKey.Builder()
-        children.forEach { builder.addKey(it.node, it.weight) }
-        return builder.build(threshold) as CompositeKey
-    }
-}
-
 @ThreadSafe
 object PrivateKeySerializer : Serializer<PrivateKey>() {
     override fun write(kryo: Kryo, output: Output, obj: PrivateKey) {

From 257756d8628c4f070ad3a1a7ddfa8997bd6f2f11 Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Thu, 5 Oct 2017 10:33:35 +0100
Subject: [PATCH 089/185] Change IdentitySyncFlow to only offer own identities
 (#1740)

Change IdentitySyncFlow to only offer confidential identities matching the identity the flow is run as. This avoids risks of nodes being convinced to include a state with a confidential identity in it, by a remote node, then feeding the well known identity to the node during identity sync.
---
 .../corda/confidential/IdentitySyncFlow.kt    | 31 ++++++++-------
 .../confidential/IdentitySyncFlowTests.kt     | 38 ++++++++++++++++++-
 2 files changed, 55 insertions(+), 14 deletions(-)

diff --git a/confidential-identities/src/main/kotlin/net/corda/confidential/IdentitySyncFlow.kt b/confidential-identities/src/main/kotlin/net/corda/confidential/IdentitySyncFlow.kt
index 01f520afda..b454556bf3 100644
--- a/confidential-identities/src/main/kotlin/net/corda/confidential/IdentitySyncFlow.kt
+++ b/confidential-identities/src/main/kotlin/net/corda/confidential/IdentitySyncFlow.kt
@@ -12,14 +12,12 @@ import net.corda.core.utilities.unwrap
 
 object IdentitySyncFlow {
     /**
-     * Flow for ensuring that one or more counterparties to a transaction have the full certificate paths of confidential
-     * identities used in the transaction. This is intended for use as a subflow of another flow, typically between
+     * Flow for ensuring that our counterparties in a transaction have the full certificate paths for *our* confidential
+     * identities used in states present in the transaction. This is intended for use as a subflow of another flow, typically between
      * transaction assembly and signing. An example of where this is useful is where a recipient of a [Cash] state wants
      * to know that it is being paid by the correct party, and the owner of the state is a confidential identity of that
      * party. This flow would send a copy of the confidential identity path to the recipient, enabling them to verify that
      * identity.
-     *
-     * @return a mapping of well known identities to the confidential identities used in the transaction.
      */
     // TODO: Can this be triggered automatically from [SendTransactionFlow]
     class Send(val otherSideSessions: Set<FlowSession>,
@@ -36,17 +34,10 @@ object IdentitySyncFlow {
         @Suspendable
         override fun call() {
             progressTracker.currentStep = SYNCING_IDENTITIES
-            val states: List<ContractState> = (tx.inputs.map { serviceHub.loadState(it) }.requireNoNulls().map { it.data } + tx.outputs.map { it.data })
-            val identities: Set<AbstractParty> = states.flatMap { it.participants }.toSet()
-            // Filter participants down to the set of those not in the network map (are not well known)
-            val confidentialIdentities = identities
-                    .filter { serviceHub.networkMapCache.getNodesByLegalIdentityKey(it.owningKey).isEmpty() }
-                    .toList()
-            val identityCertificates: Map<AbstractParty, PartyAndCertificate?> = identities
-                    .map { Pair(it, serviceHub.identityService.certificateFromKey(it.owningKey)) }.toMap()
+            val identityCertificates: Map<AbstractParty, PartyAndCertificate?> = extractOurConfidentialIdentities()
 
             otherSideSessions.forEach { otherSideSession ->
-                val requestedIdentities: List<AbstractParty> = otherSideSession.sendAndReceive<List<AbstractParty>>(confidentialIdentities).unwrap { req ->
+                val requestedIdentities: List<AbstractParty> = otherSideSession.sendAndReceive<List<AbstractParty>>(identityCertificates.keys.toList()).unwrap { req ->
                     require(req.all { it in identityCertificates.keys }) { "${otherSideSession.counterparty} requested a confidential identity not part of transaction: ${tx.id}" }
                     req
                 }
@@ -61,6 +52,20 @@ object IdentitySyncFlow {
             }
         }
 
+        private fun extractOurConfidentialIdentities(): Map<AbstractParty, PartyAndCertificate?> {
+            val states: List<ContractState> = (tx.inputs.map { serviceHub.loadState(it) }.requireNoNulls().map { it.data } + tx.outputs.map { it.data })
+            val identities: Set<AbstractParty> = states.flatMap(ContractState::participants).toSet()
+            // Filter participants down to the set of those not in the network map (are not well known)
+            val confidentialIdentities = identities
+                    .filter { serviceHub.networkMapCache.getNodesByLegalIdentityKey(it.owningKey).isEmpty() }
+                    .toList()
+            return confidentialIdentities
+                    .map { Pair(it, serviceHub.identityService.certificateFromKey(it.owningKey)) }
+                    // Filter down to confidential identities of our well known identity
+                    // TODO: Consider if this too restrictive - we perhaps should be checking the name on the signing certificate in the certificate path instead
+                    .filter { it.second?.name == ourIdentity.name }
+                    .toMap()
+        }
     }
 
     /**
diff --git a/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt b/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
index 1fe89e43ec..ac5863d818 100644
--- a/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
+++ b/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
@@ -13,12 +13,14 @@ import net.corda.core.utilities.unwrap
 import net.corda.finance.DOLLARS
 import net.corda.finance.contracts.asset.Cash
 import net.corda.finance.flows.CashIssueAndPaymentFlow
+import net.corda.finance.flows.CashPaymentFlow
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 
 class IdentitySyncFlowTests {
@@ -45,12 +47,12 @@ class IdentitySyncFlowTests {
         val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
         val alice: Party = aliceNode.services.myInfo.chooseIdentity()
         val bob: Party = bobNode.services.myInfo.chooseIdentity()
+        val notary = notaryNode.services.getDefaultNotary()
         bobNode.internals.registerInitiatedFlow(Receive::class.java)
 
         // Alice issues then pays some cash to a new confidential identity that Bob doesn't know about
         val anonymous = true
         val ref = OpaqueBytes.of(0x01)
-        val notary = aliceNode.services.getDefaultNotary()
         val issueFlow = aliceNode.services.startFlow(CashIssueAndPaymentFlow(1000.DOLLARS, ref, alice, anonymous, notary))
         val issueTx = issueFlow.resultFuture.getOrThrow().stx
         val confidentialIdentity = issueTx.tx.outputs.map { it.data }.filterIsInstance<Cash.State>().single().owner
@@ -67,6 +69,40 @@ class IdentitySyncFlowTests {
         assertEquals(expected, actual)
     }
 
+    @Test
+    fun `don't offer other's identities confidential identities`() {
+        // Set up values we'll need
+        val notaryNode = mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+        val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
+        val charlieNode = mockNet.createPartyNode(notaryNode.network.myAddress, CHARLIE.name)
+        val alice: Party = aliceNode.services.myInfo.chooseIdentity()
+        val bob: Party = bobNode.services.myInfo.chooseIdentity()
+        val charlie: Party = charlieNode.services.myInfo.chooseIdentity()
+        val notary = notaryNode.services.getDefaultNotary()
+        bobNode.internals.registerInitiatedFlow(Receive::class.java)
+
+        // Charlie issues then pays some cash to a new confidential identity
+        val anonymous = true
+        val ref = OpaqueBytes.of(0x01)
+        val issueFlow = charlieNode.services.startFlow(CashIssueAndPaymentFlow(1000.DOLLARS, ref, charlie, anonymous, notary))
+        val issueTx = issueFlow.resultFuture.getOrThrow().stx
+        val confidentialIdentity = issueTx.tx.outputs.map { it.data }.filterIsInstance<Cash.State>().single().owner
+        val confidentialIdentCert = charlieNode.services.identityService.certificateFromKey(confidentialIdentity.owningKey)!!
+
+        // Manually inject this identity into Alice's database so the node could leak it, but we prove won't
+        aliceNode.database.transaction { aliceNode.services.identityService.verifyAndRegisterIdentity(confidentialIdentCert) }
+        assertNotNull(aliceNode.database.transaction { aliceNode.services.identityService.wellKnownPartyFromAnonymous(confidentialIdentity) })
+
+        // Generate a payment from Charlie to Alice, including the confidential state
+        val payTx = charlieNode.services.startFlow(CashPaymentFlow(1000.DOLLARS, alice, anonymous)).resultFuture.getOrThrow().stx
+
+        // Run the flow to sync up the identities, and confirm Charlie's confidential identity doesn't leak
+        assertNull(bobNode.database.transaction { bobNode.services.identityService.wellKnownPartyFromAnonymous(confidentialIdentity) })
+        aliceNode.services.startFlow(Initiator(bob, payTx.tx)).resultFuture.getOrThrow()
+        assertNull(bobNode.database.transaction { bobNode.services.identityService.wellKnownPartyFromAnonymous(confidentialIdentity) })
+    }
+
     /**
      * Very lightweight wrapping flow to trigger the counterparty flow that receives the identities.
      */

From cf83328d5da82ee71bd6343db608e57b49f45c56 Mon Sep 17 00:00:00 2001
From: Alberto Arri <30873160+al-r3@users.noreply.github.com>
Date: Thu, 5 Oct 2017 14:11:10 +0100
Subject: [PATCH 090/185] Add filesystem polling to nodes (#1623)

Add the logic in node to poll for new serialized nodes to appear on disk.

Newly discovered nodes are automatically added to the PersistentNetworkMapCache
---
 docs/source/changelog.rst                     |   3 +-
 .../net/corda/node/internal/AbstractNode.kt   |   3 +-
 .../services/network/NodeInfoSerializer.kt    |  85 ----------
 .../node/services/network/NodeInfoWatcher.kt  | 150 ++++++++++++++++++
 .../network/PersistentNetworkMapCache.kt      |   9 +-
 .../network/NodeInfoSerializerTest.kt         |  67 --------
 .../services/network/NodeInfoWatcherTest.kt   | 113 +++++++++++++
 7 files changed, 271 insertions(+), 159 deletions(-)
 delete mode 100644 node/src/main/kotlin/net/corda/node/services/network/NodeInfoSerializer.kt
 create mode 100644 node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
 delete mode 100644 node/src/test/kotlin/net/corda/node/services/network/NodeInfoSerializerTest.kt
 create mode 100644 node/src/test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt

diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index 0012e64902..c996b4254b 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -11,7 +11,8 @@ UNRELEASED
   * Cordform may not specify a value for ``NetworkMap``, when that happens, during the task execution the following happens:
     1. Each node is started and its signed serialized NodeInfo is written to disk in the node base directory.
     2. Every serialized ``NodeInfo`` above is copied in every other node "additional-node-info" folder under the NodeInfo folder.
-  * Nodes read all the nodes stored in ``additional-node-info`` when the ``NetworkMapService`` starts up.
+
+* Nodes read and poll the filesystem for serialized ``NodeInfo`` in the ``additional-node-info`` directory.
 
 * ``Cordapp`` now has a name field for identifying CorDapps and all CorDapp names are printed to console at startup.
 
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 3472db31b4..d8146ff1fe 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -170,7 +170,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
     }
 
     private fun saveOwnNodeInfo() {
-        NodeInfoSerializer().saveToFile(configuration.baseDirectory, info, services.keyManagementService)
+        NodeInfoWatcher.saveToFile(configuration.baseDirectory, info, services.keyManagementService)
     }
 
     private fun initCertificate() {
@@ -409,7 +409,6 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
                 services.transactionVerifierService, services.validatedTransactions, services.contractUpgradeService,
                 services, cordappProvider, this)
         makeNetworkServices(tokenizableServices)
-
         return tokenizableServices
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoSerializer.kt b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoSerializer.kt
deleted file mode 100644
index 925f393b7a..0000000000
--- a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoSerializer.kt
+++ /dev/null
@@ -1,85 +0,0 @@
-package net.corda.node.services.network
-
-import net.corda.cordform.CordformNode
-import net.corda.core.crypto.SecureHash
-import net.corda.core.crypto.SignedData
-import net.corda.core.internal.createDirectories
-import net.corda.core.internal.div
-import net.corda.core.internal.isDirectory
-import net.corda.core.node.NodeInfo
-import net.corda.core.node.services.KeyManagementService
-import net.corda.core.serialization.deserialize
-import net.corda.core.serialization.serialize
-import net.corda.core.utilities.ByteSequence
-import net.corda.core.utilities.loggerFor
-import java.io.File
-import java.nio.file.Files
-import java.nio.file.Path
-
-/**
- * Class containing the logic to serialize and de-serialize a [NodeInfo] to disk and reading it back.
- */
-class NodeInfoSerializer {
-
-    companion object {
-        val logger = loggerFor<NodeInfoSerializer>()
-    }
-
-    /**
-     * Saves the given [NodeInfo] to a path.
-     * The node is 'encoded' as a SignedData<NodeInfo>, signed with the owning key of its first identity.
-     * The name of the written file will be "nodeInfo-" followed by the hash of the content. The hash in the filename
-     * is used so that one can freely copy these files without fearing to overwrite another one.
-     *
-     * @param path the path where to write the file, if non-existent it will be created.
-     * @param nodeInfo the NodeInfo to serialize.
-     * @param keyManager a KeyManagementService used to sign the NodeInfo data.
-     */
-    fun saveToFile(path: Path, nodeInfo: NodeInfo, keyManager: KeyManagementService) {
-        try {
-            path.createDirectories()
-            val serializedBytes = nodeInfo.serialize()
-            val regSig = keyManager.sign(serializedBytes.bytes, nodeInfo.legalIdentities.first().owningKey)
-            val signedData = SignedData(serializedBytes, regSig)
-            val file = (path / ("nodeInfo-" + SecureHash.sha256(serializedBytes.bytes).toString())).toFile()
-            file.writeBytes(signedData.serialize().bytes)
-        } catch (e : Exception) {
-            logger.warn("Couldn't write node info to file: $e")
-        }
-    }
-
-    /**
-     * Loads all the files contained in a given path and returns the deserialized [NodeInfo]s.
-     * Signatures are checked before returning a value.
-     *
-     * @param nodePath the node base path. NodeInfo files are searched for in nodePath/[NODE_INFO_FOLDER]
-     * @return a list of [NodeInfo]s
-     */
-    fun loadFromDirectory(nodePath: Path): List<NodeInfo> {
-        val result = mutableListOf<NodeInfo>()
-        val nodeInfoDirectory = nodePath / CordformNode.NODE_INFO_DIRECTORY
-        if (!nodeInfoDirectory.isDirectory()) {
-            logger.info("$nodeInfoDirectory isn't a Directory, not loading NodeInfo from files")
-            return result
-        }
-        for (path in Files.list(nodeInfoDirectory)) {
-            val file = path.toFile()
-            if (file.isFile) {
-                try {
-                    logger.info("Reading NodeInfo from file: $file")
-                    val nodeInfo = loadFromFile(file)
-                    result.add(nodeInfo)
-                } catch (e: Exception) {
-                    logger.error("Exception parsing NodeInfo from file. $file" , e)
-                }
-            }
-        }
-        logger.info("Succesfully read ${result.size} NodeInfo files.")
-        return result
-    }
-
-    private fun loadFromFile(file: File): NodeInfo {
-        val signedData = ByteSequence.of(file.readBytes()).deserialize<SignedData<NodeInfo>>()
-        return signedData.verified()
-    }
-}
\ No newline at end of file
diff --git a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
new file mode 100644
index 0000000000..2d4db9e3fa
--- /dev/null
+++ b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
@@ -0,0 +1,150 @@
+package net.corda.node.services.network
+
+import net.corda.cordform.CordformNode
+import net.corda.core.crypto.SecureHash
+import net.corda.core.crypto.SignedData
+import net.corda.core.internal.*
+import net.corda.core.node.NodeInfo
+import net.corda.core.node.services.KeyManagementService
+import net.corda.core.serialization.deserialize
+import net.corda.core.serialization.serialize
+import net.corda.core.utilities.loggerFor
+import rx.Observable
+import rx.Scheduler
+import rx.schedulers.Schedulers
+import java.nio.file.Path
+import java.nio.file.StandardWatchEventKinds
+import java.nio.file.WatchEvent
+import java.nio.file.WatchKey
+import java.nio.file.WatchService
+import java.util.concurrent.TimeUnit
+import kotlin.streams.toList
+
+/**
+ * Class containing the logic to
+ * - Serialize and de-serialize a [NodeInfo] to disk and reading it back.
+ * - Poll a directory for new serialized [NodeInfo]
+ *
+ * @param path the base path of a node.
+ * @param scheduler a [Scheduler] for the rx [Observable] returned by [nodeInfoUpdates], this is mainly useful for
+ *        testing. It defaults to the io scheduler which is the appropriate value for production uses.
+ */
+class NodeInfoWatcher(private val nodePath: Path,
+                      private val scheduler: Scheduler = Schedulers.io()) {
+
+    private val nodeInfoDirectory = nodePath / CordformNode.NODE_INFO_DIRECTORY
+    private val watchService : WatchService? by lazy { initWatch() }
+
+    companion object {
+        private val logger = loggerFor<NodeInfoWatcher>()
+
+        /**
+         * Saves the given [NodeInfo] to a path.
+         * The node is 'encoded' as a SignedData<NodeInfo>, signed with the owning key of its first identity.
+         * The name of the written file will be "nodeInfo-" followed by the hash of the content. The hash in the filename
+         * is used so that one can freely copy these files without fearing to overwrite another one.
+         *
+         * @param path the path where to write the file, if non-existent it will be created.
+         * @param nodeInfo the NodeInfo to serialize.
+         * @param keyManager a KeyManagementService used to sign the NodeInfo data.
+         */
+        fun saveToFile(path: Path, nodeInfo: NodeInfo, keyManager: KeyManagementService) {
+            try {
+                path.createDirectories()
+                val serializedBytes = nodeInfo.serialize()
+                val regSig = keyManager.sign(serializedBytes.bytes,
+                        nodeInfo.legalIdentities.first().owningKey)
+                val signedData = SignedData(serializedBytes, regSig)
+                val file = (path / ("nodeInfo-" + SecureHash.sha256(serializedBytes.bytes).toString())).toFile()
+                file.writeBytes(signedData.serialize().bytes)
+            } catch (e: Exception) {
+                logger.warn("Couldn't write node info to file", e)
+            }
+        }
+    }
+
+    /**
+     * Read all the files contained in [nodePath] / [CordformNode.NODE_INFO_DIRECTORY] and keep watching
+     * the folder for further updates.
+     *
+     * @return an [Observable] returning [NodeInfo]s, there is no guarantee that the same value isn't returned more
+     *      than once.
+     */
+    fun nodeInfoUpdates(): Observable<NodeInfo> {
+        val pollForFiles = Observable.interval(5, TimeUnit.SECONDS, scheduler)
+                .flatMapIterable { pollWatch() }
+        val readCurrentFiles = Observable.from(loadFromDirectory())
+        return readCurrentFiles.mergeWith(pollForFiles)
+    }
+
+    /**
+     * Loads all the files contained in a given path and returns the deserialized [NodeInfo]s.
+     * Signatures are checked before returning a value.
+     *
+     * @return a list of [NodeInfo]s
+     */
+    private fun loadFromDirectory(): List<NodeInfo> {
+        val nodeInfoDirectory = nodePath / CordformNode.NODE_INFO_DIRECTORY
+        if (!nodeInfoDirectory.isDirectory()) {
+            logger.info("$nodeInfoDirectory isn't a Directory, not loading NodeInfo from files")
+            return emptyList()
+        }
+        val result = nodeInfoDirectory.list { paths ->
+            paths.filter { it.isRegularFile() }
+                    .map { processFile(it) }
+                    .toList()
+                    .filterNotNull()
+        }
+        logger.info("Successfully read ${result.size} NodeInfo files.")
+        return result
+    }
+
+    // Polls the watchService for changes to nodeInfoDirectory, return all the newly read NodeInfos.
+    private fun pollWatch(): List<NodeInfo> {
+        if (watchService == null) {
+            return emptyList()
+        }
+        val watchKey: WatchKey = watchService?.poll() ?: return emptyList()
+        val files = mutableSetOf<Path>()
+        for (event in watchKey.pollEvents()) {
+            val kind = event.kind()
+            if (kind == StandardWatchEventKinds.OVERFLOW) continue
+
+            val ev: WatchEvent<Path> = uncheckedCast(event)
+            val filename = ev.context()
+            val absolutePath = nodeInfoDirectory.resolve(filename)
+            if (absolutePath.isRegularFile()) {
+                files.add(absolutePath)
+            }
+        }
+        val valid = watchKey.reset()
+        if (!valid) {
+            logger.warn("Can't poll $nodeInfoDirectory anymore, it was probably deleted.")
+        }
+        return files.mapNotNull { processFile(it) }
+    }
+
+    private fun processFile(file: Path) : NodeInfo? {
+        try {
+            logger.info("Reading NodeInfo from file: $file")
+            val signedData = file.readAll().deserialize<SignedData<NodeInfo>>()
+            return signedData.verified()
+        } catch (e: Exception) {
+            logger.warn("Exception parsing NodeInfo from file. $file", e)
+            return null
+        }
+    }
+
+    // Create a WatchService watching for changes in nodeInfoDirectory.
+    private fun initWatch() : WatchService? {
+        if (!nodeInfoDirectory.isDirectory()) {
+            logger.warn("Not watching folder $nodeInfoDirectory it doesn't exist or it's not a directory")
+            return null
+        }
+        val watchService = nodeInfoDirectory.fileSystem.newWatchService()
+        nodeInfoDirectory.register(watchService, StandardWatchEventKinds.ENTRY_CREATE,
+                StandardWatchEventKinds.ENTRY_MODIFY)
+        logger.info("Watching $nodeInfoDirectory for new files")
+        return watchService
+    }
+}
diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
index f2f5e8396c..2dac97909a 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
@@ -1,11 +1,11 @@
 package net.corda.node.services.network
 
 import net.corda.core.concurrent.CordaFuture
-import net.corda.core.internal.bufferUntilSubscribed
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.internal.VisibleForTesting
+import net.corda.core.internal.bufferUntilSubscribed
 import net.corda.core.internal.concurrent.map
 import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.messaging.DataFeed
@@ -40,6 +40,7 @@ import java.security.PublicKey
 import java.security.SignatureException
 import java.util.*
 import javax.annotation.concurrent.ThreadSafe
+import kotlin.collections.HashMap
 
 /**
  * Extremely simple in-memory cache of the network map.
@@ -87,6 +88,8 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
                     .sortedBy { it.name.toString() }
         }
 
+    private val nodeInfoSerializer = NodeInfoWatcher(serviceHub.configuration.baseDirectory)
+
     init {
         loadFromFiles()
         serviceHub.database.transaction { loadFromDB() }
@@ -94,9 +97,7 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
 
     private fun loadFromFiles() {
         logger.info("Loading network map from files..")
-        for (node in NodeInfoSerializer().loadFromDirectory(serviceHub.configuration.baseDirectory)) {
-            addNode(node)
-        }
+        nodeInfoSerializer.nodeInfoUpdates().subscribe { node -> addNode(node) }
     }
 
     override fun getPartyInfo(party: Party): PartyInfo? {
diff --git a/node/src/test/kotlin/net/corda/node/services/network/NodeInfoSerializerTest.kt b/node/src/test/kotlin/net/corda/node/services/network/NodeInfoSerializerTest.kt
deleted file mode 100644
index 6fe8ea6a28..0000000000
--- a/node/src/test/kotlin/net/corda/node/services/network/NodeInfoSerializerTest.kt
+++ /dev/null
@@ -1,67 +0,0 @@
-package net.corda.node.services.network
-
-import net.corda.cordform.CordformNode
-import net.corda.core.internal.div
-import net.corda.core.node.NodeInfo
-import net.corda.core.node.services.KeyManagementService
-import net.corda.node.services.identity.InMemoryIdentityService
-import net.corda.testing.*
-import net.corda.testing.node.MockKeyManagementService
-import net.corda.testing.node.NodeBasedTest
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import org.junit.rules.TemporaryFolder
-import java.nio.charset.Charset
-import kotlin.test.assertEquals
-import kotlin.test.assertTrue
-import org.assertj.core.api.Assertions.assertThat
-import org.assertj.core.api.Assertions.contentOf
-
-class NodeInfoSerializerTest : NodeBasedTest() {
-
-    @Rule @JvmField var folder = TemporaryFolder()
-
-    lateinit var keyManagementService: KeyManagementService
-
-    // Object under test
-    val nodeInfoSerializer = NodeInfoSerializer()
-
-    companion object {
-        val nodeInfoFileRegex = Regex("nodeInfo\\-.*")
-        val nodeInfo = NodeInfo(listOf(), listOf(getTestPartyAndCertificate(ALICE)), 0, 0)
-    }
-
-    @Before
-    fun start() {
-        val identityService = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
-        keyManagementService = MockKeyManagementService(identityService, ALICE_KEY)
-    }
-
-    @Test
-    fun `save a NodeInfo`() {
-        nodeInfoSerializer.saveToFile(folder.root.toPath(), nodeInfo, keyManagementService)
-
-        assertEquals(1, folder.root.list().size)
-        val fileName = folder.root.list()[0]
-        assertTrue(fileName.matches(nodeInfoFileRegex))
-        val file = (folder.root.path / fileName).toFile()
-        // Just check that something is written, another tests verifies that the written value can be read back.
-        assertThat(contentOf(file)).isNotEmpty()
-    }
-
-    @Test
-    fun `load an empty Directory`() {
-        assertEquals(0, nodeInfoSerializer.loadFromDirectory(folder.root.toPath()).size)
-    }
-
-    @Test
-    fun `load a non empty Directory`() {
-        val nodeInfoFolder = folder.newFolder(CordformNode.NODE_INFO_DIRECTORY)
-        nodeInfoSerializer.saveToFile(nodeInfoFolder.toPath(), nodeInfo, keyManagementService)
-        val nodeInfos = nodeInfoSerializer.loadFromDirectory(folder.root.toPath())
-
-        assertEquals(1, nodeInfos.size)
-        assertEquals(nodeInfo, nodeInfos.first())
-    }
-}
diff --git a/node/src/test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt b/node/src/test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
new file mode 100644
index 0000000000..758374f5c9
--- /dev/null
+++ b/node/src/test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
@@ -0,0 +1,113 @@
+package net.corda.node.services.network
+
+import net.corda.cordform.CordformNode
+import net.corda.core.internal.createDirectories
+import net.corda.core.internal.div
+import net.corda.core.node.NodeInfo
+import net.corda.core.node.services.KeyManagementService
+import net.corda.node.services.identity.InMemoryIdentityService
+import net.corda.testing.*
+import net.corda.testing.node.MockKeyManagementService
+import net.corda.testing.node.NodeBasedTest
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import rx.observers.TestSubscriber
+import rx.schedulers.TestScheduler
+import java.util.concurrent.TimeUnit
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.contentOf
+import java.nio.file.Path
+
+class NodeInfoWatcherTest : NodeBasedTest() {
+
+    @Rule @JvmField var folder = TemporaryFolder()
+
+    lateinit var keyManagementService: KeyManagementService
+    lateinit var nodeInfoPath: Path
+    val scheduler = TestScheduler();
+    val testSubscriber = TestSubscriber<NodeInfo>()
+
+    // Object under test
+    lateinit var nodeInfoWatcher: NodeInfoWatcher
+
+    companion object {
+        val nodeInfoFileRegex = Regex("nodeInfo\\-.*")
+        val nodeInfo = NodeInfo(listOf(), listOf(getTestPartyAndCertificate(ALICE)), 0, 0)
+    }
+
+    @Before
+    fun start() {
+        val identityService = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        keyManagementService = MockKeyManagementService(identityService, ALICE_KEY)
+        nodeInfoWatcher = NodeInfoWatcher(folder.root.toPath(), scheduler)
+        nodeInfoPath = folder.root.toPath() / CordformNode.NODE_INFO_DIRECTORY
+    }
+
+    @Test
+    fun `save a NodeInfo`() {
+        NodeInfoWatcher.saveToFile(folder.root.toPath(), nodeInfo, keyManagementService)
+
+        assertEquals(1, folder.root.list().size)
+        val fileName = folder.root.list()[0]
+        assertTrue(fileName.matches(nodeInfoFileRegex))
+        val file = (folder.root.path / fileName).toFile()
+        // Just check that something is written, another tests verifies that the written value can be read back.
+        assertThat(contentOf(file)).isNotEmpty()
+    }
+
+    @Test
+    fun `load an empty Directory`() {
+        nodeInfoPath.createDirectories()
+
+        nodeInfoWatcher.nodeInfoUpdates()
+                .subscribe(testSubscriber)
+
+        val readNodes = testSubscriber.onNextEvents.distinct()
+        scheduler.advanceTimeBy(1, TimeUnit.HOURS)
+        assertEquals(0, readNodes.size)
+    }
+
+    @Test
+    fun `load a non empty Directory`() {
+        createNodeInfoFileInPath(nodeInfo)
+
+        nodeInfoWatcher.nodeInfoUpdates()
+                .subscribe(testSubscriber)
+
+        val readNodes = testSubscriber.onNextEvents.distinct()
+
+        assertEquals(1, readNodes.size)
+        assertEquals(nodeInfo, readNodes.first())
+    }
+
+    @Test
+    fun `polling folder`() {
+        nodeInfoPath.createDirectories()
+
+        // Start polling with an empty folder.
+        nodeInfoWatcher.nodeInfoUpdates()
+                .subscribe(testSubscriber)
+        // Ensure the watch service is started.
+        scheduler.advanceTimeBy(1, TimeUnit.HOURS)
+
+        // Check no nodeInfos are read.
+        assertEquals(0, testSubscriber.valueCount)
+        createNodeInfoFileInPath(nodeInfo)
+
+        scheduler.advanceTimeBy(1, TimeUnit.HOURS)
+
+        // The same folder can be reported more than once, so take unique values.
+        val readNodes = testSubscriber.onNextEvents.distinct()
+        assertEquals(1, readNodes.size)
+        assertEquals(nodeInfo, readNodes.first())
+    }
+
+    // Write a nodeInfo under the right path.
+    private fun createNodeInfoFileInPath(nodeInfo: NodeInfo) {
+        NodeInfoWatcher.saveToFile(nodeInfoPath, nodeInfo, keyManagementService)
+    }
+}

From 248c898818da157e8368dab34efc7afe1dd04db4 Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Thu, 5 Oct 2017 15:20:21 +0100
Subject: [PATCH 091/185] Instantiate Contract classes outside of
 LedgerTransaction.verify() (#1770)

* Load the contract classes when we create the LedgerTransaction.
* Fix Verifier tests by making ContractResult serialisable.
* Use named parameters to create ContractResult.
* Make the @JvmStatic function private.
* Refactor ContractResult to use Try.on{} instead.
---
 .../core/transactions/LedgerTransaction.kt    | 36 ++++++++++++-------
 .../net/corda/verifier/VerifierTests.kt       |  2 +-
 2 files changed, 24 insertions(+), 14 deletions(-)

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 9f8bdf1001..d62b1c0e6e 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt
@@ -7,6 +7,7 @@ import net.corda.core.internal.UpgradeCommand
 import net.corda.core.internal.castIfPossible
 import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.CordaSerializable
+import net.corda.core.utilities.Try
 import java.security.PublicKey
 import java.util.*
 import java.util.function.Predicate
@@ -48,6 +49,16 @@ data class LedgerTransaction(
         checkEncumbrancesValid()
     }
 
+    private companion object {
+        @JvmStatic
+        private fun createContractFor(className: ContractClassName): Try<Contract> {
+            return Try.on { this::class.java.classLoader.loadClass(className).asSubclass(Contract::class.java).getConstructor().newInstance() }
+        }
+    }
+
+    private val contracts: Map<ContractClassName, Try<Contract>> = (inputs.map { it.state.contract } + outputs.map { it.contract })
+                    .toSet().map { it to createContractFor(it) }.toMap()
+
     val inputStates: List<ContractState> get() = inputs.map { it.state.data }
 
     /**
@@ -98,19 +109,18 @@ data class LedgerTransaction(
      * If any contract fails to verify, the whole transaction is considered to be invalid.
      */
     private fun verifyContracts() {
-        val contracts = (inputs.map { it.state.contract } + outputs.map { it.contract }).toSet()
-        for (contractClassName in contracts) {
-            val contract = try {
-                assert(javaClass.classLoader == ClassLoader.getSystemClassLoader())
-                javaClass.classLoader.loadClass(contractClassName).asSubclass(Contract::class.java).getConstructor().newInstance()
-            } catch (e: ClassNotFoundException) {
-                throw TransactionVerificationException.ContractCreationError(id, contractClassName, e)
-            }
-
-            try {
-                contract.verify(this)
-            } catch (e: Throwable) {
-                throw TransactionVerificationException.ContractRejection(id, contract, e)
+        for (contractEntry in contracts.entries) {
+            val result = contractEntry.value
+            when (result) {
+                is Try.Failure -> throw TransactionVerificationException.ContractCreationError(id, contractEntry.key, result.exception)
+                is Try.Success -> {
+                    val contract = result.value
+                    try {
+                        contract.verify(this)
+                    } catch (e: Throwable) {
+                        throw TransactionVerificationException.ContractRejection(id, contract, e)
+                    }
+                }
             }
         }
     }
diff --git a/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt b/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
index f9965a5ffa..4ce985d0f5 100644
--- a/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
+++ b/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
@@ -23,7 +23,7 @@ import java.util.concurrent.atomic.AtomicInteger
 class VerifierTests {
     private fun generateTransactions(number: Int): List<LedgerTransaction> {
         var currentLedger = GeneratedLedger.empty
-        val transactions = ArrayList<WireTransaction>()
+        val transactions = arrayListOf<WireTransaction>()
         val random = SplittableRandom()
         for (i in 0 until number) {
             val (tx, ledger) = currentLedger.transactionGenerator.generateOrFail(random)

From 9239050fc88aeb9e8f649317f671039bdac5afc1 Mon Sep 17 00:00:00 2001
From: Andrzej Cichocki <andrzej.cichocki@r3.com>
Date: Thu, 5 Oct 2017 15:38:25 +0100
Subject: [PATCH 092/185] Make cordapp-example java tree buildable (#1809)

---
 .../src/main/kotlin/net/corda/testing/driver/Driver.kt     | 7 +++++--
 .../src/main/kotlin/net/corda/testing/node/MockNode.kt     | 5 +----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
index 15fd43b655..8f62fa88c3 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
@@ -133,12 +133,15 @@ interface DriverDSLExposedInterface : CordformContext {
             rpcUsers: List<User> = emptyList(),
             startInSameProcess: Boolean? = null): CordaFuture<Pair<Party, List<NodeHandle>>>
 
+    /** Call [startWebserver] with a default maximumHeapSize. */
+    fun startWebserver(handle: NodeHandle): CordaFuture<WebserverHandle> = startWebserver(handle, "200m")
+
     /**
      * Starts a web server for a node
-     *
      * @param handle The handle for the node that this webserver connects to via RPC.
+     * @param maximumHeapSize Argument for JVM -Xmx option e.g. "200m".
      */
-    fun startWebserver(handle: NodeHandle, maximumHeapSize: String = "200m"): CordaFuture<WebserverHandle>
+    fun startWebserver(handle: NodeHandle, maximumHeapSize: String): CordaFuture<WebserverHandle>
 
     /**
      * Starts a network map service node. Note that only a single one should ever be running, so you will probably want
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index 92a40391b5..af479b9382 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -404,10 +404,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                 advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type, serviceName)))
     }
 
-    // Convenience method for Java
-    fun createPartyNode(networkMapAddress: SingleMessageRecipient,
-                        legalName: CordaX500Name) = createPartyNode(networkMapAddress, legalName, null)
-
+    @JvmOverloads
     fun createPartyNode(networkMapAddress: SingleMessageRecipient,
                         legalName: CordaX500Name? = null,
                         overrideServices: Map<ServiceInfo, KeyPair>? = null): StartedNode<MockNode> {

From e8d21f2311d7e1e63cddc00c7b6b82a92f15cc46 Mon Sep 17 00:00:00 2001
From: Alberto Arri <30873160+al-r3@users.noreply.github.com>
Date: Thu, 5 Oct 2017 17:15:40 +0100
Subject: [PATCH 093/185] Deflake NodeInfoWatcherTest (#1811)

* Deflake NodeInfoWatcherTest

* Moved to integration tests, added eventually to check the validity
---
 .../services/network/NodeInfoWatcherTest.kt   | 35 ++++++++++++-------
 1 file changed, 23 insertions(+), 12 deletions(-)
 rename node/src/{test => integration-test}/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt (82%)

diff --git a/node/src/test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
similarity index 82%
rename from node/src/test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
rename to node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
index 758374f5c9..61dee26ad0 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
@@ -5,22 +5,27 @@ import net.corda.core.internal.createDirectories
 import net.corda.core.internal.div
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.services.KeyManagementService
+import net.corda.core.utilities.seconds
 import net.corda.node.services.identity.InMemoryIdentityService
-import net.corda.testing.*
+import net.corda.testing.ALICE
+import net.corda.testing.ALICE_KEY
+import net.corda.testing.DEV_TRUST_ROOT
+import net.corda.testing.eventually
+import net.corda.testing.getTestPartyAndCertificate
 import net.corda.testing.node.MockKeyManagementService
 import net.corda.testing.node.NodeBasedTest
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.contentOf
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.rules.TemporaryFolder
 import rx.observers.TestSubscriber
 import rx.schedulers.TestScheduler
+import java.nio.file.Path
 import java.util.concurrent.TimeUnit
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
-import org.assertj.core.api.Assertions.assertThat
-import org.assertj.core.api.Assertions.contentOf
-import java.nio.file.Path
 
 class NodeInfoWatcherTest : NodeBasedTest() {
 
@@ -67,7 +72,7 @@ class NodeInfoWatcherTest : NodeBasedTest() {
                 .subscribe(testSubscriber)
 
         val readNodes = testSubscriber.onNextEvents.distinct()
-        scheduler.advanceTimeBy(1, TimeUnit.HOURS)
+        advanceTime()
         assertEquals(0, readNodes.size)
     }
 
@@ -92,18 +97,24 @@ class NodeInfoWatcherTest : NodeBasedTest() {
         nodeInfoWatcher.nodeInfoUpdates()
                 .subscribe(testSubscriber)
         // Ensure the watch service is started.
-        scheduler.advanceTimeBy(1, TimeUnit.HOURS)
-
+        advanceTime()
         // Check no nodeInfos are read.
         assertEquals(0, testSubscriber.valueCount)
         createNodeInfoFileInPath(nodeInfo)
 
-        scheduler.advanceTimeBy(1, TimeUnit.HOURS)
+        advanceTime()
 
-        // The same folder can be reported more than once, so take unique values.
-        val readNodes = testSubscriber.onNextEvents.distinct()
-        assertEquals(1, readNodes.size)
-        assertEquals(nodeInfo, readNodes.first())
+        // We need the WatchService to report a change and that might not happen immediately.
+        eventually<AssertionError, Unit>(5.seconds) {
+            // The same folder can be reported more than once, so take unique values.
+            val readNodes = testSubscriber.onNextEvents.distinct()
+            assertEquals(1, readNodes.size)
+            assertEquals(nodeInfo, readNodes.first())
+        }
+    }
+
+    private fun advanceTime() {
+        scheduler.advanceTimeBy(1, TimeUnit.HOURS)
     }
 
     // Write a nodeInfo under the right path.

From 33ba145149c87ae1f19ee37b09c77513588c8efb Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Thu, 5 Oct 2017 17:42:16 +0100
Subject: [PATCH 094/185] CORDA-540: Add verification to ensure that private
 keys can only be serialized with specific contexts (#1800)

---
 .../serialization/AllButBlacklisted.kt        |  3 ++
 .../nodeapi/internal/serialization/Kryo.kt    | 18 ++++----
 .../serialization/UseCaseAwareness.kt         | 12 ++++++
 .../internal/serialization/KryoTests.kt       |  2 +-
 .../PrivateKeySerializationTest.kt            | 42 +++++++++++++++++++
 5 files changed, 67 insertions(+), 10 deletions(-)
 create mode 100644 node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/UseCaseAwareness.kt
 create mode 100644 node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/PrivateKeySerializationTest.kt

diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AllButBlacklisted.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AllButBlacklisted.kt
index eadd539414..4bc36e9a8b 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AllButBlacklisted.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AllButBlacklisted.kt
@@ -30,6 +30,9 @@ import kotlin.collections.LinkedHashSet
  * we can often end up pulling in a lot of objects that do not make sense to put in a checkpoint.
  * Thus, by blacklisting classes/interfaces we don't expect to be serialised, we can better handle/monitor the aforementioned behaviour.
  * Inheritance works for blacklisted items, but one can specifically exclude classes from blacklisting as well.
+ * Note: Custom serializer registration trumps white/black lists. So if a given type has a custom serializer and has its name
+ * in the blacklist - it will still be serialized as specified by custom serializer.
+ * For more details, see [net.corda.nodeapi.internal.serialization.CordaClassResolver.getRegistration]
  */
 object AllButBlacklisted : ClassWhitelist {
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
index 2905922460..7b998d5cd7 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
@@ -10,30 +10,23 @@ import com.esotericsoftware.kryo.util.MapReferenceResolver
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.contracts.PrivacySalt
 import net.corda.core.contracts.StateRef
-import net.corda.core.crypto.CompositeKey
 import net.corda.core.crypto.Crypto
 import net.corda.core.crypto.TransactionSignature
 import net.corda.core.identity.Party
 import net.corda.core.internal.uncheckedCast
 import net.corda.core.serialization.SerializationContext
+import net.corda.core.serialization.SerializationContext.UseCase.*
 import net.corda.core.serialization.SerializeAsTokenContext
 import net.corda.core.serialization.SerializedBytes
 import net.corda.core.toFuture
 import net.corda.core.toObservable
 import net.corda.core.transactions.*
-import net.i2p.crypto.eddsa.EdDSAPrivateKey
-import net.i2p.crypto.eddsa.EdDSAPublicKey
-import net.i2p.crypto.eddsa.spec.EdDSANamedCurveSpec
-import net.i2p.crypto.eddsa.spec.EdDSAPrivateKeySpec
-import net.i2p.crypto.eddsa.spec.EdDSAPublicKeySpec
 import org.bouncycastle.asn1.ASN1InputStream
 import org.bouncycastle.asn1.x500.X500Name
 import org.bouncycastle.cert.X509CertificateHolder
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import rx.Observable
-import sun.security.ec.ECPublicKeyImpl
-import sun.security.util.DerValue
 import java.io.ByteArrayInputStream
 import java.io.InputStream
 import java.lang.reflect.InvocationTargetException
@@ -285,9 +278,16 @@ object SignedTransactionSerializer : Serializer<SignedTransaction>() {
     }
 }
 
+sealed class UseCaseSerializer<T>(private val allowedUseCases: EnumSet<SerializationContext.UseCase>) : Serializer<T>() {
+    protected fun checkUseCase() {
+        checkUseCase(allowedUseCases)
+    }
+}
+
 @ThreadSafe
-object PrivateKeySerializer : Serializer<PrivateKey>() {
+object PrivateKeySerializer : UseCaseSerializer<PrivateKey>(EnumSet.of(Storage, Checkpoint)) {
     override fun write(kryo: Kryo, output: Output, obj: PrivateKey) {
+        checkUseCase()
         output.writeBytesWithLength(obj.encoded)
     }
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/UseCaseAwareness.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/UseCaseAwareness.kt
new file mode 100644
index 0000000000..fdf57d28be
--- /dev/null
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/UseCaseAwareness.kt
@@ -0,0 +1,12 @@
+package net.corda.nodeapi.internal.serialization
+
+import net.corda.core.serialization.SerializationContext
+import net.corda.core.serialization.SerializationFactory
+import java.util.*
+
+internal fun checkUseCase(allowedUseCases: EnumSet<SerializationContext.UseCase>) {
+    val currentContext: SerializationContext = SerializationFactory.currentFactory?.currentContext ?: throw IllegalStateException("Current context is not set")
+    if(!allowedUseCases.contains(currentContext.useCase)) {
+        throw IllegalStateException("UseCase '${currentContext.useCase}' is not within '$allowedUseCases'")
+    }
+}
\ No newline at end of file
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/KryoTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/KryoTests.kt
index 1855a4c8c7..bf9c157c86 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/KryoTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/KryoTests.kt
@@ -43,7 +43,7 @@ class KryoTests : TestDependencyInjectionBase() {
                 AllWhitelist,
                 emptyMap(),
                 true,
-                SerializationContext.UseCase.P2P)
+                SerializationContext.UseCase.Storage)
     }
 
     @Test
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/PrivateKeySerializationTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/PrivateKeySerializationTest.kt
new file mode 100644
index 0000000000..bf9cd8f2e5
--- /dev/null
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/PrivateKeySerializationTest.kt
@@ -0,0 +1,42 @@
+package net.corda.nodeapi.internal.serialization
+
+import net.corda.core.crypto.Crypto
+import net.corda.core.serialization.SerializationContext.UseCase.*
+import net.corda.core.serialization.SerializationDefaults
+import net.corda.core.serialization.serialize
+import net.corda.testing.TestDependencyInjectionBase
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import java.security.PrivateKey
+import kotlin.test.assertTrue
+
+@RunWith(Parameterized::class)
+class PrivateKeySerializationTest(private val privateKey: PrivateKey, private val testName: String) : TestDependencyInjectionBase() {
+
+    companion object {
+        @JvmStatic
+        @Parameterized.Parameters(name = "{1}")
+        fun data(): Collection<Array<Any>> {
+            val privateKeys: List<PrivateKey> = Crypto.supportedSignatureSchemes().filterNot { Crypto.COMPOSITE_KEY === it }
+                    .map { Crypto.generateKeyPair(it).private }
+
+            return privateKeys.map { arrayOf<Any>(it, PrivateKeySerializationTest::class.java.simpleName + "-" + it.javaClass.simpleName) }
+        }
+    }
+
+    @Test
+    fun `passed with expected UseCases`() {
+        assertTrue { privateKey.serialize(context = SerializationDefaults.STORAGE_CONTEXT).bytes.isNotEmpty() }
+        assertTrue { privateKey.serialize(context = SerializationDefaults.CHECKPOINT_CONTEXT).bytes.isNotEmpty() }
+    }
+
+    @Test
+    fun `failed with wrong UseCase`() {
+        assertThatThrownBy { privateKey.serialize(context = SerializationDefaults.P2P_CONTEXT) }
+                .isInstanceOf(IllegalStateException::class.java)
+                .hasMessageContaining("UseCase '${P2P}' is not within")
+
+    }
+}
\ No newline at end of file

From d499ee32bbd25c41e3127e00fc3927770e0a8819 Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 10:16:40 +0100
Subject: [PATCH 095/185] Correct bad exception reference and various rendering
 issues

---
 docs/source/tutorial-contract.rst |  6 +++---
 docs/source/tutorial-test-dsl.rst | 12 ++++++------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/docs/source/tutorial-contract.rst b/docs/source/tutorial-contract.rst
index 11e6ef0755..8c48d33358 100644
--- a/docs/source/tutorial-contract.rst
+++ b/docs/source/tutorial-contract.rst
@@ -327,7 +327,7 @@ little odd: we have a *requireThat* construct that looks like it's built into th
 ordinary function provided by the platform's contract API. Kotlin supports the creation of *domain specific languages*
 through the intersection of several features of the language, and we use it here to support the natural listing of
 requirements. To see what it compiles down to, look at the Java version. Each ``"string" using (expression)`` statement
-inside a ``requireThat`` turns into an assertion that the given expression is true, with an ``IllegalStateException``
+inside a ``requireThat`` turns into an assertion that the given expression is true, with an ``IllegalArgumentException``
 being thrown that contains the string if not. It's just another way to write out a regular assertion, but with the
 English-language requirement being put front and center.
 
@@ -340,8 +340,8 @@ the owner.
 1. We still check there is a CP input state.
 2. We want to see that the face value of the CP is being moved as a cash claim against some party, that is, the
    issuer of the CP is really paying back the face value.
-2. The transaction must be happening after the maturity date.
-3. The commercial paper must *not* be propagated by this transaction: it must be deleted, by the group having no
+3. The transaction must be happening after the maturity date.
+4. The commercial paper must *not* be propagated by this transaction: it must be deleted, by the group having no
    output state. This prevents the same CP being considered redeemable multiple times.
 
 To calculate how much cash is moving, we use the ``sumCashBy`` utility function. Again, this is an extension function,
diff --git a/docs/source/tutorial-test-dsl.rst b/docs/source/tutorial-test-dsl.rst
index 8bfbab79b0..b32be173c7 100644
--- a/docs/source/tutorial-test-dsl.rst
+++ b/docs/source/tutorial-test-dsl.rst
@@ -141,11 +141,11 @@ Let's take a look at a transaction that fails.
         :end-before: DOCEND 3
         :dedent: 4
 
-            .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
-:language: java
-                :start-after: DOCSTART 3
-                :end-before: DOCEND 3
-                :dedent: 4
+    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java
+        :language: java
+        :start-after: DOCSTART 3
+        :end-before: DOCEND 3
+        :dedent: 4
 
 When run, that code produces the following error:
 
@@ -297,4 +297,4 @@ verification (``this.fails()`` at the end). As in previous examples we can use `
         :language: java
         :start-after: DOCSTART 10
         :end-before: DOCEND 10
-        :dedent: 4
\ No newline at end of file
+        :dedent: 4

From 66d78fcf65110962a993998cdf1132f88ed6967b Mon Sep 17 00:00:00 2001
From: Katarzyna Streich <katarzyna.streich@r3.com>
Date: Fri, 6 Oct 2017 10:32:54 +0100
Subject: [PATCH 096/185] Cleanup of mock network pre-NetworkParameters (#1802)

* MockNode rename overrideServices to notaryIdentity

Permit only one override of service.

* MockNetwork: force creation of NetworkMapNode

Tests cleanup: decouple normal nodes and network map. NetworkMap node is created as first.
---
 .../confidential/IdentitySyncFlowTests.kt     |  14 +--
 .../confidential/SwapIdentitiesFlowTests.kt   |   5 +-
 .../net/corda/core/flows/FlowsInJavaTest.java |   7 +-
 .../net/corda/core/flows/AttachmentTests.kt   |  18 +--
 .../core/flows/CollectSignaturesFlowTests.kt  |   6 +-
 .../core/flows/ContractUpgradeFlowTest.kt     |   4 +-
 .../net/corda/core/flows/FinalityFlowTests.kt |   6 +-
 .../internal/ResolveTransactionsFlowTest.kt   |   4 +-
 .../AttachmentSerializationTest.kt            |   8 +-
 .../net/corda/docs/CustomVaultQueryTest.kt    |   9 +-
 .../docs/FxTransactionBuildTutorialTest.kt    |   9 +-
 .../WorkflowTransactionBuildTutorialTest.kt   |   9 +-
 .../corda/finance/flows/CashExitFlowTests.kt  |   2 +-
 .../corda/finance/flows/CashIssueFlowTests.kt |   2 +-
 .../finance/flows/CashPaymentFlowTests.kt     |   2 +-
 .../node/services/BFTNotaryServiceTests.kt    |   1 -
 .../net/corda/node/CordaRPCOpsImplTest.kt     |   7 +-
 .../node/messaging/InMemoryMessagingTests.kt  |  16 +--
 .../node/messaging/TwoPartyTradeFlowTests.kt  |  46 +++-----
 .../corda/node/services/NotaryChangeTests.kt  |   7 +-
 .../services/events/ScheduledFlowTests.kt     |   4 +-
 .../network/AbstractNetworkMapServiceTest.kt  |  13 +--
 .../services/network/NetworkMapCacheTest.kt   |  15 ++-
 .../PersistentNetworkMapServiceTest.kt        |   4 +-
 .../statemachine/FlowFrameworkTests.kt        |  32 +++---
 .../transactions/NotaryServiceTests.kt        |   2 +-
 .../ValidatingNotaryServiceTests.kt           |   2 +-
 .../corda/irs/api/NodeInterestRatesTest.kt    |   2 +-
 .../net/corda/netmap/simulation/Simulation.kt |  35 +++---
 .../corda/testing/FlowStackSnapshotTest.kt    |   4 +-
 .../kotlin/net/corda/testing/node/MockNode.kt | 108 ++++++++++--------
 31 files changed, 195 insertions(+), 208 deletions(-)

diff --git a/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt b/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
index ac5863d818..7482825440 100644
--- a/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
+++ b/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
@@ -42,12 +42,12 @@ class IdentitySyncFlowTests {
     @Test
     fun `sync confidential identities`() {
         // Set up values we'll need
-        val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-        val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
+        mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val bobNode = mockNet.createPartyNode(BOB.name)
         val alice: Party = aliceNode.services.myInfo.chooseIdentity()
         val bob: Party = bobNode.services.myInfo.chooseIdentity()
-        val notary = notaryNode.services.getDefaultNotary()
+        val notary = aliceNode.services.getDefaultNotary()
         bobNode.internals.registerInitiatedFlow(Receive::class.java)
 
         // Alice issues then pays some cash to a new confidential identity that Bob doesn't know about
@@ -73,9 +73,9 @@ class IdentitySyncFlowTests {
     fun `don't offer other's identities confidential identities`() {
         // Set up values we'll need
         val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-        val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
-        val charlieNode = mockNet.createPartyNode(notaryNode.network.myAddress, CHARLIE.name)
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val bobNode = mockNet.createPartyNode(BOB.name)
+        val charlieNode = mockNet.createPartyNode(CHARLIE.name)
         val alice: Party = aliceNode.services.myInfo.chooseIdentity()
         val bob: Party = bobNode.services.myInfo.chooseIdentity()
         val charlie: Party = charlieNode.services.myInfo.chooseIdentity()
diff --git a/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt b/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
index 202da9412e..5554b8ea34 100644
--- a/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
+++ b/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
@@ -23,11 +23,10 @@ class SwapIdentitiesFlowTests {
 
         // Set up values we'll need
         val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-        val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val bobNode = mockNet.createPartyNode(BOB.name)
         val alice: Party = aliceNode.services.myInfo.chooseIdentity()
         val bob: Party = bobNode.services.myInfo.chooseIdentity()
-        mockNet.registerIdentities()
 
         // Run the flows
         val requesterFlow = aliceNode.services.startFlow(SwapIdentitiesFlow(bob))
diff --git a/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java b/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java
index ff30e6547d..6e836dbaba 100644
--- a/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java
+++ b/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java
@@ -20,15 +20,14 @@ import static org.junit.Assert.fail;
 public class FlowsInJavaTest {
 
     private final MockNetwork mockNet = new MockNetwork();
-    private StartedNode<MockNetwork.MockNode> notaryNode;
     private StartedNode<MockNetwork.MockNode> aliceNode;
     private StartedNode<MockNetwork.MockNode> bobNode;
 
     @Before
     public void setUp() throws Exception {
-        notaryNode = mockNet.createNotaryNode();
-        aliceNode = mockNet.createPartyNode(notaryNode.getNetwork().getMyAddress(), TestConstants.getALICE().getName());
-        bobNode = mockNet.createPartyNode(notaryNode.getNetwork().getMyAddress(), TestConstants.getBOB().getName());
+        mockNet.createNotaryNode();
+        aliceNode = mockNet.createPartyNode(TestConstants.getALICE().getName());
+        bobNode = mockNet.createPartyNode(TestConstants.getBOB().getName());
         mockNet.runNetwork();
         // Ensure registration was successful
         aliceNode.getInternals().getNodeReadyFuture().get();
diff --git a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
index bf5c6af06f..5da5583af6 100644
--- a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
@@ -56,9 +56,9 @@ class AttachmentTests {
 
     @Test
     fun `download and store`() {
-        val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-        val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
+        mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val bobNode = mockNet.createPartyNode(BOB.name)
 
         // Ensure that registration was successful before progressing any further
         mockNet.runNetwork()
@@ -94,9 +94,9 @@ class AttachmentTests {
 
     @Test
     fun `missing`() {
-        val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-        val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
+        mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val bobNode = mockNet.createPartyNode(BOB.name)
 
         // Ensure that registration was successful before progressing any further
         mockNet.runNetwork()
@@ -120,14 +120,14 @@ class AttachmentTests {
         val aliceNode = mockNet.createNode(legalName = ALICE.name, nodeFactory = object : MockNetwork.Factory<MockNetwork.MockNode> {
             override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
                                 advertisedServices: Set<ServiceInfo>, id: Int,
-                                overrideServices: Map<ServiceInfo, KeyPair>?,
+                                notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                                 entropyRoot: BigInteger): MockNetwork.MockNode {
-                return object : MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot) {
+                return object : MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
                     override fun start() = super.start().apply { attachments.checkAttachmentsOnLoad = false }
                 }
             }
         }, advertisedServices = *arrayOf(ServiceInfo(SimpleNotaryService.type)))
-        val bobNode = mockNet.createNode(aliceNode.network.myAddress, legalName = BOB.name)
+        val bobNode = mockNet.createNode(legalName = BOB.name)
 
         // Ensure that registration was successful before progressing any further
         mockNet.runNetwork()
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 8a913d5983..619ddec8a6 100644
--- a/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
@@ -34,9 +34,9 @@ class CollectSignaturesFlowTests {
         setCordappPackages("net.corda.testing.contracts")
         mockNet = MockNetwork()
         val notaryNode = mockNet.createNotaryNode()
-        aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-        bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
-        charlieNode = mockNet.createPartyNode(notaryNode.network.myAddress, CHARLIE.name)
+        aliceNode = mockNet.createPartyNode(ALICE.name)
+        bobNode = mockNet.createPartyNode(BOB.name)
+        charlieNode = mockNet.createPartyNode(CHARLIE.name)
         mockNet.runNetwork()
         notary = notaryNode.services.getDefaultNotary()
         aliceNode.internals.ensureRegistered()
diff --git a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
index 18a422441a..197f8ca00c 100644
--- a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
@@ -43,8 +43,8 @@ class ContractUpgradeFlowTest {
         setCordappPackages("net.corda.testing.contracts", "net.corda.finance.contracts.asset", "net.corda.core.flows")
         mockNet = MockNetwork()
         val notaryNode = mockNet.createNotaryNode()
-        aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-        bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
+        aliceNode = mockNet.createPartyNode(ALICE.name)
+        bobNode = mockNet.createPartyNode(BOB.name)
 
         // Process registration
         mockNet.runNetwork()
diff --git a/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt b/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
index 0d38513c25..fb865fd291 100644
--- a/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
@@ -25,9 +25,9 @@ class FinalityFlowTests {
     fun setup() {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork()
-        val notaryNode = mockNet.createNotaryNode()
-        aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-        bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
+        mockNet.createNotaryNode()
+        aliceNode = mockNet.createPartyNode(ALICE.name)
+        bobNode = mockNet.createPartyNode(BOB.name)
         mockNet.runNetwork()
         aliceNode.internals.ensureRegistered()
         notary = aliceNode.services.getDefaultNotary()
diff --git a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
index 6e446d0bd8..bf16c93f53 100644
--- a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
@@ -39,8 +39,8 @@ class ResolveTransactionsFlowTest {
         setCordappPackages("net.corda.testing.contracts")
         mockNet = MockNetwork()
         notaryNode = mockNet.createNotaryNode()
-        megaCorpNode = mockNet.createPartyNode(notaryNode.network.myAddress, MEGA_CORP.name)
-        miniCorpNode = mockNet.createPartyNode(notaryNode.network.myAddress, MINI_CORP.name)
+        megaCorpNode = mockNet.createPartyNode(MEGA_CORP.name)
+        miniCorpNode = mockNet.createPartyNode(MINI_CORP.name)
         megaCorpNode.internals.registerInitiatedFlow(TestResponseFlow::class.java)
         miniCorpNode.internals.registerInitiatedFlow(TestResponseFlow::class.java)
         mockNet.runNetwork()
diff --git a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
index 37183b1fd8..db7d27d06a 100644
--- a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
+++ b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
@@ -70,7 +70,7 @@ class AttachmentSerializationTest {
     fun setUp() {
         mockNet = MockNetwork()
         server = mockNet.createNode()
-        client = mockNet.createNode(server.network.myAddress)
+        client = mockNet.createNode()
         client.internals.disableDBCloseOnStop() // Otherwise the in-memory database may disappear (taking the checkpoint with it) while we reboot the client.
         mockNet.runNetwork()
         server.internals.ensureRegistered()
@@ -159,11 +159,11 @@ class AttachmentSerializationTest {
 
     private fun rebootClientAndGetAttachmentContent(checkAttachmentsOnLoad: Boolean = true): String {
         client.dispose()
-        client = mockNet.createNode(server.network.myAddress, client.internals.id, object : MockNetwork.Factory<MockNetwork.MockNode> {
+        client = mockNet.createNode(client.internals.id, object : MockNetwork.Factory<MockNetwork.MockNode> {
             override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                                advertisedServices: Set<ServiceInfo>, id: Int, overrideServices: Map<ServiceInfo, KeyPair>?,
+                                advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                                 entropyRoot: BigInteger): MockNetwork.MockNode {
-                return object : MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot) {
+                return object : MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
                     override fun start() = super.start().apply { attachments.checkAttachmentsOnLoad = checkAttachmentsOnLoad }
                 }
             }
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
index 3105f151cb..36a98ebe8b 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
@@ -22,7 +22,6 @@ import java.util.*
 class CustomVaultQueryTest {
 
     lateinit var mockNet: MockNetwork
-    lateinit var notaryNode: StartedNode<MockNetwork.MockNode>
     lateinit var nodeA: StartedNode<MockNetwork.MockNode>
     lateinit var nodeB: StartedNode<MockNetwork.MockNode>
     lateinit var notary: Party
@@ -32,12 +31,12 @@ class CustomVaultQueryTest {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork(threadPerNode = true)
         val notaryService = ServiceInfo(ValidatingNotaryService.type)
-        notaryNode = mockNet.createNode(
+        mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
-                overrideServices = mapOf(notaryService to DUMMY_NOTARY_KEY),
+                notaryIdentity = notaryService to DUMMY_NOTARY_KEY,
                 advertisedServices = *arrayOf(notaryService))
-        nodeA = mockNet.createPartyNode(notaryNode.network.myAddress)
-        nodeB = mockNet.createPartyNode(notaryNode.network.myAddress)
+        nodeA = mockNet.createPartyNode()
+        nodeB = mockNet.createPartyNode()
 
         nodeA.internals.registerInitiatedFlow(TopupIssuerFlow.TopupIssuer::class.java)
         nodeA.internals.installCordaService(CustomVaultQuery.Service::class.java)
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
index 4548af15a3..3152da5650 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
@@ -20,7 +20,6 @@ import kotlin.test.assertEquals
 
 class FxTransactionBuildTutorialTest {
     lateinit var mockNet: MockNetwork
-    lateinit var notaryNode: StartedNode<MockNetwork.MockNode>
     lateinit var nodeA: StartedNode<MockNetwork.MockNode>
     lateinit var nodeB: StartedNode<MockNetwork.MockNode>
     lateinit var notary: Party
@@ -30,12 +29,12 @@ class FxTransactionBuildTutorialTest {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork(threadPerNode = true)
         val notaryService = ServiceInfo(ValidatingNotaryService.type)
-        notaryNode = mockNet.createNode(
+        mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
-                overrideServices = mapOf(notaryService to DUMMY_NOTARY_KEY),
+                notaryIdentity = notaryService to DUMMY_NOTARY_KEY,
                 advertisedServices = *arrayOf(notaryService))
-        nodeA = mockNet.createPartyNode(notaryNode.network.myAddress)
-        nodeB = mockNet.createPartyNode(notaryNode.network.myAddress)
+        nodeA = mockNet.createPartyNode()
+        nodeB = mockNet.createPartyNode()
         nodeA.internals.registerCustomSchemas(setOf(CashSchemaV1))
         nodeB.internals.registerCustomSchemas(setOf(CashSchemaV1))
         nodeB.internals.registerInitiatedFlow(ForeignExchangeRemoteFlow::class.java)
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
index 4242dd79e3..eed9b53759 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
@@ -20,7 +20,6 @@ import kotlin.test.assertEquals
 
 class WorkflowTransactionBuildTutorialTest {
     lateinit var mockNet: MockNetwork
-    lateinit var notaryNode: StartedNode<MockNetwork.MockNode>
     lateinit var nodeA: StartedNode<MockNetwork.MockNode>
     lateinit var nodeB: StartedNode<MockNetwork.MockNode>
 
@@ -35,12 +34,12 @@ class WorkflowTransactionBuildTutorialTest {
         setCordappPackages("net.corda.docs")
         mockNet = MockNetwork(threadPerNode = true)
         val notaryService = ServiceInfo(ValidatingNotaryService.type)
-        notaryNode = mockNet.createNode(
+        mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
-                overrideServices = mapOf(Pair(notaryService, DUMMY_NOTARY_KEY)),
+                notaryIdentity = Pair(notaryService, DUMMY_NOTARY_KEY),
                 advertisedServices = *arrayOf(notaryService))
-        nodeA = mockNet.createPartyNode(notaryNode.network.myAddress)
-        nodeB = mockNet.createPartyNode(notaryNode.network.myAddress)
+        nodeA = mockNet.createPartyNode()
+        nodeB = mockNet.createPartyNode()
         nodeA.internals.registerInitiatedFlow(RecordCompletionFlow::class.java)
     }
 
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
index 60c50f3211..515480760a 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
@@ -31,7 +31,7 @@ class CashExitFlowTests {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
         notaryNode = mockNet.createNotaryNode()
-        bankOfCordaNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
+        bankOfCordaNode = mockNet.createPartyNode(BOC.name)
         notary = notaryNode.services.getDefaultNotary()
         bankOfCorda = bankOfCordaNode.info.chooseIdentity()
 
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
index 87299eea8d..791dc0d9da 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
@@ -33,7 +33,7 @@ class CashIssueFlowTests {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
         notaryNode = mockNet.createNotaryNode()
-        bankOfCordaNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
+        bankOfCordaNode = mockNet.createPartyNode(BOC.name)
         bankOfCorda = bankOfCordaNode.info.chooseIdentity()
         notary = notaryNode.services.getDefaultNotary()
         mockNet.runNetwork()
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
index 5ba26a9712..9304425778 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
@@ -34,7 +34,7 @@ class CashPaymentFlowTests {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
         notaryNode = mockNet.createNotaryNode()
-        bankOfCordaNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
+        bankOfCordaNode = mockNet.createPartyNode(BOC.name)
         bankOfCorda = bankOfCordaNode.info.chooseIdentity()
         notary = notaryNode.services.getDefaultNotary()
         val future = bankOfCordaNode.services.startFlow(CashIssueFlow(initialBalance, ref, notary)).resultFuture
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt
index 97859a5cdb..c014788530 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt
@@ -58,7 +58,6 @@ class BFTNotaryServiceTests {
         val notaryClusterAddresses = replicaIds.map { NetworkHostAndPort("localhost", 11000 + it * 10) }
         replicaIds.forEach { replicaId ->
             mockNet.createNode(
-                    node.network.myAddress,
                     advertisedServices = bftNotaryService,
                     configOverrides = {
                         whenever(it.bftSMaRt).thenReturn(BFTSMaRtConfiguration(replicaId, false, exposeRaces))
diff --git a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
index 8fae3f60cc..ce3f6f3a6b 100644
--- a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
+++ b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
@@ -67,9 +67,8 @@ class CordaRPCOpsImplTest {
         setCordappPackages("net.corda.finance.contracts.asset")
 
         mockNet = MockNetwork()
-        val networkMap = mockNet.createNode()
-        aliceNode = mockNet.createNode(networkMapAddress = networkMap.network.myAddress)
-        notaryNode = mockNet.createNode(advertisedServices = ServiceInfo(SimpleNotaryService.type), networkMapAddress = networkMap.network.myAddress)
+        aliceNode = mockNet.createNode()
+        notaryNode = mockNet.createNode(advertisedServices = ServiceInfo(SimpleNotaryService.type))
         rpc = CordaRPCOpsImpl(aliceNode.services, aliceNode.smm, aliceNode.database)
         CURRENT_RPC_CONTEXT.set(RpcContext(User("user", "pwd", permissions = setOf(
                 startFlowPermission<CashIssueFlow>(),
@@ -77,7 +76,7 @@ class CordaRPCOpsImplTest {
         ))))
 
         mockNet.runNetwork()
-        networkMap.internals.ensureRegistered()
+        mockNet.networkMapNode.internals.ensureRegistered()
         notary = rpc.notaryIdentities().first()
     }
 
diff --git a/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt b/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt
index e949ca11d2..b3a3fb32e4 100644
--- a/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt
+++ b/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt
@@ -47,9 +47,9 @@ class InMemoryMessagingTests {
 
     @Test
     fun basics() {
-        val node1 = mockNet.createNode()
-        val node2 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
-        val node3 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
+        val node1 = mockNet.networkMapNode
+        val node2 = mockNet.createNode()
+        val node3 = mockNet.createNode()
 
         val bits = "test-content".toByteArray()
         var finalDelivery: Message? = null
@@ -76,9 +76,9 @@ class InMemoryMessagingTests {
 
     @Test
     fun broadcast() {
-        val node1 = mockNet.createNode()
-        val node2 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
-        val node3 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
+        val node1 = mockNet.networkMapNode
+        val node2 = mockNet.createNode()
+        val node3 = mockNet.createNode()
 
         val bits = "test-content".toByteArray()
 
@@ -95,8 +95,8 @@ class InMemoryMessagingTests {
      */
     @Test
     fun `skip unhandled messages`() {
-        val node1 = mockNet.createNode()
-        val node2 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
+        val node1 = mockNet.networkMapNode
+        val node2 = mockNet.createNode()
         var received = 0
 
         node1.network.addMessageHandler("valid_message") { _, _ ->
diff --git a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
index 4cdcbc42e4..294d758cf4 100644
--- a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
@@ -104,9 +104,9 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
 
         ledger(initialiseSerialization = false) {
             val notaryNode = mockNet.createNotaryNode()
-            val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-            val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
-            val bankNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
+            val aliceNode = mockNet.createPartyNode(ALICE.name)
+            val bobNode = mockNet.createPartyNode(BOB.name)
+            val bankNode = mockNet.createPartyNode(BOC.name)
             val notary = notaryNode.services.getDefaultNotary()
             val cashIssuer = bankNode.info.chooseIdentity().ref(1)
             val cpIssuer = bankNode.info.chooseIdentity().ref(1, 2, 3)
@@ -153,9 +153,9 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
 
         ledger(initialiseSerialization = false) {
             val notaryNode = mockNet.createNotaryNode()
-            val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-            val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
-            val bankNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
+            val aliceNode = mockNet.createPartyNode(ALICE.name)
+            val bobNode = mockNet.createPartyNode(BOB.name)
+            val bankNode = mockNet.createPartyNode(BOC.name)
             val issuer = bankNode.info.chooseIdentity().ref(1)
             val notary = aliceNode.services.getDefaultNotary()
 
@@ -207,14 +207,11 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
         mockNet = MockNetwork(false)
         ledger(initialiseSerialization = false) {
             val notaryNode = mockNet.createNotaryNode()
-            val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-            var bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
-            val bankNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
+            val aliceNode = mockNet.createPartyNode(ALICE.name)
+            var bobNode = mockNet.createPartyNode(BOB.name)
+            val bankNode = mockNet.createPartyNode(BOC.name)
             val issuer = bankNode.info.chooseIdentity().ref(1, 2, 3)
 
-            // Let the nodes know about each other - normally the network map would handle this
-            mockNet.registerIdentities()
-
             aliceNode.database.transaction {
                 aliceNode.services.identityService.verifyAndRegisterIdentity(bobNode.info.chooseIdentityAndCert())
             }
@@ -276,11 +273,11 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
 
             // ... bring the node back up ... the act of constructing the SMM will re-register the message handlers
             // that Bob was waiting on before the reboot occurred.
-            bobNode = mockNet.createNode(networkMapAddress, bobAddr.id, object : MockNetwork.Factory<MockNetwork.MockNode> {
+            bobNode = mockNet.createNode(bobAddr.id, object : MockNetwork.Factory<MockNetwork.MockNode> {
                 override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                                    advertisedServices: Set<ServiceInfo>, id: Int, overrideServices: Map<ServiceInfo, KeyPair>?,
+                                    advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                                     entropyRoot: BigInteger): MockNetwork.MockNode {
-                    return MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, bobAddr.id, overrideServices, entropyRoot)
+                    return MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, bobAddr.id, notaryIdentity, entropyRoot)
                 }
             }, BOB.name)
 
@@ -319,14 +316,14 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
             networkMapAddress: SingleMessageRecipient?,
             name: CordaX500Name): StartedNode<MockNetwork.MockNode> {
         // Create a node in the mock network ...
-        return mockNet.createNode(networkMapAddress, nodeFactory = object : MockNetwork.Factory<MockNetwork.MockNode> {
+        return mockNet.createNode(nodeFactory = object : MockNetwork.Factory<MockNetwork.MockNode> {
             override fun create(config: NodeConfiguration,
                                 network: MockNetwork,
                                 networkMapAddr: SingleMessageRecipient?,
                                 advertisedServices: Set<ServiceInfo>, id: Int,
-                                overrideServices: Map<ServiceInfo, KeyPair>?,
+                                notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                                 entropyRoot: BigInteger): MockNetwork.MockNode {
-                return object : MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot) {
+                return object : MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
                     // That constructs a recording tx storage
                     override fun makeTransactionStorage(): WritableTransactionStorage {
                         return RecordingTransactionStorage(database, super.makeTransactionStorage())
@@ -349,8 +346,6 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
         notaryNode.internals.ensureRegistered()
         val notary = aliceNode.services.getDefaultNotary()
 
-        mockNet.registerIdentities()
-
         ledger(aliceNode.services, initialiseSerialization = false) {
 
             // Insert a prospectus type attachment into the commercial paper transaction.
@@ -457,8 +452,6 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
         notaryNode.internals.ensureRegistered()
         val notary = aliceNode.services.getDefaultNotary()
 
-        mockNet.registerIdentities()
-
         ledger(aliceNode.services, initialiseSerialization = false) {
             // Insert a prospectus type attachment into the commercial paper transaction.
             val stream = ByteArrayOutputStream()
@@ -604,18 +597,15 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
             expectedMessageSubstring: String
     ) {
         val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
-        val bobNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOB.name)
-        val bankNode = mockNet.createPartyNode(notaryNode.network.myAddress, BOC.name)
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val bobNode = mockNet.createPartyNode(BOB.name)
+        val bankNode = mockNet.createPartyNode(BOC.name)
         val issuer = bankNode.info.chooseIdentity().ref(1, 2, 3)
 
         mockNet.runNetwork()
         notaryNode.internals.ensureRegistered()
         val notary = aliceNode.services.getDefaultNotary()
 
-        // Let the nodes know about each other - normally the network map would handle this
-        mockNet.registerIdentities()
-
         val bobsBadCash = bobNode.database.transaction {
             fillUpForBuyer(bobError, issuer, bobNode.info.chooseIdentity(),
                     notary).second
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 e1a560c1ca..4bb4b6aa62 100644
--- a/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
@@ -42,10 +42,9 @@ class NotaryChangeTests {
         oldNotaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
                 advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type)))
-        clientNodeA = mockNet.createNode(networkMapAddress = oldNotaryNode.network.myAddress)
-        clientNodeB = mockNet.createNode(networkMapAddress = oldNotaryNode.network.myAddress)
-        newNotaryNode = mockNet.createNode(networkMapAddress = oldNotaryNode.network.myAddress, advertisedServices = ServiceInfo(ValidatingNotaryService.type))
-        mockNet.registerIdentities()
+        clientNodeA = mockNet.createNode()
+        clientNodeB = mockNet.createNode()
+        newNotaryNode = mockNet.createNode(advertisedServices = ServiceInfo(ValidatingNotaryService.type))
         mockNet.runNetwork() // Clear network map registration messages
         oldNotaryNode.internals.ensureRegistered()
         newNotaryParty = newNotaryNode.info.legalIdentities[1]
diff --git a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
index 9e4215a814..399f58f196 100644
--- a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
@@ -98,8 +98,8 @@ class ScheduledFlowTests {
         notaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
                 advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type)))
-        val a = mockNet.createUnstartedNode(notaryNode.network.myAddress)
-        val b = mockNet.createUnstartedNode(notaryNode.network.myAddress)
+        val a = mockNet.createUnstartedNode()
+        val b = mockNet.createUnstartedNode()
 
         notaryNode.internals.ensureRegistered()
 
diff --git a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
index 403a149183..a429b84d1f 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
@@ -50,11 +50,8 @@ abstract class AbstractNetworkMapServiceTest<out S : AbstractNetworkMapService>
     @Before
     fun setup() {
         mockNet = MockNetwork(defaultFactory = nodeFactory)
-        mapServiceNode = mockNet.createNode(
-                nodeFactory = nodeFactory,
-                legalName = DUMMY_MAP.name,
-                advertisedServices = *arrayOf(ServiceInfo(SimpleNotaryService.type)))
-        alice = mockNet.createNode(mapServiceNode.network.myAddress, nodeFactory = nodeFactory, legalName = ALICE.name)
+        mapServiceNode = mockNet.networkMapNode
+        alice = mockNet.createNode(nodeFactory = nodeFactory, legalName = ALICE.name)
         mockNet.runNetwork()
         lastSerial = System.currentTimeMillis()
     }
@@ -249,7 +246,7 @@ abstract class AbstractNetworkMapServiceTest<out S : AbstractNetworkMapService>
     }
 
     private fun addNewNodeToNetworkMap(legalName: CordaX500Name): StartedNode<MockNode> {
-        val node = mockNet.createNode(mapServiceNode.network.myAddress, legalName = legalName)
+        val node = mockNet.createNode(legalName = legalName)
         mockNet.runNetwork()
         lastSerial = System.currentTimeMillis()
         return node
@@ -275,9 +272,9 @@ abstract class AbstractNetworkMapServiceTest<out S : AbstractNetworkMapService>
                             networkMapAddr: SingleMessageRecipient?,
                             advertisedServices: Set<ServiceInfo>,
                             id: Int,
-                            overrideServices: Map<ServiceInfo, KeyPair>?,
+                            notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): MockNode {
-            return object : MockNode(config, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot) {
+            return object : MockNode(config, network, null, advertisedServices, id, notaryIdentity, entropyRoot) {
                 override fun makeNetworkMapService() = NullNetworkMapService
             }
         }
diff --git a/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt b/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
index 2baba6ff3c..d097f8d614 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
@@ -28,9 +28,9 @@ class NetworkMapCacheTest {
 
     @Test
     fun registerWithNetwork() {
-        val mapNode = mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(mapNode.network.myAddress, ALICE.name)
-        val future = aliceNode.services.networkMapCache.addMapService(aliceNode.network, mapNode.network.myAddress, false, null)
+        mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val future = aliceNode.services.networkMapCache.addMapService(aliceNode.network, mockNet.networkMapNode.network.myAddress, false, null)
         mockNet.runNetwork()
         future.getOrThrow()
     }
@@ -39,13 +39,12 @@ class NetworkMapCacheTest {
     fun `key collision`() {
         val entropy = BigInteger.valueOf(24012017L)
         val aliceNode = mockNet.createNode(nodeFactory = MockNetwork.DefaultFactory, legalName = ALICE.name, entropyRoot = entropy)
-        val bobNode = mockNet.createNode(nodeFactory = MockNetwork.DefaultFactory, legalName = BOB.name, entropyRoot = entropy)
-        assertEquals(aliceNode.info.chooseIdentity(), bobNode.info.chooseIdentity())
-
         mockNet.runNetwork()
 
         // Node A currently knows only about itself, so this returns node A
         assertEquals(aliceNode.services.networkMapCache.getNodesByLegalIdentityKey(aliceNode.info.chooseIdentity().owningKey).singleOrNull(), aliceNode.info)
+        val bobNode = mockNet.createNode(nodeFactory = MockNetwork.DefaultFactory, legalName = BOB.name, entropyRoot = entropy)
+        assertEquals(aliceNode.info.chooseIdentity(), bobNode.info.chooseIdentity())
 
         aliceNode.services.networkMapCache.addNode(bobNode.info)
         // The details of node B write over those for node A
@@ -55,7 +54,7 @@ class NetworkMapCacheTest {
     @Test
     fun `getNodeByLegalIdentity`() {
         val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
         val notaryCache: NetworkMapCache = notaryNode.services.networkMapCache
         val expected = aliceNode.info
 
@@ -69,7 +68,7 @@ class NetworkMapCacheTest {
     @Test
     fun `remove node from cache`() {
         val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(notaryNode.network.myAddress, ALICE.name)
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
         val notaryLegalIdentity = notaryNode.info.chooseIdentity()
         val alice = aliceNode.info.chooseIdentity()
         val notaryCache = notaryNode.services.networkMapCache as PersistentNetworkMapCache
diff --git a/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt
index 2f6966097a..19bf42cf65 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt
@@ -32,9 +32,9 @@ class PersistentNetworkMapServiceTest : AbstractNetworkMapServiceTest<Persistent
                             networkMapAddr: SingleMessageRecipient?,
                             advertisedServices: Set<ServiceInfo>,
                             id: Int,
-                            overrideServices: Map<ServiceInfo, KeyPair>?,
+                            notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): MockNode {
-            return object : MockNode(config, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot) {
+            return object : MockNode(config, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
                 override fun makeNetworkMapService() = SwizzleNetworkMapService(services)
             }
         }
diff --git a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
index 0d832f164a..34f5e256a5 100644
--- a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
@@ -79,7 +79,7 @@ class FlowFrameworkTests {
         setCordappPackages("net.corda.finance.contracts", "net.corda.testing.contracts")
         mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
         node1 = mockNet.createNode()
-        node2 = mockNet.createNode(networkMapAddress = node1.network.myAddress)
+        node2 = mockNet.createNode()
 
         mockNet.runNetwork()
         node1.internals.ensureRegistered()
@@ -87,17 +87,15 @@ class FlowFrameworkTests {
         // We intentionally create our own notary and ignore the one provided by the network
         val notaryKeyPair = generateKeyPair()
         val notaryService = ServiceInfo(ValidatingNotaryService.type, CordaX500Name(commonName = ValidatingNotaryService.type.id, organisation = "Notary service 2000", locality = "London", country = "GB"))
-        val overrideServices = mapOf(Pair(notaryService, notaryKeyPair))
+        val notaryIdentityOverride = Pair(notaryService, notaryKeyPair)
         // Note that these notaries don't operate correctly as they don't share their state. They are only used for testing
         // service addressing.
-        notary1 = mockNet.createNotaryNode(networkMapAddress = node1.network.myAddress, overrideServices = overrideServices, serviceName = notaryService.name)
-        notary2 = mockNet.createNotaryNode(networkMapAddress = node1.network.myAddress, overrideServices = overrideServices, serviceName = notaryService.name)
+        notary1 = mockNet.createNotaryNode(notaryIdentity = notaryIdentityOverride, serviceName = notaryService.name)
+        notary2 = mockNet.createNotaryNode(notaryIdentity = notaryIdentityOverride, serviceName = notaryService.name)
 
         receivedSessionMessagesObservable().forEach { receivedSessionMessages += it }
         mockNet.runNetwork()
 
-        // We don't create a network map, so manually handle registrations
-        mockNet.registerIdentities()
         notary1Identity = notary1.services.myInfo.legalIdentities[1]
         notary2Identity = notary2.services.myInfo.legalIdentities[1]
     }
@@ -160,7 +158,7 @@ class FlowFrameworkTests {
 
     @Test
     fun `flow added before network map does run after init`() {
-        val node3 = mockNet.createNode(node1.network.myAddress) //create vanilla node
+        val node3 = mockNet.createNode() //create vanilla node
         val flow = NoOpFlow()
         node3.services.startFlow(flow)
         assertEquals(false, flow.flowStarted) // Not started yet as no network activity has been allowed yet
@@ -170,7 +168,7 @@ class FlowFrameworkTests {
 
     @Test
     fun `flow added before network map will be init checkpointed`() {
-        var node3 = mockNet.createNode(node1.network.myAddress) //create vanilla node
+        var node3 = mockNet.createNode() //create vanilla node
         val flow = NoOpFlow()
         node3.services.startFlow(flow)
         assertEquals(false, flow.flowStarted) // Not started yet as no network activity has been allowed yet
@@ -178,7 +176,7 @@ class FlowFrameworkTests {
         node3.services.networkMapCache.clearNetworkMapCache() // zap persisted NetworkMapCache to force use of network.
         node3.dispose()
 
-        node3 = mockNet.createNode(node1.network.myAddress, node3.internals.id)
+        node3 = mockNet.createNode(node3.internals.id)
         val restoredFlow = node3.getSingleFlow<NoOpFlow>().first
         assertEquals(false, restoredFlow.flowStarted) // Not started yet as no network activity has been allowed yet
         mockNet.runNetwork() // Allow network map messages to flow
@@ -189,7 +187,7 @@ class FlowFrameworkTests {
         node3.dispose()
 
         // Now it is completed the flow should leave no Checkpoint.
-        node3 = mockNet.createNode(node1.network.myAddress, node3.internals.id)
+        node3 = mockNet.createNode(node3.internals.id)
         mockNet.runNetwork() // Allow network map messages to flow
         node3.smm.executor.flush()
         assertTrue(node3.smm.findStateMachines(NoOpFlow::class.java).isEmpty())
@@ -215,7 +213,7 @@ class FlowFrameworkTests {
         var sentCount = 0
         mockNet.messagingNetwork.sentMessages.toSessionTransfers().filter { it.isPayloadTransfer }.forEach { sentCount++ }
 
-        val node3 = mockNet.createNode(node1.network.myAddress)
+        val node3 = mockNet.createNode()
         val secondFlow = node3.registerFlowFactory(PingPongFlow::class) { PingPongFlow(it, payload2) }
         mockNet.runNetwork()
 
@@ -233,7 +231,7 @@ class FlowFrameworkTests {
             assertEquals(1, node2.checkpointStorage.checkpoints().size) // confirm checkpoint
             node2.services.networkMapCache.clearNetworkMapCache()
         }
-        val node2b = mockNet.createNode(node1.network.myAddress, node2.internals.id, advertisedServices = *node2.internals.advertisedServices.toTypedArray())
+        val node2b = mockNet.createNode(node2.internals.id, advertisedServices = *node2.internals.advertisedServices.toTypedArray())
         node2.internals.manuallyCloseDB()
         val (firstAgain, fut1) = node2b.getSingleFlow<PingPongFlow>()
         // Run the network which will also fire up the second flow. First message should get deduped. So message data stays in sync.
@@ -260,7 +258,7 @@ class FlowFrameworkTests {
 
     @Test
     fun `sending to multiple parties`() {
-        val node3 = mockNet.createNode(node1.network.myAddress)
+        val node3 = mockNet.createNode()
         mockNet.runNetwork()
         node2.registerFlowFactory(SendFlow::class) { InitiatedReceiveFlow(it).nonTerminating() }
         node3.registerFlowFactory(SendFlow::class) { InitiatedReceiveFlow(it).nonTerminating() }
@@ -292,7 +290,7 @@ class FlowFrameworkTests {
 
     @Test
     fun `receiving from multiple parties`() {
-        val node3 = mockNet.createNode(node1.network.myAddress)
+        val node3 = mockNet.createNode()
         mockNet.runNetwork()
         val node2Payload = "Test 1"
         val node3Payload = "Test 2"
@@ -501,7 +499,7 @@ class FlowFrameworkTests {
 
     @Test
     fun `FlowException propagated in invocation chain`() {
-        val node3 = mockNet.createNode(node1.network.myAddress)
+        val node3 = mockNet.createNode()
         mockNet.runNetwork()
 
         node3.registerFlowFactory(ReceiveFlow::class) { ExceptionFlow { MyFlowException("Chain") } }
@@ -515,7 +513,7 @@ class FlowFrameworkTests {
 
     @Test
     fun `FlowException thrown and there is a 3rd unrelated party flow`() {
-        val node3 = mockNet.createNode(node1.network.myAddress)
+        val node3 = mockNet.createNode()
         mockNet.runNetwork()
 
         // Node 2 will send its payload and then block waiting for the receive from node 1. Meanwhile node 1 will move
@@ -763,7 +761,7 @@ class FlowFrameworkTests {
     private inline fun <reified P : FlowLogic<*>> StartedNode<MockNode>.restartAndGetRestoredFlow(networkMapNode: StartedNode<*>? = null) = internals.run {
         disableDBCloseOnStop() // Handover DB to new node copy
         stop()
-        val newNode = mockNet.createNode(networkMapNode?.network?.myAddress, id, advertisedServices = *advertisedServices.toTypedArray())
+        val newNode = mockNet.createNode(id, advertisedServices = *advertisedServices.toTypedArray())
         newNode.internals.acceptableLiveFiberCountOnStop = 1
         manuallyCloseDB()
         mockNet.runNetwork() // allow NetworkMapService messages to stabilise and thus start the state machine
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
index eac332f7f6..e395ce739e 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
@@ -39,7 +39,7 @@ class NotaryServiceTests {
         notaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
                 advertisedServices = *arrayOf(ServiceInfo(SimpleNotaryService.type)))
-        clientNode = mockNet.createNode(notaryNode.network.myAddress)
+        clientNode = mockNet.createNode()
         mockNet.runNetwork() // Clear network map registration messages
         notaryNode.internals.ensureRegistered()
         notary = clientNode.services.getDefaultNotary()
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
index 4de1dfba75..fb4741e373 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
@@ -40,7 +40,7 @@ class ValidatingNotaryServiceTests {
                 legalName = DUMMY_NOTARY.name,
                 advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type))
         )
-        clientNode = mockNet.createNode(notaryNode.network.myAddress)
+        clientNode = mockNet.createNode()
         mockNet.runNetwork() // Clear network map registration messages
         notaryNode.internals.ensureRegistered()
         notary = clientNode.services.getDefaultNotary()
diff --git a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
index 905ee4dbdc..a6b720cf72 100644
--- a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
+++ b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
@@ -204,7 +204,7 @@ class NodeInterestRatesTest : TestDependencyInjectionBase() {
     fun `network tearoff`() {
         val mockNet = MockNetwork(initialiseSerialization = false)
         val n1 = mockNet.createNotaryNode()
-        val oracleNode = mockNet.createNode(n1.network.myAddress).apply {
+        val oracleNode = mockNet.createNode().apply {
             internals.registerInitiatedFlow(NodeInterestRates.FixQueryHandler::class.java)
             internals.registerInitiatedFlow(NodeInterestRates.FixSignHandler::class.java)
             database.transaction {
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
index 47483f7610..ea09fa73c0 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
@@ -54,9 +54,9 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
     // This puts together a mock network of SimulatedNodes.
 
     open class SimulatedNode(config: NodeConfiguration, mockNet: MockNetwork, networkMapAddress: SingleMessageRecipient?,
-                             advertisedServices: Set<ServiceInfo>, id: Int, overrideServices: Map<ServiceInfo, KeyPair>?,
+                             advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                              entropyRoot: BigInteger)
-        : MockNetwork.MockNode(config, mockNet, networkMapAddress, advertisedServices, id, overrideServices, entropyRoot) {
+        : MockNetwork.MockNode(config, mockNet, networkMapAddress, advertisedServices, id, notaryIdentity, entropyRoot) {
         override val started: StartedNode<SimulatedNode>? get() = uncheckedCast(super.started)
         override fun findMyLocation(): WorldMapLocation? {
             return configuration.myLegalName.locality.let { CityDatabase[it] }
@@ -67,7 +67,7 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
         var counter = 0
 
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, overrideServices: Map<ServiceInfo, KeyPair>?,
+                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): SimulatedNode {
             val letter = 'A' + counter
             val (city, country) = bankLocations[counter++ % bankLocations.size]
@@ -75,13 +75,13 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
                     myLegalName = CordaX500Name(organisation = "Bank $letter", locality = city, country = country))
-            return SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot)
+            return SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot)
         }
 
         fun createAll(): List<SimulatedNode> {
             return bankLocations.mapIndexed { i, _ ->
                 // Use deterministic seeds so the simulation is stable. Needed so that party owning keys are stable.
-                mockNet.createUnstartedNode(networkMap.network.myAddress, nodeFactory = this, entropyRoot = BigInteger.valueOf(i.toLong()))
+                mockNet.createUnstartedNode(nodeFactory = this, entropyRoot = BigInteger.valueOf(i.toLong()))
             }
         }
     }
@@ -90,24 +90,24 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
 
     object NetworkMapNodeFactory : MockNetwork.Factory<SimulatedNode> {
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, overrideServices: Map<ServiceInfo, KeyPair>?,
+                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): SimulatedNode {
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
                     myLegalName = DUMMY_MAP.name)
-            return object : SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot) {}
+            return object : SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {}
         }
     }
 
     object NotaryNodeFactory : MockNetwork.Factory<SimulatedNode> {
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, overrideServices: Map<ServiceInfo, KeyPair>?,
+                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): SimulatedNode {
             require(advertisedServices.containsType(SimpleNotaryService.type))
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
                     myLegalName = DUMMY_NOTARY.name)
-            return SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot)
+            return SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot)
         }
     }
 
@@ -116,12 +116,12 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
         val RATES_SERVICE_NAME = CordaX500Name(organisation = "Rates Service Provider", locality = "Madrid", country = "ES")
 
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, overrideServices: Map<ServiceInfo, KeyPair>?,
+                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): SimulatedNode {
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
                     myLegalName = RATES_SERVICE_NAME)
-            return object : SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot) {
+            return object : SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
                 override fun start() = super.start().apply {
                     registerInitiatedFlow(NodeInterestRates.FixQueryHandler::class.java)
                     registerInitiatedFlow(NodeInterestRates.FixSignHandler::class.java)
@@ -137,12 +137,12 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
 
     object RegulatorFactory : MockNetwork.Factory<SimulatedNode> {
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, overrideServices: Map<ServiceInfo, KeyPair>?,
+                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): SimulatedNode {
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
                     myLegalName = DUMMY_REGULATOR.name)
-            return object : SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot) {
+            return object : SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
                 // TODO: Regulatory nodes don't actually exist properly, this is a last minute demo request.
                 //       So we just fire a message at a node that doesn't know how to handle it, and it'll ignore it.
                 //       But that's fine for visualisation purposes.
@@ -152,10 +152,10 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
 
     val mockNet = MockNetwork(networkSendManuallyPumped, runAsync)
     // This one must come first.
-    val networkMap = mockNet.createNode(nodeFactory = NetworkMapNodeFactory)
-    val notary = mockNet.createNode(networkMap.network.myAddress, nodeFactory = NotaryNodeFactory, advertisedServices = ServiceInfo(SimpleNotaryService.type))
-    val regulators = listOf(mockNet.createUnstartedNode(networkMap.network.myAddress, nodeFactory = RegulatorFactory))
-    val ratesOracle = mockNet.createUnstartedNode(networkMap.network.myAddress, nodeFactory = RatesOracleFactory)
+    val networkMap = mockNet.startNetworkMapNode(nodeFactory = NetworkMapNodeFactory)
+    val notary = mockNet.createNode(nodeFactory = NotaryNodeFactory, advertisedServices = ServiceInfo(SimpleNotaryService.type))
+    val regulators = listOf(mockNet.createUnstartedNode(nodeFactory = RegulatorFactory))
+    val ratesOracle = mockNet.createUnstartedNode(nodeFactory = RatesOracleFactory)
 
     // All nodes must be in one of these two lists for the purposes of the visualiser tool.
     val serviceProviders: List<SimulatedNode> = listOf(notary.internals, ratesOracle, networkMap.internals)
@@ -264,7 +264,6 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
     fun start(): Future<Unit> {
         setCordappPackages("net.corda.irs.contract", "net.corda.finance.contract")
         mockNet.startNodes()
-        mockNet.registerIdentities()
         // Wait for all the nodes to have finished registering with the network map service.
         return networkInitialisationFinished.thenCompose { startMainSimulation() }
     }
diff --git a/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt b/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
index 15c8fb4c77..f9fc3f3002 100644
--- a/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
+++ b/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
@@ -295,9 +295,9 @@ class FlowStackSnapshotTest {
         val notaryService = ServiceInfo(ValidatingNotaryService.type)
         val notaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
-                overrideServices = mapOf(notaryService to DUMMY_NOTARY_KEY),
+                notaryIdentity = notaryService to DUMMY_NOTARY_KEY,
                 advertisedServices = *arrayOf(notaryService))
-        val node = mockNet.createPartyNode(notaryNode.network.myAddress)
+        val node = mockNet.createPartyNode()
         node.internals.registerInitiatedFlow(DummyFlow::class.java)
         node.services.startFlow(FlowStackSnapshotSerializationTestingFlow()).resultFuture.get()
         val thrown = try {
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index af479b9382..2f8f50b7c3 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -6,6 +6,7 @@ import com.nhaarman.mockito_kotlin.whenever
 import net.corda.core.crypto.entropyToKeyPair
 import net.corda.core.crypto.random63BitValue
 import net.corda.core.identity.CordaX500Name
+import net.corda.core.identity.Party
 import net.corda.core.identity.PartyAndCertificate
 import net.corda.core.internal.cert
 import net.corda.core.internal.concurrent.doneFuture
@@ -76,6 +77,11 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                   InMemoryMessagingNetwork.ServicePeerAllocationStrategy.Random(),
                   private val defaultFactory: Factory<*> = MockNetwork.DefaultFactory,
                   private val initialiseSerialization: Boolean = true) {
+    companion object {
+        // TODO In future PR we're removing the concept of network map node so the details of this mock are not important.
+        val MOCK_NET_MAP = Party(CordaX500Name(organisation = "Mock Network Map", locality = "Madrid", country = "ES"), DUMMY_KEY_1.public)
+    }
+
     var nextNodeId = 0
         private set
     private val filesystem = Jimfs.newFileSystem(unix())
@@ -87,6 +93,9 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
     /** A read only view of the current set of executing nodes. */
     val nodes: List<MockNode> get() = _nodes
 
+    private var _networkMapNode: StartedNode<MockNode>? = null
+    val networkMapNode: StartedNode<MockNode> get() = _networkMapNode ?: startNetworkMapNode()
+
     init {
         if (initialiseSerialization) initialiseTestSerialization()
         filesystem.getPath("/nodes").createDirectory()
@@ -95,21 +104,21 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
     /** Allows customisation of how nodes are created. */
     interface Factory<out N : MockNode> {
         /**
-         * @param overrideServices a set of service entries to use in place of the node's default service entries,
-         * for example where a node's service is part of a cluster.
+         * @param notaryIdentity is an additional override to use in place of the node's default notary service,
+         * main usage is for when the node is part of a notary cluster.
          * @param entropyRoot the initial entropy value to use when generating keys. Defaults to an (insecure) random value,
          * but can be overriden to cause nodes to have stable or colliding identity/service keys.
          */
         fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                   advertisedServices: Set<ServiceInfo>, id: Int, overrideServices: Map<ServiceInfo, KeyPair>?,
+                   advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                    entropyRoot: BigInteger): N
     }
 
     object DefaultFactory : Factory<MockNode> {
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, overrideServices: Map<ServiceInfo, KeyPair>?,
+                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): MockNode {
-            return MockNode(config, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot)
+            return MockNode(config, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot)
         }
     }
 
@@ -137,8 +146,8 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
     }
 
     /**
-     * @param overrideServices a set of service entries to use in place of the node's default service entries,
-     * for example where a node's service is part of a cluster.
+     * @param notaryIdentity is an additional override to use in place of the node's default notary service,
+     * main usage is for when the node is part of a notary cluster.
      * @param entropyRoot the initial entropy value to use when generating keys. Defaults to an (insecure) random value,
      * but can be overriden to cause nodes to have stable or colliding identity/service keys.
      */
@@ -147,7 +156,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                         override val networkMapAddress: SingleMessageRecipient?,
                         advertisedServices: Set<ServiceInfo>,
                         val id: Int,
-                        val overrideServices: Map<ServiceInfo, KeyPair>?,
+                        internal val notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                         val entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue())) :
             AbstractNode(config, advertisedServices, TestClock(), mockNet.busyLatch) {
         var counter = entropyRoot
@@ -199,7 +208,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
         }
 
         override fun makeKeyManagementService(identityService: IdentityService): KeyManagementService {
-            return E2ETestKeyManagementService(identityService, partyKeys + (overrideServices?.values ?: emptySet()))
+            return E2ETestKeyManagementService(identityService, partyKeys + (notaryIdentity?.let { setOf(it.second) } ?: emptySet()))
         }
 
         override fun startMessagingService(rpcOps: RPCOps) {
@@ -212,12 +221,11 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
 
         override fun getNotaryIdentity(): PartyAndCertificate? {
             val defaultIdentity = super.getNotaryIdentity()
-            val override = overrideServices?.filter { it.key.type.isNotary() }?.entries?.singleOrNull()
-            return if (override == null || defaultIdentity == null)
+            return if (notaryIdentity == null || !notaryIdentity.first.type.isNotary() || defaultIdentity == null)
                 defaultIdentity
             else {
                 // Ensure that we always have notary in name and type of it. TODO It is temporary solution until we will have proper handling of NetworkParameters
-                myNotaryIdentity = getTestPartyAndCertificate(defaultIdentity.name, override.value.public)
+                myNotaryIdentity = getTestPartyAndCertificate(defaultIdentity.name, notaryIdentity.second.public)
                 myNotaryIdentity
             }
         }
@@ -294,49 +302,67 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
         }
     }
 
-    fun createUnstartedNode(networkMapAddress: SingleMessageRecipient? = null, forcedID: Int? = null,
-                            legalName: CordaX500Name? = null, overrideServices: Map<ServiceInfo, KeyPair>? = null,
+    fun <N : MockNode> startNetworkMapNode(nodeFactory: Factory<N>? = null): StartedNode<N> {
+        check(_networkMapNode == null) { "Trying to start more than one network map node" }
+        return uncheckedCast(createNodeImpl(networkMapAddress = null,
+                forcedID = null,
+                nodeFactory = nodeFactory ?: defaultFactory,
+                legalName = MOCK_NET_MAP.name,
+                notaryIdentity = null,
+                advertisedServices = arrayOf(),
+                entropyRoot  = BigInteger.valueOf(random63BitValue()),
+                configOverrides = {},
+                start = true
+        ).started!!.apply {
+            _networkMapNode = this
+        })
+    }
+
+    fun createUnstartedNode(forcedID: Int? = null,
+                            legalName: CordaX500Name? = null, notaryIdentity: Pair<ServiceInfo, KeyPair>? = null,
                             entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue()),
                             vararg advertisedServices: ServiceInfo,
                             configOverrides: (NodeConfiguration) -> Any? = {}): MockNode {
-        return createUnstartedNode(networkMapAddress, forcedID, defaultFactory, legalName, overrideServices, entropyRoot, *advertisedServices, configOverrides = configOverrides)
+        return createUnstartedNode(forcedID, defaultFactory, legalName, notaryIdentity, entropyRoot, *advertisedServices, configOverrides = configOverrides)
     }
 
-    fun <N : MockNode> createUnstartedNode(networkMapAddress: SingleMessageRecipient? = null, forcedID: Int? = null, nodeFactory: Factory<N>,
-                                           legalName: CordaX500Name? = null, overrideServices: Map<ServiceInfo, KeyPair>? = null,
+    fun <N : MockNode> createUnstartedNode(forcedID: Int? = null, nodeFactory: Factory<N>,
+                                           legalName: CordaX500Name? = null, notaryIdentity: Pair<ServiceInfo, KeyPair>? = null,
                                            entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue()),
                                            vararg advertisedServices: ServiceInfo,
                                            configOverrides: (NodeConfiguration) -> Any? = {}): N {
-        return createNodeImpl(networkMapAddress, forcedID, nodeFactory, false, legalName, overrideServices, entropyRoot, advertisedServices, configOverrides)
+        val networkMapAddress = networkMapNode.network.myAddress
+        return createNodeImpl(networkMapAddress, forcedID, nodeFactory, false, legalName, notaryIdentity, entropyRoot, advertisedServices, configOverrides)
     }
 
     /**
      * Returns a node, optionally created by the passed factory method.
-     * @param overrideServices a set of service entries to use in place of the node's default service entries,
+     * @param notaryIdentity a set of service entries to use in place of the node's default service entries,
      * for example where a node's service is part of a cluster.
      * @param entropyRoot the initial entropy value to use when generating keys. Defaults to an (insecure) random value,
      * but can be overridden to cause nodes to have stable or colliding identity/service keys.
      * @param configOverrides add/override behaviour of the [NodeConfiguration] mock object.
      */
-    fun createNode(networkMapAddress: SingleMessageRecipient? = null, forcedID: Int? = null,
-                   legalName: CordaX500Name? = null, overrideServices: Map<ServiceInfo, KeyPair>? = null,
+    fun createNode(forcedID: Int? = null,
+                   legalName: CordaX500Name? = null, notaryIdentity: Pair<ServiceInfo, KeyPair>? = null,
                    entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue()),
                    vararg advertisedServices: ServiceInfo,
                    configOverrides: (NodeConfiguration) -> Any? = {}): StartedNode<MockNode> {
-        return createNode(networkMapAddress, forcedID, defaultFactory, legalName, overrideServices, entropyRoot, *advertisedServices, configOverrides = configOverrides)
+        return createNode(forcedID, defaultFactory, legalName, notaryIdentity, entropyRoot, *advertisedServices, configOverrides = configOverrides)
     }
 
     /** Like the other [createNode] but takes a [Factory] and propagates its [MockNode] subtype. */
-    fun <N : MockNode> createNode(networkMapAddress: SingleMessageRecipient? = null, forcedID: Int? = null, nodeFactory: Factory<N>,
-                                  legalName: CordaX500Name? = null, overrideServices: Map<ServiceInfo, KeyPair>? = null,
+    fun <N : MockNode> createNode(forcedID: Int? = null, nodeFactory: Factory<N>,
+                                  legalName: CordaX500Name? = null, notaryIdentity: Pair<ServiceInfo, KeyPair>? = null,
                                   entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue()),
                                   vararg advertisedServices: ServiceInfo,
                                   configOverrides: (NodeConfiguration) -> Any? = {}): StartedNode<N> {
-        return uncheckedCast(createNodeImpl(networkMapAddress, forcedID, nodeFactory, true, legalName, overrideServices, entropyRoot, advertisedServices, configOverrides).started)!!
+        val networkMapAddress = networkMapNode.network.myAddress
+        return uncheckedCast(createNodeImpl(networkMapAddress, forcedID, nodeFactory, true, legalName, notaryIdentity, entropyRoot, advertisedServices, configOverrides).started)!!
     }
 
     private fun <N : MockNode> createNodeImpl(networkMapAddress: SingleMessageRecipient?, forcedID: Int?, nodeFactory: Factory<N>,
-                                              start: Boolean, legalName: CordaX500Name?, overrideServices: Map<ServiceInfo, KeyPair>?,
+                                              start: Boolean, legalName: CordaX500Name?, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                                               entropyRoot: BigInteger,
                                               advertisedServices: Array<out ServiceInfo>,
                                               configOverrides: (NodeConfiguration) -> Any?): N {
@@ -347,7 +373,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
             whenever(it.dataSourceProperties).thenReturn(makeTestDataSourceProperties("node_${id}_net_$networkId"))
             configOverrides(it)
         }
-        return nodeFactory.create(config, this, networkMapAddress, advertisedServices.toSet(), id, overrideServices, entropyRoot).apply {
+        return nodeFactory.create(config, this, networkMapAddress, advertisedServices.toSet(), id, notaryIdentity, entropyRoot).apply {
             if (start) {
                 start()
                 if (threadPerNode && networkMapAddress != null) nodeReadyFuture.getOrThrow() // XXX: What about manually-started nodes?
@@ -379,36 +405,22 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
         }
     }
 
-    /**
-     * Register network identities in identity service, normally it's done on network map cache change, but we may run without
-     * network map service.
-     */
-    fun registerIdentities(){
-        nodes.forEach { itNode ->
-            itNode.started!!.database.transaction {
-                nodes.map { it.started!!.info.legalIdentitiesAndCerts.first() }.map(itNode.started!!.services.identityService::verifyAndRegisterIdentity)
-            }
-        }
-    }
-
     /**
      * Construct a default notary node.
      */
-    fun createNotaryNode() = createNotaryNode(null, DUMMY_NOTARY.name, null, null)
+    fun createNotaryNode() = createNotaryNode(DUMMY_NOTARY.name, null, null)
 
-    fun createNotaryNode(networkMapAddress: SingleMessageRecipient? = null,
-                         legalName: CordaX500Name? = null,
-                         overrideServices: Map<ServiceInfo, KeyPair>? = null,
+    fun createNotaryNode(legalName: CordaX500Name? = null,
+                         notaryIdentity: Pair<ServiceInfo, KeyPair>? = null,
                          serviceName: CordaX500Name? = null): StartedNode<MockNode> {
-        return createNode(networkMapAddress, legalName = legalName, overrideServices = overrideServices,
+        return createNode(legalName = legalName, notaryIdentity = notaryIdentity,
                 advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type, serviceName)))
     }
 
     @JvmOverloads
-    fun createPartyNode(networkMapAddress: SingleMessageRecipient,
-                        legalName: CordaX500Name? = null,
-                        overrideServices: Map<ServiceInfo, KeyPair>? = null): StartedNode<MockNode> {
-        return createNode(networkMapAddress, legalName = legalName, overrideServices = overrideServices)
+    fun createPartyNode(legalName: CordaX500Name? = null,
+                        notaryIdentity: Pair<ServiceInfo, KeyPair>? = null): StartedNode<MockNode> {
+        return createNode(legalName = legalName, notaryIdentity = notaryIdentity)
     }
 
     @Suppress("unused") // This is used from the network visualiser tool.

From fde30d01811fb82d579f8edc04e1c170af192cdb Mon Sep 17 00:00:00 2001
From: Alberto Arri <30873160+al-r3@users.noreply.github.com>
Date: Fri, 6 Oct 2017 10:45:17 +0100
Subject: [PATCH 097/185] removed unused variable in PersistentNetworkMapCache
 (#1813)

val publicKey in unused in PersistentNetworkMapCache, removed.
---
 .../corda/node/services/network/PersistentNetworkMapCache.kt    | 2 --
 1 file changed, 2 deletions(-)

diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
index 2dac97909a..b2fb8c3bde 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
@@ -19,7 +19,6 @@ import net.corda.core.serialization.deserialize
 import net.corda.core.serialization.serialize
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.loggerFor
-import net.corda.core.utilities.parsePublicKeyBase58
 import net.corda.core.utilities.toBase58String
 import net.corda.node.services.api.NetworkCacheException
 import net.corda.node.services.api.NetworkMapCacheInternal
@@ -274,7 +273,6 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
             for (nodeInfo in result) {
                 try {
                     logger.info("Loaded node info: $nodeInfo")
-                    val publicKey = parsePublicKeyBase58(nodeInfo.legalIdentitiesAndCerts.single { it.isMain }.owningKey)
                     val node = nodeInfo.toNodeInfo()
                     addNode(node)
                     _loadDBSuccess = true // This is used in AbstractNode to indicate that node is ready.

From fe4635a81e4f4cf216a8f3cdecd762cfe79317ce Mon Sep 17 00:00:00 2001
From: Matthew Nesbit <matthew.nesbit@r3cev.com>
Date: Tue, 3 Oct 2017 17:47:47 +0100
Subject: [PATCH 098/185] Start Flows from services

Update tests

Add a test to show progress tracking works

Include service startable flow in Cordapp data structures.

Respond to PR comments

Fixup change of api inline with PR comments.

Address PR comments
---
 .../kotlin/net/corda/core/cordapp/Cordapp.kt  |   2 +
 .../net/corda/core/flows/FlowInitiator.kt     |   4 +
 .../corda/core/flows/StartableByService.kt    |  12 ++
 .../core/internal/cordapp/CordappImpl.kt      |   1 +
 .../net/corda/core/node/AppServiceHub.kt      |  30 ++++
 .../corda/core/node/services/CordaService.kt  |   2 +-
 .../net/corda/node/internal/AbstractNode.kt   |  60 +++++++-
 .../node/internal/cordapp/CordappLoader.kt    |  14 +-
 .../node/shell/FlowWatchPrintingSubscriber.kt |   1 +
 .../corda/node/internal/CordaServiceTest.kt   | 132 ++++++++++++++++++
 .../internal/cordapp/CordappLoaderTest.kt     |   5 +
 .../corda/testing/node/MockCordappProvider.kt |   2 +-
 12 files changed, 254 insertions(+), 11 deletions(-)
 create mode 100644 core/src/main/kotlin/net/corda/core/flows/StartableByService.kt
 create mode 100644 core/src/main/kotlin/net/corda/core/node/AppServiceHub.kt
 create mode 100644 node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt

diff --git a/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt b/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
index 32c011866e..8f7f5f8d56 100644
--- a/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
+++ b/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt
@@ -17,6 +17,7 @@ import java.net.URL
  * @property contractClassNames List of contracts
  * @property initiatedFlows List of initiatable flow classes
  * @property rpcFlows List of RPC initiable flows classes
+ * @property serviceFlows List of [CordaService] initiable flows classes
  * @property schedulableFlows List of flows startable by the scheduler
  * @property servies List of RPC services
  * @property serializationWhitelists List of Corda plugin registries
@@ -28,6 +29,7 @@ interface Cordapp {
     val contractClassNames: List<String>
     val initiatedFlows: List<Class<out FlowLogic<*>>>
     val rpcFlows: List<Class<out FlowLogic<*>>>
+    val serviceFlows:  List<Class<out FlowLogic<*>>>
     val schedulableFlows: List<Class<out FlowLogic<*>>>
     val services: List<Class<out SerializeAsToken>>
     val serializationWhitelists: List<SerializationWhitelist>
diff --git a/core/src/main/kotlin/net/corda/core/flows/FlowInitiator.kt b/core/src/main/kotlin/net/corda/core/flows/FlowInitiator.kt
index 3860e73a06..549af46dcf 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FlowInitiator.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FlowInitiator.kt
@@ -20,6 +20,10 @@ sealed class FlowInitiator : Principal {
     data class Peer(val party: Party) : FlowInitiator() {
         override fun getName(): String = party.name.toString()
     }
+    /** Started by a CordaService. */
+    data class Service(val serviceClassName: String) : FlowInitiator() {
+        override fun getName(): String = serviceClassName
+    }
     /** Started as scheduled activity. */
     data class Scheduled(val scheduledState: ScheduledStateRef) : FlowInitiator() {
         override fun getName(): String = "Scheduler"
diff --git a/core/src/main/kotlin/net/corda/core/flows/StartableByService.kt b/core/src/main/kotlin/net/corda/core/flows/StartableByService.kt
new file mode 100644
index 0000000000..3674c53e04
--- /dev/null
+++ b/core/src/main/kotlin/net/corda/core/flows/StartableByService.kt
@@ -0,0 +1,12 @@
+package net.corda.core.flows
+
+import kotlin.annotation.AnnotationTarget.CLASS
+
+/**
+ * Any [FlowLogic] which is to be started by the [AppServiceHub] interface from
+ * within a [CordaService] must have this annotation. If it's missing the
+ * flow will not be allowed to start and an exception will be thrown.
+ */
+@Target(CLASS)
+@MustBeDocumented
+annotation class StartableByService
\ No newline at end of file
diff --git a/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt b/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
index e03e83f92c..02410db37a 100644
--- a/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt
@@ -12,6 +12,7 @@ data class CordappImpl(
         override val contractClassNames: List<String>,
         override val initiatedFlows: List<Class<out FlowLogic<*>>>,
         override val rpcFlows: List<Class<out FlowLogic<*>>>,
+        override val serviceFlows:  List<Class<out FlowLogic<*>>>,
         override val schedulableFlows: List<Class<out FlowLogic<*>>>,
         override val services: List<Class<out SerializeAsToken>>,
         override val serializationWhitelists: List<SerializationWhitelist>,
diff --git a/core/src/main/kotlin/net/corda/core/node/AppServiceHub.kt b/core/src/main/kotlin/net/corda/core/node/AppServiceHub.kt
new file mode 100644
index 0000000000..94ab6da2e9
--- /dev/null
+++ b/core/src/main/kotlin/net/corda/core/node/AppServiceHub.kt
@@ -0,0 +1,30 @@
+package net.corda.core.node
+
+import net.corda.core.flows.FlowLogic
+import net.corda.core.messaging.FlowHandle
+import net.corda.core.messaging.FlowProgressHandle
+import rx.Observable
+
+/**
+ * A [CordaService] annotated class requires a constructor taking a
+ * single parameter of type [AppServiceHub].
+ * With the [AppServiceHub] parameter a [CordaService] is able to access to privileged operations.
+ * In particular such a [CordaService] can initiate and track flows marked with [net.corda.core.flows.StartableByService].
+ */
+interface AppServiceHub : ServiceHub {
+
+    /**
+     * Start the given flow with the given arguments. [flow] must be annotated
+     * with [net.corda.core.flows.StartableByService].
+     * TODO it is assumed here that the flow object has an appropriate classloader.
+     */
+    fun <T> startFlow(flow: FlowLogic<T>): FlowHandle<T>
+
+    /**
+     * Start the given flow with the given arguments, returning an [Observable] with a single observation of the
+     * result of running the flow. [flow] must be annotated with [net.corda.core.flows.StartableByService].
+     * TODO it is assumed here that the flow object has an appropriate classloader.
+     */
+    fun <T> startTrackedFlow(flow: FlowLogic<T>): FlowProgressHandle<T>
+
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/net/corda/core/node/services/CordaService.kt b/core/src/main/kotlin/net/corda/core/node/services/CordaService.kt
index 0e40e3acce..cdefa92037 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/CordaService.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/CordaService.kt
@@ -7,7 +7,7 @@ import kotlin.annotation.AnnotationTarget.CLASS
 
 /**
  * Annotate any class that needs to be a long-lived service within the node, such as an oracle, with this annotation.
- * Such a class needs to have a constructor with a single parameter of type [ServiceHub]. This constructor will be invoked
+ * Such a class needs to have a constructor with a single parameter of type [AppServiceHub]. This constructor will be invoked
  * during node start to initialise the service. The service hub provided can be used to get information about the node
  * that may be necessary for the service. Corda services are created as singletons within the node and are available
  * to flows via [ServiceHub.cordaService].
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index d8146ff1fe..15ed414620 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -20,9 +20,8 @@ import net.corda.core.internal.concurrent.flatMap
 import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.internal.toX509CertHolder
 import net.corda.core.internal.uncheckedCast
-import net.corda.core.messaging.CordaRPCOps
-import net.corda.core.messaging.RPCOps
-import net.corda.core.messaging.SingleMessageRecipient
+import net.corda.core.messaging.*
+import net.corda.core.node.AppServiceHub
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.ServiceHub
 import net.corda.core.node.services.*
@@ -264,6 +263,49 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         }
     }
 
+    /**
+     * This customizes the ServiceHub for each CordaService that is initiating flows
+     */
+    private class AppServiceHubImpl<T : SerializeAsToken>(val serviceHub: ServiceHubInternal): AppServiceHub, ServiceHub by serviceHub {
+        lateinit var serviceInstance: T
+        override fun <T> startTrackedFlow(flow: FlowLogic<T>): FlowProgressHandle<T> {
+            val stateMachine = startFlowChecked(flow)
+            return FlowProgressHandleImpl(
+                    id = stateMachine.id,
+                    returnValue = stateMachine.resultFuture,
+                    progress = stateMachine.logic.track()?.updates ?: Observable.empty()
+            )
+        }
+
+        override fun <T> startFlow(flow: FlowLogic<T>): FlowHandle<T> {
+            val stateMachine = startFlowChecked(flow)
+            return FlowHandleImpl(id = stateMachine.id, returnValue = stateMachine.resultFuture)
+        }
+
+        private fun <T> startFlowChecked(flow: FlowLogic<T>): FlowStateMachineImpl<T> {
+            val logicType = flow.javaClass
+            require(logicType.isAnnotationPresent(StartableByService::class.java)) { "${logicType.name} was not designed for starting by a CordaService" }
+            val currentUser = FlowInitiator.Service(serviceInstance.javaClass.name)
+            return serviceHub.startFlow(flow, currentUser)
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) return true
+            if (other !is AppServiceHubImpl<*>) return false
+
+            if (serviceHub != other.serviceHub) return false
+            if (serviceInstance != other.serviceInstance) return false
+
+            return true
+        }
+
+        override fun hashCode(): Int {
+            var result = serviceHub.hashCode()
+            result = 31 * result + serviceInstance.hashCode()
+            return result
+        }
+    }
+
     /**
      * Use this method to install your Corda services in your tests. This is automatically done by the node when it
      * starts up for all classes it finds which are annotated with [CordaService].
@@ -276,8 +318,16 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
                 val constructor = serviceClass.getDeclaredConstructor(ServiceHub::class.java, PublicKey::class.java).apply { isAccessible = true }
                 constructor.newInstance(services, myNotaryIdentity!!.owningKey)
             } else {
-                val constructor = serviceClass.getDeclaredConstructor(ServiceHub::class.java).apply { isAccessible = true }
-                constructor.newInstance(services)
+                try {
+                    val extendedServiceConstructor = serviceClass.getDeclaredConstructor(AppServiceHub::class.java).apply { isAccessible = true }
+                    val serviceContext = AppServiceHubImpl<T>(services)
+                    serviceContext.serviceInstance = extendedServiceConstructor.newInstance(serviceContext)
+                    serviceContext.serviceInstance
+                } catch (ex: NoSuchMethodException) {
+                    val constructor = serviceClass.getDeclaredConstructor(ServiceHub::class.java).apply { isAccessible = true }
+                    log.warn("${serviceClass.name} is using legacy CordaService constructor with ServiceHub parameter. Upgrade to an AppServiceHub parameter to enable updated API features.")
+                    constructor.newInstance(services)
+                }
             }
         } catch (e: InvocationTargetException) {
             throw ServiceInstantiationException(e.cause)
diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
index 1449a32fb8..e1cec24244 100644
--- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
@@ -169,6 +169,7 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
                 listOf(),
                 listOf(),
                 listOf(),
+                listOf(),
                 setOf(),
                 ContractUpgradeFlow.javaClass.protectionDomain.codeSource.location // Core JAR location
         )
@@ -180,6 +181,7 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
             CordappImpl(findContractClassNames(scanResult),
                     findInitiatedFlows(scanResult),
                     findRPCFlows(scanResult),
+                    findServiceFlows(scanResult),
                     findSchedulableFlows(scanResult),
                     findServices(scanResult),
                     findPlugins(it),
@@ -207,14 +209,18 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
                 }
     }
 
-    private fun findRPCFlows(scanResult: ScanResult): List<Class<out FlowLogic<*>>> {
-        fun Class<out FlowLogic<*>>.isUserInvokable(): Boolean {
-            return Modifier.isPublic(modifiers) && !isLocalClass && !isAnonymousClass && (!isMemberClass || Modifier.isStatic(modifiers))
-        }
+    private fun Class<out FlowLogic<*>>.isUserInvokable(): Boolean {
+        return Modifier.isPublic(modifiers) && !isLocalClass && !isAnonymousClass && (!isMemberClass || Modifier.isStatic(modifiers))
+    }
 
+    private fun findRPCFlows(scanResult: ScanResult): List<Class<out FlowLogic<*>>> {
         return scanResult.getClassesWithAnnotation(FlowLogic::class, StartableByRPC::class).filter { it.isUserInvokable() }
     }
 
+    private fun findServiceFlows(scanResult: ScanResult): List<Class<out FlowLogic<*>>> {
+        return scanResult.getClassesWithAnnotation(FlowLogic::class, StartableByService::class)
+    }
+
     private fun findSchedulableFlows(scanResult: ScanResult): List<Class<out FlowLogic<*>>> {
         return scanResult.getClassesWithAnnotation(FlowLogic::class, SchedulableFlow::class)
     }
diff --git a/node/src/main/kotlin/net/corda/node/shell/FlowWatchPrintingSubscriber.kt b/node/src/main/kotlin/net/corda/node/shell/FlowWatchPrintingSubscriber.kt
index 0c6db1a7b8..32920ffd23 100644
--- a/node/src/main/kotlin/net/corda/node/shell/FlowWatchPrintingSubscriber.kt
+++ b/node/src/main/kotlin/net/corda/node/shell/FlowWatchPrintingSubscriber.kt
@@ -111,6 +111,7 @@ class FlowWatchPrintingSubscriber(private val toStream: RenderPrintWriter) : Sub
             is FlowInitiator.Shell -> "Shell" // TODO Change when we will have more information on shell user.
             is FlowInitiator.Peer -> flowInitiator.party.name.organisation
             is FlowInitiator.RPC -> "RPC: " + flowInitiator.username
+            is FlowInitiator.Service -> "Service: " + flowInitiator.name
         }
     }
 
diff --git a/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt b/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt
new file mode 100644
index 0000000000..579b865c1f
--- /dev/null
+++ b/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt
@@ -0,0 +1,132 @@
+package net.corda.node.internal
+
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.flows.FlowInitiator
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.StartableByService
+import net.corda.core.node.AppServiceHub
+import net.corda.core.node.ServiceHub
+import net.corda.core.node.services.CordaService
+import net.corda.core.serialization.SingletonSerializeAsToken
+import net.corda.core.utilities.OpaqueBytes
+import net.corda.core.utilities.ProgressTracker
+import net.corda.finance.DOLLARS
+import net.corda.finance.flows.CashIssueFlow
+import net.corda.node.internal.cordapp.DummyRPCFlow
+import net.corda.node.services.transactions.ValidatingNotaryService
+import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.testing.DUMMY_NOTARY
+import net.corda.testing.node.MockNetwork
+import net.corda.testing.setCordappPackages
+import net.corda.testing.unsetCordappPackages
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.test.*
+
+@StartableByService
+class DummyServiceFlow : FlowLogic<FlowInitiator>() {
+    companion object {
+        object TEST_STEP : ProgressTracker.Step("Custom progress step")
+    }
+    override val progressTracker: ProgressTracker = ProgressTracker(TEST_STEP)
+
+    @Suspendable
+    override fun call(): FlowInitiator {
+        // We call a subFlow, otehrwise there is no chance to subscribe to the ProgressTracker
+        subFlow(CashIssueFlow(100.DOLLARS, OpaqueBytes.of(1), serviceHub.networkMapCache.notaryIdentities.first()))
+        progressTracker.currentStep = TEST_STEP
+        return stateMachine.flowInitiator
+    }
+}
+
+@CordaService
+class TestCordaService(val appServiceHub: AppServiceHub): SingletonSerializeAsToken() {
+    fun startServiceFlow() {
+        val handle = appServiceHub.startFlow(DummyServiceFlow())
+        val initiator = handle.returnValue.get()
+        initiator as FlowInitiator.Service
+        assertEquals(this.javaClass.name, initiator.serviceClassName)
+    }
+
+    fun startServiceFlowAndTrack() {
+        val handle = appServiceHub.startTrackedFlow(DummyServiceFlow())
+        val count = AtomicInteger(0)
+        val subscriber = handle.progress.subscribe { count.incrementAndGet() }
+        handle.returnValue.get()
+        // Simply prove some progress was made.
+        // The actual number is currently 11, but don't want to hard code an implementation detail.
+        assertTrue(count.get() > 1)
+        subscriber.unsubscribe()
+    }
+
+}
+
+@CordaService
+class TestCordaService2(val appServiceHub: AppServiceHub): SingletonSerializeAsToken() {
+    fun startInvalidRPCFlow() {
+        val handle = appServiceHub.startFlow(DummyRPCFlow())
+        handle.returnValue.get()
+    }
+
+}
+
+@CordaService
+class LegacyCordaService(val simpleServiceHub: ServiceHub): SingletonSerializeAsToken() {
+
+}
+
+class CordaServiceTest {
+    lateinit var mockNet: MockNetwork
+    lateinit var notaryNode: StartedNode<MockNetwork.MockNode>
+    lateinit var nodeA: StartedNode<MockNetwork.MockNode>
+
+    @Before
+    fun start() {
+        setCordappPackages("net.corda.node.internal","net.corda.finance")
+        mockNet = MockNetwork(threadPerNode = true)
+        notaryNode = mockNet.createNode(
+                legalName = DUMMY_NOTARY.name,
+                advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type)))
+        nodeA = mockNet.createNode(notaryNode.network.myAddress)
+        mockNet.startNodes()
+    }
+
+    @After
+    fun cleanUp() {
+        mockNet.stopNodes()
+        unsetCordappPackages()
+    }
+
+    @Test
+    fun `Can find distinct services on node`() {
+        val service = nodeA.services.cordaService(TestCordaService::class.java)
+        val service2 = nodeA.services.cordaService(TestCordaService2::class.java)
+        val legacyService = nodeA.services.cordaService(LegacyCordaService::class.java)
+        assertEquals(TestCordaService::class.java, service.javaClass)
+        assertEquals(TestCordaService2::class.java, service2.javaClass)
+        assertNotEquals(service.appServiceHub, service2.appServiceHub) // Each gets a customised AppServiceHub
+        assertEquals(LegacyCordaService::class.java, legacyService.javaClass)
+    }
+
+    @Test
+    fun `Can start StartableByService flows`() {
+        val service = nodeA.services.cordaService(TestCordaService::class.java)
+        service.startServiceFlow()
+    }
+
+    @Test
+    fun `Can't start StartableByRPC flows`() {
+        val service = nodeA.services.cordaService(TestCordaService2::class.java)
+        assertFailsWith<IllegalArgumentException> { service.startInvalidRPCFlow() }
+    }
+
+
+    @Test
+    fun `Test flow with progress tracking`() {
+        val service = nodeA.services.cordaService(TestCordaService::class.java)
+        service.startServiceFlowAndTrack()
+    }
+
+}
\ No newline at end of file
diff --git a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
index f2352d475d..c1a1b6e5b0 100644
--- a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
+++ b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
@@ -1,5 +1,6 @@
 package net.corda.node.internal.cordapp
 
+import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.flows.*
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
@@ -7,21 +8,25 @@ import java.nio.file.Paths
 
 @InitiatingFlow
 class DummyFlow : FlowLogic<Unit>() {
+    @Suspendable
     override fun call() { }
 }
 
 @InitiatedBy(DummyFlow::class)
 class LoaderTestFlow(unusedSession: FlowSession) : FlowLogic<Unit>() {
+    @Suspendable
     override fun call() { }
 }
 
 @SchedulableFlow
 class DummySchedulableFlow : FlowLogic<Unit>() {
+    @Suspendable
     override fun call() { }
 }
 
 @StartableByRPC
 class DummyRPCFlow : FlowLogic<Unit>() {
+    @Suspendable
     override fun call() { }
 }
 
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
index f51d59d20d..976d595ec6 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
@@ -14,7 +14,7 @@ class MockCordappProvider(cordappLoader: CordappLoader) : CordappProviderImpl(co
     val cordappRegistry = mutableListOf<Pair<Cordapp, AttachmentId>>()
 
     fun addMockCordapp(contractClassName: ContractClassName, services: ServiceHub) {
-        val cordapp = CordappImpl(listOf(contractClassName), emptyList(), emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), Paths.get(".").toUri().toURL())
+        val cordapp = CordappImpl(listOf(contractClassName), emptyList(), emptyList(), emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), Paths.get(".").toUri().toURL())
         if (cordappRegistry.none { it.first.contractClassNames.contains(contractClassName) }) {
             cordappRegistry.add(Pair(cordapp, findOrImportAttachment(contractClassName.toByteArray(), services)))
         }

From 82d1979b94451697f0a7b225b213f2984fe1b136 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Fri, 6 Oct 2017 11:25:32 +0100
Subject: [PATCH 099/185] Better error for driver instantiated outside package.

---
 .../src/main/kotlin/net/corda/testing/driver/Driver.kt         | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
index 8f62fa88c3..344244bfa4 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
@@ -990,7 +990,8 @@ class DriverDSL(
             return Exception()
                     .stackTrace
                     .first { it.fileName != "Driver.kt" }
-                    .let { Class.forName(it.className).`package`.name }
+                    .let { Class.forName(it.className).`package`?.name }
+                    ?: throw IllegalStateException("Function instantiating driver must be defined in a package.")
         }
     }
 }

From b5a77a7a9cd4cf82a537252535db0d554b93a2ed Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 10:29:29 +0100
Subject: [PATCH 100/185] Remove unnecessary `this` in sample code + minor
 changes to contract paragraph

---
 .../docs/tutorial/testdsl/TutorialTestDSL.kt  | 42 +++++++++----------
 docs/source/tutorial-contract.rst             |  2 +-
 docs/source/tutorial-test-dsl.rst             | 10 ++---
 3 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
index 2b25fe726e..a52961b0e0 100644
--- a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
@@ -31,7 +31,7 @@ class CommercialPaperTest {
             transaction {
                 attachments(CP_PROGRAM_ID)
                 input(CP_PROGRAM_ID) { inState }
-                this.verifies()
+                verifies()
             }
         }
     }
@@ -46,7 +46,7 @@ class CommercialPaperTest {
                 input(CP_PROGRAM_ID) { inState }
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
                 attachments(CP_PROGRAM_ID)
-                this.verifies()
+                verifies()
             }
         }
     }
@@ -61,7 +61,7 @@ class CommercialPaperTest {
                 input(CP_PROGRAM_ID) { inState }
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
                 attachments(CP_PROGRAM_ID)
-                this `fails with` "the state is propagated"
+                `fails with`("the state is propagated")
             }
         }
     }
@@ -76,9 +76,9 @@ class CommercialPaperTest {
                 input(CP_PROGRAM_ID) { inState }
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
                 attachments(CP_PROGRAM_ID)
-                this `fails with` "the state is propagated"
+                `fails with`("the state is propagated")
                 output(CP_PROGRAM_ID, "alice's paper") { inState.withOwner(ALICE) }
-                this.verifies()
+                verifies()
             }
         }
     }
@@ -95,11 +95,11 @@ class CommercialPaperTest {
                     // The wrong pubkey.
                     command(BIG_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
                     timeWindow(TEST_TX_TIME)
-                    this `fails with` "output states are issued by a command signer"
+                    `fails with`("output states are issued by a command signer")
                 }
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
                 timeWindow(TEST_TX_TIME)
-                this.verifies()
+                verifies()
             }
         }
     }
@@ -115,11 +115,11 @@ class CommercialPaperTest {
                 // The wrong pubkey.
                 command(BIG_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
                 timeWindow(TEST_TX_TIME)
-                this `fails with` "output states are issued by a command signer"
+                `fails with`("output states are issued by a command signer")
             }
             command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
             timeWindow(TEST_TX_TIME)
-            this.verifies()
+            verifies()
         }
     }
     // DOCEND 7
@@ -141,7 +141,7 @@ class CommercialPaperTest {
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
                 attachments(CP_PROGRAM_ID)
                 timeWindow(TEST_TX_TIME)
-                this.verifies()
+                verifies()
             }
 
 
@@ -152,7 +152,7 @@ class CommercialPaperTest {
                 output(CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>().withOwner(ALICE) }
                 command(ALICE_PUBKEY) { Cash.Commands.Move() }
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                this.verifies()
+                verifies()
             }
         }
     }
@@ -174,7 +174,7 @@ class CommercialPaperTest {
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
                 attachments(CP_PROGRAM_ID)
                 timeWindow(TEST_TX_TIME)
-                this.verifies()
+                verifies()
             }
 
             transaction("Trade") {
@@ -184,7 +184,7 @@ class CommercialPaperTest {
                 output(CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>().withOwner(ALICE) }
                 command(ALICE_PUBKEY) { Cash.Commands.Move() }
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                this.verifies()
+                verifies()
             }
 
             transaction {
@@ -192,10 +192,10 @@ class CommercialPaperTest {
                 // We moved a paper to another pubkey.
                 output(CP_PROGRAM_ID, "bob's paper") { "paper".output<ICommercialPaperState>().withOwner(BOB) }
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                this.verifies()
+                verifies()
             }
 
-            this.fails()
+            fails()
         }
     }
     // DOCEND 9
@@ -216,7 +216,7 @@ class CommercialPaperTest {
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Issue() }
                 attachments(CP_PROGRAM_ID)
                 timeWindow(TEST_TX_TIME)
-                this.verifies()
+                verifies()
             }
 
             transaction("Trade") {
@@ -226,7 +226,7 @@ class CommercialPaperTest {
                 output(CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>().withOwner(ALICE) }
                 command(ALICE_PUBKEY) { Cash.Commands.Move() }
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                this.verifies()
+                verifies()
             }
 
             tweak {
@@ -235,13 +235,13 @@ class CommercialPaperTest {
                     // We moved a paper to another pubkey.
                     output(CP_PROGRAM_ID, "bob's paper") { "paper".output<ICommercialPaperState>().withOwner(BOB) }
                     command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
-                    this.verifies()
+                    verifies()
                 }
-                this.fails()
+                fails()
             }
 
-            this.verifies()
+            verifies()
         }
     }
     // DOCEND 10
-}
\ No newline at end of file
+}
diff --git a/docs/source/tutorial-contract.rst b/docs/source/tutorial-contract.rst
index 8c48d33358..23c1430286 100644
--- a/docs/source/tutorial-contract.rst
+++ b/docs/source/tutorial-contract.rst
@@ -476,7 +476,7 @@ generate methods should operate on the same transaction. You can see an example
 for the commercial paper contract.
 
 The paper is given to us as a ``StateAndRef<CommercialPaper.State>`` object. This is exactly what it sounds like:
-a small object that has a (copy of) a state object, and also the (txhash, index) that indicates the location of this
+a small object that has a (copy of a) state object, and also the ``(txhash, index)`` that indicates the location of this
 state on the ledger.
 
 We add the existing paper state as an input, the same paper state with the owner field adjusted as an output,
diff --git a/docs/source/tutorial-test-dsl.rst b/docs/source/tutorial-test-dsl.rst
index b32be173c7..ce66251a5c 100644
--- a/docs/source/tutorial-test-dsl.rst
+++ b/docs/source/tutorial-test-dsl.rst
@@ -114,7 +114,7 @@ The above code however doesn't compile:
 
         Error:(35, 27) java: incompatible types: bad return type in lambda expression missing return value
 
-This is deliberate: The DSL forces us to specify either ``this.verifies()`` or ``this `fails with` "some text"`` on the
+This is deliberate: The DSL forces us to specify either ``verifies()`` or ```fails with`("some text")`` on the
 last line of ``transaction``:
 
 .. container:: codeset
@@ -160,7 +160,7 @@ When run, that code produces the following error:
         net.corda.core.contracts.TransactionVerificationException$ContractRejection: java.lang.IllegalStateException: the state is propagated
 
 The transaction verification failed, because we wanted to move paper but didn't specify an output - but the state should be propagated.
-However we can specify that this is an intended behaviour by changing ``this.verifies()`` to ``this `fails with` "the state is propagated"``:
+However we can specify that this is an intended behaviour by changing ``verifies()`` to ```fails with`("the state is propagated")``:
 
 .. container:: codeset
 
@@ -256,7 +256,7 @@ Now that we know how to define a single transaction, let's look at how to define
         :dedent: 4
 
 In this example we declare that ``ALICE`` has $900 but we don't care where from. For this we can use
-``unverifiedTransaction``. Note how we don't need to specify ``this.verifies()``.
+``unverifiedTransaction``. Note how we don't need to specify ``verifies()``.
 
 Notice that we labelled output with ``"alice's $900"``, also in transaction named ``"Issuance"``
 we labelled a commercial paper with ``"paper"``. Now we can subsequently refer to them in other transactions, e.g.
@@ -265,7 +265,7 @@ by ``input("alice's $900")`` or ``"paper".output<ICommercialPaperState>()``.
 The last transaction named ``"Trade"`` exemplifies simple fact of selling the ``CommercialPaper`` to Alice for her $900,
 $100 less than the face value at 10% interest after only 7 days.
 
-We can also test whole ledger calling ``this.verifies()`` and ``this.fails()`` on the ledger level.
+We can also test whole ledger calling ``verifies()`` and ``fails()`` on the ledger level.
 To do so let's create a simple example that uses the same input twice:
 
 .. container:: codeset
@@ -283,7 +283,7 @@ To do so let's create a simple example that uses the same input twice:
         :dedent: 4
 
 The transactions ``verifies()`` individually, however the state was spent twice! That's why we need the global ledger
-verification (``this.fails()`` at the end). As in previous examples we can use ``tweak`` to create a local copy of the whole ledger:
+verification (``fails()`` at the end). As in previous examples we can use ``tweak`` to create a local copy of the whole ledger:
 
 .. container:: codeset
 

From d9f086cf9199cf8e0691d9f611716f8a96127f4a Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Fri, 6 Oct 2017 11:53:40 +0100
Subject: [PATCH 101/185] Modify the API Scanner plugin to filter method
 annotations.

---
 .ci/api-current.txt                           | 168 +++++++++---------
 constants.properties                          |   2 +-
 .../main/java/net/corda/plugins/ScanApi.java  |  25 ++-
 3 files changed, 109 insertions(+), 86 deletions(-)

diff --git a/.ci/api-current.txt b/.ci/api-current.txt
index 6d69bc4289..86d889b83d 100644
--- a/.ci/api-current.txt
+++ b/.ci/api-current.txt
@@ -64,8 +64,8 @@ public final class net.corda.core.contracts.Amount extends java.lang.Object impl
   @org.jetbrains.annotations.NotNull public final Object component3()
   @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount copy(long, java.math.BigDecimal, Object)
   public boolean equals(Object)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object, java.math.RoundingMode)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object, java.math.RoundingMode)
   @org.jetbrains.annotations.NotNull public final java.math.BigDecimal getDisplayTokenSize()
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.math.BigDecimal getDisplayTokenSize(Object)
   public final long getQuantity()
@@ -86,8 +86,8 @@ public final class net.corda.core.contracts.Amount extends java.lang.Object impl
   public static final net.corda.core.contracts.Amount$Companion Companion
 ##
 public static final class net.corda.core.contracts.Amount$Companion extends java.lang.Object
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object, java.math.RoundingMode)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount fromDecimal(java.math.BigDecimal, Object, java.math.RoundingMode)
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final java.math.BigDecimal getDisplayTokenSize(Object)
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.Amount parseCurrency(String)
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.Nullable public final net.corda.core.contracts.Amount sumOrNull(Iterable)
@@ -100,8 +100,8 @@ public final class net.corda.core.contracts.AmountTransfer extends java.lang.Obj
   @org.jetbrains.annotations.NotNull public final List apply(List, Object)
   @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AmountTransfer copy(long, Object, Object, Object)
   public boolean equals(Object)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object, java.math.RoundingMode)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object, java.math.RoundingMode)
   @org.jetbrains.annotations.NotNull public final Object getDestination()
   public final long getQuantityDelta()
   @org.jetbrains.annotations.NotNull public final Object getSource()
@@ -115,8 +115,8 @@ public final class net.corda.core.contracts.AmountTransfer extends java.lang.Obj
   public static final net.corda.core.contracts.AmountTransfer$Companion Companion
 ##
 public static final class net.corda.core.contracts.AmountTransfer$Companion extends java.lang.Object
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object, java.math.RoundingMode)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AmountTransfer fromDecimal(java.math.BigDecimal, Object, Object, Object, java.math.RoundingMode)
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.AmountTransfer zero(Object, Object, Object)
 ##
 public interface net.corda.core.contracts.Attachment extends net.corda.core.contracts.NamedByHash
@@ -370,9 +370,9 @@ public final class net.corda.core.contracts.TransactionResolutionException exten
   @org.jetbrains.annotations.NotNull public final net.corda.core.crypto.SecureHash getHash()
 ##
 public final class net.corda.core.contracts.TransactionState extends java.lang.Object
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer, net.corda.core.contracts.AttachmentConstraint)
+  public <init>(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party)
+  public <init>(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer)
+  public <init>(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer, net.corda.core.contracts.AttachmentConstraint)
   @org.jetbrains.annotations.NotNull public final net.corda.core.contracts.ContractState component1()
   @org.jetbrains.annotations.NotNull public final String component2()
   @org.jetbrains.annotations.NotNull public final net.corda.core.identity.Party component3()
@@ -613,9 +613,9 @@ public final class net.corda.core.crypto.Crypto extends java.lang.Object
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme findSignatureScheme(java.security.PrivateKey)
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme findSignatureScheme(java.security.PublicKey)
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.crypto.SignatureScheme findSignatureScheme(org.bouncycastle.asn1.x509.AlgorithmIdentifier)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final java.security.KeyPair generateKeyPair()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.KeyPair generateKeyPair()
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.KeyPair generateKeyPair(String)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final java.security.KeyPair generateKeyPair(net.corda.core.crypto.SignatureScheme)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final java.security.KeyPair generateKeyPair(net.corda.core.crypto.SignatureScheme)
   @kotlin.jvm.JvmStatic public static final boolean isSupportedSignatureScheme(net.corda.core.crypto.SignatureScheme)
   @kotlin.jvm.JvmStatic public static final boolean isValid(java.security.PublicKey, byte[], byte[])
   @kotlin.jvm.JvmStatic public static final boolean isValid(net.corda.core.crypto.SecureHash, net.corda.core.crypto.TransactionSignature)
@@ -920,10 +920,10 @@ public final class net.corda.core.flows.CollectSignatureFlow extends net.corda.c
   @org.jetbrains.annotations.NotNull public final List getSigningKeys()
 ##
 public final class net.corda.core.flows.CollectSignaturesFlow extends net.corda.core.flows.FlowLogic
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.transactions.SignedTransaction, Collection)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.transactions.SignedTransaction, Collection, Iterable)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.transactions.SignedTransaction, Collection, Iterable, net.corda.core.utilities.ProgressTracker)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.transactions.SignedTransaction, Collection, net.corda.core.utilities.ProgressTracker)
+  public <init>(net.corda.core.transactions.SignedTransaction, Collection)
+  public <init>(net.corda.core.transactions.SignedTransaction, Collection, Iterable)
+  public <init>(net.corda.core.transactions.SignedTransaction, Collection, Iterable, net.corda.core.utilities.ProgressTracker)
+  public <init>(net.corda.core.transactions.SignedTransaction, Collection, net.corda.core.utilities.ProgressTracker)
   @co.paralleluniverse.fibers.Suspendable @org.jetbrains.annotations.NotNull public net.corda.core.transactions.SignedTransaction call()
   @org.jetbrains.annotations.Nullable public final Iterable getMyOptionalKeys()
   @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction getPartiallySignedTx()
@@ -1234,9 +1234,9 @@ public static final class net.corda.core.flows.StateMachineRunId$Companion exten
   @org.jetbrains.annotations.NotNull public final net.corda.core.flows.StateMachineRunId createRandom()
 ##
 public class net.corda.core.flows.StateReplacementException extends net.corda.core.flows.FlowException
-  @kotlin.jvm.JvmOverloads public <init>()
-  @kotlin.jvm.JvmOverloads public <init>(String)
-  @kotlin.jvm.JvmOverloads public <init>(String, Throwable)
+  public <init>()
+  public <init>(String)
+  public <init>(String, Throwable)
 ##
 public final class net.corda.core.flows.TransactionParts extends java.lang.Object
   public <init>(net.corda.core.crypto.SecureHash, List, net.corda.core.contracts.TimeWindow, net.corda.core.identity.Party)
@@ -1831,9 +1831,9 @@ public final class net.corda.core.node.services.vault.BinaryLogicalOperator exte
   public static net.corda.core.node.services.vault.BinaryLogicalOperator[] values()
 ##
 public final class net.corda.core.node.services.vault.Builder extends java.lang.Object
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression avg(reflect.Field)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression avg(reflect.Field, List)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression avg(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression avg(reflect.Field)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression avg(reflect.Field, List)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression avg(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression avg(kotlin.reflect.KProperty1, List, net.corda.core.node.services.vault.Sort$Direction)
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$Between between(Comparable, Comparable)
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression between(reflect.Field, Comparable, Comparable)
@@ -1867,13 +1867,13 @@ public final class net.corda.core.node.services.vault.Builder extends java.lang.
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression lessThanOrEqual(kotlin.reflect.KProperty1, Comparable)
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression like(reflect.Field, String)
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression like(kotlin.reflect.KProperty1, String)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression max(reflect.Field)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression max(reflect.Field, List)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression max(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression max(reflect.Field)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression max(reflect.Field, List)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression max(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression max(kotlin.reflect.KProperty1, List, net.corda.core.node.services.vault.Sort$Direction)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression min(reflect.Field)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression min(reflect.Field, List)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression min(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression min(reflect.Field)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression min(reflect.Field, List)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression min(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression min(kotlin.reflect.KProperty1, List, net.corda.core.node.services.vault.Sort$Direction)
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.ColumnPredicate$EqualityComparison notEqual(Object)
   @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression notEqual(reflect.Field, Object)
@@ -1887,9 +1887,9 @@ public final class net.corda.core.node.services.vault.Builder extends java.lang.
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression notNull(kotlin.reflect.KProperty1)
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression predicate(reflect.Field, net.corda.core.node.services.vault.ColumnPredicate)
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$ColumnPredicateExpression predicate(kotlin.reflect.KProperty1, net.corda.core.node.services.vault.ColumnPredicate)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression sum(reflect.Field)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression sum(reflect.Field, List)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression sum(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression sum(reflect.Field)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression sum(reflect.Field, List)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression sum(reflect.Field, List, net.corda.core.node.services.vault.Sort$Direction)
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression$AggregateFunctionExpression sum(kotlin.reflect.KProperty1, List, net.corda.core.node.services.vault.Sort$Direction)
   public static final net.corda.core.node.services.vault.Builder INSTANCE
 ##
@@ -2082,14 +2082,14 @@ public abstract static class net.corda.core.node.services.vault.QueryCriteria$Co
   @org.jetbrains.annotations.NotNull public Collection visit(net.corda.core.node.services.vault.IQueryCriteriaParser)
 ##
 public static final class net.corda.core.node.services.vault.QueryCriteria$FungibleAssetQueryCriteria extends net.corda.core.node.services.vault.QueryCriteria$CommonQueryCriteria
-  @kotlin.jvm.JvmOverloads public <init>()
-  @kotlin.jvm.JvmOverloads public <init>(List)
-  @kotlin.jvm.JvmOverloads public <init>(List, List)
-  @kotlin.jvm.JvmOverloads public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate)
-  @kotlin.jvm.JvmOverloads public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List)
-  @kotlin.jvm.JvmOverloads public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List, List)
-  @kotlin.jvm.JvmOverloads public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List, List, net.corda.core.node.services.Vault$StateStatus)
-  @kotlin.jvm.JvmOverloads public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List, List, net.corda.core.node.services.Vault$StateStatus, Set)
+  public <init>()
+  public <init>(List)
+  public <init>(List, List)
+  public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate)
+  public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List)
+  public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List, List)
+  public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List, List, net.corda.core.node.services.Vault$StateStatus)
+  public <init>(List, List, net.corda.core.node.services.vault.ColumnPredicate, List, List, net.corda.core.node.services.Vault$StateStatus, Set)
   @org.jetbrains.annotations.Nullable public final List component1()
   @org.jetbrains.annotations.Nullable public final List component2()
   @org.jetbrains.annotations.Nullable public final net.corda.core.node.services.vault.ColumnPredicate component3()
@@ -2111,12 +2111,12 @@ public static final class net.corda.core.node.services.vault.QueryCriteria$Fungi
   @org.jetbrains.annotations.NotNull public Collection visit(net.corda.core.node.services.vault.IQueryCriteriaParser)
 ##
 public static final class net.corda.core.node.services.vault.QueryCriteria$LinearStateQueryCriteria extends net.corda.core.node.services.vault.QueryCriteria$CommonQueryCriteria
-  @kotlin.jvm.JvmOverloads public <init>()
-  @kotlin.jvm.JvmOverloads public <init>(List)
-  @kotlin.jvm.JvmOverloads public <init>(List, List)
-  @kotlin.jvm.JvmOverloads public <init>(List, List, List)
-  @kotlin.jvm.JvmOverloads public <init>(List, List, List, net.corda.core.node.services.Vault$StateStatus)
-  @kotlin.jvm.JvmOverloads public <init>(List, List, List, net.corda.core.node.services.Vault$StateStatus, Set)
+  public <init>()
+  public <init>(List)
+  public <init>(List, List)
+  public <init>(List, List, List)
+  public <init>(List, List, List, net.corda.core.node.services.Vault$StateStatus)
+  public <init>(List, List, List, net.corda.core.node.services.Vault$StateStatus, Set)
   public <init>(List, List, net.corda.core.node.services.Vault$StateStatus, Set)
   @org.jetbrains.annotations.Nullable public final List component1()
   @org.jetbrains.annotations.Nullable public final List component2()
@@ -2167,9 +2167,9 @@ public static final class net.corda.core.node.services.vault.QueryCriteria$TimeI
   public static net.corda.core.node.services.vault.QueryCriteria$TimeInstantType[] values()
 ##
 public static final class net.corda.core.node.services.vault.QueryCriteria$VaultCustomQueryCriteria extends net.corda.core.node.services.vault.QueryCriteria$CommonQueryCriteria
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.vault.CriteriaExpression)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.vault.CriteriaExpression, net.corda.core.node.services.Vault$StateStatus)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.vault.CriteriaExpression, net.corda.core.node.services.Vault$StateStatus, Set)
+  public <init>(net.corda.core.node.services.vault.CriteriaExpression)
+  public <init>(net.corda.core.node.services.vault.CriteriaExpression, net.corda.core.node.services.Vault$StateStatus)
+  public <init>(net.corda.core.node.services.vault.CriteriaExpression, net.corda.core.node.services.Vault$StateStatus, Set)
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.vault.CriteriaExpression component1()
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$StateStatus component2()
   @org.jetbrains.annotations.Nullable public final Set component3()
@@ -2183,13 +2183,13 @@ public static final class net.corda.core.node.services.vault.QueryCriteria$Vault
   @org.jetbrains.annotations.NotNull public Collection visit(net.corda.core.node.services.vault.IQueryCriteriaParser)
 ##
 public static final class net.corda.core.node.services.vault.QueryCriteria$VaultQueryCriteria extends net.corda.core.node.services.vault.QueryCriteria$CommonQueryCriteria
-  @kotlin.jvm.JvmOverloads public <init>()
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus, Set)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List, List)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List, List, net.corda.core.node.services.vault.QueryCriteria$SoftLockingCondition)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List, List, net.corda.core.node.services.vault.QueryCriteria$SoftLockingCondition, net.corda.core.node.services.vault.QueryCriteria$TimeCondition)
+  public <init>()
+  public <init>(net.corda.core.node.services.Vault$StateStatus)
+  public <init>(net.corda.core.node.services.Vault$StateStatus, Set)
+  public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List)
+  public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List, List)
+  public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List, List, net.corda.core.node.services.vault.QueryCriteria$SoftLockingCondition)
+  public <init>(net.corda.core.node.services.Vault$StateStatus, Set, List, List, net.corda.core.node.services.vault.QueryCriteria$SoftLockingCondition, net.corda.core.node.services.vault.QueryCriteria$TimeCondition)
   @org.jetbrains.annotations.NotNull public final net.corda.core.node.services.Vault$StateStatus component1()
   @org.jetbrains.annotations.Nullable public final Set component2()
   @org.jetbrains.annotations.Nullable public final List component3()
@@ -2697,11 +2697,11 @@ public final class net.corda.core.transactions.SignedTransaction extends java.la
   @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction plus(Collection)
   @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction plus(net.corda.core.crypto.TransactionSignature)
   @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.NotaryChangeLedgerTransaction resolveNotaryChangeTransaction(net.corda.core.node.ServiceHub)
-  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.LedgerTransaction toLedgerTransaction(net.corda.core.node.ServiceHub)
-  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.LedgerTransaction toLedgerTransaction(net.corda.core.node.ServiceHub, boolean)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.LedgerTransaction toLedgerTransaction(net.corda.core.node.ServiceHub)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.LedgerTransaction toLedgerTransaction(net.corda.core.node.ServiceHub, boolean)
   @org.jetbrains.annotations.NotNull public String toString()
-  @kotlin.jvm.JvmOverloads public final void verify(net.corda.core.node.ServiceHub)
-  @kotlin.jvm.JvmOverloads public final void verify(net.corda.core.node.ServiceHub, boolean)
+  public final void verify(net.corda.core.node.ServiceHub)
+  public final void verify(net.corda.core.node.ServiceHub, boolean)
   public void verifyRequiredSignatures()
   @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction withAdditionalSignature(java.security.KeyPair, net.corda.core.crypto.SignatureMetadata)
   @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.SignedTransaction withAdditionalSignature(net.corda.core.crypto.TransactionSignature)
@@ -2728,12 +2728,12 @@ public class net.corda.core.transactions.TransactionBuilder extends java.lang.Ob
   @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addCommand(net.corda.core.contracts.Command)
   @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addCommand(net.corda.core.contracts.CommandData, List)
   @org.jetbrains.annotations.NotNull public net.corda.core.transactions.TransactionBuilder addInputState(net.corda.core.contracts.StateAndRef)
-  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String)
-  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.contracts.AttachmentConstraint)
-  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party)
-  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer)
-  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer, net.corda.core.contracts.AttachmentConstraint)
-  @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.TransactionState)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.contracts.AttachmentConstraint)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.ContractState, String, net.corda.core.identity.Party, Integer, net.corda.core.contracts.AttachmentConstraint)
+  @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder addOutputState(net.corda.core.contracts.TransactionState)
   @org.jetbrains.annotations.NotNull public final List attachments()
   @org.jetbrains.annotations.NotNull public final List commands()
   @org.jetbrains.annotations.NotNull public final net.corda.core.transactions.TransactionBuilder copy()
@@ -2810,9 +2810,9 @@ public abstract class net.corda.core.utilities.ByteSequence extends java.lang.Ob
   public abstract int getOffset()
   public abstract int getSize()
   public int hashCode()
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ByteSequence of(byte[])
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ByteSequence of(byte[], int)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ByteSequence of(byte[], int, int)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ByteSequence of(byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ByteSequence of(byte[], int)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final net.corda.core.utilities.ByteSequence of(byte[], int, int)
   @org.jetbrains.annotations.NotNull public final java.io.ByteArrayInputStream open()
   @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence subSequence(int, int)
   @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence take(int)
@@ -2820,9 +2820,9 @@ public abstract class net.corda.core.utilities.ByteSequence extends java.lang.Ob
   public static final net.corda.core.utilities.ByteSequence$Companion Companion
 ##
 public static final class net.corda.core.utilities.ByteSequence$Companion extends java.lang.Object
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence of(byte[])
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence of(byte[], int)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence of(byte[], int, int)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence of(byte[])
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence of(byte[], int)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public final net.corda.core.utilities.ByteSequence of(byte[], int, int)
 ##
 public final class net.corda.core.utilities.EncodingUtils extends java.lang.Object
   @org.jetbrains.annotations.NotNull public static final byte[] base58ToByteArray(String)
@@ -3048,14 +3048,14 @@ public interface net.corda.core.utilities.VariablePropertyDelegate extends net.c
   public abstract void setValue(Object, kotlin.reflect.KProperty, Object)
 ##
 public final class net.corda.client.jackson.JacksonSupport extends java.lang.Object
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createDefaultMapper(net.corda.core.messaging.CordaRPCOps)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createDefaultMapper(net.corda.core.messaging.CordaRPCOps, com.fasterxml.jackson.core.JsonFactory)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createDefaultMapper(net.corda.core.messaging.CordaRPCOps, com.fasterxml.jackson.core.JsonFactory, boolean)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createInMemoryMapper(net.corda.core.node.services.IdentityService)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createInMemoryMapper(net.corda.core.node.services.IdentityService, com.fasterxml.jackson.core.JsonFactory)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createInMemoryMapper(net.corda.core.node.services.IdentityService, com.fasterxml.jackson.core.JsonFactory, boolean)
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createNonRpcMapper()
-  @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createNonRpcMapper(com.fasterxml.jackson.core.JsonFactory)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createDefaultMapper(net.corda.core.messaging.CordaRPCOps)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createDefaultMapper(net.corda.core.messaging.CordaRPCOps, com.fasterxml.jackson.core.JsonFactory)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createDefaultMapper(net.corda.core.messaging.CordaRPCOps, com.fasterxml.jackson.core.JsonFactory, boolean)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createInMemoryMapper(net.corda.core.node.services.IdentityService)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createInMemoryMapper(net.corda.core.node.services.IdentityService, com.fasterxml.jackson.core.JsonFactory)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createInMemoryMapper(net.corda.core.node.services.IdentityService, com.fasterxml.jackson.core.JsonFactory, boolean)
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createNonRpcMapper()
+  @kotlin.jvm.JvmStatic @org.jetbrains.annotations.NotNull public static final com.fasterxml.jackson.databind.ObjectMapper createNonRpcMapper(com.fasterxml.jackson.core.JsonFactory)
   @org.jetbrains.annotations.NotNull public final com.fasterxml.jackson.databind.Module getCordaModule()
   public static final net.corda.client.jackson.JacksonSupport INSTANCE
 ##
@@ -3174,8 +3174,8 @@ public abstract static class net.corda.client.jackson.JacksonSupport$WireTransac
   @com.fasterxml.jackson.annotation.JsonIgnore @org.jetbrains.annotations.NotNull public abstract List getOutputStates()
 ##
 public class net.corda.client.jackson.StringToMethodCallParser extends java.lang.Object
-  @kotlin.jvm.JvmOverloads public <init>(Class)
-  @kotlin.jvm.JvmOverloads public <init>(Class, com.fasterxml.jackson.databind.ObjectMapper)
+  public <init>(Class)
+  public <init>(Class, com.fasterxml.jackson.databind.ObjectMapper)
   public <init>(kotlin.reflect.KClass)
   @org.jetbrains.annotations.NotNull public final Map getAvailableCommands()
   @org.jetbrains.annotations.NotNull protected final com.google.common.collect.Multimap getMethodMap()
@@ -3216,8 +3216,8 @@ public static final class net.corda.client.jackson.StringToMethodCallParser$Unpa
   @org.jetbrains.annotations.NotNull public final String getMethodName()
 ##
 public final class net.corda.client.rpc.CordaRPCClient extends java.lang.Object
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.utilities.NetworkHostAndPort)
-  @kotlin.jvm.JvmOverloads public <init>(net.corda.core.utilities.NetworkHostAndPort, net.corda.client.rpc.CordaRPCClientConfiguration)
+  public <init>(net.corda.core.utilities.NetworkHostAndPort)
+  public <init>(net.corda.core.utilities.NetworkHostAndPort, net.corda.client.rpc.CordaRPCClientConfiguration)
   @org.jetbrains.annotations.NotNull public final net.corda.client.rpc.CordaRPCConnection start(String, String)
   public final Object use(String, String, kotlin.jvm.functions.Function1)
 ##
diff --git a/constants.properties b/constants.properties
index 286d4dbc1c..1965e53715 100644
--- a/constants.properties
+++ b/constants.properties
@@ -1,4 +1,4 @@
-gradlePluginsVersion=1.1.0
+gradlePluginsVersion=1.1.1
 kotlinVersion=1.1.50
 guavaVersion=21.0
 bouncycastleVersion=1.57
diff --git a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
index 53f7ee9fc0..6e10ec1fe3 100644
--- a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
+++ b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
@@ -36,6 +36,13 @@ public class ScanApi extends DefaultTask {
     private static final int FIELD_MASK = Modifier.fieldModifiers();
     private static final int VISIBILITY_MASK = Modifier.PUBLIC | Modifier.PROTECTED;
 
+    private static final Set<String> ANNOTATION_BLACKLIST;
+    static {
+       Set<String> blacklist = new LinkedHashSet<>();
+       blacklist.add("kotlin.jvm.JvmOverloads");
+       ANNOTATION_BLACKLIST = unmodifiableSet(blacklist);
+    }
+
     /**
      * This information has been lifted from:
      * @link <a href="https://github.com/JetBrains/kotlin/blob/master/core/runtime.jvm/src/kotlin/Metadata.kt">Metadata.kt</a>
@@ -251,7 +258,7 @@ public class ScanApi extends DefaultTask {
                 if (isVisible(method.getAccessFlags()) // Only public and protected methods
                         && isValid(method.getAccessFlags(), METHOD_MASK) // Excludes bridge and synthetic methods
                         && !isKotlinInternalScope(method)) {
-                    writer.append("  ").println(method);
+                    writer.append("  ").println(filterAnnotationsFor(method));
                 }
             }
         }
@@ -278,6 +285,22 @@ public class ScanApi extends DefaultTask {
             }
             return 0;
         }
+
+        private String filterAnnotationsFor(MethodInfo method) {
+            return new MethodInfo(
+                method.getClassName(),
+                method.getMethodName(),
+                method.getAccessFlags(),
+                method.getTypeDescriptor(),
+                method.getAnnotationNames().stream()
+                    .filter(ScanApi::isVisibleAnnotation)
+                    .collect(toList())
+            ).toString();
+        }
+    }
+
+    private static boolean isVisibleAnnotation(String annotationName) {
+        return !ANNOTATION_BLACKLIST.contains(annotationName);
     }
 
     private static boolean isKotlinInternalScope(MethodInfo method) {

From 3f6ce3c861063c9755c4d40c023290b5466079fe Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Fri, 6 Oct 2017 14:33:24 +0100
Subject: [PATCH 102/185] Removes broken link.

---
 docs/source/flow-testing.rst | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/docs/source/flow-testing.rst b/docs/source/flow-testing.rst
index 939da0769e..967dbe9877 100644
--- a/docs/source/flow-testing.rst
+++ b/docs/source/flow-testing.rst
@@ -63,8 +63,4 @@ transaction as shown here.
 
 With regards to initiated flows (see :doc:`flow-state-machines` for information on initiated and initiating flows), the
 full node automatically registers them by scanning the CorDapp jars. In a unit test environment this is not possible so
-``MockNode`` has the ``registerInitiatedFlow`` method to manually register an initiated flow.
-
-And that's it: you can explore the documentation for the
-`MockNetwork API <api/kotlin/corda/net.corda.testing.node/-mock-network/index.html>`_
-here.
+``MockNode`` has the ``registerInitiatedFlow`` method to manually register an initiated flow.
\ No newline at end of file

From 3afe85504216f24348e4330be57dfe73bbd19124 Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Fri, 6 Oct 2017 14:50:54 +0100
Subject: [PATCH 103/185] Update to match MockNetwork API change (#1831)

---
 .../src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt b/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt
index 579b865c1f..bbe685017a 100644
--- a/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt
@@ -89,7 +89,7 @@ class CordaServiceTest {
         notaryNode = mockNet.createNode(
                 legalName = DUMMY_NOTARY.name,
                 advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type)))
-        nodeA = mockNet.createNode(notaryNode.network.myAddress)
+        nodeA = mockNet.createNode()
         mockNet.startNodes()
     }
 

From d761d52c16520bd1131cf692f423ed9fa88d5c48 Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Fri, 6 Oct 2017 14:55:30 +0100
Subject: [PATCH 104/185] Fix filterAnnotationsFor() to return MethodInfo.

---
 .../api-scanner/src/main/java/net/corda/plugins/ScanApi.java  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
index 6e10ec1fe3..f0220add42 100644
--- a/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
+++ b/gradle-plugins/api-scanner/src/main/java/net/corda/plugins/ScanApi.java
@@ -286,7 +286,7 @@ public class ScanApi extends DefaultTask {
             return 0;
         }
 
-        private String filterAnnotationsFor(MethodInfo method) {
+        private MethodInfo filterAnnotationsFor(MethodInfo method) {
             return new MethodInfo(
                 method.getClassName(),
                 method.getMethodName(),
@@ -295,7 +295,7 @@ public class ScanApi extends DefaultTask {
                 method.getAnnotationNames().stream()
                     .filter(ScanApi::isVisibleAnnotation)
                     .collect(toList())
-            ).toString();
+            );
         }
     }
 

From 6562579e8e9ae362ab458e02c9e1f63b570472e6 Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Fri, 6 Oct 2017 15:23:20 +0100
Subject: [PATCH 105/185] Extend NetworkMapCache API (#1766)

* Add functions to:
** Return PartyAndCertificate rather than just Party
** Return all NodeInfo entries for a name (rather than just by key)
* General documentation improvements
---
 .../core/node/services/IdentityService.kt     | 31 ++++++++++-------
 .../core/node/services/NetworkMapCache.kt     | 33 ++++++++++++++-----
 .../network/PersistentNetworkMapCache.kt      | 19 ++++++++++-
 .../services/network/NetworkMapCacheTest.kt   | 12 +++++++
 4 files changed, 74 insertions(+), 21 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/node/services/IdentityService.kt b/core/src/main/kotlin/net/corda/core/node/services/IdentityService.kt
index 645afb5550..489e316e01 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/IdentityService.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/IdentityService.kt
@@ -10,7 +10,11 @@ import java.security.cert.*
 /**
  * An identity service maintains a directory of parties by their associated distinguished name/public keys and thus
  * supports lookup of a party given its key, or name. The service also manages the certificates linking confidential
- * identities back to the well known identity (i.e. the identity in the network map) of a party.
+ * identities back to the well known identity.
+ *
+ * Well known identities in Corda are the public identity of a party, registered with the network map directory,
+ * whereas confidential identities are distributed only on a need to know basis (typically between parties in
+ * a transaction being built). See [NetworkMapCache] for retrieving well known identities from the network map.
  */
 interface IdentityService {
     val trustRoot: X509Certificate
@@ -43,8 +47,9 @@ interface IdentityService {
     fun getAllIdentities(): Iterable<PartyAndCertificate>
 
     /**
-     * Get the certificate and path for a known identity's owning key.
+     * Resolves a public key to the well known identity [PartyAndCertificate] instance which is owned by the key.
      *
+     * @param owningKey The [PublicKey] to determine well known identity for.
      * @return the party and certificate, or null if unknown.
      */
     fun certificateFromKey(owningKey: PublicKey): PartyAndCertificate?
@@ -59,17 +64,18 @@ interface IdentityService {
     fun partyFromKey(key: PublicKey): Party?
 
     /**
-     * Resolves a party name to the well known identity [Party] instance for this name.
-     * @param name The [CordaX500Name] to search for.
+     * Resolves a party name to the well known identity [Party] instance for this name. Where possible well known identity
+     * lookup from name should be done from the network map (via [NetworkMapCache]) instead, as it is the authoritative
+     * source of well known identities.
+     *
+     * @param name The [CordaX500Name] to determine well known identity for.
      * @return If known the canonical [Party] with that name, else null.
      */
     fun wellKnownPartyFromX500Name(name: CordaX500Name): Party?
 
     /**
-     * Returns the well known identity from an [AbstractParty]. This is intended to resolve the well known identity,
-     * as visible in the [NetworkMapCache] from a confidential identity.
-     * It transparently handles returning the well known identity back if
-     * a well known identity is passed in.
+     * Resolves a (optionally) confidential identity to the corresponding well known identity [Party].
+     * It transparently handles returning the well known identity back if a well known identity is passed in.
      *
      * @param party identity to determine well known identity for.
      * @return well known identity, if found.
@@ -77,11 +83,12 @@ interface IdentityService {
     fun wellKnownPartyFromAnonymous(party: AbstractParty): Party?
 
     /**
-     * Returns the well known identity from a PartyAndReference. This is intended to resolve the well known identity,
-     * as visible in the [NetworkMapCache] from a confidential identity.
-     * It transparently handles returning the well known identity back if
-     * a well known identity is passed in.
+     * Resolves a (optionally) confidential identity to the corresponding well known identity [Party].
+     * Convenience method which unwraps the [Party] from the [PartyAndReference] and then resolves the
+     * well known identity as normal.
+     * It transparently handles returning the well known identity back if a well known identity is passed in.
      *
+     * @param partyRef identity (and reference, which is unused) to determine well known identity for.
      * @return the well known identity, or null if unknown.
      */
     fun wellKnownPartyFromAnonymous(partyRef: PartyAndReference) = wellKnownPartyFromAnonymous(partyRef.party)
diff --git a/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt b/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
index 2bb1dc0bb4..8217eb69b4 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
@@ -4,6 +4,7 @@ import net.corda.core.concurrent.CordaFuture
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
+import net.corda.core.identity.PartyAndCertificate
 import net.corda.core.messaging.DataFeed
 import net.corda.core.node.NodeInfo
 import net.corda.core.serialization.CordaSerializable
@@ -72,26 +73,42 @@ interface NetworkMapCache {
     /** Look up the node info for a host and port. */
     fun getNodeByAddress(address: NetworkHostAndPort): NodeInfo?
 
-    fun getPeerByLegalName(name: CordaX500Name): Party? = getNodeByLegalName(name)?.let {
-        it.legalIdentitiesAndCerts.singleOrNull { it.name == name }?.party
-    }
+    /**
+     * Look up a well known identity (including certificate path) of a legal name. This should be used in preference
+     * to well known identity lookup in the identity service where possible, as the network map is the authoritative
+     * source of well known identities.
+     */
+    fun getPeerCertificateByLegalName(name: CordaX500Name): PartyAndCertificate?
+
+    /**
+     * Look up the well known identity of a legal name. This should be used in preference
+     * to well known identity lookup in the identity service where possible, as the network map is the authoritative
+     * source of well known identities.
+     */
+    fun getPeerByLegalName(name: CordaX500Name): Party? = getPeerCertificateByLegalName(name)?.party
 
     /** Return all [NodeInfo]s the node currently is aware of (including ourselves). */
     val allNodes: List<NodeInfo>
 
     /**
-     * Look up the node infos for a specific peer key.
-     * In general, nodes can advertise multiple identities: a legal identity, and separate identities for each of
-     * the services it provides. In case of a distributed service – run by multiple nodes – each participant advertises
-     * the identity of the *whole group*.
+     * Look up the node information entries for a specific identity key.
+     * Note that normally there will be only one node for a key, but for clusters of nodes or distributed services there
+     * can be multiple nodes.
      */
     fun getNodesByLegalIdentityKey(identityKey: PublicKey): List<NodeInfo>
 
+    /**
+     * Look up the node information entries for a legal name.
+     * Note that normally there will be only one node for a legal name, but for clusters of nodes or distributed services there
+     * can be multiple nodes.
+     */
+    fun getNodesByLegalName(name: CordaX500Name): List<NodeInfo>
+
     /** Returns information about the party, which may be a specific node or a service */
     fun getPartyInfo(party: Party): PartyInfo?
 
     // DOCSTART 2
-    /** Gets a notary identity by the given name. */
+    /** Look up a well known identity of notary by legal name. */
     fun getNotary(name: CordaX500Name): Party? = notaryIdentities.firstOrNull { it.name == name }
     // DOCEND 2
 
diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
index b2fb8c3bde..8b27a9a396 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
@@ -4,6 +4,7 @@ import net.corda.core.concurrent.CordaFuture
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
+import net.corda.core.identity.PartyAndCertificate
 import net.corda.core.internal.VisibleForTesting
 import net.corda.core.internal.bufferUntilSubscribed
 import net.corda.core.internal.concurrent.map
@@ -114,7 +115,8 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
         return null
     }
 
-    override fun getNodeByLegalName(name: CordaX500Name): NodeInfo? = serviceHub.database.transaction { queryByLegalName(name).firstOrNull() }
+    override fun getNodeByLegalName(name: CordaX500Name): NodeInfo? = getNodesByLegalName(name).firstOrNull()
+    override fun getNodesByLegalName(name: CordaX500Name): List<NodeInfo> = serviceHub.database.transaction { queryByLegalName(name) }
     override fun getNodesByLegalIdentityKey(identityKey: PublicKey): List<NodeInfo> =
             serviceHub.database.transaction { queryByIdentityKey(identityKey) }
     override fun getNodeByLegalIdentity(party: AbstractParty): NodeInfo? {
@@ -126,6 +128,8 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
 
     override fun getNodeByAddress(address: NetworkHostAndPort): NodeInfo? = serviceHub.database.transaction { queryByAddress(address) }
 
+    override fun getPeerCertificateByLegalName(name: CordaX500Name): PartyAndCertificate? = serviceHub.database.transaction { queryIdentityByLegalName(name) }
+
     override fun track(): DataFeed<List<NodeInfo>, MapChange> {
         synchronized(_changed) {
             return DataFeed(partyNodes, _changed.bufferUntilSubscribed().wrapWithDatabaseTransaction())
@@ -329,6 +333,19 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
         }
     }
 
+    private fun queryIdentityByLegalName(name: CordaX500Name): PartyAndCertificate? {
+        createSession {
+            val query = it.createQuery(
+                    // We do the JOIN here to restrict results to those present in the network map
+                    "SELECT DISTINCT l FROM ${NodeInfoSchemaV1.PersistentNodeInfo::class.java.name} n JOIN n.legalIdentitiesAndCerts l WHERE l.name = :name",
+                    NodeInfoSchemaV1.DBPartyAndCertificate::class.java)
+            query.setParameter("name", name.toString())
+            val candidates = query.resultList.map { it.toLegalIdentityAndCert() }
+            // The map is restricted to holding a single identity for any X.500 name, so firstOrNull() is correct here.
+            return candidates.firstOrNull()
+        }
+    }
+
     private fun queryByLegalName(name: CordaX500Name): List<NodeInfo> {
         createSession {
             val query = it.createQuery(
diff --git a/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt b/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
index d097f8d614..10aa2c62ac 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
@@ -65,6 +65,18 @@ class NetworkMapCacheTest {
         // TODO: Should have a test case with anonymous lookup
     }
 
+    @Test
+    fun `getPeerByLegalName`() {
+        val notaryNode = mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val notaryCache: NetworkMapCache = notaryNode.services.networkMapCache
+        val expected = aliceNode.info.legalIdentities.single()
+
+        mockNet.runNetwork()
+        val actual = notaryNode.database.transaction { notaryCache.getPeerByLegalName(ALICE.name) }
+        assertEquals(expected, actual)
+    }
+
     @Test
     fun `remove node from cache`() {
         val notaryNode = mockNet.createNotaryNode()

From 0b35a99c5a6c0498e577fc1bfbb16bf3a84c0473 Mon Sep 17 00:00:00 2001
From: Michele Sollecito <michele.sollecito@gmail.com>
Date: Fri, 6 Oct 2017 15:37:33 +0100
Subject: [PATCH 106/185] [CORDA-682]: Claim Jigsaw module names (#1824)

[CORDA-682] Specify Jigsaw module names for all JAR projects.
---
 build.gradle                             |  4 +-
 client/jackson/build.gradle              |  3 +
 client/jfx/build.gradle                  |  3 +
 client/mock/build.gradle                 |  3 +
 client/rpc/build.gradle                  |  3 +
 docs/source/api-index.rst                | 64 ----------------
 docs/source/building-a-cordapp-index.rst |  1 -
 docs/source/corda-modules.rst            | 93 ++++++++++++++++++++++++
 docs/source/getting-set-up.rst           |  2 +-
 docs/source/other-index.rst              |  1 +
 docs/source/release-notes.rst            |  2 +-
 experimental/sandbox/build.gradle        |  5 +-
 samples/attachment-demo/build.gradle     |  8 ++
 samples/bank-of-corda-demo/build.gradle  |  8 ++
 samples/irs-demo/build.gradle            |  5 ++
 samples/network-visualiser/build.gradle  |  8 ++
 samples/notary-demo/build.gradle         |  8 ++
 samples/simm-valuation-demo/build.gradle |  8 ++
 samples/trader-demo/build.gradle         |  8 ++
 tools/demobench/build.gradle             |  3 +-
 tools/explorer/build.gradle              |  8 ++
 tools/graphs/build.gradle                |  8 ++
 tools/loadtest/build.gradle              |  8 ++
 23 files changed, 194 insertions(+), 70 deletions(-)
 delete mode 100644 docs/source/api-index.rst
 create mode 100644 docs/source/corda-modules.rst

diff --git a/build.gradle b/build.gradle
index acee113b33..6cfd34fed9 100644
--- a/build.gradle
+++ b/build.gradle
@@ -116,12 +116,14 @@ allprojects {
         }
     }
 
-    tasks.withType(Jar) { // Includes War and Ear
+    tasks.withType(Jar) { task ->
+        // Includes War and Ear
         manifest {
             attributes('Corda-Release-Version': corda_release_version)
             attributes('Corda-Platform-Version': corda_platform_version)
             attributes('Corda-Revision': corda_revision)
             attributes('Corda-Vendor': 'Corda Open Source')
+            attributes('Automatic-Module-Name': "net.corda.${task.project.name.replaceAll('-', '.')}")
         }
     }
 
diff --git a/client/jackson/build.gradle b/client/jackson/build.gradle
index bcff947dfb..fadfdf9975 100644
--- a/client/jackson/build.gradle
+++ b/client/jackson/build.gradle
@@ -25,6 +25,9 @@ dependencies {
 
 jar {
     baseName 'corda-jackson'
+    manifest {
+        attributes 'Automatic-Module-Name': 'net.corda.client.jackson'
+    }
 }
 
 publish {
diff --git a/client/jfx/build.gradle b/client/jfx/build.gradle
index 867ba2b9f0..aaf1d5fd14 100644
--- a/client/jfx/build.gradle
+++ b/client/jfx/build.gradle
@@ -57,6 +57,9 @@ task integrationTest(type: Test) {
 
 jar {
     baseName 'corda-jfx'
+    manifest {
+        attributes 'Automatic-Module-Name': 'net.corda.client.jfx'
+    }
 }
 
 publish {
diff --git a/client/mock/build.gradle b/client/mock/build.gradle
index 1080cf9b7a..b492455b49 100644
--- a/client/mock/build.gradle
+++ b/client/mock/build.gradle
@@ -21,6 +21,9 @@ dependencies {
 
 jar {
     baseName 'corda-mock'
+    manifest {
+        attributes 'Automatic-Module-Name': 'net.corda.client.mock'
+    }
 }
 
 publish {
diff --git a/client/rpc/build.gradle b/client/rpc/build.gradle
index d8c61b4a99..bd234e8ee1 100644
--- a/client/rpc/build.gradle
+++ b/client/rpc/build.gradle
@@ -90,6 +90,9 @@ task smokeTest(type: Test) {
 
 jar {
     baseName 'corda-rpc'
+    manifest {
+        attributes 'Automatic-Module-Name': 'net.corda.client.rpc'
+    }
 }
 
 publish {
diff --git a/docs/source/api-index.rst b/docs/source/api-index.rst
deleted file mode 100644
index c3486e4cea..0000000000
--- a/docs/source/api-index.rst
+++ /dev/null
@@ -1,64 +0,0 @@
-API
-===
-
-This section describes the APIs that are available for the development of CorDapps:
-
-.. toctree::
-   :maxdepth: 1
-
-   api-states
-   api-persistence
-   api-contracts
-   api-vault-query
-   api-transactions
-   api-flows
-   api-identity
-   api-service-hub
-   api-rpc
-   api-core-types
-
-Before reading this page, you should be familiar with the :doc:`key concepts of Corda <key-concepts>`.
-
-Internal APIs and stability guarantees
---------------------------------------
-
-.. warning:: For Corda 1.0 we do not currently provide a stable wire protocol or support for database upgrades.
-   Additionally, the JSON format produced by the client-jackson module may change in future.
-   Therefore, you should not expect to be able to migrate persisted data from 1.0 to future versions.
-
-   Additionally, it may be necessary to recompile applications against future versions of the API until we begin offering
-   ABI stability as well. We plan to do this soon after the release of Corda 1.0.
-
-   Finally, please note that the 1.0 release has not yet been security audited. You should not run it in situations
-   where security is required.
-
-As of Corda 1.0, the following modules export public API that we promise to maintain backwards compatibility for,
-unless an incompatible change is required for security reasons:
-
-* core
-* client-rpc
-* client-jackson
-
-The following modules don't yet have a completely stable API, but we will do our best to minimise disruption to
-developers using them until we are able to graduate them into the public API:
-
-* the Gradle plugins (cordformation)
-* node-driver
-* confidential-identities
-* test-utils
-* client-jfx, client-mock
-* finance
-* anything under the experimental directory (sub-components here may never graduate)
-
-We hope to graduate the node-driver, test-utils and confidential-identities modules in the next feature release
-after 1.0. The bulk of the Corda API is found in the core module. Other modules should be assumed to be fully internal.
-
-The web server module will be removed in future: you should build web front-ends for CorDapps using standard frameworks
-like Spring Boot, J2EE, Play, etc.
-
-Code that falls into the following packages namespaces are for internal use only and not for public use:
-
-* Any package in the ``net.corda`` namespace which contains ``.internal``
-* ``net.corda.node``
-
-In the future releases the node upon starting up will reject any CorDapps which uses classes from these packages.
\ No newline at end of file
diff --git a/docs/source/building-a-cordapp-index.rst b/docs/source/building-a-cordapp-index.rst
index e073aef623..12466338ee 100644
--- a/docs/source/building-a-cordapp-index.rst
+++ b/docs/source/building-a-cordapp-index.rst
@@ -7,6 +7,5 @@ Building a CorDapp
    cordapp-overview
    writing-cordapps
    cordapp-build-systems
-   api-index
    flow-cookbook
    cheat-sheet
\ No newline at end of file
diff --git a/docs/source/corda-modules.rst b/docs/source/corda-modules.rst
new file mode 100644
index 0000000000..0307db092c
--- /dev/null
+++ b/docs/source/corda-modules.rst
@@ -0,0 +1,93 @@
+Corda modules
+=============
+
+This section describes the APIs that are available for the development of CorDapps:
+
+.. toctree::
+   :maxdepth: 1
+
+   api-states
+   api-persistence
+   api-contracts
+   api-vault-query
+   api-transactions
+   api-flows
+   api-identity
+   api-service-hub
+   api-rpc
+   api-core-types
+
+Before reading this page, you should be familiar with the :doc:`key concepts of Corda <key-concepts>`.
+
+Internal APIs and stability guarantees
+--------------------------------------
+
+.. warning:: For Corda 1.0 we do not currently provide a stable wire protocol or support for database upgrades.
+   Additionally, the JSON format produced by the client-jackson module may change in future.
+   Therefore, you should not expect to be able to migrate persisted data from 1.0 to future versions.
+
+   Additionally, it may be necessary to recompile applications against future versions of the API until we begin offering
+   ABI stability as well. We plan to do this soon after the release of Corda 1.0.
+
+   Finally, please note that the 1.0 release has not yet been security audited. You should not run it in situations
+   where security is required.
+
+Corda artifacts can be required from Java 9 Jigsaw modules.
+From within a ``module-info.java``, you can reference one of the modules e.g., ``requires net.corda.core;``.
+
+.. warning:: while Corda artifacts can be required from ``module-info.java`` files, they are still not proper Jigsaw modules,
+   because they rely on the automatic module mechanism and declare no module descriptors themselves. We plan to integrate Jigsaw more thoroughly in the future.
+
+Corda stable modules
+--------------------
+
+The following modules have a stable API we commit not to break in following releases, unless an incompatible change is required for security reasons:
+
+* **Core (net.corda.core)**: core Corda libraries such as crypto functions, types for Corda's building blocks: states, contracts, transactions, attachments, etc. and some interfaces for nodes and protocols
+* **Client RPC (net.corda.client.rpc)**: client RPC
+* **Client Jackson (net.corda.client.jackson)**: JSON support for client applications
+
+Corda incubating modules
+------------------------
+
+The following modules don't yet have a completely stable API, but we will do our best to minimise disruption to
+developers using them until we are able to graduate them into the public API:
+
+* **net.corda.node.driver**: test utilities to run nodes programmatically
+* **net.corda.confidential.identities**: experimental support for confidential identities on the ledger
+* **net.corda.node.test.utils**: generic test utilities
+* **net.corda.finance**: a range of elementary contracts (and associated schemas) and protocols, such as abstract fungible assets, cash, obligation and commercial paper
+* **net.corda.client.jfx**: support for Java FX UI
+* **net.corda.client.mock**: client mock utilities
+* **Cordformation**: Gradle integration plugins
+
+Corda unstable modules
+----------------------
+
+The following modules are available but we do not commit to their stability or continuation in any sense:
+
+* **net.corda.buildSrc**: necessary gradle plugins to build Corda
+* **net.corda.node**: core code of the Corda node (eg: node driver, node services, messaging, persistence)
+* **net.corda.node.api**: data structures shared between the node and the client module, e.g. types sent via RPC
+* **net.corda.samples.network.visualiser**: a network visualiser that uses a simulation to visualise the interaction and messages between nodes on the Corda network
+* **net.corda.samples.demos.attachment**: demonstrates sending a transaction with an attachment from one to node to another, and the receiving node accessing the attachment
+* **net.corda.samples.demos.bankofcorda**: simulates the role of an asset issuing authority (eg. central bank for cash)
+* **net.corda.samples.demos.irs**: demonstrates an Interest Rate Swap agreement between two banks
+* **net.corda.samples.demos.notary**: a simple demonstration of a node getting multiple transactions notarised by a distributed (Raft or BFT SMaRt) notary
+* **net.corda.samples.demos.simmvaluation**: See our [main documentation site](https://docs.corda.net/initial-margin-agreement.html) regarding the SIMM valuation and agreement on a distributed ledger
+* **net.corda.samples.demos.trader**: demonstrates four nodes, a notary, an issuer of cash (Bank of Corda), and two parties trading with each other, exchanging cash for a commercial paper
+* **net.corda.node.smoke.test.utils**: test utilities for smoke testing
+* **net.corda.node.test.common**: common test functionality
+* **net.corda.tools.demobench**: a GUI tool that allows to run Corda nodes locally for demonstrations
+* **net.corda.tools.explorer**: a GUI front-end for Corda
+* **net.corda.tools.graphs**: utilities to infer project dependencies
+* **net.corda.tools.loadtest**: Corda load tests
+* **net.corda.verifier**: allows out-of-node transaction verification, allowing verification to scale horizontally
+* **net.corda.webserver**: is a servlet container for CorDapps that export HTTP endpoints. This server is an RPC client of the node
+* **net.corda.sandbox-creator**: sandbox utilities
+* **net.corda.quasar.hook**: agent to hook into Quasar and provide types exclusion lists
+
+.. warning:: Code inside any package in the ``net.corda`` namespace which contains ``.internal`` or in ``net.corda.node`` for internal use only.
+   Future releases will reject any CorDapps that use types from these packages.
+
+.. warning:: The web server module will be removed in future. You should call Corda nodes through RPC from your web server of choice e.g., Spring Boot, Vertx, Undertow.
\ No newline at end of file
diff --git a/docs/source/getting-set-up.rst b/docs/source/getting-set-up.rst
index 95bb99bfc9..1fbe7060b3 100644
--- a/docs/source/getting-set-up.rst
+++ b/docs/source/getting-set-up.rst
@@ -169,7 +169,7 @@ The best way to check that everything is working fine is by taking a deeper look
 Next, you should read through :doc:`Corda Key Concepts <key-concepts>` to understand how Corda works.
 
 By then, you'll be ready to start writing your own CorDapps. Learn how to do this in the
-:doc:`Hello, World tutorial <hello-world-index>`. You may want to refer to the :doc:`API docs <api-index>` along the
+:doc:`Hello, World tutorial <hello-world-index>`. You may want to refer to the :doc:`Modules documentation <corda-modules>` along the
 way.
 
 If you encounter any issues, please see the :doc:`troubleshooting` page, or get in touch with us on the
diff --git a/docs/source/other-index.rst b/docs/source/other-index.rst
index 7f6fa6ef66..539608be94 100644
--- a/docs/source/other-index.rst
+++ b/docs/source/other-index.rst
@@ -7,5 +7,6 @@ Other
    json
    secure-coding-guidelines
    corda-repo-layout
+   corda-modules
    building-the-docs
    codestyle
\ No newline at end of file
diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst
index 845933db05..3552fc329e 100644
--- a/docs/source/release-notes.rst
+++ b/docs/source/release-notes.rst
@@ -32,7 +32,7 @@ Our extensive testing frameworks will continue to evolve alongside future Corda
 we have introduced a new test node driver module to encapsulate all test functionality in support of building standalone node integration 
 tests using our DSL driver. 
 
-Please read :doc:`api-index` for complete details.
+Please read :doc:`corda-modules` for complete details.
 
 .. note:: it may be necessary to recompile applications against future versions of the API until we begin offering
          `ABI (Application Binary Interface) <https://en.wikipedia.org/wiki/Application_binary_interface>`_ stability as well.
diff --git a/experimental/sandbox/build.gradle b/experimental/sandbox/build.gradle
index 53e244815a..2e64b70651 100644
--- a/experimental/sandbox/build.gradle
+++ b/experimental/sandbox/build.gradle
@@ -30,7 +30,10 @@ task standaloneJar(type: Jar) {
     }
     with jar
     manifest {
-        attributes 'Main-Class': 'net.corda.sandbox.tools.SandboxCreator'
+        attributes(
+                'Main-Class': 'net.corda.sandbox.tools.SandboxCreator',
+                'Automatic-Module-Name': 'net.corda.sandbox.creator'
+        )
     }
     archiveName "corda-sandbox-creator-${version}.jar"
 }
diff --git a/samples/attachment-demo/build.gradle b/samples/attachment-demo/build.gradle
index 170f9e265c..1ca4d85d3d 100644
--- a/samples/attachment-demo/build.gradle
+++ b/samples/attachment-demo/build.gradle
@@ -102,3 +102,11 @@ task runRecipient(type: JavaExec) {
     args '--role'
     args 'RECIPIENT'
 }
+
+jar {
+    manifest {
+        attributes(
+                'Automatic-Module-Name': 'net.corda.samples.demos.attachment'
+        )
+    }
+}
diff --git a/samples/bank-of-corda-demo/build.gradle b/samples/bank-of-corda-demo/build.gradle
index 4da684ed47..dcdbe408d0 100644
--- a/samples/bank-of-corda-demo/build.gradle
+++ b/samples/bank-of-corda-demo/build.gradle
@@ -143,3 +143,11 @@ task runWebCashIssue(type: JavaExec) {
     args '--currency'
     args 'GBP'
 }
+
+jar {
+    manifest {
+        attributes(
+                'Automatic-Module-Name': 'net.corda.samples.demos.bankofcorda'
+        )
+    }
+}
diff --git a/samples/irs-demo/build.gradle b/samples/irs-demo/build.gradle
index d1bd45a246..6d9b908823 100644
--- a/samples/irs-demo/build.gradle
+++ b/samples/irs-demo/build.gradle
@@ -117,4 +117,9 @@ publishing {
 
 jar {
     from sourceSets.test.output
+    manifest {
+        attributes(
+                'Automatic-Module-Name': 'net.corda.samples.demos.irs'
+        )
+    }
 }
diff --git a/samples/network-visualiser/build.gradle b/samples/network-visualiser/build.gradle
index bad1295dbc..d0ee4ea3e3 100644
--- a/samples/network-visualiser/build.gradle
+++ b/samples/network-visualiser/build.gradle
@@ -42,3 +42,11 @@ task deployVisualiser(type: FatCapsule) {
         javaAgents = [configurations.quasar.singleFile.name]
     }
 }
+
+jar {
+    manifest {
+        attributes(
+                'Automatic-Module-Name': 'net.corda.samples.network.visualiser'
+        )
+    }
+}
diff --git a/samples/notary-demo/build.gradle b/samples/notary-demo/build.gradle
index b2d3f3e341..fbbaa6a9a7 100644
--- a/samples/notary-demo/build.gradle
+++ b/samples/notary-demo/build.gradle
@@ -66,3 +66,11 @@ task notarise(type: JavaExec) {
     classpath = sourceSets.main.runtimeClasspath
     main = 'net.corda.notarydemo.NotariseKt'
 }
+
+jar {
+    manifest {
+        attributes(
+                'Automatic-Module-Name': 'net.corda.samples.demos.notary'
+        )
+    }
+}
diff --git a/samples/simm-valuation-demo/build.gradle b/samples/simm-valuation-demo/build.gradle
index 1d7d654ee8..278608bd77 100644
--- a/samples/simm-valuation-demo/build.gradle
+++ b/samples/simm-valuation-demo/build.gradle
@@ -117,3 +117,11 @@ publishing {
         }
     }
 }
+
+jar {
+    manifest {
+        attributes(
+                'Automatic-Module-Name': 'net.corda.samples.demos.simmvaluation'
+        )
+    }
+}
diff --git a/samples/trader-demo/build.gradle b/samples/trader-demo/build.gradle
index 216405f66f..5d2a1750eb 100644
--- a/samples/trader-demo/build.gradle
+++ b/samples/trader-demo/build.gradle
@@ -121,3 +121,11 @@ task runSeller(type: JavaExec) {
     args '--role'
     args 'SELLER'
 }
+
+jar {
+    manifest {
+        attributes(
+                'Automatic-Module-Name': 'net.corda.samples.demos.trader'
+        )
+    }
+}
\ No newline at end of file
diff --git a/tools/demobench/build.gradle b/tools/demobench/build.gradle
index 6a3452b8c9..727a5c8237 100644
--- a/tools/demobench/build.gradle
+++ b/tools/demobench/build.gradle
@@ -78,7 +78,8 @@ jar {
     manifest {
         attributes(
             'Main-Class': mainClassName,
-            'Class-Path': configurations.runtime.collect { it.getName() }.join(' ')
+            'Class-Path': configurations.runtime.collect { it.getName() }.join(' '),
+            'Automatic-Module-Name': 'net.corda.tools.demobench'
         )
     }
 }
diff --git a/tools/explorer/build.gradle b/tools/explorer/build.gradle
index 3ffc1e543c..9eddf905ca 100644
--- a/tools/explorer/build.gradle
+++ b/tools/explorer/build.gradle
@@ -65,3 +65,11 @@ task(runSimulationNodes, dependsOn: 'classes', type: JavaExec) {
     classpath = sourceSets.main.runtimeClasspath
     args '-S'
 }
+
+jar {
+    manifest {
+        attributes(
+                'Automatic-Module-Name': 'net.corda.tools.explorer'
+        )
+    }
+}
\ No newline at end of file
diff --git a/tools/graphs/build.gradle b/tools/graphs/build.gradle
index 5e81dee1c9..01a4da9637 100644
--- a/tools/graphs/build.gradle
+++ b/tools/graphs/build.gradle
@@ -79,3 +79,11 @@ task graphs {
         }
     }
 }
+
+jar {
+    manifest {
+        attributes(
+                'Automatic-Module-Name': 'net.corda.tools.graphs'
+        )
+    }
+}
\ No newline at end of file
diff --git a/tools/loadtest/build.gradle b/tools/loadtest/build.gradle
index af7012b2e6..00480419c0 100644
--- a/tools/loadtest/build.gradle
+++ b/tools/loadtest/build.gradle
@@ -35,3 +35,11 @@ run {
         systemProperty "consoleLogLevel", System.properties.getProperty('consoleLogLevel')
     }
 }
+
+jar {
+    manifest {
+        attributes(
+                'Automatic-Module-Name': 'net.corda.tools.loadtest'
+        )
+    }
+}

From 894f05d84e4185fab3d694a16e29f365a4810a1b Mon Sep 17 00:00:00 2001
From: Andrzej Cichocki <andrzej.cichocki@r3.com>
Date: Sat, 7 Oct 2017 10:46:20 +0100
Subject: [PATCH 107/185] CORDA-599 Remove dependency of NetworkMapService
 impls on ServiceHub (#1713)

---
 .../core/node/services/VaultQueryService.kt   |  0
 .../net/corda/core/node/ServiceInfoTests.kt   |  0
 .../kotlin/net/corda/flows/IssuerFlowTest.kt  |  0
 .../net/corda/node/internal/AbstractNode.kt   | 27 +++++++++++--------
 .../kotlin/net/corda/node/internal/Node.kt    | 12 ++++++---
 .../node/services/api/AbstractNodeService.kt  |  7 ++---
 .../node/services/config/NodeConfiguration.kt |  1 +
 .../network/InMemoryNetworkMapCache.kt        |  0
 .../services/network/NetworkMapService.kt     | 26 +++++++-----------
 .../network/PersistentNetworkMapService.kt    |  7 ++---
 .../services/vault/HibernateVaultQueryImpl.kt |  0
 .../network/AbstractNetworkMapServiceTest.kt  |  6 ++---
 .../PersistentNetworkMapServiceTest.kt        | 13 +++++----
 .../kotlin/net/corda/testing/node/MockNode.kt | 13 ++++-----
 14 files changed, 60 insertions(+), 52 deletions(-)
 delete mode 100644 core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt
 delete mode 100644 core/src/test/kotlin/net/corda/core/node/ServiceInfoTests.kt
 delete mode 100644 finance/src/test/kotlin/net/corda/flows/IssuerFlowTest.kt
 delete mode 100644 node/src/main/kotlin/net/corda/node/services/network/InMemoryNetworkMapCache.kt
 delete mode 100644 node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt

diff --git a/core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt b/core/src/main/kotlin/net/corda/core/node/services/VaultQueryService.kt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/core/src/test/kotlin/net/corda/core/node/ServiceInfoTests.kt b/core/src/test/kotlin/net/corda/core/node/ServiceInfoTests.kt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/finance/src/test/kotlin/net/corda/flows/IssuerFlowTest.kt b/finance/src/test/kotlin/net/corda/flows/IssuerFlowTest.kt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 15ed414620..ba3f1d06b6 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -33,6 +33,7 @@ import net.corda.core.serialization.SingletonSerializeAsToken
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.debug
+import net.corda.node.VersionInfo
 import net.corda.node.internal.classloading.requireAnnotation
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
@@ -95,10 +96,17 @@ import net.corda.core.crypto.generateKeyPair as cryptoGenerateKeyPair
 // TODO: Where this node is the initial network map service, currently no networkMapService is provided.
 // In theory the NodeInfo for the node should be passed in, instead, however currently this is constructed by the
 // AbstractNode. It should be possible to generate the NodeInfo outside of AbstractNode, so it can be passed in.
-abstract class AbstractNode(open val configuration: NodeConfiguration,
+abstract class AbstractNode(config: NodeConfiguration,
                             val advertisedServices: Set<ServiceInfo>,
                             val platformClock: Clock,
+                            protected val versionInfo: VersionInfo,
                             @VisibleForTesting val busyNodeLatch: ReusableLatch = ReusableLatch()) : SingletonSerializeAsToken() {
+    open val configuration = config.apply {
+        require(minimumPlatformVersion <= versionInfo.platformVersion) {
+            "minimumPlatformVersion cannot be greater than the node's own version"
+        }
+    }
+
     private class StartedNodeImpl<out N : AbstractNode>(
             override val internals: N,
             override val services: ServiceHubInternalImpl,
@@ -119,7 +127,6 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
 
     protected abstract val log: Logger
     protected abstract val networkMapAddress: SingleMessageRecipient?
-    protected abstract val platformVersion: Int
 
     // We will run as much stuff in this single thread as possible to keep the risk of thread safety bugs low during the
     // low-performance prototyping period.
@@ -452,13 +459,13 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         legalIdentity = obtainIdentity()
         network = makeMessagingService(legalIdentity)
         info = makeInfo(legalIdentity)
-
+        val networkMapCache = services.networkMapCache
         val tokenizableServices = mutableListOf(attachments, network, services.vaultService,
                 services.keyManagementService, services.identityService, platformClock, services.schedulerService,
-                services.auditService, services.monitoringService, services.networkMapCache, services.schemaService,
+                services.auditService, services.monitoringService, networkMapCache, services.schemaService,
                 services.transactionVerifierService, services.validatedTransactions, services.contractUpgradeService,
                 services, cordappProvider, this)
-        makeNetworkServices(tokenizableServices)
+        makeNetworkServices(network, networkMapCache, tokenizableServices)
         return tokenizableServices
     }
 
@@ -489,7 +496,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         val allIdentitiesList = mutableListOf(legalIdentity)
         myNotaryIdentity?.let { allIdentitiesList.add(it) }
         val addresses = myAddresses() // TODO There is no support for multiple IP addresses yet.
-        return NodeInfo(addresses, allIdentitiesList, platformVersion, platformClock.instant().toEpochMilli())
+        return NodeInfo(addresses, allIdentitiesList, versionInfo.platformVersion, platformClock.instant().toEpochMilli())
     }
 
     /**
@@ -550,9 +557,9 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         }
     }
 
-    private fun makeNetworkServices(tokenizableServices: MutableList<Any>) {
+    private fun makeNetworkServices(network: MessagingService, networkMapCache: NetworkMapCacheInternal, tokenizableServices: MutableList<Any>) {
         val serviceTypes = advertisedServices.map { it.type }
-        inNodeNetworkMapService = if (configuration.networkMapService == null) makeNetworkMapService() else NullNetworkMapService
+        inNodeNetworkMapService = if (configuration.networkMapService == null) makeNetworkMapService(network, networkMapCache) else NullNetworkMapService
         val notaryServiceType = serviceTypes.singleOrNull { it.isNotary() }
         if (notaryServiceType != null) {
             val service = makeCoreNotaryService(notaryServiceType)
@@ -631,9 +638,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         return PersistentKeyManagementService(identityService, partyKeys)
     }
 
-    open protected fun makeNetworkMapService(): NetworkMapService {
-        return PersistentNetworkMapService(services, configuration.minimumPlatformVersion)
-    }
+    abstract protected fun makeNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal): NetworkMapService
 
     open protected fun makeCoreNotaryService(type: ServiceType): NotaryService? {
         check(myNotaryIdentity != null) { "No notary identity initialized when creating a notary service" }
diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt
index 31cb1cb27f..adf92b70c1 100644
--- a/node/src/main/kotlin/net/corda/node/internal/Node.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt
@@ -19,6 +19,7 @@ import net.corda.node.serialization.KryoServerSerializationScheme
 import net.corda.node.serialization.NodeClock
 import net.corda.node.services.RPCUserService
 import net.corda.node.services.RPCUserServiceImpl
+import net.corda.node.services.api.NetworkMapCacheInternal
 import net.corda.node.services.api.SchemaService
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.config.FullNodeConfiguration
@@ -27,6 +28,8 @@ import net.corda.node.services.messaging.ArtemisMessagingServer.Companion.ipDete
 import net.corda.node.services.messaging.ArtemisMessagingServer.Companion.ipDetectResponseProperty
 import net.corda.node.services.messaging.MessagingService
 import net.corda.node.services.messaging.NodeMessagingClient
+import net.corda.node.services.network.NetworkMapService
+import net.corda.node.services.network.PersistentNetworkMapService
 import net.corda.node.utilities.AddressUtils
 import net.corda.node.utilities.AffinityExecutor
 import net.corda.node.utilities.TestClock
@@ -62,9 +65,9 @@ import kotlin.system.exitProcess
  */
 open class Node(override val configuration: FullNodeConfiguration,
                 advertisedServices: Set<ServiceInfo>,
-                private val versionInfo: VersionInfo,
+                versionInfo: VersionInfo,
                 val initialiseSerialization: Boolean = true
-) : AbstractNode(configuration, advertisedServices, createClock(configuration)) {
+) : AbstractNode(configuration, advertisedServices, createClock(configuration), versionInfo) {
     companion object {
         private val logger = loggerFor<Node>()
         var renderBasicInfoToConsole = true
@@ -90,7 +93,6 @@ open class Node(override val configuration: FullNodeConfiguration,
     }
 
     override val log: Logger get() = logger
-    override val platformVersion: Int get() = versionInfo.platformVersion
     override val networkMapAddress: NetworkMapAddress? get() = configuration.networkMapService?.address?.let(::NetworkMapAddress)
     override fun makeTransactionVerifierService() = (network as NodeMessagingClient).verifierService
 
@@ -277,6 +279,10 @@ open class Node(override val configuration: FullNodeConfiguration,
         return listOf(address.hostAndPort)
     }
 
+    override fun makeNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal): NetworkMapService {
+        return PersistentNetworkMapService(network, networkMapCache, configuration.minimumPlatformVersion)
+    }
+
     /**
      * If the node is persisting to an embedded H2 database, then expose this via TCP with a JDBC URL of the form:
      * jdbc:h2:tcp://<host>:<port>/node
diff --git a/node/src/main/kotlin/net/corda/node/services/api/AbstractNodeService.kt b/node/src/main/kotlin/net/corda/node/services/api/AbstractNodeService.kt
index f14f0af01a..42b12629c4 100644
--- a/node/src/main/kotlin/net/corda/node/services/api/AbstractNodeService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/api/AbstractNodeService.kt
@@ -10,10 +10,7 @@ import javax.annotation.concurrent.ThreadSafe
  * Abstract superclass for services that a node can host, which provides helper functions.
  */
 @ThreadSafe
-abstract class AbstractNodeService(val services: ServiceHubInternal) : SingletonSerializeAsToken() {
-
-    val network: MessagingService get() = services.networkService
-
+abstract class AbstractNodeService(val network: MessagingService) : SingletonSerializeAsToken() {
     /**
      * Register a handler for a message topic. In comparison to using net.addMessageHandler() this manages a lot of
      * common boilerplate code. Exceptions are caught and passed to the provided consumer.  If you just want a simple
@@ -36,7 +33,7 @@ abstract class AbstractNodeService(val services: ServiceHubInternal) : Singleton
                     val msg = network.createMessage(topic, request.sessionID, response.serialize().bytes)
                     network.send(msg, request.replyTo)
                 }
-            } catch(e: Exception) {
+            } catch (e: Exception) {
                 exceptionConsumer(message, e)
             }
         }
diff --git a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
index cbaa194aad..ba865ecaba 100644
--- a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
+++ b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
@@ -93,6 +93,7 @@ data class FullNodeConfiguration(
             require(it.username.matches("\\w+".toRegex())) { "Username ${it.username} contains invalid characters" }
         }
         require(myLegalName.commonName == null) { "Common name must be null: $myLegalName" }
+        require(minimumPlatformVersion >= 1) { "minimumPlatformVersion cannot be less than 1" }
     }
 
     fun calculateServices(): Set<ServiceInfo> {
diff --git a/node/src/main/kotlin/net/corda/node/services/network/InMemoryNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/InMemoryNetworkMapCache.kt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt b/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt
index 966d537954..06b04e55a7 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt
@@ -20,8 +20,9 @@ import net.corda.core.serialization.serialize
 import net.corda.core.utilities.debug
 import net.corda.core.utilities.loggerFor
 import net.corda.node.services.api.AbstractNodeService
-import net.corda.node.services.api.ServiceHubInternal
+import net.corda.node.services.api.NetworkMapCacheInternal
 import net.corda.node.services.messaging.MessageHandlerRegistration
+import net.corda.node.services.messaging.MessagingService
 import net.corda.node.services.messaging.ServiceRequestMessage
 import net.corda.node.services.messaging.createMessage
 import net.corda.node.services.network.NetworkMapService.*
@@ -114,8 +115,8 @@ interface NetworkMapService {
 object NullNetworkMapService : NetworkMapService
 
 @ThreadSafe
-class InMemoryNetworkMapService(services: ServiceHubInternal, minimumPlatformVersion: Int)
-    : AbstractNetworkMapService(services, minimumPlatformVersion) {
+class InMemoryNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal, minimumPlatformVersion: Int)
+    : AbstractNetworkMapService(network, networkMapCache, minimumPlatformVersion) {
 
     override val nodeRegistrations: MutableMap<PartyAndCertificate, NodeRegistrationInfo> = ConcurrentHashMap()
     override val subscribers = ThreadBox(mutableMapOf<SingleMessageRecipient, LastAcknowledgeInfo>())
@@ -132,8 +133,9 @@ class InMemoryNetworkMapService(services: ServiceHubInternal, minimumPlatformVer
  * subscriber clean up and is simpler to persist than the previous implementation based on a set of missing messages acks.
  */
 @ThreadSafe
-abstract class AbstractNetworkMapService(services: ServiceHubInternal,
-                                         val minimumPlatformVersion: Int) : NetworkMapService, AbstractNodeService(services) {
+abstract class AbstractNetworkMapService(network: MessagingService,
+                                         private val networkMapCache: NetworkMapCacheInternal,
+                                         private val minimumPlatformVersion: Int) : NetworkMapService, AbstractNodeService(network) {
     companion object {
         /**
          * Maximum credible size for a registration request. Generally requests are around 2000-6000 bytes, so this gives a
@@ -158,14 +160,6 @@ abstract class AbstractNetworkMapService(services: ServiceHubInternal,
     val maxUnacknowledgedUpdates = 10
 
     private val handlers = ArrayList<MessageHandlerRegistration>()
-
-    init {
-        require(minimumPlatformVersion >= 1) { "minimumPlatformVersion cannot be less than 1" }
-        require(minimumPlatformVersion <= services.myInfo.platformVersion) {
-            "minimumPlatformVersion cannot be greater than the node's own version"
-        }
-    }
-
     protected fun setup() {
         // Register message handlers
         handlers += addMessageHandler(FETCH_TOPIC) { req: FetchMapRequest -> processFetchAllRequest(req) }
@@ -200,7 +194,7 @@ abstract class AbstractNetworkMapService(services: ServiceHubInternal,
         subscribers.locked { remove(subscriber) }
     }
 
-    private fun processAcknowledge(request: UpdateAcknowledge): Unit {
+    private fun processAcknowledge(request: UpdateAcknowledge) {
         if (request.replyTo !is SingleMessageRecipient) throw NodeMapException.InvalidSubscriber()
         subscribers.locked {
             val lastVersionAcked = this[request.replyTo]?.mapVersion
@@ -280,11 +274,11 @@ abstract class AbstractNetworkMapService(services: ServiceHubInternal,
         when (change.type) {
             ADD -> {
                 logger.info("Added node ${node.addresses} to network map")
-                services.networkMapCache.addNode(change.node)
+                networkMapCache.addNode(change.node)
             }
             REMOVE -> {
                 logger.info("Removed node ${node.addresses} from network map")
-                services.networkMapCache.removeNode(change.node)
+                networkMapCache.removeNode(change.node)
             }
         }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapService.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapService.kt
index f62748dcba..6d3600d398 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapService.kt
@@ -7,7 +7,8 @@ import net.corda.core.messaging.SingleMessageRecipient
 import net.corda.core.serialization.SerializationDefaults
 import net.corda.core.serialization.deserialize
 import net.corda.core.serialization.serialize
-import net.corda.node.services.api.ServiceHubInternal
+import net.corda.node.services.api.NetworkMapCacheInternal
+import net.corda.node.services.messaging.MessagingService
 import net.corda.node.utilities.*
 import net.corda.nodeapi.ArtemisMessagingComponent
 import java.io.ByteArrayInputStream
@@ -23,8 +24,8 @@ import java.util.*
  * This class needs database transactions to be in-flight during method calls and init, otherwise it will throw
  * exceptions.
  */
-class PersistentNetworkMapService(services: ServiceHubInternal, minimumPlatformVersion: Int)
-    : AbstractNetworkMapService(services, minimumPlatformVersion) {
+class PersistentNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal, minimumPlatformVersion: Int)
+    : AbstractNetworkMapService(network, networkMapCache, minimumPlatformVersion) {
 
     // Only the node_party_path column is needed to reconstruct a PartyAndCertificate but we have the others for human readability
     @Entity
diff --git a/node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt b/node/src/main/kotlin/net/corda/node/services/vault/HibernateVaultQueryImpl.kt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
index a429b84d1f..a8646caad0 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
@@ -7,6 +7,8 @@ import net.corda.core.node.NodeInfo
 import net.corda.core.serialization.deserialize
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
+import net.corda.node.services.api.NetworkMapCacheInternal
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.messaging.MessagingService
 import net.corda.node.services.messaging.send
@@ -20,11 +22,9 @@ import net.corda.node.services.network.NetworkMapService.Companion.PUSH_TOPIC
 import net.corda.node.services.network.NetworkMapService.Companion.QUERY_TOPIC
 import net.corda.node.services.network.NetworkMapService.Companion.REGISTER_TOPIC
 import net.corda.node.services.network.NetworkMapService.Companion.SUBSCRIPTION_TOPIC
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.node.utilities.AddOrRemove
 import net.corda.node.utilities.AddOrRemove.ADD
 import net.corda.node.utilities.AddOrRemove.REMOVE
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
@@ -275,7 +275,7 @@ abstract class AbstractNetworkMapServiceTest<out S : AbstractNetworkMapService>
                             notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): MockNode {
             return object : MockNode(config, network, null, advertisedServices, id, notaryIdentity, entropyRoot) {
-                override fun makeNetworkMapService() = NullNetworkMapService
+                override fun makeNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal) = NullNetworkMapService
             }
         }
     }
diff --git a/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt
index 19bf42cf65..7e8e6a34a1 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt
@@ -1,11 +1,13 @@
 package net.corda.node.services.network
 
 import net.corda.core.messaging.SingleMessageRecipient
+import net.corda.node.services.api.NetworkMapCacheInternal
 import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.api.ServiceHubInternal
 import net.corda.node.services.config.NodeConfiguration
+import net.corda.node.services.messaging.MessagingService
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
+import net.corda.testing.node.MockServices.Companion.MOCK_VERSION_INFO
 import java.math.BigInteger
 import java.security.KeyPair
 
@@ -35,7 +37,7 @@ class PersistentNetworkMapServiceTest : AbstractNetworkMapServiceTest<Persistent
                             notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): MockNode {
             return object : MockNode(config, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
-                override fun makeNetworkMapService() = SwizzleNetworkMapService(services)
+                override fun makeNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal) = SwizzleNetworkMapService(network, networkMapCache)
             }
         }
     }
@@ -44,12 +46,13 @@ class PersistentNetworkMapServiceTest : AbstractNetworkMapServiceTest<Persistent
      * We use a special [NetworkMapService] that allows us to switch in a new instance at any time to check that the
      * state within it is correctly restored.
      */
-    private class SwizzleNetworkMapService(val services: ServiceHubInternal) : NetworkMapService {
-        var delegate: PersistentNetworkMapService = PersistentNetworkMapService(services, 1)
+    private class SwizzleNetworkMapService(private val delegateFactory: () -> PersistentNetworkMapService) : NetworkMapService {
+        constructor(network: MessagingService, networkMapCache: NetworkMapCacheInternal) : this({ PersistentNetworkMapService(network, networkMapCache, 1) })
 
+        var delegate = delegateFactory()
         fun swizzle() {
             delegate.unregisterNetworkHandlers()
-            delegate = PersistentNetworkMapService(services, 1)
+            delegate = delegateFactory()
         }
     }
 }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index 2f8f50b7c3..e1d1f5c4c3 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -27,6 +27,9 @@ import net.corda.core.utilities.loggerFor
 import net.corda.finance.utils.WorldMapLocation
 import net.corda.node.internal.AbstractNode
 import net.corda.node.internal.StartedNode
+import net.corda.node.services.api.NetworkMapCacheInternal
+import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.nodeapi.internal.ServiceType
 import net.corda.node.services.api.SchemaService
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.identity.PersistentIdentityService
@@ -41,9 +44,8 @@ import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.node.utilities.AffinityExecutor
 import net.corda.node.utilities.AffinityExecutor.ServiceAffinityExecutor
 import net.corda.node.utilities.CertificateAndKeyPair
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.testing.*
+import net.corda.testing.node.MockServices.Companion.MOCK_VERSION_INFO
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
 import org.apache.activemq.artemis.utils.ReusableLatch
 import org.slf4j.Logger
@@ -158,10 +160,9 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                         val id: Int,
                         internal val notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                         val entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue())) :
-            AbstractNode(config, advertisedServices, TestClock(), mockNet.busyLatch) {
+            AbstractNode(config, advertisedServices, TestClock(), MOCK_VERSION_INFO, mockNet.busyLatch) {
         var counter = entropyRoot
         override val log: Logger = loggerFor<MockNode>()
-        override val platformVersion: Int get() = 1
         override val serverThread: AffinityExecutor =
                 if (mockNet.threadPerNode)
                     ServiceAffinityExecutor("Mock node $id thread", 1)
@@ -215,8 +216,8 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
             // Nothing to do
         }
 
-        override fun makeNetworkMapService(): NetworkMapService {
-            return InMemoryNetworkMapService(services, platformVersion)
+        override fun makeNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal): NetworkMapService {
+            return InMemoryNetworkMapService(network, networkMapCache, 1)
         }
 
         override fun getNotaryIdentity(): PartyAndCertificate? {

From 83f37417ae25426e0a24ec4e63b51239b9dfc50c Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Sat, 7 Oct 2017 12:48:16 +0100
Subject: [PATCH 108/185] Fixes the API docs.

---
 docs/source/api-flows.rst                     | 119 ++++++++----------
 docs/source/api-identity.rst                  |   4 +-
 docs/source/api-transactions.rst              |  78 ++++++------
 .../java/net/corda/docs/FlowCookbookJava.java |  32 ++---
 .../kotlin/net/corda/docs/FlowCookbook.kt     |  32 ++---
 5 files changed, 124 insertions(+), 141 deletions(-)

diff --git a/docs/source/api-flows.rst b/docs/source/api-flows.rst
index 931aa493df..4a0e284621 100644
--- a/docs/source/api-flows.rst
+++ b/docs/source/api-flows.rst
@@ -221,14 +221,14 @@ There are several ways to retrieve a notary from the network map:
 
     .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
         :language: kotlin
-        :start-after: DOCSTART 1
-        :end-before: DOCEND 1
-        :dedent: 12
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
-        :start-after: DOCSTART 1
-        :end-before: DOCEND 1
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
         :dedent: 12
 
 Specific counterparties
@@ -239,32 +239,14 @@ We can also use the network map to retrieve a specific counterparty:
 
     .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
         :language: kotlin
-        :start-after: DOCSTART 2
-        :end-before: DOCEND 2
-        :dedent: 12
+        :start-after: DOCSTART 02
+        :end-before: DOCEND 02
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
-        :start-after: DOCSTART 2
-        :end-before: DOCEND 2
-        :dedent: 12
-
-Specific services
-~~~~~~~~~~~~~~~~~
-Finally, we can use the map to identify nodes providing a specific service (e.g. a regulator or an oracle):
-
-.. container:: codeset
-
-    .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
-        :language: kotlin
-        :start-after: DOCSTART 3
-        :end-before: DOCEND 3
-        :dedent: 12
-
-    .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
-        :language: java
-        :start-after: DOCSTART 3
-        :end-before: DOCEND 3
+        :start-after: DOCSTART 02
+        :end-before: DOCEND 02
         :dedent: 12
 
 Communication between parties
@@ -295,7 +277,7 @@ InitiateFlow
         :language: kotlin
         :start-after: DOCSTART initiateFlow
         :end-before: DOCEND initiateFlow
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -318,14 +300,14 @@ Once we have a ``FlowSession`` object we can send arbitrary data to a counterpar
 
     .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
         :language: kotlin
-        :start-after: DOCSTART 4
-        :end-before: DOCEND 4
-        :dedent: 12
+        :start-after: DOCSTART 04
+        :end-before: DOCEND 04
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
-        :start-after: DOCSTART 4
-        :end-before: DOCEND 4
+        :start-after: DOCSTART 04
+        :end-before: DOCEND 04
         :dedent: 12
 
 The flow on the other side must eventually reach a corresponding ``receive`` call to get this message.
@@ -350,14 +332,14 @@ be what it appears to be! We must unwrap the ``UntrustworthyData`` using a lambd
 
     .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
         :language: kotlin
-        :start-after: DOCSTART 5
-        :end-before: DOCEND 5
-        :dedent: 12
+        :start-after: DOCSTART 05
+        :end-before: DOCEND 05
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
-        :start-after: DOCSTART 5
-        :end-before: DOCEND 5
+        :start-after: DOCSTART 05
+        :end-before: DOCEND 05
         :dedent: 12
 
 We're not limited to sending to and receiving from a single counterparty. A flow can send messages to as many parties
@@ -367,14 +349,14 @@ as it likes, and each party can invoke a different response flow:
 
     .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
         :language: kotlin
-        :start-after: DOCSTART 6
-        :end-before: DOCEND 6
-        :dedent: 12
+        :start-after: DOCSTART 06
+        :end-before: DOCEND 06
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
-        :start-after: DOCSTART 6
-        :end-before: DOCEND 6
+        :start-after: DOCSTART 06
+        :end-before: DOCEND 06
         :dedent: 12
 
 .. warning:: If you initiate several flows from the same ``@InitiatingFlow`` flow then on the receiving side you must be
@@ -392,14 +374,14 @@ type of data sent doesn't need to match the type of the data received back:
 
     .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
         :language: kotlin
-        :start-after: DOCSTART 7
-        :end-before: DOCEND 7
-        :dedent: 12
+        :start-after: DOCSTART 07
+        :end-before: DOCEND 07
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
-        :start-after: DOCSTART 7
-        :end-before: DOCEND 7
+        :start-after: DOCSTART 07
+        :end-before: DOCEND 07
         :dedent: 12
 
 Counterparty response
@@ -417,14 +399,14 @@ Our side of the flow must mirror these calls. We could do this as follows:
 
     .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
         :language: kotlin
-        :start-after: DOCSTART 8
-        :end-before: DOCEND 8
-        :dedent: 12
+        :start-after: DOCSTART 08
+        :end-before: DOCEND 08
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
-        :start-after: DOCSTART 8
-        :end-before: DOCEND 8
+        :start-after: DOCSTART 08
+        :end-before: DOCEND 08
         :dedent: 12
 
 Why sessions?
@@ -481,7 +463,7 @@ explicit in the ``initiateFlow`` function call. To port existing code:
         :language: kotlin
         :start-after: DOCSTART FlowSession porting
         :end-before: DOCEND FlowSession porting
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -489,7 +471,6 @@ explicit in the ``initiateFlow`` function call. To port existing code:
         :end-before: DOCEND FlowSession porting
         :dedent: 12
 
-
 Subflows
 --------
 
@@ -560,14 +541,14 @@ the transaction's states:
 
     .. literalinclude:: ../../docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt
         :language: kotlin
-        :start-after: DOCSTART 9
-        :end-before: DOCEND 9
-        :dedent: 12
+        :start-after: DOCSTART 09
+        :end-before: DOCEND 09
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
-        :start-after: DOCSTART 9
-        :end-before: DOCEND 9
+        :start-after: DOCSTART 09
+        :end-before: DOCEND 09
         :dedent: 12
 
 We can also choose to send the transaction to additional parties who aren't one of the state's participants:
@@ -578,7 +559,7 @@ We can also choose to send the transaction to additional parties who aren't one
         :language: kotlin
         :start-after: DOCSTART 10
         :end-before: DOCEND 10
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -601,7 +582,7 @@ transaction ourselves, we can automatically gather the signatures of the other r
         :language: kotlin
         :start-after: DOCSTART 15
         :end-before: DOCEND 15
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -618,7 +599,7 @@ transaction and provide their signature if they are satisfied:
         :language: kotlin
         :start-after: DOCSTART 16
         :end-before: DOCEND 16
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -639,7 +620,7 @@ transaction data vending requests as the receiver walks the dependency chain usi
         :language: kotlin
         :start-after: DOCSTART 12
         :end-before: DOCEND 12
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -656,7 +637,7 @@ dependencies and verify the transaction:
         :language: kotlin
         :start-after: DOCSTART 13
         :end-before: DOCEND 13
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -672,7 +653,7 @@ We can also send and receive a ``StateAndRef`` dependency chain and automaticall
         :language: kotlin
         :start-after: DOCSTART 14
         :end-before: DOCEND 14
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -731,7 +712,7 @@ To provide a progress tracker, we have to override ``FlowLogic.progressTracker``
         :language: kotlin
         :start-after: DOCSTART 17
         :end-before: DOCEND 17
-        :dedent: 8
+        :dedent: 4
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -747,7 +728,7 @@ We then update the progress tracker's current step as we progress through the fl
         :language: kotlin
         :start-after: DOCSTART 18
         :end-before: DOCEND 18
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
diff --git a/docs/source/api-identity.rst b/docs/source/api-identity.rst
index 270e31bafd..c87b50a45f 100644
--- a/docs/source/api-identity.rst
+++ b/docs/source/api-identity.rst
@@ -69,6 +69,7 @@ You can see an example of it being used in ``TwoPartyDealFlow.kt``:
         :language: kotlin
         :start-after: DOCSTART 2
         :end-before: DOCEND 2
+        :dedent: 8
 
 The swap identities flow goes through the following key steps:
 
@@ -100,6 +101,7 @@ entities (counterparties) to require to know which well known identities those c
         :language: kotlin
         :start-after: DOCSTART 6
         :end-before: DOCEND 6
+        :dedent: 12
 
 The identity synchronization flow goes through the following key steps:
 
@@ -126,4 +128,4 @@ identity. This is important for more complex transaction cases with 3+ parties,
 Alice may know all of the confidential identities ahead of time, but Bob not know about Charlie's and vice-versa.
 The assembled transaction therefore has three input states *x*, *y* and *z*, for which only Alice possesses certificates
 for all confidential identities. ``IdentitySyncFlow`` must send not just Alice's confidential identity but also any other
-identities in the transaction to the Bob and Charlie.
+identities in the transaction to the Bob and Charlie.
\ No newline at end of file
diff --git a/docs/source/api-transactions.rst b/docs/source/api-transactions.rst
index 7d76a0624b..0c02f4b565 100644
--- a/docs/source/api-transactions.rst
+++ b/docs/source/api-transactions.rst
@@ -59,7 +59,7 @@ An input state is added to a transaction as a ``StateAndRef``, which combines:
         :language: kotlin
         :start-after: DOCSTART 21
         :end-before: DOCEND 21
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -78,7 +78,7 @@ A ``StateRef`` uniquely identifies an input state, allowing the notary to mark i
         :language: kotlin
         :start-after: DOCSTART 20
         :end-before: DOCEND 20
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -102,7 +102,7 @@ add them to the transaction directly:
         :language: kotlin
         :start-after: DOCSTART 22
         :end-before: DOCEND 22
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -119,7 +119,7 @@ it on the input state:
         :language: kotlin
         :start-after: DOCSTART 23
         :end-before: DOCEND 23
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -139,7 +139,7 @@ wrapping the output state in a ``StateAndContract``, which combines:
         :language: kotlin
         :start-after: DOCSTART 47
         :end-before: DOCEND 47
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -160,7 +160,7 @@ A command is added to the transaction as a ``Command``, which combines:
         :language: kotlin
         :start-after: DOCSTART 24
         :end-before: DOCEND 24
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -178,7 +178,7 @@ Attachments are identified by their hash:
         :language: kotlin
         :start-after: DOCSTART 25
         :end-before: DOCEND 25
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -199,7 +199,7 @@ time, or be open at either end:
         :language: kotlin
         :start-after: DOCSTART 26
         :end-before: DOCEND 26
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -215,7 +215,7 @@ We can also define a time window as an ``Instant`` plus/minus a time tolerance (
         :language: kotlin
         :start-after: DOCSTART 42
         :end-before: DOCEND 42
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -231,7 +231,7 @@ Or as a start-time plus a duration:
         :language: kotlin
         :start-after: DOCSTART 43
         :end-before: DOCEND 43
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -255,7 +255,7 @@ that will notarise the inputs and verify the time-window:
        :language: kotlin
        :start-after: DOCSTART 19
        :end-before: DOCEND 19
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
@@ -274,7 +274,7 @@ instantiated without one:
         :language: kotlin
         :start-after: DOCSTART 46
         :end-before: DOCEND 46
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -317,7 +317,7 @@ Here's an example usage of ``TransactionBuilder.withItems``:
        :language: kotlin
        :start-after: DOCSTART 27
        :end-before: DOCEND 27
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
@@ -335,7 +335,7 @@ Here are the methods for adding inputs and attachments:
         :language: kotlin
         :start-after: DOCSTART 28
         :end-before: DOCEND 28
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -351,7 +351,7 @@ An output state can be added as a ``ContractState``, contract class name and not
         :language: kotlin
         :start-after: DOCSTART 49
         :end-before: DOCEND 49
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -367,7 +367,7 @@ We can also leave the notary field blank, in which case the transaction's defaul
         :language: kotlin
         :start-after: DOCSTART 50
         :end-before: DOCEND 50
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -383,7 +383,7 @@ Or we can add the output state as a ``TransactionState``, which already specifie
         :language: kotlin
         :start-after: DOCSTART 51
         :end-before: DOCEND 51
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -399,7 +399,7 @@ Commands can be added as a ``Command``:
         :language: kotlin
         :start-after: DOCSTART 52
         :end-before: DOCEND 52
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -415,7 +415,7 @@ Or as ``CommandData`` and a ``vararg PublicKey``:
         :language: kotlin
         :start-after: DOCSTART 53
         :end-before: DOCEND 53
-        :dedent: 12
+        :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
         :language: java
@@ -431,7 +431,7 @@ For the time-window, we can set a time-window directly:
        :language: kotlin
        :start-after: DOCSTART 44
        :end-before: DOCEND 44
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
@@ -447,7 +447,7 @@ Or define the time-window as a time plus a duration (e.g. 45 seconds):
        :language: kotlin
        :start-after: DOCSTART 45
        :end-before: DOCEND 45
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
@@ -467,7 +467,7 @@ We can either sign with our legal identity key:
        :language: kotlin
        :start-after: DOCSTART 29
        :end-before: DOCEND 29
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
@@ -483,7 +483,7 @@ Or we can also choose to use another one of our public keys:
        :language: kotlin
        :start-after: DOCSTART 30
        :end-before: DOCEND 30
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
@@ -527,13 +527,13 @@ and output states:
        :language: kotlin
        :start-after: DOCSTART 33
        :end-before: DOCEND 33
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
        :start-after: DOCSTART 33
        :end-before: DOCEND 33
-       :dedent: 12
+       :dedent: 16
 
 Checking that the transaction meets the contract constraints is only part of verifying the transaction's contents. We
 will usually also want to perform our own additional validation of the transaction contents before signing, to ensure
@@ -552,13 +552,13 @@ We achieve this by using the ``ServiceHub`` to convert the ``SignedTransaction``
        :language: kotlin
        :start-after: DOCSTART 32
        :end-before: DOCEND 32
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
        :start-after: DOCSTART 32
        :end-before: DOCEND 32
-       :dedent: 12
+       :dedent: 16
 
 We can now perform our additional verification. Here's a simple example:
 
@@ -568,13 +568,13 @@ We can now perform our additional verification. Here's a simple example:
        :language: kotlin
        :start-after: DOCSTART 34
        :end-before: DOCEND 34
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
        :start-after: DOCSTART 34
        :end-before: DOCEND 34
-       :dedent: 12
+       :dedent: 16
 
 Verifying the transaction's signatures
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -589,13 +589,13 @@ We can verify that all the transaction's required signatures are present and val
        :language: kotlin
        :start-after: DOCSTART 35
        :end-before: DOCEND 35
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
        :start-after: DOCSTART 35
        :end-before: DOCEND 35
-       :dedent: 12
+       :dedent: 16
 
 However, we'll often want to verify the transaction's existing signatures before all of them have been collected. For
 this we can use ``SignedTransaction.verifySignaturesExcept``, which takes a ``vararg`` of the public keys for
@@ -607,13 +607,13 @@ which the signatures are allowed to be missing:
        :language: kotlin
        :start-after: DOCSTART 36
        :end-before: DOCEND 36
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
        :start-after: DOCSTART 36
        :end-before: DOCEND 36
-       :dedent: 12
+       :dedent: 16
 
 If the transaction is missing any signatures without the corresponding public keys being passed in, a
 ``SignaturesMissingException`` is thrown.
@@ -626,13 +626,13 @@ We can also choose to simply verify the signatures that are present:
        :language: kotlin
        :start-after: DOCSTART 37
        :end-before: DOCEND 37
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
        :start-after: DOCSTART 37
        :end-before: DOCEND 37
-       :dedent: 12
+       :dedent: 16
 
 Be very careful, however - this function neither guarantees that the signatures that are present are required, nor
 checks whether any signatures are missing.
@@ -650,7 +650,7 @@ We can sign using our legal identity key, as follows:
        :language: kotlin
        :start-after: DOCSTART 38
        :end-before: DOCEND 38
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
@@ -666,7 +666,7 @@ Or we can choose to sign using another one of our public keys:
        :language: kotlin
        :start-after: DOCSTART 39
        :end-before: DOCEND 39
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
@@ -684,7 +684,7 @@ We can do this with our legal identity key:
        :language: kotlin
        :start-after: DOCSTART 40
        :end-before: DOCEND 40
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
@@ -700,7 +700,7 @@ Or using another one of our public keys:
        :language: kotlin
        :start-after: DOCSTART 41
        :end-before: DOCEND 41
-       :dedent: 12
+       :dedent: 8
 
     .. literalinclude:: ../../docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
        :language: java
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
index 1946a2501d..e007e3af6f 100644
--- a/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
+++ b/docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java
@@ -122,7 +122,7 @@ public class FlowCookbookJava {
             //   - To serve as a timestamping authority if the transaction has a
             //     time-window
             // We retrieve a notary from the network map.
-            // DOCSTART 1
+            // DOCSTART 01
             CordaX500Name notaryName = new CordaX500Name("Notary Service", "London", "GB");
             Party specificNotary = getServiceHub().getNetworkMapCache().getNotary(notaryName);
             // Alternatively, we can pick an arbitrary notary from the notary
@@ -130,15 +130,15 @@ public class FlowCookbookJava {
             // explicitly, as the notary list might change when new notaries are
             // introduced, or old ones decommissioned.
             Party firstNotary = getServiceHub().getNetworkMapCache().getNotaryIdentities().get(0);
-            // DOCEND 1
+            // DOCEND 01
 
             // We may also need to identify a specific counterparty. We do so
             // using the identity service.
-            // DOCSTART 2
+            // DOCSTART 02
             CordaX500Name counterPartyName = new CordaX500Name("NodeA", "London", "GB");
             Party namedCounterparty = getServiceHub().getIdentityService().wellKnownPartyFromX500Name(counterPartyName);
             Party keyedCounterparty = getServiceHub().getIdentityService().partyFromKey(dummyPubKey);
-            // DOCEND 2
+            // DOCEND 02
 
             /*------------------------------
              * SENDING AND RECEIVING DATA *
@@ -162,9 +162,9 @@ public class FlowCookbookJava {
             // In other words, we are assuming that the counterparty is
             // registered to respond to this flow, and has a corresponding
             // ``receive`` call.
-            // DOCSTART 4
+            // DOCSTART 04
             counterpartySession.send(new Object());
-            // DOCEND 4
+            // DOCEND 04
 
             // We can wait to receive arbitrary data of a specific type from a
             // counterparty. Again, this implies a corresponding ``send`` call
@@ -185,7 +185,7 @@ public class FlowCookbookJava {
             // instance. This is a reminder that the data we receive may not
             // be what it appears to be! We must unwrap the
             // ``UntrustworthyData`` using a lambda.
-            // DOCSTART 5
+            // DOCSTART 05
             UntrustworthyData<Integer> packet1 = counterpartySession.receive(Integer.class);
             Integer integer = packet1.unwrap(data -> {
                 // Perform checking on the object received.
@@ -193,13 +193,13 @@ public class FlowCookbookJava {
                 // Return the object.
                 return data;
             });
-            // DOCEND 5
+            // DOCEND 05
 
             // We can also use a single call to send data to a counterparty
             // and wait to receive data of a specific type back. The type of
             // data sent doesn't need to match the type of the data received
             // back.
-            // DOCSTART 7
+            // DOCSTART 07
             UntrustworthyData<Boolean> packet2 = counterpartySession.sendAndReceive(Boolean.class, "You can send and receive any class!");
             Boolean bool = packet2.unwrap(data -> {
                 // Perform checking on the object received.
@@ -207,16 +207,16 @@ public class FlowCookbookJava {
                 // Return the object.
                 return data;
             });
-            // DOCEND 7
+            // DOCEND 07
 
             // We're not limited to sending to and receiving from a single
             // counterparty. A flow can send messages to as many parties as it
             // likes, and each party can invoke a different response flow.
-            // DOCSTART 6
+            // DOCSTART 06
             FlowSession regulatorSession = initiateFlow(regulator);
             regulatorSession.send(new Object());
             UntrustworthyData<Object> packet3 = regulatorSession.receive(Object.class);
-            // DOCEND 6
+            // DOCEND 06
 
             /*------------------------------------
              * EXTRACTING STATES FROM THE VAULT *
@@ -564,9 +564,9 @@ public class FlowCookbookJava {
 
             // We notarise the transaction and get it recorded in the vault of
             // the participants of all the transaction's states.
-            // DOCSTART 9
+            // DOCSTART 09
             SignedTransaction notarisedTx1 = subFlow(new FinalityFlow(fullySignedTx, FINALISATION.childProgressTracker()));
-            // DOCEND 9
+            // DOCEND 09
             // We can also choose to send it to additional parties who aren't one
             // of the state's participants.
             // DOCSTART 10
@@ -629,11 +629,11 @@ public class FlowCookbookJava {
             // 3. They sent a ``String`` instance and waited to receive a
             //    ``Boolean`` instance back
             // Our side of the flow must mirror these calls.
-            // DOCSTART 8
+            // DOCSTART 08
             Object obj = counterpartySession.receive(Object.class).unwrap(data -> data);
             String string = counterpartySession.sendAndReceive(String.class, 99).unwrap(data -> data);
             counterpartySession.send(true);
-            // DOCEND 8
+            // DOCEND 08
 
             /*-----------------------------------------
              * RESPONDING TO COLLECT_SIGNATURES_FLOW *
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 1fbee1e1be..1ef82f8a1b 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
@@ -102,7 +102,7 @@ class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty:
         //   - To serve as a timestamping authority if the transaction has a
         //     time-window
         // We retrieve the notary from the network map.
-        // DOCSTART 1
+        // DOCSTART 01
         val notaryName: CordaX500Name = CordaX500Name(
                 organisation = "Notary Service",
                 locality = "London",
@@ -113,11 +113,11 @@ class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty:
         // explicitly, as the notary list might change when new notaries are
         // introduced, or old ones decommissioned.
         val firstNotary: Party = serviceHub.networkMapCache.notaryIdentities.first()
-        // DOCEND 1
+        // DOCEND 01
 
         // We may also need to identify a specific counterparty. We do so
         // using the identity service.
-        // DOCSTART 2
+        // DOCSTART 02
         val counterpartyName: CordaX500Name = CordaX500Name(
                 organisation = "NodeA",
                 locality = "London",
@@ -126,7 +126,7 @@ class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty:
                 throw IllegalArgumentException("Couldn't find counterparty for NodeA in identity service")
         val keyedCounterparty: Party = serviceHub.identityService.partyFromKey(dummyPubKey) ?:
                 throw IllegalArgumentException("Couldn't find counterparty with key: $dummyPubKey in identity service")
-        // DOCEND 2
+        // DOCEND 02
 
         /**-----------------------------
          * SENDING AND RECEIVING DATA *
@@ -150,9 +150,9 @@ class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty:
         // In other words, we are assuming that the counterparty is
         // registered to respond to this flow, and has a corresponding
         // ``receive`` call.
-        // DOCSTART 4
+        // DOCSTART 04
         counterpartySession.send(Any())
-        // DOCEND 4
+        // DOCEND 04
 
         // We can wait to receive arbitrary data of a specific type from a
         // counterparty. Again, this implies a corresponding ``send`` call
@@ -173,7 +173,7 @@ class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty:
         // instance. This is a reminder that the data we receive may not
         // be what it appears to be! We must unwrap the
         // ``UntrustworthyData`` using a lambda.
-        // DOCSTART 5
+        // DOCSTART 05
         val packet1: UntrustworthyData<Int> = counterpartySession.receive<Int>()
         val int: Int = packet1.unwrap { data ->
             // Perform checking on the object received.
@@ -181,13 +181,13 @@ class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty:
             // Return the object.
             data
         }
-        // DOCEND 5
+        // DOCEND 05
 
         // We can also use a single call to send data to a counterparty
         // and wait to receive data of a specific type back. The type of
         // data sent doesn't need to match the type of the data received
         // back.
-        // DOCSTART 7
+        // DOCSTART 07
         val packet2: UntrustworthyData<Boolean> = counterpartySession.sendAndReceive<Boolean>("You can send and receive any class!")
         val boolean: Boolean = packet2.unwrap { data ->
             // Perform checking on the object received.
@@ -195,16 +195,16 @@ class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty:
             // Return the object.
             data
         }
-        // DOCEND 7
+        // DOCEND 07
 
         // We're not limited to sending to and receiving from a single
         // counterparty. A flow can send messages to as many parties as it
         // likes, and each party can invoke a different response flow.
-        // DOCSTART 6
+        // DOCSTART 06
         val regulatorSession: FlowSession = initiateFlow(regulator)
         regulatorSession.send(Any())
         val packet3: UntrustworthyData<Any> = regulatorSession.receive<Any>()
-        // DOCEND 6
+        // DOCEND 06
 
         /**-----------------------------------
          * EXTRACTING STATES FROM THE VAULT *
@@ -543,9 +543,9 @@ class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty:
 
         // We notarise the transaction and get it recorded in the vault of
         // the participants of all the transaction's states.
-        // DOCSTART 9
+        // DOCSTART 09
         val notarisedTx1: SignedTransaction = subFlow(FinalityFlow(fullySignedTx, FINALISATION.childProgressTracker()))
-        // DOCEND 9
+        // DOCEND 09
         // We can also choose to send it to additional parties who aren't one
         // of the state's participants.
         // DOCSTART 10
@@ -603,11 +603,11 @@ class ResponderFlow(val counterpartySession: FlowSession) : FlowLogic<Unit>() {
         // 3. They sent a ``String`` instance and waited to receive a
         //    ``Boolean`` instance back
         // Our side of the flow must mirror these calls.
-        // DOCSTART 8
+        // DOCSTART 08
         val any: Any = counterpartySession.receive<Any>().unwrap { data -> data }
         val string: String = counterpartySession.sendAndReceive<String>(99).unwrap { data -> data }
         counterpartySession.send(true)
-        // DOCEND 8
+        // DOCEND 08
 
         /**----------------------------------------
          * RESPONDING TO COLLECT_SIGNATURES_FLOW *

From 727cd0e55c9c992f2e337b2e26f3e8472ac9d8c1 Mon Sep 17 00:00:00 2001
From: Shams Asari <shams.asari@r3.com>
Date: Thu, 5 Oct 2017 12:27:45 +0100
Subject: [PATCH 109/185] Cleaned up notary configuration by introducing a
 notary config option.

extraAdvertisedServiceIds is no longer used for this.
---
 build.gradle                                  |   3 +-
 .../corda/client/jfx/NodeMonitorModelTest.kt  |   4 +-
 .../client/rpc/CordaRPCJavaClientTest.java    |   6 +-
 .../corda/client/rpc/CordaRPCClientTest.kt    |   4 +-
 .../rpc/StandaloneCordaRPCJavaClientTest.java |  12 +-
 .../kotlin/rpc/StandaloneCordaRPClientTest.kt |   2 +-
 config/dev/nameservernode.conf                |   4 +-
 .../kotlin/net/corda/core/flows/NotaryFlow.kt |   6 +-
 .../core/node/services/NetworkMapCache.kt     |   6 +-
 .../corda/core/node/services/NotaryService.kt |  12 ++
 .../net/corda/core/flows/AttachmentTests.kt   |   5 +-
 docs/source/changelog.rst                     |   5 +
 docs/source/corda-configuration-file.rst      |  34 ++++--
 docs/source/deploying-a-node.rst              |   3 +-
 docs/source/example-code/build.gradle         |   3 +-
 .../corda/docs/IntegrationTestingTutorial.kt  |   6 +-
 .../net/corda/docs/ClientRpcTutorial.kt       |   4 +-
 .../net/corda/docs/CustomVaultQueryTest.kt    |   8 +-
 .../docs/FxTransactionBuildTutorialTest.kt    |   8 +-
 .../WorkflowTransactionBuildTutorialTest.kt   |  13 +-
 docs/source/hello-world-running.rst           |   3 +-
 docs/source/running-a-notary.rst              |   8 +-
 docs/source/tutorial-custom-notary.rst        |   6 -
 .../java/net/corda/cordform/CordformNode.java |  31 ++---
 .../main/groovy/net/corda/plugins/Node.groovy |  16 +--
 .../src/main/kotlin/net/corda/nodeapi/User.kt |   8 +-
 .../corda/nodeapi/config/ConfigUtilities.kt   |  68 ++++++++++-
 .../corda/nodeapi/config/ConfigParsingTest.kt |  52 +++++---
 .../net/corda/node/NodePerformanceTests.kt    |  12 +-
 .../node/services/AttachmentLoadingTests.kt   |   4 +-
 .../node/services/BFTNotaryServiceTests.kt    |  23 ++--
 .../node/services/DistributedServiceTests.kt  |   5 +-
 .../node/services/RaftNotaryServiceTests.kt   |   4 +-
 .../services/messaging/P2PMessagingTest.kt    |  46 +------
 .../test/node/NodeStatePersistenceTests.kt    |   5 +-
 .../net/corda/node/internal/AbstractNode.kt   | 113 ++++++++++--------
 .../net/corda/node/internal/NodeStartup.kt    |  11 +-
 .../node/services/config/NodeConfiguration.kt |  41 ++++---
 .../network/PersistentNetworkMapCache.kt      |   7 +-
 .../BFTNonValidatingNotaryService.kt          |  62 +++++-----
 .../RaftNonValidatingNotaryService.kt         |  13 +-
 .../transactions/RaftUniquenessProvider.kt    |  26 ++--
 .../RaftValidatingNotaryService.kt            |  13 +-
 .../transactions/SimpleNotaryService.kt       |   5 -
 .../transactions/ValidatingNotaryService.kt   |   4 +-
 node/src/main/resources/reference.conf        |   4 -
 .../kotlin/net/corda/node/CordappSmokeTest.kt |   2 +-
 .../net/corda/node/CordaRPCOpsImplTest.kt     |   4 +-
 .../corda/node/internal/CordaServiceTest.kt   |  11 +-
 .../corda/node/services/NotaryChangeTests.kt  |   8 +-
 .../config/FullNodeConfigurationTest.kt       |   4 +-
 .../services/events/ScheduledFlowTests.kt     |   6 +-
 .../statemachine/FlowFrameworkTests.kt        |  87 ++------------
 .../transactions/NotaryServiceTests.kt        |   5 +-
 .../ValidatingNotaryServiceTests.kt           |   6 +-
 samples/attachment-demo/build.gradle          |   3 +-
 .../attachmentdemo/AttachmentDemoTest.kt      |   4 +-
 .../kotlin/net/corda/attachmentdemo/Main.kt   |   6 +-
 samples/bank-of-corda-demo/build.gradle       |   3 +-
 .../net/corda/bank/BankOfCordaHttpAPITest.kt  |   4 +-
 .../corda/bank/BankOfCordaRPCClientTest.kt    |   4 +-
 .../net/corda/bank/BankOfCordaDriver.kt       |   8 +-
 samples/irs-demo/build.gradle                 |   3 +-
 .../kotlin/net/corda/irs/IRSDemoTest.kt       |   6 +-
 .../src/test/kotlin/net/corda/irs/Main.kt     |   6 +-
 .../net/corda/netmap/simulation/Simulation.kt |  14 +--
 .../net/corda/notarydemo/BFTNotaryCordform.kt |  15 +--
 .../corda/notarydemo/RaftNotaryCordform.kt    |  24 ++--
 .../corda/notarydemo/SingleNotaryCordform.kt  |  15 ++-
 samples/simm-valuation-demo/build.gradle      |   5 +-
 .../net/corda/vega/SimmValuationTest.kt       |  11 +-
 .../src/test/kotlin/net/corda/vega/Main.kt    |   4 +-
 samples/trader-demo/build.gradle              |   3 +-
 .../net/corda/traderdemo/TraderDemoTest.kt    |   4 +-
 .../test/kotlin/net/corda/traderdemo/Main.kt  |   4 +-
 .../corda/testing/FlowStackSnapshotTest.kt    |   8 +-
 .../net/corda/testing/driver/DriverTests.kt   |   6 +-
 .../net/corda/testing/DriverConstants.kt      |  18 +--
 .../kotlin/net/corda/testing/NodeTestUtils.kt |   6 +-
 .../kotlin/net/corda/testing/driver/Driver.kt |  62 +++++++---
 .../testing/internal/demorun/CordformUtils.kt |  13 +-
 .../kotlin/net/corda/testing/node/MockNode.kt |  56 ++++-----
 .../net/corda/testing/node/NodeBasedTest.kt   |  49 +++++---
 .../net/corda/smoketesting/NodeConfig.kt      |  33 +++--
 .../net/corda/demobench/model/NodeConfig.kt   |  32 ++---
 .../net/corda/demobench/model/UserTest.kt     |   4 +-
 .../net/corda/explorer/ExplorerSimulation.kt  |   6 +-
 .../net/corda/verifier/VerifierTests.kt       |   6 +-
 88 files changed, 600 insertions(+), 716 deletions(-)

diff --git a/build.gradle b/build.gradle
index 6cfd34fed9..bf12b2ff1f 100644
--- a/build.gradle
+++ b/build.gradle
@@ -233,7 +233,8 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     networkMap "O=Controller,OU=corda,L=London,C=GB"
     node {
         name "O=Controller,OU=corda,L=London,C=GB"
-        advertisedServices = ["corda.notary.validating"]
+        notary = [validating : true]
+        advertisedServices = []
         p2pPort 10002
         cordapps = []
     }
diff --git a/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt b/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt
index ea0c88189c..e0131e6e99 100644
--- a/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt
+++ b/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt
@@ -27,9 +27,7 @@ import net.corda.finance.flows.CashExitFlow
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.User
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.driver.driver
 import net.corda.testing.node.DriverBasedTest
@@ -59,7 +57,7 @@ class NodeMonitorModelTest : DriverBasedTest() {
                 startFlowPermission<CashExitFlow>())
         )
         val aliceNodeFuture = startNode(providedName = ALICE.name, rpcUsers = listOf(cashUser))
-        val notaryHandle = startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type))).getOrThrow()
+        val notaryHandle = startNotaryNode(DUMMY_NOTARY.name, validating = false).getOrThrow()
         val aliceNodeHandle = aliceNodeFuture.getOrThrow()
         aliceNode = aliceNodeHandle.nodeInfo
         newNode = { nodeName -> startNode(providedName = nodeName).getOrThrow().nodeInfo }
diff --git a/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java b/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
index 1862324c4f..e596a61418 100644
--- a/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
+++ b/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
@@ -11,9 +11,7 @@ import net.corda.finance.flows.CashPaymentFlow;
 import net.corda.finance.schemas.CashSchemaV1;
 import net.corda.node.internal.Node;
 import net.corda.node.internal.StartedNode;
-import net.corda.node.services.transactions.ValidatingNotaryService;
 import net.corda.nodeapi.User;
-import net.corda.nodeapi.internal.ServiceInfo;
 import net.corda.testing.CoreTestUtils;
 import net.corda.testing.node.NodeBasedTest;
 import org.junit.After;
@@ -24,7 +22,6 @@ import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.ExecutionException;
 
-import static java.util.Collections.emptyMap;
 import static java.util.Collections.singletonList;
 import static java.util.Objects.requireNonNull;
 import static kotlin.test.AssertionsKt.assertEquals;
@@ -53,8 +50,7 @@ public class CordaRPCJavaClientTest extends NodeBasedTest {
     @Before
     public void setUp() throws ExecutionException, InterruptedException {
         setCordappPackages("net.corda.finance.contracts");
-        Set<ServiceInfo> services = new HashSet<>(singletonList(new ServiceInfo(ValidatingNotaryService.Companion.getType(), null)));
-        CordaFuture<StartedNode<Node>> nodeFuture = startNode(getALICE().getName(), 1, services, singletonList(rpcUser), emptyMap());
+        CordaFuture<StartedNode<Node>> nodeFuture = startNotaryNode(getALICE().getName(), singletonList(rpcUser), true);
         node = nodeFuture.get();
         node.getInternals().registerCustomSchemas(Collections.singleton(CashSchemaV1.INSTANCE));
         client = new CordaRPCClient(requireNonNull(node.getInternals().getConfiguration().getRpcAddress()));
diff --git a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
index 32284a970f..422f08f8f3 100644
--- a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
+++ b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
@@ -19,9 +19,7 @@ import net.corda.finance.schemas.CashSchemaV1
 import net.corda.node.internal.Node
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.User
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.ALICE
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.NodeBasedTest
@@ -52,7 +50,7 @@ class CordaRPCClientTest : NodeBasedTest() {
     @Before
     fun setUp() {
         setCordappPackages("net.corda.finance.contracts")
-        node = startNode(ALICE.name, rpcUsers = listOf(rpcUser), advertisedServices = setOf(ServiceInfo(ValidatingNotaryService.type))).getOrThrow()
+        node = startNotaryNode(ALICE.name, rpcUsers = listOf(rpcUser)).getOrThrow()
         node.internals.registerCustomSchemas(setOf(CashSchemaV1))
         client = CordaRPCClient(node.internals.configuration.rpcAddress!!)
     }
diff --git a/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java b/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java
index bc522e42f0..e9ebce530f 100644
--- a/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java
+++ b/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java
@@ -6,7 +6,6 @@ import net.corda.core.identity.CordaX500Name;
 import net.corda.core.identity.Party;
 import net.corda.core.messaging.CordaRPCOps;
 import net.corda.core.messaging.FlowHandle;
-import net.corda.core.node.NodeInfo;
 import net.corda.core.utilities.OpaqueBytes;
 import net.corda.finance.flows.AbstractCashFlow;
 import net.corda.finance.flows.CashIssueFlow;
@@ -41,7 +40,6 @@ public class StandaloneCordaRPCJavaClientTest {
     private NodeProcess notary;
     private CordaRPCOps rpcProxy;
     private CordaRPCConnection connection;
-    private NodeInfo notaryNode;
     private Party notaryNodeIdentity;
 
     private NodeConfig notaryConfig = new NodeConfig(
@@ -49,8 +47,8 @@ public class StandaloneCordaRPCJavaClientTest {
             port.getAndIncrement(),
             port.getAndIncrement(),
             port.getAndIncrement(),
-            Collections.singletonList("corda.notary.validating"),
-            Arrays.asList(rpcUser),
+            true,
+            Collections.singletonList(rpcUser),
             null
     );
 
@@ -61,7 +59,6 @@ public class StandaloneCordaRPCJavaClientTest {
         notary = factory.create(notaryConfig);
         connection = notary.connect();
         rpcProxy = connection.getProxy();
-        notaryNode = fetchNotaryIdentity();
         notaryNodeIdentity = rpcProxy.nodeInfo().getLegalIdentities().get(0);
     }
 
@@ -98,11 +95,6 @@ public class StandaloneCordaRPCJavaClientTest {
         }
     }
 
-    private NodeInfo fetchNotaryIdentity() {
-        List<NodeInfo> nodeDataSnapshot = rpcProxy.networkMapSnapshot();
-        return nodeDataSnapshot.get(0);
-    }
-
     @Test
     public void testCashBalances() throws NoSuchFieldException, ExecutionException, InterruptedException {
         Amount<Currency> dollars123 = new Amount<>(123, Currency.getInstance("USD"));
diff --git a/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt b/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt
index 6da6aa3dc4..40ae8c5f16 100644
--- a/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt
+++ b/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt
@@ -64,7 +64,7 @@ class StandaloneCordaRPClientTest {
             p2pPort = port.andIncrement,
             rpcPort = port.andIncrement,
             webPort = port.andIncrement,
-            extraServices = listOf("corda.notary.validating"),
+            isNotary = true,
             users = listOf(user)
     )
 
diff --git a/config/dev/nameservernode.conf b/config/dev/nameservernode.conf
index 664f2b6816..0519e56872 100644
--- a/config/dev/nameservernode.conf
+++ b/config/dev/nameservernode.conf
@@ -3,5 +3,7 @@ keyStorePassword : "cordacadevpass"
 trustStorePassword : "trustpass"
 p2pAddress : "localhost:10000"
 webAddress : "localhost:10001"
-extraAdvertisedServiceIds : [ "corda.notary.validating" ]
+notary : {
+    validating : true
+}
 useHTTPS : false
diff --git a/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt b/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt
index f738df62be..c4d122c649 100644
--- a/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt
@@ -13,7 +13,6 @@ import net.corda.core.node.services.NotaryService
 import net.corda.core.node.services.TrustedAuthorityNotaryService
 import net.corda.core.node.services.UniquenessProvider
 import net.corda.core.serialization.CordaSerializable
-import net.corda.core.transactions.FilteredTransaction
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.utilities.ProgressTracker
 import net.corda.core.utilities.UntrustworthyData
@@ -138,8 +137,11 @@ class NotaryFlow {
         // Check if transaction is intended to be signed by this notary.
         @Suspendable
         protected fun checkNotary(notary: Party?) {
-            if (notary !in serviceHub.myInfo.legalIdentities)
+            // TODO This check implies that it's OK to use the node's main identity. Shouldn't it be just limited to the
+            // notary identities?
+            if (notary !in serviceHub.myInfo.legalIdentities) {
                 throw NotaryException(NotaryError.WrongNotary)
+            }
         }
 
         @Suspendable
diff --git a/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt b/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
index 8217eb69b4..792baadb39 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/NetworkMapCache.kt
@@ -116,10 +116,8 @@ interface NetworkMapCache {
     fun isNotary(party: Party): Boolean = party in notaryIdentities
 
     /** Checks whether a given party is an validating notary identity. */
-    fun isValidatingNotary(party: Party): Boolean {
-        require(isNotary(party)) { "No notary found with identity $party." }
-        return !party.name.toString().contains("corda.notary.simple", true) // TODO This implementation will change after introducing of NetworkParameters.
-    }
+    // TODO This implementation will change after introducing of NetworkParameters.
+    fun isValidatingNotary(party: Party): Boolean = isNotary(party) && "validating" in party.name.commonName!!
 
     /** Clear all network map data from local node cache. */
     fun clearNetworkMapCache()
diff --git a/core/src/main/kotlin/net/corda/core/node/services/NotaryService.kt b/core/src/main/kotlin/net/corda/core/node/services/NotaryService.kt
index 71e24c506d..574008d6d8 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/NotaryService.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/NotaryService.kt
@@ -13,6 +13,18 @@ import org.slf4j.Logger
 import java.security.PublicKey
 
 abstract class NotaryService : SingletonSerializeAsToken() {
+    companion object {
+        const val ID_PREFIX = "corda.notary."
+        fun constructId(validating: Boolean, raft: Boolean = false, bft: Boolean = false): String {
+            require(!raft || !bft)
+            return StringBuffer(ID_PREFIX).apply {
+                append(if (validating) "validating" else "simple")
+                if (raft) append(".raft")
+                if (bft) append(".bft")
+            }.toString()
+        }
+    }
+
     abstract val services: ServiceHub
     abstract val notaryIdentityKey: PublicKey
 
diff --git a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
index 5da5583af6..034c28c834 100644
--- a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
@@ -12,7 +12,6 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.persistence.NodeAttachmentService
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.node.utilities.DatabaseTransactionManager
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.ALICE
@@ -117,7 +116,7 @@ class AttachmentTests {
     @Test
     fun `malicious response`() {
         // Make a node that doesn't do sanity checking at load time.
-        val aliceNode = mockNet.createNode(legalName = ALICE.name, nodeFactory = object : MockNetwork.Factory<MockNetwork.MockNode> {
+        val aliceNode = mockNet.createNotaryNode(legalName = ALICE.name, nodeFactory = object : MockNetwork.Factory<MockNetwork.MockNode> {
             override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
                                 advertisedServices: Set<ServiceInfo>, id: Int,
                                 notaryIdentity: Pair<ServiceInfo, KeyPair>?,
@@ -126,7 +125,7 @@ class AttachmentTests {
                     override fun start() = super.start().apply { attachments.checkAttachmentsOnLoad = false }
                 }
             }
-        }, advertisedServices = *arrayOf(ServiceInfo(SimpleNotaryService.type)))
+        }, validating = false)
         val bobNode = mockNet.createNode(legalName = BOB.name)
 
         // Ensure that registration was successful before progressing any further
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index c996b4254b..f07f2e964e 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -20,6 +20,11 @@ UNRELEASED
   either annotated with the @CordaSerializable annotation or explicitly whitelisted then a NotSerializableException is
   thrown.
 
+* ``extraAdvertisedServiceIds`` config has been removed as part of the previous work to retire the concept of advertised
+  services. The remaining use of this config was for notaries, the configuring of which has been cleaned up and simplified.
+  ``notaryNodeAddress``, ``notaryClusterAddresses`` and ``bftSMaRt`` have also been removed and replaced by a single
+  ``notary`` config object. See :doc:`corda-configuration-file` for more details.
+
 .. _changelog_v1:
 
 Release 1.0
diff --git a/docs/source/corda-configuration-file.rst b/docs/source/corda-configuration-file.rst
index e2c2365c92..8511b2d486 100644
--- a/docs/source/corda-configuration-file.rst
+++ b/docs/source/corda-configuration-file.rst
@@ -30,7 +30,7 @@ General node configuration file for hosting the IRSDemo services.
 .. literalinclude:: example-code/src/main/resources/example-node.conf
     :language: javascript
 
-NetworkMapService plus Simple Notary configuration file.
+Simple Notary configuration file.
 
 .. parsed-literal::
 
@@ -40,7 +40,9 @@ NetworkMapService plus Simple Notary configuration file.
     p2pAddress : "localhost:12345"
     rpcAddress : "localhost:12346"
     webAddress : "localhost:12347"
-    extraAdvertisedServiceIds : ["corda.notary.simple"]
+    notary : {
+        validating : false
+    }
     useHTTPS : false
     devMode : true
     // Certificate signing service will be hosted by R3 in the near future.
@@ -92,19 +94,25 @@ path to the node's base directory.
     .. note:: The driver will not automatically create a webserver instance, but the Cordformation will. If this field
               is present the web server will start.
 
-:extraAdvertisedServiceIds: A list of ServiceType id strings to be advertised to the NetworkMapService and thus be available
-    when other nodes query the NetworkMapCache for supporting nodes. This can also include plugin services loaded from .jar
-    files in the plugins folder. Optionally, a custom advertised service name can be provided by appending it to the service
-    type id: ``"corda.notary.validating|Notary A"``
+:notary: Optional config object which if present configures the node to run as a notary. If part of a Raft or BFT SMaRt
+    cluster then specify ``raft`` or ``bftSMaRt`` respectively as described below. If a single node notary then omit both.
 
-:notaryNodeAddress: The host and port to which to bind the embedded Raft server. Required only when running a distributed
-    notary service. A group of Corda nodes can run a distributed notary service by each running an embedded Raft server and
-    joining them to the same cluster to replicate the committed state log. Note that the Raft cluster uses a separate transport
-    layer for communication that does not integrate with ArtemisMQ messaging services.
+        :validating: Boolean to determine whether the notary is a validating or non-validating one.
 
-:notaryClusterAddresses: List of Raft cluster member addresses used to join the cluster. At least one of the specified
-    members must be active and be able to communicate with the cluster leader for joining. If empty, a new cluster will be
-    bootstrapped. Required only when running a distributed notary service.
+        :raft: If part of a distributed Raft cluster specify this config object, with the following settings:
+
+                :nodeAddress: The host and port to which to bind the embedded Raft server. Note that the Raft cluster uses a
+                    separate transport layer for communication that does not integrate with ArtemisMQ messaging services.
+
+                :clusterAddresses: List of Raft cluster member addresses used to join the cluster. At least one of the specified
+                    members must be active and be able to communicate with the cluster leader for joining. If empty, a new
+                    cluster will be bootstrapped.
+
+        :bftSMaRt: If part of a distributed BFT SMaRt cluster specify this config object, with the following settings:
+
+                :replicaId:
+
+                :clusterAddresses:
 
 :networkMapService: If `null`, or missing the node is declaring itself as the NetworkMapService host. Otherwise this is
     a config object with the details of the network map service:
diff --git a/docs/source/deploying-a-node.rst b/docs/source/deploying-a-node.rst
index 562df5952f..ec15b75d8b 100644
--- a/docs/source/deploying-a-node.rst
+++ b/docs/source/deploying-a-node.rst
@@ -20,7 +20,8 @@ notary/network map node:
         networkMap "O=Controller,OU=corda,L=London,C=UK"
         node {
             name "O=Controller,OU=corda,L=London,C=UK"
-            advertisedServices = ["corda.notary.validating"]
+            notary = [validating : true]
+            advertisedServices = []
             p2pPort 10002
             rpcPort 10003
             webPort 10004
diff --git a/docs/source/example-code/build.gradle b/docs/source/example-code/build.gradle
index cf0c3046e8..6709d9fcbe 100644
--- a/docs/source/example-code/build.gradle
+++ b/docs/source/example-code/build.gradle
@@ -75,7 +75,8 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     networkMap "O=Notary Service,OU=corda,L=London,C=GB"
     node {
         name "O=Notary Service,OU=corda,L=London,C=GB"
-        advertisedServices = ["corda.notary.validating"]
+        notary = [validating : true]
+        advertisedServices = []
         p2pPort 10002
         rpcPort 10003
         webPort 10004
diff --git a/docs/source/example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt b/docs/source/example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
index 07ef6d6983..c665a8cb67 100644
--- a/docs/source/example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
+++ b/docs/source/example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
@@ -11,8 +11,6 @@ import net.corda.finance.contracts.asset.Cash
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.User
 import net.corda.testing.*
 import net.corda.testing.driver.driver
@@ -32,10 +30,10 @@ class IntegrationTestingTutorial {
             val bobUser = User("bobUser", "testPassword2", permissions = setOf(
                     startFlowPermission<CashPaymentFlow>()
             ))
-            val (alice, bob, notary) = listOf(
+            val (alice, bob) = listOf(
                     startNode(providedName = ALICE.name, rpcUsers = listOf(aliceUser)),
                     startNode(providedName = BOB.name, rpcUsers = listOf(bobUser)),
-                    startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(ValidatingNotaryService.type)))
+                    startNotaryNode(DUMMY_NOTARY.name)
             ).transpose().getOrThrow()
             // END 1
 
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
index bf6b46be6e..5b11d79549 100644
--- a/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt
@@ -15,9 +15,7 @@ import net.corda.finance.flows.CashExitFlow
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.User
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.ALICE
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.driver.driver
@@ -49,7 +47,7 @@ fun main(args: Array<String>) {
             startFlowPermission<CashExitFlow>()))
 
     driver(driverDirectory = baseDirectory, extraCordappPackagesToScan = listOf("net.corda.finance")) {
-        startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(ValidatingNotaryService.type)))
+        startNotaryNode(DUMMY_NOTARY.name)
         val node = startNode(providedName = ALICE.name, rpcUsers = listOf(user)).get()
         // END 1
 
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
index 36a98ebe8b..d313217f40 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
@@ -9,8 +9,6 @@ import net.corda.finance.contracts.getCashBalances
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.schemas.CashSchemaV1
 import net.corda.node.internal.StartedNode
-import net.corda.node.services.transactions.ValidatingNotaryService
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import org.junit.After
@@ -30,11 +28,7 @@ class CustomVaultQueryTest {
     fun setup() {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork(threadPerNode = true)
-        val notaryService = ServiceInfo(ValidatingNotaryService.type)
-        mockNet.createNode(
-                legalName = DUMMY_NOTARY.name,
-                notaryIdentity = notaryService to DUMMY_NOTARY_KEY,
-                advertisedServices = *arrayOf(notaryService))
+        mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         nodeA = mockNet.createPartyNode()
         nodeB = mockNet.createPartyNode()
 
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
index 3152da5650..be28ddbec0 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
@@ -9,8 +9,6 @@ import net.corda.finance.contracts.getCashBalances
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.schemas.CashSchemaV1
 import net.corda.node.internal.StartedNode
-import net.corda.node.services.transactions.ValidatingNotaryService
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import org.junit.After
@@ -28,11 +26,7 @@ class FxTransactionBuildTutorialTest {
     fun setup() {
         setCordappPackages("net.corda.finance.contracts.asset")
         mockNet = MockNetwork(threadPerNode = true)
-        val notaryService = ServiceInfo(ValidatingNotaryService.type)
-        mockNet.createNode(
-                legalName = DUMMY_NOTARY.name,
-                notaryIdentity = notaryService to DUMMY_NOTARY_KEY,
-                advertisedServices = *arrayOf(notaryService))
+        mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         nodeA = mockNet.createPartyNode()
         nodeB = mockNet.createPartyNode()
         nodeA.internals.registerCustomSchemas(setOf(CashSchemaV1))
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
index eed9b53759..6b9f0d279d 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
@@ -9,10 +9,11 @@ import net.corda.core.node.services.vault.QueryCriteria
 import net.corda.core.toFuture
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
-import net.corda.node.services.transactions.ValidatingNotaryService
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.testing.*
+import net.corda.testing.DUMMY_NOTARY
+import net.corda.testing.chooseIdentity
 import net.corda.testing.node.MockNetwork
+import net.corda.testing.setCordappPackages
+import net.corda.testing.unsetCordappPackages
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -33,11 +34,7 @@ class WorkflowTransactionBuildTutorialTest {
     fun setup() {
         setCordappPackages("net.corda.docs")
         mockNet = MockNetwork(threadPerNode = true)
-        val notaryService = ServiceInfo(ValidatingNotaryService.type)
-        mockNet.createNode(
-                legalName = DUMMY_NOTARY.name,
-                notaryIdentity = Pair(notaryService, DUMMY_NOTARY_KEY),
-                advertisedServices = *arrayOf(notaryService))
+        mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         nodeA = mockNet.createPartyNode()
         nodeB = mockNet.createPartyNode()
         nodeA.internals.registerInitiatedFlow(RecordCompletionFlow::class.java)
diff --git a/docs/source/hello-world-running.rst b/docs/source/hello-world-running.rst
index 7bf00e4771..1bfc2be2df 100644
--- a/docs/source/hello-world-running.rst
+++ b/docs/source/hello-world-running.rst
@@ -28,7 +28,8 @@ Let's take a look at the nodes we're going to deploy. Open the project's ``build
             networkMap "O=Controller,L=London,C=GB"
             node {
                 name "O=Controller,L=London,C=GB"
-                advertisedServices = ["corda.notary.validating"]
+                notary = [validating : true]
+                advertisedServices = []
                 p2pPort 10002
                 rpcPort 10003
                 cordapps = ["net.corda:corda-finance:$corda_release_version"]
diff --git a/docs/source/running-a-notary.rst b/docs/source/running-a-notary.rst
index 32b62359a8..57ce2d0964 100644
--- a/docs/source/running-a-notary.rst
+++ b/docs/source/running-a-notary.rst
@@ -11,20 +11,20 @@ At present we have several prototype notary implementations:
    we are using the `Copycat <http://atomix.io/copycat/>`_ framework
 4. ``RaftValidatingNotaryService`` (distributed) -- as above, but performs validation on the transactions received
 
-To have a node run a notary service, you need to set appropriate configuration values before starting it
+To have a node run a notary service, you need to set appropriate ``notary`` configuration before starting it
 (see :doc:`corda-configuration-file` for reference).
 
-For ``SimpleNotaryService``, simply add the following service id to the list of advertised services:
+For ``SimpleNotaryService`` the config is simply:
 
 .. parsed-literal::
 
-  extraAdvertisedServiceIds : [ "net.corda.notary.simple" ]
+    notary : { validating : false }
 
 For ``ValidatingNotaryService``, it is:
 
 .. parsed-literal::
 
-  extraAdvertisedServiceIds : [ "net.corda.notary.validating" ]
+    notary : { validating : true }
 
 Setting up a Raft notary is currently slightly more involved and is not recommended for prototyping purposes. There is
 work in progress to simplify it. To see it in action, however, you can try out the :ref:`notary-demo`.
diff --git a/docs/source/tutorial-custom-notary.rst b/docs/source/tutorial-custom-notary.rst
index 190d51533a..01e5da1b71 100644
--- a/docs/source/tutorial-custom-notary.rst
+++ b/docs/source/tutorial-custom-notary.rst
@@ -24,9 +24,3 @@ as ``ValidatingNotaryFlow``, ``NonValidatingNotaryFlow``, or implement your own
    :language: kotlin
    :start-after: START 2
    :end-before: END 2
-
-To ensure the custom notary is installed and advertised by the node, specify it in the configuration file:
-
-.. parsed-literal::
-
-    extraAdvertisedServiceIds : ["corda.notary.validating.mycustom"]
diff --git a/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java b/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
index d219c52281..7ecaa9fce9 100644
--- a/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
+++ b/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
@@ -1,9 +1,7 @@
 package net.corda.cordform;
 
 import static java.util.Collections.emptyList;
-import com.typesafe.config.Config;
-import com.typesafe.config.ConfigFactory;
-import com.typesafe.config.ConfigValueFactory;
+import com.typesafe.config.*;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -30,11 +28,6 @@ public class CordformNode implements NodeDefinition {
      */
     public List<String> advertisedServices = emptyList();
 
-    /**
-     * If running a Raft notary cluster, the address of at least one node in the cluster, or leave blank to start a new cluster.
-     * If running a BFT notary cluster, the addresses of all nodes in the cluster.
-     */
-    public List<String> notaryClusterAddresses = emptyList();
     /**
      * Set the RPC users for this node. This configuration block allows arbitrary configuration.
      * The recommended current structure is:
@@ -45,6 +38,12 @@ public class CordformNode implements NodeDefinition {
      */
     public List<Map<String, Object>> rpcUsers = emptyList();
 
+    /**
+     * Apply the notary configuration if this node is a notary. The map is the config structure of
+     * net.corda.node.services.config.NotaryConfig
+     */
+    public Map<String, Object> notary = null;
+
     protected Config config = ConfigFactory.empty();
 
     public Config getConfig() {
@@ -78,20 +77,4 @@ public class CordformNode implements NodeDefinition {
     public void rpcPort(Integer rpcPort) {
         config = config.withValue("rpcAddress", ConfigValueFactory.fromAnyRef(DEFAULT_HOST + ':' + rpcPort));
     }
-
-    /**
-     * Set the port which to bind the Copycat (Raft) node to.
-     *
-     * @param notaryPort The Raft port.
-     */
-    public void notaryNodePort(Integer notaryPort) {
-        config = config.withValue("notaryNodeAddress", ConfigValueFactory.fromAnyRef(DEFAULT_HOST + ':' + notaryPort));
-    }
-
-    /**
-     * @param id The (0-based) BFT replica ID.
-     */
-    public void bftReplicaId(Integer id) {
-        config = config.withValue("bftSMaRt", ConfigValueFactory.fromMap(Collections.singletonMap("replicaId", id)));
-    }
 }
diff --git a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
index 19e3a6b9b3..262f4df38c 100644
--- a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
+++ b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
@@ -99,7 +99,7 @@ class Node extends CordformNode {
     }
 
     protected void build() {
-        configureRpcUsers()
+        configureProperties()
         installCordaJar()
         if (config.hasPath("webAddress")) {
             installWebserverJar()
@@ -118,11 +118,12 @@ class Node extends CordformNode {
         return config.getString("p2pAddress")
     }
 
-    /**
-     * Write the RPC users to the config
-     */
-    private void configureRpcUsers() {
+    private void configureProperties() {
         config = config.withValue("rpcUsers", ConfigValueFactory.fromIterable(rpcUsers))
+        if (notary) {
+            config = config.withValue("notary", ConfigValueFactory.fromMap(notary))
+        }
+        config = config.withValue('extraAdvertisedServiceIds', ConfigValueFactory.fromIterable(advertisedServices*.toString()))
     }
 
     /**
@@ -177,11 +178,6 @@ class Node extends CordformNode {
      * Installs the configuration file to this node's directory and detokenises it.
      */
     private void installConfig() {
-        // Adding required default values
-        config = config.withValue('extraAdvertisedServiceIds', ConfigValueFactory.fromIterable(advertisedServices*.toString()))
-        if (notaryClusterAddresses.size() > 0) {
-            config = config.withValue('notaryClusterAddresses', ConfigValueFactory.fromIterable(notaryClusterAddresses*.toString()))
-        }
         def configFileText = config.root().render(new ConfigRenderOptions(false, false, true, false)).split("\n").toList()
 
         // Need to write a temporary file first to use the project.copy, which resolves directories correctly.
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/User.kt b/node-api/src/main/kotlin/net/corda/nodeapi/User.kt
index 0c0d259ab2..aa86e64414 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/User.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/User.kt
@@ -1,6 +1,7 @@
 package net.corda.nodeapi
 
 import net.corda.nodeapi.config.OldConfig
+import net.corda.nodeapi.config.toConfig
 
 data class User(
         @OldConfig("user")
@@ -8,9 +9,6 @@ data class User(
         val password: String,
         val permissions: Set<String>) {
     override fun toString(): String = "${javaClass.simpleName}($username, permissions=$permissions)"
-    fun toMap() = mapOf(
-            "username" to username,
-            "password" to password,
-            "permissions" to permissions
-    )
+    @Deprecated("Use toConfig().root().unwrapped() instead")
+    fun toMap(): Map<String, Any> = toConfig().root().unwrapped()
 }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt b/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
index 1463229b13..78283ea654 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
@@ -2,18 +2,23 @@
 package net.corda.nodeapi.config
 
 import com.typesafe.config.Config
+import com.typesafe.config.ConfigFactory
 import com.typesafe.config.ConfigUtil
+import com.typesafe.config.ConfigValueFactory
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.noneOrSingle
 import net.corda.core.internal.uncheckedCast
 import net.corda.core.utilities.NetworkHostAndPort
 import org.slf4j.LoggerFactory
+import java.lang.reflect.Field
+import java.lang.reflect.ParameterizedType
 import java.net.Proxy
 import java.net.URL
 import java.nio.file.Path
 import java.nio.file.Paths
 import java.time.Instant
 import java.time.LocalDate
+import java.time.temporal.Temporal
 import java.util.*
 import kotlin.reflect.KClass
 import kotlin.reflect.KProperty
@@ -71,8 +76,8 @@ private fun Config.getSingleValue(path: String, type: KType): Any? {
         NetworkHostAndPort::class -> NetworkHostAndPort.parse(getString(path))
         Path::class -> Paths.get(getString(path))
         URL::class -> URL(getString(path))
-        Properties::class -> getConfig(path).toProperties()
         CordaX500Name::class -> CordaX500Name.parse(getString(path))
+        Properties::class -> getConfig(path).toProperties()
         else -> if (typeClass.java.isEnum) {
             parseEnum(typeClass.java, getString(path))
         } else {
@@ -126,4 +131,65 @@ private fun parseEnum(enumType: Class<*>, name: String): Enum<*> = enumBridge<Pr
 
 private fun <T : Enum<T>> enumBridge(clazz: Class<T>, name: String): T = java.lang.Enum.valueOf(clazz, name)
 
+/**
+ * Convert the receiver object into a [Config]. This does the inverse action of [parseAs].
+ */
+fun Any.toConfig(): Config = ConfigValueFactory.fromMap(toConfigMap()).toConfig()
+
+@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
+// Reflect over the fields of the receiver and generate a value Map that can use to create Config object.
+private fun Any.toConfigMap(): Map<String, Any> {
+    val values = HashMap<String, Any>()
+    for (field in javaClass.declaredFields) {
+        if (field.isSynthetic) continue
+        field.isAccessible = true
+        val value = field.get(this) ?: continue
+        val configValue = if (value is String || value is Boolean || value is Number) {
+            // These types are supported by Config as use as is
+            value
+        } else if (value is Temporal || value is NetworkHostAndPort || value is CordaX500Name || value is Path || value is URL) {
+            // These types make sense to be represented as Strings and the exact inverse parsing function for use in parseAs
+            value.toString()
+        } else if (value is Enum<*>) {
+            // Expicitly use the Enum's name in case the toString is overridden, which would make parsing problematic.
+            value.name
+        } else if (value is Properties) {
+            // For Properties we treat keys with . as nested configs
+            ConfigFactory.parseMap(uncheckedCast(value)).root()
+        } else if (value is Iterable<*>) {
+            value.toConfigIterable(field)
+        } else {
+            // Else this is a custom object recursed over
+            value.toConfigMap()
+        }
+        values[field.name] = configValue
+    }
+    return values
+}
+
+// For Iterables figure out the type parameter and apply the same logic as above on the individual elements.
+private fun Iterable<*>.toConfigIterable(field: Field): Iterable<Any?> {
+    val elementType = (field.genericType as ParameterizedType).actualTypeArguments[0] as Class<*>
+    return when (elementType) {
+        // For the types already supported by Config we can use the Iterable as is
+        String::class.java -> this
+        Integer::class.java -> this
+        java.lang.Long::class.java -> this
+        java.lang.Double::class.java -> this
+        java.lang.Boolean::class.java -> this
+        LocalDate::class.java -> map(Any?::toString)
+        Instant::class.java -> map(Any?::toString)
+        NetworkHostAndPort::class.java -> map(Any?::toString)
+        Path::class.java -> map(Any?::toString)
+        URL::class.java -> map(Any?::toString)
+        CordaX500Name::class.java -> map(Any?::toString)
+        Properties::class.java -> map { ConfigFactory.parseMap(uncheckedCast(it)).root() }
+        else -> if (elementType.isEnum) {
+            map { (it as Enum<*>).name }
+        } else {
+            map { it?.toConfigMap() }
+        }
+    }
+}
+
 private val logger = LoggerFactory.getLogger("net.corda.nodeapi.config")
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/config/ConfigParsingTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/config/ConfigParsingTest.kt
index e13c47ce05..8737ac9160 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/config/ConfigParsingTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/config/ConfigParsingTest.kt
@@ -76,54 +76,66 @@ class ConfigParsingTest {
         testPropertyType<URLData, URLListData, URL>(URL("http://localhost:1234"), URL("http://localhost:1235"), valuesToString = true)
     }
 
+    @Test
+    fun CordaX500Name() {
+        testPropertyType<CordaX500NameData, CordaX500NameListData, CordaX500Name>(
+                CordaX500Name(organisation = "Mock Party", locality = "London", country = "GB"),
+                CordaX500Name(organisation = "Mock Party 2", locality = "London", country = "GB"),
+                valuesToString = true)
+    }
+
     @Test
     fun `flat Properties`() {
         val config = config("value" to mapOf("key" to "prop"))
-        assertThat(config.parseAs<PropertiesData>().value).isEqualTo(Properties().apply { this["key"] = "prop" })
+        val data = PropertiesData(Properties().apply { this["key"] = "prop" })
+        assertThat(config.parseAs<PropertiesData>()).isEqualTo(data)
+        assertThat(data.toConfig()).isEqualTo(config)
     }
 
     @Test
     fun `Properties key with dot`() {
         val config = config("value" to mapOf("key.key2" to "prop"))
-        assertThat(config.parseAs<PropertiesData>().value).isEqualTo(Properties().apply { this["key.key2"] = "prop" })
+        val data = PropertiesData(Properties().apply { this["key.key2"] = "prop" })
+        assertThat(config.parseAs<PropertiesData>().value).isEqualTo(data.value)
     }
 
     @Test
     fun `nested Properties`() {
         val config = config("value" to mapOf("first" to mapOf("second" to "prop")))
-        assertThat(config.parseAs<PropertiesData>().value).isEqualTo(Properties().apply { this["first.second"] = "prop" })
+        val data = PropertiesData(Properties().apply { this["first.second"] = "prop" })
+        assertThat(config.parseAs<PropertiesData>().value).isEqualTo(data.value)
+        assertThat(data.toConfig()).isEqualTo(config)
     }
 
     @Test
     fun `List of Properties`() {
         val config = config("values" to listOf(emptyMap(), mapOf("key" to "prop")))
-        assertThat(config.parseAs<PropertiesListData>().values).containsExactly(
+        val data = PropertiesListData(listOf(
                 Properties(),
-                Properties().apply { this["key"] = "prop" })
+                Properties().apply { this["key"] = "prop" }))
+        assertThat(config.parseAs<PropertiesListData>().values).isEqualTo(data.values)
+        assertThat(data.toConfig()).isEqualTo(config)
     }
 
     @Test
     fun `Set`() {
-        val config = config("values" to listOf("a", "a", "b"))
-        assertThat(config.parseAs<StringSetData>().values).containsOnly("a", "b")
+        val data = StringSetData(setOf("a", "b"))
+        assertThat(config("values" to listOf("a", "a", "b")).parseAs<StringSetData>()).isEqualTo(data)
+        assertThat(data.toConfig()).isEqualTo(config("values" to listOf("a", "b")))
         assertThat(empty().parseAs<StringSetData>().values).isEmpty()
     }
 
-    @Test
-    fun x500Name() {
-        testPropertyType<X500NameData, X500NameListData, CordaX500Name>(CordaX500Name(organisation = "Mock Party", locality = "London", country = "GB"), CordaX500Name(organisation = "Mock Party 2", locality = "London", country = "GB"), valuesToString = true)
-    }
-
     @Test
     fun `multi property data class`() {
-        val data = config(
+        val config = config(
                 "b" to true,
                 "i" to 123,
                 "l" to listOf("a", "b"))
-                .parseAs<MultiPropertyData>()
+        val data = config.parseAs<MultiPropertyData>()
         assertThat(data.i).isEqualTo(123)
         assertThat(data.b).isTrue()
         assertThat(data.l).containsExactly("a", "b")
+        assertThat(data.toConfig()).isEqualTo(config)
     }
 
     @Test
@@ -133,6 +145,7 @@ class ConfigParsingTest {
                         "value" to "nested"))
         val data = NestedData(StringData("nested"))
         assertThat(config.parseAs<NestedData>()).isEqualTo(data)
+        assertThat(data.toConfig()).isEqualTo(config)
     }
 
     @Test
@@ -143,12 +156,14 @@ class ConfigParsingTest {
                         mapOf("value" to "2")))
         val data = DataListData(listOf(StringData("1"), StringData("2")))
         assertThat(config.parseAs<DataListData>()).isEqualTo(data)
+        assertThat(data.toConfig()).isEqualTo(config)
     }
 
     @Test
     fun `default value property`() {
         assertThat(config("a" to 3).parseAs<DefaultData>()).isEqualTo(DefaultData(3, 2))
         assertThat(config("a" to 3, "defaultOfTwo" to 3).parseAs<DefaultData>()).isEqualTo(DefaultData(3, 3))
+        assertThat(DefaultData(3).toConfig()).isEqualTo(config("a" to 3, "defaultOfTwo" to 2))
     }
 
     @Test
@@ -156,12 +171,14 @@ class ConfigParsingTest {
         assertThat(empty().parseAs<NullableData>().nullable).isNull()
         assertThat(config("nullable" to null).parseAs<NullableData>().nullable).isNull()
         assertThat(config("nullable" to "not null").parseAs<NullableData>().nullable).isEqualTo("not null")
+        assertThat(NullableData(null).toConfig()).isEqualTo(empty())
     }
 
     @Test
     fun `old config property`() {
         assertThat(config("oldValue" to "old").parseAs<OldData>().newValue).isEqualTo("old")
         assertThat(config("newValue" to "new").parseAs<OldData>().newValue).isEqualTo("new")
+        assertThat(OldData("old").toConfig()).isEqualTo(config("newValue" to "old"))
     }
 
     private inline fun <reified S : SingleData<V>, reified L : ListData<V>, V : Any> testPropertyType(
@@ -177,6 +194,7 @@ class ConfigParsingTest {
         val config = config("value" to if (valueToString) value.toString() else value)
         val data = constructor.call(value)
         assertThat(config.parseAs<T>().value).isEqualTo(data.value)
+        assertThat(data.toConfig()).isEqualTo(config)
     }
 
     private inline fun <reified T : ListData<V>, V : Any> testListProperty(value1: V, value2: V, valuesToString: Boolean) {
@@ -187,6 +205,7 @@ class ConfigParsingTest {
             val config = config("values" to configValues.take(n))
             val data = constructor.call(rawValues.take(n))
             assertThat(config.parseAs<T>().values).isEqualTo(data.values)
+            assertThat(data.toConfig()).isEqualTo(config)
         }
         assertThat(empty().parseAs<T>().values).isEmpty()
     }
@@ -228,8 +247,8 @@ class ConfigParsingTest {
     data class PathListData(override val values: List<Path>) : ListData<Path>
     data class URLData(override val value: URL) : SingleData<URL>
     data class URLListData(override val values: List<URL>) : ListData<URL>
-    data class X500NameData(override val value: CordaX500Name) : SingleData<CordaX500Name>
-    data class X500NameListData(override val values: List<CordaX500Name>) : ListData<CordaX500Name>
+    data class CordaX500NameData(override val value: CordaX500Name) : SingleData<CordaX500Name>
+    data class CordaX500NameListData(override val values: List<CordaX500Name>) : ListData<CordaX500Name>
     data class PropertiesData(override val value: Properties) : SingleData<Properties>
     data class PropertiesListData(override val values: List<Properties>) : ListData<Properties>
     data class MultiPropertyData(val i: Int, val b: Boolean, val l: List<String>)
@@ -242,5 +261,4 @@ class ConfigParsingTest {
             val newValue: String)
 
     enum class TestEnum { Value1, Value2 }
-
 }
\ No newline at end of file
diff --git a/node/src/integration-test/kotlin/net/corda/node/NodePerformanceTests.kt b/node/src/integration-test/kotlin/net/corda/node/NodePerformanceTests.kt
index e2d9648556..211f0e1f15 100644
--- a/node/src/integration-test/kotlin/net/corda/node/NodePerformanceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/NodePerformanceTests.kt
@@ -7,14 +7,14 @@ import net.corda.core.flows.StartableByRPC
 import net.corda.core.internal.concurrent.transpose
 import net.corda.core.messaging.startFlow
 import net.corda.core.utilities.OpaqueBytes
+import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.minutes
 import net.corda.finance.DOLLARS
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.User
+import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.chooseIdentity
 import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.driver
@@ -103,10 +103,10 @@ class NodePerformanceTests {
     @Test
     fun `self pay rate`() {
         driver(startNodesInProcess = true) {
-            val a = startNode(
-                    rpcUsers = listOf(User("A", "A", setOf(startFlowPermission<CashIssueFlow>(), startFlowPermission<CashPaymentFlow>()))),
-                    advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type))
-            ).get()
+            val a = startNotaryNode(
+                    DUMMY_NOTARY.name,
+                    rpcUsers = listOf(User("A", "A", setOf(startFlowPermission<CashIssueFlow>(), startFlowPermission<CashPaymentFlow>())))
+            ).getOrThrow()
             a as NodeHandle.InProcess
             val metricRegistry = startReporter(shutdownManager, a.node.services.monitoringService.metrics)
             a.rpcClientToNode().use("A", "A") { connection ->
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
index fd803ee9ef..bb177abfd9 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@@ -18,9 +18,7 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.loggerFor
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.User
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.DUMMY_BANK_A
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.TestDependencyInjectionBase
@@ -120,7 +118,7 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
         val nodes = listOf(
                 startNode(providedName = bankAName, rpcUsers = listOf(adminUser)),
                 startNode(providedName = bankBName, rpcUsers = listOf(adminUser)),
-                startNode(providedName = notaryName, rpcUsers = listOf(adminUser), advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
+                startNotaryNode(providedName = notaryName, rpcUsers = listOf(adminUser), validating = false)
         ).transpose().getOrThrow()   // Wait for all nodes to start up.
         nodes.forEach { it.rpc.waitUntilNetworkReady().getOrThrow() }
         return nodes
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt
index c014788530..9a6a5c3112 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt
@@ -10,6 +10,7 @@ import net.corda.core.flows.NotaryException
 import net.corda.core.flows.NotaryFlow
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
+import net.corda.core.internal.deleteIfExists
 import net.corda.core.internal.div
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.TransactionBuilder
@@ -18,11 +19,11 @@ import net.corda.core.utilities.Try
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.config.BFTSMaRtConfiguration
+import net.corda.node.services.config.NotaryConfig
 import net.corda.node.services.transactions.BFTNonValidatingNotaryService
 import net.corda.node.services.transactions.minClusterSize
 import net.corda.node.services.transactions.minCorrectReplicas
 import net.corda.node.utilities.ServiceIdentityGenerator
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.chooseIdentity
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.dummyCommand
@@ -30,14 +31,13 @@ import net.corda.testing.getDefaultNotary
 import net.corda.testing.node.MockNetwork
 import org.junit.After
 import org.junit.Test
-import java.nio.file.Files
+import java.nio.file.Paths
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 class BFTNotaryServiceTests {
     companion object {
-        private val serviceType = BFTNonValidatingNotaryService.type
-        private val clusterName = CordaX500Name(serviceType.id, "BFT", "Zurich", "CH")
+        private val clusterName = CordaX500Name(BFTNonValidatingNotaryService.id, "BFT", "Zurich", "CH")
     }
 
     private val mockNet = MockNetwork()
@@ -49,20 +49,17 @@ class BFTNotaryServiceTests {
     }
 
     private fun bftNotaryCluster(clusterSize: Int, exposeRaces: Boolean = false) {
-        Files.deleteIfExists("config" / "currentView") // XXX: Make config object warn if this exists?
+        (Paths.get("config") / "currentView").deleteIfExists() // XXX: Make config object warn if this exists?
         val replicaIds = (0 until clusterSize)
         ServiceIdentityGenerator.generateToDisk(
                 replicaIds.map { mockNet.baseDirectory(mockNet.nextNodeId + it) },
                 clusterName)
-        val bftNotaryService = ServiceInfo(serviceType, clusterName)
-        val notaryClusterAddresses = replicaIds.map { NetworkHostAndPort("localhost", 11000 + it * 10) }
+        val clusterAddresses = replicaIds.map { NetworkHostAndPort("localhost", 11000 + it * 10) }
         replicaIds.forEach { replicaId ->
-            mockNet.createNode(
-                    advertisedServices = bftNotaryService,
-                    configOverrides = {
-                        whenever(it.bftSMaRt).thenReturn(BFTSMaRtConfiguration(replicaId, false, exposeRaces))
-                        whenever(it.notaryClusterAddresses).thenReturn(notaryClusterAddresses)
-                    })
+            mockNet.createNode(configOverrides = {
+                val notary = NotaryConfig(validating = false, bftSMaRt = BFTSMaRtConfiguration(replicaId, clusterAddresses, exposeRaces = exposeRaces))
+                whenever(it.notary).thenReturn(notary)
+            })
         }
         mockNet.runNetwork() // Exchange initial network map registration messages.
     }
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/DistributedServiceTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/DistributedServiceTests.kt
index 69915138dd..06ed089e16 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/DistributedServiceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/DistributedServiceTests.kt
@@ -39,10 +39,9 @@ class DistributedServiceTests : DriverBasedTest() {
         )
         val aliceFuture = startNode(providedName = ALICE.name, rpcUsers = listOf(testUser))
         val notariesFuture = startNotaryCluster(
-                DUMMY_NOTARY.name.copy(commonName = RaftValidatingNotaryService.type.id),
+                DUMMY_NOTARY.name.copy(commonName = RaftValidatingNotaryService.id),
                 rpcUsers = listOf(testUser),
-                clusterSize = clusterSize,
-                type = RaftValidatingNotaryService.type
+                clusterSize = clusterSize
         )
 
         alice = aliceFuture.get()
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/RaftNotaryServiceTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/RaftNotaryServiceTests.kt
index c81b86195c..0b5d72d858 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/RaftNotaryServiceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/RaftNotaryServiceTests.kt
@@ -14,8 +14,6 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.transactions.RaftValidatingNotaryService
 import net.corda.testing.*
-import net.corda.testing.DUMMY_BANK_A
-import net.corda.testing.chooseIdentity
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.NodeBasedTest
 import org.junit.After
@@ -26,7 +24,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class RaftNotaryServiceTests : NodeBasedTest() {
-    private val notaryName = CordaX500Name(RaftValidatingNotaryService.type.id, "RAFT Notary Service", "London", "GB")
+    private val notaryName = CordaX500Name(RaftValidatingNotaryService.id, "RAFT Notary Service", "London", "GB")
 
     @Before
     fun setup() {
diff --git a/node/src/integration-test/kotlin/net/corda/services/messaging/P2PMessagingTest.kt b/node/src/integration-test/kotlin/net/corda/services/messaging/P2PMessagingTest.kt
index 786e5c0af8..5503d5ca19 100644
--- a/node/src/integration-test/kotlin/net/corda/services/messaging/P2PMessagingTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/services/messaging/P2PMessagingTest.kt
@@ -17,9 +17,6 @@ import net.corda.core.utilities.seconds
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.messaging.*
 import net.corda.node.services.transactions.RaftValidatingNotaryService
-import net.corda.node.services.transactions.SimpleNotaryService
-import net.corda.node.utilities.ServiceIdentityGenerator
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.node.NodeBasedTest
 import org.assertj.core.api.Assertions.assertThat
@@ -32,8 +29,7 @@ import java.util.concurrent.atomic.AtomicInteger
 
 class P2PMessagingTest : NodeBasedTest() {
     private companion object {
-        val DISTRIBUTED_SERVICE_NAME = CordaX500Name(RaftValidatingNotaryService.type.id, "DistributedService", "London", "GB")
-        val SERVICE_2_NAME = CordaX500Name(organisation = "Service 2", locality = "London", country = "GB")
+        val DISTRIBUTED_SERVICE_NAME = CordaX500Name(RaftValidatingNotaryService.id, "DistributedService", "London", "GB")
     }
 
     @Test
@@ -49,46 +45,6 @@ class P2PMessagingTest : NodeBasedTest() {
         startNodes().getOrThrow(timeout = startUpDuration * 3)
     }
 
-    // https://github.com/corda/corda/issues/71
-    @Test
-    fun `communicating with a service running on the network map node`() {
-        startNetworkMapNode(advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
-        networkMapNode.respondWith("Hello")
-        val alice = startNode(ALICE.name).getOrThrow()
-        val serviceAddress = alice.services.networkMapCache.run {
-            val notaryParty = notaryIdentities.randomOrNull()!!
-            alice.network.getAddressOfParty(getPartyInfo(notaryParty)!!)
-        }
-        val received = alice.receiveFrom(serviceAddress).getOrThrow(10.seconds)
-        assertThat(received).isEqualTo("Hello")
-    }
-
-    // TODO Use a dummy distributed service
-    @Test
-    fun `communicating with a distributed service which the network map node is part of`() {
-        ServiceIdentityGenerator.generateToDisk(
-                listOf(DUMMY_MAP.name, SERVICE_2_NAME).map { baseDirectory(it) },
-                DISTRIBUTED_SERVICE_NAME)
-
-        val distributedService = ServiceInfo(RaftValidatingNotaryService.type, DISTRIBUTED_SERVICE_NAME)
-        val notaryClusterAddress = freeLocalHostAndPort()
-        startNetworkMapNode(
-                DUMMY_MAP.name,
-                advertisedServices = setOf(distributedService),
-                configOverrides = mapOf("notaryNodeAddress" to notaryClusterAddress.toString()))
-        val (serviceNode2, alice) = listOf(
-                startNode(
-                        SERVICE_2_NAME,
-                        advertisedServices = setOf(distributedService),
-                        configOverrides = mapOf(
-                                "notaryNodeAddress" to freeLocalHostAndPort().toString(),
-                                "notaryClusterAddresses" to listOf(notaryClusterAddress.toString()))),
-                startNode(ALICE.name)
-        ).transpose().getOrThrow()
-
-        assertAllNodesAreUsed(listOf(networkMapNode, serviceNode2), DISTRIBUTED_SERVICE_NAME, alice)
-    }
-
     @Ignore
     @Test
     fun `communicating with a distributed service which we're part of`() {
diff --git a/node/src/integration-test/kotlin/net/corda/test/node/NodeStatePersistenceTests.kt b/node/src/integration-test/kotlin/net/corda/test/node/NodeStatePersistenceTests.kt
index efd07f1a55..0e8f062c9c 100644
--- a/node/src/integration-test/kotlin/net/corda/test/node/NodeStatePersistenceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/test/node/NodeStatePersistenceTests.kt
@@ -18,8 +18,6 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.ProgressTracker
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.services.FlowPermissions
-import net.corda.node.services.transactions.SimpleNotaryService
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.nodeapi.User
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.chooseIdentity
@@ -38,8 +36,7 @@ class NodeStatePersistenceTests {
         val user = User("mark", "dadada", setOf(FlowPermissions.startFlowPermission<SendMessageFlow>()))
         val message = Message("Hello world!")
         driver(isDebug = true, startNodesInProcess = isQuasarAgentSpecified()) {
-
-            startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type))).getOrThrow()
+            startNotaryNode(DUMMY_NOTARY.name, validating = false).getOrThrow()
             var nodeHandle = startNode(rpcUsers = listOf(user)).getOrThrow()
             val nodeName = nodeHandle.nodeInfo.chooseIdentity().name
             nodeHandle.rpcClientToNode().start(user.username, user.password).use {
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index ba3f1d06b6..8e9d219d66 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -1,7 +1,6 @@
 package net.corda.node.internal
 
 import com.codahale.metrics.MetricRegistry
-import com.google.common.collect.Lists
 import com.google.common.collect.MutableClassToInstanceMap
 import com.google.common.util.concurrent.MoreExecutors
 import net.corda.confidential.SwapIdentitiesFlow
@@ -41,7 +40,9 @@ import net.corda.node.services.ContractUpgradeHandler
 import net.corda.node.services.FinalityHandler
 import net.corda.node.services.NotaryChangeHandler
 import net.corda.node.services.api.*
+import net.corda.node.services.config.BFTSMaRtConfiguration
 import net.corda.node.services.config.NodeConfiguration
+import net.corda.node.services.config.NotaryConfig
 import net.corda.node.services.config.configureWithDevSSLCertificate
 import net.corda.node.services.events.NodeSchedulerService
 import net.corda.node.services.events.ScheduledActivityObserver
@@ -66,7 +67,6 @@ import net.corda.node.services.vault.VaultSoftLockManager
 import net.corda.node.utilities.*
 import net.corda.node.utilities.AddOrRemove.ADD
 import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import org.apache.activemq.artemis.utils.ReusableLatch
 import org.slf4j.Logger
 import rx.Observable
@@ -456,7 +456,7 @@ abstract class AbstractNode(config: NodeConfiguration,
         _services = ServiceHubInternalImpl(schemaService)
         attachments = NodeAttachmentService(services.monitoringService.metrics)
         cordappProvider.start(attachments)
-        legalIdentity = obtainIdentity()
+        legalIdentity = obtainIdentity(notaryConfig = null)
         network = makeMessagingService(legalIdentity)
         info = makeInfo(legalIdentity)
         val networkMapCache = services.networkMapCache
@@ -500,19 +500,10 @@ abstract class AbstractNode(config: NodeConfiguration,
     }
 
     /**
-     * A service entry contains the advertised [ServiceInfo] along with the service identity. The identity *name* is
-     * taken from the configuration or, if non specified, generated by combining the node's legal name and the service id.
-     * Used only for notary identities.
+     * Obtain the node's notary identity if it's configured to be one. If part of a distributed notary then this will be
+     * the distributed identity shared across all the nodes of the cluster.
      */
-    protected open fun getNotaryIdentity(): PartyAndCertificate? {
-        return advertisedServices.singleOrNull { it.type.isNotary() }?.let {
-            it.name?.let {
-                require(it.commonName != null) {"Common name in '$it' must not be null for notary service, use service type id as common name."}
-                require(ServiceType.parse(it.commonName!!).isNotary()) {"Common name for notary service in '$it' must be the notary service type id."}
-            }
-            obtainIdentity(it)
-        }
-    }
+    protected fun getNotaryIdentity(): PartyAndCertificate? = configuration.notary?.let { obtainIdentity(it) }
 
     @VisibleForTesting
     protected open fun acceptableLiveFiberCountOnStop(): Int = 0
@@ -558,22 +549,14 @@ abstract class AbstractNode(config: NodeConfiguration,
     }
 
     private fun makeNetworkServices(network: MessagingService, networkMapCache: NetworkMapCacheInternal, tokenizableServices: MutableList<Any>) {
-        val serviceTypes = advertisedServices.map { it.type }
         inNodeNetworkMapService = if (configuration.networkMapService == null) makeNetworkMapService(network, networkMapCache) else NullNetworkMapService
-        val notaryServiceType = serviceTypes.singleOrNull { it.isNotary() }
-        if (notaryServiceType != null) {
-            val service = makeCoreNotaryService(notaryServiceType)
-            if (service != null) {
-                service.apply {
-                    tokenizableServices.add(this)
-                    runOnStop += this::stop
-                    start()
-                }
-                installCoreFlow(NotaryFlow.Client::class, service::createServiceFlow)
-            } else {
-                log.info("Notary type ${notaryServiceType.id} does not match any built-in notary types. " +
-                        "It is expected to be loaded via a CorDapp")
-            }
+        configuration.notary?.let {
+            val notaryService = makeCoreNotaryService(it)
+            tokenizableServices.add(notaryService)
+            runOnStop += notaryService::stop
+            installCoreFlow(NotaryFlow.Client::class, notaryService::createServiceFlow)
+            log.info("Running core notary: ${notaryService.javaClass.name}")
+            notaryService.start()
         }
     }
 
@@ -640,15 +623,33 @@ abstract class AbstractNode(config: NodeConfiguration,
 
     abstract protected fun makeNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal): NetworkMapService
 
-    open protected fun makeCoreNotaryService(type: ServiceType): NotaryService? {
-        check(myNotaryIdentity != null) { "No notary identity initialized when creating a notary service" }
-        return when (type) {
-            SimpleNotaryService.type -> SimpleNotaryService(services, myNotaryIdentity!!.owningKey)
-            ValidatingNotaryService.type -> ValidatingNotaryService(services, myNotaryIdentity!!.owningKey)
-            RaftNonValidatingNotaryService.type -> RaftNonValidatingNotaryService(services, myNotaryIdentity!!.owningKey)
-            RaftValidatingNotaryService.type -> RaftValidatingNotaryService(services, myNotaryIdentity!!.owningKey)
-            BFTNonValidatingNotaryService.type -> BFTNonValidatingNotaryService(services, myNotaryIdentity!!.owningKey)
-            else -> null
+    private fun makeCoreNotaryService(notaryConfig: NotaryConfig): NotaryService {
+        val notaryKey = myNotaryIdentity?.owningKey ?: throw IllegalArgumentException("No notary identity initialized when creating a notary service")
+        return if (notaryConfig.validating) {
+            if (notaryConfig.raft != null) {
+                RaftValidatingNotaryService(services, notaryKey, notaryConfig.raft)
+            } else if (notaryConfig.bftSMaRt != null) {
+                throw IllegalArgumentException("Validating BFTSMaRt notary not supported")
+            } else {
+                ValidatingNotaryService(services, notaryKey)
+            }
+        } else {
+            if (notaryConfig.raft != null) {
+                RaftNonValidatingNotaryService(services, notaryKey, notaryConfig.raft)
+            } else if (notaryConfig.bftSMaRt != null) {
+                val cluster = makeBFTCluster(notaryKey, notaryConfig.bftSMaRt)
+                BFTNonValidatingNotaryService(services, notaryKey, notaryConfig.bftSMaRt, cluster)
+            } else {
+                SimpleNotaryService(services, notaryKey)
+            }
+        }
+    }
+
+    protected open fun makeBFTCluster(notaryKey: PublicKey, bftSMaRtConfig: BFTSMaRtConfiguration): BFTSMaRt.Cluster {
+        return object : BFTSMaRt.Cluster {
+            override fun waitUntilAllReplicasHaveInitialized() {
+                log.warn("A BFT replica may still be initializing, in which case the upcoming consensus change may cause it to spin.")
+            }
         }
     }
 
@@ -691,29 +692,32 @@ abstract class AbstractNode(config: NodeConfiguration,
 
     protected abstract fun startMessagingService(rpcOps: RPCOps)
 
-    private fun obtainIdentity(serviceInfo: ServiceInfo? = null): PartyAndCertificate {
-        // Load the private identity key, creating it if necessary. The identity key is a long term well known key that
-        // is distributed to other peers and we use it (or a key signed by it) when we need to do something
-        // "permissioned". The identity file is what gets distributed and contains the node's legal name along with
-        // the public key. Obviously in a real system this would need to be a certificate chain of some kind to ensure
-        // the legal name is actually validated in some way.
+    private fun obtainIdentity(notaryConfig: NotaryConfig?): PartyAndCertificate {
         val keyStore = KeyStoreWrapper(configuration.nodeKeystore, configuration.keyStorePassword)
 
-        val (id, name) = if (serviceInfo == null) {
-            // Create node identity if service info = null
+        val (id, singleName) = if (notaryConfig == null) {
+            // Node's main identity
             Pair("identity", myLegalName)
         } else {
-            val name = serviceInfo.name ?: myLegalName.copy(commonName = serviceInfo.type.id)
-            Pair(serviceInfo.type.id, name)
+            val notaryId = notaryConfig.run { NotaryService.constructId(validating, raft != null, bftSMaRt != null) }
+            if (notaryConfig.bftSMaRt == null && notaryConfig.raft == null) {
+                // Node's notary identity
+                Pair(notaryId, myLegalName.copy(commonName = notaryId))
+            } else {
+                // The node is part of a distributed notary whose identity must already be generated beforehand
+                Pair(notaryId, null)
+            }
         }
 
         // TODO: Integrate with Key management service?
         val privateKeyAlias = "$id-private-key"
 
         if (!keyStore.containsAlias(privateKeyAlias)) {
+            singleName ?: throw IllegalArgumentException(
+                    "Unable to find in the key store the identity of the distributed notary ($id) the node is part of")
             // TODO: Remove use of [ServiceIdentityGenerator.generateToDisk].
             log.info("$privateKeyAlias not found in key store ${configuration.nodeKeystore}, generating fresh key!")
-            keyStore.signAndSaveNewKeyPair(name, privateKeyAlias, generateKeyPair())
+            keyStore.signAndSaveNewKeyPair(singleName, privateKeyAlias, generateKeyPair())
         }
 
         val (x509Cert, keys) = keyStore.certificateAndKeyPair(privateKeyAlias)
@@ -726,7 +730,7 @@ abstract class AbstractNode(config: NodeConfiguration,
             // We have to create the certificate chain for the composite key manually, this is because we don't have a keystore
             // provider that understand compositeKey-privateKey combo. The cert chain is created using the composite key certificate +
             // the tail of the private key certificates, as they are both signed by the same certificate chain.
-            Lists.asList(certificate, keyStore.getCertificateChain(privateKeyAlias).drop(1).toTypedArray())
+            listOf(certificate) + keyStore.getCertificateChain(privateKeyAlias).drop(1)
         } else {
             keyStore.getCertificateChain(privateKeyAlias).let {
                 check(it[0].toX509CertHolder() == x509Cert) { "Certificates from key store do not line up!" }
@@ -736,8 +740,11 @@ abstract class AbstractNode(config: NodeConfiguration,
 
         val nodeCert = certificates[0] as? X509Certificate ?: throw ConfigurationException("Node certificate must be an X.509 certificate")
         val subject = CordaX500Name.build(nodeCert.subjectX500Principal)
-        if (subject != name)
-            throw ConfigurationException("The name '$name' for $id doesn't match what's in the key store: $subject")
+        // TODO Include the name of the distributed notary, which the node is part of, in the notary config so that we
+        // can cross-check the identity we get from the key store
+        if (singleName != null && subject != singleName) {
+            throw ConfigurationException("The name '$singleName' for $id doesn't match what's in the key store: $subject")
+        }
 
         partyKeys += keys
         return PartyAndCertificate(CertificateFactory.getInstance("X509").generateCertPath(certificates))
diff --git a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
index 6413daa3ee..631361cd04 100644
--- a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
@@ -99,7 +99,7 @@ open class NodeStartup(val args: Array<String>) {
             return
         }
         val startedNode = node.start()
-        printPluginsAndServices(startedNode.internals)
+        Node.printBasicNodeInfo("Loaded CorDapps", startedNode.internals.cordappProvider.cordapps.joinToString { it.name })
         startedNode.internals.nodeReadyFuture.thenMatch({
             val elapsed = (System.currentTimeMillis() - startTime) / 10 / 100.0
             val name = startedNode.info.legalIdentitiesAndCerts.first().name.organisation
@@ -165,7 +165,7 @@ open class NodeStartup(val args: Array<String>) {
     }
 
     open protected fun banJavaSerialisation(conf: FullNodeConfiguration) {
-        SerialFilter.install(if (conf.bftSMaRt.isValid()) ::bftSMaRtSerialFilter else ::defaultSerialFilter)
+        SerialFilter.install(if (conf.notary?.bftSMaRt != null) ::bftSMaRtSerialFilter else ::defaultSerialFilter)
     }
 
     open protected fun getVersionInfo(): VersionInfo {
@@ -263,13 +263,6 @@ open class NodeStartup(val args: Array<String>) {
         }
     }
 
-    private fun printPluginsAndServices(node: Node) {
-        node.configuration.extraAdvertisedServiceIds.filter { it.startsWith("corda.notary.") }.let {
-            if (it.isNotEmpty()) Node.printBasicNodeInfo("Providing additional services", it.joinToString())
-        }
-        Node.printBasicNodeInfo("Loaded CorDapps", node.cordappProvider.cordapps.joinToString { it.name })
-    }
-
     open fun drawBanner(versionInfo: VersionInfo) {
         // This line makes sure ANSI escapes work on Windows, where they aren't supported out of the box.
         AnsiConsole.systemInstall()
diff --git a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
index ba865ecaba..b15e768f19 100644
--- a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
+++ b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
@@ -6,17 +6,11 @@ import net.corda.node.internal.NetworkMapInfo
 import net.corda.node.services.messaging.CertificateChainCheckPolicy
 import net.corda.nodeapi.User
 import net.corda.nodeapi.config.NodeSSLConfiguration
-import net.corda.nodeapi.config.OldConfig
 import net.corda.nodeapi.internal.ServiceInfo
 import java.net.URL
 import java.nio.file.Path
 import java.util.*
 
-/** @param exposeRaces for testing only, so its default is not in reference.conf but here. */
-data class BFTSMaRtConfiguration(val replicaId: Int, val debug: Boolean, val exposeRaces: Boolean = false) {
-    fun isValid() = replicaId >= 0
-}
-
 interface NodeConfiguration : NodeSSLConfiguration {
     // myLegalName should be only used in the initial network registration, we should use the name from the certificate instead of this.
     // TODO: Remove this so we don't accidentally use this identity in the code?
@@ -37,17 +31,31 @@ interface NodeConfiguration : NodeSSLConfiguration {
     val certificateChainCheckPolicies: List<CertChainPolicyConfig>
     val verifierType: VerifierType
     val messageRedeliveryDelaySeconds: Int
-    val bftSMaRt: BFTSMaRtConfiguration
-    val notaryNodeAddress: NetworkHostAndPort?
-    val notaryClusterAddresses: List<NetworkHostAndPort>
+    val notary: NotaryConfig?
     val activeMQServer: ActiveMqServerConfiguration
 }
 
-data class BridgeConfiguration(
-        val retryIntervalMs: Long,
-        val maxRetryIntervalMin: Long,
-        val retryIntervalMultiplier: Double
-)
+data class NotaryConfig(val validating: Boolean, val raft: RaftConfig? = null, val bftSMaRt: BFTSMaRtConfiguration? = null) {
+    init {
+        require(raft == null || bftSMaRt == null) { "raft and bftSMaRt configs cannot be specified together" }
+    }
+}
+
+data class RaftConfig(val nodeAddress: NetworkHostAndPort, val clusterAddresses: List<NetworkHostAndPort>)
+
+/** @param exposeRaces for testing only, so its default is not in reference.conf but here. */
+data class BFTSMaRtConfiguration constructor(val replicaId: Int,
+                                 val clusterAddresses: List<NetworkHostAndPort>,
+                                 val debug: Boolean = false,
+                                 val exposeRaces: Boolean = false) {
+    init {
+        require(replicaId >= 0) { "replicaId cannot be negative" }
+    }
+}
+
+data class BridgeConfiguration(val retryIntervalMs: Long,
+                               val maxRetryIntervalMin: Long,
+                               val retryIntervalMultiplier: Double)
 
 data class ActiveMqServerConfiguration(val bridge: BridgeConfiguration)
 
@@ -67,16 +75,13 @@ data class FullNodeConfiguration(
         override val verifierType: VerifierType,
         override val messageRedeliveryDelaySeconds: Int = 30,
         val useHTTPS: Boolean,
-        @OldConfig("artemisAddress")
         val p2pAddress: NetworkHostAndPort,
         val rpcAddress: NetworkHostAndPort?,
         // TODO This field is slightly redundant as p2pAddress is sufficient to hold the address of the node's MQ broker.
         // Instead this should be a Boolean indicating whether that broker is an internal one started by the node or an external one
         val messagingServerAddress: NetworkHostAndPort?,
         val extraAdvertisedServiceIds: List<String>,
-        override val bftSMaRt: BFTSMaRtConfiguration,
-        override val notaryNodeAddress: NetworkHostAndPort?,
-        override val notaryClusterAddresses: List<NetworkHostAndPort>,
+        override val notary: NotaryConfig?,
         override val certificateChainCheckPolicies: List<CertChainPolicyConfig>,
         override val devMode: Boolean = false,
         val useTestClock: Boolean = false,
diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
index 8b27a9a396..322a2c9299 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
@@ -13,6 +13,7 @@ import net.corda.core.messaging.DataFeed
 import net.corda.core.messaging.SingleMessageRecipient
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.services.NetworkMapCache.MapChange
+import net.corda.core.node.services.NotaryService
 import net.corda.core.node.services.PartyInfo
 import net.corda.core.schemas.NodeInfoSchemaV1
 import net.corda.core.serialization.SingletonSerializeAsToken
@@ -81,10 +82,8 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
                         //       Notary certificates have to be signed by the doorman directly
                         it.legalIdentities
                     }
-                    .filter {
-                        it.name.toString().contains("corda.notary", true)
-                    }
-                    .distinct() // Distinct, because of distributed service nodes
+                    .filter { it.name.commonName?.startsWith(NotaryService.ID_PREFIX) ?: false }
+                    .toSet() // Distinct, because of distributed service nodes
                     .sortedBy { it.name.toString() }
         }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/BFTNonValidatingNotaryService.kt b/node/src/main/kotlin/net/corda/node/services/transactions/BFTNonValidatingNotaryService.kt
index 807bcc9415..8ea6e6af09 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/BFTNonValidatingNotaryService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/BFTNonValidatingNotaryService.kt
@@ -20,10 +20,12 @@ import net.corda.core.serialization.serialize
 import net.corda.core.transactions.FilteredTransaction
 import net.corda.core.utilities.*
 import net.corda.node.services.api.ServiceHubInternal
+import net.corda.node.services.config.BFTSMaRtConfiguration
 import net.corda.node.utilities.AppendOnlyPersistentMap
 import net.corda.node.utilities.NODE_DATABASE_PREFIX
 import java.security.PublicKey
 import javax.persistence.Entity
+import javax.persistence.Table
 import kotlin.concurrent.thread
 
 /**
@@ -33,24 +35,19 @@ import kotlin.concurrent.thread
  */
 class BFTNonValidatingNotaryService(override val services: ServiceHubInternal,
                                     override val notaryIdentityKey: PublicKey,
-                                    cluster: BFTSMaRt.Cluster = distributedCluster) : NotaryService() {
+                                    private val bftSMaRtConfig: BFTSMaRtConfiguration,
+                                    cluster: BFTSMaRt.Cluster) : NotaryService() {
     companion object {
-        val type = SimpleNotaryService.type.getSubType("bft")
+        val id = constructId(validating = false, bft = true)
         private val log = loggerFor<BFTNonValidatingNotaryService>()
-        private val distributedCluster = object : BFTSMaRt.Cluster {
-            override fun waitUntilAllReplicasHaveInitialized() {
-                log.warn("A replica may still be initializing, in which case the upcoming consensus change may cause it to spin.")
-            }
-        }
     }
 
     private val client: BFTSMaRt.Client
     private val replicaHolder = SettableFuture.create<Replica>()
 
     init {
-        require(services.configuration.bftSMaRt.isValid()) { "bftSMaRt replicaId must be specified in the configuration" }
-        client = BFTSMaRtConfig(services.configuration.notaryClusterAddresses, services.configuration.bftSMaRt.debug, services.configuration.bftSMaRt.exposeRaces).use {
-            val replicaId = services.configuration.bftSMaRt.replicaId
+        client = BFTSMaRtConfig(bftSMaRtConfig.clusterAddresses, bftSMaRtConfig.debug, bftSMaRtConfig.exposeRaces).use {
+            val replicaId = bftSMaRtConfig.replicaId
             val configHandle = it.handle()
             // Replica startup must be in parallel with other replicas, otherwise the constructor may not return:
             thread(name = "BFT SMaRt replica $replicaId init", isDaemon = true) {
@@ -66,7 +63,7 @@ class BFTNonValidatingNotaryService(override val services: ServiceHubInternal,
     }
 
     fun waitUntilReplicaHasInitialized() {
-        log.debug { "Waiting for replica ${services.configuration.bftSMaRt.replicaId} to initialize." }
+        log.debug { "Waiting for replica ${bftSMaRtConfig.replicaId} to initialize." }
         replicaHolder.getOrThrow() // It's enough to wait for the ServiceReplica constructor to return.
     }
 
@@ -96,36 +93,37 @@ class BFTNonValidatingNotaryService(override val services: ServiceHubInternal,
     }
 
     @Entity
-    @javax.persistence.Table(name = "${NODE_DATABASE_PREFIX}bft_smart_notary_committed_states")
+    @Table(name = "${NODE_DATABASE_PREFIX}bft_smart_notary_committed_states")
     class PersistedCommittedState(id: PersistentStateRef, consumingTxHash: String, consumingIndex: Int, party: PersistentUniquenessProvider.PersistentParty)
         : PersistentUniquenessProvider.PersistentUniqueness(id, consumingTxHash, consumingIndex, party)
 
-    fun createMap(): AppendOnlyPersistentMap<StateRef, UniquenessProvider.ConsumingTx, PersistedCommittedState, PersistentStateRef> =
-            AppendOnlyPersistentMap(
-                    toPersistentEntityKey = { PersistentStateRef(it.txhash.toString(), it.index) },
-                    fromPersistentEntity = {
-                        //TODO null check will become obsolete after making DB/JPA columns not nullable
-                        val txId = it.id.txId ?: throw IllegalStateException("DB returned null SecureHash transactionId")
-                        val index = it.id.index ?: throw IllegalStateException("DB returned null SecureHash index")
-                        Pair(StateRef(txhash = SecureHash.parse(txId), index = index),
+    private fun createMap(): AppendOnlyPersistentMap<StateRef, UniquenessProvider.ConsumingTx, PersistedCommittedState, PersistentStateRef> {
+        return AppendOnlyPersistentMap(
+                toPersistentEntityKey = { PersistentStateRef(it.txhash.toString(), it.index) },
+                fromPersistentEntity = {
+                    //TODO null check will become obsolete after making DB/JPA columns not nullable
+                    val txId = it.id.txId ?: throw IllegalStateException("DB returned null SecureHash transactionId")
+                    val index = it.id.index ?: throw IllegalStateException("DB returned null SecureHash index")
+                    Pair(StateRef(txhash = SecureHash.parse(txId), index = index),
                             UniquenessProvider.ConsumingTx(
                                     id = SecureHash.parse(it.consumingTxHash),
                                     inputIndex = it.consumingIndex,
                                     requestingParty = Party(
                                             name = CordaX500Name.parse(it.party.name),
                                             owningKey = parsePublicKeyBase58(it.party.owningKey))))
-                    },
-                    toPersistentEntity = { (txHash, index) : StateRef, (id, inputIndex, requestingParty): UniquenessProvider.ConsumingTx ->
-                        PersistedCommittedState(
-                                id = PersistentStateRef(txHash.toString(), index),
-                                consumingTxHash = id.toString(),
-                                consumingIndex = inputIndex,
-                                party = PersistentUniquenessProvider.PersistentParty(requestingParty.name.toString(),
-                                        requestingParty.owningKey.toBase58String())
-                        )
-                    },
-                    persistentEntityClass = PersistedCommittedState::class.java
-            )
+                },
+                toPersistentEntity = { (txHash, index) : StateRef, (id, inputIndex, requestingParty): UniquenessProvider.ConsumingTx ->
+                    PersistedCommittedState(
+                            id = PersistentStateRef(txHash.toString(), index),
+                            consumingTxHash = id.toString(),
+                            consumingIndex = inputIndex,
+                            party = PersistentUniquenessProvider.PersistentParty(requestingParty.name.toString(),
+                                    requestingParty.owningKey.toBase58String())
+                    )
+                },
+                persistentEntityClass = PersistedCommittedState::class.java
+        )
+    }
 
     private class Replica(config: BFTSMaRtConfig,
                           replicaId: Int,
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/RaftNonValidatingNotaryService.kt b/node/src/main/kotlin/net/corda/node/services/transactions/RaftNonValidatingNotaryService.kt
index 6e0916e3cc..797f9aa7de 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/RaftNonValidatingNotaryService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/RaftNonValidatingNotaryService.kt
@@ -5,18 +5,23 @@ import net.corda.core.flows.NotaryFlow
 import net.corda.core.node.services.TimeWindowChecker
 import net.corda.core.node.services.TrustedAuthorityNotaryService
 import net.corda.node.services.api.ServiceHubInternal
+import net.corda.node.services.config.RaftConfig
 import java.security.PublicKey
 
 /** A non-validating notary service operated by a group of mutually trusting parties, uses the Raft algorithm to achieve consensus. */
-class RaftNonValidatingNotaryService(override val services: ServiceHubInternal, override val notaryIdentityKey: PublicKey) : TrustedAuthorityNotaryService() {
+class RaftNonValidatingNotaryService(override val services: ServiceHubInternal,
+                                     override val notaryIdentityKey: PublicKey,
+                                     raftConfig: RaftConfig) : TrustedAuthorityNotaryService() {
     companion object {
-        val type = SimpleNotaryService.type.getSubType("raft")
+        val id = constructId(validating = false, raft = true)
     }
 
     override val timeWindowChecker: TimeWindowChecker = TimeWindowChecker(services.clock)
-    override val uniquenessProvider: RaftUniquenessProvider = RaftUniquenessProvider(services)
+    override val uniquenessProvider: RaftUniquenessProvider = RaftUniquenessProvider(services, raftConfig)
 
-    override fun createServiceFlow(otherPartySession: FlowSession): NotaryFlow.Service = NonValidatingNotaryFlow(otherPartySession, this)
+    override fun createServiceFlow(otherPartySession: FlowSession): NotaryFlow.Service {
+        return NonValidatingNotaryFlow(otherPartySession, this)
+    }
 
     override fun start() {
         uniquenessProvider.start()
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/RaftUniquenessProvider.kt b/node/src/main/kotlin/net/corda/node/services/transactions/RaftUniquenessProvider.kt
index ed349f1cc6..93daf5a23a 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/RaftUniquenessProvider.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/RaftUniquenessProvider.kt
@@ -26,16 +26,14 @@ import net.corda.core.serialization.deserialize
 import net.corda.core.serialization.serialize
 import net.corda.core.utilities.loggerFor
 import net.corda.node.services.api.ServiceHubInternal
+import net.corda.node.services.config.RaftConfig
 import net.corda.node.utilities.AppendOnlyPersistentMap
 import net.corda.node.utilities.CordaPersistence
 import net.corda.nodeapi.config.SSLConfiguration
 import java.nio.file.Path
 import java.util.concurrent.CompletableFuture
 import javax.annotation.concurrent.ThreadSafe
-import javax.persistence.Column
-import javax.persistence.Entity
-import javax.persistence.Id
-import javax.persistence.Lob
+import javax.persistence.*
 
 /**
  * A uniqueness provider that records committed input states in a distributed collection replicated and
@@ -46,7 +44,7 @@ import javax.persistence.Lob
  * to the cluster leader to be actioned.
  */
 @ThreadSafe
-class RaftUniquenessProvider(private val services: ServiceHubInternal) : UniquenessProvider, SingletonSerializeAsToken() {
+class RaftUniquenessProvider(private val services: ServiceHubInternal, private val raftConfig: RaftConfig) : UniquenessProvider, SingletonSerializeAsToken() {
     companion object {
         private val log = loggerFor<RaftUniquenessProvider>()
 
@@ -67,7 +65,7 @@ class RaftUniquenessProvider(private val services: ServiceHubInternal) : Uniquen
     }
 
     @Entity
-    @javax.persistence.Table(name = "notary_committed_states")
+    @Table(name = "notary_committed_states")
     class RaftState(
             @Id
             @Column
@@ -81,13 +79,6 @@ class RaftUniquenessProvider(private val services: ServiceHubInternal) : Uniquen
     /** Directory storing the Raft log and state machine snapshots */
     private val storagePath: Path = services.configuration.baseDirectory
     /** Address of the Copycat node run by this Corda node */
-    private val myAddress = services.configuration.notaryNodeAddress
-            ?: throw IllegalArgumentException("notaryNodeAddress must be specified in configuration")
-    /**
-     * List of node addresses in the existing Copycat cluster. At least one active node must be
-     * provided to join the cluster. If empty, a new cluster will be bootstrapped.
-     */
-    private val clusterAddresses = services.configuration.notaryClusterAddresses
     /** The database to store the state machine state in */
     private val db: CordaPersistence = services.database
     /** SSL configuration */
@@ -96,7 +87,6 @@ class RaftUniquenessProvider(private val services: ServiceHubInternal) : Uniquen
     private lateinit var _clientFuture: CompletableFuture<CopycatClient>
     private lateinit var server: CopycatServer
 
-
     /**
      * Copycat clients are responsible for connecting to the cluster and submitting commands and queries that operate
      * on the cluster's replicated state machine.
@@ -108,7 +98,7 @@ class RaftUniquenessProvider(private val services: ServiceHubInternal) : Uniquen
         log.info("Creating Copycat server, log stored in: ${storagePath.toFile()}")
         val stateMachineFactory = {
             DistributedImmutableMap(db, RaftUniquenessProvider.Companion::createMap) }
-        val address = Address(myAddress.host, myAddress.port)
+        val address = raftConfig.nodeAddress.let { Address(it.host, it.port) }
         val storage = buildStorage(storagePath)
         val transport = buildTransport(transportConfiguration)
         val serializer = Serializer().apply {
@@ -142,9 +132,9 @@ class RaftUniquenessProvider(private val services: ServiceHubInternal) : Uniquen
                 .withSerializer(serializer)
                 .build()
 
-        val serverFuture = if (clusterAddresses.isNotEmpty()) {
-            log.info("Joining an existing Copycat cluster at $clusterAddresses")
-            val cluster = clusterAddresses.map { Address(it.host, it.port) }
+        val serverFuture = if (raftConfig.clusterAddresses.isNotEmpty()) {
+            log.info("Joining an existing Copycat cluster at ${raftConfig.clusterAddresses}")
+            val cluster = raftConfig.clusterAddresses.map { Address(it.host, it.port) }
             server.join(cluster)
         } else {
             log.info("Bootstrapping a Copycat cluster at $address")
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/RaftValidatingNotaryService.kt b/node/src/main/kotlin/net/corda/node/services/transactions/RaftValidatingNotaryService.kt
index 10da5581fe..4af9e2be74 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/RaftValidatingNotaryService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/RaftValidatingNotaryService.kt
@@ -5,18 +5,23 @@ import net.corda.core.flows.NotaryFlow
 import net.corda.core.node.services.TimeWindowChecker
 import net.corda.core.node.services.TrustedAuthorityNotaryService
 import net.corda.node.services.api.ServiceHubInternal
+import net.corda.node.services.config.RaftConfig
 import java.security.PublicKey
 
 /** A validating notary service operated by a group of mutually trusting parties, uses the Raft algorithm to achieve consensus. */
-class RaftValidatingNotaryService(override val services: ServiceHubInternal, override val notaryIdentityKey: PublicKey) : TrustedAuthorityNotaryService() {
+class RaftValidatingNotaryService(override val services: ServiceHubInternal,
+                                  override val notaryIdentityKey: PublicKey,
+                                  raftConfig: RaftConfig) : TrustedAuthorityNotaryService() {
     companion object {
-        val type = ValidatingNotaryService.type.getSubType("raft")
+        val id = constructId(validating = true, raft = true)
     }
 
     override val timeWindowChecker: TimeWindowChecker = TimeWindowChecker(services.clock)
-    override val uniquenessProvider: RaftUniquenessProvider = RaftUniquenessProvider(services)
+    override val uniquenessProvider: RaftUniquenessProvider = RaftUniquenessProvider(services, raftConfig)
 
-    override fun createServiceFlow(otherPartySession: FlowSession): NotaryFlow.Service = ValidatingNotaryFlow(otherPartySession, this)
+    override fun createServiceFlow(otherPartySession: FlowSession): NotaryFlow.Service {
+        return ValidatingNotaryFlow(otherPartySession, this)
+    }
 
     override fun start() {
         uniquenessProvider.start()
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/SimpleNotaryService.kt b/node/src/main/kotlin/net/corda/node/services/transactions/SimpleNotaryService.kt
index e62bcecb85..cb4401cae5 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/SimpleNotaryService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/SimpleNotaryService.kt
@@ -4,16 +4,11 @@ import net.corda.core.flows.FlowSession
 import net.corda.core.flows.NotaryFlow
 import net.corda.core.node.services.TimeWindowChecker
 import net.corda.core.node.services.TrustedAuthorityNotaryService
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.node.services.api.ServiceHubInternal
 import java.security.PublicKey
 
 /** A simple Notary service that does not perform transaction validation */
 class SimpleNotaryService(override val services: ServiceHubInternal, override val notaryIdentityKey: PublicKey) : TrustedAuthorityNotaryService() {
-    companion object {
-        val type = ServiceType.notary.getSubType("simple")
-    }
-
     override val timeWindowChecker = TimeWindowChecker(services.clock)
     override val uniquenessProvider = PersistentUniquenessProvider()
 
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryService.kt b/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryService.kt
index c13b9186f1..6c7e36046b 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryService.kt
@@ -4,16 +4,14 @@ import net.corda.core.flows.FlowSession
 import net.corda.core.flows.NotaryFlow
 import net.corda.core.node.services.TimeWindowChecker
 import net.corda.core.node.services.TrustedAuthorityNotaryService
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.node.services.api.ServiceHubInternal
 import java.security.PublicKey
 
 /** A Notary service that validates the transaction chain of the submitted transaction before committing it */
 class ValidatingNotaryService(override val services: ServiceHubInternal, override val notaryIdentityKey: PublicKey) : TrustedAuthorityNotaryService() {
     companion object {
-        val type = ServiceType.notary.getSubType("validating")
+        val id = constructId(validating = true)
     }
-
     override val timeWindowChecker = TimeWindowChecker(services.clock)
     override val uniquenessProvider = PersistentUniquenessProvider()
 
diff --git a/node/src/main/resources/reference.conf b/node/src/main/resources/reference.conf
index 37a91c5e5e..37ff984da6 100644
--- a/node/src/main/resources/reference.conf
+++ b/node/src/main/resources/reference.conf
@@ -19,10 +19,6 @@ useHTTPS = false
 h2port = 0
 useTestClock = false
 verifierType = InMemory
-bftSMaRt = {
-    replicaId = -1
-    debug = false
-}
 activeMQServer = {
     bridge = {
         retryIntervalMs = 5000
diff --git a/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt b/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt
index a4bfc6d12b..dbb62d3bac 100644
--- a/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt
+++ b/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt
@@ -33,7 +33,7 @@ class CordappSmokeTest {
             p2pPort = port.andIncrement,
             rpcPort = port.andIncrement,
             webPort = port.andIncrement,
-            extraServices = emptyList(),
+            isNotary = false,
             users = listOf(user)
     )
 
diff --git a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
index ce3f6f3a6b..a33dadfcea 100644
--- a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
+++ b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
@@ -28,9 +28,7 @@ import net.corda.node.internal.StartedNode
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
 import net.corda.node.services.messaging.CURRENT_RPC_CONTEXT
 import net.corda.node.services.messaging.RpcContext
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.User
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
@@ -68,7 +66,7 @@ class CordaRPCOpsImplTest {
 
         mockNet = MockNetwork()
         aliceNode = mockNet.createNode()
-        notaryNode = mockNet.createNode(advertisedServices = ServiceInfo(SimpleNotaryService.type))
+        notaryNode = mockNet.createNotaryNode(validating = false)
         rpc = CordaRPCOpsImpl(aliceNode.services, aliceNode.smm, aliceNode.database)
         CURRENT_RPC_CONTEXT.set(RpcContext(User("user", "pwd", permissions = setOf(
                 startFlowPermission<CashIssueFlow>(),
diff --git a/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt b/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt
index bbe685017a..1a08a04e76 100644
--- a/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt
@@ -13,8 +13,6 @@ import net.corda.core.utilities.ProgressTracker
 import net.corda.finance.DOLLARS
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.node.internal.cordapp.DummyRPCFlow
-import net.corda.node.services.transactions.ValidatingNotaryService
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.setCordappPackages
@@ -23,7 +21,10 @@ import org.junit.After
 import org.junit.Before
 import org.junit.Test
 import java.util.concurrent.atomic.AtomicInteger
-import kotlin.test.*
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertNotEquals
+import kotlin.test.assertTrue
 
 @StartableByService
 class DummyServiceFlow : FlowLogic<FlowInitiator>() {
@@ -86,9 +87,7 @@ class CordaServiceTest {
     fun start() {
         setCordappPackages("net.corda.node.internal","net.corda.finance")
         mockNet = MockNetwork(threadPerNode = true)
-        notaryNode = mockNet.createNode(
-                legalName = DUMMY_NOTARY.name,
-                advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type)))
+        notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name, validating = true)
         nodeA = mockNet.createNode()
         mockNet.startNodes()
     }
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 4bb4b6aa62..a758655ff8 100644
--- a/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
@@ -12,8 +12,6 @@ import net.corda.core.transactions.WireTransaction
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.seconds
 import net.corda.node.internal.StartedNode
-import net.corda.node.services.transactions.ValidatingNotaryService
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
@@ -39,12 +37,10 @@ class NotaryChangeTests {
     fun setUp() {
         setCordappPackages("net.corda.testing.contracts")
         mockNet = MockNetwork()
-        oldNotaryNode = mockNet.createNode(
-                legalName = DUMMY_NOTARY.name,
-                advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type)))
+        oldNotaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         clientNodeA = mockNet.createNode()
         clientNodeB = mockNet.createNode()
-        newNotaryNode = mockNet.createNode(advertisedServices = ServiceInfo(ValidatingNotaryService.type))
+        newNotaryNode = mockNet.createNotaryNode()
         mockNet.runNetwork() // Clear network map registration messages
         oldNotaryNode.internals.ensureRegistered()
         newNotaryParty = newNotaryNode.info.legalIdentities[1]
diff --git a/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
index b4cce7d46f..2935053699 100644
--- a/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
@@ -30,9 +30,7 @@ class FullNodeConfigurationTest {
                 rpcAddress = NetworkHostAndPort("localhost", 1),
                 messagingServerAddress = null,
                 extraAdvertisedServiceIds = emptyList(),
-                bftSMaRt = BFTSMaRtConfiguration(-1, false),
-                notaryNodeAddress = null,
-                notaryClusterAddresses = emptyList(),
+                notary = null,
                 certificateChainCheckPolicies = emptyList(),
                 devMode = true,
                 activeMQServer = ActiveMqServerConfiguration(BridgeConfiguration(0, 0, 0.0)))
diff --git a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
index 399f58f196..bb7c0d3e92 100644
--- a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
@@ -16,8 +16,6 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.statemachine.StateMachineManager
-import net.corda.node.services.transactions.ValidatingNotaryService
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
@@ -95,9 +93,7 @@ class ScheduledFlowTests {
     fun setup() {
         setCordappPackages("net.corda.testing.contracts")
         mockNet = MockNetwork(threadPerNode = true)
-        notaryNode = mockNet.createNode(
-                legalName = DUMMY_NOTARY.name,
-                advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type)))
+        notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         val a = mockNet.createUnstartedNode()
         val b = mockNet.createUnstartedNode()
 
diff --git a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
index 34f5e256a5..42b504a65e 100644
--- a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
@@ -6,10 +6,8 @@ import co.paralleluniverse.strands.concurrent.Semaphore
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.StateAndRef
-import net.corda.core.crypto.generateKeyPair
 import net.corda.core.crypto.random63BitValue
 import net.corda.core.flows.*
-import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.internal.concurrent.flatMap
 import net.corda.core.internal.concurrent.map
@@ -21,23 +19,16 @@ import net.corda.core.serialization.serialize
 import net.corda.core.toFuture
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.TransactionBuilder
-import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.ProgressTracker
 import net.corda.core.utilities.ProgressTracker.Change
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.unwrap
-import net.corda.finance.DOLLARS
-import net.corda.finance.flows.CashIssueFlow
-import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.internal.InitiatedFlowFactory
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.persistence.checkpoints
-import net.corda.node.services.transactions.ValidatingNotaryService
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.contracts.DummyState
-import net.corda.testing.node.InMemoryMessagingNetwork
 import net.corda.testing.node.InMemoryMessagingNetwork.MessageTransfer
 import net.corda.testing.node.InMemoryMessagingNetwork.ServicePeerAllocationStrategy.RoundRobin
 import net.corda.testing.node.MockNetwork
@@ -69,10 +60,8 @@ class FlowFrameworkTests {
     private val receivedSessionMessages = ArrayList<SessionTransfer>()
     private lateinit var node1: StartedNode<MockNode>
     private lateinit var node2: StartedNode<MockNode>
-    private lateinit var notary1: StartedNode<MockNode>
-    private lateinit var notary2: StartedNode<MockNode>
-    private lateinit var notary1Identity: Party
-    private lateinit var notary2Identity: Party
+    private lateinit var notary: StartedNode<MockNode>
+    private lateinit var notaryIdentity: Party
 
     @Before
     fun start() {
@@ -85,19 +74,13 @@ class FlowFrameworkTests {
         node1.internals.ensureRegistered()
 
         // We intentionally create our own notary and ignore the one provided by the network
-        val notaryKeyPair = generateKeyPair()
-        val notaryService = ServiceInfo(ValidatingNotaryService.type, CordaX500Name(commonName = ValidatingNotaryService.type.id, organisation = "Notary service 2000", locality = "London", country = "GB"))
-        val notaryIdentityOverride = Pair(notaryService, notaryKeyPair)
         // Note that these notaries don't operate correctly as they don't share their state. They are only used for testing
         // service addressing.
-        notary1 = mockNet.createNotaryNode(notaryIdentity = notaryIdentityOverride, serviceName = notaryService.name)
-        notary2 = mockNet.createNotaryNode(notaryIdentity = notaryIdentityOverride, serviceName = notaryService.name)
+        notary = mockNet.createNotaryNode()
 
         receivedSessionMessagesObservable().forEach { receivedSessionMessages += it }
         mockNet.runNetwork()
-
-        notary1Identity = notary1.services.myInfo.legalIdentities[1]
-        notary2Identity = notary2.services.myInfo.legalIdentities[1]
+        notaryIdentity = notary.services.myInfo.legalIdentities[1]
     }
 
     @After
@@ -335,62 +318,6 @@ class FlowFrameworkTests {
         )
     }
 
-    @Test
-    fun `different notaries are picked when addressing shared notary identity`() {
-        assertEquals(notary1Identity, notary2Identity)
-        assertThat(node1.services.networkMapCache.notaryIdentities.size == 1)
-        node1.services.startFlow(CashIssueFlow(
-                2000.DOLLARS,
-                OpaqueBytes.of(0x01),
-                notary1Identity)).resultFuture.getOrThrow()
-        // We pay a couple of times, the notary picking should go round robin
-        for (i in 1..3) {
-            val flow = node1.services.startFlow(CashPaymentFlow(500.DOLLARS, node2.info.chooseIdentity()))
-            mockNet.runNetwork()
-            flow.resultFuture.getOrThrow()
-        }
-        val endpoint = mockNet.messagingNetwork.endpoint(notary1.network.myAddress as InMemoryMessagingNetwork.PeerHandle)!!
-        val party1Info = notary1.services.networkMapCache.getPartyInfo(notary1Identity)!!
-        assertTrue(party1Info is PartyInfo.DistributedNode)
-        val notary1Address: MessageRecipients = endpoint.getAddressOfParty(notary1.services.networkMapCache.getPartyInfo(notary1Identity)!!)
-        assertThat(notary1Address).isInstanceOf(InMemoryMessagingNetwork.ServiceHandle::class.java)
-        assertEquals(notary1Address, endpoint.getAddressOfParty(notary2.services.networkMapCache.getPartyInfo(notary2Identity)!!))
-        receivedSessionMessages.expectEvents(isStrict = false) {
-            sequence(
-                    // First Pay
-                    expect(match = { it.message is SessionInit && it.message.initiatingFlowClass == NotaryFlow.Client::class.java.name }) {
-                        it.message as SessionInit
-                        assertEquals(node1.internals.id, it.from)
-                        assertEquals(notary1Address, it.to)
-                    },
-                    expect(match = { it.message is SessionConfirm }) {
-                        it.message as SessionConfirm
-                        assertEquals(notary1.internals.id, it.from)
-                    },
-                    // Second pay
-                    expect(match = { it.message is SessionInit && it.message.initiatingFlowClass == NotaryFlow.Client::class.java.name }) {
-                        it.message as SessionInit
-                        assertEquals(node1.internals.id, it.from)
-                        assertEquals(notary1Address, it.to)
-                    },
-                    expect(match = { it.message is SessionConfirm }) {
-                        it.message as SessionConfirm
-                        assertEquals(notary2.internals.id, it.from)
-                    },
-                    // Third pay
-                    expect(match = { it.message is SessionInit && it.message.initiatingFlowClass == NotaryFlow.Client::class.java.name }) {
-                        it.message as SessionInit
-                        assertEquals(node1.internals.id, it.from)
-                        assertEquals(notary1Address, it.to)
-                    },
-                    expect(match = { it.message is SessionConfirm }) {
-                        it.message as SessionConfirm
-                        assertEquals(it.from, notary1.internals.id)
-                    }
-            )
-        }
-    }
-
     @Test
     fun `other side ends before doing expected send`() {
         node2.registerFlowFactory(ReceiveFlow::class) { NoOpFlow() }
@@ -604,7 +531,7 @@ class FlowFrameworkTests {
 
     @Test
     fun `wait for transaction`() {
-        val ptx = TransactionBuilder(notary = notary1Identity)
+        val ptx = TransactionBuilder(notary = notaryIdentity)
                 .addOutputState(DummyState(), DummyContract.PROGRAM_ID)
                 .addCommand(dummyCommand(node1.info.chooseIdentity().owningKey))
         val stx = node1.services.signInitialTransaction(ptx)
@@ -619,7 +546,7 @@ class FlowFrameworkTests {
 
     @Test
     fun `committer throws exception before calling the finality flow`() {
-        val ptx = TransactionBuilder(notary = notary1Identity)
+        val ptx = TransactionBuilder(notary = notaryIdentity)
                 .addOutputState(DummyState(), DummyContract.PROGRAM_ID)
                 .addCommand(dummyCommand())
         val stx = node1.services.signInitialTransaction(ptx)
@@ -636,7 +563,7 @@ class FlowFrameworkTests {
 
     @Test
     fun `verify vault query service is tokenizable by force checkpointing within a flow`() {
-        val ptx = TransactionBuilder(notary = notary1Identity)
+        val ptx = TransactionBuilder(notary = notaryIdentity)
                 .addOutputState(DummyState(), DummyContract.PROGRAM_ID)
                 .addCommand(dummyCommand(node1.info.chooseIdentity().owningKey))
         val stx = node1.services.signInitialTransaction(ptx)
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
index e395ce739e..579f653018 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
@@ -13,7 +13,6 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.seconds
 import net.corda.node.internal.StartedNode
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
@@ -36,9 +35,7 @@ class NotaryServiceTests {
     fun setup() {
         setCordappPackages("net.corda.testing.contracts")
         mockNet = MockNetwork()
-        notaryNode = mockNet.createNode(
-                legalName = DUMMY_NOTARY.name,
-                advertisedServices = *arrayOf(ServiceInfo(SimpleNotaryService.type)))
+        notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name, validating = false)
         clientNode = mockNet.createNode()
         mockNet.runNetwork() // Clear network map registration messages
         notaryNode.internals.ensureRegistered()
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
index fb4741e373..87410fecb8 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
@@ -14,7 +14,6 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.issueInvalidState
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
@@ -36,10 +35,7 @@ class ValidatingNotaryServiceTests {
     fun setup() {
         setCordappPackages("net.corda.testing.contracts")
         mockNet = MockNetwork()
-        notaryNode = mockNet.createNode(
-                legalName = DUMMY_NOTARY.name,
-                advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type))
-        )
+        notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         clientNode = mockNet.createNode()
         mockNet.runNetwork() // Clear network map registration messages
         notaryNode.internals.ensureRegistered()
diff --git a/samples/attachment-demo/build.gradle b/samples/attachment-demo/build.gradle
index 1ca4d85d3d..379fcf6af8 100644
--- a/samples/attachment-demo/build.gradle
+++ b/samples/attachment-demo/build.gradle
@@ -40,7 +40,8 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     networkMap "O=Notary Service,L=Zurich,C=CH"
     node {
         name "O=Notary Service,L=Zurich,C=CH"
-        advertisedServices["corda.notary.validating"]
+        notary = [validating : true]
+        advertisedServices = []
         p2pPort 10002
         rpcPort 10003
         cordapps = []
diff --git a/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt b/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt
index 3f3458997b..d0cdb64932 100644
--- a/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt
+++ b/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt
@@ -2,9 +2,7 @@ package net.corda.attachmentdemo
 
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.User
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.DUMMY_BANK_A
 import net.corda.testing.DUMMY_BANK_B
 import net.corda.testing.DUMMY_NOTARY
@@ -22,7 +20,7 @@ class AttachmentDemoTest {
             val (nodeA, nodeB) = listOf(
                     startNode(providedName = DUMMY_BANK_A.name, rpcUsers = demoUser, maximumHeapSize = "1g"),
                     startNode(providedName = DUMMY_BANK_B.name, rpcUsers = demoUser, maximumHeapSize = "1g"),
-                    startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type))))
+                    startNotaryNode(DUMMY_NOTARY.name, validating = false))
                     .map { it.getOrThrow() }
             startWebserver(nodeB).getOrThrow()
 
diff --git a/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/Main.kt b/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/Main.kt
index b331dbacc7..f63d1c68a7 100644
--- a/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/Main.kt
+++ b/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/Main.kt
@@ -1,12 +1,10 @@
 package net.corda.attachmentdemo
 
 import net.corda.core.internal.div
-import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.nodeapi.User
 import net.corda.testing.DUMMY_BANK_A
 import net.corda.testing.DUMMY_BANK_B
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.node.services.transactions.SimpleNotaryService
-import net.corda.nodeapi.User
 import net.corda.testing.driver.driver
 
 /**
@@ -16,7 +14,7 @@ import net.corda.testing.driver.driver
 fun main(args: Array<String>) {
     val demoUser = listOf(User("demo", "demo", setOf("StartFlow.net.corda.flows.FinalityFlow")))
     driver(isDebug = true, driverDirectory = "build" / "attachment-demo-nodes") {
-        startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
+        startNotaryNode(DUMMY_NOTARY.name, validating = false)
         startNode(providedName = DUMMY_BANK_A.name, rpcUsers = demoUser)
         startNode(providedName = DUMMY_BANK_B.name, rpcUsers = demoUser)
         waitForAllNodesToFinish()
diff --git a/samples/bank-of-corda-demo/build.gradle b/samples/bank-of-corda-demo/build.gradle
index dcdbe408d0..c673a10da1 100644
--- a/samples/bank-of-corda-demo/build.gradle
+++ b/samples/bank-of-corda-demo/build.gradle
@@ -53,7 +53,8 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     networkMap "O=Notary Service,L=Zurich,C=CH"
     node {
         name "O=Notary Service,L=Zurich,C=CH"
-        advertisedServices = ["corda.notary.validating"]
+        notary = [validating : true]
+        advertisedServices = []
         p2pPort 10002
         rpcPort 10003
         cordapps = ["net.corda:finance:$corda_release_version"]
diff --git a/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaHttpAPITest.kt b/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaHttpAPITest.kt
index 22e33c41b9..8077105e41 100644
--- a/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaHttpAPITest.kt
+++ b/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaHttpAPITest.kt
@@ -3,8 +3,6 @@ package net.corda.bank
 import net.corda.bank.api.BankOfCordaClientApi
 import net.corda.bank.api.BankOfCordaWebApi.IssueRequestParams
 import net.corda.core.utilities.getOrThrow
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.testing.BOC
 import net.corda.testing.driver.driver
 import net.corda.testing.notary
@@ -16,7 +14,7 @@ class BankOfCordaHttpAPITest {
     fun `issuer flow via Http`() {
         driver(extraCordappPackagesToScan = listOf("net.corda.finance"), dsl = {
             val bigCorpNodeFuture = startNode(providedName = BIGCORP_LEGAL_NAME)
-            val nodeBankOfCordaFuture = startNode(providedName = BOC.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
+            val nodeBankOfCordaFuture = startNotaryNode(BOC.name, validating = false)
             val (nodeBankOfCorda) = listOf(nodeBankOfCordaFuture, bigCorpNodeFuture).map { it.getOrThrow() }
             val nodeBankOfCordaApiAddr = startWebserver(nodeBankOfCorda).getOrThrow().listenAddress
             val notaryName = notary().node.nodeInfo.legalIdentities[1].name
diff --git a/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt b/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt
index 157b2c0fd6..d379e3b98a 100644
--- a/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt
+++ b/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt
@@ -8,8 +8,6 @@ import net.corda.finance.DOLLARS
 import net.corda.finance.contracts.asset.Cash
 import net.corda.finance.flows.CashIssueAndPaymentFlow
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.User
 import net.corda.testing.*
 import net.corda.testing.driver.driver
@@ -22,7 +20,7 @@ class BankOfCordaRPCClientTest {
             val bocManager = User("bocManager", "password1", permissions = setOf(
                     startFlowPermission<CashIssueAndPaymentFlow>()))
             val bigCorpCFO = User("bigCorpCFO", "password2", permissions = emptySet())
-            val nodeBankOfCordaFuture = startNode(providedName = BOC.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)), rpcUsers = listOf(bocManager))
+            val nodeBankOfCordaFuture = startNotaryNode(BOC.name, rpcUsers = listOf(bocManager), validating = false)
             val nodeBigCorporationFuture = startNode(providedName = BIGCORP_LEGAL_NAME, rpcUsers = listOf(bigCorpCFO))
             val (nodeBankOfCorda, nodeBigCorporation) = listOf(nodeBankOfCordaFuture, nodeBigCorporationFuture).map { it.getOrThrow() }
 
diff --git a/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/BankOfCordaDriver.kt b/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/BankOfCordaDriver.kt
index e1b75e3f1b..ac2e890f09 100644
--- a/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/BankOfCordaDriver.kt
+++ b/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/BankOfCordaDriver.kt
@@ -9,8 +9,7 @@ import net.corda.finance.flows.CashExitFlow
 import net.corda.finance.flows.CashIssueAndPaymentFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.transactions.SimpleNotaryService
+import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.User
 import net.corda.testing.BOC
 import net.corda.testing.DUMMY_NOTARY
@@ -55,7 +54,7 @@ private class BankOfCordaDriver {
         val role = options.valueOf(roleArg)!!
 
         val requestParams = IssueRequestParams(options.valueOf(quantity), options.valueOf(currency), BIGCORP_LEGAL_NAME,
-                "1", BOC.name, DUMMY_NOTARY.name.copy(commonName = "corda.notary.validating"))
+                "1", BOC.name, DUMMY_NOTARY.name.copy(commonName = ValidatingNotaryService.id))
 
         try {
             when (role) {
@@ -70,8 +69,7 @@ private class BankOfCordaDriver {
                         val bigCorpUser = User(BIGCORP_USERNAME, "test",
                                 permissions = setOf(
                                         startFlowPermission<CashPaymentFlow>()))
-                        startNode(providedName = DUMMY_NOTARY.name,
-                                advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
+                        startNotaryNode(DUMMY_NOTARY.name, validating = false)
                         val bankOfCorda = startNode(
                                 providedName = BOC.name,
                                 rpcUsers = listOf(bankUser))
diff --git a/samples/irs-demo/build.gradle b/samples/irs-demo/build.gradle
index 6d9b908823..bc482b26d7 100644
--- a/samples/irs-demo/build.gradle
+++ b/samples/irs-demo/build.gradle
@@ -53,7 +53,8 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     networkMap "O=Notary Service,L=Zurich,C=CH"
     node {
         name "O=Notary Service,L=Zurich,C=CH"
-        advertisedServices = ["corda.notary.validating", "corda.interest_rates"]
+        notary = [validating : true]
+        advertisedServices = ["corda.interest_rates"]
         p2pPort 10002
         rpcPort 10003
         webPort 10004
diff --git a/samples/irs-demo/src/integration-test/kotlin/net/corda/irs/IRSDemoTest.kt b/samples/irs-demo/src/integration-test/kotlin/net/corda/irs/IRSDemoTest.kt
index 4d3c92b7dc..a598595f0b 100644
--- a/samples/irs-demo/src/integration-test/kotlin/net/corda/irs/IRSDemoTest.kt
+++ b/samples/irs-demo/src/integration-test/kotlin/net/corda/irs/IRSDemoTest.kt
@@ -21,9 +21,7 @@ import net.corda.finance.plugin.registerFinanceJSONMappers
 import net.corda.irs.contract.InterestRateSwap
 import net.corda.irs.utilities.uploadFile
 import net.corda.node.services.config.FullNodeConfiguration
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.User
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.driver.driver
 import net.corda.testing.http.HttpApi
@@ -50,9 +48,7 @@ class IRSDemoTest : IntegrationTestCategory {
     fun `runs IRS demo`() {
         driver(useTestClock = true, isDebug = true) {
             val (controller, nodeA, nodeB) = listOf(
-                    startNode(
-                            providedName = DUMMY_NOTARY.name,
-                            advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type))),
+                    startNotaryNode(DUMMY_NOTARY.name, validating = false),
                     startNode(providedName = DUMMY_BANK_A.name, rpcUsers = listOf(rpcUser)),
                     startNode(providedName = DUMMY_BANK_B.name))
                     .map { it.getOrThrow() }
diff --git a/samples/irs-demo/src/test/kotlin/net/corda/irs/Main.kt b/samples/irs-demo/src/test/kotlin/net/corda/irs/Main.kt
index 6cd3425e58..d1e770b257 100644
--- a/samples/irs-demo/src/test/kotlin/net/corda/irs/Main.kt
+++ b/samples/irs-demo/src/test/kotlin/net/corda/irs/Main.kt
@@ -1,8 +1,6 @@
 package net.corda.irs
 
 import net.corda.core.utilities.getOrThrow
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.testing.DUMMY_BANK_A
 import net.corda.testing.DUMMY_BANK_B
 import net.corda.testing.DUMMY_NOTARY
@@ -15,9 +13,7 @@ import net.corda.testing.driver.driver
 fun main(args: Array<String>) {
     driver(dsl = {
         val (controller, nodeA, nodeB) = listOf(
-                startNode(
-                        providedName = DUMMY_NOTARY.name,
-                        advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type))),
+                startNotaryNode(DUMMY_NOTARY.name, validating = false),
                 startNode(providedName = DUMMY_BANK_A.name),
                 startNode(providedName = DUMMY_BANK_B.name))
                 .map { it.getOrThrow() }
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
index ea09fa73c0..46a38d7f5e 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
@@ -11,18 +11,13 @@ import net.corda.irs.api.NodeInterestRates
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.statemachine.StateMachineManager
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.nodeapi.internal.ServiceType
-import net.corda.testing.DUMMY_MAP
-import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.DUMMY_REGULATOR
+import net.corda.testing.*
 import net.corda.testing.node.InMemoryMessagingNetwork
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.TestClock
 import net.corda.testing.node.setTo
-import net.corda.testing.setCordappPackages
-import net.corda.testing.testNodeConfiguration
 import rx.Observable
 import rx.subjects.PublishSubject
 import java.math.BigInteger
@@ -103,10 +98,11 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
                             advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): SimulatedNode {
-            require(advertisedServices.containsType(SimpleNotaryService.type))
+            requireNotNull(config.notary)
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
-                    myLegalName = DUMMY_NOTARY.name)
+                    myLegalName = DUMMY_NOTARY.name,
+                    notaryConfig = config.notary)
             return SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot)
         }
     }
@@ -153,7 +149,7 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
     val mockNet = MockNetwork(networkSendManuallyPumped, runAsync)
     // This one must come first.
     val networkMap = mockNet.startNetworkMapNode(nodeFactory = NetworkMapNodeFactory)
-    val notary = mockNet.createNode(nodeFactory = NotaryNodeFactory, advertisedServices = ServiceInfo(SimpleNotaryService.type))
+    val notary = mockNet.createNotaryNode(validating = false, nodeFactory = NotaryNodeFactory)
     val regulators = listOf(mockNet.createUnstartedNode(nodeFactory = RegulatorFactory))
     val ratesOracle = mockNet.createUnstartedNode(nodeFactory = RatesOracleFactory)
 
diff --git a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/BFTNotaryCordform.kt b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/BFTNotaryCordform.kt
index 87c12cd663..477adecd20 100644
--- a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/BFTNotaryCordform.kt
+++ b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/BFTNotaryCordform.kt
@@ -5,10 +5,9 @@ import net.corda.cordform.CordformDefinition
 import net.corda.cordform.CordformNode
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.div
-import net.corda.core.internal.stream
-import net.corda.core.internal.toTypedArray
 import net.corda.core.utilities.NetworkHostAndPort
-import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.node.services.config.BFTSMaRtConfiguration
+import net.corda.node.services.config.NotaryConfig
 import net.corda.node.services.transactions.BFTNonValidatingNotaryService
 import net.corda.node.services.transactions.minCorrectReplicas
 import net.corda.node.utilities.ServiceIdentityGenerator
@@ -24,9 +23,7 @@ private val notaryNames = createNotaryNames(clusterSize)
 // This is not the intended final design for how to use CordformDefinition, please treat this as experimental and DO
 // NOT use this as a design to copy.
 object BFTNotaryCordform : CordformDefinition("build" / "notary-demo-nodes", notaryNames[0].toString()) {
-    private val serviceType = BFTNonValidatingNotaryService.type
-    private val clusterName = CordaX500Name(serviceType.id, "BFT", "Zurich", "CH")
-    private val advertisedService = ServiceInfo(serviceType, clusterName)
+    private val clusterName = CordaX500Name(BFTNonValidatingNotaryService.id, "BFT", "Zurich", "CH")
 
     init {
         node {
@@ -40,12 +37,10 @@ object BFTNotaryCordform : CordformDefinition("build" / "notary-demo-nodes", not
             p2pPort(10005)
             rpcPort(10006)
         }
-        val clusterAddresses = (0 until clusterSize).stream().mapToObj { NetworkHostAndPort("localhost", 11000 + it * 10) }.toTypedArray()
+        val clusterAddresses = (0 until clusterSize).map { NetworkHostAndPort("localhost", 11000 + it * 10) }
         fun notaryNode(replicaId: Int, configure: CordformNode.() -> Unit) = node {
             name(notaryNames[replicaId])
-            advertisedServices(advertisedService)
-            notaryClusterAddresses(*clusterAddresses)
-            bftReplicaId(replicaId)
+            notary(NotaryConfig(validating = false, bftSMaRt = BFTSMaRtConfiguration(replicaId, clusterAddresses)))
             configure()
         }
         notaryNode(0) {
diff --git a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/RaftNotaryCordform.kt b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/RaftNotaryCordform.kt
index 2aa043364a..1d78c51266 100644
--- a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/RaftNotaryCordform.kt
+++ b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/RaftNotaryCordform.kt
@@ -6,7 +6,8 @@ import net.corda.cordform.CordformNode
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.div
 import net.corda.core.utilities.NetworkHostAndPort
-import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.node.services.config.NotaryConfig
+import net.corda.node.services.config.RaftConfig
 import net.corda.node.services.transactions.RaftValidatingNotaryService
 import net.corda.node.utilities.ServiceIdentityGenerator
 import net.corda.testing.ALICE
@@ -22,9 +23,7 @@ private val notaryNames = createNotaryNames(3)
 // This is not the intended final design for how to use CordformDefinition, please treat this as experimental and DO
 // NOT use this as a design to copy.
 object RaftNotaryCordform : CordformDefinition("build" / "notary-demo-nodes", notaryNames[0].toString()) {
-    private val serviceType = RaftValidatingNotaryService.type
-    private val clusterName = CordaX500Name(serviceType.id, "Raft", "Zurich", "CH")
-    private val advertisedService = ServiceInfo(serviceType, clusterName)
+    private val clusterName = CordaX500Name(RaftValidatingNotaryService.id, "Raft", "Zurich", "CH")
 
     init {
         node {
@@ -38,28 +37,23 @@ object RaftNotaryCordform : CordformDefinition("build" / "notary-demo-nodes", no
             p2pPort(10005)
             rpcPort(10006)
         }
-        fun notaryNode(index: Int, configure: CordformNode.() -> Unit) = node {
+        fun notaryNode(index: Int, nodePort: Int, clusterPort: Int? = null, configure: CordformNode.() -> Unit) = node {
             name(notaryNames[index])
-            advertisedServices(advertisedService)
+            val clusterAddresses = if (clusterPort != null ) listOf(NetworkHostAndPort("localhost", clusterPort)) else emptyList()
+            notary(NotaryConfig(validating = true, raft = RaftConfig(NetworkHostAndPort("localhost", nodePort), clusterAddresses)))
             configure()
         }
-        notaryNode(0) {
-            notaryNodePort(10008)
+        notaryNode(0, 10008) {
             p2pPort(10009)
             rpcPort(10010)
         }
-        val clusterAddress = NetworkHostAndPort("localhost", 10008) // Otherwise each notary forms its own cluster.
-        notaryNode(1) {
-            notaryNodePort(10012)
+        notaryNode(1, 10012, 10008) {
             p2pPort(10013)
             rpcPort(10014)
-            notaryClusterAddresses(clusterAddress)
         }
-        notaryNode(2) {
-            notaryNodePort(10016)
+        notaryNode(2, 10016, 10008) {
             p2pPort(10017)
             rpcPort(10018)
-            notaryClusterAddresses(clusterAddress)
         }
     }
 
diff --git a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/SingleNotaryCordform.kt b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/SingleNotaryCordform.kt
index e9c45fd7e4..beec66a8fc 100644
--- a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/SingleNotaryCordform.kt
+++ b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/SingleNotaryCordform.kt
@@ -1,17 +1,16 @@
 package net.corda.notarydemo
 
+import net.corda.cordform.CordformContext
+import net.corda.cordform.CordformDefinition
 import net.corda.core.internal.div
-import net.corda.testing.ALICE
-import net.corda.testing.BOB
-import net.corda.testing.DUMMY_NOTARY
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.node.services.transactions.ValidatingNotaryService
+import net.corda.node.services.config.NotaryConfig
 import net.corda.nodeapi.User
 import net.corda.notarydemo.flows.DummyIssueAndMove
 import net.corda.notarydemo.flows.RPCStartableNotaryFlowClient
-import net.corda.cordform.CordformDefinition
-import net.corda.cordform.CordformContext
-import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.testing.ALICE
+import net.corda.testing.BOB
+import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.internal.demorun.*
 
 fun main(args: Array<String>) = SingleNotaryCordform.runNodes()
@@ -37,7 +36,7 @@ object SingleNotaryCordform : CordformDefinition("build" / "notary-demo-nodes",
             name(DUMMY_NOTARY.name)
             p2pPort(10009)
             rpcPort(10010)
-            advertisedServices(ServiceInfo(ValidatingNotaryService.type))
+            notary(NotaryConfig(validating = true))
         }
     }
 
diff --git a/samples/simm-valuation-demo/build.gradle b/samples/simm-valuation-demo/build.gradle
index 278608bd77..ffce26eb4f 100644
--- a/samples/simm-valuation-demo/build.gradle
+++ b/samples/simm-valuation-demo/build.gradle
@@ -1,5 +1,3 @@
-import org.apache.tools.ant.filters.FixCrLfFilter
-
 buildscript {
     ext.strata_version = '1.1.2'
 }
@@ -68,7 +66,8 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     networkMap "O=Notary Service,L=Zurich,C=CH"
     node {
         name "O=Notary Service,L=Zurich,C=CH"
-        advertisedServices = ["corda.notary.validating"]
+        notary = [validating : true]
+        advertisedServices = []
         p2pPort 10002
         cordapps = ["net.corda:finance:$corda_release_version"]
     }
diff --git a/samples/simm-valuation-demo/src/integration-test/kotlin/net/corda/vega/SimmValuationTest.kt b/samples/simm-valuation-demo/src/integration-test/kotlin/net/corda/vega/SimmValuationTest.kt
index a81b898920..e113f235b7 100644
--- a/samples/simm-valuation-demo/src/integration-test/kotlin/net/corda/vega/SimmValuationTest.kt
+++ b/samples/simm-valuation-demo/src/integration-test/kotlin/net/corda/vega/SimmValuationTest.kt
@@ -3,16 +3,9 @@ package net.corda.vega
 import com.opengamma.strata.product.common.BuySell
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.utilities.getOrThrow
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.transactions.SimpleNotaryService
-import net.corda.testing.DUMMY_BANK_A
-import net.corda.testing.DUMMY_BANK_B
-import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.IntegrationTestCategory
+import net.corda.testing.*
 import net.corda.testing.driver.driver
 import net.corda.testing.http.HttpApi
-import net.corda.testing.setCordappPackages
-import net.corda.testing.unsetCordappPackages
 import net.corda.vega.api.PortfolioApi
 import net.corda.vega.api.PortfolioApiUtils
 import net.corda.vega.api.SwapDataModel
@@ -46,7 +39,7 @@ class SimmValuationTest : IntegrationTestCategory {
     @Test
     fun `runs SIMM valuation demo`() {
         driver(isDebug = true) {
-            startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type))).getOrThrow()
+            startNotaryNode(DUMMY_NOTARY.name, validating = false).getOrThrow()
             val nodeAFuture = startNode(providedName = nodeALegalName)
             val nodeBFuture = startNode(providedName = nodeBLegalName)
             val (nodeA, nodeB) = listOf(nodeAFuture, nodeBFuture).map { it.getOrThrow() }
diff --git a/samples/simm-valuation-demo/src/test/kotlin/net/corda/vega/Main.kt b/samples/simm-valuation-demo/src/test/kotlin/net/corda/vega/Main.kt
index ee855f6ffc..9cc72b5af0 100644
--- a/samples/simm-valuation-demo/src/test/kotlin/net/corda/vega/Main.kt
+++ b/samples/simm-valuation-demo/src/test/kotlin/net/corda/vega/Main.kt
@@ -1,12 +1,10 @@
 package net.corda.vega
 
 import net.corda.core.utilities.getOrThrow
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.DUMMY_BANK_A
 import net.corda.testing.DUMMY_BANK_B
 import net.corda.testing.DUMMY_BANK_C
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.testing.driver.driver
 
 /**
@@ -16,7 +14,7 @@ import net.corda.testing.driver.driver
  */
 fun main(args: Array<String>) {
     driver(dsl = {
-        val notaryFuture = startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
+        val notaryFuture = startNotaryNode(DUMMY_NOTARY.name, validating = false)
         val nodeAFuture = startNode(providedName = DUMMY_BANK_A.name)
         val nodeBFuture = startNode(providedName = DUMMY_BANK_B.name)
         val nodeCFuture = startNode(providedName = DUMMY_BANK_C.name)
diff --git a/samples/trader-demo/build.gradle b/samples/trader-demo/build.gradle
index 5d2a1750eb..5d6f861e8a 100644
--- a/samples/trader-demo/build.gradle
+++ b/samples/trader-demo/build.gradle
@@ -54,7 +54,8 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     networkMap "O=Notary Service,L=Zurich,C=CH"
     node {
         name "O=Notary Service,L=Zurich,C=CH"
-        advertisedServices = ["corda.notary.validating"]
+        notary = [validating : true]
+        advertisedServices = []
         p2pPort 10002
         cordapps = ["net.corda:finance:$corda_release_version"]
     }
diff --git a/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt b/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
index 93034badfe..0efa101ec7 100644
--- a/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
+++ b/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
@@ -9,9 +9,7 @@ import net.corda.finance.flows.CashPaymentFlow
 import net.corda.finance.schemas.CashSchemaV1
 import net.corda.finance.schemas.CommercialPaperSchemaV1
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.User
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.driver.poll
 import net.corda.testing.node.NodeBasedTest
@@ -43,7 +41,7 @@ class TraderDemoTest : NodeBasedTest() {
                 startFlowPermission<CashIssueFlow>(),
                 startFlowPermission<CashPaymentFlow>(),
                 startFlowPermission<CommercialPaperIssueFlow>()))
-        val notaryFuture = startNode(DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
+        val notaryFuture = startNotaryNode(DUMMY_NOTARY.name, validating = false)
         val nodeAFuture = startNode(DUMMY_BANK_A.name, rpcUsers = listOf(demoUser))
         val nodeBFuture = startNode(DUMMY_BANK_B.name, rpcUsers = listOf(demoUser))
         val bankNodeFuture = startNode(BOC.name, rpcUsers = listOf(bankUser))
diff --git a/samples/trader-demo/src/test/kotlin/net/corda/traderdemo/Main.kt b/samples/trader-demo/src/test/kotlin/net/corda/traderdemo/Main.kt
index 5b41ae9ec3..4a032576f5 100644
--- a/samples/trader-demo/src/test/kotlin/net/corda/traderdemo/Main.kt
+++ b/samples/trader-demo/src/test/kotlin/net/corda/traderdemo/Main.kt
@@ -3,8 +3,6 @@ package net.corda.traderdemo
 import net.corda.core.internal.div
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.nodeapi.User
 import net.corda.testing.BOC
 import net.corda.testing.DUMMY_BANK_A
@@ -27,7 +25,7 @@ fun main(args: Array<String>) {
         val user = User("user1", "test", permissions = setOf(startFlowPermission<CashIssueFlow>(),
                 startFlowPermission<CommercialPaperIssueFlow>(),
                 startFlowPermission<SellerFlow>()))
-        startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
+        startNotaryNode(DUMMY_NOTARY.name, validating = false)
         startNode(providedName = DUMMY_BANK_A.name, rpcUsers = demoUser)
         startNode(providedName = DUMMY_BANK_B.name, rpcUsers = demoUser)
         startNode(providedName = BOC.name, rpcUsers = listOf(user))
diff --git a/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt b/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
index f9fc3f3002..ae31e3bbb5 100644
--- a/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
+++ b/testing/node-driver/src/integration-test/kotlin/net/corda/testing/FlowStackSnapshotTest.kt
@@ -9,9 +9,7 @@ import net.corda.core.internal.read
 import net.corda.core.messaging.startFlow
 import net.corda.core.serialization.CordaSerializable
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.User
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.driver.driver
 import net.corda.testing.node.MockNetwork
 import org.junit.Ignore
@@ -292,11 +290,7 @@ class FlowStackSnapshotTest {
     @Test
     fun `flowStackSnapshot object is serializable`() {
         val mockNet = MockNetwork(threadPerNode = true)
-        val notaryService = ServiceInfo(ValidatingNotaryService.type)
-        val notaryNode = mockNet.createNode(
-                legalName = DUMMY_NOTARY.name,
-                notaryIdentity = notaryService to DUMMY_NOTARY_KEY,
-                advertisedServices = *arrayOf(notaryService))
+        mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         val node = mockNet.createPartyNode()
         node.internals.registerInitiatedFlow(DummyFlow::class.java)
         node.services.startFlow(FlowStackSnapshotSerializationTestingFlow()).resultFuture.get()
diff --git a/testing/node-driver/src/integration-test/kotlin/net/corda/testing/driver/DriverTests.kt b/testing/node-driver/src/integration-test/kotlin/net/corda/testing/driver/DriverTests.kt
index 43260d5500..c9cf4ae4a0 100644
--- a/testing/node-driver/src/integration-test/kotlin/net/corda/testing/driver/DriverTests.kt
+++ b/testing/node-driver/src/integration-test/kotlin/net/corda/testing/driver/DriverTests.kt
@@ -5,12 +5,10 @@ import net.corda.core.internal.div
 import net.corda.core.internal.list
 import net.corda.core.internal.readLines
 import net.corda.core.utilities.getOrThrow
+import net.corda.node.internal.NodeStartup
 import net.corda.testing.DUMMY_BANK_A
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.DUMMY_REGULATOR
-import net.corda.node.internal.NodeStartup
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.transactions.SimpleNotaryService
 import net.corda.testing.ProjectStructure.projectRootDir
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
@@ -40,7 +38,7 @@ class DriverTests {
     @Test
     fun `simple node startup and shutdown`() {
         val handles = driver {
-            val notary = startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
+            val notary = startNotaryNode(DUMMY_NOTARY.name, validating = false)
             val regulator = startNode(providedName = DUMMY_REGULATOR.name)
             listOf(nodeMustBeUp(notary), nodeMustBeUp(regulator))
         }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/DriverConstants.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/DriverConstants.kt
index 398cc9262c..1a17d02f3a 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/DriverConstants.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/DriverConstants.kt
@@ -5,8 +5,6 @@ package net.corda.testing
 import net.corda.core.identity.Party
 import net.corda.core.internal.concurrent.transpose
 import net.corda.core.messaging.CordaRPCOps
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.User
 import net.corda.testing.driver.DriverDSLExposedInterface
 
@@ -19,9 +17,15 @@ import net.corda.testing.driver.DriverDSLExposedInterface
  * node construction won't start until you access the members. You can get one of these from the
  * [alice], [bob] and [aliceBobAndNotary] functions.
  */
-class PredefinedTestNode internal constructor(party: Party, driver: DriverDSLExposedInterface, services: Set<ServiceInfo>) {
+class PredefinedTestNode internal constructor(party: Party, driver: DriverDSLExposedInterface, ifNotaryIsValidating: Boolean?) {
     val rpcUsers = listOf(User("admin", "admin", setOf("ALL")))  // TODO: Randomize?
-    val nodeFuture by lazy { driver.startNode(providedName = party.name, rpcUsers = rpcUsers, advertisedServices = services) }
+    val nodeFuture by lazy {
+        if (ifNotaryIsValidating != null) {
+            driver.startNotaryNode(providedName = party.name, rpcUsers = rpcUsers, validating = ifNotaryIsValidating)
+        } else {
+            driver.startNode(providedName = party.name, rpcUsers = rpcUsers)
+        }
+    }
     val node by lazy { nodeFuture.get()!! }
     val rpc by lazy { node.rpcClientToNode() }
 
@@ -34,17 +38,17 @@ class PredefinedTestNode internal constructor(party: Party, driver: DriverDSLExp
  * Returns a plain, entirely stock node pre-configured with the [ALICE] identity. Note that a random key will be generated
  * for it: you won't have [ALICE_KEY].
  */
-fun DriverDSLExposedInterface.alice(): PredefinedTestNode = PredefinedTestNode(ALICE, this, emptySet())
+fun DriverDSLExposedInterface.alice(): PredefinedTestNode = PredefinedTestNode(ALICE, this, null)
 /**
  * Returns a plain, entirely stock node pre-configured with the [BOB] identity. Note that a random key will be generated
  * for it: you won't have [BOB_KEY].
  */
-fun DriverDSLExposedInterface.bob(): PredefinedTestNode = PredefinedTestNode(BOB, this, emptySet())
+fun DriverDSLExposedInterface.bob(): PredefinedTestNode = PredefinedTestNode(BOB, this, null)
 /**
  * Returns a plain single node notary pre-configured with the [DUMMY_NOTARY] identity. Note that a random key will be generated
  * for it: you won't have [DUMMY_NOTARY_KEY].
  */
-fun DriverDSLExposedInterface.notary(): PredefinedTestNode = PredefinedTestNode(DUMMY_NOTARY, this, setOf(ServiceInfo(ValidatingNotaryService.type)))
+fun DriverDSLExposedInterface.notary(): PredefinedTestNode = PredefinedTestNode(DUMMY_NOTARY, this, true)
 
 /**
  * Returns plain, entirely stock nodes pre-configured with the [ALICE], [BOB] and [DUMMY_NOTARY] X.500 names in that
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt
index 088eaaf6f0..7f8069e919 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt
@@ -8,8 +8,8 @@ import net.corda.core.identity.CordaX500Name
 import net.corda.core.node.ServiceHub
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.node.services.config.NodeConfiguration
+import net.corda.node.services.config.NotaryConfig
 import net.corda.node.services.config.VerifierType
-import net.corda.testing.node.MockCordappProvider
 import net.corda.testing.node.MockServices
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
 import net.corda.testing.node.MockServices.Companion.makeTestDatabaseProperties
@@ -51,7 +51,8 @@ import java.nio.file.Path
 
 fun testNodeConfiguration(
         baseDirectory: Path,
-        myLegalName: CordaX500Name): NodeConfiguration {
+        myLegalName: CordaX500Name,
+        notaryConfig: NotaryConfig? = null): NodeConfiguration {
     abstract class MockableNodeConfiguration : NodeConfiguration // Otherwise Mockito is defeated by val getters.
     val nc = spy<MockableNodeConfiguration>()
     whenever(nc.baseDirectory).thenReturn(baseDirectory)
@@ -60,6 +61,7 @@ fun testNodeConfiguration(
     whenever(nc.keyStorePassword).thenReturn("cordacadevpass")
     whenever(nc.trustStorePassword).thenReturn("trustpass")
     whenever(nc.rpcUsers).thenReturn(emptyList())
+    whenever(nc.notary).thenReturn(notaryConfig)
     whenever(nc.dataSourceProperties).thenReturn(makeTestDataSourceProperties(myLegalName.organisation))
     whenever(nc.database).thenReturn(makeTestDatabaseProperties())
     whenever(nc.emailAddress).thenReturn("")
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
index 344244bfa4..9382ce4b3a 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
@@ -26,12 +26,11 @@ import net.corda.node.internal.NodeStartup
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.config.*
 import net.corda.node.services.network.NetworkMapService
-import net.corda.node.services.transactions.RaftValidatingNotaryService
 import net.corda.node.utilities.ServiceIdentityGenerator
 import net.corda.nodeapi.User
 import net.corda.nodeapi.config.parseAs
+import net.corda.nodeapi.config.toConfig
 import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.nodeapi.internal.addShutdownHook
 import net.corda.testing.*
 import net.corda.testing.node.MockServices.Companion.MOCK_VERSION_INFO
@@ -96,6 +95,14 @@ interface DriverDSLExposedInterface : CordformContext {
             startInSameProcess: Boolean? = defaultParameters.startInSameProcess,
             maximumHeapSize: String = defaultParameters.maximumHeapSize): CordaFuture<NodeHandle>
 
+    // TODO This method has been added temporarily, to be deleted once the set of notaries is defined at the network level.
+    fun startNotaryNode(providedName: CordaX500Name,
+                        rpcUsers: List<User> = emptyList(),
+                        verifierType: VerifierType = VerifierType.InMemory,
+                        customOverrides: Map<String, Any?> = emptyMap(),
+                        //TODO Switch the default value
+                        validating: Boolean = true): CordaFuture<NodeHandle>
+
     /**
      * Helper function for starting a [node] with custom parameters from Java.
      *
@@ -118,7 +125,6 @@ interface DriverDSLExposedInterface : CordformContext {
      *
      * @param notaryName The legal name of the advertised distributed notary service.
      * @param clusterSize Number of nodes to create for the cluster.
-     * @param type The advertised notary service type. Currently the only supported type is [RaftValidatingNotaryService.type].
      * @param verifierType The type of transaction verifier to use. See: [VerifierType]
      * @param rpcUsers List of users who are authorised to use the RPC system. Defaults to empty list.
      * @param startInSameProcess Determines if the node should be started inside the same process the Driver is running
@@ -128,7 +134,6 @@ interface DriverDSLExposedInterface : CordformContext {
     fun startNotaryCluster(
             notaryName: CordaX500Name,
             clusterSize: Int = 3,
-            type: ServiceType = RaftValidatingNotaryService.type,
             verifierType: VerifierType = VerifierType.InMemory,
             rpcUsers: List<User> = emptyList(),
             startInSameProcess: Boolean? = null): CordaFuture<Pair<Party, List<NodeHandle>>>
@@ -668,9 +673,9 @@ class DriverDSL(
                     }
                 }
                 is NetworkMapStartStrategy.Nominated -> {
-                    serviceConfig(networkMapCandidates.filter {
+                    serviceConfig(networkMapCandidates.single {
                         it.name == legalName.toString()
-                    }.single().config.getString("p2pAddress").let(NetworkHostAndPort.Companion::parse)).let {
+                    }.config.getString("p2pAddress").let(NetworkHostAndPort.Companion::parse)).let {
                         { nodeName: CordaX500Name -> if (nodeName == legalName) null else it }
                     }
                 }
@@ -715,6 +720,15 @@ class DriverDSL(
         return startNodeInternal(config, webAddress, startInSameProcess, maximumHeapSize)
     }
 
+    override fun startNotaryNode(providedName: CordaX500Name,
+                                 rpcUsers: List<User>,
+                                 verifierType: VerifierType,
+                                 customOverrides: Map<String, Any?>,
+                                 validating: Boolean): CordaFuture<NodeHandle> {
+        val config = customOverrides + NotaryConfig(validating).toConfigMap()
+        return startNode(providedName = providedName, rpcUsers = rpcUsers, verifierType = verifierType, customOverrides = config)
+    }
+
     override fun startNodes(nodes: List<CordformNode>, startInSameProcess: Boolean?, maximumHeapSize: String): List<CordaFuture<NodeHandle>> {
         val networkMapServiceConfigLookup = networkMapServiceConfigLookup(nodes)
         return nodes.map { node ->
@@ -722,50 +736,62 @@ class DriverDSL(
             val webAddress = portAllocation.nextHostAndPort()
             val name = CordaX500Name.parse(node.name)
             val rpcUsers = node.rpcUsers
+            val notary = if (node.notary != null) mapOf("notary" to node.notary) else emptyMap()
             val config = ConfigHelper.loadConfig(
                     baseDirectory = baseDirectory(name),
                     allowMissingConfig = true,
-                    configOverrides = node.config + mapOf(
+                    configOverrides = node.config + notary + mapOf(
                             "extraAdvertisedServiceIds" to node.advertisedServices,
                             "networkMapService" to networkMapServiceConfigLookup(name),
-                            "rpcUsers" to if (rpcUsers.isEmpty()) defaultRpcUserList else rpcUsers,
-                            "notaryClusterAddresses" to node.notaryClusterAddresses
+                            "rpcUsers" to if (rpcUsers.isEmpty()) defaultRpcUserList else rpcUsers
                     )
             )
             startNodeInternal(config, webAddress, startInSameProcess, maximumHeapSize)
         }
     }
 
+    // TODO This mapping is done is several plaecs including the gradle plugin. In general we need a better way of
+    // generating the configs for the nodes, probably making use of Any.toConfig()
+    private fun NotaryConfig.toConfigMap(): Map<String, Any> = mapOf("notary" to toConfig().root().unwrapped())
+
     override fun startNotaryCluster(
             notaryName: CordaX500Name,
             clusterSize: Int,
-            type: ServiceType,
             verifierType: VerifierType,
             rpcUsers: List<User>,
             startInSameProcess: Boolean?
     ): CordaFuture<Pair<Party, List<NodeHandle>>> {
+        fun notaryConfig(nodeAddress: NetworkHostAndPort, clusterAddress: NetworkHostAndPort? = null): Map<String, Any> {
+            val clusterAddresses = if (clusterAddress != null) listOf(clusterAddress) else emptyList()
+            val config = NotaryConfig(validating = true, raft = RaftConfig(nodeAddress = nodeAddress, clusterAddresses = clusterAddresses))
+            return config.toConfigMap()
+        }
+
         val nodeNames = (0 until clusterSize).map { CordaX500Name("Notary Service $it", "Zurich", "CH") }
         val paths = nodeNames.map { baseDirectory(it) }
         ServiceIdentityGenerator.generateToDisk(paths, notaryName)
-        val advertisedServices = setOf(ServiceInfo(type, notaryName))
-        val notaryClusterAddress = portAllocation.nextHostAndPort()
+        val clusterAddress = portAllocation.nextHostAndPort()
 
         // Start the first node that will bootstrap the cluster
         val firstNotaryFuture = startNode(
                 providedName = nodeNames.first(),
-                advertisedServices = advertisedServices,
                 rpcUsers = rpcUsers,
                 verifierType = verifierType,
-                customOverrides = mapOf("notaryNodeAddress" to notaryClusterAddress.toString(),
-                        "database.serverNameTablePrefix" to if (nodeNames.isNotEmpty()) nodeNames.first().toString().replace(Regex("[^0-9A-Za-z]+"), "") else ""),
+                customOverrides = notaryConfig(clusterAddress) + mapOf(
+                        "database.serverNameTablePrefix" to if (nodeNames.isNotEmpty()) nodeNames.first().toString().replace(Regex("[^0-9A-Za-z]+"), "") else ""
+                ),
                 startInSameProcess = startInSameProcess
         )
         // All other nodes will join the cluster
         val restNotaryFutures = nodeNames.drop(1).map {
             val nodeAddress = portAllocation.nextHostAndPort()
-            val configOverride = mapOf("notaryNodeAddress" to nodeAddress.toString(), "notaryClusterAddresses" to listOf(notaryClusterAddress.toString()),
-                    "database.serverNameTablePrefix" to it.toString().replace(Regex("[^0-9A-Za-z]+"), ""))
-            startNode(providedName = it, advertisedServices = advertisedServices, rpcUsers = rpcUsers, verifierType = verifierType, customOverrides = configOverride)
+            startNode(
+                    providedName = it,
+                    rpcUsers = rpcUsers,
+                    verifierType = verifierType,
+                    customOverrides = notaryConfig(nodeAddress, clusterAddress) + mapOf(
+                            "database.serverNameTablePrefix" to it.toString().replace(Regex("[^0-9A-Za-z]+"), "")
+                    ))
         }
 
         return firstNotaryFuture.flatMap { firstNotary ->
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/CordformUtils.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/CordformUtils.kt
index c7006d02f4..80f078d2bf 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/CordformUtils.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/CordformUtils.kt
@@ -5,9 +5,10 @@ package net.corda.testing.internal.demorun
 import net.corda.cordform.CordformDefinition
 import net.corda.cordform.CordformNode
 import net.corda.core.identity.CordaX500Name
-import net.corda.core.utilities.NetworkHostAndPort
-import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.node.services.config.NotaryConfig
 import net.corda.nodeapi.User
+import net.corda.nodeapi.config.toConfig
+import net.corda.nodeapi.internal.ServiceInfo
 
 fun CordformDefinition.node(configure: CordformNode.() -> Unit) {
     addNode { cordformNode -> cordformNode.configure() }
@@ -19,10 +20,10 @@ fun CordformNode.rpcUsers(vararg users: User) {
     rpcUsers = users.map { it.toMap() }
 }
 
+fun CordformNode.notary(notaryConfig: NotaryConfig) {
+    notary = notaryConfig.toConfig().root().unwrapped()
+}
+
 fun CordformNode.advertisedServices(vararg services: ServiceInfo) {
     advertisedServices = services.map { it.toString() }
 }
-
-fun CordformNode.notaryClusterAddresses(vararg addresses: NetworkHostAndPort) {
-    notaryClusterAddresses = addresses.map { it.toString() }
-}
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index e1d1f5c4c3..b1f02788c6 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -19,7 +19,6 @@ import net.corda.core.messaging.SingleMessageRecipient
 import net.corda.core.node.services.IdentityService
 import net.corda.core.node.services.KeyManagementService
 import net.corda.core.node.services.NetworkMapCache
-import net.corda.core.node.services.NotaryService
 import net.corda.core.serialization.SerializationWhitelist
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.getOrThrow
@@ -28,10 +27,10 @@ import net.corda.finance.utils.WorldMapLocation
 import net.corda.node.internal.AbstractNode
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.api.NetworkMapCacheInternal
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.node.services.api.SchemaService
+import net.corda.node.services.config.BFTSMaRtConfiguration
 import net.corda.node.services.config.NodeConfiguration
+import net.corda.node.services.config.NotaryConfig
 import net.corda.node.services.identity.PersistentIdentityService
 import net.corda.node.services.keys.E2ETestKeyManagementService
 import net.corda.node.services.messaging.MessagingService
@@ -40,18 +39,22 @@ import net.corda.node.services.network.NetworkMapService
 import net.corda.node.services.transactions.BFTNonValidatingNotaryService
 import net.corda.node.services.transactions.BFTSMaRt
 import net.corda.node.services.transactions.InMemoryTransactionVerifierService
-import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.node.utilities.AffinityExecutor
 import net.corda.node.utilities.AffinityExecutor.ServiceAffinityExecutor
 import net.corda.node.utilities.CertificateAndKeyPair
-import net.corda.testing.*
+import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.testing.DUMMY_KEY_1
+import net.corda.testing.initialiseTestSerialization
 import net.corda.testing.node.MockServices.Companion.MOCK_VERSION_INFO
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
+import net.corda.testing.resetTestSerialization
+import net.corda.testing.testNodeConfiguration
 import org.apache.activemq.artemis.utils.ReusableLatch
 import org.slf4j.Logger
 import java.math.BigInteger
 import java.nio.file.Path
 import java.security.KeyPair
+import java.security.PublicKey
 import java.security.cert.X509Certificate
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicInteger
@@ -220,17 +223,6 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
             return InMemoryNetworkMapService(network, networkMapCache, 1)
         }
 
-        override fun getNotaryIdentity(): PartyAndCertificate? {
-            val defaultIdentity = super.getNotaryIdentity()
-            return if (notaryIdentity == null || !notaryIdentity.first.type.isNotary() || defaultIdentity == null)
-                defaultIdentity
-            else {
-                // Ensure that we always have notary in name and type of it. TODO It is temporary solution until we will have proper handling of NetworkParameters
-                myNotaryIdentity = getTestPartyAndCertificate(defaultIdentity.name, notaryIdentity.second.public)
-                myNotaryIdentity
-            }
-        }
-
         // This is not thread safe, but node construction is done on a single thread, so that should always be fine
         override fun generateKeyPair(): KeyPair {
             counter = counter.add(BigInteger.ONE)
@@ -277,12 +269,11 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
 
         override fun acceptableLiveFiberCountOnStop(): Int = acceptableLiveFiberCountOnStop
 
-        override fun makeCoreNotaryService(type: ServiceType): NotaryService? {
-            if (type != BFTNonValidatingNotaryService.type) return super.makeCoreNotaryService(type)
-            return BFTNonValidatingNotaryService(services, myNotaryIdentity!!.owningKey, object : BFTSMaRt.Cluster {
+        override fun makeBFTCluster(notaryKey: PublicKey, bftSMaRtConfig: BFTSMaRtConfiguration): BFTSMaRt.Cluster {
+            return object : BFTSMaRt.Cluster {
                 override fun waitUntilAllReplicasHaveInitialized() {
-                    val clusterNodes = mockNet.nodes.filter { myNotaryIdentity!!.owningKey in it.started!!.info.legalIdentities.map { it.owningKey } }
-                    if (clusterNodes.size != configuration.notaryClusterAddresses.size) {
+                    val clusterNodes = mockNet.nodes.filter { notaryKey in it.started!!.info.legalIdentities.map { it.owningKey } }
+                    if (clusterNodes.size != bftSMaRtConfig.clusterAddresses.size) {
                         throw IllegalStateException("Unable to enumerate all nodes in BFT cluster.")
                     }
                     clusterNodes.forEach {
@@ -290,7 +281,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                         notaryService.waitUntilReplicaHasInitialized()
                     }
                 }
-            })
+            }
         }
 
         /**
@@ -406,16 +397,19 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
         }
     }
 
-    /**
-     * Construct a default notary node.
-     */
-    fun createNotaryNode() = createNotaryNode(DUMMY_NOTARY.name, null, null)
+    @JvmOverloads
+    fun createNotaryNode(legalName: CordaX500Name? = null, validating: Boolean = true): StartedNode<MockNode> {
+        return createNode(legalName = legalName, configOverrides = {
+            whenever(it.notary).thenReturn(NotaryConfig(validating))
+        })
+    }
 
-    fun createNotaryNode(legalName: CordaX500Name? = null,
-                         notaryIdentity: Pair<ServiceInfo, KeyPair>? = null,
-                         serviceName: CordaX500Name? = null): StartedNode<MockNode> {
-        return createNode(legalName = legalName, notaryIdentity = notaryIdentity,
-                advertisedServices = *arrayOf(ServiceInfo(ValidatingNotaryService.type, serviceName)))
+    fun <N : MockNode> createNotaryNode(legalName: CordaX500Name? = null,
+                                        validating: Boolean = true,
+                                        nodeFactory: Factory<N>): StartedNode<N> {
+        return createNode(legalName = legalName, nodeFactory = nodeFactory, configOverrides = {
+            whenever(it.notary).thenReturn(NotaryConfig(validating))
+        })
     }
 
     @JvmOverloads
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
index 2a126e5d21..3a8f838ffb 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
@@ -5,19 +5,16 @@ import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.concurrent.*
 import net.corda.core.internal.createDirectories
 import net.corda.core.internal.div
+import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.Node
 import net.corda.node.internal.StartedNode
-import net.corda.node.services.config.ConfigHelper
-import net.corda.node.services.config.FullNodeConfiguration
-import net.corda.node.services.config.configOf
-import net.corda.node.services.config.plus
-import net.corda.node.services.transactions.RaftValidatingNotaryService
+import net.corda.node.services.config.*
 import net.corda.node.utilities.ServiceIdentityGenerator
 import net.corda.nodeapi.User
 import net.corda.nodeapi.config.parseAs
+import net.corda.nodeapi.config.toConfig
 import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.testing.DUMMY_MAP
 import net.corda.testing.TestDependencyInjectionBase
 import net.corda.testing.driver.addressMustNotBeBoundFuture
@@ -129,30 +126,44 @@ abstract class NodeBasedTest : TestDependencyInjectionBase() {
         return if (waitForConnection) node.internals.nodeReadyFuture.map { node } else doneFuture(node)
     }
 
-    fun startNotaryCluster(notaryName: CordaX500Name,
-                           clusterSize: Int,
-                           serviceType: ServiceType = RaftValidatingNotaryService.type): CordaFuture<List<StartedNode<Node>>> {
+    // TODO This method has been added temporarily, to be deleted once the set of notaries is defined at the network level.
+    fun startNotaryNode(name: CordaX500Name,
+                        rpcUsers: List<User> = emptyList(),
+                        validating: Boolean = true): CordaFuture<StartedNode<Node>> {
+        return startNode(name, rpcUsers = rpcUsers, configOverrides = mapOf("notary" to mapOf("validating" to validating)))
+    }
+
+    fun startNotaryCluster(notaryName: CordaX500Name, clusterSize: Int): CordaFuture<List<StartedNode<Node>>> {
+        fun notaryConfig(nodeAddress: NetworkHostAndPort, clusterAddress: NetworkHostAndPort? = null): Map<String, Any> {
+            val clusterAddresses = if (clusterAddress != null) listOf(clusterAddress) else emptyList()
+            val config = NotaryConfig(validating = true, raft = RaftConfig(nodeAddress = nodeAddress, clusterAddresses = clusterAddresses))
+            return mapOf("notary" to config.toConfig().root().unwrapped())
+        }
+
         ServiceIdentityGenerator.generateToDisk(
                 (0 until clusterSize).map { baseDirectory(notaryName.copy(organisation = "${notaryName.organisation}-$it")) },
                 notaryName)
 
-        val serviceInfo = ServiceInfo(serviceType, notaryName)
-        val nodeAddresses = getFreeLocalPorts("localhost", clusterSize).map { it.toString() }
+        val nodeAddresses = getFreeLocalPorts("localhost", clusterSize)
 
         val masterNodeFuture = startNode(
                 CordaX500Name(organisation = "${notaryName.organisation}-0", locality = notaryName.locality, country = notaryName.country),
-                advertisedServices = setOf(serviceInfo),
-                configOverrides = mapOf("notaryNodeAddress" to nodeAddresses[0],
-                        "database" to mapOf("serverNameTablePrefix" to if (clusterSize > 1) "${notaryName.organisation}0".replace(Regex("[^0-9A-Za-z]+"), "") else "")))
+                configOverrides = notaryConfig(nodeAddresses[0]) + mapOf(
+                        "database" to mapOf(
+                                "serverNameTablePrefix" to if (clusterSize > 1) "${notaryName.organisation}0".replace(Regex("[^0-9A-Za-z]+"), "") else ""
+                        )
+                )
+        )
 
         val remainingNodesFutures = (1 until clusterSize).map {
             startNode(
                     CordaX500Name(organisation = "${notaryName.organisation}-$it", locality = notaryName.locality, country = notaryName.country),
-                    advertisedServices = setOf(serviceInfo),
-                    configOverrides = mapOf(
-                            "notaryNodeAddress" to nodeAddresses[it],
-                            "notaryClusterAddresses" to listOf(nodeAddresses[0]),
-                            "database" to mapOf("serverNameTablePrefix" to "${notaryName.organisation}$it".replace(Regex("[^0-9A-Za-z]+"), ""))))
+                    configOverrides = notaryConfig(nodeAddresses[it], nodeAddresses[0]) + mapOf(
+                            "database" to mapOf(
+                                    "serverNameTablePrefix" to "${notaryName.organisation}$it".replace(Regex("[^0-9A-Za-z]+"), "")
+                            )
+                    )
+            )
         }
 
         return remainingNodesFutures.transpose().flatMap { remainingNodes ->
diff --git a/testing/smoke-test-utils/src/main/kotlin/net/corda/smoketesting/NodeConfig.kt b/testing/smoke-test-utils/src/main/kotlin/net/corda/smoketesting/NodeConfig.kt
index ef0c1ff87b..cc003edc6b 100644
--- a/testing/smoke-test-utils/src/main/kotlin/net/corda/smoketesting/NodeConfig.kt
+++ b/testing/smoke-test-utils/src/main/kotlin/net/corda/smoketesting/NodeConfig.kt
@@ -13,7 +13,7 @@ class NodeConfig(
         val p2pPort: Int,
         val rpcPort: Int,
         val webPort: Int,
-        val extraServices: List<String>,
+        val isNotary: Boolean,
         val users: List<User>,
         var networkMap: NodeConfig? = null
 ) {
@@ -27,18 +27,25 @@ class NodeConfig(
      * The configuration object depends upon the networkMap,
      * which is mutable.
      */
-    fun toFileConfig(): Config = empty()
-            .withValue("myLegalName", valueFor(legalName.toString()))
-            .withValue("p2pAddress", addressValueFor(p2pPort))
-            .withValue("extraAdvertisedServiceIds", valueFor(extraServices))
-            .withFallback(optional("networkMapService", networkMap, { c, n ->
-                c.withValue("address", addressValueFor(n.p2pPort))
-                    .withValue("legalName", valueFor(n.legalName.toString()))
-            }))
-            .withValue("webAddress", addressValueFor(webPort))
-            .withValue("rpcAddress", addressValueFor(rpcPort))
-            .withValue("rpcUsers", valueFor(users.map(User::toMap).toList()))
-            .withValue("useTestClock", valueFor(true))
+    //TODO Make use of Any.toConfig
+    private fun toFileConfig(): Config {
+        val config = empty()
+                .withValue("myLegalName", valueFor(legalName.toString()))
+                .withValue("p2pAddress", addressValueFor(p2pPort))
+                .withFallback(optional("networkMapService", networkMap, { c, n ->
+                    c.withValue("address", addressValueFor(n.p2pPort))
+                            .withValue("legalName", valueFor(n.legalName.toString()))
+                }))
+                .withValue("webAddress", addressValueFor(webPort))
+                .withValue("rpcAddress", addressValueFor(rpcPort))
+                .withValue("rpcUsers", valueFor(users.map(User::toMap).toList()))
+                .withValue("useTestClock", valueFor(true))
+        return if (isNotary) {
+            config.withValue("notary", ConfigValueFactory.fromMap(mapOf("validating" to true)))
+        } else {
+            config
+        }
+    }
 
     fun toText(): String = toFileConfig().root().render(renderOptions)
 
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
index 141a9e1d68..03dda19564 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
@@ -8,7 +8,7 @@ import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.StandardCopyOption
 
-class NodeConfig(
+class NodeConfig constructor(
         baseDir: Path,
         legalName: CordaX500Name,
         p2pPort: Int,
@@ -42,20 +42,22 @@ class NodeConfig(
      * The configuration object depends upon the networkMap,
      * which is mutable.
      */
-    fun toFileConfig(): Config = ConfigFactory.empty()
-            .withValue("myLegalName", valueFor(legalName.toString()))
-            .withValue("p2pAddress", addressValueFor(p2pPort))
-            .withValue("extraAdvertisedServiceIds", valueFor(extraServices))
-            .withFallback(optional("networkMapService", networkMap, { c, n ->
-                c.withValue("address", addressValueFor(n.p2pPort))
-                    .withValue("legalName", valueFor(n.legalName.toString()))
-            }))
-            .withValue("webAddress", addressValueFor(webPort))
-            .withValue("rpcAddress", addressValueFor(rpcPort))
-            .withValue("rpcUsers", valueFor(users.map(User::toMap).toList()))
-            .withValue("h2port", valueFor(h2Port))
-            .withValue("useTestClock", valueFor(true))
-            .withValue("detectPublicIp", valueFor(false))
+    fun toFileConfig(): Config {
+        return ConfigFactory.empty()
+                .withValue("myLegalName", valueFor(legalName.toString()))
+                .withValue("p2pAddress", addressValueFor(p2pPort))
+                .withValue("extraAdvertisedServiceIds", valueFor(extraServices))
+                .withFallback(optional("networkMapService", networkMap, { c, n ->
+                    c.withValue("address", addressValueFor(n.p2pPort))
+                            .withValue("legalName", valueFor(n.legalName.toString()))
+                }))
+                .withValue("webAddress", addressValueFor(webPort))
+                .withValue("rpcAddress", addressValueFor(rpcPort))
+                .withValue("rpcUsers", valueFor(users.map(User::toMap).toList()))
+                .withValue("h2port", valueFor(h2Port))
+                .withValue("useTestClock", valueFor(true))
+                .withValue("detectPublicIp", valueFor(false))
+    }
 
     fun toText(): String = toFileConfig().root().render(renderOptions)
 
diff --git a/tools/demobench/src/test/kotlin/net/corda/demobench/model/UserTest.kt b/tools/demobench/src/test/kotlin/net/corda/demobench/model/UserTest.kt
index e902bcfec9..5376c0915e 100644
--- a/tools/demobench/src/test/kotlin/net/corda/demobench/model/UserTest.kt
+++ b/tools/demobench/src/test/kotlin/net/corda/demobench/model/UserTest.kt
@@ -11,7 +11,7 @@ class UserTest {
         val user = toUser(emptyMap())
         assertEquals("none", user.username)
         assertEquals("none", user.password)
-        assertEquals(emptySet<String>(), user.permissions)
+        assertEquals(emptySet(), user.permissions)
     }
 
     @Test
@@ -33,7 +33,7 @@ class UserTest {
         val map = user.toMap()
         assertEquals("MyName", map["username"])
         assertEquals("MyPassword", map["password"])
-        assertEquals(setOf("Flow.MyFlow"), map["permissions"])
+        assertEquals(listOf("Flow.MyFlow"), map["permissions"])
     }
 
     @Test
diff --git a/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt b/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt
index 706d5e3649..5dbb09753c 100644
--- a/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt
+++ b/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt
@@ -21,10 +21,9 @@ import net.corda.finance.flows.*
 import net.corda.finance.flows.CashExitFlow.ExitRequest
 import net.corda.finance.flows.CashIssueAndPaymentFlow.IssueAndPaymentRequest
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
-import net.corda.node.services.transactions.SimpleNotaryService
+import net.corda.nodeapi.User
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.nodeapi.internal.ServiceType
-import net.corda.nodeapi.User
 import net.corda.testing.ALICE
 import net.corda.testing.BOB
 import net.corda.testing.DUMMY_NOTARY
@@ -70,8 +69,7 @@ class ExplorerSimulation(val options: OptionSet) {
         val portAllocation = PortAllocation.Incremental(20000)
         driver(portAllocation = portAllocation, extraCordappPackagesToScan = listOf("net.corda.finance")) {
             // TODO : Supported flow should be exposed somehow from the node instead of set of ServiceInfo.
-            val notary = startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)),
-                    customOverrides = mapOf("nearestCity" to "Zurich"))
+            val notary = startNotaryNode(DUMMY_NOTARY.name, customOverrides = mapOf("nearestCity" to "Zurich"), validating = false)
             val alice = startNode(providedName = ALICE.name, rpcUsers = arrayListOf(user),
                     advertisedServices = setOf(ServiceInfo(ServiceType.corda.getSubType("cash"))),
                     customOverrides = mapOf("nearestCity" to "Milan"))
diff --git a/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt b/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
index 4ce985d0f5..6648fdb83d 100644
--- a/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
+++ b/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
@@ -10,12 +10,10 @@ import net.corda.finance.DOLLARS
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.services.config.VerifierType
-import net.corda.node.services.transactions.ValidatingNotaryService
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.ALICE
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.driver.NetworkMapStartStrategy
 import net.corda.testing.chooseIdentity
+import net.corda.testing.driver.NetworkMapStartStrategy
 import org.junit.Test
 import java.util.*
 import java.util.concurrent.atomic.AtomicInteger
@@ -117,7 +115,7 @@ class VerifierTests {
             extraCordappPackagesToScan = listOf("net.corda.finance.contracts")
         ) {
             val aliceFuture = startNode(providedName = ALICE.name)
-            val notaryFuture = startNode(providedName = DUMMY_NOTARY.name, advertisedServices = setOf(ServiceInfo(ValidatingNotaryService.type)), verifierType = VerifierType.OutOfProcess)
+            val notaryFuture = startNotaryNode(DUMMY_NOTARY.name, verifierType = VerifierType.OutOfProcess)
             val alice = aliceFuture.get()
             val notary = notaryFuture.get()
             val notaryIdentity = notary.nodeInfo.legalIdentities[1]

From 8d46b6bcbfffeb5c0b93957a0a2f70e95ece50e6 Mon Sep 17 00:00:00 2001
From: Shams Asari <shams.asari@r3.com>
Date: Mon, 9 Oct 2017 09:34:08 +0100
Subject: [PATCH 110/185] Update gradle plugin version for previous commit

---
 constants.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/constants.properties b/constants.properties
index 1965e53715..dd42901d00 100644
--- a/constants.properties
+++ b/constants.properties
@@ -1,4 +1,4 @@
-gradlePluginsVersion=1.1.1
+gradlePluginsVersion=1.1.2
 kotlinVersion=1.1.50
 guavaVersion=21.0
 bouncycastleVersion=1.57

From a425f82c773176a04bf1cba11f4a721c6bde0087 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Mon, 9 Oct 2017 10:19:37 +0100
Subject: [PATCH 111/185] CORDA-540: Change how standard mutable whitelists
 structured (#1814)

---
 .../serialization/CordaClassResolver.kt       | 35 +++++++++----------
 1 file changed, 16 insertions(+), 19 deletions(-)

diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
index 91573ed24e..b614284139 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
@@ -152,14 +152,15 @@ object AllWhitelist : ClassWhitelist {
     override fun hasListed(type: Class<*>): Boolean = true
 }
 
-// TODO: Need some concept of from which class loader
-class GlobalTransientClassWhiteList(val delegate: ClassWhitelist) : MutableClassWhitelist, ClassWhitelist by delegate {
-    companion object {
-        val whitelist: MutableSet<String> = Collections.synchronizedSet(mutableSetOf())
-    }
+sealed class AbstractMutableClassWhitelist(private val whitelist: MutableSet<String>,  private val delegate: ClassWhitelist) : MutableClassWhitelist {
 
     override fun hasListed(type: Class<*>): Boolean {
-        return (type.name in whitelist) || delegate.hasListed(type)
+        /**
+         * There are certain delegates like [net.corda.nodeapi.internal.serialization.AllButBlacklisted]
+         * which may throw when asked whether the type is listed.
+         * In such situations - it may be a good idea to ask [delegate] first before making a check against own [whitelist].
+         */
+        return delegate.hasListed(type) || (type.name in whitelist)
     }
 
     override fun add(entry: Class<*>) {
@@ -167,21 +168,17 @@ class GlobalTransientClassWhiteList(val delegate: ClassWhitelist) : MutableClass
     }
 }
 
+// TODO: Need some concept of from which class loader
+class GlobalTransientClassWhiteList(delegate: ClassWhitelist) : AbstractMutableClassWhitelist(GlobalTransientClassWhiteList.whitelist, delegate) {
+    companion object {
+        private val whitelist: MutableSet<String> = Collections.synchronizedSet(mutableSetOf())
+    }
+}
+
 /**
- * A whitelist that can be customised via the [net.corda.core.node.SerializationWhitelist], since implements [MutableClassWhitelist].
+ * A whitelist that can be customised via the [net.corda.core.node.SerializationWhitelist], since it implements [MutableClassWhitelist].
  */
-class TransientClassWhiteList(val delegate: ClassWhitelist) : MutableClassWhitelist, ClassWhitelist by delegate {
-    val whitelist: MutableSet<String> = Collections.synchronizedSet(mutableSetOf())
-
-    override fun hasListed(type: Class<*>): Boolean {
-        return (type.name in whitelist) || delegate.hasListed(type)
-    }
-
-    override fun add(entry: Class<*>) {
-        whitelist += entry.name
-    }
-}
-
+class TransientClassWhiteList(delegate: ClassWhitelist) : AbstractMutableClassWhitelist(Collections.synchronizedSet(mutableSetOf()), delegate)
 
 /**
  * This class is not currently used, but can be installed to log a large number of missing entries from the whitelist

From a9508b393cb12f6f15202c52e19f7495a1ea6a8d Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Mon, 9 Oct 2017 11:22:11 +0100
Subject: [PATCH 112/185] CORDA-540: AMQP Private key serializer (#1838)

---
 .../serialization/AMQPSerializationScheme.kt  |  1 +
 .../amqp/custom/PrivateKeySerializer.kt       | 27 +++++++++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/PrivateKeySerializer.kt

diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AMQPSerializationScheme.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AMQPSerializationScheme.kt
index bbc3be72a8..501840e3df 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AMQPSerializationScheme.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/AMQPSerializationScheme.kt
@@ -33,6 +33,7 @@ abstract class AbstractAMQPSerializationScheme : SerializationScheme {
         fun registerCustomSerializers(factory: SerializerFactory) {
             with(factory) {
                 register(net.corda.nodeapi.internal.serialization.amqp.custom.PublicKeySerializer)
+                register(net.corda.nodeapi.internal.serialization.amqp.custom.PrivateKeySerializer)
                 register(net.corda.nodeapi.internal.serialization.amqp.custom.ThrowableSerializer(this))
                 register(net.corda.nodeapi.internal.serialization.amqp.custom.X500NameSerializer)
                 register(net.corda.nodeapi.internal.serialization.amqp.custom.BigDecimalSerializer)
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/PrivateKeySerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/PrivateKeySerializer.kt
new file mode 100644
index 0000000000..f9a2d1817d
--- /dev/null
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/PrivateKeySerializer.kt
@@ -0,0 +1,27 @@
+package net.corda.nodeapi.internal.serialization.amqp.custom
+
+import net.corda.core.crypto.Crypto
+import net.corda.core.serialization.SerializationContext.UseCase.*
+import net.corda.nodeapi.internal.serialization.amqp.*
+import net.corda.nodeapi.internal.serialization.checkUseCase
+import org.apache.qpid.proton.codec.Data
+import java.lang.reflect.Type
+import java.security.PrivateKey
+import java.util.*
+
+object PrivateKeySerializer : CustomSerializer.Implements<PrivateKey>(PrivateKey::class.java) {
+
+    private val allowedUseCases = EnumSet.of(Storage, Checkpoint)
+
+    override val schemaForDocumentation = Schema(listOf(RestrictedType(type.toString(), "", listOf(type.toString()), SerializerFactory.primitiveTypeName(ByteArray::class.java)!!, descriptor, emptyList())))
+
+    override fun writeDescribedObject(obj: PrivateKey, data: Data, type: Type, output: SerializationOutput) {
+        checkUseCase(allowedUseCases)
+        output.writeObject(obj.encoded, data, clazz)
+    }
+
+    override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): PrivateKey {
+        val bits = input.readObject(obj, schema, ByteArray::class.java) as ByteArray
+        return Crypto.decodePrivateKey(bits)
+    }
+}
\ No newline at end of file

From 0c2289de8c8a3c112d5769dc4d174b67949e00a8 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Mon, 9 Oct 2017 11:32:03 +0100
Subject: [PATCH 113/185] Joel move api docs

---
 docs/source/building-a-cordapp-index.rst         |  1 +
 docs/source/{corda-modules.rst => corda-api.rst} |  6 +++---
 docs/source/getting-set-up.rst                   |  2 +-
 docs/source/hello-world-running.rst              | 10 ++--------
 docs/source/other-index.rst                      |  1 -
 docs/source/release-notes.rst                    |  2 +-
 6 files changed, 8 insertions(+), 14 deletions(-)
 rename docs/source/{corda-modules.rst => corda-api.rst} (97%)

diff --git a/docs/source/building-a-cordapp-index.rst b/docs/source/building-a-cordapp-index.rst
index 12466338ee..a5ea4e9bfe 100644
--- a/docs/source/building-a-cordapp-index.rst
+++ b/docs/source/building-a-cordapp-index.rst
@@ -7,5 +7,6 @@ Building a CorDapp
    cordapp-overview
    writing-cordapps
    cordapp-build-systems
+   corda-api
    flow-cookbook
    cheat-sheet
\ No newline at end of file
diff --git a/docs/source/corda-modules.rst b/docs/source/corda-api.rst
similarity index 97%
rename from docs/source/corda-modules.rst
rename to docs/source/corda-api.rst
index 0307db092c..57863be4b7 100644
--- a/docs/source/corda-modules.rst
+++ b/docs/source/corda-api.rst
@@ -1,7 +1,7 @@
-Corda modules
-=============
+Corda API
+=========
 
-This section describes the APIs that are available for the development of CorDapps:
+The following are the core APIs that are used in the development of CorDapps:
 
 .. toctree::
    :maxdepth: 1
diff --git a/docs/source/getting-set-up.rst b/docs/source/getting-set-up.rst
index 1fbe7060b3..f6ce762df1 100644
--- a/docs/source/getting-set-up.rst
+++ b/docs/source/getting-set-up.rst
@@ -169,7 +169,7 @@ The best way to check that everything is working fine is by taking a deeper look
 Next, you should read through :doc:`Corda Key Concepts <key-concepts>` to understand how Corda works.
 
 By then, you'll be ready to start writing your own CorDapps. Learn how to do this in the
-:doc:`Hello, World tutorial <hello-world-index>`. You may want to refer to the :doc:`Modules documentation <corda-modules>` along the
+:doc:`Hello, World tutorial <hello-world-index>`. You may want to refer to the :doc:`API documentation <corda-api>` along the
 way.
 
 If you encounter any issues, please see the :doc:`troubleshooting` page, or get in touch with us on the
diff --git a/docs/source/hello-world-running.rst b/docs/source/hello-world-running.rst
index 1bfc2be2df..ae91fe0907 100644
--- a/docs/source/hello-world-running.rst
+++ b/docs/source/hello-world-running.rst
@@ -117,15 +117,9 @@ commands.
 
 We want to create an IOU of 100 with PartyB. We start the ``IOUFlow`` by typing:
 
-.. container:: codeset
+.. code:: bash
 
-    .. code-block:: java
-
-        start IOUFlow arg0: 99, arg1: "O=PartyB,L=New York,C=US"
-
-    .. code-block:: kotlin
-
-        start IOUFlow iouValue: 99, otherParty: "O=PartyB,L=New York,C=US"
+    start IOUFlow iouValue: 99, otherParty: "O=PartyB,L=New York,C=US"
 
 PartyA and PartyB will automatically agree an IOU. If the flow worked, it should have led to the recording of a new IOU
 in the vaults of both PartyA and PartyB.
diff --git a/docs/source/other-index.rst b/docs/source/other-index.rst
index 539608be94..7f6fa6ef66 100644
--- a/docs/source/other-index.rst
+++ b/docs/source/other-index.rst
@@ -7,6 +7,5 @@ Other
    json
    secure-coding-guidelines
    corda-repo-layout
-   corda-modules
    building-the-docs
    codestyle
\ No newline at end of file
diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst
index 3552fc329e..72baf8cd6f 100644
--- a/docs/source/release-notes.rst
+++ b/docs/source/release-notes.rst
@@ -32,7 +32,7 @@ Our extensive testing frameworks will continue to evolve alongside future Corda
 we have introduced a new test node driver module to encapsulate all test functionality in support of building standalone node integration 
 tests using our DSL driver. 
 
-Please read :doc:`corda-modules` for complete details.
+Please read :doc:`corda-api` for complete details.
 
 .. note:: it may be necessary to recompile applications against future versions of the API until we begin offering
          `ABI (Application Binary Interface) <https://en.wikipedia.org/wiki/Application_binary_interface>`_ stability as well.

From f83f1b7010e4f9a614add352eaccd581d8ea5968 Mon Sep 17 00:00:00 2001
From: Andrzej Cichocki <andrzej.cichocki@r3.com>
Date: Mon, 9 Oct 2017 12:49:07 +0100
Subject: [PATCH 114/185] CORDA-599 Fix circular dependency between vault and
 SH (#1630)

Fix circular dependency between the 2 vault objects and SH.
---
 .../kotlin/net/corda/core/node/ServiceHub.kt  | 40 ++++--------
 .../transactions/NotaryChangeTransactions.kt  |  6 +-
 .../core/transactions/SignedTransaction.kt    |  7 +-
 .../contracts/LedgerTransactionQueryTests.kt  |  2 +-
 .../net/corda/node/internal/AbstractNode.kt   | 16 +++--
 .../net/corda/node/internal/StartedNode.kt    | 15 +++++
 .../node/services/api/ServiceHubInternal.kt   |  4 +-
 .../node/services/api/VaultServiceInternal.kt | 19 ++++++
 .../node/services/vault/NodeVaultService.kt   | 64 ++++++++-----------
 .../events/NodeSchedulerServiceTest.kt        |  4 +-
 .../persistence/DBTransactionStorageTests.kt  | 12 ++--
 .../persistence/HibernateConfigurationTest.kt |  6 +-
 .../services/vault/NodeVaultServiceTest.kt    | 10 +--
 .../node/testing/MockServiceHubInternal.kt    | 11 ++--
 .../net/corda/testing/node/MockServices.kt    | 25 +++++---
 .../main/kotlin/net/corda/testing/TestDSL.kt  |  6 +-
 .../corda/testing/node/MockCordappProvider.kt | 23 +++----
 17 files changed, 148 insertions(+), 122 deletions(-)
 create mode 100644 node/src/main/kotlin/net/corda/node/services/api/VaultServiceInternal.kt

diff --git a/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt b/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
index 5d23e76dab..c278ac16a3 100644
--- a/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
+++ b/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
@@ -7,10 +7,6 @@ import net.corda.core.crypto.SignableData
 import net.corda.core.crypto.SignatureMetadata
 import net.corda.core.crypto.TransactionSignature
 import net.corda.core.flows.ContractUpgradeFlow
-import net.corda.core.identity.AbstractParty
-import net.corda.core.identity.AnonymousParty
-import net.corda.core.identity.Party
-import net.corda.core.internal.toMultiMap
 import net.corda.core.node.services.*
 import net.corda.core.serialization.SerializeAsToken
 import net.corda.core.transactions.FilteredTransaction
@@ -20,11 +16,24 @@ import java.security.PublicKey
 import java.sql.Connection
 import java.time.Clock
 
+/**
+ * Part of [ServiceHub].
+ */
+interface StateLoader {
+    /**
+     * Given a [StateRef] loads the referenced transaction and looks up the specified output [ContractState].
+     *
+     * @throws TransactionResolutionException if [stateRef] points to a non-existent transaction.
+     */
+    @Throws(TransactionResolutionException::class)
+    fun loadState(stateRef: StateRef): TransactionState<*>
+}
+
 /**
  * Subset of node services that are used for loading transactions from the wire into fully resolved, looked up
  * forms ready for verification.
  */
-interface ServicesForResolution {
+interface ServicesForResolution : StateLoader {
     /**
      * An identity service maintains a directory of parties by their associated distinguished name/public keys and thus
      * supports lookup of a party given its key, or name. The service also manages the certificates linking confidential
@@ -37,14 +46,6 @@ interface ServicesForResolution {
 
     /** Provides access to anything relating to cordapps including contract attachment resolution and app context */
     val cordappProvider: CordappProvider
-
-    /**
-     * Given a [StateRef] loads the referenced transaction and looks up the specified output [ContractState].
-     *
-     * @throws TransactionResolutionException if the [StateRef] points to a non-existent transaction.
-     */
-    @Throws(TransactionResolutionException::class)
-    fun loadState(stateRef: StateRef): TransactionState<*>
 }
 
 /**
@@ -155,19 +156,6 @@ interface ServiceHub : ServicesForResolution {
         recordTransactions(true, txs)
     }
 
-    /**
-     * Given a [StateRef] loads the referenced transaction and looks up the specified output [ContractState].
-     *
-     * @throws TransactionResolutionException if [stateRef] points to a non-existent transaction.
-     */
-    @Throws(TransactionResolutionException::class)
-    override fun loadState(stateRef: StateRef): TransactionState<*> {
-        val stx = validatedTransactions.getTransaction(stateRef.txhash) ?: throw TransactionResolutionException(stateRef.txhash)
-        return if (stx.isNotaryChangeTransaction()) {
-            stx.resolveNotaryChangeTransaction(this).outputs[stateRef.index]
-        } else stx.tx.outputs[stateRef.index]
-    }
-
     /**
      * Converts the given [StateRef] into a [StateAndRef] object.
      *
diff --git a/core/src/main/kotlin/net/corda/core/transactions/NotaryChangeTransactions.kt b/core/src/main/kotlin/net/corda/core/transactions/NotaryChangeTransactions.kt
index f592f998b7..332718fd94 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/NotaryChangeTransactions.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/NotaryChangeTransactions.kt
@@ -7,6 +7,7 @@ import net.corda.core.crypto.serializedHash
 import net.corda.core.utilities.toBase58String
 import net.corda.core.identity.Party
 import net.corda.core.node.ServiceHub
+import net.corda.core.node.StateLoader
 import net.corda.core.serialization.CordaSerializable
 import java.security.PublicKey
 
@@ -39,9 +40,10 @@ data class NotaryChangeWireTransaction(
      */
     override val id: SecureHash by lazy { serializedHash(inputs + notary + newNotary) }
 
-    fun resolve(services: ServiceHub, sigs: List<TransactionSignature>): NotaryChangeLedgerTransaction {
+    fun resolve(services: ServiceHub, sigs: List<TransactionSignature>) = resolve(services as StateLoader, sigs)
+    fun resolve(stateLoader: StateLoader, sigs: List<TransactionSignature>): NotaryChangeLedgerTransaction {
         val resolvedInputs = inputs.map { ref ->
-            services.loadState(ref).let { StateAndRef(it, ref) }
+            stateLoader.loadState(ref).let { StateAndRef(it, ref) }
         }
         return NotaryChangeLedgerTransaction(resolvedInputs, notary, newNotary, id, sigs)
     }
diff --git a/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
index af811c25b3..4e8602daf6 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
@@ -7,6 +7,7 @@ import net.corda.core.crypto.*
 import net.corda.core.identity.Party
 import net.corda.core.internal.VisibleForTesting
 import net.corda.core.node.ServiceHub
+import net.corda.core.node.StateLoader
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.serialization.SerializedBytes
 import net.corda.core.serialization.deserialize
@@ -181,10 +182,12 @@ data class SignedTransaction(val txBits: SerializedBytes<CoreTransaction>,
      * If [transaction] is a [NotaryChangeWireTransaction], loads the input states and resolves it to a
      * [NotaryChangeLedgerTransaction] so the signatures can be verified.
      */
-    fun resolveNotaryChangeTransaction(services: ServiceHub): NotaryChangeLedgerTransaction {
+    fun resolveNotaryChangeTransaction(services: ServiceHub) = resolveNotaryChangeTransaction(services as StateLoader)
+
+    fun resolveNotaryChangeTransaction(stateLoader: StateLoader): NotaryChangeLedgerTransaction {
         val ntx = transaction as? NotaryChangeWireTransaction
                 ?: throw IllegalStateException("Expected a ${NotaryChangeWireTransaction::class.simpleName} but found ${transaction::class.simpleName}")
-        return ntx.resolve(services, sigs)
+        return ntx.resolve(stateLoader, sigs)
     }
 
     override fun toString(): String = "${javaClass.simpleName}(id=$id)"
diff --git a/core/src/test/kotlin/net/corda/core/contracts/LedgerTransactionQueryTests.kt b/core/src/test/kotlin/net/corda/core/contracts/LedgerTransactionQueryTests.kt
index 8273cd9a80..aa8b071299 100644
--- a/core/src/test/kotlin/net/corda/core/contracts/LedgerTransactionQueryTests.kt
+++ b/core/src/test/kotlin/net/corda/core/contracts/LedgerTransactionQueryTests.kt
@@ -22,7 +22,7 @@ class LedgerTransactionQueryTests : TestDependencyInjectionBase() {
 
     @Before
     fun setup() {
-        services.mockCordappProvider.addMockCordapp(DummyContract.PROGRAM_ID, services)
+        services.mockCordappProvider.addMockCordapp(DummyContract.PROGRAM_ID, services.attachments)
     }
 
     interface Commands {
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 8e9d219d66..640ac65389 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -19,6 +19,10 @@ import net.corda.core.internal.concurrent.flatMap
 import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.internal.toX509CertHolder
 import net.corda.core.internal.uncheckedCast
+import net.corda.core.messaging.CordaRPCOps
+import net.corda.core.messaging.RPCOps
+import net.corda.core.messaging.SingleMessageRecipient
+import net.corda.core.node.*
 import net.corda.core.messaging.*
 import net.corda.core.node.AppServiceHub
 import net.corda.core.node.NodeInfo
@@ -453,7 +457,8 @@ abstract class AbstractNode(config: NodeConfiguration,
     private fun makeServices(schemaService: SchemaService): MutableList<Any> {
         checkpointStorage = DBCheckpointStorage()
         cordappProvider = CordappProviderImpl(cordappLoader)
-        _services = ServiceHubInternalImpl(schemaService)
+        val transactionStorage = makeTransactionStorage()
+        _services = ServiceHubInternalImpl(schemaService, transactionStorage, StateLoaderImpl(transactionStorage))
         attachments = NodeAttachmentService(services.monitoringService.metrics)
         cordappProvider.start(attachments)
         legalIdentity = obtainIdentity(notaryConfig = null)
@@ -752,15 +757,18 @@ abstract class AbstractNode(config: NodeConfiguration,
 
     protected open fun generateKeyPair() = cryptoGenerateKeyPair()
 
-    private inner class ServiceHubInternalImpl(override val schemaService: SchemaService) : ServiceHubInternal, SingletonSerializeAsToken() {
+    private inner class ServiceHubInternalImpl(
+            override val schemaService: SchemaService,
+            override val validatedTransactions: WritableTransactionStorage,
+            private val stateLoader: StateLoader
+    ) : SingletonSerializeAsToken(), ServiceHubInternal, StateLoader by stateLoader {
         override val rpcFlows = ArrayList<Class<out FlowLogic<*>>>()
         override val stateMachineRecordedTransactionMapping = DBTransactionMappingStorage()
         override val auditService = DummyAuditService()
         override val monitoringService = MonitoringService(MetricRegistry())
-        override val validatedTransactions = makeTransactionStorage()
         override val transactionVerifierService by lazy { makeTransactionVerifierService() }
         override val networkMapCache by lazy { PersistentNetworkMapCache(this) }
-        override val vaultService by lazy { NodeVaultService(this, database.hibernateConfig) }
+        override val vaultService by lazy { NodeVaultService(platformClock, keyManagementService, stateLoader, this@AbstractNode.database.hibernateConfig) }
         override val contractUpgradeService by lazy { ContractUpgradeServiceImpl() }
 
         // Place the long term identity key in the KMS. Eventually, this is likely going to be separated again because
diff --git a/node/src/main/kotlin/net/corda/node/internal/StartedNode.kt b/node/src/main/kotlin/net/corda/node/internal/StartedNode.kt
index 03ad5b5a23..501b8f926a 100644
--- a/node/src/main/kotlin/net/corda/node/internal/StartedNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/StartedNode.kt
@@ -1,8 +1,13 @@
 package net.corda.node.internal
 
+import net.corda.core.contracts.StateRef
+import net.corda.core.contracts.TransactionResolutionException
+import net.corda.core.contracts.TransactionState
 import net.corda.core.flows.FlowLogic
 import net.corda.core.messaging.CordaRPCOps
 import net.corda.core.node.NodeInfo
+import net.corda.core.node.StateLoader
+import net.corda.core.node.services.TransactionStorage
 import net.corda.node.services.api.CheckpointStorage
 import net.corda.node.services.api.ServiceHubInternal
 import net.corda.node.services.messaging.MessagingService
@@ -25,3 +30,13 @@ interface StartedNode<out N : AbstractNode> {
     fun dispose() = internals.stop()
     fun <T : FlowLogic<*>> registerInitiatedFlow(initiatedFlowClass: Class<T>) = internals.registerInitiatedFlow(initiatedFlowClass)
 }
+
+class StateLoaderImpl(private val validatedTransactions: TransactionStorage) : StateLoader {
+    @Throws(TransactionResolutionException::class)
+    override fun loadState(stateRef: StateRef): TransactionState<*> {
+        val stx = validatedTransactions.getTransaction(stateRef.txhash) ?: throw TransactionResolutionException(stateRef.txhash)
+        return if (stx.isNotaryChangeTransaction()) {
+            stx.resolveNotaryChangeTransaction(this).outputs[stateRef.index]
+        } else stx.tx.outputs[stateRef.index]
+    }
+}
diff --git a/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt b/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
index c1fb4f0c1b..65bd38d843 100644
--- a/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
+++ b/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
@@ -25,7 +25,6 @@ import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.messaging.MessagingService
 import net.corda.node.services.statemachine.FlowLogicRefFactoryImpl
 import net.corda.node.services.statemachine.FlowStateMachineImpl
-import net.corda.node.services.vault.NodeVaultService
 import net.corda.node.utilities.CordaPersistence
 
 interface NetworkMapCacheInternal : NetworkMapCache {
@@ -73,6 +72,7 @@ interface ServiceHubInternal : ServiceHub {
         private val log = loggerFor<ServiceHubInternal>()
     }
 
+    override val vaultService: VaultServiceInternal
     /**
      * A map of hash->tx where tx has been signature/contract validated and the states are known to be correct.
      * The signatures aren't technically needed after that point, but we keep them around so that we can relay
@@ -104,7 +104,7 @@ interface ServiceHubInternal : ServiceHub {
 
         if (notifyVault) {
             val toNotify = recordedTransactions.map { if (it.isNotaryChangeTransaction()) it.notaryChangeTx else it.tx }
-            (vaultService as NodeVaultService).notifyAll(toNotify)
+            vaultService.notifyAll(toNotify)
         }
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/api/VaultServiceInternal.kt b/node/src/main/kotlin/net/corda/node/services/api/VaultServiceInternal.kt
new file mode 100644
index 0000000000..fde38dfe05
--- /dev/null
+++ b/node/src/main/kotlin/net/corda/node/services/api/VaultServiceInternal.kt
@@ -0,0 +1,19 @@
+package net.corda.node.services.api
+
+import net.corda.core.node.services.VaultService
+import net.corda.core.transactions.CoreTransaction
+import net.corda.core.transactions.NotaryChangeWireTransaction
+import net.corda.core.transactions.WireTransaction
+
+interface VaultServiceInternal : VaultService {
+    /**
+     * Splits the provided [txns] into batches of [WireTransaction] and [NotaryChangeWireTransaction].
+     * This is required because the batches get aggregated into single updates, and we want to be able to
+     * indicate whether an update consists entirely of regular or notary change transactions, which may require
+     * different processing logic.
+     */
+    fun notifyAll(txns: Iterable<CoreTransaction>)
+
+    /** Same as notifyAll but with a single transaction. */
+    fun notify(tx: CoreTransaction) = notifyAll(listOf(tx))
+}
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 15796f15eb..6564859865 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
@@ -4,16 +4,16 @@ import co.paralleluniverse.fibers.Suspendable
 import co.paralleluniverse.strands.Strand
 import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
-import net.corda.core.internal.ThreadBox
-import net.corda.core.internal.VisibleForTesting
-import net.corda.core.internal.bufferUntilSubscribed
-import net.corda.core.internal.tee
-import net.corda.core.messaging.DataFeed
-import net.corda.core.node.ServiceHub
+import net.corda.core.internal.*
+import net.corda.core.node.StateLoader
+import net.corda.core.node.services.*
 import net.corda.core.node.services.StatesNotAvailableException
 import net.corda.core.node.services.Vault
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.node.services.vault.Sort
+import net.corda.core.node.services.vault.SortAttribute
+import net.corda.core.messaging.DataFeed
 import net.corda.core.node.services.VaultQueryException
-import net.corda.core.node.services.VaultService
 import net.corda.core.node.services.vault.*
 import net.corda.core.schemas.PersistentStateRef
 import net.corda.core.serialization.SerializationDefaults.STORAGE_CONTEXT
@@ -24,6 +24,7 @@ import net.corda.core.transactions.CoreTransaction
 import net.corda.core.transactions.NotaryChangeWireTransaction
 import net.corda.core.transactions.WireTransaction
 import net.corda.core.utilities.*
+import net.corda.node.services.api.VaultServiceInternal
 import net.corda.node.services.persistence.HibernateConfiguration
 import net.corda.node.services.statemachine.FlowStateMachineImpl
 import net.corda.node.utilities.DatabaseTransactionManager
@@ -33,6 +34,7 @@ import org.hibernate.Session
 import rx.Observable
 import rx.subjects.PublishSubject
 import java.security.PublicKey
+import java.time.Clock
 import java.time.Instant
 import java.util.*
 import javax.persistence.Tuple
@@ -47,7 +49,7 @@ import javax.persistence.Tuple
  * TODO: keep an audit trail with time stamps of previously unconsumed states "as of" a particular point in time.
  * TODO: have transaction storage do some caching.
  */
-class NodeVaultService(private val services: ServiceHub, private val hibernateConfig: HibernateConfiguration) : SingletonSerializeAsToken(), VaultService {
+class NodeVaultService(private val clock: Clock, private val keyManagementService: KeyManagementService, private val stateLoader: StateLoader, private val hibernateConfig: HibernateConfiguration) : SingletonSerializeAsToken(), VaultServiceInternal {
 
     private companion object {
         val log = loggerFor<NodeVaultService>()
@@ -78,7 +80,7 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
                         contractStateClassName = stateAndRef.value.state.data.javaClass.name,
                         contractState = stateAndRef.value.state.serialize(context = STORAGE_CONTEXT).bytes,
                         stateStatus = Vault.StateStatus.UNCONSUMED,
-                        recordedTime = services.clock.instant())
+                        recordedTime = clock.instant())
                 state.stateRef = PersistentStateRef(stateAndRef.key)
                 session.save(state)
             }
@@ -86,11 +88,11 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
                 val state = session.get<VaultSchemaV1.VaultStates>(VaultSchemaV1.VaultStates::class.java, PersistentStateRef(stateRef))
                 state?.run {
                     stateStatus = Vault.StateStatus.CONSUMED
-                    consumedTime = services.clock.instant()
+                    consumedTime = clock.instant()
                     // remove lock (if held)
                     if (lockId != null) {
                         lockId = null
-                        lockUpdateTime = services.clock.instant()
+                        lockUpdateTime = clock.instant()
                         log.trace("Releasing soft lock on consumed state: $stateRef")
                     }
                     session.save(state)
@@ -106,13 +108,7 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
     override val updates: Observable<Vault.Update<ContractState>>
         get() = mutex.locked { _updatesInDbTx }
 
-    /**
-     * Splits the provided [txns] into batches of [WireTransaction] and [NotaryChangeWireTransaction].
-     * This is required because the batches get aggregated into single updates, and we want to be able to
-     * indicate whether an update consists entirely of regular or notary change transactions, which may require
-     * different processing logic.
-     */
-    fun notifyAll(txns: Iterable<CoreTransaction>) {
+    override fun notifyAll(txns: Iterable<CoreTransaction>) {
         // It'd be easier to just group by type, but then we'd lose ordering.
         val regularTxns = mutableListOf<WireTransaction>()
         val notaryChangeTxns = mutableListOf<NotaryChangeWireTransaction>()
@@ -140,12 +136,9 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
         if (notaryChangeTxns.isNotEmpty()) notifyNotaryChange(notaryChangeTxns.toList())
     }
 
-    /** Same as notifyAll but with a single transaction. */
-    fun notify(tx: CoreTransaction) = notifyAll(listOf(tx))
-
     private fun notifyRegular(txns: Iterable<WireTransaction>) {
         fun makeUpdate(tx: WireTransaction): Vault.Update<ContractState> {
-            val myKeys = services.keyManagementService.filterMyKeys(tx.outputs.flatMap { it.data.participants.map { it.owningKey } })
+            val myKeys = keyManagementService.filterMyKeys(tx.outputs.flatMap { it.data.participants.map { it.owningKey } })
             val ourNewStates = tx.outputs.
                     filter { isRelevant(it.data, myKeys.toSet()) }.
                     map { tx.outRef<ContractState>(it.data) }
@@ -171,8 +164,8 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
             // We need to resolve the full transaction here because outputs are calculated from inputs
             // We also can't do filtering beforehand, since output encumbrance pointers get recalculated based on
             // input positions
-            val ltx = tx.resolve(services, emptyList())
-            val myKeys = services.keyManagementService.filterMyKeys(ltx.outputs.flatMap { it.data.participants.map { it.owningKey } })
+            val ltx = tx.resolve(stateLoader, emptyList())
+            val myKeys = keyManagementService.filterMyKeys(ltx.outputs.flatMap { it.data.participants.map { it.owningKey } })
             val (consumedStateAndRefs, producedStates) = ltx.inputs.
                     zip(ltx.outputs).
                     filter { (_, output) -> isRelevant(output.data, myKeys.toSet()) }.
@@ -246,7 +239,7 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
 
     @Throws(StatesNotAvailableException::class)
     override fun softLockReserve(lockId: UUID, stateRefs: NonEmptySet<StateRef>) {
-        val softLockTimestamp = services.clock.instant()
+        val softLockTimestamp = clock.instant()
         try {
             val session = DatabaseTransactionManager.current().session
             val criteriaBuilder = session.criteriaBuilder
@@ -292,7 +285,7 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
     }
 
     override fun softLockRelease(lockId: UUID, stateRefs: NonEmptySet<StateRef>?) {
-        val softLockTimestamp = services.clock.instant()
+        val softLockTimestamp = clock.instant()
         val session = DatabaseTransactionManager.current().session
         val criteriaBuilder = session.criteriaBuilder
         if (stateRefs == null) {
@@ -440,8 +433,8 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
                 // pagination checks
                 if (!paging.isDefault) {
                     // pagination
-                    if (paging.pageNumber < DEFAULT_PAGE_NUM) throw VaultQueryException("Page specification: invalid page number ${paging.pageNumber} [page numbers start from ${DEFAULT_PAGE_NUM}]")
-                    if (paging.pageSize < 1) throw VaultQueryException("Page specification: invalid page size ${paging.pageSize} [must be a value between 1 and ${MAX_PAGE_SIZE}]")
+                    if (paging.pageNumber < DEFAULT_PAGE_NUM) throw VaultQueryException("Page specification: invalid page number ${paging.pageNumber} [page numbers start from $DEFAULT_PAGE_NUM]")
+                    if (paging.pageSize < 1) throw VaultQueryException("Page specification: invalid page size ${paging.pageSize} [must be a value between 1 and $MAX_PAGE_SIZE]")
                 }
 
                 query.firstResult = (paging.pageNumber - 1) * paging.pageSize
@@ -452,7 +445,7 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
 
                 // final pagination check (fail-fast on too many results when no pagination specified)
                 if (paging.isDefault && results.size > DEFAULT_PAGE_SIZE)
-                    throw VaultQueryException("Please specify a `PageSpecification` as there are more results [${results.size}] than the default page size [${DEFAULT_PAGE_SIZE}]")
+                    throw VaultQueryException("Please specify a `PageSpecification` as there are more results [${results.size}] than the default page size [$DEFAULT_PAGE_SIZE]")
 
                 val statesAndRefs: MutableList<StateAndRef<T>> = mutableListOf()
                 val statesMeta: MutableList<Vault.StateMetadata> = mutableListOf()
@@ -495,8 +488,7 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
     override fun <T : ContractState> _trackBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
         return mutex.locked {
             val snapshotResults = _queryBy(criteria, paging, sorting, contractStateType)
-            @Suppress("UNCHECKED_CAST")
-            val updates = _updatesPublisher.bufferUntilSubscribed().filter { it.containsType(contractStateType, snapshotResults.stateTypes) } as Observable<Vault.Update<T>>
+            val updates: Observable<Vault.Update<T>> = uncheckedCast(_updatesPublisher.bufferUntilSubscribed().filter { it.containsType(contractStateType, snapshotResults.stateTypes) })
             DataFeed(snapshotResults, updates)
         }
     }
@@ -522,8 +514,7 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
 
             val contractInterfaceToConcreteTypes = mutableMapOf<String, MutableSet<String>>()
             distinctTypes.forEach { type ->
-                @Suppress("UNCHECKED_CAST")
-                val concreteType = Class.forName(type) as Class<ContractState>
+                val concreteType: Class<ContractState> = uncheckedCast(Class.forName(type))
                 val contractInterfaces = deriveContractInterfaces(concreteType)
                 contractInterfaces.map {
                     val contractInterface = contractInterfaceToConcreteTypes.getOrPut(it.name, { mutableSetOf() })
@@ -537,10 +528,9 @@ class NodeVaultService(private val services: ServiceHub, private val hibernateCo
     private fun <T : ContractState> deriveContractInterfaces(clazz: Class<T>): Set<Class<T>> {
         val myInterfaces: MutableSet<Class<T>> = mutableSetOf()
         clazz.interfaces.forEach {
-            if (!it.equals(ContractState::class.java)) {
-                @Suppress("UNCHECKED_CAST")
-                myInterfaces.add(it as Class<T>)
-                myInterfaces.addAll(deriveContractInterfaces(it))
+            if (it != ContractState::class.java) {
+                myInterfaces.add(uncheckedCast(it))
+                myInterfaces.addAll(deriveContractInterfaces(uncheckedCast(it)))
             }
         }
         return myInterfaces
diff --git a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
index 0b7466dddf..ad05ba1ad2 100644
--- a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
@@ -9,12 +9,12 @@ import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.node.ServiceHub
-import net.corda.core.node.services.VaultService
 import net.corda.core.serialization.SingletonSerializeAsToken
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.days
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
+import net.corda.node.services.api.VaultServiceInternal
 import net.corda.node.services.identity.InMemoryIdentityService
 import net.corda.node.services.persistence.DBCheckpointStorage
 import net.corda.node.services.statemachine.FlowLogicRefFactoryImpl
@@ -96,7 +96,7 @@ class NodeSchedulerServiceTest : SingletonSerializeAsToken() {
                     overrideClock = testClock,
                     keyManagement = kms,
                     network = mockMessagingService), TestReference {
-                override val vaultService: VaultService = NodeVaultService(this, database.hibernateConfig)
+                override val vaultService: VaultServiceInternal = NodeVaultService(testClock, kms, stateLoader, database.hibernateConfig)
                 override val testReference = this@NodeSchedulerServiceTest
                 override val cordappProvider: CordappProviderImpl = CordappProviderImpl(CordappLoader.createWithTestPackages()).start(attachments)
             }
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
index e13460aea9..f043a4c675 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
@@ -6,18 +6,14 @@ import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.SignatureMetadata
 import net.corda.core.crypto.TransactionSignature
 import net.corda.core.node.services.VaultService
-import net.corda.core.schemas.MappedSchema
 import net.corda.core.toFuture
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.WireTransaction
-import net.corda.finance.schemas.CashSchemaV1
-import net.corda.finance.schemas.SampleCashSchemaV2
-import net.corda.finance.schemas.SampleCashSchemaV3
+import net.corda.node.services.api.VaultServiceInternal
 import net.corda.node.services.schema.HibernateObserver
 import net.corda.node.services.schema.NodeSchemaService
 import net.corda.node.services.transactions.PersistentUniquenessProvider
 import net.corda.node.services.vault.NodeVaultService
-import net.corda.node.services.vault.VaultSchemaV1
 import net.corda.node.utilities.CordaPersistence
 import net.corda.node.utilities.configureDatabase
 import net.corda.testing.*
@@ -46,8 +42,8 @@ class DBTransactionStorageTests : TestDependencyInjectionBase() {
         database.transaction {
 
             services = object : MockServices(BOB_KEY) {
-                override val vaultService: VaultService get() {
-                    val vaultService = NodeVaultService(this, database.hibernateConfig)
+                override val vaultService: VaultServiceInternal get() {
+                    val vaultService = NodeVaultService(clock, keyManagementService, stateLoader, database.hibernateConfig)
                     hibernatePersister = HibernateObserver(vaultService.rawUpdates, database.hibernateConfig)
                     return vaultService
                 }
@@ -57,7 +53,7 @@ class DBTransactionStorageTests : TestDependencyInjectionBase() {
                         validatedTransactions.addTransaction(stx)
                     }
                     // Refactored to use notifyAll() as we have no other unit test for that method with multiple transactions.
-                    (vaultService as NodeVaultService).notifyAll(txs.map { it.tx })
+                    vaultService.notifyAll(txs.map { it.tx })
                 }
             }
         }
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
index 54c7f933c8..7cb537575b 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
@@ -26,7 +26,6 @@ import net.corda.finance.schemas.SampleCashSchemaV3
 import net.corda.finance.utils.sumCash
 import net.corda.node.services.schema.HibernateObserver
 import net.corda.node.services.schema.NodeSchemaService
-import net.corda.node.services.vault.NodeVaultService
 import net.corda.node.services.vault.VaultSchemaV1
 import net.corda.node.utilities.CordaPersistence
 import net.corda.node.utilities.configureDatabase
@@ -82,14 +81,13 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
         database.transaction {
             hibernateConfig = database.hibernateConfig
             services = object : MockServices(BOB_KEY, BOC_KEY, DUMMY_NOTARY_KEY) {
-                override val vaultService: VaultService = makeVaultService(database.hibernateConfig)
-
+                override val vaultService = makeVaultService(database.hibernateConfig)
                 override fun recordTransactions(notifyVault: Boolean, txs: Iterable<SignedTransaction>) {
                     for (stx in txs) {
                         validatedTransactions.addTransaction(stx)
                     }
                     // Refactored to use notifyAll() as we have no other unit test for that method with multiple transactions.
-                    (vaultService as NodeVaultService).notifyAll(txs.map { it.tx })
+                    vaultService.notifyAll(txs.map { it.tx })
                 }
                 override fun jdbcSession() = database.createSession()
             }
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
index 2880435862..8b364eb12b 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
@@ -47,7 +47,7 @@ import kotlin.test.assertTrue
 class NodeVaultServiceTest : TestDependencyInjectionBase() {
     lateinit var services: MockServices
     lateinit var issuerServices: MockServices
-    val vaultService: VaultService get() = services.vaultService
+    val vaultService get() = services.vaultService as NodeVaultService
     lateinit var database: CordaPersistence
 
     @Before
@@ -98,7 +98,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
             val originalVault = vaultService
             val services2 = object : MockServices() {
-                override val vaultService: NodeVaultService get() = originalVault as NodeVaultService
+                override val vaultService: NodeVaultService get() = originalVault
                 override fun recordTransactions(notifyVault: Boolean, txs: Iterable<SignedTransaction>) {
                     for (stx in txs) {
                         validatedTransactions.addTransaction(stx)
@@ -473,7 +473,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
     @Test
     fun `is ownable state relevant`() {
-        val service = (services.vaultService as NodeVaultService)
+        val service = vaultService
         val amount = Amount(1000, Issued(BOC.ref(1), GBP))
         val wellKnownCash = Cash.State(amount, services.myInfo.chooseIdentity())
         val myKeys = services.keyManagementService.filterMyKeys(listOf(wellKnownCash.owner.owningKey))
@@ -494,7 +494,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
     @Test
     fun `correct updates are generated for general transactions`() {
-        val service = (services.vaultService as NodeVaultService)
+        val service = vaultService
         val vaultSubscriber = TestSubscriber<Vault.Update<*>>().apply {
             service.updates.subscribe(this)
         }
@@ -527,7 +527,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
     @Test
     fun `correct updates are generated when changing notaries`() {
-        val service = (services.vaultService as NodeVaultService)
+        val service = vaultService
         val notary = services.myInfo.chooseIdentity()
 
         val vaultSubscriber = TestSubscriber<Vault.Update<*>>().apply {
diff --git a/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt b/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt
index e3e54de6d4..c4ca2077cf 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt
@@ -6,9 +6,11 @@ import net.corda.core.flows.FlowInitiator
 import net.corda.core.flows.FlowLogic
 import net.corda.core.identity.Party
 import net.corda.core.node.NodeInfo
+import net.corda.core.node.StateLoader
 import net.corda.core.node.services.*
 import net.corda.core.serialization.SerializeAsToken
 import net.corda.node.internal.InitiatedFlowFactory
+import net.corda.node.internal.StateLoaderImpl
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
 import net.corda.node.serialization.NodeClock
@@ -34,7 +36,7 @@ import java.time.Clock
 open class MockServiceHubInternal(
         override val database: CordaPersistence,
         override val configuration: NodeConfiguration,
-        val customVault: VaultService? = null,
+        val customVault: VaultServiceInternal? = null,
         val keyManagement: KeyManagementService? = null,
         val network: MessagingService? = null,
         val identity: IdentityService? = MOCK_IDENTITY_SERVICE,
@@ -47,11 +49,12 @@ open class MockServiceHubInternal(
         val schemas: SchemaService? = NodeSchemaService(),
         val customContractUpgradeService: ContractUpgradeService? = null,
         val customTransactionVerifierService: TransactionVerifierService? = InMemoryTransactionVerifierService(2),
-        override val cordappProvider: CordappProvider = CordappProviderImpl(CordappLoader.createDefault(Paths.get("."))).start(attachments)
-) : ServiceHubInternal {
+        override val cordappProvider: CordappProvider = CordappProviderImpl(CordappLoader.createDefault(Paths.get("."))).start(attachments),
+        protected val stateLoader: StateLoaderImpl = StateLoaderImpl(validatedTransactions)
+) : ServiceHubInternal, StateLoader by stateLoader {
     override val transactionVerifierService: TransactionVerifierService
         get() = customTransactionVerifierService ?: throw UnsupportedOperationException()
-    override val vaultService: VaultService
+    override val vaultService: VaultServiceInternal
         get() = customVault ?: throw UnsupportedOperationException()
     override val contractUpgradeService: ContractUpgradeService
         get() = customContractUpgradeService ?: throw UnsupportedOperationException()
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
index 367dcad228..6263dfbc65 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
@@ -7,14 +7,17 @@ import net.corda.core.identity.PartyAndCertificate
 import net.corda.core.messaging.DataFeed
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.ServiceHub
+import net.corda.core.node.StateLoader
 import net.corda.core.node.services.*
 import net.corda.core.schemas.MappedSchema
 import net.corda.core.serialization.SerializeAsToken
 import net.corda.core.serialization.SingletonSerializeAsToken
 import net.corda.core.transactions.SignedTransaction
 import net.corda.node.VersionInfo
+import net.corda.node.internal.StateLoaderImpl
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.services.api.StateMachineRecordedTransactionMappingStorage
+import net.corda.node.services.api.VaultServiceInternal
 import net.corda.node.services.api.WritableTransactionStorage
 import net.corda.node.services.identity.InMemoryIdentityService
 import net.corda.node.services.keys.freshCertificate
@@ -42,7 +45,12 @@ import java.util.*
  * A singleton utility that only provides a mock identity, key and storage service. However, this is sufficient for
  * building chains of transactions and verifying them. It isn't sufficient for testing flows however.
  */
-open class MockServices(cordappPackages: List<String> = emptyList(), vararg val keys: KeyPair) : ServiceHub {
+open class MockServices(
+        cordappPackages: List<String>,
+        override val validatedTransactions: WritableTransactionStorage,
+        protected val stateLoader: StateLoaderImpl = StateLoaderImpl(validatedTransactions),
+        vararg val keys: KeyPair
+) : ServiceHub, StateLoader by stateLoader {
     companion object {
 
         @JvmStatic
@@ -105,14 +113,14 @@ open class MockServices(cordappPackages: List<String> = emptyList(), vararg val
             val mockService = database.transaction {
                 object : MockServices(cordappPackages, *(keys.toTypedArray())) {
                     override val identityService: IdentityService = database.transaction { identityServiceRef }
-                    override val vaultService: VaultService = makeVaultService(database.hibernateConfig)
+                    override val vaultService = makeVaultService(database.hibernateConfig)
 
                     override fun recordTransactions(notifyVault: Boolean, txs: Iterable<SignedTransaction>) {
                         for (stx in txs) {
                             validatedTransactions.addTransaction(stx)
                         }
                         // Refactored to use notifyAll() as we have no other unit test for that method with multiple transactions.
-                        (vaultService as NodeVaultService).notifyAll(txs.map { it.tx })
+                        vaultService.notifyAll(txs.map { it.tx })
                     }
 
                     override fun jdbcSession(): Connection = database.createSession()
@@ -122,9 +130,9 @@ open class MockServices(cordappPackages: List<String> = emptyList(), vararg val
         }
     }
 
+    constructor(cordappPackages: List<String>, vararg keys: KeyPair) : this(cordappPackages, MockTransactionStorage(), keys = *keys)
     constructor(vararg keys: KeyPair) : this(emptyList(), *keys)
-
-    constructor() : this(emptyList(), generateKeyPair())
+    constructor() : this(generateKeyPair())
 
     val key: KeyPair get() = keys.first()
 
@@ -137,8 +145,7 @@ open class MockServices(cordappPackages: List<String> = emptyList(), vararg val
         }
     }
 
-    final override val attachments: AttachmentStorage = MockAttachmentStorage()
-    override val validatedTransactions: WritableTransactionStorage = MockTransactionStorage()
+    final override val attachments = MockAttachmentStorage()
     val stateMachineRecordedTransactionMapping: StateMachineRecordedTransactionMappingStorage = MockStateMachineRecordedTransactionMappingStorage()
     override val identityService: IdentityService = InMemoryIdentityService(MOCK_IDENTITIES, trustRoot = DEV_TRUST_ROOT)
     override val keyManagementService: KeyManagementService by lazy { MockKeyManagementService(identityService, *keys) }
@@ -157,8 +164,8 @@ open class MockServices(cordappPackages: List<String> = emptyList(), vararg val
 
     lateinit var hibernatePersister: HibernateObserver
 
-    fun makeVaultService(hibernateConfig: HibernateConfiguration = HibernateConfiguration(NodeSchemaService(), makeTestDatabaseProperties(), { identityService })): VaultService {
-        val vaultService = NodeVaultService(this, hibernateConfig)
+    fun makeVaultService(hibernateConfig: HibernateConfiguration = HibernateConfiguration(NodeSchemaService(), makeTestDatabaseProperties(), { identityService })): VaultServiceInternal {
+        val vaultService = NodeVaultService(Clock.systemUTC(), keyManagementService, stateLoader, hibernateConfig)
         hibernatePersister = HibernateObserver(vaultService.rawUpdates, hibernateConfig)
         return vaultService
     }
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
index d157583c2e..9b4e99b752 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
@@ -8,10 +8,12 @@ import net.corda.core.flows.FlowException
 import net.corda.core.identity.Party
 import net.corda.core.internal.uncheckedCast
 import net.corda.core.node.ServiceHub
+import net.corda.core.node.ServicesForResolution
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.transactions.WireTransaction
 import net.corda.testing.contracts.DummyContract
+import net.corda.testing.node.MockAttachmentStorage
 import net.corda.testing.node.MockCordappProvider
 import java.io.InputStream
 import java.security.KeyPair
@@ -72,7 +74,7 @@ data class TestTransactionDSLInterpreter private constructor(
             transactionBuilder: TransactionBuilder
     ) : this(ledgerInterpreter, transactionBuilder, HashMap())
 
-    val services = object : ServiceHub by ledgerInterpreter.services {
+    val services = object : ServicesForResolution by ledgerInterpreter.services {
         override fun loadState(stateRef: StateRef) = ledgerInterpreter.resolveStateRef<ContractState>(stateRef)
         override val cordappProvider: CordappProvider = ledgerInterpreter.services.cordappProvider
     }
@@ -136,7 +138,7 @@ data class TestTransactionDSLInterpreter private constructor(
     ) = dsl(TransactionDSL(copy()))
 
     override fun _attachment(contractClassName: ContractClassName) {
-        (services.cordappProvider as MockCordappProvider).addMockCordapp(contractClassName, services)
+        (services.cordappProvider as MockCordappProvider).addMockCordapp(contractClassName, services.attachments as MockAttachmentStorage)
     }
 }
 
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
index 976d595ec6..dae72192a6 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
@@ -3,7 +3,6 @@ package net.corda.testing.node
 import net.corda.core.contracts.ContractClassName
 import net.corda.core.cordapp.Cordapp
 import net.corda.core.internal.cordapp.CordappImpl
-import net.corda.core.node.ServiceHub
 import net.corda.core.node.services.AttachmentId
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
@@ -13,27 +12,23 @@ import java.util.*
 class MockCordappProvider(cordappLoader: CordappLoader) : CordappProviderImpl(cordappLoader) {
     val cordappRegistry = mutableListOf<Pair<Cordapp, AttachmentId>>()
 
-    fun addMockCordapp(contractClassName: ContractClassName, services: ServiceHub) {
+    fun addMockCordapp(contractClassName: ContractClassName, attachments: MockAttachmentStorage) {
         val cordapp = CordappImpl(listOf(contractClassName), emptyList(), emptyList(), emptyList(), emptyList(), emptyList(), emptyList(), emptySet(), Paths.get(".").toUri().toURL())
         if (cordappRegistry.none { it.first.contractClassNames.contains(contractClassName) }) {
-            cordappRegistry.add(Pair(cordapp, findOrImportAttachment(contractClassName.toByteArray(), services)))
+            cordappRegistry.add(Pair(cordapp, findOrImportAttachment(contractClassName.toByteArray(), attachments)))
         }
     }
 
     override fun getContractAttachmentID(contractClassName: ContractClassName): AttachmentId? = cordappRegistry.find { it.first.contractClassNames.contains(contractClassName) }?.second ?: super.getContractAttachmentID(contractClassName)
 
-    private fun findOrImportAttachment(data: ByteArray, services: ServiceHub): AttachmentId {
-        return if (services.attachments is MockAttachmentStorage) {
-            val existingAttachment = (services.attachments as MockAttachmentStorage).files.filter {
-                Arrays.equals(it.value, data)
-            }
-            if (!existingAttachment.isEmpty()) {
-                existingAttachment.keys.first()
-            } else {
-                services.attachments.importAttachment(data.inputStream())
-            }
+    private fun findOrImportAttachment(data: ByteArray, attachments: MockAttachmentStorage): AttachmentId {
+        val existingAttachment = attachments.files.filter {
+            Arrays.equals(it.value, data)
+        }
+        return if (!existingAttachment.isEmpty()) {
+            existingAttachment.keys.first()
         } else {
-            throw Exception("MockCordappService only requires MockAttachmentStorage")
+            attachments.importAttachment(data.inputStream())
         }
     }
 }

From 689758a71cf934dcc0aa87be15b5a842687537dd Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Mon, 9 Oct 2017 13:02:40 +0100
Subject: [PATCH 115/185] CORDA-644: Only serialise Kotlin lambdas when
 checkpointing. (#1801)

* Remove local function because it is serialised as a lambda.
* Don't automatically whitelist Kotlin lambdas unless checkpointing.
* Add comment to @CordaSerializable, warning not to allow AnnotationTarget.EXPRESSION.
---
 .../client/rpc/BlacklistKotlinClosureTest.kt  | 92 +++++++++++++++++++
 .../core/serialization/CordaSerializable.kt   |  3 +
 .../corda/core/utilities/KotlinUtilsTest.kt   | 48 +++++++++-
 .../serialization/CordaClassResolver.kt       |  2 -
 .../statemachine/FlowStateMachineImpl.kt      |  6 +-
 5 files changed, 141 insertions(+), 10 deletions(-)
 create mode 100644 client/rpc/src/integration-test/kotlin/net/corda/client/rpc/BlacklistKotlinClosureTest.kt

diff --git a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/BlacklistKotlinClosureTest.kt b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/BlacklistKotlinClosureTest.kt
new file mode 100644
index 0000000000..776b96f87f
--- /dev/null
+++ b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/BlacklistKotlinClosureTest.kt
@@ -0,0 +1,92 @@
+package net.corda.client.rpc
+
+import co.paralleluniverse.fibers.Suspendable
+import com.esotericsoftware.kryo.KryoException
+import net.corda.core.flows.*
+import net.corda.core.identity.Party
+import net.corda.core.messaging.startFlow
+import net.corda.core.serialization.CordaSerializable
+import net.corda.core.utilities.getOrThrow
+import net.corda.core.utilities.loggerFor
+import net.corda.core.utilities.unwrap
+import net.corda.node.internal.Node
+import net.corda.node.internal.StartedNode
+import net.corda.nodeapi.User
+import net.corda.testing.*
+import net.corda.testing.node.NodeBasedTest
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.ExpectedException
+
+@CordaSerializable
+data class Packet(val x: () -> Long)
+
+class BlacklistKotlinClosureTest : NodeBasedTest() {
+    companion object {
+        @Suppress("UNUSED") val logger = loggerFor<BlacklistKotlinClosureTest>()
+        const val EVIL: Long = 666
+    }
+
+    @StartableByRPC
+    @InitiatingFlow
+    class FlowC(private val remoteParty: Party, private val data: Packet) : FlowLogic<Unit>() {
+        @Suspendable
+        override fun call() {
+            val session = initiateFlow(remoteParty)
+            val x = session.sendAndReceive<Packet>(data).unwrap { x -> x }
+            logger.info("FlowC: ${x.x()}")
+        }
+    }
+
+    @InitiatedBy(FlowC::class)
+    class RemoteFlowC(private val session: FlowSession) : FlowLogic<Unit>() {
+        @Suspendable
+        override fun call() {
+            val packet = session.receive<Packet>().unwrap { x -> x }
+            logger.info("RemoteFlowC: ${packet.x() + 1}")
+            session.send(Packet({ packet.x() + 1 }))
+        }
+    }
+
+    @JvmField
+    @Rule
+    val expectedEx: ExpectedException = ExpectedException.none()
+
+    private val rpcUser = User("user1", "test", permissions = setOf("ALL"))
+    private lateinit var aliceNode: StartedNode<Node>
+    private lateinit var bobNode: StartedNode<Node>
+    private lateinit var aliceClient: CordaRPCClient
+    private var connection: CordaRPCConnection? = null
+
+    private fun login(username: String, password: String) {
+        connection = aliceClient.start(username, password)
+    }
+
+    @Before
+    fun setUp() {
+        setCordappPackages("net.corda.client.rpc")
+        aliceNode = startNode(ALICE.name, rpcUsers = listOf(rpcUser)).getOrThrow()
+        bobNode = startNode(BOB.name, rpcUsers = listOf(rpcUser)).getOrThrow()
+        bobNode.registerInitiatedFlow(RemoteFlowC::class.java)
+        aliceClient = CordaRPCClient(aliceNode.internals.configuration.rpcAddress!!)
+    }
+
+    @After
+    fun done() {
+        connection?.close()
+        bobNode.internals.stop()
+        aliceNode.internals.stop()
+        unsetCordappPackages()
+    }
+
+    @Test
+    fun `closure sent via RPC`() {
+        login(rpcUser.username, rpcUser.password)
+        val proxy = connection!!.proxy
+        expectedEx.expect(KryoException::class.java)
+        expectedEx.expectMessage("is not annotated or on the whitelist, so cannot be used in serialization")
+        proxy.startFlow(::FlowC, bobNode.info.chooseIdentity(), Packet{ EVIL }).returnValue.getOrThrow()
+    }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/net/corda/core/serialization/CordaSerializable.kt b/core/src/main/kotlin/net/corda/core/serialization/CordaSerializable.kt
index ff90f2a462..ce80444256 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/CordaSerializable.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/CordaSerializable.kt
@@ -11,6 +11,9 @@ import java.lang.annotation.Inherited
  *
  * It also makes it possible for a code reviewer to clearly identify the classes that can be passed on the wire.
  *
+ * Do NOT include [AnnotationTarget.EXPRESSION] as one of the @Target parameters, as this would allow any Lambda to
+ * be serialised. This would be a security hole.
+ *
  * TODO: As we approach a long term wire format, this annotation will only be permitted on classes that meet certain criteria.
  */
 @Target(AnnotationTarget.CLASS)
diff --git a/core/src/test/kotlin/net/corda/core/utilities/KotlinUtilsTest.kt b/core/src/test/kotlin/net/corda/core/utilities/KotlinUtilsTest.kt
index 60bfdd8369..22ef438a6b 100644
--- a/core/src/test/kotlin/net/corda/core/utilities/KotlinUtilsTest.kt
+++ b/core/src/test/kotlin/net/corda/core/utilities/KotlinUtilsTest.kt
@@ -1,14 +1,22 @@
 package net.corda.core.utilities
 
+import com.esotericsoftware.kryo.KryoException
 import net.corda.core.crypto.random63BitValue
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.serialization.deserialize
 import net.corda.core.serialization.serialize
+import net.corda.nodeapi.internal.serialization.KRYO_CHECKPOINT_CONTEXT
 import net.corda.testing.TestDependencyInjectionBase
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.Rule
 import org.junit.Test
+import org.junit.rules.ExpectedException
 
 class KotlinUtilsTest : TestDependencyInjectionBase() {
+    @JvmField
+    @Rule
+    val expectedEx: ExpectedException = ExpectedException.none()
+
     @Test
     fun `transient property which is null`() {
         val test = NullTransientProperty()
@@ -18,26 +26,58 @@ class KotlinUtilsTest : TestDependencyInjectionBase() {
     }
 
     @Test
-    fun `transient property with non-capturing lamba`() {
+    fun `checkpointing a transient property with non-capturing lamba`() {
         val original = NonCapturingTransientProperty()
         val originalVal = original.transientVal
-        val copy = original.serialize().deserialize()
+        val copy = original.serialize(context = KRYO_CHECKPOINT_CONTEXT).deserialize(context = KRYO_CHECKPOINT_CONTEXT)
         val copyVal = copy.transientVal
         assertThat(copyVal).isNotEqualTo(originalVal)
         assertThat(copy.transientVal).isEqualTo(copyVal)
     }
 
     @Test
-    fun `transient property with capturing lamba`() {
+    fun `serialise transient property with non-capturing lamba`() {
+        expectedEx.expect(KryoException::class.java)
+        expectedEx.expectMessage("is not annotated or on the whitelist, so cannot be used in serialization")
+        val original = NonCapturingTransientProperty()
+        original.serialize()
+    }
+
+    @Test
+    fun `deserialise transient property with non-capturing lamba`() {
+        expectedEx.expect(KryoException::class.java)
+        expectedEx.expectMessage("is not annotated or on the whitelist, so cannot be used in serialization")
+        val original = NonCapturingTransientProperty()
+        original.serialize(context = KRYO_CHECKPOINT_CONTEXT).deserialize()
+    }
+
+    @Test
+    fun `checkpointing a transient property with capturing lamba`() {
         val original = CapturingTransientProperty("Hello")
         val originalVal = original.transientVal
-        val copy = original.serialize().deserialize()
+        val copy = original.serialize(context = KRYO_CHECKPOINT_CONTEXT).deserialize(context = KRYO_CHECKPOINT_CONTEXT)
         val copyVal = copy.transientVal
         assertThat(copyVal).isNotEqualTo(originalVal)
         assertThat(copy.transientVal).isEqualTo(copyVal)
         assertThat(copy.transientVal).startsWith("Hello")
     }
 
+    @Test
+    fun `serialise transient property with capturing lamba`() {
+        expectedEx.expect(KryoException::class.java)
+        expectedEx.expectMessage("is not annotated or on the whitelist, so cannot be used in serialization")
+        val original = CapturingTransientProperty("Hello")
+        original.serialize()
+    }
+
+    @Test
+    fun `deserialise transient property with capturing lamba`() {
+        expectedEx.expect(KryoException::class.java)
+        expectedEx.expectMessage("is not annotated or on the whitelist, so cannot be used in serialization")
+        val original = CapturingTransientProperty("Hello")
+        original.serialize(context = KRYO_CHECKPOINT_CONTEXT).deserialize()
+    }
+
     private class NullTransientProperty {
         var evalCount = 0
         val transientValue by transient {
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
index b614284139..afcdcbf0c8 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
@@ -63,8 +63,6 @@ class CordaClassResolver(serializationContext: SerializationContext) : DefaultCl
         if (type.isArray) return checkClass(type.componentType)
         // Specialised enum entry, so just resolve the parent Enum type since cannot annotate the specialised entry.
         if (!type.isEnum && Enum::class.java.isAssignableFrom(type)) return checkClass(type.superclass)
-        // Kotlin lambdas require some special treatment
-        if (kotlin.jvm.internal.Lambda::class.java.isAssignableFrom(type)) return null
         // It's safe to have the Class already, since Kryo loads it with initialisation off.
         // If we use a whitelist with blacklisting capabilities, whitelist.hasListed(type) may throw an IllegalStateException if input class is blacklisted.
         // Thus, blacklisting precedes annotation checking.
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
index b3103f979e..59f40a8533 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
@@ -404,9 +404,7 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
 
     @Suspendable
     private fun ReceiveRequest<*>.suspendAndExpectReceive(): ReceivedSessionMessage<*> {
-        fun pollForMessage() = session.receivedMessages.poll()
-
-        val polledMessage = pollForMessage()
+        val polledMessage = session.receivedMessages.poll()
         return if (polledMessage != null) {
             if (this is SendAndReceive) {
                 // Since we've already received the message, we downgrade to a send only to get the payload out and not
@@ -417,7 +415,7 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
         } else {
             // Suspend while we wait for a receive
             suspend(this)
-            pollForMessage() ?:
+            session.receivedMessages.poll() ?:
                     throw IllegalStateException("Was expecting a ${receiveType.simpleName} but instead got nothing for $this")
         }
     }

From 20a30b30da98ec4af386efce5e6386c3bd411f1c Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Mon, 9 Oct 2017 13:24:17 +0100
Subject: [PATCH 116/185] Initial stub for IntelliJ Code Style settings (#1832)

* Initial stub for IntelliJ Code Style settings

* Added exclusion to ".gitignore"
---
 .gitignore                  |  1 +
 .idea/codeStyleSettings.xml | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 .idea/codeStyleSettings.xml

diff --git a/.gitignore b/.gitignore
index ae3bd7f4de..645707dcfb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,6 +38,7 @@ lib/quasar.jar
 
 # Include the -parameters compiler option by default in IntelliJ required for serialization.
 !.idea/compiler.xml
+!.idea/codeStyleSettings.xml
 
 # if you remove the above rule, at least ignore the following:
 
diff --git a/.idea/codeStyleSettings.xml b/.idea/codeStyleSettings.xml
new file mode 100644
index 0000000000..e7e9428374
--- /dev/null
+++ b/.idea/codeStyleSettings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectCodeStyleSettingsManager">
+    <option name="PER_PROJECT_SETTINGS">
+      <value>
+        <JetCodeStyleSettings>
+          <option name="PACKAGES_TO_USE_STAR_IMPORTS">
+            <value>
+              <package name="java.util" withSubpackages="false" static="false" />
+              <package name="kotlinx.android.synthetic" withSubpackages="true" static="false" />
+              <package name="tornadofx" withSubpackages="false" static="false" />
+            </value>
+          </option>
+        </JetCodeStyleSettings>
+      </value>
+    </option>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </component>
+</project>
\ No newline at end of file

From 29a101c3780a7bde1ccec60ea6425796899058a1 Mon Sep 17 00:00:00 2001
From: Michele Sollecito <michele.sollecito@gmail.com>
Date: Mon, 9 Oct 2017 13:46:37 +0100
Subject: [PATCH 117/185] [CORDA-683] Enable `receiveAll()` from Flows.

---
 .gitignore                                    |   1 +
 .../kotlin/net/corda/core/flows/FlowLogic.kt  |  48 +++++++-
 .../corda/core/internal/FlowStateMachine.kt   |  11 +-
 .../net/corda/core/flows/FlowTestsUtils.kt    | 115 ++++++++++++++++++
 .../corda/core/flows/ReceiveAllFlowTests.kt   |  87 +++++++++++++
 docs/source/changelog.rst                     |   1 +
 .../services/statemachine/FlowIORequest.kt    |  66 +++++++++-
 .../statemachine/FlowSessionInternal.kt       |   2 +
 .../statemachine/FlowStateMachineImpl.kt      |  34 +++++-
 .../statemachine/StateMachineManager.kt       |  10 +-
 .../kotlin/net/corda/testing/node/MockNode.kt |  17 ++-
 11 files changed, 377 insertions(+), 15 deletions(-)
 create mode 100644 core/src/test/kotlin/net/corda/core/flows/FlowTestsUtils.kt
 create mode 100644 core/src/test/kotlin/net/corda/core/flows/ReceiveAllFlowTests.kt

diff --git a/.gitignore b/.gitignore
index 645707dcfb..ad05b9958f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,6 +34,7 @@ lib/quasar.jar
 .idea/shelf
 .idea/dataSources
 .idea/markdown-navigator
+.idea/runConfigurations
 /gradle-plugins/.idea/
 
 # Include the -parameters compiler option by default in IntelliJ required for serialization.
diff --git a/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt b/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
index fd2c144d9e..419c918753 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
@@ -6,6 +6,7 @@ import net.corda.core.identity.Party
 import net.corda.core.identity.PartyAndCertificate
 import net.corda.core.internal.FlowStateMachine
 import net.corda.core.internal.abbreviate
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.DataFeed
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.ServiceHub
@@ -177,6 +178,38 @@ abstract class FlowLogic<out T> {
         return stateMachine.receive(receiveType, otherParty, flowUsedForSessions)
     }
 
+    /** Suspends until a message has been received for each session in the specified [sessions].
+     *
+     * Consider [receiveAll(receiveType: Class<R>, sessions: List<FlowSession>): List<UntrustworthyData<R>>] when the same type is expected from all sessions.
+     *
+     * Remember that when receiving data from other parties the data should not be trusted until it's been thoroughly
+     * verified for consistency and that all expectations are satisfied, as a malicious peer may send you subtly
+     * corrupted data in order to exploit your code.
+     *
+     * @returns a [Map] containing the objects received, wrapped in an [UntrustworthyData], by the [FlowSession]s who sent them.
+     */
+    @Suspendable
+    open fun receiveAll(sessions: Map<FlowSession, Class<out Any>>): Map<FlowSession, UntrustworthyData<Any>> {
+        return stateMachine.receiveAll(sessions, this)
+    }
+
+    /**
+     * Suspends until a message has been received for each session in the specified [sessions].
+     *
+     * Consider [sessions: Map<FlowSession, Class<out Any>>): Map<FlowSession, UntrustworthyData<Any>>] when sessions are expected to receive different types.
+     *
+     * Remember that when receiving data from other parties the data should not be trusted until it's been thoroughly
+     * verified for consistency and that all expectations are satisfied, as a malicious peer may send you subtly
+     * corrupted data in order to exploit your code.
+     *
+     * @returns a [List] containing the objects received, wrapped in an [UntrustworthyData], with the same order of [sessions].
+     */
+    @Suspendable
+    open fun <R : Any> receiveAll(receiveType: Class<R>, sessions: List<FlowSession>): List<UntrustworthyData<R>> {
+        enforceNoDuplicates(sessions)
+        return castMapValuesToKnownType(receiveAll(associateSessionsToReceiveType(receiveType, sessions)))
+    }
+
     /**
      * Queues the given [payload] for sending to the [otherParty] and continues without suspending.
      *
@@ -231,7 +264,6 @@ abstract class FlowLogic<out T> {
         stateMachine.checkFlowPermission(permissionName, extraAuditData)
     }
 
-
     /**
      * Flows can call this method to record application level flow audit events
      * @param eventType is a string representing the type of event. Each flow is given a distinct namespace for these names.
@@ -334,6 +366,18 @@ abstract class FlowLogic<out T> {
             ours.setChildProgressTracker(ours.currentStep, theirs)
         }
     }
+
+    private fun enforceNoDuplicates(sessions: List<FlowSession>) {
+        require(sessions.size == sessions.toSet().size) { "A flow session can only appear once as argument." }
+    }
+
+    private fun <R> associateSessionsToReceiveType(receiveType: Class<R>, sessions: List<FlowSession>): Map<FlowSession, Class<R>> {
+        return sessions.associateByTo(LinkedHashMap(), { it }, { receiveType })
+    }
+
+    private fun <R> castMapValuesToKnownType(map: Map<FlowSession, UntrustworthyData<Any>>): List<UntrustworthyData<R>> {
+        return map.values.map { uncheckedCast<Any, UntrustworthyData<R>>(it) }
+    }
 }
 
 /**
@@ -351,4 +395,4 @@ data class FlowInfo(
          * to deduplicate it from other releases of the same CorDapp, typically a version string. See the
          * [CorDapp JAR format](https://docs.corda.net/cordapp-build-systems.html#cordapp-jar-format) for more details.
          */
-        val appName: String)
+        val appName: String)
\ No newline at end of file
diff --git a/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt b/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt
index dc09d6da3f..261af49f02 100644
--- a/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt
@@ -30,20 +30,20 @@ interface FlowStateMachine<R> {
     fun <T : Any> receive(receiveType: Class<T>, otherParty: Party, sessionFlow: FlowLogic<*>): UntrustworthyData<T>
 
     @Suspendable
-    fun send(otherParty: Party, payload: Any, sessionFlow: FlowLogic<*>): Unit
+    fun send(otherParty: Party, payload: Any, sessionFlow: FlowLogic<*>)
 
     @Suspendable
     fun waitForLedgerCommit(hash: SecureHash, sessionFlow: FlowLogic<*>): SignedTransaction
 
-    fun checkFlowPermission(permissionName: String, extraAuditData: Map<String, String>): Unit
+    fun checkFlowPermission(permissionName: String, extraAuditData: Map<String, String>)
 
-    fun recordAuditEvent(eventType: String, comment: String, extraAuditData: Map<String, String>): Unit
+    fun recordAuditEvent(eventType: String, comment: String, extraAuditData: Map<String, String>)
 
     @Suspendable
     fun flowStackSnapshot(flowClass: Class<out FlowLogic<*>>): FlowStackSnapshot?
 
     @Suspendable
-    fun persistFlowStackSnapshot(flowClass: Class<out FlowLogic<*>>): Unit
+    fun persistFlowStackSnapshot(flowClass: Class<out FlowLogic<*>>)
 
     val serviceHub: ServiceHub
     val logger: Logger
@@ -51,4 +51,7 @@ interface FlowStateMachine<R> {
     val resultFuture: CordaFuture<R>
     val flowInitiator: FlowInitiator
     val ourIdentityAndCert: PartyAndCertificate
+
+    @Suspendable
+    fun receiveAll(sessions: Map<FlowSession, Class<out Any>>, sessionFlow: FlowLogic<*>): Map<FlowSession, UntrustworthyData<Any>>
 }
diff --git a/core/src/test/kotlin/net/corda/core/flows/FlowTestsUtils.kt b/core/src/test/kotlin/net/corda/core/flows/FlowTestsUtils.kt
new file mode 100644
index 0000000000..6b6f0492b3
--- /dev/null
+++ b/core/src/test/kotlin/net/corda/core/flows/FlowTestsUtils.kt
@@ -0,0 +1,115 @@
+package net.corda.core.flows
+
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.utilities.UntrustworthyData
+import net.corda.core.utilities.unwrap
+import net.corda.node.internal.InitiatedFlowFactory
+import net.corda.node.internal.StartedNode
+import kotlin.reflect.KClass
+
+/**
+ * Allows to simplify writing flows that simply rend a message back to an initiating flow.
+ */
+class Answer<out R : Any>(session: FlowSession, override val answer: R, closure: (result: R) -> Unit = {}) : SimpleAnswer<R>(session, closure)
+
+/**
+ * Allows to simplify writing flows that simply rend a message back to an initiating flow.
+ */
+abstract class SimpleAnswer<out R : Any>(private val session: FlowSession, private val closure: (result: R) -> Unit = {}) : FlowLogic<Unit>() {
+    @Suspendable
+    override fun call() {
+        val tmp = answer
+        closure(tmp)
+        session.send(tmp)
+    }
+
+    protected abstract val answer: R
+}
+
+/**
+ * A flow that does not do anything when triggered.
+ */
+class NoAnswer(private val closure: () -> Unit = {}) : FlowLogic<Unit>() {
+    @Suspendable
+    override fun call() = closure()
+}
+
+/**
+ * Allows to register a flow of type [R] against an initiating flow of type [I].
+ */
+inline fun <I : FlowLogic<*>, reified R : FlowLogic<*>> StartedNode<*>.registerInitiatedFlow(initiatingFlowType: KClass<I>, crossinline construct: (session: FlowSession) -> R) {
+    internals.internalRegisterFlowFactory(initiatingFlowType.java, InitiatedFlowFactory.Core { session -> construct(session) }, R::class.javaObjectType, true)
+}
+
+/**
+ * Allows to register a flow of type [Answer] against an initiating flow of type [I], returning a valure of type [R].
+ */
+inline fun <I : FlowLogic<*>, reified R : Any> StartedNode<*>.registerAnswer(initiatingFlowType: KClass<I>, value: R) {
+    internals.internalRegisterFlowFactory(initiatingFlowType.java, InitiatedFlowFactory.Core { session -> Answer(session, value) }, Answer::class.javaObjectType, true)
+}
+
+/**
+ * Extracts data from a [Map[FlowSession, UntrustworthyData<Any>]] without performing checks and casting to [R].
+ */
+@Suppress("UNCHECKED_CAST")
+infix fun <R : Any> Map<FlowSession, UntrustworthyData<Any>>.from(session: FlowSession): R = this[session]!!.unwrap { it as R }
+
+/**
+ * Creates a [Pair([session], [Class])] from this [Class].
+ */
+infix fun <T : Class<out Any>> T.from(session: FlowSession): Pair<FlowSession, T> = session to this
+
+/**
+ * Creates a [Pair([session], [Class])] from this [KClass].
+ */
+infix fun <T : Any> KClass<T>.from(session: FlowSession): Pair<FlowSession, Class<T>> = session to this.javaObjectType
+
+/**
+ * Suspends until a message has been received for each session in the specified [sessions].
+ *
+ * Consider [receiveAll(receiveType: Class<R>, sessions: List<FlowSession>): List<UntrustworthyData<R>>] when the same type is expected from all sessions.
+ *
+ * Remember that when receiving data from other parties the data should not be trusted until it's been thoroughly
+ * verified for consistency and that all expectations are satisfied, as a malicious peer may send you subtly
+ * corrupted data in order to exploit your code.
+ *
+ * @returns a [Map] containing the objects received, wrapped in an [UntrustworthyData], by the [FlowSession]s who sent them.
+ */
+@Suspendable
+fun FlowLogic<*>.receiveAll(session: Pair<FlowSession, Class<out Any>>, vararg sessions: Pair<FlowSession, Class<out Any>>): Map<FlowSession, UntrustworthyData<Any>> {
+    val allSessions = arrayOf(session, *sessions)
+    allSessions.enforceNoDuplicates()
+    return receiveAll(mapOf(*allSessions))
+}
+
+/**
+ * Suspends until a message has been received for each session in the specified [sessions].
+ *
+ * Consider [sessions: Map<FlowSession, Class<out Any>>): Map<FlowSession, UntrustworthyData<Any>>] when sessions are expected to receive different types.
+ *
+ * Remember that when receiving data from other parties the data should not be trusted until it's been thoroughly
+ * verified for consistency and that all expectations are satisfied, as a malicious peer may send you subtly
+ * corrupted data in order to exploit your code.
+ *
+ * @returns a [List] containing the objects received, wrapped in an [UntrustworthyData], with the same order of [sessions].
+ */
+@Suspendable
+fun <R : Any> FlowLogic<*>.receiveAll(receiveType: Class<R>, session: FlowSession, vararg sessions: FlowSession): List<UntrustworthyData<R>> = receiveAll(receiveType, listOf(session, *sessions))
+
+/**
+ * Suspends until a message has been received for each session in the specified [sessions].
+ *
+ * Consider [sessions: Map<FlowSession, Class<out Any>>): Map<FlowSession, UntrustworthyData<Any>>] when sessions are expected to receive different types.
+ *
+ * Remember that when receiving data from other parties the data should not be trusted until it's been thoroughly
+ * verified for consistency and that all expectations are satisfied, as a malicious peer may send you subtly
+ * corrupted data in order to exploit your code.
+ *
+ * @returns a [List] containing the objects received, wrapped in an [UntrustworthyData], with the same order of [sessions].
+ */
+@Suspendable
+inline fun <reified R : Any> FlowLogic<*>.receiveAll(session: FlowSession, vararg sessions: FlowSession): List<UntrustworthyData<R>> = receiveAll(R::class.javaObjectType, listOf(session, *sessions))
+
+private fun Array<out Pair<FlowSession, Class<out Any>>>.enforceNoDuplicates() {
+    require(this.size == this.toSet().size) { "A flow session can only appear once as argument." }
+}
\ No newline at end of file
diff --git a/core/src/test/kotlin/net/corda/core/flows/ReceiveAllFlowTests.kt b/core/src/test/kotlin/net/corda/core/flows/ReceiveAllFlowTests.kt
new file mode 100644
index 0000000000..cfadcf4bf5
--- /dev/null
+++ b/core/src/test/kotlin/net/corda/core/flows/ReceiveAllFlowTests.kt
@@ -0,0 +1,87 @@
+package net.corda.core.flows
+
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.identity.Party
+import net.corda.core.utilities.UntrustworthyData
+import net.corda.core.utilities.getOrThrow
+import net.corda.core.utilities.unwrap
+import net.corda.testing.chooseIdentity
+import net.corda.testing.node.network
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class ReceiveMultipleFlowTests {
+    @Test
+    fun `receive all messages in parallel using map style`() {
+        network(3) { nodes, _ ->
+            val doubleValue = 5.0
+            nodes[1].registerAnswer(AlgorithmDefinition::class, doubleValue)
+            val stringValue = "Thriller"
+            nodes[2].registerAnswer(AlgorithmDefinition::class, stringValue)
+
+            val flow = nodes[0].services.startFlow(ParallelAlgorithmMap(nodes[1].info.chooseIdentity(), nodes[2].info.chooseIdentity()))
+            runNetwork()
+
+            val result = flow.resultFuture.getOrThrow()
+
+            assertThat(result).isEqualTo(doubleValue * stringValue.length)
+        }
+    }
+
+    @Test
+    fun `receive all messages in parallel using list style`() {
+        network(3) { nodes, _ ->
+            val value1 = 5.0
+            nodes[1].registerAnswer(ParallelAlgorithmList::class, value1)
+            val value2 = 6.0
+            nodes[2].registerAnswer(ParallelAlgorithmList::class, value2)
+
+            val flow = nodes[0].services.startFlow(ParallelAlgorithmList(nodes[1].info.chooseIdentity(), nodes[2].info.chooseIdentity()))
+            runNetwork()
+            val data = flow.resultFuture.getOrThrow()
+
+            assertThat(data[0]).isEqualTo(value1)
+            assertThat(data[1]).isEqualTo(value2)
+            assertThat(data.fold(1.0) { a, b -> a * b }).isEqualTo(value1 * value2)
+        }
+    }
+
+    class ParallelAlgorithmMap(doubleMember: Party, stringMember: Party) : AlgorithmDefinition(doubleMember, stringMember) {
+        @Suspendable
+        override fun askMembersForData(doubleMember: Party, stringMember: Party): Data {
+            val doubleSession = initiateFlow(doubleMember)
+            val stringSession = initiateFlow(stringMember)
+            val rawData = receiveAll(Double::class from doubleSession, String::class from stringSession)
+            return Data(rawData from doubleSession, rawData from stringSession)
+        }
+    }
+
+    @InitiatingFlow
+    class ParallelAlgorithmList(private val member1: Party, private val member2: Party) : FlowLogic<List<Double>>() {
+        @Suspendable
+        override fun call(): List<Double> {
+            val session1 = initiateFlow(member1)
+            val session2 = initiateFlow(member2)
+            val data = receiveAll<Double>(session1, session2)
+            return computeAnswer(data)
+        }
+
+        private fun computeAnswer(data: List<UntrustworthyData<Double>>): List<Double> {
+            return data.map { element -> element.unwrap { it } }
+        }
+    }
+
+    @InitiatingFlow
+    abstract class AlgorithmDefinition(private val doubleMember: Party, private val stringMember: Party) : FlowLogic<Double>() {
+        protected data class Data(val double: Double, val string: String)
+
+        @Suspendable
+        protected abstract fun askMembersForData(doubleMember: Party, stringMember: Party): Data
+
+        @Suspendable
+        override fun call(): Double {
+            val (double, string) = askMembersForData(doubleMember, stringMember)
+            return double * string.length
+        }
+    }
+}
\ No newline at end of file
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index f07f2e964e..0955876373 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -6,6 +6,7 @@ from the previous milestone release.
 
 UNRELEASED
 ----------
+* ``FlowLogic`` now exposes a series of function called ``receiveAll(...)`` allowing to join ``receive(...)`` instructions.
 
 * ``Cordform`` and node identity generation
   * Cordform may not specify a value for ``NetworkMap``, when that happens, during the task execution the following happens:
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowIORequest.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowIORequest.kt
index 748cce9bd8..cd56d786ad 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowIORequest.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowIORequest.kt
@@ -1,5 +1,6 @@
 package net.corda.node.services.statemachine
 
+import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.crypto.SecureHash
 
 interface FlowIORequest {
@@ -8,7 +9,9 @@ interface FlowIORequest {
     val stackTraceInCaseOfProblems: StackSnapshot
 }
 
-interface WaitingRequest : FlowIORequest
+interface WaitingRequest : FlowIORequest {
+    fun shouldResume(message: ExistingSessionMessage, session: FlowSessionInternal): Boolean
+}
 
 interface SessionedFlowIORequest : FlowIORequest {
     val session: FlowSessionInternal
@@ -21,6 +24,8 @@ interface SendRequest : SessionedFlowIORequest {
 interface ReceiveRequest<T : SessionMessage> : SessionedFlowIORequest, WaitingRequest {
     val receiveType: Class<T>
     val userReceiveType: Class<*>?
+
+    override fun shouldResume(message: ExistingSessionMessage, session: FlowSessionInternal): Boolean = this.session === session
 }
 
 data class SendAndReceive<T : SessionMessage>(override val session: FlowSessionInternal,
@@ -38,6 +43,63 @@ data class ReceiveOnly<T : SessionMessage>(override val session: FlowSessionInte
     override val stackTraceInCaseOfProblems: StackSnapshot = StackSnapshot()
 }
 
+class ReceiveAll(val requests: List<ReceiveRequest<SessionData>>) : WaitingRequest {
+    @Transient
+    override val stackTraceInCaseOfProblems: StackSnapshot = StackSnapshot()
+
+    private fun isComplete(received: LinkedHashMap<FlowSessionInternal, RequestMessage>): Boolean {
+        return received.keys == requests.map { it.session }.toSet()
+    }
+    private fun shouldResumeIfRelevant() = requests.all { hasSuccessfulEndMessage(it) }
+
+    private fun hasSuccessfulEndMessage(it: ReceiveRequest<SessionData>): Boolean {
+        return it.session.receivedMessages.map { it.message }.any { it is SessionData || it is SessionEnd }
+    }
+
+    @Suspendable
+    fun suspendAndExpectReceive(suspend: Suspend): Map<FlowSessionInternal, RequestMessage> {
+        val receivedMessages = LinkedHashMap<FlowSessionInternal, RequestMessage>()
+
+        poll(receivedMessages)
+        return if (isComplete(receivedMessages)) {
+            receivedMessages
+        } else {
+            suspend(this)
+            poll(receivedMessages)
+            if (isComplete(receivedMessages)) {
+                receivedMessages
+            } else {
+                throw IllegalStateException(requests.filter { it.session !in receivedMessages.keys }.map { "Was expecting a ${it.receiveType.simpleName} but instead got nothing for $it." }.joinToString { "\n" })
+            }
+        }
+    }
+
+    interface Suspend {
+        @Suspendable
+        operator fun invoke(request: FlowIORequest)
+    }
+
+    @Suspendable
+    private fun poll(receivedMessages: LinkedHashMap<FlowSessionInternal, RequestMessage>) {
+        return requests.filter { it.session !in receivedMessages.keys }.forEach { request ->
+            poll(request)?.let {
+                receivedMessages[request.session] = RequestMessage(request, it)
+            }
+        }
+    }
+
+    @Suspendable
+    private fun poll(request: ReceiveRequest<SessionData>): ReceivedSessionMessage<*>? {
+        return request.session.receivedMessages.poll()
+    }
+
+    override fun shouldResume(message: ExistingSessionMessage, session: FlowSessionInternal): Boolean = isRelevant(session) && shouldResumeIfRelevant()
+
+    private fun isRelevant(session: FlowSessionInternal) = requests.any { it.session === session }
+
+    data class RequestMessage(val request: ReceiveRequest<SessionData>, val message: ReceivedSessionMessage<*>)
+}
+
 data class SendOnly(override val session: FlowSessionInternal, override val message: SessionMessage) : SendRequest {
     @Transient
     override val stackTraceInCaseOfProblems: StackSnapshot = StackSnapshot()
@@ -46,6 +108,8 @@ data class SendOnly(override val session: FlowSessionInternal, override val mess
 data class WaitForLedgerCommit(val hash: SecureHash, val fiber: FlowStateMachineImpl<*>) : WaitingRequest {
     @Transient
     override val stackTraceInCaseOfProblems: StackSnapshot = StackSnapshot()
+
+    override fun shouldResume(message: ExistingSessionMessage, session: FlowSessionInternal): Boolean = message is ErrorSessionEnd
 }
 
 class StackSnapshot : Throwable("This is a stack trace to help identify the source of the underlying problem")
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowSessionInternal.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowSessionInternal.kt
index 4f2d1ba5fc..dc5b39c6f5 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowSessionInternal.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowSessionInternal.kt
@@ -2,6 +2,7 @@ package net.corda.node.services.statemachine
 
 import net.corda.core.flows.FlowInfo
 import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.FlowSession
 import net.corda.core.identity.Party
 import net.corda.node.services.statemachine.FlowSessionState.Initiated
 import net.corda.node.services.statemachine.FlowSessionState.Initiating
@@ -15,6 +16,7 @@ import java.util.concurrent.ConcurrentLinkedQueue
 // TODO rename this
 class FlowSessionInternal(
         val flow: FlowLogic<*>,
+        val flowSession : FlowSession,
         val ourSessionId: Long,
         val initiatingParty: Party?,
         var state: FlowSessionState,
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
index 59f40a8533..0de001283e 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
@@ -12,9 +12,13 @@ import net.corda.core.crypto.random63BitValue
 import net.corda.core.flows.*
 import net.corda.core.identity.Party
 import net.corda.core.identity.PartyAndCertificate
-import net.corda.core.internal.*
+import net.corda.core.internal.FlowStateMachine
+import net.corda.core.internal.abbreviate
 import net.corda.core.internal.concurrent.OpenFuture
 import net.corda.core.internal.concurrent.openFuture
+import net.corda.core.internal.isRegularFile
+import net.corda.core.internal.staticField
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.utilities.*
 import net.corda.node.services.api.FlowAppAuditEvent
@@ -171,8 +175,8 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
                             "@${InitiatingFlow::class.java.simpleName} sub-flow."
             )
         }
-        createNewSession(otherParty, sessionFlow)
         val flowSession = FlowSessionImpl(otherParty)
+        createNewSession(otherParty, flowSession, sessionFlow)
         flowSession.stateMachine = this
         flowSession.sessionFlow = sessionFlow
         return flowSession
@@ -299,6 +303,22 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
         FlowStackSnapshotFactory.instance.persistAsJsonFile(flowClass, serviceHub.configuration.baseDirectory, id)
     }
 
+    @Suspendable
+    override fun receiveAll(sessions: Map<FlowSession, Class<out Any>>, sessionFlow: FlowLogic<*>): Map<FlowSession, UntrustworthyData<Any>> {
+        val requests = ArrayList<ReceiveOnly<SessionData>>()
+        for ((session, receiveType) in sessions) {
+            val sessionInternal = getConfirmedSession(session.counterparty, sessionFlow)
+            requests.add(ReceiveOnly(sessionInternal, SessionData::class.java, receiveType))
+        }
+        val receivedMessages = ReceiveAll(requests).suspendAndExpectReceive(suspend)
+        val result = LinkedHashMap<FlowSession, UntrustworthyData<Any>>()
+        for ((sessionInternal, requestAndMessage) in receivedMessages) {
+            val message = requestAndMessage.message.confirmReceiveType(requestAndMessage.request)
+            result[sessionInternal.flowSession] = message.checkPayloadIs(requestAndMessage.request.userReceiveType as Class<out Any>)
+        }
+        return result
+    }
+
     /**
      * This method will suspend the state machine and wait for incoming session init response from other party.
      */
@@ -362,10 +382,11 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
 
     private fun createNewSession(
             otherParty: Party,
+            flowSession: FlowSession,
             sessionFlow: FlowLogic<*>
     ) {
         logger.trace { "Creating a new session with $otherParty" }
-        val session = FlowSessionInternal(sessionFlow, random63BitValue(), null, FlowSessionState.Uninitiated(otherParty))
+        val session = FlowSessionInternal(sessionFlow, flowSession, random63BitValue(), null, FlowSessionState.Uninitiated(otherParty))
         openSessions[Pair(sessionFlow, otherParty)] = session
     }
 
@@ -402,6 +423,13 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
         return receiveRequest.suspendAndExpectReceive().confirmReceiveType(receiveRequest)
     }
 
+    private val suspend : ReceiveAll.Suspend = object : ReceiveAll.Suspend {
+        @Suspendable
+        override fun invoke(request: FlowIORequest) {
+            suspend(request)
+        }
+    }
+
     @Suspendable
     private fun ReceiveRequest<*>.suspendAndExpectReceive(): ReceivedSessionMessage<*> {
         val polledMessage = session.receivedMessages.poll()
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
index 28e2c58958..c8189063a6 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
@@ -15,7 +15,11 @@ import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.random63BitValue
 import net.corda.core.flows.*
 import net.corda.core.identity.Party
-import net.corda.core.internal.*
+import net.corda.core.internal.FlowStateMachine
+import net.corda.core.internal.ThreadBox
+import net.corda.core.internal.bufferUntilSubscribed
+import net.corda.core.internal.castIfPossible
+import net.corda.core.internal.uncheckedCast
 import net.corda.core.messaging.DataFeed
 import net.corda.core.serialization.SerializationDefaults.CHECKPOINT_CONTEXT
 import net.corda.core.serialization.SerializationDefaults.SERIALIZATION_FACTORY
@@ -342,8 +346,7 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
     // commit but a counterparty flow has ended with an error (in which case our flow also has to end)
     private fun resumeOnMessage(message: ExistingSessionMessage, session: FlowSessionInternal): Boolean {
         val waitingForResponse = session.fiber.waitingForResponse
-        return (waitingForResponse as? ReceiveRequest<*>)?.session === session ||
-                waitingForResponse is WaitForLedgerCommit && message is ErrorSessionEnd
+        return waitingForResponse?.shouldResume(message, session) ?: false
     }
 
     private fun onSessionInit(sessionInit: SessionInit, receivedMessage: ReceivedMessage, sender: Party) {
@@ -362,6 +365,7 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
             }
             val session = FlowSessionInternal(
                     flow,
+                    flowSession,
                     random63BitValue(),
                     sender,
                     FlowSessionState.Initiated(sender, senderSessionId, FlowInfo(senderFlowVersion, sessionInit.appName)))
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index b1f02788c6..52989475b3 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -51,6 +51,7 @@ import net.corda.testing.resetTestSerialization
 import net.corda.testing.testNodeConfiguration
 import org.apache.activemq.artemis.utils.ReusableLatch
 import org.slf4j.Logger
+import java.io.Closeable
 import java.math.BigInteger
 import java.nio.file.Path
 import java.security.KeyPair
@@ -81,12 +82,11 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                   servicePeerAllocationStrategy: InMemoryMessagingNetwork.ServicePeerAllocationStrategy =
                   InMemoryMessagingNetwork.ServicePeerAllocationStrategy.Random(),
                   private val defaultFactory: Factory<*> = MockNetwork.DefaultFactory,
-                  private val initialiseSerialization: Boolean = true) {
+                  private val initialiseSerialization: Boolean = true) : Closeable {
     companion object {
         // TODO In future PR we're removing the concept of network map node so the details of this mock are not important.
         val MOCK_NET_MAP = Party(CordaX500Name(organisation = "Mock Network Map", locality = "Madrid", country = "ES"), DUMMY_KEY_1.public)
     }
-
     var nextNodeId = 0
         private set
     private val filesystem = Jimfs.newFileSystem(unix())
@@ -445,4 +445,17 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
     fun waitQuiescent() {
         busyLatch.await()
     }
+
+    override fun close() {
+        stopNodes()
+    }
 }
+
+fun network(nodesCount: Int, action: MockNetwork.(nodes: List<StartedNode<MockNetwork.MockNode>>, notary: StartedNode<MockNetwork.MockNode>) -> Unit) {
+    MockNetwork().use {
+        it.runNetwork()
+        val notary = it.createNotaryNode()
+        val nodes = (1..nodesCount).map { _ -> it.createPartyNode() }
+        action(it, nodes, notary)
+    }
+}
\ No newline at end of file

From 69ad52cf5c8b4e1931238fc7504c49c6fcaaec53 Mon Sep 17 00:00:00 2001
From: Alberto Arri <30873160+al-r3@users.noreply.github.com>
Date: Mon, 9 Oct 2017 13:53:36 +0100
Subject: [PATCH 118/185] Deflake node infoWatcherTest (#1836)

* Stop using the watch service, just re-read the whole directory every time. On macOS it's quite unpredictable and the tests are almost always failing.
---
 .../services/network/NodeInfoWatcherTest.kt   |  5 +-
 .../node/services/network/NodeInfoWatcher.kt  | 60 ++++---------------
 2 files changed, 14 insertions(+), 51 deletions(-)

diff --git a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
index 61dee26ad0..f845395020 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
@@ -70,9 +70,9 @@ class NodeInfoWatcherTest : NodeBasedTest() {
 
         nodeInfoWatcher.nodeInfoUpdates()
                 .subscribe(testSubscriber)
+        advanceTime()
 
         val readNodes = testSubscriber.onNextEvents.distinct()
-        advanceTime()
         assertEquals(0, readNodes.size)
     }
 
@@ -82,6 +82,7 @@ class NodeInfoWatcherTest : NodeBasedTest() {
 
         nodeInfoWatcher.nodeInfoUpdates()
                 .subscribe(testSubscriber)
+        advanceTime()
 
         val readNodes = testSubscriber.onNextEvents.distinct()
 
@@ -114,7 +115,7 @@ class NodeInfoWatcherTest : NodeBasedTest() {
     }
 
     private fun advanceTime() {
-        scheduler.advanceTimeBy(1, TimeUnit.HOURS)
+        scheduler.advanceTimeBy(1, TimeUnit.MINUTES)
     }
 
     // Write a nodeInfo under the right path.
diff --git a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
index 2d4db9e3fa..b73ded13e3 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
@@ -3,7 +3,12 @@ package net.corda.node.services.network
 import net.corda.cordform.CordformNode
 import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.SignedData
-import net.corda.core.internal.*
+import net.corda.core.internal.createDirectories
+import net.corda.core.internal.div
+import net.corda.core.internal.isDirectory
+import net.corda.core.internal.isRegularFile
+import net.corda.core.internal.list
+import net.corda.core.internal.readAll
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.services.KeyManagementService
 import net.corda.core.serialization.deserialize
@@ -13,10 +18,6 @@ import rx.Observable
 import rx.Scheduler
 import rx.schedulers.Schedulers
 import java.nio.file.Path
-import java.nio.file.StandardWatchEventKinds
-import java.nio.file.WatchEvent
-import java.nio.file.WatchKey
-import java.nio.file.WatchService
 import java.util.concurrent.TimeUnit
 import kotlin.streams.toList
 
@@ -33,7 +34,6 @@ class NodeInfoWatcher(private val nodePath: Path,
                       private val scheduler: Scheduler = Schedulers.io()) {
 
     private val nodeInfoDirectory = nodePath / CordformNode.NODE_INFO_DIRECTORY
-    private val watchService : WatchService? by lazy { initWatch() }
 
     companion object {
         private val logger = loggerFor<NodeInfoWatcher>()
@@ -67,14 +67,15 @@ class NodeInfoWatcher(private val nodePath: Path,
      * Read all the files contained in [nodePath] / [CordformNode.NODE_INFO_DIRECTORY] and keep watching
      * the folder for further updates.
      *
+     * We simply list the directory content every 5 seconds, the Java implementation of WatchService has been proven to
+     * be unreliable on MacOs and given the fairly simple use case we have, this simple implementation should do.
+     *
      * @return an [Observable] returning [NodeInfo]s, there is no guarantee that the same value isn't returned more
      *      than once.
      */
     fun nodeInfoUpdates(): Observable<NodeInfo> {
-        val pollForFiles = Observable.interval(5, TimeUnit.SECONDS, scheduler)
-                .flatMapIterable { pollWatch() }
-        val readCurrentFiles = Observable.from(loadFromDirectory())
-        return readCurrentFiles.mergeWith(pollForFiles)
+        return Observable.interval(5, TimeUnit.SECONDS, scheduler)
+                .flatMapIterable { loadFromDirectory() }
     }
 
     /**
@@ -84,7 +85,6 @@ class NodeInfoWatcher(private val nodePath: Path,
      * @return a list of [NodeInfo]s
      */
     private fun loadFromDirectory(): List<NodeInfo> {
-        val nodeInfoDirectory = nodePath / CordformNode.NODE_INFO_DIRECTORY
         if (!nodeInfoDirectory.isDirectory()) {
             logger.info("$nodeInfoDirectory isn't a Directory, not loading NodeInfo from files")
             return emptyList()
@@ -99,31 +99,6 @@ class NodeInfoWatcher(private val nodePath: Path,
         return result
     }
 
-    // Polls the watchService for changes to nodeInfoDirectory, return all the newly read NodeInfos.
-    private fun pollWatch(): List<NodeInfo> {
-        if (watchService == null) {
-            return emptyList()
-        }
-        val watchKey: WatchKey = watchService?.poll() ?: return emptyList()
-        val files = mutableSetOf<Path>()
-        for (event in watchKey.pollEvents()) {
-            val kind = event.kind()
-            if (kind == StandardWatchEventKinds.OVERFLOW) continue
-
-            val ev: WatchEvent<Path> = uncheckedCast(event)
-            val filename = ev.context()
-            val absolutePath = nodeInfoDirectory.resolve(filename)
-            if (absolutePath.isRegularFile()) {
-                files.add(absolutePath)
-            }
-        }
-        val valid = watchKey.reset()
-        if (!valid) {
-            logger.warn("Can't poll $nodeInfoDirectory anymore, it was probably deleted.")
-        }
-        return files.mapNotNull { processFile(it) }
-    }
-
     private fun processFile(file: Path) : NodeInfo? {
         try {
             logger.info("Reading NodeInfo from file: $file")
@@ -134,17 +109,4 @@ class NodeInfoWatcher(private val nodePath: Path,
             return null
         }
     }
-
-    // Create a WatchService watching for changes in nodeInfoDirectory.
-    private fun initWatch() : WatchService? {
-        if (!nodeInfoDirectory.isDirectory()) {
-            logger.warn("Not watching folder $nodeInfoDirectory it doesn't exist or it's not a directory")
-            return null
-        }
-        val watchService = nodeInfoDirectory.fileSystem.newWatchService()
-        nodeInfoDirectory.register(watchService, StandardWatchEventKinds.ENTRY_CREATE,
-                StandardWatchEventKinds.ENTRY_MODIFY)
-        logger.info("Watching $nodeInfoDirectory for new files")
-        return watchService
-    }
 }

From f6e5d2385a5aeffe6d89373c3dac0b978ee021c6 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Mon, 9 Oct 2017 15:24:39 +0100
Subject: [PATCH 119/185] Non-material public API change due to interfaces
 being re-arranged (#1852)

---
 .ci/api-current.txt | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.ci/api-current.txt b/.ci/api-current.txt
index 86d889b83d..cd28b2719a 100644
--- a/.ci/api-current.txt
+++ b/.ci/api-current.txt
@@ -1519,7 +1519,6 @@ public interface net.corda.core.node.ServiceHub extends net.corda.core.node.Serv
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.TransactionStorage getValidatedTransactions()
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.VaultService getVaultService()
   @org.jetbrains.annotations.NotNull public abstract java.sql.Connection jdbcSession()
-  @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.TransactionState loadState(net.corda.core.contracts.StateRef)
   public abstract void recordTransactions(Iterable)
   public abstract void recordTransactions(boolean, Iterable)
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.transactions.SignedTransaction signInitialTransaction(net.corda.core.transactions.TransactionBuilder)
@@ -1527,10 +1526,12 @@ public interface net.corda.core.node.ServiceHub extends net.corda.core.node.Serv
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.transactions.SignedTransaction signInitialTransaction(net.corda.core.transactions.TransactionBuilder, java.security.PublicKey)
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.StateAndRef toStateAndRef(net.corda.core.contracts.StateRef)
 ##
-public interface net.corda.core.node.ServicesForResolution
+public interface net.corda.core.node.ServicesForResolution extends net.corda.core.node.StateLoader
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.AttachmentStorage getAttachments()
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.cordapp.CordappProvider getCordappProvider()
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.services.IdentityService getIdentityService()
+##
+public interface net.corda.core.node.StateLoader
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.contracts.TransactionState loadState(net.corda.core.contracts.StateRef)
 ##
 public interface net.corda.core.node.services.AttachmentStorage

From a633f8dada3b996a3874153a130de4e1dad13882 Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 14:35:27 +0100
Subject: [PATCH 120/185] Reformat files in `core`

---
 .../corda/core/concurrent/ConcurrencyUtils.kt |  1 +
 .../kotlin/net/corda/core/contracts/Amount.kt |  2 +-
 .../net/corda/core/contracts/ContractsDSL.kt  |  4 +-
 .../net/corda/core/contracts/TimeWindow.kt    |  1 +
 .../core/crypto/CordaSecurityProvider.kt      |  6 +-
 .../kotlin/net/corda/core/crypto/Crypto.kt    |  4 +-
 .../net/corda/core/crypto/CryptoUtils.kt      |  7 +-
 .../net/corda/core/crypto/DigitalSignature.kt |  2 +
 .../net/corda/core/crypto/SecureHash.kt       | 15 +++-
 .../corda/core/crypto/TransactionSignature.kt |  2 +-
 .../flows/AbstractStateReplacementFlow.kt     |  3 +-
 .../corda/core/flows/CollectSignaturesFlow.kt | 12 +--
 .../corda/core/flows/ContractUpgradeFlow.kt   |  4 +-
 .../net/corda/core/flows/FinalityFlow.kt      |  4 +-
 .../net/corda/core/flows/FlowInitiator.kt     |  4 +
 .../net/corda/core/flows/FlowSession.kt       |  2 +
 .../kotlin/net/corda/core/flows/NotaryFlow.kt |  2 +-
 .../core/flows/ReceiveTransactionFlow.kt      |  2 +-
 .../net/corda/core/identity/AbstractParty.kt  |  1 +
 .../net/corda/core/identity/CordaX500Name.kt  |  4 +-
 .../kotlin/net/corda/core/identity/Party.kt   |  1 +
 .../core/identity/PartyAndCertificate.kt      |  7 +-
 .../kotlin/net/corda/core/internal/Emoji.kt   | 48 ++++++++----
 .../net/corda/core/internal/InternalUtils.kt  |  7 +-
 .../net/corda/core/internal/LazyPool.kt       |  1 +
 .../net/corda/core/internal/LazyStickyPool.kt |  1 +
 .../core/internal/ResolveTransactionsFlow.kt  |  1 +
 .../corda/core/internal/WriteOnceProperty.kt  |  2 +-
 .../corda/core/internal/X509EdDSAEngine.kt    |  1 +
 .../net/corda/core/messaging/CordaRPCOps.kt   |  9 ++-
 .../net/corda/core/messaging/FlowHandle.kt    |  2 +-
 .../kotlin/net/corda/core/node/NodeInfo.kt    |  7 +-
 .../net/corda/core/node/services/PartyInfo.kt |  5 +-
 .../corda/core/node/services/VaultService.kt  |  2 +-
 .../core/node/services/vault/QueryCriteria.kt | 58 +++++++--------
 .../node/services/vault/QueryCriteriaUtils.kt | 74 +++++++++++++------
 .../net/corda/core/schemas/CommonSchema.kt    |  6 +-
 .../net/corda/core/schemas/NodeInfoSchema.kt  |  9 ++-
 .../net/corda/core/schemas/PersistentTypes.kt |  3 +-
 .../core/serialization/SerializationAPI.kt    |  1 +
 .../core/transactions/LedgerTransaction.kt    |  5 +-
 .../core/transactions/MerkleTransaction.kt    | 14 ++--
 .../MissingContractAttachments.kt             |  2 +-
 .../core/transactions/SignedTransaction.kt    |  3 +-
 .../core/transactions/TransactionBuilder.kt   |  5 +-
 .../core/transactions/WireTransaction.kt      | 23 +++---
 .../net/corda/core/utilities/ByteArrays.kt    |  1 +
 .../net/corda/core/utilities/EncodingUtils.kt |  1 +
 .../core/utilities/NetworkHostAndPort.kt      |  2 +-
 .../net/corda/core/utilities/NonEmptySet.kt   |  2 +
 .../contracts/CompatibleTransactionTests.kt   | 12 +--
 .../core/crypto/X509NameConstraintsTest.kt    |  2 +-
 .../core/flows/ContractUpgradeFlowTest.kt     |  8 +-
 .../core/internal/X509EdDSAEngineTest.kt      | 10 +--
 .../AttachmentSerializationTest.kt            |  1 +
 55 files changed, 262 insertions(+), 156 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/concurrent/ConcurrencyUtils.kt b/core/src/main/kotlin/net/corda/core/concurrent/ConcurrencyUtils.kt
index dedc468904..f86ca21fce 100644
--- a/core/src/main/kotlin/net/corda/core/concurrent/ConcurrencyUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/concurrent/ConcurrencyUtils.kt
@@ -1,4 +1,5 @@
 @file:JvmName("ConcurrencyUtils")
+
 package net.corda.core.concurrent
 
 import net.corda.core.internal.concurrent.openFuture
diff --git a/core/src/main/kotlin/net/corda/core/contracts/Amount.kt b/core/src/main/kotlin/net/corda/core/contracts/Amount.kt
index 64849d3430..629461a3d7 100644
--- a/core/src/main/kotlin/net/corda/core/contracts/Amount.kt
+++ b/core/src/main/kotlin/net/corda/core/contracts/Amount.kt
@@ -167,7 +167,7 @@ data class Amount<T : Any>(val quantity: Long, val displayTokenSize: BigDecimal,
                         }
                     }
                 }
-            } catch(e: Exception) {
+            } catch (e: Exception) {
                 throw IllegalArgumentException("Could not parse $input as a currency", e)
             }
             throw IllegalArgumentException("Did not recognise the currency in $input or could not parse")
diff --git a/core/src/main/kotlin/net/corda/core/contracts/ContractsDSL.kt b/core/src/main/kotlin/net/corda/core/contracts/ContractsDSL.kt
index d43ae5c001..82a1d348a0 100644
--- a/core/src/main/kotlin/net/corda/core/contracts/ContractsDSL.kt
+++ b/core/src/main/kotlin/net/corda/core/contracts/ContractsDSL.kt
@@ -34,7 +34,7 @@ inline fun <R> requireThat(body: Requirements.() -> R) = Requirements.body()
 
 /** Filters the command list by type, party and public key all at once. */
 inline fun <reified T : CommandData> Collection<CommandWithParties<CommandData>>.select(signer: PublicKey? = null,
-                                                                                         party: AbstractParty? = null) =
+                                                                                        party: AbstractParty? = null) =
         filter { it.value is T }.
                 filter { if (signer == null) true else signer in it.signers }.
                 filter { if (party == null) true else party in it.signingParties }.
@@ -44,7 +44,7 @@ inline fun <reified T : CommandData> Collection<CommandWithParties<CommandData>>
 
 /** Filters the command list by type, parties and public keys all at once. */
 inline fun <reified T : CommandData> Collection<CommandWithParties<CommandData>>.select(signers: Collection<PublicKey>?,
-                                                                                         parties: Collection<Party>?) =
+                                                                                        parties: Collection<Party>?) =
         filter { it.value is T }.
                 filter { if (signers == null) true else it.signers.containsAll(signers) }.
                 filter { if (parties == null) true else it.signingParties.containsAll(parties) }.
diff --git a/core/src/main/kotlin/net/corda/core/contracts/TimeWindow.kt b/core/src/main/kotlin/net/corda/core/contracts/TimeWindow.kt
index e26ea50cd0..c8c650257d 100644
--- a/core/src/main/kotlin/net/corda/core/contracts/TimeWindow.kt
+++ b/core/src/main/kotlin/net/corda/core/contracts/TimeWindow.kt
@@ -85,6 +85,7 @@ abstract class TimeWindow {
         init {
             require(fromTime < untilTime) { "fromTime must be earlier than untilTime" }
         }
+
         override val midpoint: Instant get() = fromTime + (fromTime until untilTime) / 2
         override fun contains(instant: Instant): Boolean = instant >= fromTime && instant < untilTime
         override fun toString(): String = "[$fromTime, $untilTime)"
diff --git a/core/src/main/kotlin/net/corda/core/crypto/CordaSecurityProvider.kt b/core/src/main/kotlin/net/corda/core/crypto/CordaSecurityProvider.kt
index eaae5e2ffb..b9bdd52afb 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/CordaSecurityProvider.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/CordaSecurityProvider.kt
@@ -31,6 +31,8 @@ class CordaSecurityProvider : Provider(PROVIDER_NAME, 0.1, "$PROVIDER_NAME secur
 object CordaObjectIdentifier {
     // UUID-based OID
     // TODO: Register for an OID space and issue our own shorter OID.
-    @JvmField val COMPOSITE_KEY = ASN1ObjectIdentifier("2.25.30086077608615255153862931087626791002")
-    @JvmField val COMPOSITE_SIGNATURE = ASN1ObjectIdentifier("2.25.30086077608615255153862931087626791003")
+    @JvmField
+    val COMPOSITE_KEY = ASN1ObjectIdentifier("2.25.30086077608615255153862931087626791002")
+    @JvmField
+    val COMPOSITE_SIGNATURE = ASN1ObjectIdentifier("2.25.30086077608615255153862931087626791003")
 }
diff --git a/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt b/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt
index b6df5e2bc9..58b68bb176 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt
@@ -774,9 +774,10 @@ object Crypto {
         // it forms, by itself, the new private key, which in turn is used to compute the new public key.
         val pointQ = FixedPointCombMultiplier().multiply(parameterSpec.g, deterministicD)
         // This is unlikely to happen, but we should check for point at infinity.
-        if (pointQ.isInfinity)
+        if (pointQ.isInfinity) {
             // Instead of throwing an exception, we retry with SHA256(seed).
             return deriveKeyPairECDSA(parameterSpec, privateKey, seed.sha256().bytes)
+        }
         val publicKeySpec = ECPublicKeySpec(pointQ, parameterSpec)
         val publicKeyD = BCECPublicKey(privateKey.algorithm, publicKeySpec, BouncyCastleProvider.CONFIGURATION)
 
@@ -849,6 +850,7 @@ object Crypto {
         override fun generatePublic(keyInfo: SubjectPublicKeyInfo?): PublicKey? {
             return keyInfo?.let { decodePublicKey(signatureScheme, it.encoded) }
         }
+
         override fun generatePrivate(keyInfo: PrivateKeyInfo?): PrivateKey? {
             return keyInfo?.let { decodePrivateKey(signatureScheme, it.encoded) }
         }
diff --git a/core/src/main/kotlin/net/corda/core/crypto/CryptoUtils.kt b/core/src/main/kotlin/net/corda/core/crypto/CryptoUtils.kt
index 2dffd5afda..32b14cffcd 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/CryptoUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/CryptoUtils.kt
@@ -35,6 +35,7 @@ fun PrivateKey.sign(bytesToSign: ByteArray, publicKey: PublicKey) = DigitalSigna
  */
 @Throws(IllegalArgumentException::class, InvalidKeyException::class, SignatureException::class)
 fun KeyPair.sign(bytesToSign: ByteArray) = private.sign(bytesToSign, public)
+
 fun KeyPair.sign(bytesToSign: OpaqueBytes) = sign(bytesToSign.bytes)
 /**
  * Helper function for signing a [SignableData] object.
@@ -72,18 +73,18 @@ fun PublicKey.verify(content: ByteArray, signature: DigitalSignature) = Crypto.d
  * @return whether the signature is correct for this key.
  */
 @Throws(IllegalStateException::class, SignatureException::class, IllegalArgumentException::class)
-fun PublicKey.isValid(content: ByteArray, signature: DigitalSignature) : Boolean {
+fun PublicKey.isValid(content: ByteArray, signature: DigitalSignature): Boolean {
     if (this is CompositeKey)
         throw IllegalStateException("Verification of CompositeKey signatures currently not supported.") // TODO CompositeSignature verification.
     return Crypto.isValid(this, signature.bytes, content)
 }
 
 /** Render a public key to its hash (in Base58) of its serialised form using the DL prefix. */
-fun PublicKey.toStringShort(): String  = "DL" + this.toSHA256Bytes().toBase58()
+fun PublicKey.toStringShort(): String = "DL" + this.toSHA256Bytes().toBase58()
 
 val PublicKey.keys: Set<PublicKey> get() = (this as? CompositeKey)?.leafKeys ?: setOf(this)
 
-fun PublicKey.isFulfilledBy(otherKey: PublicKey): Boolean  = isFulfilledBy(setOf(otherKey))
+fun PublicKey.isFulfilledBy(otherKey: PublicKey): Boolean = isFulfilledBy(setOf(otherKey))
 fun PublicKey.isFulfilledBy(otherKeys: Iterable<PublicKey>): Boolean = (this as? CompositeKey)?.isFulfilledBy(otherKeys) ?: (this in otherKeys)
 
 /** Checks whether any of the given [keys] matches a leaf on the [CompositeKey] tree or a single [PublicKey]. */
diff --git a/core/src/main/kotlin/net/corda/core/crypto/DigitalSignature.kt b/core/src/main/kotlin/net/corda/core/crypto/DigitalSignature.kt
index 9e28be8a3a..d343913712 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/DigitalSignature.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/DigitalSignature.kt
@@ -23,6 +23,7 @@ open class DigitalSignature(bytes: ByteArray) : OpaqueBytes(bytes) {
          */
         @Throws(InvalidKeyException::class, SignatureException::class)
         fun verify(content: ByteArray) = by.verify(content, this)
+
         /**
          * Utility to simplify the act of verifying a signature.
          *
@@ -32,6 +33,7 @@ open class DigitalSignature(bytes: ByteArray) : OpaqueBytes(bytes) {
          */
         @Throws(InvalidKeyException::class, SignatureException::class)
         fun verify(content: OpaqueBytes) = by.verify(content.bytes, this)
+
         /**
          * Utility to simplify the act of verifying a signature. In comparison to [verify] doesn't throw an
          * exception, making it more suitable where a boolean is required, but normally you should use the function
diff --git a/core/src/main/kotlin/net/corda/core/crypto/SecureHash.kt b/core/src/main/kotlin/net/corda/core/crypto/SecureHash.kt
index f0773a7bac..16bf533550 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/SecureHash.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/SecureHash.kt
@@ -34,11 +34,18 @@ sealed class SecureHash(bytes: ByteArray) : OpaqueBytes(bytes) {
             }
         }
 
-        @JvmStatic fun sha256(bytes: ByteArray) = SHA256(MessageDigest.getInstance("SHA-256").digest(bytes))
-        @JvmStatic fun sha256Twice(bytes: ByteArray) = sha256(sha256(bytes).bytes)
-        @JvmStatic fun sha256(str: String) = sha256(str.toByteArray())
+        @JvmStatic
+        fun sha256(bytes: ByteArray) = SHA256(MessageDigest.getInstance("SHA-256").digest(bytes))
+
+        @JvmStatic
+        fun sha256Twice(bytes: ByteArray) = sha256(sha256(bytes).bytes)
+
+        @JvmStatic
+        fun sha256(str: String) = sha256(str.toByteArray())
+
+        @JvmStatic
+        fun randomSHA256() = sha256(newSecureRandom().generateSeed(32))
 
-        @JvmStatic fun randomSHA256() = sha256(newSecureRandom().generateSeed(32))
         val zeroHash = SecureHash.SHA256(ByteArray(32, { 0.toByte() }))
         val allOnesHash = SecureHash.SHA256(ByteArray(32, { 255.toByte() }))
     }
diff --git a/core/src/main/kotlin/net/corda/core/crypto/TransactionSignature.kt b/core/src/main/kotlin/net/corda/core/crypto/TransactionSignature.kt
index 28e843a82d..4f5f7eb207 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/TransactionSignature.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/TransactionSignature.kt
@@ -11,7 +11,7 @@ import java.util.*
  * This is similar to [DigitalSignature.WithKey], but targeted to DLT transaction signatures.
  */
 @CordaSerializable
-class TransactionSignature(bytes: ByteArray, val by: PublicKey, val signatureMetadata: SignatureMetadata): DigitalSignature(bytes) {
+class TransactionSignature(bytes: ByteArray, val by: PublicKey, val signatureMetadata: SignatureMetadata) : DigitalSignature(bytes) {
     /**
      * Function to verify a [SignableData] object's signature.
      * Note that [SignableData] contains the id of the transaction and extra metadata, such as DLT's platform version.
diff --git a/core/src/main/kotlin/net/corda/core/flows/AbstractStateReplacementFlow.kt b/core/src/main/kotlin/net/corda/core/flows/AbstractStateReplacementFlow.kt
index bcc712df71..82a960cfc7 100644
--- a/core/src/main/kotlin/net/corda/core/flows/AbstractStateReplacementFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/AbstractStateReplacementFlow.kt
@@ -136,7 +136,8 @@ abstract class AbstractStateReplacementFlow {
     // We use Void? instead of Unit? as that's what you'd use in Java.
     abstract class Acceptor<in T>(val initiatingSession: FlowSession,
                                   override val progressTracker: ProgressTracker = Acceptor.tracker()) : FlowLogic<Void?>() {
-            constructor(initiatingSession: FlowSession) : this(initiatingSession, Acceptor.tracker())
+        constructor(initiatingSession: FlowSession) : this(initiatingSession, Acceptor.tracker())
+
         companion object {
             object VERIFYING : ProgressTracker.Step("Verifying state replacement proposal")
             object APPROVING : ProgressTracker.Step("State replacement approved")
diff --git a/core/src/main/kotlin/net/corda/core/flows/CollectSignaturesFlow.kt b/core/src/main/kotlin/net/corda/core/flows/CollectSignaturesFlow.kt
index cfb232a7ec..8dfe4a69ff 100644
--- a/core/src/main/kotlin/net/corda/core/flows/CollectSignaturesFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/CollectSignaturesFlow.kt
@@ -61,11 +61,12 @@ import java.security.PublicKey
  * just in the states. If null, the default well known identity of the node is used.
  */
 // TODO: AbstractStateReplacementFlow needs updating to use this flow.
-class CollectSignaturesFlow @JvmOverloads constructor (val partiallySignedTx: SignedTransaction,
-                                                       val sessionsToCollectFrom: Collection<FlowSession>,
-                                                       val myOptionalKeys: Iterable<PublicKey>?,
-                                                       override val progressTracker: ProgressTracker = CollectSignaturesFlow.tracker()) : FlowLogic<SignedTransaction>() {
+class CollectSignaturesFlow @JvmOverloads constructor(val partiallySignedTx: SignedTransaction,
+                                                      val sessionsToCollectFrom: Collection<FlowSession>,
+                                                      val myOptionalKeys: Iterable<PublicKey>?,
+                                                      override val progressTracker: ProgressTracker = CollectSignaturesFlow.tracker()) : FlowLogic<SignedTransaction>() {
     @JvmOverloads constructor(partiallySignedTx: SignedTransaction, sessionsToCollectFrom: Collection<FlowSession>, progressTracker: ProgressTracker = CollectSignaturesFlow.tracker()) : this(partiallySignedTx, sessionsToCollectFrom, null, progressTracker)
+
     companion object {
         object COLLECTING : ProgressTracker.Step("Collecting signatures from counter-parties.")
         object VERIFYING : ProgressTracker.Step("Verifying collected signatures.")
@@ -134,6 +135,7 @@ class CollectSignaturesFlow @JvmOverloads constructor (val partiallySignedTx: Si
 class CollectSignatureFlow(val partiallySignedTx: SignedTransaction, val session: FlowSession, val signingKeys: List<PublicKey>) : FlowLogic<List<TransactionSignature>>() {
     constructor(partiallySignedTx: SignedTransaction, session: FlowSession, vararg signingKeys: PublicKey) :
             this(partiallySignedTx, session, listOf(*signingKeys))
+
     @Suspendable
     override fun call(): List<TransactionSignature> {
         // SendTransactionFlow allows counterparty to access our data to resolve the transaction.
@@ -224,7 +226,7 @@ abstract class SignTransactionFlow(val otherSideSession: FlowSession,
         // Perform some custom verification over the transaction.
         try {
             checkTransaction(stx)
-        } catch(e: Exception) {
+        } catch (e: Exception) {
             if (e is IllegalStateException || e is IllegalArgumentException || e is AssertionError)
                 throw FlowException(e)
             else
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 d1217909da..423b6c1fa6 100644
--- a/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt
@@ -28,7 +28,7 @@ object ContractUpgradeFlow {
             val stateAndRef: StateAndRef<*>,
             private val upgradedContractClass: Class<out UpgradedContract<*, *>>
     ) : FlowLogic<Void?>() {
-    // DOCEND 1
+        // DOCEND 1
         @Suspendable
         override fun call(): Void? {
             val upgrade = upgradedContractClass.newInstance()
@@ -50,7 +50,7 @@ object ContractUpgradeFlow {
     class Deauthorise(val stateRef: StateRef) : FlowLogic<Void?>() {
         @Suspendable
         override fun call(): Void? {
-    //DOCEND 2
+            //DOCEND 2
             serviceHub.contractUpgradeService.removeAuthorisedContractUpgrade(stateRef)
             return null
         }
diff --git a/core/src/main/kotlin/net/corda/core/flows/FinalityFlow.kt b/core/src/main/kotlin/net/corda/core/flows/FinalityFlow.kt
index 7b45eb6a73..e2aafc165c 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FinalityFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FinalityFlow.kt
@@ -26,8 +26,8 @@ import net.corda.core.utilities.ProgressTracker
  */
 @InitiatingFlow
 class FinalityFlow(val transaction: SignedTransaction,
-                        private val extraRecipients: Set<Party>,
-                        override val progressTracker: ProgressTracker) : FlowLogic<SignedTransaction>() {
+                   private val extraRecipients: Set<Party>,
+                   override val progressTracker: ProgressTracker) : FlowLogic<SignedTransaction>() {
     constructor(transaction: SignedTransaction, extraParticipants: Set<Party>) : this(transaction, extraParticipants, tracker())
     constructor(transaction: SignedTransaction) : this(transaction, emptySet(), tracker())
     constructor(transaction: SignedTransaction, progressTracker: ProgressTracker) : this(transaction, emptySet(), progressTracker)
diff --git a/core/src/main/kotlin/net/corda/core/flows/FlowInitiator.kt b/core/src/main/kotlin/net/corda/core/flows/FlowInitiator.kt
index 549af46dcf..6bc488c162 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FlowInitiator.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FlowInitiator.kt
@@ -16,18 +16,22 @@ sealed class FlowInitiator : Principal {
     data class RPC(val username: String) : FlowInitiator() {
         override fun getName(): String = username
     }
+
     /** Started when we get new session initiation request. */
     data class Peer(val party: Party) : FlowInitiator() {
         override fun getName(): String = party.name.toString()
     }
+
     /** Started by a CordaService. */
     data class Service(val serviceClassName: String) : FlowInitiator() {
         override fun getName(): String = serviceClassName
     }
+
     /** Started as scheduled activity. */
     data class Scheduled(val scheduledState: ScheduledStateRef) : FlowInitiator() {
         override fun getName(): String = "Scheduler"
     }
+
     // TODO When proper ssh access enabled, add username/use RPC?
     object Shell : FlowInitiator() {
         override fun getName(): String = "Shell User"
diff --git a/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt b/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
index 07e4b49d33..f5589f96c4 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FlowSession.kt
@@ -75,6 +75,7 @@ abstract class FlowSession {
     inline fun <reified R : Any> sendAndReceive(payload: Any): UntrustworthyData<R> {
         return sendAndReceive(R::class.java, payload)
     }
+
     /**
      * Serializes and queues the given [payload] object for sending to the [counterparty]. Suspends until a response
      * is received, which must be of the given [receiveType]. Remember that when receiving data from other parties the data
@@ -100,6 +101,7 @@ abstract class FlowSession {
     inline fun <reified R : Any> receive(): UntrustworthyData<R> {
         return receive(R::class.java)
     }
+
     /**
      * Suspends until [counterparty] sends us a message of type [receiveType].
      *
diff --git a/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt b/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt
index c4d122c649..c59986c61b 100644
--- a/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt
@@ -173,5 +173,5 @@ sealed class NotaryError {
         override fun toString() = cause.toString()
     }
 
-    object WrongNotary: NotaryError()
+    object WrongNotary : NotaryError()
 }
diff --git a/core/src/main/kotlin/net/corda/core/flows/ReceiveTransactionFlow.kt b/core/src/main/kotlin/net/corda/core/flows/ReceiveTransactionFlow.kt
index 35f17c64ea..2e686e8746 100644
--- a/core/src/main/kotlin/net/corda/core/flows/ReceiveTransactionFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/ReceiveTransactionFlow.kt
@@ -13,7 +13,7 @@ import java.security.SignatureException
  * This flow is a combination of [FlowSession.receive], resolve and [SignedTransaction.verify]. This flow will receive the
  * [SignedTransaction] and perform the resolution back-and-forth required to check the dependencies and download any missing
  * attachments. The flow will return the [SignedTransaction] after it is resolved and then verified using [SignedTransaction.verify].
- * 
+ *
  * @param otherSideSession session to the other side which is calling [SendTransactionFlow].
  * @param checkSufficientSignatures if true checks all required signatures are present. See [SignedTransaction.verify].
  */
diff --git a/core/src/main/kotlin/net/corda/core/identity/AbstractParty.kt b/core/src/main/kotlin/net/corda/core/identity/AbstractParty.kt
index 6f6f1a8109..8f03ed640b 100644
--- a/core/src/main/kotlin/net/corda/core/identity/AbstractParty.kt
+++ b/core/src/main/kotlin/net/corda/core/identity/AbstractParty.kt
@@ -13,6 +13,7 @@ import java.security.PublicKey
 abstract class AbstractParty(val owningKey: PublicKey) {
     /** Anonymised parties do not include any detail apart from owning key, so equality is dependent solely on the key */
     override fun equals(other: Any?): Boolean = other === this || other is AbstractParty && other.owningKey == owningKey
+
     override fun hashCode(): Int = owningKey.hashCode()
     abstract fun nameOrNull(): CordaX500Name?
 
diff --git a/core/src/main/kotlin/net/corda/core/identity/CordaX500Name.kt b/core/src/main/kotlin/net/corda/core/identity/CordaX500Name.kt
index a563ebb1ca..37e872d562 100644
--- a/core/src/main/kotlin/net/corda/core/identity/CordaX500Name.kt
+++ b/core/src/main/kotlin/net/corda/core/identity/CordaX500Name.kt
@@ -81,7 +81,7 @@ data class CordaX500Name(val commonName: String?,
         private val countryCodes: Set<String> = ImmutableSet.copyOf(Locale.getISOCountries())
 
         @JvmStatic
-        fun build(principal: X500Principal) : CordaX500Name {
+        fun build(principal: X500Principal): CordaX500Name {
             val x500Name = X500Name.getInstance(principal.encoded)
             val attrsMap: Map<ASN1ObjectIdentifier, ASN1Encodable> = x500Name.rdNs
                     .flatMap { it.typesAndValues.asList() }
@@ -109,7 +109,7 @@ data class CordaX500Name(val commonName: String?,
         }
 
         @JvmStatic
-        fun parse(name: String) : CordaX500Name = build(X500Principal(name))
+        fun parse(name: String): CordaX500Name = build(X500Principal(name))
     }
 
     @Transient
diff --git a/core/src/main/kotlin/net/corda/core/identity/Party.kt b/core/src/main/kotlin/net/corda/core/identity/Party.kt
index 78f36ca543..9316391ae7 100644
--- a/core/src/main/kotlin/net/corda/core/identity/Party.kt
+++ b/core/src/main/kotlin/net/corda/core/identity/Party.kt
@@ -29,6 +29,7 @@ import java.security.cert.X509Certificate
 class Party(val name: CordaX500Name, owningKey: PublicKey) : AbstractParty(owningKey) {
     constructor(certificate: X509Certificate)
             : this(CordaX500Name.build(certificate.subjectX500Principal), Crypto.toSupportedPublicKey(certificate.publicKey))
+
     override fun nameOrNull(): CordaX500Name = name
     fun anonymise(): AnonymousParty = AnonymousParty(owningKey)
     override fun ref(bytes: OpaqueBytes): PartyAndReference = PartyAndReference(this, bytes)
diff --git a/core/src/main/kotlin/net/corda/core/identity/PartyAndCertificate.kt b/core/src/main/kotlin/net/corda/core/identity/PartyAndCertificate.kt
index f158138b84..12661d2881 100644
--- a/core/src/main/kotlin/net/corda/core/identity/PartyAndCertificate.kt
+++ b/core/src/main/kotlin/net/corda/core/identity/PartyAndCertificate.kt
@@ -11,7 +11,9 @@ import java.security.cert.*
  */
 @CordaSerializable
 class PartyAndCertificate(val certPath: CertPath) {
-    @Transient val certificate: X509Certificate
+    @Transient
+    val certificate: X509Certificate
+
     init {
         require(certPath.type == "X.509") { "Only X.509 certificates supported" }
         val certs = certPath.certificates
@@ -19,7 +21,8 @@ class PartyAndCertificate(val certPath: CertPath) {
         certificate = certs[0] as X509Certificate
     }
 
-    @Transient val party: Party = Party(certificate)
+    @Transient
+    val party: Party = Party(certificate)
 
     val owningKey: PublicKey get() = party.owningKey
     val name: CordaX500Name get() = party.name
diff --git a/core/src/main/kotlin/net/corda/core/internal/Emoji.kt b/core/src/main/kotlin/net/corda/core/internal/Emoji.kt
index 7c7e5202f5..eb057cfe30 100644
--- a/core/src/main/kotlin/net/corda/core/internal/Emoji.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/Emoji.kt
@@ -13,22 +13,38 @@ object Emoji {
                 (System.getenv("TERM_PROGRAM") == "JediTerm" && System.getProperty("java.vendor") == "JetBrains s.r.o")
     }
 
-    @JvmStatic val CODE_SANTA_CLAUS: String = codePointsString(0x1F385)
-    @JvmStatic val CODE_DIAMOND: String = codePointsString(0x1F537)
-    @JvmStatic val CODE_BAG_OF_CASH: String = codePointsString(0x1F4B0)
-    @JvmStatic val CODE_NEWSPAPER: String = codePointsString(0x1F4F0)
-    @JvmStatic val CODE_RIGHT_ARROW: String = codePointsString(0x27A1, 0xFE0F)
-    @JvmStatic val CODE_LEFT_ARROW: String = codePointsString(0x2B05, 0xFE0F)
-    @JvmStatic val CODE_GREEN_TICK: String = codePointsString(0x2705)
-    @JvmStatic val CODE_PAPERCLIP: String = codePointsString(0x1F4CE)
-    @JvmStatic val CODE_COOL_GUY: String = codePointsString(0x1F60E)
-    @JvmStatic val CODE_NO_ENTRY: String = codePointsString(0x1F6AB)
-    @JvmStatic val CODE_SKULL_AND_CROSSBONES: String = codePointsString(0x2620)
-    @JvmStatic val CODE_BOOKS: String = codePointsString(0x1F4DA)
-    @JvmStatic val CODE_SLEEPING_FACE: String = codePointsString(0x1F634)
-    @JvmStatic val CODE_LIGHTBULB: String = codePointsString(0x1F4A1)
-    @JvmStatic val CODE_FREE: String = codePointsString(0x1F193)
-    @JvmStatic val CODE_SOON: String = codePointsString(0x1F51C)
+    @JvmStatic
+    val CODE_SANTA_CLAUS: String = codePointsString(0x1F385)
+    @JvmStatic
+    val CODE_DIAMOND: String = codePointsString(0x1F537)
+    @JvmStatic
+    val CODE_BAG_OF_CASH: String = codePointsString(0x1F4B0)
+    @JvmStatic
+    val CODE_NEWSPAPER: String = codePointsString(0x1F4F0)
+    @JvmStatic
+    val CODE_RIGHT_ARROW: String = codePointsString(0x27A1, 0xFE0F)
+    @JvmStatic
+    val CODE_LEFT_ARROW: String = codePointsString(0x2B05, 0xFE0F)
+    @JvmStatic
+    val CODE_GREEN_TICK: String = codePointsString(0x2705)
+    @JvmStatic
+    val CODE_PAPERCLIP: String = codePointsString(0x1F4CE)
+    @JvmStatic
+    val CODE_COOL_GUY: String = codePointsString(0x1F60E)
+    @JvmStatic
+    val CODE_NO_ENTRY: String = codePointsString(0x1F6AB)
+    @JvmStatic
+    val CODE_SKULL_AND_CROSSBONES: String = codePointsString(0x2620)
+    @JvmStatic
+    val CODE_BOOKS: String = codePointsString(0x1F4DA)
+    @JvmStatic
+    val CODE_SLEEPING_FACE: String = codePointsString(0x1F634)
+    @JvmStatic
+    val CODE_LIGHTBULB: String = codePointsString(0x1F4A1)
+    @JvmStatic
+    val CODE_FREE: String = codePointsString(0x1F193)
+    @JvmStatic
+    val CODE_SOON: String = codePointsString(0x1F51C)
 
 
     /**
diff --git a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
index ccc6cee84c..3996dee1de 100644
--- a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
@@ -49,6 +49,7 @@ operator fun Duration.times(multiplicand: Long): Duration = multipliedBy(multipl
  * separator problems.
  */
 operator fun Path.div(other: String): Path = resolve(other)
+
 operator fun String.div(other: String): Path = Paths.get(this) / other
 
 /**
@@ -104,6 +105,7 @@ fun Path.copyToDirectory(targetDir: Path, vararg options: CopyOption): Path {
     Files.copy(this, targetFile, *options)
     return targetFile
 }
+
 fun Path.moveTo(target: Path, vararg options: CopyOption): Path = Files.move(this, target, *options)
 fun Path.isRegularFile(vararg options: LinkOption): Boolean = Files.isRegularFile(this, *options)
 fun Path.isDirectory(vararg options: LinkOption): Boolean = Files.isDirectory(this, *options)
@@ -238,10 +240,13 @@ fun <T> Class<T>.castIfPossible(obj: Any): T? = if (isInstance(obj)) cast(obj) e
 
 /** Returns a [DeclaredField] wrapper around the declared (possibly non-public) static field of the receiver [Class]. */
 fun <T> Class<*>.staticField(name: String): DeclaredField<T> = DeclaredField(this, name, null)
+
 /** Returns a [DeclaredField] wrapper around the declared (possibly non-public) static field of the receiver [KClass]. */
 fun <T> KClass<*>.staticField(name: String): DeclaredField<T> = DeclaredField(java, name, null)
+
 /** @suppress Returns a [DeclaredField] wrapper around the declared (possibly non-public) instance field of the receiver object. */
 fun <T> Any.declaredField(name: String): DeclaredField<T> = DeclaredField(javaClass, name, this)
+
 /**
  * Returns a [DeclaredField] wrapper around the (possibly non-public) instance field of the receiver object, but declared
  * in its superclass [clazz].
@@ -250,7 +255,7 @@ fun <T> Any.declaredField(name: String): DeclaredField<T> = DeclaredField(javaCl
 fun <T> Any.declaredField(clazz: KClass<*>, name: String): DeclaredField<T> = DeclaredField(clazz.java, name, this)
 
 /** creates a new instance if not a Kotlin object */
-fun <T: Any> KClass<T>.objectOrNewInstance(): T {
+fun <T : Any> KClass<T>.objectOrNewInstance(): T {
     return this.objectInstance ?: this.createInstance()
 }
 
diff --git a/core/src/main/kotlin/net/corda/core/internal/LazyPool.kt b/core/src/main/kotlin/net/corda/core/internal/LazyPool.kt
index 3e4e3a526d..edbb545d20 100644
--- a/core/src/main/kotlin/net/corda/core/internal/LazyPool.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/LazyPool.kt
@@ -27,6 +27,7 @@ class LazyPool<A>(
         STARTED,
         FINISHED
     }
+
     private val lifeCycle = LifeCycle(State.STARTED)
 
     private fun clearIfNeeded(instance: A): A {
diff --git a/core/src/main/kotlin/net/corda/core/internal/LazyStickyPool.kt b/core/src/main/kotlin/net/corda/core/internal/LazyStickyPool.kt
index 6746989291..5974f97f8e 100644
--- a/core/src/main/kotlin/net/corda/core/internal/LazyStickyPool.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/LazyStickyPool.kt
@@ -18,6 +18,7 @@ class LazyStickyPool<A : Any>(
     private class InstanceBox<A> {
         var instance: LinkedBlockingQueue<A>? = null
     }
+
     private val random = Random()
     private val boxes = Array(size) { InstanceBox<A>() }
 
diff --git a/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt b/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt
index c38368aaf6..e0fec0f7ac 100644
--- a/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/ResolveTransactionsFlow.kt
@@ -28,6 +28,7 @@ class ResolveTransactionsFlow(private val txHashes: Set<SecureHash>,
     constructor(signedTransaction: SignedTransaction, otherSide: FlowSession) : this(dependencyIDs(signedTransaction), otherSide) {
         this.signedTransaction = signedTransaction
     }
+
     companion object {
         private fun dependencyIDs(stx: SignedTransaction) = stx.inputs.map { it.txhash }.toSet()
 
diff --git a/core/src/main/kotlin/net/corda/core/internal/WriteOnceProperty.kt b/core/src/main/kotlin/net/corda/core/internal/WriteOnceProperty.kt
index ad0ae9bc39..ae815be6ca 100644
--- a/core/src/main/kotlin/net/corda/core/internal/WriteOnceProperty.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/WriteOnceProperty.kt
@@ -6,7 +6,7 @@ import kotlin.reflect.KProperty
  * A write-once property to be used as delegate for Kotlin var properties.  The expectation is that this is initialised
  * prior to the spawning of any threads that may access it and so there's no need for it to be volatile.
  */
-class WriteOnceProperty<T : Any>(private val defaultValue:T? = null) {
+class WriteOnceProperty<T : Any>(private val defaultValue: T? = null) {
     private var v: T? = defaultValue
 
     operator fun getValue(thisRef: Any?, property: KProperty<*>) = v ?: throw IllegalStateException("Write-once property $property not set.")
diff --git a/core/src/main/kotlin/net/corda/core/internal/X509EdDSAEngine.kt b/core/src/main/kotlin/net/corda/core/internal/X509EdDSAEngine.kt
index 0bebc73130..cd5fac1ee1 100644
--- a/core/src/main/kotlin/net/corda/core/internal/X509EdDSAEngine.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/X509EdDSAEngine.kt
@@ -46,6 +46,7 @@ class X509EdDSAEngine : Signature {
     override fun engineSetParameter(params: AlgorithmParameterSpec) = engine.setParameter(params)
     @Suppress("DEPRECATION")
     override fun engineGetParameter(param: String): Any = engine.getParameter(param)
+
     @Suppress("DEPRECATION")
     override fun engineSetParameter(param: String, value: Any?) = engine.setParameter(param, value)
 }
diff --git a/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt b/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
index 9fddfead5d..d29cc7a193 100644
--- a/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
+++ b/core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
@@ -104,12 +104,15 @@ interface CordaRPCOps : RPCOps {
     fun <T : ContractState> vaultQuery(contractStateType: Class<out T>): Vault.Page<T> {
         return vaultQueryBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), contractStateType)
     }
+
     fun <T : ContractState> vaultQueryByCriteria(criteria: QueryCriteria, contractStateType: Class<out T>): Vault.Page<T> {
         return vaultQueryBy(criteria, PageSpecification(), Sort(emptySet()), contractStateType)
     }
+
     fun <T : ContractState> vaultQueryByWithPagingSpec(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification): Vault.Page<T> {
         return vaultQueryBy(criteria, paging, Sort(emptySet()), contractStateType)
     }
+
     fun <T : ContractState> vaultQueryByWithSorting(contractStateType: Class<out T>, criteria: QueryCriteria, sorting: Sort): Vault.Page<T> {
         return vaultQueryBy(criteria, PageSpecification(), sorting, contractStateType)
     }
@@ -142,12 +145,15 @@ interface CordaRPCOps : RPCOps {
     fun <T : ContractState> vaultTrack(contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> {
         return vaultTrackBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), contractStateType)
     }
+
     fun <T : ContractState> vaultTrackByCriteria(contractStateType: Class<out T>, criteria: QueryCriteria): DataFeed<Vault.Page<T>, Vault.Update<T>> {
         return vaultTrackBy(criteria, PageSpecification(), Sort(emptySet()), contractStateType)
     }
+
     fun <T : ContractState> vaultTrackByWithPagingSpec(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification): DataFeed<Vault.Page<T>, Vault.Update<T>> {
         return vaultTrackBy(criteria, paging, Sort(emptySet()), contractStateType)
     }
+
     fun <T : ContractState> vaultTrackByWithSorting(contractStateType: Class<out T>, criteria: QueryCriteria, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> {
         return vaultTrackBy(criteria, PageSpecification(), sorting, contractStateType)
     }
@@ -250,6 +256,7 @@ interface CordaRPCOps : RPCOps {
      * @return well known identity, if found.
      */
     fun wellKnownPartyFromAnonymous(party: AbstractParty): Party?
+
     /** Returns the [Party] corresponding to the given key, if found. */
     fun partyFromKey(key: PublicKey): Party?
 
@@ -310,7 +317,7 @@ inline fun <T, reified R : FlowLogic<T>> CordaRPCOps.startFlow(
         flowConstructor: () -> R
 ): FlowHandle<T> = startFlowDynamic(R::class.java)
 
-inline fun <T , A, reified R : FlowLogic<T>> CordaRPCOps.startFlow(
+inline fun <T, A, reified R : FlowLogic<T>> CordaRPCOps.startFlow(
         @Suppress("UNUSED_PARAMETER")
         flowConstructor: (A) -> R,
         arg0: A
diff --git a/core/src/main/kotlin/net/corda/core/messaging/FlowHandle.kt b/core/src/main/kotlin/net/corda/core/messaging/FlowHandle.kt
index 9cd9776061..166825de0c 100644
--- a/core/src/main/kotlin/net/corda/core/messaging/FlowHandle.kt
+++ b/core/src/main/kotlin/net/corda/core/messaging/FlowHandle.kt
@@ -43,7 +43,7 @@ data class FlowHandleImpl<A>(
         override val id: StateMachineRunId,
         override val returnValue: CordaFuture<A>) : FlowHandle<A> {
 
-     // Remember to add @Throws to FlowHandle.close() if this throws an exception.
+    // Remember to add @Throws to FlowHandle.close() if this throws an exception.
     override fun close() {
         returnValue.cancel(false)
     }
diff --git a/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt b/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
index d5ef1df776..cf3e5aed2e 100644
--- a/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
+++ b/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
@@ -35,9 +35,10 @@ data class NodeInfo(val addresses: List<NetworkHostAndPort>,
      * are porting code from earlier versions of Corda that expected a single party per node, just use the first item
      * in the returned list.
      */
-    val legalIdentities: List<Party> get() {
-        return _legalIdentities ?: legalIdentitiesAndCerts.map { it.party }.also { _legalIdentities = it }
-    }
+    val legalIdentities: List<Party>
+        get() {
+            return _legalIdentities ?: legalIdentitiesAndCerts.map { it.party }.also { _legalIdentities = it }
+        }
 
     /** Returns true if [party] is one of the identities of this node, else false. */
     fun isLegalIdentity(party: Party): Boolean = party in legalIdentities
diff --git a/core/src/main/kotlin/net/corda/core/node/services/PartyInfo.kt b/core/src/main/kotlin/net/corda/core/node/services/PartyInfo.kt
index 2db0543618..998c846c20 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/PartyInfo.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/PartyInfo.kt
@@ -8,6 +8,7 @@ import net.corda.core.utilities.NetworkHostAndPort
  */
 sealed class PartyInfo {
     abstract val party: Party
-    data class SingleNode(override val party: Party, val addresses: List<NetworkHostAndPort>): PartyInfo()
-    data class DistributedNode(override val party: Party): PartyInfo()
+
+    data class SingleNode(override val party: Party, val addresses: List<NetworkHostAndPort>) : PartyInfo()
+    data class DistributedNode(override val party: Party) : PartyInfo()
 }
diff --git a/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt b/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt
index a16243a7db..38545ac754 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/VaultService.kt
@@ -99,7 +99,7 @@ class Vault<out T : ContractState>(val states: Iterable<StateAndRef<T>>) {
 
     companion object {
         val NoUpdate = Update(emptySet(), emptySet(), type = Vault.UpdateType.GENERAL)
-        val NoNotaryUpdate = Vault.Update(emptySet(), emptySet(),  type = Vault.UpdateType.NOTARY_CHANGE)
+        val NoNotaryUpdate = Vault.Update(emptySet(), emptySet(), type = Vault.UpdateType.NOTARY_CHANGE)
     }
 
     @CordaSerializable
diff --git a/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteria.kt b/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteria.kt
index 6f15271057..1e5eeb858f 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteria.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteria.kt
@@ -49,12 +49,12 @@ sealed class QueryCriteria {
     /**
      * VaultQueryCriteria: provides query by attributes defined in [VaultSchema.VaultStates]
      */
-    data class VaultQueryCriteria @JvmOverloads constructor (override val status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED,
-                                                             override val contractStateTypes: Set<Class<out ContractState>>? = null,
-                                                             val stateRefs: List<StateRef>? = null,
-                                                             val notary: List<AbstractParty>? = null,
-                                                             val softLockingCondition: SoftLockingCondition? = null,
-                                                             val timeCondition: TimeCondition? = null) : CommonQueryCriteria() {
+    data class VaultQueryCriteria @JvmOverloads constructor(override val status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED,
+                                                            override val contractStateTypes: Set<Class<out ContractState>>? = null,
+                                                            val stateRefs: List<StateRef>? = null,
+                                                            val notary: List<AbstractParty>? = null,
+                                                            val softLockingCondition: SoftLockingCondition? = null,
+                                                            val timeCondition: TimeCondition? = null) : CommonQueryCriteria() {
         override fun visit(parser: IQueryCriteriaParser): Collection<Predicate> {
             super.visit(parser)
             return parser.parseCriteria(this)
@@ -69,10 +69,10 @@ sealed class QueryCriteria {
                                                                   val externalId: List<String>? = null,
                                                                   override val status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED,
                                                                   override val contractStateTypes: Set<Class<out ContractState>>? = null) : CommonQueryCriteria() {
-            constructor(participants: List<AbstractParty>? = null,
-                        linearId: List<UniqueIdentifier>? = null,
-                        status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED,
-                        contractStateTypes: Set<Class<out ContractState>>? = null) : this(participants, linearId?.map { it.id }, linearId?.mapNotNull { it.externalId }, status, contractStateTypes)
+        constructor(participants: List<AbstractParty>? = null,
+                    linearId: List<UniqueIdentifier>? = null,
+                    status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED,
+                    contractStateTypes: Set<Class<out ContractState>>? = null) : this(participants, linearId?.map { it.id }, linearId?.mapNotNull { it.externalId }, status, contractStateTypes)
 
         override fun visit(parser: IQueryCriteriaParser): Collection<Predicate> {
             super.visit(parser)
@@ -80,13 +80,13 @@ sealed class QueryCriteria {
         }
     }
 
-   /**
-    * FungibleStateQueryCriteria: provides query by attributes defined in [VaultSchema.VaultFungibleState]
-    *
-    * Valid TokenType implementations defined by Amount<T> are
-    *   [Currency] as used in [Cash] contract state
-    *   [Commodity] as used in [CommodityContract] state
-    */
+    /**
+     * FungibleStateQueryCriteria: provides query by attributes defined in [VaultSchema.VaultFungibleState]
+     *
+     * Valid TokenType implementations defined by Amount<T> are
+     *   [Currency] as used in [Cash] contract state
+     *   [Commodity] as used in [CommodityContract] state
+     */
     data class FungibleAssetQueryCriteria @JvmOverloads constructor(val participants: List<AbstractParty>? = null,
                                                                     val owner: List<AbstractParty>? = null,
                                                                     val quantity: ColumnPredicate<Long>? = null,
@@ -94,11 +94,11 @@ sealed class QueryCriteria {
                                                                     val issuerRef: List<OpaqueBytes>? = null,
                                                                     override val status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED,
                                                                     override val contractStateTypes: Set<Class<out ContractState>>? = null) : CommonQueryCriteria() {
-       override fun visit(parser: IQueryCriteriaParser): Collection<Predicate> {
-           super.visit(parser)
-           return parser.parseCriteria(this)
-       }
-   }
+        override fun visit(parser: IQueryCriteriaParser): Collection<Predicate> {
+            super.visit(parser)
+            return parser.parseCriteria(this)
+        }
+    }
 
     /**
      * VaultCustomQueryCriteria: provides query by custom attributes defined in a contracts
@@ -111,9 +111,9 @@ sealed class QueryCriteria {
      * Refer to [CommercialPaper.State] for a concrete example.
      */
     data class VaultCustomQueryCriteria<L : PersistentState> @JvmOverloads constructor
-                                    (val expression: CriteriaExpression<L, Boolean>,
-                                     override val status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED,
-                                     override val contractStateTypes: Set<Class<out ContractState>>? = null) : CommonQueryCriteria() {
+    (val expression: CriteriaExpression<L, Boolean>,
+     override val status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED,
+     override val contractStateTypes: Set<Class<out ContractState>>? = null) : CommonQueryCriteria() {
         override fun visit(parser: IQueryCriteriaParser): Collection<Predicate> {
             super.visit(parser)
             return parser.parseCriteria(this)
@@ -121,13 +121,13 @@ sealed class QueryCriteria {
     }
 
     // enable composition of [QueryCriteria]
-    private data class AndComposition(val a: QueryCriteria, val b: QueryCriteria): QueryCriteria() {
+    private data class AndComposition(val a: QueryCriteria, val b: QueryCriteria) : QueryCriteria() {
         override fun visit(parser: IQueryCriteriaParser): Collection<Predicate> {
             return parser.parseAnd(this.a, this.b)
         }
     }
 
-    private data class OrComposition(val a: QueryCriteria, val b: QueryCriteria): QueryCriteria() {
+    private data class OrComposition(val a: QueryCriteria, val b: QueryCriteria) : QueryCriteria() {
         override fun visit(parser: IQueryCriteriaParser): Collection<Predicate> {
             return parser.parseOr(this.a, this.b)
         }
@@ -148,9 +148,9 @@ interface IQueryCriteriaParser {
     fun parseCriteria(criteria: QueryCriteria.CommonQueryCriteria): Collection<Predicate>
     fun parseCriteria(criteria: QueryCriteria.FungibleAssetQueryCriteria): Collection<Predicate>
     fun parseCriteria(criteria: QueryCriteria.LinearStateQueryCriteria): Collection<Predicate>
-    fun <L: PersistentState> parseCriteria(criteria: QueryCriteria.VaultCustomQueryCriteria<L>): Collection<Predicate>
+    fun <L : PersistentState> parseCriteria(criteria: QueryCriteria.VaultCustomQueryCriteria<L>): Collection<Predicate>
     fun parseCriteria(criteria: QueryCriteria.VaultQueryCriteria): Collection<Predicate>
     fun parseOr(left: QueryCriteria, right: QueryCriteria): Collection<Predicate>
     fun parseAnd(left: QueryCriteria, right: QueryCriteria): Collection<Predicate>
-    fun parse(criteria: QueryCriteria, sorting: Sort? = null) : Collection<Predicate>
+    fun parse(criteria: QueryCriteria, sorting: Sort? = null): Collection<Predicate>
 }
diff --git a/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteriaUtils.kt b/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteriaUtils.kt
index 1ee9ab89d4..85d7292061 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteriaUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteriaUtils.kt
@@ -170,8 +170,8 @@ data class Sort(val columns: Collection<SortColumn>) {
 
     @CordaSerializable
     data class SortColumn(
-        val sortAttribute: SortAttribute,
-        val direction: Sort.Direction = Sort.Direction.ASC)
+            val sortAttribute: SortAttribute,
+            val direction: Sort.Direction = Sort.Direction.ASC)
 }
 
 @CordaSerializable
@@ -199,8 +199,9 @@ object Builder {
 
     fun <R> Field.predicate(predicate: ColumnPredicate<R>) = CriteriaExpression.ColumnPredicateExpression(Column<Any, R>(this), predicate)
 
-    fun <O, R> KProperty1<O, R?>.functionPredicate(predicate: ColumnPredicate<R>, groupByColumns:  List<Column<O, R>>? = null, orderBy: Sort.Direction? = null)
+    fun <O, R> KProperty1<O, R?>.functionPredicate(predicate: ColumnPredicate<R>, groupByColumns: List<Column<O, R>>? = null, orderBy: Sort.Direction? = null)
             = CriteriaExpression.AggregateFunctionExpression(Column(this), predicate, groupByColumns, orderBy)
+
     fun <R> Field.functionPredicate(predicate: ColumnPredicate<R>, groupByColumns: List<Column<Any, R>>? = null, orderBy: Sort.Direction? = null)
             = CriteriaExpression.AggregateFunctionExpression(Column<Any, R>(this), predicate, groupByColumns, orderBy)
 
@@ -217,15 +218,32 @@ object Builder {
     fun <O, R : Comparable<R>> KProperty1<O, R?>.`in`(collection: Collection<R>) = predicate(ColumnPredicate.CollectionExpression(CollectionOperator.IN, collection))
     fun <O, R : Comparable<R>> KProperty1<O, R?>.notIn(collection: Collection<R>) = predicate(ColumnPredicate.CollectionExpression(CollectionOperator.NOT_IN, collection))
 
-    @JvmStatic fun <R> Field.equal(value: R) = predicate(ColumnPredicate.EqualityComparison(EqualityComparisonOperator.EQUAL, value))
-    @JvmStatic fun <R> Field.notEqual(value: R) = predicate(ColumnPredicate.EqualityComparison(EqualityComparisonOperator.NOT_EQUAL, value))
-    @JvmStatic fun <R : Comparable<R>> Field.lessThan(value: R) = comparePredicate(BinaryComparisonOperator.LESS_THAN, value)
-    @JvmStatic fun <R : Comparable<R>> Field.lessThanOrEqual(value: R) = comparePredicate(BinaryComparisonOperator.LESS_THAN_OR_EQUAL, value)
-    @JvmStatic fun <R : Comparable<R>> Field.greaterThan(value: R) = comparePredicate(BinaryComparisonOperator.GREATER_THAN, value)
-    @JvmStatic fun <R : Comparable<R>> Field.greaterThanOrEqual(value: R) = comparePredicate(BinaryComparisonOperator.GREATER_THAN_OR_EQUAL, value)
-    @JvmStatic fun <R : Comparable<R>> Field.between(from: R, to: R) = predicate(ColumnPredicate.Between(from, to))
-    @JvmStatic fun <R : Comparable<R>> Field.`in`(collection: Collection<R>) = predicate(ColumnPredicate.CollectionExpression(CollectionOperator.IN, collection))
-    @JvmStatic fun <R : Comparable<R>> Field.notIn(collection: Collection<R>) = predicate(ColumnPredicate.CollectionExpression(CollectionOperator.NOT_IN, collection))
+    @JvmStatic
+    fun <R> Field.equal(value: R) = predicate(ColumnPredicate.EqualityComparison(EqualityComparisonOperator.EQUAL, value))
+
+    @JvmStatic
+    fun <R> Field.notEqual(value: R) = predicate(ColumnPredicate.EqualityComparison(EqualityComparisonOperator.NOT_EQUAL, value))
+
+    @JvmStatic
+    fun <R : Comparable<R>> Field.lessThan(value: R) = comparePredicate(BinaryComparisonOperator.LESS_THAN, value)
+
+    @JvmStatic
+    fun <R : Comparable<R>> Field.lessThanOrEqual(value: R) = comparePredicate(BinaryComparisonOperator.LESS_THAN_OR_EQUAL, value)
+
+    @JvmStatic
+    fun <R : Comparable<R>> Field.greaterThan(value: R) = comparePredicate(BinaryComparisonOperator.GREATER_THAN, value)
+
+    @JvmStatic
+    fun <R : Comparable<R>> Field.greaterThanOrEqual(value: R) = comparePredicate(BinaryComparisonOperator.GREATER_THAN_OR_EQUAL, value)
+
+    @JvmStatic
+    fun <R : Comparable<R>> Field.between(from: R, to: R) = predicate(ColumnPredicate.Between(from, to))
+
+    @JvmStatic
+    fun <R : Comparable<R>> Field.`in`(collection: Collection<R>) = predicate(ColumnPredicate.CollectionExpression(CollectionOperator.IN, collection))
+
+    @JvmStatic
+    fun <R : Comparable<R>> Field.notIn(collection: Collection<R>) = predicate(ColumnPredicate.CollectionExpression(CollectionOperator.NOT_IN, collection))
 
     fun <R> equal(value: R) = ColumnPredicate.EqualityComparison(EqualityComparisonOperator.EQUAL, value)
     fun <R> notEqual(value: R) = ColumnPredicate.EqualityComparison(EqualityComparisonOperator.NOT_EQUAL, value)
@@ -238,45 +256,57 @@ object Builder {
     fun <R : Comparable<R>> notIn(collection: Collection<R>) = ColumnPredicate.CollectionExpression(CollectionOperator.NOT_IN, collection)
 
     fun <O> KProperty1<O, String?>.like(string: String) = predicate(ColumnPredicate.Likeness(LikenessOperator.LIKE, string))
-    @JvmStatic fun Field.like(string: String) = predicate(ColumnPredicate.Likeness(LikenessOperator.LIKE, string))
+    @JvmStatic
+    fun Field.like(string: String) = predicate(ColumnPredicate.Likeness(LikenessOperator.LIKE, string))
+
     fun <O> KProperty1<O, String?>.notLike(string: String) = predicate(ColumnPredicate.Likeness(LikenessOperator.NOT_LIKE, string))
-    @JvmStatic fun Field.notLike(string: String) = predicate(ColumnPredicate.Likeness(LikenessOperator.NOT_LIKE, string))
+    @JvmStatic
+    fun Field.notLike(string: String) = predicate(ColumnPredicate.Likeness(LikenessOperator.NOT_LIKE, string))
 
     fun <O, R> KProperty1<O, R?>.isNull() = predicate(ColumnPredicate.NullExpression(NullOperator.IS_NULL))
-    @JvmStatic fun Field.isNull() = predicate(ColumnPredicate.NullExpression<Any>(NullOperator.IS_NULL))
+    @JvmStatic
+    fun Field.isNull() = predicate(ColumnPredicate.NullExpression<Any>(NullOperator.IS_NULL))
+
     fun <O, R> KProperty1<O, R?>.notNull() = predicate(ColumnPredicate.NullExpression(NullOperator.NOT_NULL))
-    @JvmStatic fun Field.notNull() = predicate(ColumnPredicate.NullExpression<Any>(NullOperator.NOT_NULL))
+    @JvmStatic
+    fun Field.notNull() = predicate(ColumnPredicate.NullExpression<Any>(NullOperator.NOT_NULL))
 
     /** aggregate functions */
     fun <O, R> KProperty1<O, R?>.sum(groupByColumns: List<KProperty1<O, R>>? = null, orderBy: Sort.Direction? = null) =
             functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.SUM), groupByColumns?.map { Column(it) }, orderBy)
-    @JvmStatic @JvmOverloads
+
+    @JvmStatic
+    @JvmOverloads
     fun <R> Field.sum(groupByColumns: List<Field>? = null, orderBy: Sort.Direction? = null) =
-            functionPredicate(ColumnPredicate.AggregateFunction<R>(AggregateFunctionType.SUM), groupByColumns?.map { Column<Any,R>(it) }, orderBy)
+            functionPredicate(ColumnPredicate.AggregateFunction<R>(AggregateFunctionType.SUM), groupByColumns?.map { Column<Any, R>(it) }, orderBy)
 
     fun <O, R> KProperty1<O, R?>.count() = functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.COUNT))
-    @JvmStatic fun Field.count() = functionPredicate(ColumnPredicate.AggregateFunction<Any>(AggregateFunctionType.COUNT))
+    @JvmStatic
+    fun Field.count() = functionPredicate(ColumnPredicate.AggregateFunction<Any>(AggregateFunctionType.COUNT))
 
     fun <O, R> KProperty1<O, R?>.avg(groupByColumns: List<KProperty1<O, R>>? = null, orderBy: Sort.Direction? = null) =
             functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.AVG), groupByColumns?.map { Column(it) }, orderBy)
+
     @JvmStatic
     @JvmOverloads
     fun <R> Field.avg(groupByColumns: List<Field>? = null, orderBy: Sort.Direction? = null) =
-            functionPredicate(ColumnPredicate.AggregateFunction<R>(AggregateFunctionType.AVG), groupByColumns?.map { Column<Any,R>(it) }, orderBy)
+            functionPredicate(ColumnPredicate.AggregateFunction<R>(AggregateFunctionType.AVG), groupByColumns?.map { Column<Any, R>(it) }, orderBy)
 
     fun <O, R> KProperty1<O, R?>.min(groupByColumns: List<KProperty1<O, R>>? = null, orderBy: Sort.Direction? = null) =
             functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.MIN), groupByColumns?.map { Column(it) }, orderBy)
+
     @JvmStatic
     @JvmOverloads
     fun <R> Field.min(groupByColumns: List<Field>? = null, orderBy: Sort.Direction? = null) =
-            functionPredicate(ColumnPredicate.AggregateFunction<R>(AggregateFunctionType.MIN), groupByColumns?.map { Column<Any,R>(it) }, orderBy)
+            functionPredicate(ColumnPredicate.AggregateFunction<R>(AggregateFunctionType.MIN), groupByColumns?.map { Column<Any, R>(it) }, orderBy)
 
     fun <O, R> KProperty1<O, R?>.max(groupByColumns: List<KProperty1<O, R>>? = null, orderBy: Sort.Direction? = null) =
             functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.MAX), groupByColumns?.map { Column(it) }, orderBy)
+
     @JvmStatic
     @JvmOverloads
     fun <R> Field.max(groupByColumns: List<Field>? = null, orderBy: Sort.Direction? = null) =
-            functionPredicate(ColumnPredicate.AggregateFunction<R>(AggregateFunctionType.MAX), groupByColumns?.map { Column<Any,R>(it) }, orderBy)
+            functionPredicate(ColumnPredicate.AggregateFunction<R>(AggregateFunctionType.MAX), groupByColumns?.map { Column<Any, R>(it) }, orderBy)
 }
 
 inline fun <A> builder(block: Builder.() -> A) = block(Builder)
diff --git a/core/src/main/kotlin/net/corda/core/schemas/CommonSchema.kt b/core/src/main/kotlin/net/corda/core/schemas/CommonSchema.kt
index 0f9d985791..1d5559d45d 100644
--- a/core/src/main/kotlin/net/corda/core/schemas/CommonSchema.kt
+++ b/core/src/main/kotlin/net/corda/core/schemas/CommonSchema.kt
@@ -38,9 +38,9 @@ object CommonSchemaV1 : MappedSchema(schemaFamily = CommonSchema.javaClass, vers
 
     ) : PersistentState() {
         constructor(uid: UniqueIdentifier, _participants: Set<AbstractParty>)
-            : this(participants = _participants.toMutableSet(),
-                   externalId = uid.externalId,
-                   uuid = uid.id)
+                : this(participants = _participants.toMutableSet(),
+                externalId = uid.externalId,
+                uuid = uid.id)
     }
 
     @MappedSuperclass
diff --git a/core/src/main/kotlin/net/corda/core/schemas/NodeInfoSchema.kt b/core/src/main/kotlin/net/corda/core/schemas/NodeInfoSchema.kt
index 8e019d7b5b..a0e6c80f49 100644
--- a/core/src/main/kotlin/net/corda/core/schemas/NodeInfoSchema.kt
+++ b/core/src/main/kotlin/net/corda/core/schemas/NodeInfoSchema.kt
@@ -31,8 +31,8 @@ object NodeInfoSchemaV1 : MappedSchema(
             @Column(name = "legal_identities_certs")
             @ManyToMany(cascade = arrayOf(CascadeType.ALL))
             @JoinTable(name = "link_nodeinfo_party",
-                    joinColumns = arrayOf(JoinColumn(name="node_info_id")),
-                    inverseJoinColumns = arrayOf(JoinColumn(name="party_name")))
+                    joinColumns = arrayOf(JoinColumn(name = "node_info_id")),
+                    inverseJoinColumns = arrayOf(JoinColumn(name = "party_name")))
             val legalIdentitiesAndCerts: List<DBPartyAndCertificate>,
 
             @Column(name = "platform_version")
@@ -64,14 +64,15 @@ object NodeInfoSchemaV1 : MappedSchema(
 
     @Entity
     data class DBHostAndPort(
-                @EmbeddedId
-                private val pk: PKHostAndPort
+            @EmbeddedId
+            private val pk: PKHostAndPort
     ) {
         companion object {
             fun fromHostAndPort(hostAndPort: NetworkHostAndPort) = DBHostAndPort(
                     PKHostAndPort(hostAndPort.host, hostAndPort.port)
             )
         }
+
         fun toHostAndPort(): NetworkHostAndPort {
             return NetworkHostAndPort(this.pk.host!!, this.pk.port!!)
         }
diff --git a/core/src/main/kotlin/net/corda/core/schemas/PersistentTypes.kt b/core/src/main/kotlin/net/corda/core/schemas/PersistentTypes.kt
index a02241aae2..cd55da4982 100644
--- a/core/src/main/kotlin/net/corda/core/schemas/PersistentTypes.kt
+++ b/core/src/main/kotlin/net/corda/core/schemas/PersistentTypes.kt
@@ -49,7 +49,8 @@ open class MappedSchema(schemaFamily: Class<*>,
  * A super class for all mapped states exported to a schema that ensures the [StateRef] appears on the database row.  The
  * [StateRef] will be set to the correct value by the framework (there's no need to set during mapping generation by the state itself).
  */
-@MappedSuperclass @CordaSerializable open class PersistentState(@EmbeddedId var stateRef: PersistentStateRef? = null) : StatePersistable
+@MappedSuperclass
+@CordaSerializable open class PersistentState(@EmbeddedId var stateRef: PersistentStateRef? = null) : StatePersistable
 
 /**
  * Embedded [StateRef] representation used in state mapping.
diff --git a/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt b/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
index 131578482e..b0499938ef 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
@@ -115,6 +115,7 @@ interface SerializationContext {
      * The use case we are serializing or deserializing for.  See [UseCase].
      */
     val useCase: UseCase
+
     /**
      * Helper method to return a new context based on this context with the property added.
      */
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 d62b1c0e6e..1881431114 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt
@@ -57,7 +57,7 @@ data class LedgerTransaction(
     }
 
     private val contracts: Map<ContractClassName, Try<Contract>> = (inputs.map { it.state.contract } + outputs.map { it.contract })
-                    .toSet().map { it to createContractFor(it) }.toMap()
+            .toSet().map { it to createContractFor(it) }.toMap()
 
     val inputStates: List<ContractState> get() = inputs.map { it.state.data }
 
@@ -79,8 +79,7 @@ data class LedgerTransaction(
         // TODO: make contract upgrade transactions have a separate type
         if (commands.any { it.value is UpgradeCommand }) {
             verifyContractUpgrade()
-        }
-        else {
+        } else {
             verifyContracts()
         }
     }
diff --git a/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt
index 4cd1332659..8f2c476004 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/MerkleTransaction.kt
@@ -48,7 +48,7 @@ abstract class TraversableTransaction(open val componentGroups: List<ComponentGr
      * - list of each attachment that is present
      * - The notary [Party], if present (list with one element)
      * - The time-window of the transaction, if present (list with one element)
-    */
+     */
     val availableComponentGroups: List<List<Any>>
         get() {
             val result = mutableListOf(inputs, outputs, commands, attachments)
@@ -138,7 +138,7 @@ class FilteredTransaction private constructor(
             fun updateFilteredComponents() {
                 wtx.inputs.forEachIndexed { internalIndex, it -> filter(it, ComponentGroupEnum.INPUTS_GROUP.ordinal, internalIndex) }
                 wtx.outputs.forEachIndexed { internalIndex, it -> filter(it, ComponentGroupEnum.OUTPUTS_GROUP.ordinal, internalIndex) }
-                wtx.commands.forEachIndexed { internalIndex, it -> filter(it, ComponentGroupEnum.COMMANDS_GROUP.ordinal, internalIndex)  }
+                wtx.commands.forEachIndexed { internalIndex, it -> filter(it, ComponentGroupEnum.COMMANDS_GROUP.ordinal, internalIndex) }
                 wtx.attachments.forEachIndexed { internalIndex, it -> filter(it, ComponentGroupEnum.ATTACHMENTS_GROUP.ordinal, internalIndex) }
                 if (wtx.notary != null) filter(wtx.notary, ComponentGroupEnum.NOTARY_GROUP.ordinal, 0)
                 if (wtx.timeWindow != null) filter(wtx.timeWindow, ComponentGroupEnum.TIMEWINDOW_GROUP.ordinal, 0)
@@ -147,7 +147,7 @@ class FilteredTransaction private constructor(
                 // we decide to filter and attach this field to a FilteredTransaction.
                 // An example would be to redact certain contract state types, but otherwise leave a transaction alone,
                 // including the unknown new components.
-                wtx.componentGroups.filter { it.groupIndex >= ComponentGroupEnum.values().size }.forEach { componentGroup -> componentGroup.components.forEachIndexed { internalIndex, component-> filter(component, componentGroup.groupIndex, internalIndex) }}
+                wtx.componentGroups.filter { it.groupIndex >= ComponentGroupEnum.values().size }.forEach { componentGroup -> componentGroup.components.forEachIndexed { internalIndex, component -> filter(component, componentGroup.groupIndex, internalIndex) } }
             }
 
             fun createPartialMerkleTree(componentGroupIndex: Int) = PartialMerkleTree.build(MerkleTree.getMerkleTree(wtx.availableComponentHashes[componentGroupIndex]!!), filteredComponentHashes[componentGroupIndex]!!)
@@ -156,7 +156,7 @@ class FilteredTransaction private constructor(
                 updateFilteredComponents()
                 val filteredComponentGroups: MutableList<FilteredComponentGroup> = mutableListOf()
                 filteredSerialisedComponents.forEach { (groupIndex, value) ->
-                    filteredComponentGroups.add(FilteredComponentGroup(groupIndex, value, filteredComponentNonces[groupIndex]!!, createPartialMerkleTree(groupIndex) ))
+                    filteredComponentGroups.add(FilteredComponentGroup(groupIndex, value, filteredComponentNonces[groupIndex]!!, createPartialMerkleTree(groupIndex)))
                 }
                 return filteredComponentGroups
             }
@@ -183,7 +183,7 @@ class FilteredTransaction private constructor(
 
         // Compute partial Merkle roots for each filtered component and verify each of the partial Merkle trees.
         filteredComponentGroups.forEach { (groupIndex, components, nonces, groupPartialTree) ->
-            verificationCheck(groupIndex < groupHashes.size ) { "There is no matching component group hash for group $groupIndex" }
+            verificationCheck(groupIndex < groupHashes.size) { "There is no matching component group hash for group $groupIndex" }
             val groupMerkleRoot = groupHashes[groupIndex]
             verificationCheck(groupMerkleRoot == PartialMerkleTree.rootAndUsedHashes(groupPartialTree.root, mutableListOf())) { "Partial Merkle tree root and advertised full Merkle tree root for component group $groupIndex do not match" }
             verificationCheck(groupPartialTree.verify(groupMerkleRoot, components.mapIndexed { index, component -> componentHash(nonces[index], component) })) { "Visible components in group $groupIndex cannot be verified against their partial Merkle tree" }
@@ -226,7 +226,7 @@ class FilteredTransaction private constructor(
                 "Did not receive components for group ${componentGroupEnum.ordinal} and cannot verify they didn't exist in the original wire transaction"
             }
         } else {
-            visibilityCheck(group.groupIndex < groupHashes.size ) { "There is no matching component group hash for group ${group.groupIndex}" }
+            visibilityCheck(group.groupIndex < groupHashes.size) { "There is no matching component group hash for group ${group.groupIndex}" }
             val groupPartialRoot = groupHashes[group.groupIndex]
             val groupFullRoot = MerkleTree.getMerkleTree(group.components.mapIndexed { index, component -> componentHash(group.nonces[index], component) }).hash
             visibilityCheck(groupPartialRoot == groupFullRoot) { "The partial Merkle tree root does not match with the received root for group ${group.groupIndex}" }
@@ -253,7 +253,7 @@ class FilteredTransaction private constructor(
  * This is similar to [ComponentGroup], but it also includes the corresponding nonce per component.
  */
 @CordaSerializable
-data class FilteredComponentGroup(override val groupIndex: Int, override val components: List<OpaqueBytes>, val nonces: List<SecureHash>, val partialMerkleTree: PartialMerkleTree): ComponentGroup(groupIndex, components) {
+data class FilteredComponentGroup(override val groupIndex: Int, override val components: List<OpaqueBytes>, val nonces: List<SecureHash>, val partialMerkleTree: PartialMerkleTree) : ComponentGroup(groupIndex, components) {
     init {
         check(components.size == nonces.size) { "Size of transaction components and nonces do not match" }
     }
diff --git a/core/src/main/kotlin/net/corda/core/transactions/MissingContractAttachments.kt b/core/src/main/kotlin/net/corda/core/transactions/MissingContractAttachments.kt
index 935ddfdd8d..725e75da0f 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/MissingContractAttachments.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/MissingContractAttachments.kt
@@ -12,4 +12,4 @@ import net.corda.core.serialization.CordaSerializable
  */
 @CordaSerializable
 class MissingContractAttachments(val states: List<TransactionState<ContractState>>)
-    : FlowException("Cannot find contract attachments for ${states.map { it.contract }.distinct() }")
\ No newline at end of file
+    : FlowException("Cannot find contract attachments for ${states.map { it.contract }.distinct()}")
\ No newline at end of file
diff --git a/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
index 4e8602daf6..d583a5f386 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
@@ -47,7 +47,8 @@ data class SignedTransaction(val txBits: SerializedBytes<CoreTransaction>,
     }
 
     /** Cache the deserialized form of the transaction. This is useful when building a transaction or collecting signatures. */
-    @Volatile @Transient private var cachedTransaction: CoreTransaction? = null
+    @Volatile
+    @Transient private var cachedTransaction: CoreTransaction? = null
 
     /** Lazily calculated access to the deserialised/hashed transaction data. */
     private val transaction: CoreTransaction get() = cachedTransaction ?: txBits.deserialize().apply { cachedTransaction = this }
diff --git a/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt b/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt
index ad6c538451..847bdfc31b 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt
@@ -38,8 +38,8 @@ open class TransactionBuilder(
         protected val commands: MutableList<Command<*>> = arrayListOf(),
         protected var window: TimeWindow? = null,
         protected var privacySalt: PrivacySalt = PrivacySalt()
-    ) {
-    constructor(notary: Party) : this (notary, (Strand.currentStrand() as? FlowStateMachine<*>)?.id?.uuid ?: UUID.randomUUID())
+) {
+    constructor(notary: Party) : this(notary, (Strand.currentStrand() as? FlowStateMachine<*>)?.id?.uuid ?: UUID.randomUUID())
 
     /**
      * Creates a copy of the builder.
@@ -179,6 +179,7 @@ open class TransactionBuilder(
 
     // Accessors that yield immutable snapshots.
     fun inputStates(): List<StateRef> = ArrayList(inputs)
+
     fun attachments(): List<SecureHash> = ArrayList(attachments)
     fun outputStates(): List<TransactionState<*>> = ArrayList(outputs)
     fun commands(): List<Command<*>> = ArrayList(commands)
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 3bba0b8ae6..2325344286 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt
@@ -63,15 +63,16 @@ class WireTransaction(componentGroups: List<ComponentGroup>, val privacySalt: Pr
     override val id: SecureHash get() = merkleTree.hash
 
     /** Public keys that need to be fulfilled by signatures in order for the transaction to be valid. */
-    val requiredSigningKeys: Set<PublicKey> get() {
-        val commandKeys = commands.flatMap { it.signers }.toSet()
-        // TODO: prevent notary field from being set if there are no inputs and no timestamp.
-        return if (notary != null && (inputs.isNotEmpty() || timeWindow != null)) {
-            commandKeys + notary.owningKey
-        } else {
-            commandKeys
+    val requiredSigningKeys: Set<PublicKey>
+        get() {
+            val commandKeys = commands.flatMap { it.signers }.toSet()
+            // TODO: prevent notary field from being set if there are no inputs and no timestamp.
+            return if (notary != null && (inputs.isNotEmpty() || timeWindow != null)) {
+                commandKeys + notary.owningKey
+            } else {
+                commandKeys
+            }
         }
-    }
 
     /**
      * Looks up identities and attachments from storage to generate a [LedgerTransaction]. A transaction is expected to
@@ -84,7 +85,7 @@ class WireTransaction(componentGroups: List<ComponentGroup>, val privacySalt: Pr
     fun toLedgerTransaction(services: ServicesForResolution): LedgerTransaction {
         return toLedgerTransaction(
                 resolveIdentity = { services.identityService.partyFromKey(it) },
-                resolveAttachment = { services.attachments.openAttachment(it)},
+                resolveAttachment = { services.attachments.openAttachment(it) },
                 resolveStateRef = { services.loadState(it) },
                 resolveContractAttachment = { services.cordappProvider.getContractAttachmentID(it.contract) }
         )
@@ -123,7 +124,7 @@ class WireTransaction(componentGroups: List<ComponentGroup>, val privacySalt: Pr
      * Build filtered transaction using provided filtering functions.
      */
     fun buildFilteredTransaction(filtering: Predicate<Any>): FilteredTransaction =
-        FilteredTransaction.buildFilteredTransaction(this, filtering)
+            FilteredTransaction.buildFilteredTransaction(this, filtering)
 
     /**
      * Builds whole Merkle tree for a transaction.
@@ -236,7 +237,7 @@ class WireTransaction(componentGroups: List<ComponentGroup>, val privacySalt: Pr
     ): List<Attachment> {
         val contractAttachments = (outputs + resolvedInputs.map { it.state }).map { Pair(it, resolveContractAttachment(it)) }
         val missingAttachments = contractAttachments.filter { it.second == null }
-        return if(missingAttachments.isEmpty()) {
+        return if (missingAttachments.isEmpty()) {
             contractAttachments.map { ContractAttachment(resolveAttachment(it.second!!) ?: throw AttachmentResolutionException(it.second!!), it.first.contract) }
         } else {
             throw MissingContractAttachments(missingAttachments.map { it.first })
diff --git a/core/src/main/kotlin/net/corda/core/utilities/ByteArrays.kt b/core/src/main/kotlin/net/corda/core/utilities/ByteArrays.kt
index 23eb6d86e5..a2b74a11ff 100644
--- a/core/src/main/kotlin/net/corda/core/utilities/ByteArrays.kt
+++ b/core/src/main/kotlin/net/corda/core/utilities/ByteArrays.kt
@@ -25,6 +25,7 @@ sealed class ByteSequence : Comparable<ByteSequence> {
      * The start position of the sequence within the byte array.
      */
     abstract val offset: Int
+
     /** Returns a [ByteArrayInputStream] of the bytes */
     fun open() = ByteArrayInputStream(bytes, offset, size)
 
diff --git a/core/src/main/kotlin/net/corda/core/utilities/EncodingUtils.kt b/core/src/main/kotlin/net/corda/core/utilities/EncodingUtils.kt
index 1cc4e53807..2c1854c897 100644
--- a/core/src/main/kotlin/net/corda/core/utilities/EncodingUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/utilities/EncodingUtils.kt
@@ -66,5 +66,6 @@ fun String.hexToBase64(): String = hexToByteArray().toBase64()
 // TODO: follow the crypto-conditions ASN.1 spec, some changes are needed to be compatible with the condition
 //       structure, e.g. mapping a PublicKey to a condition with the specific feature (ED25519).
 fun parsePublicKeyBase58(base58String: String): PublicKey = base58String.base58ToByteArray().deserialize<PublicKey>()
+
 fun PublicKey.toBase58String(): String = this.serialize().bytes.toBase58()
 fun PublicKey.toSHA256Bytes(): ByteArray = this.serialize().bytes.sha256().bytes // TODO: decide on the format of hashed key (encoded Vs serialised).
diff --git a/core/src/main/kotlin/net/corda/core/utilities/NetworkHostAndPort.kt b/core/src/main/kotlin/net/corda/core/utilities/NetworkHostAndPort.kt
index 8866e79e1b..6153c1c5d2 100644
--- a/core/src/main/kotlin/net/corda/core/utilities/NetworkHostAndPort.kt
+++ b/core/src/main/kotlin/net/corda/core/utilities/NetworkHostAndPort.kt
@@ -27,7 +27,7 @@ data class NetworkHostAndPort(val host: String, val port: Int) {
         fun parse(str: String): NetworkHostAndPort {
             val uri = try {
                 URI(null, str, null, null, null)
-            } catch(ex: URISyntaxException) {
+            } catch (ex: URISyntaxException) {
                 throw IllegalArgumentException("Host and port syntax is invalid, expected host:port")
             }
             require(uri.host != null) { NetworkHostAndPort.UNPARSEABLE_ADDRESS_FORMAT.format(str) }
diff --git a/core/src/main/kotlin/net/corda/core/utilities/NonEmptySet.kt b/core/src/main/kotlin/net/corda/core/utilities/NonEmptySet.kt
index 9e364769e2..ab5f0b86d7 100644
--- a/core/src/main/kotlin/net/corda/core/utilities/NonEmptySet.kt
+++ b/core/src/main/kotlin/net/corda/core/utilities/NonEmptySet.kt
@@ -48,11 +48,13 @@ class NonEmptySet<T> private constructor(private val elements: Set<T>) : Set<T>
 
     /** Returns the first element of the set. */
     fun head(): T = elements.iterator().next()
+
     override fun isEmpty(): Boolean = false
     override fun iterator() = object : Iterator<T> by elements.iterator() {}
 
     // Following methods are not delegated by Kotlin's Class delegation
     override fun forEach(action: Consumer<in T>) = elements.forEach(action)
+
     override fun stream(): Stream<T> = elements.stream()
     override fun parallelStream(): Stream<T> = elements.parallelStream()
     override fun spliterator(): Spliterator<T> = elements.spliterator()
diff --git a/core/src/test/kotlin/net/corda/core/contracts/CompatibleTransactionTests.kt b/core/src/test/kotlin/net/corda/core/contracts/CompatibleTransactionTests.kt
index 79d06b3ab4..7ed31d3d38 100644
--- a/core/src/test/kotlin/net/corda/core/contracts/CompatibleTransactionTests.kt
+++ b/core/src/test/kotlin/net/corda/core/contracts/CompatibleTransactionTests.kt
@@ -45,11 +45,11 @@ class CompatibleTransactionTests : TestDependencyInjectionBase() {
     // Do not add attachments (empty list).
     private val componentGroupsA by lazy {
         listOf(
-            inputGroup,
-            outputGroup,
-            commandGroup,
-            notaryGroup,
-            timeWindowGroup
+                inputGroup,
+                outputGroup,
+                commandGroup,
+                notaryGroup,
+                timeWindowGroup
         )
     }
     private val wireTransactionA by lazy { WireTransaction(componentGroups = componentGroupsA, privacySalt = privacySalt) }
@@ -199,6 +199,7 @@ class CompatibleTransactionTests : TestDependencyInjectionBase() {
                 else -> false
             }
         }
+
         val ftxInputs = wireTransactionA.buildFilteredTransaction(Predicate(::filtering)) // Inputs only filtered.
         ftxInputs.verify()
         ftxInputs.checkAllComponentsVisible(INPUTS_GROUP)
@@ -210,6 +211,7 @@ class CompatibleTransactionTests : TestDependencyInjectionBase() {
 
         // Filter one input only.
         fun filteringOneInput(elem: Any) = elem == inputs[0]
+
         val ftxOneInput = wireTransactionA.buildFilteredTransaction(Predicate(::filteringOneInput)) // First input only filtered.
         ftxOneInput.verify()
         assertFailsWith<ComponentVisibilityException> { ftxOneInput.checkAllComponentsVisible(INPUTS_GROUP) }
diff --git a/core/src/test/kotlin/net/corda/core/crypto/X509NameConstraintsTest.kt b/core/src/test/kotlin/net/corda/core/crypto/X509NameConstraintsTest.kt
index 33e060453f..88854550a4 100644
--- a/core/src/test/kotlin/net/corda/core/crypto/X509NameConstraintsTest.kt
+++ b/core/src/test/kotlin/net/corda/core/crypto/X509NameConstraintsTest.kt
@@ -20,7 +20,7 @@ class X509NameConstraintsTest {
 
     private fun makeKeyStores(subjectName: X500Name, nameConstraints: NameConstraints): Pair<KeyStore, KeyStore> {
         val rootKeys = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME)
-        val rootCACert = X509Utilities.createSelfSignedCACertificate(CordaX500Name(commonName = "Corda Root CA", organisation = "R3 Ltd", locality= "London", country = "GB"), rootKeys)
+        val rootCACert = X509Utilities.createSelfSignedCACertificate(CordaX500Name(commonName = "Corda Root CA", organisation = "R3 Ltd", locality = "London", country = "GB"), rootKeys)
 
         val intermediateCAKeyPair = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME)
         val intermediateCACert = X509Utilities.createCertificate(CertificateType.INTERMEDIATE_CA, rootCACert, rootKeys, CordaX500Name(commonName = "Corda Intermediate CA", organisation = "R3 Ltd", locality = "London", country = "GB"), intermediateCAKeyPair.public)
diff --git a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
index 197f8ca00c..0720557b1f 100644
--- a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
@@ -161,14 +161,14 @@ class ContractUpgradeFlowTest {
             assertFailsWith(UnexpectedFlowEndException::class) { rejectedFuture.getOrThrow() }
 
             // Party B authorise the contract state upgrade, and immediately deauthorise the same.
-            rpcB.startFlow( { stateAndRef, upgrade -> ContractUpgradeFlow.Authorise(stateAndRef, upgrade ) },
+            rpcB.startFlow({ stateAndRef, upgrade -> ContractUpgradeFlow.Authorise(stateAndRef, upgrade) },
                     btx!!.tx.outRef<ContractState>(0),
                     DummyContractV2::class.java).returnValue
-            rpcB.startFlow( { stateRef -> ContractUpgradeFlow.Deauthorise(stateRef) },
+            rpcB.startFlow({ stateRef -> ContractUpgradeFlow.Deauthorise(stateRef) },
                     btx.tx.outRef<ContractState>(0).ref).returnValue
 
             // The request is expected to be rejected because party B has subsequently deauthorised and a previously authorised upgrade.
-            val deauthorisedFuture = rpcA.startFlow( {stateAndRef, upgrade -> ContractUpgradeFlow.Initiate(stateAndRef, upgrade) },
+            val deauthorisedFuture = rpcA.startFlow({ stateAndRef, upgrade -> ContractUpgradeFlow.Initiate(stateAndRef, upgrade) },
                     atx.tx.outRef<DummyContract.State>(0),
                     DummyContractV2::class.java).returnValue
 
@@ -176,7 +176,7 @@ class ContractUpgradeFlowTest {
             assertFailsWith(UnexpectedFlowEndException::class) { deauthorisedFuture.getOrThrow() }
 
             // Party B authorise the contract state upgrade.
-            rpcB.startFlow( { stateAndRef, upgrade -> ContractUpgradeFlow.Authorise(stateAndRef, upgrade ) },
+            rpcB.startFlow({ stateAndRef, upgrade -> ContractUpgradeFlow.Authorise(stateAndRef, upgrade) },
                     btx.tx.outRef<ContractState>(0),
                     DummyContractV2::class.java).returnValue
 
diff --git a/core/src/test/kotlin/net/corda/core/internal/X509EdDSAEngineTest.kt b/core/src/test/kotlin/net/corda/core/internal/X509EdDSAEngineTest.kt
index 3f79a6ce36..c4cca75b83 100644
--- a/core/src/test/kotlin/net/corda/core/internal/X509EdDSAEngineTest.kt
+++ b/core/src/test/kotlin/net/corda/core/internal/X509EdDSAEngineTest.kt
@@ -15,11 +15,11 @@ import kotlin.test.assertFailsWith
 import kotlin.test.assertTrue
 
 class TestX509Key(algorithmId: AlgorithmId, key: BitArray) : X509Key() {
-   init {
-       this.algid = algorithmId
-       this.setKey(key)
-       this.encode()
-   }
+    init {
+        this.algid = algorithmId
+        this.setKey(key)
+        this.encode()
+    }
 }
 
 class X509EdDSAEngineTest {
diff --git a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
index db7d27d06a..4b14705669 100644
--- a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
+++ b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
@@ -45,6 +45,7 @@ private fun Attachment.extractContent() = ByteArrayOutputStream().apply { extrac
 private fun StartedNode<*>.saveAttachment(content: String) = database.transaction {
     attachments.importAttachment(createAttachmentData(content).inputStream())
 }
+
 private fun StartedNode<*>.hackAttachment(attachmentId: SecureHash, content: String) = database.transaction {
     updateAttachment(attachmentId, createAttachmentData(content))
 }

From 08c4fe2e9ea0fcf78fdecbc2bc0db167a0a9041a Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 14:51:19 +0100
Subject: [PATCH 121/185] Reformat files in `buildSrc`

---
 buildSrc/src/main/groovy/CanonicalizerPlugin.groovy | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/buildSrc/src/main/groovy/CanonicalizerPlugin.groovy b/buildSrc/src/main/groovy/CanonicalizerPlugin.groovy
index 6b6b87b483..85034e7bbd 100644
--- a/buildSrc/src/main/groovy/CanonicalizerPlugin.groovy
+++ b/buildSrc/src/main/groovy/CanonicalizerPlugin.groovy
@@ -28,7 +28,7 @@ class CanonicalizerPlugin implements Plugin<Project> {
             output.setMethod(ZipOutputStream.DEFLATED)
 
             entries.each {
-                def newEntry = new ZipEntry( it.name )
+                def newEntry = new ZipEntry(it.name)
 
                 newEntry.setLastModifiedTime(zeroTime)
                 newEntry.setCreationTime(zeroTime)

From 551dc432659aecfafa96b35193cfafc779ab9edd Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 14:54:07 +0100
Subject: [PATCH 122/185] Reformat files in `client`

---
 .../corda/client/jackson/JacksonSupport.kt    | 13 +++++---
 .../jackson/StringToMethodCallParser.kt       | 31 ++++++++++---------
 .../client/jackson/JacksonSupportTest.kt      |  4 +--
 .../net/corda/client/jfx/model/ModelsUtils.kt |  1 +
 .../client/jfx/model/NodeMonitorModel.kt      |  4 +--
 .../client/jfx/utils/ConcatenatedList.kt      | 15 ++++-----
 .../corda/client/jfx/utils/ObservableFold.kt  |  1 +
 .../client/jfx/utils/ObservableUtilities.kt   |  1 +
 .../utils/ReadOnlyBackedObservableMapBase.kt  | 25 ++++++++-------
 .../net/corda/client/mock/EventGenerator.kt   |  4 +--
 .../net/corda/client/mock/Generators.kt       |  1 +
 .../net/corda/client/rpc/RPCStabilityTests.kt | 19 +++++++-----
 .../rpc/internal/RPCClientProxyHandler.kt     |  1 +
 .../rpc/StandaloneCordaRPCJavaClientTest.java |  2 +-
 .../kotlin/rpc/StandaloneCordaRPClientTest.kt |  6 ++--
 .../net/corda/client/rpc/AbstractRPCTest.kt   |  5 ++-
 .../corda/client/rpc/RPCPerformanceTests.kt   | 10 ++++--
 .../corda/client/rpc/RPCPermissionsTests.kt   |  2 +-
 .../client/rpc/RepeatingBytesInputStream.kt   |  1 +
 19 files changed, 85 insertions(+), 61 deletions(-)

diff --git a/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt b/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt
index 809dbc45a9..65465e04bb 100644
--- a/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt
+++ b/client/jackson/src/main/kotlin/net/corda/client/jackson/JacksonSupport.kt
@@ -119,12 +119,14 @@ object JacksonSupport {
      * match an identity known from the network map. If true, the name is matched more leniently but if the match
      * is ambiguous a [JsonParseException] is thrown.
      */
-    @JvmStatic @JvmOverloads
+    @JvmStatic
+    @JvmOverloads
     fun createDefaultMapper(rpc: CordaRPCOps, factory: JsonFactory = JsonFactory(),
                             fuzzyIdentityMatch: Boolean = false): ObjectMapper = configureMapper(RpcObjectMapper(rpc, factory, fuzzyIdentityMatch))
 
     /** For testing or situations where deserialising parties is not required */
-    @JvmStatic @JvmOverloads
+    @JvmStatic
+    @JvmOverloads
     fun createNonRpcMapper(factory: JsonFactory = JsonFactory()): ObjectMapper = configureMapper(NoPartyObjectMapper(factory))
 
     /**
@@ -134,7 +136,8 @@ object JacksonSupport {
      * match an identity known from the network map. If true, the name is matched more leniently but if the match
      * is ambiguous a [JsonParseException] is thrown.
      */
-    @JvmStatic @JvmOverloads
+    @JvmStatic
+    @JvmOverloads
     fun createInMemoryMapper(identityService: IdentityService, factory: JsonFactory = JsonFactory(),
                              fuzzyIdentityMatch: Boolean = false) = configureMapper(IdentityObjectMapper(identityService, factory, fuzzyIdentityMatch))
 
@@ -227,7 +230,7 @@ object JacksonSupport {
 
             return try {
                 CordaX500Name.parse(parser.text)
-            } catch(ex: IllegalArgumentException) {
+            } catch (ex: IllegalArgumentException) {
                 throw JsonParseException(parser, "Invalid Corda X.500 name ${parser.text}: ${ex.message}", ex)
             }
         }
@@ -310,7 +313,7 @@ object JacksonSupport {
                     // Attempt parsing as a currency token. TODO: This needs thought about how to extend to other token types.
                     val currency = Currency.getInstance(token)
                     return Amount(quantity, currency)
-                } catch(e2: Exception) {
+                } catch (e2: Exception) {
                     throw JsonParseException(parser, "Invalid amount ${parser.text}", e2)
                 }
             }
diff --git a/client/jackson/src/main/kotlin/net/corda/client/jackson/StringToMethodCallParser.kt b/client/jackson/src/main/kotlin/net/corda/client/jackson/StringToMethodCallParser.kt
index a49409eca2..a79d14f591 100644
--- a/client/jackson/src/main/kotlin/net/corda/client/jackson/StringToMethodCallParser.kt
+++ b/client/jackson/src/main/kotlin/net/corda/client/jackson/StringToMethodCallParser.kt
@@ -100,7 +100,7 @@ open class StringToMethodCallParser<in T : Any> @JvmOverloads constructor(
     val methodParamNames: Map<String, List<String>> = targetType.declaredMethods.mapNotNull {
         try {
             it.name to paramNamesFromMethod(it)
-        } catch(e: KotlinReflectionInternalError) {
+        } catch (e: KotlinReflectionInternalError) {
             // Kotlin reflection doesn't support every method that can exist on an object (in particular, reified
             // inline methods) so we just ignore those here.
             null
@@ -175,7 +175,7 @@ open class StringToMethodCallParser<in T : Any> @JvmOverloads constructor(
             try {
                 val args = parseArguments(name, paramNamesFromMethod(method).zip(method.parameterTypes), argStr)
                 return ParsedMethodCall(target, method, args)
-            } catch(e: UnparseableCallException) {
+            } catch (e: UnparseableCallException) {
                 if (index == methods.size - 1)
                     throw e
             }
@@ -198,7 +198,7 @@ open class StringToMethodCallParser<in T : Any> @JvmOverloads constructor(
             val entry = tree[argName] ?: throw UnparseableCallException.MissingParameter(methodNameHint, argName, args)
             try {
                 om.readValue(entry.traverse(om), argType)
-            } catch(e: Exception) {
+            } catch (e: Exception) {
                 throw UnparseableCallException.FailedParse(e)
             }
         }
@@ -212,16 +212,17 @@ open class StringToMethodCallParser<in T : Any> @JvmOverloads constructor(
     }
 
     /** Returns a string-to-string map of commands to a string describing available parameter types. */
-    val availableCommands: Map<String, String> get() {
-        return methodMap.entries().map { entry ->
-            val (name, args) = entry   // TODO: Kotlin 1.1
-            val argStr = if (args.parameterCount == 0) "" else {
-                val paramNames = methodParamNames[name]!!
-                val typeNames = args.parameters.map { it.type.simpleName }
-                val paramTypes = paramNames.zip(typeNames)
-                paramTypes.map { "${it.first}: ${it.second}" }.joinToString(", ")
-            }
-            Pair(name, argStr)
-        }.toMap()
-    }
+    val availableCommands: Map<String, String>
+        get() {
+            return methodMap.entries().map { entry ->
+                val (name, args) = entry   // TODO: Kotlin 1.1
+                val argStr = if (args.parameterCount == 0) "" else {
+                    val paramNames = methodParamNames[name]!!
+                    val typeNames = args.parameters.map { it.type.simpleName }
+                    val paramTypes = paramNames.zip(typeNames)
+                    paramTypes.map { "${it.first}: ${it.second}" }.joinToString(", ")
+                }
+                Pair(name, argStr)
+            }.toMap()
+        }
 }
diff --git a/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt b/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt
index 6f057b2ff5..d8595e6bd9 100644
--- a/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt
+++ b/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt
@@ -92,10 +92,10 @@ class JacksonSupportTest : TestDependencyInjectionBase() {
     fun writeTransaction() {
         val attachmentRef = SecureHash.randomSHA256()
         whenever(cordappProvider.getContractAttachmentID(DummyContract.PROGRAM_ID))
-            .thenReturn(attachmentRef)
+                .thenReturn(attachmentRef)
         fun makeDummyTx(): SignedTransaction {
             val wtx = DummyContract.generateInitial(1, DUMMY_NOTARY, MINI_CORP.ref(1))
-                .toWireTransaction(services)
+                    .toWireTransaction(services)
             val signatures = TransactionSignature(
                     ByteArray(1),
                     ALICE_PUBKEY,
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/ModelsUtils.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/ModelsUtils.kt
index 836e046887..868849d56b 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/ModelsUtils.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/ModelsUtils.kt
@@ -1,4 +1,5 @@
 @file:JvmName("ModelsUtils")
+
 package net.corda.client.jfx.model
 
 import javafx.beans.property.ObjectProperty
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt
index 9a4da742b0..0b866332f9 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt
@@ -57,8 +57,8 @@ class NodeMonitorModel {
      */
     fun register(nodeHostAndPort: NetworkHostAndPort, username: String, password: String) {
         val client = CordaRPCClient(
-                 nodeHostAndPort,
-                 CordaRPCClientConfiguration.DEFAULT.copy(
+                nodeHostAndPort,
+                CordaRPCClientConfiguration.DEFAULT.copy(
                         connectionMaxRetryInterval = 10.seconds
                 )
         )
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ConcatenatedList.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ConcatenatedList.kt
index 9b8a5f45e5..58b602b834 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ConcatenatedList.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ConcatenatedList.kt
@@ -253,14 +253,15 @@ class ConcatenatedList<A>(sourceList: ObservableList<ObservableList<A>>) : Trans
         }
     }
 
-    override val size: Int get() {
-        recalculateOffsets()
-        if (nestedIndexOffsets.size > 0) {
-            return nestedIndexOffsets.last()
-        } else {
-            return 0
+    override val size: Int
+        get() {
+            recalculateOffsets()
+            if (nestedIndexOffsets.size > 0) {
+                return nestedIndexOffsets.last()
+            } else {
+                return 0
+            }
         }
-    }
 
     override fun getSourceIndex(index: Int): Int {
         throw UnsupportedOperationException("Source index not supported in concatenation")
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableFold.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableFold.kt
index 17c68ac20f..76c75c38de 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableFold.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableFold.kt
@@ -1,4 +1,5 @@
 @file:JvmName("ObservableFold")
+
 package net.corda.client.jfx.utils
 
 import javafx.application.Platform
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableUtilities.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableUtilities.kt
index 89366935fa..a863af5ade 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableUtilities.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ObservableUtilities.kt
@@ -1,4 +1,5 @@
 @file:JvmName("ObservableUtilities")
+
 package net.corda.client.jfx.utils
 
 import javafx.application.Platform
diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ReadOnlyBackedObservableMapBase.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ReadOnlyBackedObservableMapBase.kt
index a751e3ac99..4ee03afc56 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ReadOnlyBackedObservableMapBase.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/utils/ReadOnlyBackedObservableMapBase.kt
@@ -50,18 +50,19 @@ open class ReadOnlyBackedObservableMapBase<K, A, B> : ObservableMap<K, A> {
 
     override fun isEmpty() = backingMap.isEmpty()
 
-    override val entries: MutableSet<MutableMap.MutableEntry<K, A>> get() = backingMap.entries.fold(mutableSetOf()) { set, entry ->
-        set.add(object : MutableMap.MutableEntry<K, A> {
-            override var value: A = entry.value.first
-            override val key = entry.key
-            override fun setValue(newValue: A): A {
-                val old = value
-                value = newValue
-                return old
-            }
-        })
-        set
-    }
+    override val entries: MutableSet<MutableMap.MutableEntry<K, A>>
+        get() = backingMap.entries.fold(mutableSetOf()) { set, entry ->
+            set.add(object : MutableMap.MutableEntry<K, A> {
+                override var value: A = entry.value.first
+                override val key = entry.key
+                override fun setValue(newValue: A): A {
+                    val old = value
+                    value = newValue
+                    return old
+                }
+            })
+            set
+        }
     override val keys: MutableSet<K> get() = backingMap.keys
     override val values: MutableCollection<A> get() = ArrayList(backingMap.values.map { it.first })
 
diff --git a/client/mock/src/main/kotlin/net/corda/client/mock/EventGenerator.kt b/client/mock/src/main/kotlin/net/corda/client/mock/EventGenerator.kt
index 1955dff5d2..28e938c843 100644
--- a/client/mock/src/main/kotlin/net/corda/client/mock/EventGenerator.kt
+++ b/client/mock/src/main/kotlin/net/corda/client/mock/EventGenerator.kt
@@ -50,7 +50,7 @@ open class EventGenerator(val parties: List<Party>, val currencies: List<Currenc
  * [Generator]s for incoming/outgoing events of starting different cash flows. It invokes flows that throw exceptions
  * for use in explorer flow triage. Exceptions are of kind spending/exiting too much cash.
  */
-class ErrorFlowsEventGenerator(parties: List<Party>, currencies: List<Currency>, notary: Party): EventGenerator(parties, currencies, notary) {
+class ErrorFlowsEventGenerator(parties: List<Party>, currencies: List<Currency>, notary: Party) : EventGenerator(parties, currencies, notary) {
     enum class IssuerEvents {
         NORMAL_EXIT,
         EXIT_ERROR
@@ -62,7 +62,7 @@ class ErrorFlowsEventGenerator(parties: List<Party>, currencies: List<Currency>,
         when (errorType) {
             IssuerEvents.NORMAL_EXIT -> {
                 println("Normal exit")
-                if (currencyMap[ccy]!! <=  amount) addToMap(ccy, -amount)
+                if (currencyMap[ccy]!! <= amount) addToMap(ccy, -amount)
                 ExitRequest(Amount(amount, ccy), issueRef) // It may fail at the beginning, but we don't care.
             }
             IssuerEvents.EXIT_ERROR -> {
diff --git a/client/mock/src/main/kotlin/net/corda/client/mock/Generators.kt b/client/mock/src/main/kotlin/net/corda/client/mock/Generators.kt
index dc1315b175..ffd110fbeb 100644
--- a/client/mock/src/main/kotlin/net/corda/client/mock/Generators.kt
+++ b/client/mock/src/main/kotlin/net/corda/client/mock/Generators.kt
@@ -1,4 +1,5 @@
 @file:JvmName("Generators")
+
 package net.corda.client.mock
 
 import net.corda.core.contracts.Amount
diff --git a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/RPCStabilityTests.kt b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/RPCStabilityTests.kt
index 2e83e1f08a..7ccf1913d5 100644
--- a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/RPCStabilityTests.kt
+++ b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/RPCStabilityTests.kt
@@ -76,10 +76,12 @@ class RPCStabilityTests {
             rpcDriver {
                 Try.on { startRpcClient<RPCOps>(NetworkHostAndPort("localhost", 9999)).get() }
                 val server = startRpcServer<RPCOps>(ops = DummyOps)
-                Try.on { startRpcClient<RPCOps>(
-                        server.get().broker.hostAndPort!!,
-                        configuration = RPCClientConfiguration.default.copy(minimumServerProtocolVersion = 1)
-                ).get() }
+                Try.on {
+                    startRpcClient<RPCOps>(
+                            server.get().broker.hostAndPort!!,
+                            configuration = RPCClientConfiguration.default.copy(minimumServerProtocolVersion = 1)
+                    ).get()
+                }
             }
         }
         repeat(5) {
@@ -173,7 +175,7 @@ class RPCStabilityTests {
         }
     }
 
-    interface LeakObservableOps: RPCOps {
+    interface LeakObservableOps : RPCOps {
         fun leakObservable(): Observable<Nothing>
     }
 
@@ -249,6 +251,7 @@ class RPCStabilityTests {
                 val trackSubscriberCountObservable = UnicastSubject.create<Unit>().share().
                         doOnSubscribe { subscriberCount.incrementAndGet() }.
                         doOnUnsubscribe { subscriberCount.decrementAndGet() }
+
                 override fun subscribe(): Observable<Unit> {
                     return trackSubscriberCountObservable
                 }
@@ -261,7 +264,7 @@ class RPCStabilityTests {
             ).get()
 
             val numberOfClients = 4
-            val clients = (1 .. numberOfClients).map {
+            val clients = (1..numberOfClients).map {
                 startRandomRpcClient<TrackSubscriberOps>(server.broker.hostAndPort!!)
             }.transpose().get()
 
@@ -272,7 +275,7 @@ class RPCStabilityTests {
             clients[0].destroyForcibly()
             pollUntilClientNumber(server, numberOfClients - 1)
             // Kill the rest
-            (1 .. numberOfClients - 1).forEach {
+            (1..numberOfClients - 1).forEach {
                 clients[it].destroyForcibly()
             }
             pollUntilClientNumber(server, 0)
@@ -284,6 +287,7 @@ class RPCStabilityTests {
     interface SlowConsumerRPCOps : RPCOps {
         fun streamAtInterval(interval: Duration, size: Int): Observable<ByteArray>
     }
+
     class SlowConsumerRPCOpsImpl : SlowConsumerRPCOps {
         override val protocolVersion = 0
 
@@ -292,6 +296,7 @@ class RPCStabilityTests {
             return Observable.interval(interval.toMillis(), TimeUnit.MILLISECONDS).map { chunk }
         }
     }
+
     @Test
     fun `slow consumers are kicked`() {
         rpcDriver {
diff --git a/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClientProxyHandler.kt b/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClientProxyHandler.kt
index a777a0c96a..0a89aecc92 100644
--- a/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClientProxyHandler.kt
+++ b/client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClientProxyHandler.kt
@@ -79,6 +79,7 @@ class RPCClientProxyHandler(
         STARTED,
         FINISHED
     }
+
     private val lifeCycle = LifeCycle(State.UNSTARTED)
 
     private companion object {
diff --git a/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java b/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java
index e9ebce530f..70ae26e1b6 100644
--- a/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java
+++ b/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java
@@ -67,7 +67,7 @@ public class StandaloneCordaRPCJavaClientTest {
         try {
             connection.close();
         } finally {
-            if(notary != null) {
+            if (notary != null) {
                 notary.close();
             }
         }
diff --git a/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt b/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt
index 40ae8c5f16..1d487f762b 100644
--- a/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt
+++ b/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt
@@ -114,14 +114,14 @@ class StandaloneCordaRPClientTest {
     @Test
     fun `test starting flow`() {
         rpcProxy.startFlow(::CashIssueFlow, 127.POUNDS, OpaqueBytes.of(0), notaryNodeIdentity)
-            .returnValue.getOrThrow(timeout)
+                .returnValue.getOrThrow(timeout)
     }
 
     @Test
     fun `test starting tracked flow`() {
         var trackCount = 0
         val handle = rpcProxy.startTrackedFlow(
-            ::CashIssueFlow, 429.DOLLARS, OpaqueBytes.of(0), notaryNodeIdentity
+                ::CashIssueFlow, 429.DOLLARS, OpaqueBytes.of(0), notaryNodeIdentity
         )
         val updateLatch = CountDownLatch(1)
         handle.progress.subscribe { msg ->
@@ -156,7 +156,7 @@ class StandaloneCordaRPClientTest {
 
         // Now issue some cash
         rpcProxy.startFlow(::CashIssueFlow, 513.SWISS_FRANCS, OpaqueBytes.of(0), notaryNodeIdentity)
-            .returnValue.getOrThrow(timeout)
+                .returnValue.getOrThrow(timeout)
         updateLatch.await()
         assertEquals(1, updateCount.get())
     }
diff --git a/client/rpc/src/test/kotlin/net/corda/client/rpc/AbstractRPCTest.kt b/client/rpc/src/test/kotlin/net/corda/client/rpc/AbstractRPCTest.kt
index c6b5329d8c..35eaa9dfd8 100644
--- a/client/rpc/src/test/kotlin/net/corda/client/rpc/AbstractRPCTest.kt
+++ b/client/rpc/src/test/kotlin/net/corda/client/rpc/AbstractRPCTest.kt
@@ -20,10 +20,13 @@ open class AbstractRPCTest {
     }
 
     companion object {
-        @JvmStatic @Parameterized.Parameters(name = "Mode = {0}")
+        @JvmStatic
+        @Parameterized.Parameters(name = "Mode = {0}")
         fun defaultModes() = modes(RPCTestMode.InVm, RPCTestMode.Netty)
+
         fun modes(vararg modes: RPCTestMode) = listOf(*modes).map { arrayOf(it) }
     }
+
     @Parameterized.Parameter
     lateinit var mode: RPCTestMode
 
diff --git a/client/rpc/src/test/kotlin/net/corda/client/rpc/RPCPerformanceTests.kt b/client/rpc/src/test/kotlin/net/corda/client/rpc/RPCPerformanceTests.kt
index b9d64a3cab..2923040034 100644
--- a/client/rpc/src/test/kotlin/net/corda/client/rpc/RPCPerformanceTests.kt
+++ b/client/rpc/src/test/kotlin/net/corda/client/rpc/RPCPerformanceTests.kt
@@ -26,9 +26,11 @@ import java.util.concurrent.TimeUnit
 @RunWith(Parameterized::class)
 class RPCPerformanceTests : AbstractRPCTest() {
     companion object {
-        @JvmStatic @Parameterized.Parameters(name = "Mode = {0}")
+        @JvmStatic
+        @Parameterized.Parameters(name = "Mode = {0}")
         fun modes() = modes(RPCTestMode.Netty)
     }
+
     private interface TestOps : RPCOps {
         fun simpleReply(input: ByteArray, sizeOfReply: Int): ByteArray
     }
@@ -60,7 +62,7 @@ class RPCPerformanceTests : AbstractRPCTest() {
             val executor = Executors.newFixedThreadPool(4)
             val N = 10000
             val latch = CountDownLatch(N)
-            for (i in 1 .. N) {
+            for (i in 1..N) {
                 executor.submit {
                     proxy.ops.simpleReply(ByteArray(1024), 1024)
                     latch.countDown()
@@ -155,10 +157,12 @@ class RPCPerformanceTests : AbstractRPCTest() {
     data class BigMessagesResult(
             val Mbps: Double
     )
+
     @Test
     fun `big messages`() {
         warmup()
-        measure(listOf(1)) { clientParallelism -> // TODO this hangs with more parallelism
+        measure(listOf(1)) { clientParallelism ->
+            // TODO this hangs with more parallelism
             rpcDriver {
                 val proxy = testProxy(
                         RPCClientConfiguration.default,
diff --git a/client/rpc/src/test/kotlin/net/corda/client/rpc/RPCPermissionsTests.kt b/client/rpc/src/test/kotlin/net/corda/client/rpc/RPCPermissionsTests.kt
index 4411bbfd07..cee75881aa 100644
--- a/client/rpc/src/test/kotlin/net/corda/client/rpc/RPCPermissionsTests.kt
+++ b/client/rpc/src/test/kotlin/net/corda/client/rpc/RPCPermissionsTests.kt
@@ -79,7 +79,7 @@ class RPCPermissionsTests : AbstractRPCTest() {
     }
 
     @Test
-    fun `check ALL is implemented the correct way round` () {
+    fun `check ALL is implemented the correct way round`() {
         rpcDriver {
             val joeUser = userOf("joe", setOf(DUMMY_FLOW))
             val proxy = testProxyFor(joeUser)
diff --git a/client/rpc/src/test/kotlin/net/corda/client/rpc/RepeatingBytesInputStream.kt b/client/rpc/src/test/kotlin/net/corda/client/rpc/RepeatingBytesInputStream.kt
index 8887aa2476..b22ed8b506 100644
--- a/client/rpc/src/test/kotlin/net/corda/client/rpc/RepeatingBytesInputStream.kt
+++ b/client/rpc/src/test/kotlin/net/corda/client/rpc/RepeatingBytesInputStream.kt
@@ -13,6 +13,7 @@ class RepeatingBytesInputStream(val bytesToRepeat: ByteArray, val numberOfBytes:
             return bytesToRepeat[(numberOfBytes - bytesLeft) % bytesToRepeat.size].toInt()
         }
     }
+
     override fun read(byteArray: ByteArray, offset: Int, length: Int): Int {
         val lastIdx = Math.min(Math.min(offset + length, byteArray.size), offset + bytesLeft)
         for (i in offset until lastIdx) {

From b1fb321230f67383ab3eadf4ce8f54353e8ce218 Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 14:56:44 +0100
Subject: [PATCH 123/185] Reformat files in `experimental`

---
 .../quasarhook/QuasarInstrumentationHook.kt   |  9 ++---
 .../net/corda/sandbox/CandidacyStatus.java    | 20 +++++------
 .../net/corda/sandbox/CandidateMethod.java    | 20 +++++------
 .../sandbox/SandboxAwareClassWriter.java      | 16 ++++-----
 .../net/corda/sandbox/SandboxRemapper.java    |  1 -
 .../main/java/net/corda/sandbox/Utils.java    | 34 +++++++++---------
 .../corda/sandbox/WhitelistClassLoader.java   | 36 ++++++++++---------
 .../WhitelistClassloadingException.java       |  8 ++---
 .../net/corda/sandbox/costing/Contract.java   |  2 +-
 .../sandbox/costing/ContractExecutor.java     |  6 ++--
 .../sandbox/costing/RuntimeCostAccounter.java |  1 -
 .../corda/sandbox/tools/SandboxCreator.java   | 15 ++++----
 .../CostInstrumentingMethodVisitor.java       | 14 ++++----
 .../DefinitelyDisallowedMethodVisitor.java    |  2 +-
 .../sandbox/visitors/SandboxPathVisitor.java  |  8 +++--
 .../WhitelistCheckingClassVisitor.java        | 15 ++++----
 .../WhitelistCheckingMethodVisitor.java       | 19 +++++-----
 .../sandbox/costing/RuntimeCostAccounter.java |  2 +-
 .../java/net/corda/sandbox/TestUtils.java     | 18 +++++-----
 .../sandbox/WhitelistClassLoaderTest.java     |  7 ++--
 .../DeterministicClassInstrumenterTest.java   |  3 +-
 .../costing/SandboxedRewritingTest.java       |  7 +++-
 .../sandbox/greymalkin/StringReturner.java    |  1 -
 23 files changed, 134 insertions(+), 130 deletions(-)

diff --git a/experimental/quasar-hook/src/main/kotlin/net/corda/quasarhook/QuasarInstrumentationHook.kt b/experimental/quasar-hook/src/main/kotlin/net/corda/quasarhook/QuasarInstrumentationHook.kt
index c32328ba4a..acd586fa31 100644
--- a/experimental/quasar-hook/src/main/kotlin/net/corda/quasarhook/QuasarInstrumentationHook.kt
+++ b/experimental/quasar-hook/src/main/kotlin/net/corda/quasarhook/QuasarInstrumentationHook.kt
@@ -32,7 +32,7 @@ fun recordUsedInstrumentedCallStack() {
     val throwable = Throwable()
     var index = 0
     while (true) {
-        require (index < throwable.stackTrace.size) { "Can't find getStack call" }
+        require(index < throwable.stackTrace.size) { "Can't find getStack call" }
         val stackElement = throwable.stackTrace[index]
         if (stackElement.className == "co.paralleluniverse.fibers.Stack" && stackElement.methodName == "getStack") {
             break
@@ -129,7 +129,7 @@ class QuasarInstrumentationHookAgent {
                 // The separator append is a hack, it causes a package with an empty name to be added to the exclude tree,
                 // which practically causes that level of the tree to be always expanded in the output globs.
                 val expand = arguments.expand?.let { PackageTree.fromStrings(it.map { "$it${arguments.separator}" }, arguments.separator) }
-                val truncatedTree = truncate?.let { scannedTree.truncate(it)} ?: scannedTree
+                val truncatedTree = truncate?.let { scannedTree.truncate(it) } ?: scannedTree
                 val expandedTree = expand?.let { alwaysExcludedTree.merge(it) } ?: alwaysExcludedTree
                 val globs = truncatedTree.toGlobs(expandedTree)
                 globs.forEach {
@@ -152,7 +152,7 @@ object QuasarInstrumentationHook : ClassFileTransformer {
     val instrumentMap = mapOf<String, (CtClass) -> Unit>(
             "co/paralleluniverse/fibers/Stack" to { clazz ->
                 // This is called on each suspend, we hook into it to get the stack trace of actually used Suspendables
-                val getStackMethod = clazz.methods.single { it.name ==  "getStack" }
+                val getStackMethod = clazz.methods.single { it.name == "getStack" }
                 getStackMethod.insertBefore(
                         "$hookClassName.${::recordUsedInstrumentedCallStack.name}();"
                 )
@@ -194,7 +194,7 @@ object QuasarInstrumentationHook : ClassFileTransformer {
             throwable.printStackTrace(System.out)
             classfileBuffer
         }
-   }
+    }
 }
 
 data class Glob(val parts: List<String>, val isFull: Boolean) {
@@ -271,6 +271,7 @@ data class PackageTree(val branches: Map<String, PackageTree>) {
                 val exclude: PackageTree,
                 val globSoFar: List<String>
         )
+
         val toExpandList = LinkedList(listOf(State(this, excludeTree, emptyList())))
         val globs = ArrayList<Glob>()
         while (true) {
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/CandidacyStatus.java b/experimental/sandbox/src/main/java/net/corda/sandbox/CandidacyStatus.java
index 7bcaf86684..f0fd4bf668 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/CandidacyStatus.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/CandidacyStatus.java
@@ -43,7 +43,6 @@ public class CandidacyStatus {
     }
 
     /**
-     *
      * @param signature
      * @return true if the input was absent from the underlying map
      */
@@ -52,7 +51,6 @@ public class CandidacyStatus {
     }
 
     /**
-     * 
      * @param methodSignature
      * @return true if the input was absent from the underlying map
      */
@@ -62,7 +60,7 @@ public class CandidacyStatus {
 
     /**
      * Static factory method
-     * 
+     *
      * @param startingSet
      * @return a candidacy status based on the starting set
      */
@@ -81,7 +79,7 @@ public class CandidacyStatus {
 
     /**
      * Static factory method
-     * 
+     *
      * @return a candidacy status based on the starting set
      */
     public static CandidacyStatus of() {
@@ -90,8 +88,8 @@ public class CandidacyStatus {
 
     /**
      * Add additional methods that are known to be deterministic
-     * 
-     * @param methodNames 
+     *
+     * @param methodNames
      */
     public void addKnownDeterministicMethods(final Set<String> methodNames) {
         for (String known : methodNames) {
@@ -101,7 +99,7 @@ public class CandidacyStatus {
 
     /**
      * Getter method for candidate methods
-     * 
+     *
      * @param methodSignature
      * @return the candidate method corresponding to a method signature
      */
@@ -149,10 +147,10 @@ public class CandidacyStatus {
     }
 
     /**
-     * Increases the recursive depth of this classloading process, throwing a 
+     * Increases the recursive depth of this classloading process, throwing a
      * ClassNotFoundException if it becomes too high
-     * 
-     * @throws ClassNotFoundException 
+     *
+     * @throws ClassNotFoundException
      */
     public void incRecursiveCount() throws ClassNotFoundException {
         if (recursiveDepth >= MAX_CLASSLOADING_RECURSIVE_DEPTH - 1) {
@@ -174,7 +172,7 @@ public class CandidacyStatus {
                 out.add(candidateName);
             }
         }
-        
+
         return out;
     }
 
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/CandidateMethod.java b/experimental/sandbox/src/main/java/net/corda/sandbox/CandidateMethod.java
index 49e5091fbe..b806d58b65 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/CandidateMethod.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/CandidateMethod.java
@@ -6,15 +6,14 @@ import java.util.Set;
 
 /**
  * A candidate method that is under evaluation. Candidate methods have one of the following states:
- *
+ * <p>
  * <ul>
- *     <li>{@link CandidateMethod.State#DETERMINISTIC} - It's deterministic and therefore is allowed to be loaded.</li>
- *     <li>{@link CandidateMethod.State#DISALLOWED} - It's not deterministic and won't be allowed to be loaded.</li>
- *     <li>{@link CandidateMethod.State#SCANNED} - We're not sure if it's deterministic or not.</li>
+ * <li>{@link CandidateMethod.State#DETERMINISTIC} - It's deterministic and therefore is allowed to be loaded.</li>
+ * <li>{@link CandidateMethod.State#DISALLOWED} - It's not deterministic and won't be allowed to be loaded.</li>
+ * <li>{@link CandidateMethod.State#SCANNED} - We're not sure if it's deterministic or not.</li>
  * </ul>
- *
+ * <p>
  * CandidateMethods themselves reference other CandidateMethods which are be checked for their deterministic state
- *
  */
 public final class CandidateMethod {
 
@@ -43,7 +42,7 @@ public final class CandidateMethod {
 
     private final Set<CandidateMethod> referencedCandidateMethods = new HashSet<>();
 
-    
+
     public State getCurrentState() {
         return currentState;
     }
@@ -59,7 +58,7 @@ public final class CandidateMethod {
 
     public void deterministic() {
         if (currentState == State.DISALLOWED) {
-            throw new IllegalArgumentException("Method "+ internalMethodName +" attempted to transition from DISALLOWED to DETERMINISTIC");
+            throw new IllegalArgumentException("Method " + internalMethodName + " attempted to transition from DISALLOWED to DETERMINISTIC");
         }
         currentState = State.DETERMINISTIC;
     }
@@ -79,7 +78,7 @@ public final class CandidateMethod {
     public String getInternalMethodName() {
         return internalMethodName;
     }
-    
+
     public void addReferencedCandidateMethod(final CandidateMethod referenceCandidateMethod) {
         referencedCandidateMethods.add(referenceCandidateMethod);
     }
@@ -94,8 +93,9 @@ public final class CandidateMethod {
 
     /**
      * This factory constructor is only called for methods that are known to be deterministic in advance
+     *
      * @param methodSignature
-     * @return 
+     * @return
      */
     public static CandidateMethod proven(String methodSignature) {
         final CandidateMethod provenCandidateMethod = new CandidateMethod(methodSignature);
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxAwareClassWriter.java b/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxAwareClassWriter.java
index 03e3cf9d56..f5e742b95c 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxAwareClassWriter.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxAwareClassWriter.java
@@ -1,11 +1,11 @@
 package net.corda.sandbox;
 
 import static net.corda.sandbox.Utils.*;
+
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassWriter;
 
 /**
- *
  * @author ben
  */
 public final class SandboxAwareClassWriter extends ClassWriter {
@@ -25,17 +25,15 @@ public final class SandboxAwareClassWriter extends ClassWriter {
      * without actually loading any class, or to take into account the class
      * that is currently being generated by this ClassWriter, which can of
      * course not be loaded since it is under construction.
-     * 
-     * @param type1
-     *            the internal name of a class.
-     * @param type2
-     *            the internal name of another class.
+     *
+     * @param type1 the internal name of a class.
+     * @param type2 the internal name of another class.
      * @return the internal name of the common super class of the two given
-     *         classes.
+     * classes.
      */
     @Override
     public String getCommonSuperClass(final String type1, final String type2) {
-        if (OBJECT.equals(type1) || OBJECT.equals(type2) 
+        if (OBJECT.equals(type1) || OBJECT.equals(type2)
                 || OBJECT.equals(unsandboxNameIfNeedBe(type1)) || OBJECT.equals(unsandboxNameIfNeedBe(type2))) {
             return OBJECT;
         }
@@ -58,7 +56,7 @@ public final class SandboxAwareClassWriter extends ClassWriter {
             c = Class.forName(type1.replace('/', '.'), false, loader);
             d = Class.forName(type2.replace('/', '.'), false, loader);
         } catch (Exception e) {
-            
+
             c = Class.forName(unsandboxNameIfNeedBe(type1).replace('/', '.'), false, loader);
             d = Class.forName(unsandboxNameIfNeedBe(type2).replace('/', '.'), false, loader);
 
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxRemapper.java b/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxRemapper.java
index 2f55c4edb6..32157b6ff5 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxRemapper.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxRemapper.java
@@ -3,7 +3,6 @@ package net.corda.sandbox;
 import org.objectweb.asm.commons.Remapper;
 
 /**
- *
  * @author ben
  */
 public final class SandboxRemapper extends Remapper {
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/Utils.java b/experimental/sandbox/src/main/java/net/corda/sandbox/Utils.java
index 85fa4fc078..08cbbd794b 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/Utils.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/Utils.java
@@ -4,7 +4,6 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
- *
  * @author ben
  */
 public final class Utils {
@@ -12,7 +11,7 @@ public final class Utils {
     public final static String SANDBOX_PREFIX_INTERNAL = "sandbox/";
 
     public final static String CLASSFILE_NAME_SUFFIX = "^(.*)\\.class$";
-    
+
     public static final Pattern JAVA_LANG_PATTERN_INTERNAL = Pattern.compile("^java/lang/(.*)");
 
     public static final Pattern SANDBOX_PATTERN_INTERNAL = Pattern.compile("^" + SANDBOX_PREFIX_INTERNAL + "(.*)");
@@ -28,13 +27,13 @@ public final class Utils {
     public static final Pattern CLASSNAME_PATTERN_QUALIFIED = Pattern.compile("([^\\.]+)\\.");
 
     public static final String OBJECT = "java/lang/Object";
-    
+
     public static final String THROWABLE = "java/lang/Throwable";
-    
+
     public static final String ERROR = "java/lang/Error";
-    
+
     public static final String THREAD_DEATH = "java/lang/ThreadDeath";
-    
+
     // Hide constructor
     private Utils() {
     }
@@ -43,6 +42,7 @@ public final class Utils {
      * Helper method that converts from the internal class name format (as used in the
      * Constant Pool) to a fully-qualified class name. No obvious library method to do this
      * appears to exist, hence this code. If one exists, rip this out.
+     *
      * @param classInternalName
      * @return
      */
@@ -52,12 +52,11 @@ public final class Utils {
     }
 
     /**
-     * This method takes in an internal method name but needs to return a qualified 
+     * This method takes in an internal method name but needs to return a qualified
      * classname (suitable for loading)
-     * 
-     * 
+     *
      * @param internalMethodName
-     * @return 
+     * @return
      */
     public static String convertInternalMethodNameToQualifiedClassName(final String internalMethodName) {
         final Matcher classMatch = CLASSNAME_PATTERN_QUALIFIED.matcher(internalMethodName);
@@ -72,6 +71,7 @@ public final class Utils {
      * Helper method that converts from a fully-qualified class name to the internal class
      * name format (as used in the Constant Pool). No obvious library method to do this
      * appears to exist, hence this code. If one exists, rip this out.
+     *
      * @param qualifiedClassName
      * @return
      */
@@ -81,7 +81,7 @@ public final class Utils {
     }
 
     /**
-     * This method potentially rewrites the classname. 
+     * This method potentially rewrites the classname.
      *
      * @param internalClassname - specified in internal form
      * @return
@@ -102,9 +102,8 @@ public final class Utils {
     }
 
     /**
-     * 
      * @param qualifiedTypeName
-     * @return 
+     * @return
      */
     public static String sandboxQualifiedTypeName(final String qualifiedTypeName) {
         final String internal = convertQualifiedClassNameToInternalForm(qualifiedTypeName);
@@ -118,7 +117,7 @@ public final class Utils {
     /**
      * This method removes the sandboxing prefix from a method or type name, if it has
      * one, otherwise it returns the input string.
-     * 
+     *
      * @param internalClassname
      * @return the internal classname, unsandboxed if that was required
      */
@@ -131,7 +130,6 @@ public final class Utils {
     }
 
     /**
-     * 
      * @param desc - internal
      * @return the rewritten desc string
      */
@@ -169,9 +167,9 @@ public final class Utils {
      * loading. This should not attempt to load a classname that starts with java. as
      * the only permissable classes have already been transformed into sandboxed
      * methods
-     * 
+     *
      * @param qualifiedClassName
-     * @return 
+     * @return
      */
     public static boolean shouldAttemptToTransitivelyLoad(final String qualifiedClassName) {
         return !JAVA_PATTERN_QUALIFIED.asPredicate().test(qualifiedClassName);
@@ -179,7 +177,7 @@ public final class Utils {
 
     /**
      * Helper method that determines whether this class requires sandboxing
-     * 
+     *
      * @param clazzName - specified in internal form
      * @return true if the class should be sandboxed
      */
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassLoader.java b/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassLoader.java
index 171c2770f9..2a99ffbdca 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassLoader.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassLoader.java
@@ -2,6 +2,7 @@ package net.corda.sandbox;
 
 import net.corda.sandbox.visitors.CostInstrumentingMethodVisitor;
 import net.corda.sandbox.visitors.WhitelistCheckingClassVisitor;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URI;
@@ -9,13 +10,13 @@ import java.net.URISyntaxException;
 import java.net.URL;
 import java.nio.file.*;
 import java.util.*;
+
 import org.objectweb.asm.*;
 import org.objectweb.asm.commons.ClassRemapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
- *
  * @author ben
  */
 public final class WhitelistClassLoader extends ClassLoader {
@@ -61,8 +62,8 @@ public final class WhitelistClassLoader extends ClassLoader {
     }
 
     /**
-     * Static factory method. Throws URISyntaxException currently, as this method is 
-     * called with user data, so a checked exception is not unreasonable. Could use a 
+     * Static factory method. Throws URISyntaxException currently, as this method is
+     * called with user data, so a checked exception is not unreasonable. Could use a
      * runtime exception instead.
      *
      * @param auxiliaryClassPath
@@ -70,7 +71,7 @@ public final class WhitelistClassLoader extends ClassLoader {
      *                              methods to be deterministic, instead the classloader
      *                              will remove all non-deterministic methods.
      * @return a suitably constructed whitelisting classloader
-     * @throws URISyntaxException 
+     * @throws URISyntaxException
      */
     public static WhitelistClassLoader of(final String auxiliaryClassPath, final boolean stripNonDeterministic) throws URISyntaxException {
         final WhitelistClassLoader out = new WhitelistClassLoader(stripNonDeterministic);
@@ -96,10 +97,10 @@ public final class WhitelistClassLoader extends ClassLoader {
 
     /**
      * Static factory method. Used for recursive classloading
-     * 
+     *
      * @param other
      * @return a suitably constructed whitelisting classloader based on the state
-     *         of the passed classloader
+     * of the passed classloader
      */
     public static WhitelistClassLoader of(final WhitelistClassLoader other) {
         final WhitelistClassLoader out = new WhitelistClassLoader(other);
@@ -110,7 +111,7 @@ public final class WhitelistClassLoader extends ClassLoader {
     /**
      * Helper method that adds a jar to the path to be searched
      *
-     * @param knownGoodJar 
+     * @param knownGoodJar
      */
     void addJarToSandbox(final Path knownGoodJar) {
         fileSystemSearchPath.add(knownGoodJar);
@@ -120,9 +121,9 @@ public final class WhitelistClassLoader extends ClassLoader {
      * Setup the auxiliary classpath so that classes that are not on the original
      * classpath can be scanned for.
      * Note that this this method hardcodes Unix conventions, so won't work on e.g. Windows
-     * 
+     *
      * @param auxiliaryClassPath
-     * @throws URISyntaxException 
+     * @throws URISyntaxException
      */
     void setupClasspath(final String auxiliaryClassPath) throws URISyntaxException {
         for (String entry : auxiliaryClassPath.split(":")) {
@@ -136,11 +137,10 @@ public final class WhitelistClassLoader extends ClassLoader {
     }
 
     /**
-     * 
      * @param qualifiedClassName
      * @return a class object that has been whitelist checked and is known to be
-     *         deterministic
-     * @throws ClassNotFoundException 
+     * deterministic
+     * @throws ClassNotFoundException
      */
     @Override
     public Class<?> findClass(final String qualifiedClassName) throws ClassNotFoundException {
@@ -244,10 +244,10 @@ public final class WhitelistClassLoader extends ClassLoader {
      * around a limitation of the ASM library that does not integrate cleanly with Java 7
      * NIO.2 Path APIs. This method also performs a couple of basic sanity check on the
      * class file (e.g. that it exists, is a regular file and is readable).
-     * 
+     *
      * @param internalClassName
      * @return a path object that corresponds to a class that has been found
-     * @throws ClassNotFoundException 
+     * @throws ClassNotFoundException
      */
     Path locateClassfileDir(final String internalClassName) throws ClassNotFoundException {
         // Check the primaryClasspathSearchPath
@@ -300,7 +300,7 @@ public final class WhitelistClassLoader extends ClassLoader {
     /**
      * Creates a jar archive of all the transformed classes that this classloader
      * has loaded.
-     * 
+     *
      * @return true on success, false on failure
      * @throws java.io.IOException
      * @throws java.net.URISyntaxException
@@ -328,7 +328,8 @@ public final class WhitelistClassLoader extends ClassLoader {
 
     /**
      * Getter method for the reason for failure
-     * @return 
+     *
+     * @return
      */
     public WhitelistClassloadingException reason() {
         return candidacyStatus.getReason();
@@ -336,7 +337,8 @@ public final class WhitelistClassLoader extends ClassLoader {
 
     /**
      * Getter method for the method candidacy status
-     * @return 
+     *
+     * @return
      */
     public CandidacyStatus getCandidacyStatus() {
         return candidacyStatus;
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassloadingException.java b/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassloadingException.java
index 5f6c13ca9f..9705d4bf0e 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassloadingException.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassloadingException.java
@@ -4,7 +4,7 @@ package net.corda.sandbox;
  *
  */
 public class WhitelistClassloadingException extends Exception {
-    
+
     public WhitelistClassloadingException() {
         super();
     }
@@ -22,10 +22,10 @@ public class WhitelistClassloadingException extends Exception {
     }
 
     protected WhitelistClassloadingException(String message, Throwable cause,
-                        boolean enableSuppression,
-                        boolean writableStackTrace) {
+                                             boolean enableSuppression,
+                                             boolean writableStackTrace) {
         super(message, cause, enableSuppression, writableStackTrace);
     }
 
-    
+
 }
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/Contract.java b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/Contract.java
index ec098ecfbd..f20aaa0b79 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/Contract.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/Contract.java
@@ -5,7 +5,7 @@ import org.slf4j.LoggerFactory;
 
 /**
  * This class is the runtime representation of a running contract.
- * 
+ *
  * @author ben
  */
 public class Contract {
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/ContractExecutor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/ContractExecutor.java
index 243a3ddf11..5b719978a4 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/ContractExecutor.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/ContractExecutor.java
@@ -3,17 +3,17 @@ package net.corda.sandbox.costing;
 /**
  * This interface is to decouple the actual executable code from the entry point and
  * how vetted deterministic code will be used inside the sandbox
- * 
+ *
  * @author ben
  */
 public interface ContractExecutor {
     /**
      * Executes a smart contract
-     * 
+     *
      * @param contract the contract to be executed
      */
     void execute(Contract contract);
-    
+
     /**
      * Checks to see if the supplied Contract is suitable
      *
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/RuntimeCostAccounter.java b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/RuntimeCostAccounter.java
index f00c39defa..7274d914c7 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/RuntimeCostAccounter.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/RuntimeCostAccounter.java
@@ -4,7 +4,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
- *
  * @author ben
  */
 public class RuntimeCostAccounter {
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/tools/SandboxCreator.java b/experimental/sandbox/src/main/java/net/corda/sandbox/tools/SandboxCreator.java
index 01b0906dc2..33ab308a2e 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/tools/SandboxCreator.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/tools/SandboxCreator.java
@@ -2,6 +2,7 @@ package net.corda.sandbox.tools;
 
 import net.corda.sandbox.WhitelistClassLoader;
 import net.corda.sandbox.visitors.SandboxPathVisitor;
+
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.net.URISyntaxException;
@@ -18,7 +19,6 @@ import joptsimple.OptionSet;
  * This class takes in an exploded set of JRE classes, and a whitelist, and rewrites all
  * classes (note: not methods) that have at least one whitelisted method to create a
  * sandboxed version of the class.
- *
  */
 // java8.scan.java.lang_and_util java8.interfaces_for_compat java8 sandbox
 public final class SandboxCreator {
@@ -30,7 +30,7 @@ public final class SandboxCreator {
     private final String outputJarName;
     private final WhitelistClassLoader wlcl;
     private final boolean hasInputJar;
-    
+
     private final static OptionParser parser = new OptionParser();
 
     private static void usage() {
@@ -53,7 +53,7 @@ public final class SandboxCreator {
 
     static String unpackJar(final String zipFilePath) throws IOException {
         final Path tmpDir = Files.createTempDirectory(Paths.get("/tmp"), "wlcl-extract");
-        
+
         try (final ZipInputStream zipIn = new ZipInputStream(new FileInputStream(zipFilePath))) {
             ZipEntry entry = zipIn.getNextEntry();
 
@@ -68,13 +68,13 @@ public final class SandboxCreator {
                 entry = zipIn.getNextEntry();
             }
         }
-        
+
         return tmpDir.toString();
     }
-    
+
     void cleanup() {
         if (hasInputJar) {
-            
+
         }
     }
 
@@ -107,10 +107,9 @@ public final class SandboxCreator {
     }
 
     /**
-     * 
      * @param basePath
      * @param packageName
-     * @throws IOException 
+     * @throws IOException
      */
     void walk() throws IOException {
         final Path scanDir = Paths.get(basePathName);
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/CostInstrumentingMethodVisitor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/CostInstrumentingMethodVisitor.java
index 5f7dc3fdea..8b108fed89 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/CostInstrumentingMethodVisitor.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/CostInstrumentingMethodVisitor.java
@@ -9,7 +9,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
- *
  * @author ben
  */
 public final class CostInstrumentingMethodVisitor extends GeneratorAdapter {
@@ -34,9 +33,10 @@ public final class CostInstrumentingMethodVisitor extends GeneratorAdapter {
     }
 
     /**
-     * This method replaces MONITORENTER / MONITOREXIT opcodes with POP - basically 
+     * This method replaces MONITORENTER / MONITOREXIT opcodes with POP - basically
      * stripping the synchronization out of any sandboxed code.
-     * @param opcode 
+     *
+     * @param opcode
      */
     @Override
     public void visitInsn(final int opcode) {
@@ -60,7 +60,7 @@ public final class CostInstrumentingMethodVisitor extends GeneratorAdapter {
      * For our purposes this is a NEWARRAY opcode.
      *
      * @param opcode
-     * @param operand 
+     * @param operand
      */
     @Override
     public void visitIntInsn(final int opcode, final int operand) {
@@ -103,11 +103,11 @@ public final class CostInstrumentingMethodVisitor extends GeneratorAdapter {
     /**
      * This method is called when visiting an opcode with a single operand, that
      * is a type (represented here as a String).
-     *
+     * <p>
      * For our purposes this is either a NEW opcode or a ANEWARRAY
      *
-     * @param opcode 
-     * @param type 
+     * @param opcode
+     * @param type
      */
     @Override
     public void visitTypeInsn(final int opcode, final String type) {
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/DefinitelyDisallowedMethodVisitor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/DefinitelyDisallowedMethodVisitor.java
index 62b882f269..d4ade3415a 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/DefinitelyDisallowedMethodVisitor.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/DefinitelyDisallowedMethodVisitor.java
@@ -11,5 +11,5 @@ class DefinitelyDisallowedMethodVisitor extends MethodVisitor {
     DefinitelyDisallowedMethodVisitor(MethodVisitor baseMethodVisitor) {
         super(Opcodes.ASM5, baseMethodVisitor);
     }
-    
+
 }
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/SandboxPathVisitor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/SandboxPathVisitor.java
index bdc81bf995..e5528acbd9 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/SandboxPathVisitor.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/SandboxPathVisitor.java
@@ -2,15 +2,17 @@ package net.corda.sandbox.visitors;
 
 import net.corda.sandbox.Utils;
 import net.corda.sandbox.WhitelistClassLoader;
+
 import java.nio.file.*;
 import java.nio.file.attribute.BasicFileAttributes;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
  * This helper class visits each file (represented as a Path) in some directory
  * tree containing classes to be sandboxed.
- * 
+ *
  * @author ben
  */
 public final class SandboxPathVisitor extends SimpleFileVisitor<Path> {
@@ -30,10 +32,10 @@ public final class SandboxPathVisitor extends SimpleFileVisitor<Path> {
     public FileVisitResult visitFile(final Path path, final BasicFileAttributes attr) {
         // Check that this is a class file
         if (!path.toString().matches(Utils.CLASSFILE_NAME_SUFFIX)) {
-            System.out.println("Skipping: "+ path);
+            System.out.println("Skipping: " + path);
             return FileVisitResult.CONTINUE;
         }
-        
+
         // Check to see if this path corresponds to an allowedClass
         final String classFileName = startFrom.relativize(path).toString().replace(".class", "");
 
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingClassVisitor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingClassVisitor.java
index 5994b445a6..534c89bc6b 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingClassVisitor.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingClassVisitor.java
@@ -2,10 +2,12 @@ package net.corda.sandbox.visitors;
 
 import net.corda.sandbox.WhitelistClassLoader;
 import net.corda.sandbox.CandidacyStatus;
+
 import java.util.Arrays;
 
 import net.corda.sandbox.CandidateMethod;
 import net.corda.sandbox.Utils;
+
 import java.util.HashSet;
 import java.util.Set;
 
@@ -14,6 +16,7 @@ import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import static org.objectweb.asm.Opcodes.*;
 
 /**
@@ -57,7 +60,7 @@ public final class WhitelistCheckingClassVisitor extends ClassVisitor {
     /**
      * We initially take the method passed in and store an internal representation of
      * the method signature in the our CandidacyStatus working set.
-     *
+     * <p>
      * We then get an ASM MethodVisitor (which can read the byte code of the method) and pass that to our
      * custom method visitor which perform additional checks.
      *
@@ -66,7 +69,7 @@ public final class WhitelistCheckingClassVisitor extends ClassVisitor {
      * @param desc
      * @param signature
      * @param exceptions
-     * @return 
+     * @return
      */
     @Override
     public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) {
@@ -77,7 +80,7 @@ public final class WhitelistCheckingClassVisitor extends ClassVisitor {
         // Force new access control flags - for now just strictfp for deterministic
         // compliance to IEEE 754
         final int maskedAccess = access | ACC_STRICT;
-        
+
         final String internalName = classname + "." + name + ":" + desc;
         internalMethodNames.add(internalName);
         candidacyStatus.putIfAbsent(internalName);
@@ -151,10 +154,10 @@ public final class WhitelistCheckingClassVisitor extends ClassVisitor {
     }
 
     /**
-     * Take the name of a class and attempts to load it using a WLCL. 
-     * 
+     * Take the name of a class and attempts to load it using a WLCL.
+     *
      * @param qualifiedClassname
-     * @return 
+     * @return
      */
     CandidateMethod.State resolveState(final String qualifiedClassname) {
         Class<?> clz = null;
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingMethodVisitor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingMethodVisitor.java
index 28338f5285..0d392f342b 100644
--- a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingMethodVisitor.java
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingMethodVisitor.java
@@ -13,7 +13,6 @@ import org.objectweb.asm.Label;
 /**
  * A MethodVisitor which checks method instructions in order to determine if this
  * method is deterministic or not
- *
  */
 final class WhitelistCheckingMethodVisitor extends MethodVisitor {
 
@@ -29,7 +28,7 @@ final class WhitelistCheckingMethodVisitor extends MethodVisitor {
     }
 
     /**
-     * Visits a method instruction. A method instruction is an instruction that 
+     * Visits a method instruction. A method instruction is an instruction that
      * invokes a method.
      * <p>
      * Some method instructions are by their nature un-deterministic, so we set those methods to have a
@@ -84,15 +83,15 @@ final class WhitelistCheckingMethodVisitor extends MethodVisitor {
     }
 
     /**
-     * Currently a no-op. 
-     *
+     * Currently a no-op.
+     * <p>
      * The JVMspec seems to permit the possibility of using a backwards branch in a
-     * tableswitch to try to create an infinite loop. However, it seems to be 
+     * tableswitch to try to create an infinite loop. However, it seems to be
      * impossible in practice - the specification of StackMapFrame seems to prevent
      * it in modern classfile formats, and even by explicitly generating a version
      * 49 (Java 5) classfile, the verifier seems to be specifically resistant to a
-     * backwards branch from a tableswitch. 
-     * 
+     * backwards branch from a tableswitch.
+     * <p>
      * We could still add a belt-and-braces static instrumentation to protect
      * against this but it currently seems unnecessary - at worse it is a branch that
      * should count against the branch limit, or an explicit disallow of a backwards
@@ -102,7 +101,7 @@ final class WhitelistCheckingMethodVisitor extends MethodVisitor {
      * @param min
      * @param max
      * @param dflt
-     * @param labels 
+     * @param labels
      */
     @Override
     public void visitTableSwitchInsn(int min, int max, Label dflt, Label... labels) {
@@ -112,11 +111,11 @@ final class WhitelistCheckingMethodVisitor extends MethodVisitor {
     /**
      * Visits an invokedynamic instruction - which is specifically disallowed for
      * deterministic apps.
-     * 
+     *
      * @param name
      * @param desc
      * @param bsm
-     * @param bsmArgs 
+     * @param bsmArgs
      */
     @Override
     public void visitInvokeDynamicInsn(final String name, final String desc, final Handle bsm, final Object... bsmArgs) {
diff --git a/experimental/sandbox/src/main/java/sandbox/net/corda/sandbox/costing/RuntimeCostAccounter.java b/experimental/sandbox/src/main/java/sandbox/net/corda/sandbox/costing/RuntimeCostAccounter.java
index 7acc1f445d..22e895c41b 100644
--- a/experimental/sandbox/src/main/java/sandbox/net/corda/sandbox/costing/RuntimeCostAccounter.java
+++ b/experimental/sandbox/src/main/java/sandbox/net/corda/sandbox/costing/RuntimeCostAccounter.java
@@ -4,7 +4,7 @@ package sandbox.net.corda.sandbox.costing;
  * A helper class that just forwards any static sandboxed calls to the real runtime
  * cost accounting class. This removes the need to special case the accounting
  * method calls during rewriting of method names
- * 
+ *
  * @author ben
  */
 public class RuntimeCostAccounter {
diff --git a/experimental/sandbox/src/test/java/net/corda/sandbox/TestUtils.java b/experimental/sandbox/src/test/java/net/corda/sandbox/TestUtils.java
index d8e0fd0007..16cbda6e84 100644
--- a/experimental/sandbox/src/test/java/net/corda/sandbox/TestUtils.java
+++ b/experimental/sandbox/src/test/java/net/corda/sandbox/TestUtils.java
@@ -22,7 +22,7 @@ public class TestUtils {
         // Copy resource jar to tmp dir
         tmpdir = Files.createTempDirectory("wlcl-tmp-test");
         Path copiedJar = tmpdir.resolve("tmp-resource.jar");
-        try(final InputStream in = TestUtils.class.getResourceAsStream(resourcePathToJar)) {
+        try (final InputStream in = TestUtils.class.getResourceAsStream(resourcePathToJar)) {
             Files.copy(in, copiedJar, StandardCopyOption.REPLACE_EXISTING);
         }
         final FileSystem fs = FileSystems.newFileSystem(copiedJar, null);
@@ -33,20 +33,20 @@ public class TestUtils {
     public static Path copySandboxJarToTmpDir(final String resourcePathToJar) throws IOException {
 
         Path sandboxJar = tmpdir.resolve("tmp-sandbox.jar");
-        try(final InputStream in = TestUtils.class.getResourceAsStream(resourcePathToJar)) {
+        try (final InputStream in = TestUtils.class.getResourceAsStream(resourcePathToJar)) {
             Files.copy(in, sandboxJar, StandardCopyOption.REPLACE_EXISTING);
         }
         final FileSystem sandboxFs = FileSystems.newFileSystem(sandboxJar, null);
         tmpFileSystems.add(sandboxFs);
         return sandboxFs.getRootDirectories().iterator().next();
     }
-    
+
     public static Path getJarFSRoot() {
         return jarFSDir;
     }
 
     public static void cleanupTmpJar() throws IOException {
-        for (FileSystem fs: tmpFileSystems) {
+        for (FileSystem fs : tmpFileSystems) {
             fs.close();
         }
         tmpFileSystems.clear();
@@ -92,15 +92,15 @@ public class TestUtils {
     // Helper for finding the correct offsets if they change
     public static void printBytes(byte[] data) {
         byte[] datum = new byte[1];
-        for (int i=0; i < data.length; i++) {
+        for (int i = 0; i < data.length; i++) {
             datum[0] = data[i];
-            System.out.println(i +" : "+ DatatypeConverter.printHexBinary(datum));
+            System.out.println(i + " : " + DatatypeConverter.printHexBinary(datum));
         }
     }
 
     public static int findOffset(byte[] classBytes, byte[] originalSeq) {
         int offset = 0;
-        for (int i=415; i < classBytes.length; i++) {
+        for (int i = 415; i < classBytes.length; i++) {
             if (classBytes[i] != originalSeq[offset]) {
                 offset = 0;
                 continue;
@@ -110,7 +110,7 @@ public class TestUtils {
             }
             offset++;
         }
-        
+
         return -1;
     }
 
@@ -119,7 +119,7 @@ public class TestUtils {
         return wlcl.instrumentWithCosts(basic, hashSet);
     }
 
-    
+
     public static final class MyClassloader extends ClassLoader {
 
         public Class<?> byPath(Path p) throws IOException {
diff --git a/experimental/sandbox/src/test/java/net/corda/sandbox/WhitelistClassLoaderTest.java b/experimental/sandbox/src/test/java/net/corda/sandbox/WhitelistClassLoaderTest.java
index 91d455b0d2..bcc5e94172 100644
--- a/experimental/sandbox/src/test/java/net/corda/sandbox/WhitelistClassLoaderTest.java
+++ b/experimental/sandbox/src/test/java/net/corda/sandbox/WhitelistClassLoaderTest.java
@@ -1,10 +1,13 @@
 package net.corda.sandbox;
 
 import static org.junit.Assert.*;
+
 import org.junit.Test;
+
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.concurrent.atomic.AtomicBoolean;
+
 import org.junit.*;
 
 public class WhitelistClassLoaderTest {
@@ -123,8 +126,8 @@ public class WhitelistClassLoaderTest {
         final Class<?> clz = wlcl.loadClass("resource.ThrowExceptions");
         assertNotNull("ThrowExceptions class could not be transformed and loaded", clz);
     }
-  
-    
+
+
     // TODO Test cases that terminate when other resource limits are broken
     @Test
     public void when_too_much_memory_is_allocated_then_thread_dies() throws Exception {
diff --git a/experimental/sandbox/src/test/java/net/corda/sandbox/costing/DeterministicClassInstrumenterTest.java b/experimental/sandbox/src/test/java/net/corda/sandbox/costing/DeterministicClassInstrumenterTest.java
index c276907870..15130086d3 100644
--- a/experimental/sandbox/src/test/java/net/corda/sandbox/costing/DeterministicClassInstrumenterTest.java
+++ b/experimental/sandbox/src/test/java/net/corda/sandbox/costing/DeterministicClassInstrumenterTest.java
@@ -11,7 +11,6 @@ import java.util.*;
 import static org.junit.Assert.*;
 
 /**
- *
  * @author ben
  */
 public class DeterministicClassInstrumenterTest {
@@ -66,7 +65,7 @@ public class DeterministicClassInstrumenterTest {
 //        TestUtils.printBytes(basic);
         final int origOffset = TestUtils.findOffset(basic, originalSeq);
         final int tmfdOffset = TestUtils.findOffset(tfmd, tfmdSeq);
-        
+
         for (int i = 0; i < originalSeq.length; i++) {
             assertEquals(originalSeq[i], basic[origOffset + i]);
             assertEquals(tfmdSeq[i], tfmd[tmfdOffset + i]);
diff --git a/experimental/sandbox/src/test/java/net/corda/sandbox/costing/SandboxedRewritingTest.java b/experimental/sandbox/src/test/java/net/corda/sandbox/costing/SandboxedRewritingTest.java
index 15bd7dafe2..16b3972390 100644
--- a/experimental/sandbox/src/test/java/net/corda/sandbox/costing/SandboxedRewritingTest.java
+++ b/experimental/sandbox/src/test/java/net/corda/sandbox/costing/SandboxedRewritingTest.java
@@ -1,19 +1,24 @@
 package net.corda.sandbox.costing;
 
 import net.corda.sandbox.TestUtils;
+
 import static net.corda.sandbox.TestUtils.*;
+
 import net.corda.sandbox.Utils;
+
 import java.io.IOException;
 import java.lang.reflect.Method;
 import java.net.URISyntaxException;
+
 import org.junit.AfterClass;
 import org.junit.Test;
+
 import static org.junit.Assert.*;
+
 import org.junit.Before;
 import org.junit.BeforeClass;
 
 /**
- *
  * @author ben
  */
 public class SandboxedRewritingTest {
diff --git a/experimental/sandbox/src/test/java/sandbox/greymalkin/StringReturner.java b/experimental/sandbox/src/test/java/sandbox/greymalkin/StringReturner.java
index e0aee3b576..d34132570e 100644
--- a/experimental/sandbox/src/test/java/sandbox/greymalkin/StringReturner.java
+++ b/experimental/sandbox/src/test/java/sandbox/greymalkin/StringReturner.java
@@ -1,7 +1,6 @@
 package sandbox.greymalkin;
 
 /**
- *
  * @author ben
  */
 // Simple hack for now, generalise to lambdas later...

From 7a372bed593a1e6588a56ffc2b55c35dbe15e42d Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 15:20:22 +0100
Subject: [PATCH 124/185] Reformat files in `finance`

---
 .../kotlin/net/corda/finance/Currencies.kt    | 18 +++++---
 .../finance/contracts/CommercialPaper.kt      |  4 +-
 .../corda/finance/contracts/FinanceTypes.kt   |  2 +-
 .../net/corda/finance/contracts/asset/Cash.kt | 15 +++++--
 .../contracts/asset/CommodityContract.kt      |  5 ++-
 .../finance/contracts/asset/Obligation.kt     |  9 ++--
 .../finance/contracts/asset/OnLedgerAsset.kt  | 42 +++++++++----------
 .../cash/selection/CashSelectionH2Impl.kt     | 10 ++---
 .../cash/selection/CashSelectionMySQLImpl.kt  |  2 +-
 .../net/corda/finance/flows/CashExitFlow.kt   |  2 +-
 .../finance/flows/CashIssueAndPaymentFlow.kt  |  1 +
 .../net/corda/finance/flows/CashIssueFlow.kt  |  1 +
 .../corda/finance/flows/CashPaymentFlow.kt    |  2 +
 .../corda/finance/flows/TwoPartyDealFlow.kt   |  4 +-
 .../corda/finance/flows/TwoPartyTradeFlow.kt  |  1 +
 .../net/corda/finance/schemas/CashSchemaV1.kt |  4 +-
 .../schemas/CommercialPaperSchemaV1.kt        |  6 +--
 .../finance/utils/StateSummingUtilities.kt    |  1 +
 .../contracts/asset/CashTestsJava.java        |  2 +-
 .../finance/contracts/CommercialPaperTests.kt |  5 ++-
 .../finance/contracts/asset/CashTests.kt      | 30 ++++++-------
 .../contracts/asset/ObligationTests.kt        |  4 +-
 .../corda/finance/flows/CashExitFlowTests.kt  |  2 +-
 .../corda/finance/flows/CashIssueFlowTests.kt |  2 +-
 .../finance/flows/CashPaymentFlowTests.kt     |  2 +-
 .../finance/schemas/SampleCashSchemaV1.kt     |  4 +-
 .../finance/schemas/SampleCashSchemaV2.kt     | 34 +++++++--------
 .../finance/schemas/SampleCashSchemaV3.kt     |  2 +-
 .../schemas/SampleCommercialPaperSchemaV1.kt  |  6 +--
 .../schemas/SampleCommercialPaperSchemaV2.kt  |  6 +--
 30 files changed, 128 insertions(+), 100 deletions(-)

diff --git a/finance/src/main/kotlin/net/corda/finance/Currencies.kt b/finance/src/main/kotlin/net/corda/finance/Currencies.kt
index 906e01d8af..75bb50cd83 100644
--- a/finance/src/main/kotlin/net/corda/finance/Currencies.kt
+++ b/finance/src/main/kotlin/net/corda/finance/Currencies.kt
@@ -8,12 +8,18 @@ import net.corda.core.contracts.PartyAndReference
 import java.math.BigDecimal
 import java.util.*
 
-@JvmField val USD: Currency = Currency.getInstance("USD")
-@JvmField val GBP: Currency = Currency.getInstance("GBP")
-@JvmField val EUR: Currency = Currency.getInstance("EUR")
-@JvmField val CHF: Currency = Currency.getInstance("CHF")
-@JvmField val JPY: Currency = Currency.getInstance("JPY")
-@JvmField val RUB: Currency = Currency.getInstance("RUB")
+@JvmField
+val USD: Currency = Currency.getInstance("USD")
+@JvmField
+val GBP: Currency = Currency.getInstance("GBP")
+@JvmField
+val EUR: Currency = Currency.getInstance("EUR")
+@JvmField
+val CHF: Currency = Currency.getInstance("CHF")
+@JvmField
+val JPY: Currency = Currency.getInstance("JPY")
+@JvmField
+val RUB: Currency = Currency.getInstance("RUB")
 
 fun <T : Any> AMOUNT(amount: Int, token: T): Amount<T> = AMOUNT(amount.toLong(), token)
 fun <T : Any> AMOUNT(amount: Long, token: T): Amount<T> = Amount.fromDecimal(BigDecimal.valueOf(amount), token)
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/CommercialPaper.kt b/finance/src/main/kotlin/net/corda/finance/contracts/CommercialPaper.kt
index f7fcdc3e69..1c302480f3 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/CommercialPaper.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/CommercialPaper.kt
@@ -49,6 +49,7 @@ class CommercialPaper : Contract {
     companion object {
         const val CP_PROGRAM_ID: ContractClassName = "net.corda.finance.contracts.CommercialPaper"
     }
+
     data class State(
             val issuance: PartyAndReference,
             override val owner: AbstractParty,
@@ -89,7 +90,8 @@ class CommercialPaper : Contract {
             }
         }
 
-        /** @suppress */ infix fun `owned by`(owner: AbstractParty) = copy(owner = owner)
+        /** @suppress */
+        infix fun `owned by`(owner: AbstractParty) = copy(owner = owner)
     }
 
     interface Commands : CommandData {
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt b/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
index 1079beeccc..be6ada5492 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt
@@ -202,7 +202,7 @@ enum class Frequency(val annualCompoundCount: Int, val offset: LocalDate.(Long)
  * no staff are around to handle problems.
  */
 @CordaSerializable
-open class BusinessCalendar (val holidayDates: List<LocalDate>) {
+open class BusinessCalendar(val holidayDates: List<LocalDate>) {
     @CordaSerializable
     class UnknownCalendar(name: String) : FlowException("$name not found")
 
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt
index 9a578b7ff2..13e1725c09 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt
@@ -401,10 +401,17 @@ class Cash : OnLedgerAsset<Currency, Cash.Commands, Cash.State>() {
 
 // Small DSL extensions.
 
-/** @suppress */ infix fun Cash.State.`owned by`(owner: AbstractParty) = ownedBy(owner)
-/** @suppress */ infix fun Cash.State.`issued by`(party: AbstractParty) = issuedBy(party)
-/** @suppress */ infix fun Cash.State.`issued by`(deposit: PartyAndReference) = issuedBy(deposit)
-/** @suppress */ infix fun Cash.State.`with deposit`(deposit: PartyAndReference): Cash.State = withDeposit(deposit)
+/** @suppress */
+infix fun Cash.State.`owned by`(owner: AbstractParty) = ownedBy(owner)
+
+/** @suppress */
+infix fun Cash.State.`issued by`(party: AbstractParty) = issuedBy(party)
+
+/** @suppress */
+infix fun Cash.State.`issued by`(deposit: PartyAndReference) = issuedBy(deposit)
+
+/** @suppress */
+infix fun Cash.State.`with deposit`(deposit: PartyAndReference): Cash.State = withDeposit(deposit)
 
 // Unit testing helpers. These could go in a separate file but it's hardly worth it for just a few functions.
 
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/CommodityContract.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/CommodityContract.kt
index bf31292c69..052223b7e4 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/CommodityContract.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/CommodityContract.kt
@@ -44,6 +44,7 @@ class CommodityContract : OnLedgerAsset<Commodity, CommodityContract.Commands, C
     ) : FungibleAsset<Commodity> {
         constructor(deposit: PartyAndReference, amount: Amount<Commodity>, owner: AbstractParty)
                 : this(Amount(amount.quantity, Issued(deposit, amount.token)), owner)
+
         override val exitKeys: Set<PublicKey> = Collections.singleton(owner.owningKey)
         override val participants = listOf(owner)
 
@@ -91,7 +92,7 @@ class CommodityContract : OnLedgerAsset<Commodity, CommodityContract.Commands, C
             val party = issuer.party
 
             requireThat {
-                "there are no zero sized outputs" using ( outputs.none { it.amount.quantity == 0L } )
+                "there are no zero sized outputs" using (outputs.none { it.amount.quantity == 0L })
             }
 
             val issueCommand = tx.commands.select<Commands.Issue>().firstOrNull()
@@ -107,7 +108,7 @@ class CommodityContract : OnLedgerAsset<Commodity, CommodityContract.Commands, C
                 val amountExitingLedger = exitCommand?.value?.amount ?: Amount(0, Issued(issuer, commodity))
 
                 requireThat {
-                    "there are no zero sized inputs" using ( inputs.none { it.amount.quantity == 0L } )
+                    "there are no zero sized inputs" using (inputs.none { it.amount.quantity == 0L })
                     "for reference ${issuer.reference} at issuer ${party.nameOrNull()} the amounts balance" using
                             (inputAmount == outputAmount + amountExitingLedger)
                 }
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt
index 38371297bb..e5d45f6d51 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt
@@ -73,6 +73,7 @@ class Obligation<P : Any> : Contract {
     companion object {
         const val PROGRAM_ID: ContractClassName = "net.corda.finance.contracts.asset.Obligation"
     }
+
     /**
      * Represents where in its lifecycle a contract state is, which in turn controls the commands that can be applied
      * to the state. Most states will not leave the [NORMAL] lifecycle. Note that settled (as an end lifecycle) is
@@ -191,7 +192,7 @@ class Obligation<P : Any> : Contract {
          */
         data class Move(override val contract: Class<out Contract>? = null) : MoveCommand
 
-                /**
+        /**
          * Allows new obligation states to be issued into existence.
          */
         class Issue : TypeOnlyCommandData()
@@ -785,9 +786,11 @@ infix fun <T : Any> Obligation.State<T>.between(parties: Pair<AbstractParty, Abs
 infix fun <T : Any> Obligation.State<T>.`owned by`(owner: AbstractParty) = copy(beneficiary = owner)
 infix fun <T : Any> Obligation.State<T>.`issued by`(party: AbstractParty) = copy(obligor = party)
 // For Java users:
-@Suppress("unused") fun <T : Any> Obligation.State<T>.ownedBy(owner: AbstractParty) = copy(beneficiary = owner)
+@Suppress("unused")
+fun <T : Any> Obligation.State<T>.ownedBy(owner: AbstractParty) = copy(beneficiary = owner)
 
-@Suppress("unused") fun <T : Any> Obligation.State<T>.issuedBy(party: AnonymousParty) = copy(obligor = party)
+@Suppress("unused")
+fun <T : Any> Obligation.State<T>.issuedBy(party: AnonymousParty) = copy(obligor = party)
 
 /** A randomly generated key. */
 val DUMMY_OBLIGATION_ISSUER_KEY by lazy { entropyToKeyPair(BigInteger.valueOf(10)) }
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/OnLedgerAsset.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/OnLedgerAsset.kt
index 7042f3a94f..9f93a80a8c 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/OnLedgerAsset.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/OnLedgerAsset.kt
@@ -55,13 +55,13 @@ abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : C
          */
         @Throws(InsufficientBalanceException::class)
         @JvmStatic
-        fun <S : FungibleAsset<T>, T: Any> generateSpend(tx: TransactionBuilder,
-                                                         amount: Amount<T>,
-                                                         to: AbstractParty,
-                                                         acceptableStates: List<StateAndRef<S>>,
-                                                         payChangeTo: AbstractParty,
-                                                         deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>,
-                                                         generateMoveCommand: () -> CommandData): Pair<TransactionBuilder, List<PublicKey>> {
+        fun <S : FungibleAsset<T>, T : Any> generateSpend(tx: TransactionBuilder,
+                                                          amount: Amount<T>,
+                                                          to: AbstractParty,
+                                                          acceptableStates: List<StateAndRef<S>>,
+                                                          payChangeTo: AbstractParty,
+                                                          deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>,
+                                                          generateMoveCommand: () -> CommandData): Pair<TransactionBuilder, List<PublicKey>> {
             return generateSpend(tx, listOf(PartyAndAmount(to, amount)), acceptableStates, payChangeTo, deriveState, generateMoveCommand)
         }
 
@@ -91,12 +91,12 @@ abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : C
          */
         @Throws(InsufficientBalanceException::class)
         @JvmStatic
-        fun <S : FungibleAsset<T>, T: Any> generateSpend(tx: TransactionBuilder,
-                                                         payments: List<PartyAndAmount<T>>,
-                                                         acceptableStates: List<StateAndRef<S>>,
-                                                         payChangeTo: AbstractParty,
-                                                         deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>,
-                                                         generateMoveCommand: () -> CommandData): Pair<TransactionBuilder, List<PublicKey>> {
+        fun <S : FungibleAsset<T>, T : Any> generateSpend(tx: TransactionBuilder,
+                                                          payments: List<PartyAndAmount<T>>,
+                                                          acceptableStates: List<StateAndRef<S>>,
+                                                          payChangeTo: AbstractParty,
+                                                          deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>,
+                                                          generateMoveCommand: () -> CommandData): Pair<TransactionBuilder, List<PublicKey>> {
             // Discussion
             //
             // This code is analogous to the Wallet.send() set of methods in bitcoinj, and has the same general outline.
@@ -230,11 +230,11 @@ abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : C
          */
         @Throws(InsufficientBalanceException::class)
         @JvmStatic
-        fun <S : FungibleAsset<T>, T: Any> generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>,
-                                                        assetStates: List<StateAndRef<S>>,
-                                                        deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>,
-                                                        generateMoveCommand: () -> CommandData,
-                                                        generateExitCommand: (Amount<Issued<T>>) -> CommandData): Set<PublicKey> {
+        fun <S : FungibleAsset<T>, T : Any> generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>,
+                                                         assetStates: List<StateAndRef<S>>,
+                                                         deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>,
+                                                         generateMoveCommand: () -> CommandData,
+                                                         generateExitCommand: (Amount<Issued<T>>) -> CommandData): Set<PublicKey> {
             val owner = assetStates.map { it.state.data.owner }.toSet().singleOrNull() ?: throw InsufficientBalanceException(amountIssued)
             val currency = amountIssued.token.product
             val amount = Amount(amountIssued.quantity, currency)
@@ -272,9 +272,9 @@ abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : C
          * wrappers around this function, which build the state for you, and those should be used in preference.
          */
         @JvmStatic
-        fun <S : FungibleAsset<T>, T: Any> generateIssue(tx: TransactionBuilder,
-                                                         transactionState: TransactionState<S>,
-                                                         issueCommand: CommandData): Set<PublicKey> {
+        fun <S : FungibleAsset<T>, T : Any> generateIssue(tx: TransactionBuilder,
+                                                          transactionState: TransactionState<S>,
+                                                          issueCommand: CommandData): Set<PublicKey> {
             check(tx.inputStates().isEmpty())
             check(tx.outputStates().map { it.data }.filterIsInstance(transactionState.javaClass).isEmpty())
             require(transactionState.data.amount.quantity > 0)
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
index 7c18981857..a447827205 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
@@ -54,11 +54,11 @@ class CashSelectionH2Impl : CashSelection {
      */
     @Suspendable
     override fun unconsumedCashStatesForSpending(services: ServiceHub,
-                                        amount: Amount<Currency>,
-                                        onlyFromIssuerParties: Set<AbstractParty>,
-                                        notary: Party?,
-                                        lockId: UUID,
-                                        withIssuerRefs: Set<OpaqueBytes>): List<StateAndRef<Cash.State>> {
+                                                 amount: Amount<Currency>,
+                                                 onlyFromIssuerParties: Set<AbstractParty>,
+                                                 notary: Party?,
+                                                 lockId: UUID,
+                                                 withIssuerRefs: Set<OpaqueBytes>): List<StateAndRef<Cash.State>> {
 
         val issuerKeysStr = onlyFromIssuerParties.fold("") { left, right -> left + "('${right.owningKey.toBase58String()}')," }.dropLast(1)
         val issuerRefsStr = withIssuerRefs.fold("") { left, right -> left + "('${right.bytes.toHexString()}')," }.dropLast(1)
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionMySQLImpl.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionMySQLImpl.kt
index 73a49e8a18..1a0eac0169 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionMySQLImpl.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionMySQLImpl.kt
@@ -29,4 +29,4 @@ class CashSelectionMySQLImpl : CashSelection {
                                                  withIssuerRefs: Set<OpaqueBytes>): List<StateAndRef<Cash.State>> {
         TODO("MySQL cash selection not implemented")
     }
- }
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt b/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt
index f0084fb169..c978ded6f0 100644
--- a/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt
+++ b/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt
@@ -60,7 +60,7 @@ class CashExitFlow(private val amount: Amount<Currency>,
 
         // Work out who the owners of the burnt states were (specify page size so we don't silently drop any if > DEFAULT_PAGE_SIZE)
         val inputStates = serviceHub.vaultService.queryBy<Cash.State>(VaultQueryCriteria(stateRefs = builder.inputStates()),
-                                                                           PageSpecification(pageNumber = DEFAULT_PAGE_NUM, pageSize = builder.inputStates().size)).states
+                PageSpecification(pageNumber = DEFAULT_PAGE_NUM, pageSize = builder.inputStates().size)).states
 
         // TODO: Is it safe to drop participants we don't know how to contact? Does not knowing how to contact them
         //       count as a reason to fail?
diff --git a/finance/src/main/kotlin/net/corda/finance/flows/CashIssueAndPaymentFlow.kt b/finance/src/main/kotlin/net/corda/finance/flows/CashIssueAndPaymentFlow.kt
index 48f0f43c4a..95a58e8cfb 100644
--- a/finance/src/main/kotlin/net/corda/finance/flows/CashIssueAndPaymentFlow.kt
+++ b/finance/src/main/kotlin/net/corda/finance/flows/CashIssueAndPaymentFlow.kt
@@ -32,6 +32,7 @@ class CashIssueAndPaymentFlow(val amount: Amount<Currency>,
                 recipient: Party,
                 anonymous: Boolean,
                 notary: Party) : this(amount, issueRef, recipient, anonymous, notary, tracker())
+
     constructor(request: IssueAndPaymentRequest) : this(request.amount, request.issueRef, request.recipient, request.anonymous, request.notary, tracker())
 
     @Suspendable
diff --git a/finance/src/main/kotlin/net/corda/finance/flows/CashIssueFlow.kt b/finance/src/main/kotlin/net/corda/finance/flows/CashIssueFlow.kt
index 56f071783a..39ef76823b 100644
--- a/finance/src/main/kotlin/net/corda/finance/flows/CashIssueFlow.kt
+++ b/finance/src/main/kotlin/net/corda/finance/flows/CashIssueFlow.kt
@@ -31,6 +31,7 @@ class CashIssueFlow(private val amount: Amount<Currency>,
     constructor(amount: Amount<Currency>,
                 issuerBankPartyRef: OpaqueBytes,
                 notary: Party) : this(amount, issuerBankPartyRef, notary, tracker())
+
     constructor(request: IssueRequest) : this(request.amount, request.issueRef, request.notary, tracker())
 
     @Suspendable
diff --git a/finance/src/main/kotlin/net/corda/finance/flows/CashPaymentFlow.kt b/finance/src/main/kotlin/net/corda/finance/flows/CashPaymentFlow.kt
index 8857835da2..dc71e54884 100644
--- a/finance/src/main/kotlin/net/corda/finance/flows/CashPaymentFlow.kt
+++ b/finance/src/main/kotlin/net/corda/finance/flows/CashPaymentFlow.kt
@@ -31,8 +31,10 @@ open class CashPaymentFlow(
         val issuerConstraint: Set<Party> = emptySet()) : AbstractCashFlow<AbstractCashFlow.Result>(progressTracker) {
     /** A straightforward constructor that constructs spends using cash states of any issuer. */
     constructor(amount: Amount<Currency>, recipient: Party) : this(amount, recipient, true, tracker())
+
     /** A straightforward constructor that constructs spends using cash states of any issuer. */
     constructor(amount: Amount<Currency>, recipient: Party, anonymous: Boolean) : this(amount, recipient, anonymous, tracker())
+
     constructor(request: PaymentRequest) : this(request.amount, request.recipient, request.anonymous, tracker(), request.issuerConstraint)
 
     @Suspendable
diff --git a/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyDealFlow.kt b/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyDealFlow.kt
index 0525cead6a..b1dd0137aa 100644
--- a/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyDealFlow.kt
+++ b/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyDealFlow.kt
@@ -43,6 +43,7 @@ object TwoPartyDealFlow {
         companion object {
             object GENERATING_ID : ProgressTracker.Step("Generating anonymous identities")
             object SENDING_PROPOSAL : ProgressTracker.Step("Handshaking and awaiting transaction proposal.")
+
             fun tracker() = ProgressTracker(GENERATING_ID, SENDING_PROPOSAL)
         }
 
@@ -57,7 +58,7 @@ object TwoPartyDealFlow {
             val txIdentities = subFlow(SwapIdentitiesFlow(otherSideSession.counterparty))
             val anonymousMe = txIdentities[ourIdentity] ?: ourIdentity.anonymise()
             val anonymousCounterparty = txIdentities[otherSideSession.counterparty] ?: otherSideSession.counterparty.anonymise()
-        // DOCEND 2
+            // DOCEND 2
             progressTracker.currentStep = SENDING_PROPOSAL
             // Make the first message we'll send to kick off the flow.
             val hello = Handshake(payload, anonymousMe, anonymousCounterparty)
@@ -148,6 +149,7 @@ object TwoPartyDealFlow {
 
         @Suspendable
         protected abstract fun validateHandshake(handshake: Handshake<U>): Handshake<U>
+
         @Suspendable
         protected abstract fun assembleSharedTX(handshake: Handshake<U>): Triple<TransactionBuilder, List<PublicKey>, List<TransactionSignature>>
     }
diff --git a/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt b/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt
index d243792253..2d5093a583 100644
--- a/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt
+++ b/finance/src/main/kotlin/net/corda/finance/flows/TwoPartyTradeFlow.kt
@@ -136,6 +136,7 @@ object TwoPartyTradeFlow {
                      private val anonymous: Boolean) : FlowLogic<SignedTransaction>() {
         constructor(otherSideSession: FlowSession, notary: Party, acceptablePrice: Amount<Currency>, typeToBuy: Class<out OwnableState>) :
                 this(otherSideSession, notary, acceptablePrice, typeToBuy, true)
+
         // DOCSTART 2
         object RECEIVING : ProgressTracker.Step("Waiting for seller trading info")
 
diff --git a/finance/src/main/kotlin/net/corda/finance/schemas/CashSchemaV1.kt b/finance/src/main/kotlin/net/corda/finance/schemas/CashSchemaV1.kt
index 6ae8d9a9a0..5fdfc58492 100644
--- a/finance/src/main/kotlin/net/corda/finance/schemas/CashSchemaV1.kt
+++ b/finance/src/main/kotlin/net/corda/finance/schemas/CashSchemaV1.kt
@@ -22,8 +22,8 @@ object CashSchema
 object CashSchemaV1 : MappedSchema(schemaFamily = CashSchema.javaClass, version = 1, mappedTypes = listOf(PersistentCashState::class.java)) {
     @Entity
     @Table(name = "contract_cash_states",
-           indexes = arrayOf(Index(name = "ccy_code_idx", columnList = "ccy_code"),
-                             Index(name = "pennies_idx", columnList = "pennies")))
+            indexes = arrayOf(Index(name = "ccy_code_idx", columnList = "ccy_code"),
+                    Index(name = "pennies_idx", columnList = "pennies")))
     class PersistentCashState(
             /** X500Name of owner party **/
             @Column(name = "owner_name")
diff --git a/finance/src/main/kotlin/net/corda/finance/schemas/CommercialPaperSchemaV1.kt b/finance/src/main/kotlin/net/corda/finance/schemas/CommercialPaperSchemaV1.kt
index b1d58a5c8c..f8c1b46b0e 100644
--- a/finance/src/main/kotlin/net/corda/finance/schemas/CommercialPaperSchemaV1.kt
+++ b/finance/src/main/kotlin/net/corda/finance/schemas/CommercialPaperSchemaV1.kt
@@ -22,9 +22,9 @@ object CommercialPaperSchema
 object CommercialPaperSchemaV1 : MappedSchema(schemaFamily = CommercialPaperSchema.javaClass, version = 1, mappedTypes = listOf(PersistentCommercialPaperState::class.java)) {
     @Entity
     @Table(name = "cp_states",
-           indexes = arrayOf(Index(name = "ccy_code_index", columnList = "ccy_code"),
-                             Index(name = "maturity_index", columnList = "maturity_instant"),
-                             Index(name = "face_value_index", columnList = "face_value")))
+            indexes = arrayOf(Index(name = "ccy_code_index", columnList = "ccy_code"),
+                    Index(name = "maturity_index", columnList = "maturity_instant"),
+                    Index(name = "face_value_index", columnList = "face_value")))
     class PersistentCommercialPaperState(
             @Column(name = "issuance_key")
             var issuanceParty: String,
diff --git a/finance/src/main/kotlin/net/corda/finance/utils/StateSummingUtilities.kt b/finance/src/main/kotlin/net/corda/finance/utils/StateSummingUtilities.kt
index 75d6c072f9..5f3d7c8f37 100644
--- a/finance/src/main/kotlin/net/corda/finance/utils/StateSummingUtilities.kt
+++ b/finance/src/main/kotlin/net/corda/finance/utils/StateSummingUtilities.kt
@@ -1,4 +1,5 @@
 @file:JvmName("StateSumming")
+
 package net.corda.finance.utils
 
 import net.corda.core.contracts.Amount
diff --git a/finance/src/test/java/net/corda/finance/contracts/asset/CashTestsJava.java b/finance/src/test/java/net/corda/finance/contracts/asset/CashTestsJava.java
index 59ba1ad99c..455472503f 100644
--- a/finance/src/test/java/net/corda/finance/contracts/asset/CashTestsJava.java
+++ b/finance/src/test/java/net/corda/finance/contracts/asset/CashTestsJava.java
@@ -34,7 +34,7 @@ public class CashTestsJava {
             });
 
             tx.tweak(tw -> {
-                tw.output(Cash.PROGRAM_ID,  () -> outState );
+                tw.output(Cash.PROGRAM_ID, () -> outState);
                 tw.command(getMEGA_CORP_PUBKEY(), DummyCommandData.INSTANCE);
                 // Invalid command
                 return tw.failsWith("required net.corda.finance.contracts.asset.Cash.Commands.Move command");
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
index 73bdd6d4aa..a1a296eb05 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
@@ -80,7 +80,8 @@ class KotlinCommercialPaperLegacyTest : ICommercialPaperTestTemplate {
 @RunWith(Parameterized::class)
 class CommercialPaperTestsGeneric {
     companion object {
-        @Parameterized.Parameters @JvmStatic
+        @Parameterized.Parameters
+        @JvmStatic
         fun data() = listOf(JavaCommercialPaperTest(), KotlinCommercialPaperTest(), KotlinCommercialPaperLegacyTest())
     }
 
@@ -227,7 +228,7 @@ class CommercialPaperTestsGeneric {
 
     private lateinit var moveTX: SignedTransaction
 
-//    @Test
+    //    @Test
     @Ignore
     fun `issue move and then redeem`() {
         setCordappPackages("net.corda.finance.contracts")
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
index f30507ec3f..952aa3d9df 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
@@ -590,9 +590,9 @@ class CashTests : TestDependencyInjectionBase() {
     fun generateSimpleDirectSpend() {
         initialiseTestSerialization()
         val wtx =
-           database.transaction {
-                makeSpend(100.DOLLARS, THEIR_IDENTITY_1)
-            }
+                database.transaction {
+                    makeSpend(100.DOLLARS, THEIR_IDENTITY_1)
+                }
         database.transaction {
             val vaultState = vaultStatesUnconsumed.elementAt(0)
             assertEquals(vaultState.ref, wtx.inputs[0])
@@ -617,9 +617,9 @@ class CashTests : TestDependencyInjectionBase() {
     fun generateSimpleSpendWithChange() {
         initialiseTestSerialization()
         val wtx =
-            database.transaction {
-                makeSpend(10.DOLLARS, THEIR_IDENTITY_1)
-            }
+                database.transaction {
+                    makeSpend(10.DOLLARS, THEIR_IDENTITY_1)
+                }
         database.transaction {
             val vaultState = vaultStatesUnconsumed.elementAt(0)
             val changeAmount = 90.DOLLARS `issued by` defaultIssuer
@@ -643,9 +643,9 @@ class CashTests : TestDependencyInjectionBase() {
     fun generateSpendWithTwoInputs() {
         initialiseTestSerialization()
         val wtx =
-            database.transaction {
-                makeSpend(500.DOLLARS, THEIR_IDENTITY_1)
-            }
+                database.transaction {
+                    makeSpend(500.DOLLARS, THEIR_IDENTITY_1)
+                }
         database.transaction {
             val vaultState0 = vaultStatesUnconsumed.elementAt(0)
             val vaultState1 = vaultStatesUnconsumed.elementAt(1)
@@ -660,11 +660,11 @@ class CashTests : TestDependencyInjectionBase() {
     fun generateSpendMixedDeposits() {
         initialiseTestSerialization()
         val wtx =
-            database.transaction {
-                val wtx = makeSpend(580.DOLLARS, THEIR_IDENTITY_1)
-                assertEquals(3, wtx.inputs.size)
-                wtx
-            }
+                database.transaction {
+                    val wtx = makeSpend(580.DOLLARS, THEIR_IDENTITY_1)
+                    assertEquals(3, wtx.inputs.size)
+                    wtx
+                }
         database.transaction {
             val vaultState0: StateAndRef<Cash.State> = vaultStatesUnconsumed.elementAt(0)
             val vaultState1: StateAndRef<Cash.State> = vaultStatesUnconsumed.elementAt(1)
@@ -796,7 +796,7 @@ class CashTests : TestDependencyInjectionBase() {
             transaction {
                 attachment(Cash.PROGRAM_ID)
                 input("MEGA_CORP cash")
-                output(Cash.PROGRAM_ID, "MEGA_CORP cash 2", "MEGA_CORP cash".output<Cash.State>().copy(owner = AnonymousParty(ALICE_PUBKEY)) )
+                output(Cash.PROGRAM_ID, "MEGA_CORP cash 2", "MEGA_CORP cash".output<Cash.State>().copy(owner = AnonymousParty(ALICE_PUBKEY)))
                 command(MEGA_CORP_PUBKEY) { Cash.Commands.Move() }
                 this.verifies()
             }
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt
index 3b053c212b..8a293c4009 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt
@@ -286,7 +286,7 @@ class ObligationTests {
         assertEquals(expected, actual)
     }
 
-    private inline fun <reified T: ContractState> getStateAndRef(state: T, contractClassName: ContractClassName): StateAndRef<T> {
+    private inline fun <reified T : ContractState> getStateAndRef(state: T, contractClassName: ContractClassName): StateAndRef<T> {
         val txState = TransactionState(state, contractClassName, DUMMY_NOTARY)
         return StateAndRef(txState, StateRef(SecureHash.randomSHA256(), 0))
 
@@ -418,7 +418,7 @@ class ObligationTests {
     @Test
     fun `payment netting`() {
         // Try netting out two obligations
-        ledger(mockService)  {
+        ledger(mockService) {
             cashObligationTestRoots(this)
             transaction("Issuance") {
                 attachments(Obligation.PROGRAM_ID)
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
index 515480760a..c8c92fad91 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
@@ -18,7 +18,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class CashExitFlowTests {
-    private lateinit var mockNet : MockNetwork
+    private lateinit var mockNet: MockNetwork
     private val initialBalance = 2000.DOLLARS
     private val ref = OpaqueBytes.of(0x01)
     private lateinit var bankOfCordaNode: StartedNode<MockNode>
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
index 791dc0d9da..3aeb782a1d 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
@@ -22,7 +22,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class CashIssueFlowTests {
-    private lateinit var mockNet : MockNetwork
+    private lateinit var mockNet: MockNetwork
     private lateinit var bankOfCordaNode: StartedNode<MockNode>
     private lateinit var bankOfCorda: Party
     private lateinit var notaryNode: StartedNode<MockNode>
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
index 9304425778..a9b1352646 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
@@ -21,7 +21,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class CashPaymentFlowTests {
-    private lateinit var mockNet : MockNetwork
+    private lateinit var mockNet: MockNetwork
     private val initialBalance = 2000.DOLLARS
     private val ref = OpaqueBytes.of(0x01)
     private lateinit var bankOfCordaNode: StartedNode<MockNode>
diff --git a/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV1.kt b/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV1.kt
index f9395c1adb..b94d6ac700 100644
--- a/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV1.kt
+++ b/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV1.kt
@@ -19,8 +19,8 @@ object CashSchema
 object SampleCashSchemaV1 : MappedSchema(schemaFamily = CashSchema.javaClass, version = 1, mappedTypes = listOf(PersistentCashState::class.java)) {
     @Entity
     @Table(name = "contract_cash_states",
-           indexes = arrayOf(Index(name = "ccy_code_idx", columnList = "ccy_code"),
-                             Index(name = "pennies_idx", columnList = "pennies")))
+            indexes = arrayOf(Index(name = "ccy_code_idx", columnList = "ccy_code"),
+                    Index(name = "pennies_idx", columnList = "pennies")))
     class PersistentCashState(
             @Column(name = "owner_key")
             var owner: String,
diff --git a/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV2.kt b/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV2.kt
index 7a5e0da89c..95108eddfa 100644
--- a/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV2.kt
+++ b/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV2.kt
@@ -13,25 +13,25 @@ import javax.persistence.Table
  * [VaultFungibleState] abstract schema
  */
 object SampleCashSchemaV2 : MappedSchema(schemaFamily = CashSchema.javaClass, version = 2,
-                                   mappedTypes = listOf(PersistentCashState::class.java)) {
+        mappedTypes = listOf(PersistentCashState::class.java)) {
     @Entity
     @Table(name = "cash_states_v2",
-           indexes = arrayOf(Index(name = "ccy_code_idx2", columnList = "ccy_code")))
-    class PersistentCashState (
-        /** product type */
-        @Column(name = "ccy_code", length = 3)
-        var currency: String,
+            indexes = arrayOf(Index(name = "ccy_code_idx2", columnList = "ccy_code")))
+    class PersistentCashState(
+            /** product type */
+            @Column(name = "ccy_code", length = 3)
+            var currency: String,
 
-        /** parent attributes */
-        @Transient
-        val _participants: Set<AbstractParty>,
-        @Transient
-        val _owner: AbstractParty,
-        @Transient
-        val _quantity: Long,
-        @Transient
-        val _issuerParty: AbstractParty,
-        @Transient
-        val _issuerRef: ByteArray
+            /** parent attributes */
+            @Transient
+            val _participants: Set<AbstractParty>,
+            @Transient
+            val _owner: AbstractParty,
+            @Transient
+            val _quantity: Long,
+            @Transient
+            val _issuerParty: AbstractParty,
+            @Transient
+            val _issuerRef: ByteArray
     ) : CommonSchemaV1.FungibleState(_participants.toMutableSet(), _owner, _quantity, _issuerParty, _issuerRef)
 }
diff --git a/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV3.kt b/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV3.kt
index f6288c0591..eaae33410f 100644
--- a/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV3.kt
+++ b/finance/src/test/kotlin/net/corda/finance/schemas/SampleCashSchemaV3.kt
@@ -13,7 +13,7 @@ import javax.persistence.Table
  * at the time of writing.
  */
 object SampleCashSchemaV3 : MappedSchema(schemaFamily = CashSchema.javaClass, version = 3,
-                                         mappedTypes = listOf(PersistentCashState::class.java)) {
+        mappedTypes = listOf(PersistentCashState::class.java)) {
     @Entity
     @Table(name = "cash_states_v3")
     class PersistentCashState(
diff --git a/finance/src/test/kotlin/net/corda/finance/schemas/SampleCommercialPaperSchemaV1.kt b/finance/src/test/kotlin/net/corda/finance/schemas/SampleCommercialPaperSchemaV1.kt
index 9b4c91b179..4da37b7143 100644
--- a/finance/src/test/kotlin/net/corda/finance/schemas/SampleCommercialPaperSchemaV1.kt
+++ b/finance/src/test/kotlin/net/corda/finance/schemas/SampleCommercialPaperSchemaV1.kt
@@ -20,9 +20,9 @@ object CommercialPaperSchema
 object SampleCommercialPaperSchemaV1 : MappedSchema(schemaFamily = CommercialPaperSchema.javaClass, version = 1, mappedTypes = listOf(PersistentCommercialPaperState::class.java)) {
     @Entity
     @Table(name = "cp_states",
-           indexes = arrayOf(Index(name = "ccy_code_index", columnList = "ccy_code"),
-                             Index(name = "maturity_index", columnList = "maturity_instant"),
-                             Index(name = "face_value_index", columnList = "face_value")))
+            indexes = arrayOf(Index(name = "ccy_code_index", columnList = "ccy_code"),
+                    Index(name = "maturity_index", columnList = "maturity_instant"),
+                    Index(name = "face_value_index", columnList = "face_value")))
     class PersistentCommercialPaperState(
             @Column(name = "issuance_key")
             var issuanceParty: String,
diff --git a/finance/src/test/kotlin/net/corda/finance/schemas/SampleCommercialPaperSchemaV2.kt b/finance/src/test/kotlin/net/corda/finance/schemas/SampleCommercialPaperSchemaV2.kt
index ead55b4b1e..a3b855fe25 100644
--- a/finance/src/test/kotlin/net/corda/finance/schemas/SampleCommercialPaperSchemaV2.kt
+++ b/finance/src/test/kotlin/net/corda/finance/schemas/SampleCommercialPaperSchemaV2.kt
@@ -14,11 +14,11 @@ import javax.persistence.Table
  * [VaultFungibleState] abstract schema
  */
 object SampleCommercialPaperSchemaV2 : MappedSchema(schemaFamily = CommercialPaperSchema.javaClass, version = 1,
-                                                    mappedTypes = listOf(PersistentCommercialPaperState::class.java)) {
+        mappedTypes = listOf(PersistentCommercialPaperState::class.java)) {
     @Entity
     @Table(name = "cp_states_v2",
-           indexes = arrayOf(Index(name = "ccy_code_index2", columnList = "ccy_code"),
-                             Index(name = "maturity_index2", columnList = "maturity_instant")))
+            indexes = arrayOf(Index(name = "ccy_code_index2", columnList = "ccy_code"),
+                    Index(name = "maturity_index2", columnList = "maturity_instant")))
     class PersistentCommercialPaperState(
             @Column(name = "maturity_instant")
             var maturity: Instant,

From cb9e27a84ab82bae6e4270f05eff9512fb53817b Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 15:24:53 +0100
Subject: [PATCH 125/185] Reformat files in `node`

---
 .../kotlin/net/corda/node/BootTests.kt        |  2 +-
 .../corda/node/CordappScanningDriverTest.kt   |  2 +-
 .../corda/node/NodeStartupPerformanceTests.kt |  2 +-
 .../node/services/AttachmentLoadingTests.kt   |  2 +-
 .../services/network/NodeInfoWatcherTest.kt   |  4 +-
 .../network/PersistentNetworkMapCacheTest.kt  |  5 +-
 .../statemachine/LargeTransactionsTest.kt     |  6 +-
 .../corda/node/shell/FlowShellCommand.java    | 10 +--
 .../net/corda/node/shell/RunShellCommand.java |  6 +-
 .../main/kotlin/net/corda/node/ArgsParser.kt  |  6 +-
 .../net/corda/node/internal/AbstractNode.kt   |  2 +-
 .../kotlin/net/corda/node/internal/Node.kt    |  2 +-
 .../net/corda/node/internal/NodeStartup.kt    |  8 +-
 .../node/internal/cordapp/CordappLoader.kt    |  2 +-
 .../internal/cordapp/CordappProviderImpl.kt   |  2 +-
 .../corda/node/services/api/AuditService.kt   |  1 +
 .../node/services/config/NodeConfiguration.kt | 15 ++--
 .../services/events/NodeSchedulerService.kt   | 16 ++--
 .../identity/InMemoryIdentityService.kt       |  4 +-
 .../keys/PersistentKeyManagementService.kt    |  8 +-
 .../messaging/ArtemisMessagingServer.kt       |  3 +-
 .../services/messaging/NodeMessagingClient.kt | 22 ++---
 .../node/services/messaging/RPCServer.kt      |  6 ++
 .../node/services/network/NodeInfoWatcher.kt  |  2 +-
 .../network/PersistentNetworkMapCache.kt      |  1 +
 ...bstractPartyToX500NameAsStringConverter.kt |  2 +-
 .../persistence/DBTransactionStorage.kt       | 15 ++--
 .../persistence/HibernateConfiguration.kt     |  6 +-
 ...achineRecordedTransactionMappingStorage.kt |  1 +
 .../persistence/NodeAttachmentService.kt      | 24 ++---
 .../node/services/schema/NodeSchemaService.kt | 16 ++--
 .../statemachine/FlowStateMachineImpl.kt      | 48 +++++-----
 .../statemachine/StateMachineManager.kt       |  6 +-
 .../BFTNonValidatingNotaryService.kt          |  2 +-
 .../PersistentUniquenessProvider.kt           | 46 +++++-----
 .../transactions/RaftUniquenessProvider.kt    |  4 +-
 .../vault/HibernateQueryCriteriaParser.kt     | 26 +++---
 .../node/services/vault/NodeVaultService.kt   |  5 +-
 .../corda/node/services/vault/VaultSchema.kt  | 34 +++----
 .../node/shell/FlowWatchPrintingSubscriber.kt |  8 +-
 .../net/corda/node/shell/InteractiveShell.kt  | 14 +--
 .../node/utilities/AppendOnlyPersistentMap.kt | 18 ++--
 .../corda/node/utilities/CordaPersistence.kt  | 20 ++---
 .../utilities/DatabaseTransactionManager.kt   |  2 +-
 .../corda/node/utilities/KeyStoreUtilities.kt |  2 +-
 .../node/utilities/NonInvalidatingCache.kt    |  3 +-
 .../utilities/NonInvalidatingUnboundCache.kt  |  5 +-
 .../net/corda/node/utilities/PersistentMap.kt | 89 ++++++++++---------
 .../net/corda/node/utilities/TestClock.kt     |  3 +-
 .../net/corda/node/utilities/X509Utilities.kt |  8 +-
 .../services/vault/VaultQueryJavaTests.java   | 36 ++++----
 .../net/corda/node/CordaRPCOpsImplTest.kt     |  2 +-
 .../net/corda/node/InteractiveShellTest.kt    |  2 +-
 .../internal/cordapp/CordappLoaderTest.kt     | 12 ++-
 .../cordapp/CordappProviderImplTests.kt       |  2 +-
 .../node/messaging/TwoPartyTradeFlowTests.kt  |  5 +-
 .../services/events/ScheduledFlowTests.kt     |  2 +-
 .../messaging/ArtemisMessagingTests.kt        |  4 +-
 .../network/AbstractNetworkMapServiceTest.kt  |  4 +-
 .../persistence/DBTransactionStorageTests.kt  | 11 +--
 .../persistence/HibernateConfigurationTest.kt | 64 ++++++-------
 .../persistence/NodeAttachmentStorageTest.kt  | 22 ++---
 .../services/schema/NodeSchemaServiceTest.kt  |  4 +-
 .../statemachine/FlowFrameworkTests.kt        | 36 +++++---
 .../PersistentUniquenessProviderTests.kt      |  6 +-
 .../services/vault/NodeVaultServiceTest.kt    |  6 +-
 .../node/services/vault/VaultQueryTests.kt    |  6 +-
 .../node/services/vault/VaultWithCashTest.kt  | 59 ++++++------
 .../node/utilities/AffinityExecutorTests.kt   | 12 ++-
 69 files changed, 448 insertions(+), 393 deletions(-)

diff --git a/node/src/integration-test/kotlin/net/corda/node/BootTests.kt b/node/src/integration-test/kotlin/net/corda/node/BootTests.kt
index c61ad1cca9..4b5c17a069 100644
--- a/node/src/integration-test/kotlin/net/corda/node/BootTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/BootTests.kt
@@ -32,7 +32,7 @@ class BootTests {
         driver {
             val user = User("u", "p", setOf(startFlowPermission<ObjectInputStreamFlow>()))
             val future = startNode(rpcUsers = listOf(user)).getOrThrow().rpcClientToNode().
-                start(user.username, user.password).proxy.startFlow(::ObjectInputStreamFlow).returnValue
+                    start(user.username, user.password).proxy.startFlow(::ObjectInputStreamFlow).returnValue
             assertThatThrownBy { future.getOrThrow() }.isInstanceOf(InvalidClassException::class.java).hasMessage("filter status: REJECTED")
         }
     }
diff --git a/node/src/integration-test/kotlin/net/corda/node/CordappScanningDriverTest.kt b/node/src/integration-test/kotlin/net/corda/node/CordappScanningDriverTest.kt
index a46856b2ce..50788582b5 100644
--- a/node/src/integration-test/kotlin/net/corda/node/CordappScanningDriverTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/CordappScanningDriverTest.kt
@@ -36,7 +36,7 @@ class CordappScanningDriverTest {
 
     @StartableByRPC
     @InitiatingFlow
-    class ReceiveFlow(val otherParty: Party) :FlowLogic<String>() {
+    class ReceiveFlow(val otherParty: Party) : FlowLogic<String>() {
         @Suspendable
         override fun call(): String = initiateFlow(otherParty).receive<String>().unwrap { it }
     }
diff --git a/node/src/integration-test/kotlin/net/corda/node/NodeStartupPerformanceTests.kt b/node/src/integration-test/kotlin/net/corda/node/NodeStartupPerformanceTests.kt
index a6aef9b4fd..2f29d8df6d 100644
--- a/node/src/integration-test/kotlin/net/corda/node/NodeStartupPerformanceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/NodeStartupPerformanceTests.kt
@@ -17,7 +17,7 @@ class NodeStartupPerformanceTests {
         driver(networkMapStartStrategy = NetworkMapStartStrategy.Dedicated(startAutomatically = false)) {
             startDedicatedNetworkMapService().get()
             val times = ArrayList<Long>()
-            for (i in 1 .. 10) {
+            for (i in 1..10) {
                 val time = Stopwatch.createStarted().apply {
                     startNode().get()
                 }.stop().elapsed(TimeUnit.MICROSECONDS)
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
index bb177abfd9..e5a79d7d5c 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@@ -70,7 +70,7 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
         val contract = contractClass.newInstance()
         val txBuilder = generateInitialMethod.invoke(contract, PartyAndReference(DUMMY_BANK_A, OpaqueBytes(kotlin.ByteArray(1))), 1, DUMMY_NOTARY) as TransactionBuilder
         val context = SerializationFactory.defaultFactory.defaultContext
-            .withClassLoader(appClassLoader)
+                .withClassLoader(appClassLoader)
         val ledgerTx = txBuilder.toLedgerTransaction(services, context)
         contract.verify(ledgerTx)
 
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
index f845395020..556e47cb50 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
@@ -29,7 +29,9 @@ import kotlin.test.assertTrue
 
 class NodeInfoWatcherTest : NodeBasedTest() {
 
-    @Rule @JvmField var folder = TemporaryFolder()
+    @Rule
+    @JvmField
+    var folder = TemporaryFolder()
 
     lateinit var keyManagementService: KeyManagementService
     lateinit var nodeInfoPath: Path
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
index 465fb72229..fae4c25c51 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
@@ -170,8 +170,7 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
                     (customRetryIntervalMs?.let { mapOf("activeMQServer.bridge.retryIntervalMs" to it.toString()) } ?: emptyMap())
             if (party == DUMMY_NOTARY) {
                 startNetworkMapNode(party.name, configOverrides = configOverrides)
-            }
-            else {
+            } else {
                 startNode(party.name,
                         configOverrides = configOverrides,
                         noNetworkMap = noNetworkMap,
@@ -184,7 +183,7 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
     private fun checkConnectivity(nodes: List<StartedNode<*>>) {
         nodes.forEach { node1 ->
             nodes.forEach { node2 ->
-                if(!(node1 === node2)) { // Do not check connectivity to itself
+                if (!(node1 === node2)) { // Do not check connectivity to itself
                     node2.internals.registerInitiatedFlow(SendBackFlow::class.java)
                     val resultFuture = node1.services.startFlow(SendFlow(node2.info.chooseIdentity())).resultFuture
                     assertThat(resultFuture.getOrThrow()).isEqualTo("Hello!")
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/statemachine/LargeTransactionsTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/statemachine/LargeTransactionsTest.kt
index 0e66989f10..46ac098355 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/statemachine/LargeTransactionsTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/statemachine/LargeTransactionsTest.kt
@@ -21,7 +21,8 @@ import kotlin.test.assertEquals
  * transaction size limit (which should only consider the hashes).
  */
 class LargeTransactionsTest {
-    @StartableByRPC @InitiatingFlow
+    @StartableByRPC
+    @InitiatingFlow
     class SendLargeTransactionFlow(private val hash1: SecureHash,
                                    private val hash2: SecureHash,
                                    private val hash3: SecureHash,
@@ -44,7 +45,8 @@ class LargeTransactionsTest {
         }
     }
 
-    @InitiatedBy(SendLargeTransactionFlow::class) @Suppress("UNUSED")
+    @InitiatedBy(SendLargeTransactionFlow::class)
+    @Suppress("UNUSED")
     class ReceiveLargeTransactionFlow(private val otherSide: FlowSession) : FlowLogic<Unit>() {
         @Suspendable
         override fun call() {
diff --git a/node/src/main/java/net/corda/node/shell/FlowShellCommand.java b/node/src/main/java/net/corda/node/shell/FlowShellCommand.java
index 8f16381e01..4bac0ce5b5 100644
--- a/node/src/main/java/net/corda/node/shell/FlowShellCommand.java
+++ b/node/src/main/java/net/corda/node/shell/FlowShellCommand.java
@@ -12,11 +12,11 @@ import java.util.*;
 import static net.corda.node.shell.InteractiveShell.*;
 
 @Man(
-    "Allows you to start flows, list the ones available and to watch flows currently running on the node.\n\n" +
-    "Starting flow is the primary way in which you command the node to change the ledger.\n\n" +
-    "This command is generic, so the right way to use it depends on the flow you wish to start. You can use the 'flow start'\n" +
-    "command with either a full class name, or a substring of the class name that's unambiguous. The parameters to the \n" +
-    "flow constructors (the right one is picked automatically) are then specified using the same syntax as for the run command."
+        "Allows you to start flows, list the ones available and to watch flows currently running on the node.\n\n" +
+                "Starting flow is the primary way in which you command the node to change the ledger.\n\n" +
+                "This command is generic, so the right way to use it depends on the flow you wish to start. You can use the 'flow start'\n" +
+                "command with either a full class name, or a substring of the class name that's unambiguous. The parameters to the \n" +
+                "flow constructors (the right one is picked automatically) are then specified using the same syntax as for the run command."
 )
 public class FlowShellCommand extends InteractiveShellCommand {
     @Command
diff --git a/node/src/main/java/net/corda/node/shell/RunShellCommand.java b/node/src/main/java/net/corda/node/shell/RunShellCommand.java
index c388ccfe5f..108b567a9b 100644
--- a/node/src/main/java/net/corda/node/shell/RunShellCommand.java
+++ b/node/src/main/java/net/corda/node/shell/RunShellCommand.java
@@ -13,10 +13,10 @@ import java.util.*;
 public class RunShellCommand extends InteractiveShellCommand {
     @Command
     @Man(
-        "Runs a method from the CordaRPCOps interface, which is the same interface exposed to RPC clients.\n\n" +
+            "Runs a method from the CordaRPCOps interface, which is the same interface exposed to RPC clients.\n\n" +
 
-        "You can learn more about what commands are available by typing 'run' just by itself, or by\n" +
-        "consulting the developer guide at https://docs.corda.net/api/kotlin/corda/net.corda.core.messaging/-corda-r-p-c-ops/index.html"
+                    "You can learn more about what commands are available by typing 'run' just by itself, or by\n" +
+                    "consulting the developer guide at https://docs.corda.net/api/kotlin/corda/net.corda.core.messaging/-corda-r-p-c-ops/index.html"
     )
     @Usage("runs a method from the CordaRPCOps interface on the node.")
     public Object main(
diff --git a/node/src/main/kotlin/net/corda/node/ArgsParser.kt b/node/src/main/kotlin/net/corda/node/ArgsParser.kt
index db175ea2b7..7139055566 100644
--- a/node/src/main/kotlin/net/corda/node/ArgsParser.kt
+++ b/node/src/main/kotlin/net/corda/node/ArgsParser.kt
@@ -69,8 +69,8 @@ data class CmdLineOptions(val baseDirectory: Path,
                           val isVersion: Boolean,
                           val noLocalShell: Boolean,
                           val sshdServer: Boolean,
-                          val justGenerateNodeInfo : Boolean) {
+                          val justGenerateNodeInfo: Boolean) {
     fun loadConfig() = ConfigHelper
-                .loadConfig(baseDirectory, configFile)
-                .parseAs<FullNodeConfiguration>()
+            .loadConfig(baseDirectory, configFile)
+            .parseAs<FullNodeConfiguration>()
 }
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 640ac65389..779604259d 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -277,7 +277,7 @@ abstract class AbstractNode(config: NodeConfiguration,
     /**
      * This customizes the ServiceHub for each CordaService that is initiating flows
      */
-    private class AppServiceHubImpl<T : SerializeAsToken>(val serviceHub: ServiceHubInternal): AppServiceHub, ServiceHub by serviceHub {
+    private class AppServiceHubImpl<T : SerializeAsToken>(val serviceHub: ServiceHubInternal) : AppServiceHub, ServiceHub by serviceHub {
         lateinit var serviceInstance: T
         override fun <T> startTrackedFlow(flow: FlowLogic<T>): FlowProgressHandle<T> {
             val stateMachine = startFlowChecked(flow)
diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt
index adf92b70c1..696098df29 100644
--- a/node/src/main/kotlin/net/corda/node/internal/Node.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt
@@ -349,7 +349,7 @@ open class Node(override val configuration: FullNodeConfiguration,
                 _startupComplete.set(Unit)
             }
         },
-        { th -> logger.error("Unexpected exception", th)}
+                { th -> logger.error("Unexpected exception", th) }
         )
         shutdownHook = addShutdownHook {
             stop()
diff --git a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
index 631361cd04..2294024e90 100644
--- a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
@@ -110,14 +110,14 @@ open class NodeStartup(val args: Array<String>) {
             startedNode.internals.startupComplete.then {
                 try {
                     InteractiveShell.startShell(cmdlineOptions.baseDirectory, runShell, cmdlineOptions.sshdServer, startedNode)
-                } catch(e: Throwable) {
+                } catch (e: Throwable) {
                     logger.error("Shell failed to start", e)
                 }
             }
         },
-        {
-            th -> logger.error("Unexpected exception during registration", th)
-        })
+                { th ->
+                    logger.error("Unexpected exception during registration", th)
+                })
         startedNode.internals.run()
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
index e1cec24244..493b965ba6 100644
--- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
@@ -111,7 +111,7 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
 
         /** Takes a package of classes and creates a JAR from them - only use in tests. */
         private fun createDevCordappJar(scanPackage: String, path: URL, jarPackageName: String): URI {
-            if(!generatedCordapps.contains(path)) {
+            if (!generatedCordapps.contains(path)) {
                 val cordappDir = File("build/tmp/generated-test-cordapps")
                 cordappDir.mkdirs()
                 val cordappJAR = File(cordappDir, "$scanPackage-${UUID.randomUUID()}.jar")
diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt
index 9c3f58293f..967c332fd3 100644
--- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt
@@ -19,7 +19,7 @@ open class CordappProviderImpl(private val cordappLoader: CordappLoader) : Singl
         // TODO: Use better supported APIs in Java 9
         Exception().stackTrace.forEach { stackFrame ->
             val cordapp = getCordappForClass(stackFrame.className)
-            if(cordapp != null) {
+            if (cordapp != null) {
                 return getAppContext(cordapp)
             }
         }
diff --git a/node/src/main/kotlin/net/corda/node/services/api/AuditService.kt b/node/src/main/kotlin/net/corda/node/services/api/AuditService.kt
index b9f53f9831..127f69e3d6 100644
--- a/node/src/main/kotlin/net/corda/node/services/api/AuditService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/api/AuditService.kt
@@ -118,6 +118,7 @@ data class FlowPermissionAuditEvent(override val timestamp: Instant,
                                     override val flowId: StateMachineRunId,
                                     val permissionRequested: String,
                                     val permissionGranted: Boolean) : AuditEvent(), FlowAuditInfo
+
 /**
  * Minimal interface for recording audit information within the system. The AuditService is assumed to be available only
  * to trusted internal components via ServiceHubInternal.
diff --git a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
index b15e768f19..95467b63bc 100644
--- a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
+++ b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
@@ -122,12 +122,13 @@ enum class CertChainPolicyType {
 }
 
 data class CertChainPolicyConfig(val role: String, private val policy: CertChainPolicyType, private val trustedAliases: Set<String>) {
-    val certificateChainCheckPolicy: CertificateChainCheckPolicy get() {
-        return when (policy) {
-            CertChainPolicyType.Any -> CertificateChainCheckPolicy.Any
-            CertChainPolicyType.RootMustMatch -> CertificateChainCheckPolicy.RootMustMatch
-            CertChainPolicyType.LeafMustMatch -> CertificateChainCheckPolicy.LeafMustMatch
-            CertChainPolicyType.MustContainOneOf -> CertificateChainCheckPolicy.MustContainOneOf(trustedAliases)
+    val certificateChainCheckPolicy: CertificateChainCheckPolicy
+        get() {
+            return when (policy) {
+                CertChainPolicyType.Any -> CertificateChainCheckPolicy.Any
+                CertChainPolicyType.RootMustMatch -> CertificateChainCheckPolicy.RootMustMatch
+                CertChainPolicyType.LeafMustMatch -> CertificateChainCheckPolicy.LeafMustMatch
+                CertChainPolicyType.MustContainOneOf -> CertificateChainCheckPolicy.MustContainOneOf(trustedAliases)
+            }
         }
-    }
 }
diff --git a/node/src/main/kotlin/net/corda/node/services/events/NodeSchedulerService.kt b/node/src/main/kotlin/net/corda/node/services/events/NodeSchedulerService.kt
index 1d0b5e3d54..26a8322b80 100644
--- a/node/src/main/kotlin/net/corda/node/services/events/NodeSchedulerService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/events/NodeSchedulerService.kt
@@ -72,7 +72,7 @@ class NodeSchedulerService(private val services: ServiceHubInternal,
         // to wait in our code, rather than <code>Thread.sleep()</code> or other time-based pauses.
         @Suspendable
         @VisibleForTesting
-        // We specify full classpath on SettableFuture to differentiate it from the Quasar class of the same name
+                // We specify full classpath on SettableFuture to differentiate it from the Quasar class of the same name
         fun awaitWithDeadline(clock: Clock, deadline: Instant, future: Future<*> = GuavaSettableFuture.create<Any>()): Boolean {
             var nanos: Long
             do {
@@ -89,11 +89,11 @@ class NodeSchedulerService(private val services: ServiceHubInternal,
                     try {
                         // This will return when it times out, or when the clock mutates or when when the original future completes.
                         originalFutureCompleted.get(nanos, TimeUnit.NANOSECONDS)
-                    } catch(e: ExecutionException) {
+                    } catch (e: ExecutionException) {
                         // No need to take action as will fall out of the loop due to future.isDone
-                    } catch(e: CancellationException) {
+                    } catch (e: CancellationException) {
                         // No need to take action as will fall out of the loop due to future.isDone
-                    } catch(e: TimeoutException) {
+                    } catch (e: TimeoutException) {
                         // No need to take action as will fall out of the loop due to future.isDone
                     }
                 }
@@ -111,7 +111,7 @@ class NodeSchedulerService(private val services: ServiceHubInternal,
                         var txId = it.output.txId ?: throw IllegalStateException("DB returned null SecureHash transactionId")
                         var index = it.output.index ?: throw IllegalStateException("DB returned null SecureHash index")
                         Pair(StateRef(SecureHash.parse(txId), index),
-                            ScheduledStateRef(StateRef(SecureHash.parse(txId), index), it.scheduledAt))
+                                ScheduledStateRef(StateRef(SecureHash.parse(txId), index), it.scheduledAt))
                     },
                     toPersistentEntity = { key: StateRef, value: ScheduledStateRef ->
                         PersistentScheduledState().apply {
@@ -152,7 +152,7 @@ class NodeSchedulerService(private val services: ServiceHubInternal,
     private class InnerState {
         var scheduledStates = createMap()
 
-        var scheduledStatesQueue: PriorityQueue<ScheduledStateRef> = PriorityQueue( { a, b -> a.scheduledAt.compareTo(b.scheduledAt) } )
+        var scheduledStatesQueue: PriorityQueue<ScheduledStateRef> = PriorityQueue({ a, b -> a.scheduledAt.compareTo(b.scheduledAt) })
 
         var rescheduled: GuavaSettableFuture<Boolean>? = null
     }
@@ -162,7 +162,7 @@ class NodeSchedulerService(private val services: ServiceHubInternal,
     // We need the [StateMachineManager] to be constructed before this is called in case it schedules a flow.
     fun start() {
         mutex.locked {
-            scheduledStatesQueue.addAll(scheduledStates.all().map { it.second } .toMutableList())
+            scheduledStatesQueue.addAll(scheduledStates.all().map { it.second }.toMutableList())
             rescheduleWakeUp()
         }
     }
@@ -182,7 +182,7 @@ class NodeSchedulerService(private val services: ServiceHubInternal,
             if (action.scheduledAt.isBefore(previousEarliest?.scheduledAt ?: Instant.MAX)) {
                 // We are earliest
                 rescheduleWakeUp()
-            } else if(previousEarliest?.ref == action.ref && previousEarliest.scheduledAt != action.scheduledAt) {
+            } else if (previousEarliest?.ref == action.ref && previousEarliest.scheduledAt != action.scheduledAt) {
                 // We were earliest but might not be any more
                 rescheduleWakeUp()
             }
diff --git a/node/src/main/kotlin/net/corda/node/services/identity/InMemoryIdentityService.kt b/node/src/main/kotlin/net/corda/node/services/identity/InMemoryIdentityService.kt
index 9ee5707a57..616e4bd8c1 100644
--- a/node/src/main/kotlin/net/corda/node/services/identity/InMemoryIdentityService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/identity/InMemoryIdentityService.kt
@@ -30,6 +30,7 @@ class InMemoryIdentityService(identities: Iterable<PartyAndCertificate> = emptyS
     constructor(wellKnownIdentities: Iterable<PartyAndCertificate> = emptySet(),
                 confidentialIdentities: Iterable<PartyAndCertificate> = emptySet(),
                 trustRoot: X509CertificateHolder) : this(wellKnownIdentities, confidentialIdentities, trustRoot.cert)
+
     companion object {
         private val log = loggerFor<InMemoryIdentityService>()
     }
@@ -45,7 +46,7 @@ class InMemoryIdentityService(identities: Iterable<PartyAndCertificate> = emptyS
     init {
         val caCertificatesWithRoot: Set<X509Certificate> = caCertificates.toSet() + trustRoot
         caCertStore = CertStore.getInstance("Collection", CollectionCertStoreParameters(caCertificatesWithRoot))
-        keyToParties.putAll(identities.associateBy { it.owningKey } )
+        keyToParties.putAll(identities.associateBy { it.owningKey })
         principalToParties.putAll(identities.associateBy { it.name })
         confidentialIdentities.forEach { identity ->
             principalToParties.computeIfAbsent(identity.name) { identity }
@@ -94,6 +95,7 @@ class InMemoryIdentityService(identities: Iterable<PartyAndCertificate> = emptyS
             null
         }
     }
+
     override fun wellKnownPartyFromAnonymous(partyRef: PartyAndReference) = wellKnownPartyFromAnonymous(partyRef.party)
     override fun requireWellKnownPartyFromAnonymous(party: AbstractParty): Party {
         return wellKnownPartyFromAnonymous(party) ?: throw IllegalStateException("Could not deanonymise party ${party.owningKey.toStringShort()}")
diff --git a/node/src/main/kotlin/net/corda/node/services/keys/PersistentKeyManagementService.kt b/node/src/main/kotlin/net/corda/node/services/keys/PersistentKeyManagementService.kt
index de1b479c1f..4645c1d8e0 100644
--- a/node/src/main/kotlin/net/corda/node/services/keys/PersistentKeyManagementService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/keys/PersistentKeyManagementService.kt
@@ -48,8 +48,10 @@ class PersistentKeyManagementService(val identityService: IdentityService,
         fun createKeyMap(): AppendOnlyPersistentMap<PublicKey, PrivateKey, PersistentKey, String> {
             return AppendOnlyPersistentMap(
                     toPersistentEntityKey = { it.toBase58String() },
-                    fromPersistentEntity = { Pair(parsePublicKeyBase58(it.publicKey),
-                            it.privateKey.deserialize<PrivateKey>(context = SerializationDefaults.STORAGE_CONTEXT)) },
+                    fromPersistentEntity = {
+                        Pair(parsePublicKeyBase58(it.publicKey),
+                                it.privateKey.deserialize<PrivateKey>(context = SerializationDefaults.STORAGE_CONTEXT))
+                    },
                     toPersistentEntity = { key: PublicKey, value: PrivateKey ->
                         PersistentKey().apply {
                             publicKey = key.toBase58String()
@@ -81,7 +83,7 @@ class PersistentKeyManagementService(val identityService: IdentityService,
     override fun freshKeyAndCert(identity: PartyAndCertificate, revocationEnabled: Boolean): PartyAndCertificate =
             freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey), revocationEnabled)
 
-    private fun getSigner(publicKey: PublicKey): ContentSigner  = getSigner(getSigningKeyPair(publicKey))
+    private fun getSigner(publicKey: PublicKey): ContentSigner = getSigner(getSigningKeyPair(publicKey))
 
     //It looks for the PublicKey in the (potentially) CompositeKey that is ours, and then returns the associated PrivateKey to use in signing
     private fun getSigningKeyPair(publicKey: PublicKey): KeyPair {
diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt b/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt
index b648721633..52421eb6d1 100644
--- a/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt
+++ b/node/src/main/kotlin/net/corda/node/services/messaging/ArtemisMessagingServer.kt
@@ -97,7 +97,8 @@ class ArtemisMessagingServer(override val config: NodeConfiguration,
     companion object {
         private val log = loggerFor<ArtemisMessagingServer>()
         /** 10 MiB maximum allowed file size for attachments, including message headers. TODO: acquire this value from Network Map when supported. */
-        @JvmStatic val MAX_FILE_SIZE = 10485760
+        @JvmStatic
+        val MAX_FILE_SIZE = 10485760
 
         val ipDetectRequestProperty = "ip-request-id"
         val ipDetectResponseProperty = "ip-address"
diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/NodeMessagingClient.kt b/node/src/main/kotlin/net/corda/node/services/messaging/NodeMessagingClient.kt
index 410a753f10..02ee5500ec 100644
--- a/node/src/main/kotlin/net/corda/node/services/messaging/NodeMessagingClient.kt
+++ b/node/src/main/kotlin/net/corda/node/services/messaging/NodeMessagingClient.kt
@@ -117,10 +117,12 @@ class NodeMessagingClient(override val config: NodeConfiguration,
         fun createMessageToRedeliver(): PersistentMap<Long, Pair<Message, MessageRecipients>, RetryMessage, Long> {
             return PersistentMap(
                     toPersistentEntityKey = { it },
-                    fromPersistentEntity = { Pair(it.key,
-                            Pair(it.message.deserialize( context = SerializationDefaults.STORAGE_CONTEXT),
-                                    it.recipients.deserialize( context = SerializationDefaults.STORAGE_CONTEXT))
-                    ) },
+                    fromPersistentEntity = {
+                        Pair(it.key,
+                                Pair(it.message.deserialize(context = SerializationDefaults.STORAGE_CONTEXT),
+                                        it.recipients.deserialize(context = SerializationDefaults.STORAGE_CONTEXT))
+                        )
+                    },
                     toPersistentEntity = { _key: Long, (_message: Message, _recipient: MessageRecipients): Pair<Message, MessageRecipients> ->
                         RetryMessage().apply {
                             key = _key
@@ -241,7 +243,7 @@ class NodeMessagingClient(override val config: NodeConfiguration,
                     log.info("Network map is complete, so removing filter from P2P consumer.")
                     try {
                         p2pConsumer!!.close()
-                    } catch(e: ActiveMQObjectClosedException) {
+                    } catch (e: ActiveMQObjectClosedException) {
                         // Ignore it: this can happen if the server has gone away before we do.
                     }
                     p2pConsumer = makeP2PConsumer(session, false)
@@ -283,8 +285,8 @@ class NodeMessagingClient(override val config: NodeConfiguration,
     }
 
     private fun resumeMessageRedelivery() {
-        messagesToRedeliver.forEach {
-            retryId, (message, target) -> send(message, target, retryId)
+        messagesToRedeliver.forEach { retryId, (message, target) ->
+            send(message, target, retryId)
         }
     }
 
@@ -301,7 +303,7 @@ class NodeMessagingClient(override val config: NodeConfiguration,
         // It's safe to call into receive simultaneous with other threads calling send on a producer.
         val artemisMessage: ClientMessage = try {
             consumer.receive()
-        } catch(e: ActiveMQObjectClosedException) {
+        } catch (e: ActiveMQObjectClosedException) {
             null
         } ?: return false
 
@@ -433,7 +435,7 @@ class NodeMessagingClient(override val config: NodeConfiguration,
                     }
                 }
             }
-        } catch(e: Exception) {
+        } catch (e: Exception) {
             log.error("Caught exception whilst executing message handler for ${msg.topicSession}", e)
         }
         return true
@@ -454,7 +456,7 @@ class NodeMessagingClient(override val config: NodeConfiguration,
             val c = p2pConsumer ?: throw IllegalStateException("stop can't be called twice")
             try {
                 c.close()
-            } catch(e: ActiveMQObjectClosedException) {
+            } catch (e: ActiveMQObjectClosedException) {
                 // Ignore it: this can happen if the server has gone away before we do.
             }
             p2pConsumer = null
diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt b/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
index ad2eb239fa..ae4f328378 100644
--- a/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
+++ b/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt
@@ -86,6 +86,7 @@ class RPCServer(
     private companion object {
         val log = loggerFor<RPCServer>()
     }
+
     private enum class State {
         UNSTARTED,
         STARTED,
@@ -350,6 +351,7 @@ class RPCServer(
 
     // TODO remove this User once webserver doesn't need it
     private val nodeUser = User(NODE_USER, NODE_USER, setOf())
+
     private fun getUser(message: ClientMessage): User {
         val validatedUser = message.getStringProperty(Message.HDR_VALIDATED_USER) ?: throw IllegalArgumentException("Missing validated user from the Artemis message")
         val rpcUser = userService.getUser(validatedUser)
@@ -365,6 +367,7 @@ class RPCServer(
 
 @JvmField
 internal val CURRENT_RPC_CONTEXT: ThreadLocal<RpcContext> = ThreadLocal()
+
 /**
  * Returns a context specific to the current RPC call. Note that trying to call this function outside of an RPC will
  * throw. If you'd like to use the context outside of the call (e.g. in another thread) then pass the returned reference
@@ -422,6 +425,7 @@ class ObservableContext(
 
 object RpcServerObservableSerializer : Serializer<Observable<*>>() {
     private object RpcObservableContextKey
+
     private val log = loggerFor<RpcServerObservableSerializer>()
 
     fun createContext(observableContext: ObservableContext): SerializationContext {
@@ -448,9 +452,11 @@ object RpcServerObservableSerializer : Serializer<Observable<*>>() {
                                     }
                                 }
                             }
+
                             override fun onError(exception: Throwable) {
                                 log.error("onError called in materialize()d RPC Observable", exception)
                             }
+
                             override fun onCompleted() {
                             }
                         }
diff --git a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
index b73ded13e3..83121ba969 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
@@ -99,7 +99,7 @@ class NodeInfoWatcher(private val nodePath: Path,
         return result
     }
 
-    private fun processFile(file: Path) : NodeInfo? {
+    private fun processFile(file: Path): NodeInfo? {
         try {
             logger.info("Reading NodeInfo from file: $file")
             val signedData = file.readAll().deserialize<SignedData<NodeInfo>>()
diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
index 322a2c9299..09b3c8997f 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
@@ -118,6 +118,7 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
     override fun getNodesByLegalName(name: CordaX500Name): List<NodeInfo> = serviceHub.database.transaction { queryByLegalName(name) }
     override fun getNodesByLegalIdentityKey(identityKey: PublicKey): List<NodeInfo> =
             serviceHub.database.transaction { queryByIdentityKey(identityKey) }
+
     override fun getNodeByLegalIdentity(party: AbstractParty): NodeInfo? {
         val wellKnownParty = serviceHub.identityService.wellKnownPartyFromAnonymous(party)
         return wellKnownParty?.let {
diff --git a/node/src/main/kotlin/net/corda/node/services/persistence/AbstractPartyToX500NameAsStringConverter.kt b/node/src/main/kotlin/net/corda/node/services/persistence/AbstractPartyToX500NameAsStringConverter.kt
index ac1d696af7..8dc9c857bd 100644
--- a/node/src/main/kotlin/net/corda/node/services/persistence/AbstractPartyToX500NameAsStringConverter.kt
+++ b/node/src/main/kotlin/net/corda/node/services/persistence/AbstractPartyToX500NameAsStringConverter.kt
@@ -32,7 +32,7 @@ class AbstractPartyToX500NameAsStringConverter(identitySvc: () -> IdentityServic
         if (dbData != null) {
             val party = identityService.wellKnownPartyFromX500Name(CordaX500Name.parse(dbData))
             if (party != null) return party
-            log.warn ("Identity service unable to resolve X500name: $dbData")
+            log.warn("Identity service unable to resolve X500name: $dbData")
         }
         return null // non resolvable anonymous parties are stored as nulls
     }
diff --git a/node/src/main/kotlin/net/corda/node/services/persistence/DBTransactionStorage.kt b/node/src/main/kotlin/net/corda/node/services/persistence/DBTransactionStorage.kt
index 0e68c98cce..ff29e4c1da 100644
--- a/node/src/main/kotlin/net/corda/node/services/persistence/DBTransactionStorage.kt
+++ b/node/src/main/kotlin/net/corda/node/services/persistence/DBTransactionStorage.kt
@@ -30,8 +30,10 @@ class DBTransactionStorage : WritableTransactionStorage, SingletonSerializeAsTok
         fun createTransactionsMap(): AppendOnlyPersistentMap<SecureHash, SignedTransaction, DBTransaction, String> {
             return AppendOnlyPersistentMap(
                     toPersistentEntityKey = { it.toString() },
-                    fromPersistentEntity = { Pair(SecureHash.parse(it.txId),
-                            it.transaction.deserialize<SignedTransaction>( context = SerializationDefaults.STORAGE_CONTEXT)) },
+                    fromPersistentEntity = {
+                        Pair(SecureHash.parse(it.txId),
+                                it.transaction.deserialize<SignedTransaction>(context = SerializationDefaults.STORAGE_CONTEXT))
+                    },
                     toPersistentEntity = { key: SecureHash, value: SignedTransaction ->
                         DBTransaction().apply {
                             txId = key.toString()
@@ -46,9 +48,9 @@ class DBTransactionStorage : WritableTransactionStorage, SingletonSerializeAsTok
     private val txStorage = createTransactionsMap()
 
     override fun addTransaction(transaction: SignedTransaction): Boolean =
-        txStorage.addWithDuplicatesAllowed(transaction.id, transaction).apply {
-            updatesPublisher.bufferUntilDatabaseCommit().onNext(transaction)
-        }
+            txStorage.addWithDuplicatesAllowed(transaction.id, transaction).apply {
+                updatesPublisher.bufferUntilDatabaseCommit().onNext(transaction)
+            }
 
     override fun getTransaction(id: SecureHash): SignedTransaction? = txStorage[id]
 
@@ -59,5 +61,6 @@ class DBTransactionStorage : WritableTransactionStorage, SingletonSerializeAsTok
             DataFeed(txStorage.allPersisted().map { it.second }.toList(), updatesPublisher.bufferUntilSubscribed().wrapWithDatabaseTransaction())
 
     @VisibleForTesting
-    val transactions: Iterable<SignedTransaction> get() = txStorage.allPersisted().map { it.second }.toList()
+    val transactions: Iterable<SignedTransaction>
+        get() = txStorage.allPersisted().map { it.second }.toList()
 }
diff --git a/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt
index 73d8f77dff..bf6efb6c8c 100644
--- a/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt
+++ b/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt
@@ -32,7 +32,7 @@ class HibernateConfiguration(val schemaService: SchemaService, private val datab
     // TODO: make this a guava cache or similar to limit ability for this to grow forever.
     private val sessionFactories = ConcurrentHashMap<Set<MappedSchema>, SessionFactory>()
 
-    private val transactionIsolationLevel = parserTransactionIsolationLevel(databaseProperties.getProperty("transactionIsolationLevel") ?:"")
+    private val transactionIsolationLevel = parserTransactionIsolationLevel(databaseProperties.getProperty("transactionIsolationLevel") ?: "")
 
     init {
         logger.info("Init HibernateConfiguration for schemas: ${schemaService.schemaOptions.keys}")
@@ -61,7 +61,7 @@ class HibernateConfiguration(val schemaService: SchemaService, private val datab
         // necessarily remain and would likely be replaced by something like Liquibase.  For now it is very convenient though.
         // TODO: replace auto schema generation as it isn't intended for production use, according to Hibernate docs.
         val config = Configuration(metadataSources).setProperty("hibernate.connection.provider_class", NodeDatabaseConnectionProvider::class.java.name)
-                .setProperty("hibernate.hbm2ddl.auto", if (databaseProperties.getProperty("initDatabase","true") == "true") "update" else "validate")
+                .setProperty("hibernate.hbm2ddl.auto", if (databaseProperties.getProperty("initDatabase", "true") == "true") "update" else "validate")
                 .setProperty("hibernate.format_sql", "true")
                 .setProperty("hibernate.connection.isolation", transactionIsolationLevel.toString())
 
@@ -70,7 +70,7 @@ class HibernateConfiguration(val schemaService: SchemaService, private val datab
             schema.mappedTypes.forEach { config.addAnnotatedClass(it) }
         }
 
-        val sessionFactory = buildSessionFactory(config, metadataSources, databaseProperties.getProperty("serverNameTablePrefix",""))
+        val sessionFactory = buildSessionFactory(config, metadataSources, databaseProperties.getProperty("serverNameTablePrefix", ""))
         logger.info("Created session factory for schemas: $schemas")
         return sessionFactory
     }
diff --git a/node/src/main/kotlin/net/corda/node/services/persistence/InMemoryStateMachineRecordedTransactionMappingStorage.kt b/node/src/main/kotlin/net/corda/node/services/persistence/InMemoryStateMachineRecordedTransactionMappingStorage.kt
index 740373d3d7..84dd4974dd 100644
--- a/node/src/main/kotlin/net/corda/node/services/persistence/InMemoryStateMachineRecordedTransactionMappingStorage.kt
+++ b/node/src/main/kotlin/net/corda/node/services/persistence/InMemoryStateMachineRecordedTransactionMappingStorage.kt
@@ -22,6 +22,7 @@ class InMemoryStateMachineRecordedTransactionMappingStorage : StateMachineRecord
         val stateMachineTransactionMap = HashMap<StateMachineRunId, HashSet<SecureHash>>()
         val updates = PublishSubject.create<StateMachineTransactionMapping>()!!
     }
+
     private val mutex = ThreadBox(InnerState())
 
     override fun addMapping(stateMachineRunId: StateMachineRunId, transactionId: SecureHash) {
diff --git a/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt b/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt
index 3a175effb4..c864521d7b 100644
--- a/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt
@@ -29,7 +29,7 @@ class NodeAttachmentService(metrics: MetricRegistry) : AttachmentStorage, Single
 
     @Entity
     @Table(name = "${NODE_DATABASE_PREFIX}attachments",
-           indexes = arrayOf(Index(name = "att_id_idx", columnList = "att_id")))
+            indexes = arrayOf(Index(name = "att_id_idx", columnList = "att_id")))
     class DBAttachment(
             @Id
             @Column(name = "att_id", length = 65535)
@@ -69,7 +69,8 @@ class NodeAttachmentService(metrics: MetricRegistry) : AttachmentStorage, Single
      * around inside it, we haven't read the whole file, so we can't check the hash. But when copying it over the network
      * this will provide an additional safety check against user error.
      */
-    @VisibleForTesting @CordaSerializable
+    @VisibleForTesting
+    @CordaSerializable
     class HashCheckingStream(val expected: SecureHash.SHA256,
                              val expectedSize: Int,
                              input: InputStream,
@@ -110,16 +111,17 @@ class NodeAttachmentService(metrics: MetricRegistry) : AttachmentStorage, Single
         }
 
         private var _hash: HashCode? = null // Backing field for hash property
-        private val hash: HashCode get() {
-            var h = _hash
-            return if (h == null) {
-                h = stream.hash()
-                _hash = h
-                h
-            } else {
-                h
+        private val hash: HashCode
+            get() {
+                var h = _hash
+                return if (h == null) {
+                    h = stream.hash()
+                    _hash = h
+                    h
+                } else {
+                    h
+                }
             }
-        }
     }
 
     private class AttachmentImpl(override val id: SecureHash, dataLoader: () -> ByteArray, private val checkOnLoad: Boolean) : AbstractAttachment(dataLoader), SerializeAsToken {
diff --git a/node/src/main/kotlin/net/corda/node/services/schema/NodeSchemaService.kt b/node/src/main/kotlin/net/corda/node/services/schema/NodeSchemaService.kt
index 333ecd6152..0599616644 100644
--- a/node/src/main/kotlin/net/corda/node/services/schema/NodeSchemaService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/schema/NodeSchemaService.kt
@@ -57,18 +57,18 @@ class NodeSchemaService(customSchemas: Set<MappedSchema> = emptySet()) : SchemaS
                     PersistentIdentityService.PersistentIdentity::class.java,
                     PersistentIdentityService.PersistentIdentityNames::class.java,
                     ContractUpgradeServiceImpl.DBContractUpgrade::class.java
-                    ))
+            ))
 
     // Required schemas are those used by internal Corda services
     // For example, cash is used by the vault for coin selection (but will be extracted as a standalone CorDapp in future)
     private val requiredSchemas: Map<MappedSchema, SchemaService.SchemaOptions> =
             mapOf(Pair(CommonSchemaV1, SchemaService.SchemaOptions()),
-                  Pair(VaultSchemaV1, SchemaService.SchemaOptions()),
-                  Pair(NodeInfoSchemaV1, SchemaService.SchemaOptions()),
-                  Pair(NodeServicesV1, SchemaService.SchemaOptions()))
+                    Pair(VaultSchemaV1, SchemaService.SchemaOptions()),
+                    Pair(NodeInfoSchemaV1, SchemaService.SchemaOptions()),
+                    Pair(NodeServicesV1, SchemaService.SchemaOptions()))
 
-    override var schemaOptions: Map<MappedSchema, SchemaService.SchemaOptions> = requiredSchemas.plus(customSchemas.map {
-        mappedSchema -> Pair(mappedSchema, SchemaService.SchemaOptions())
+    override var schemaOptions: Map<MappedSchema, SchemaService.SchemaOptions> = requiredSchemas.plus(customSchemas.map { mappedSchema ->
+        Pair(mappedSchema, SchemaService.SchemaOptions())
     })
 
     // Currently returns all schemas supported by the state, with no filtering or enrichment.
@@ -94,8 +94,8 @@ class NodeSchemaService(customSchemas: Set<MappedSchema> = emptySet()) : SchemaS
     }
 
     override fun registerCustomSchemas(_customSchemas: Set<MappedSchema>) {
-        schemaOptions = schemaOptions.plus(_customSchemas.map {
-            mappedSchema -> Pair(mappedSchema, SchemaService.SchemaOptions())
+        schemaOptions = schemaOptions.plus(_customSchemas.map { mappedSchema ->
+            Pair(mappedSchema, SchemaService.SchemaOptions())
         })
     }
 }
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
index 0de001283e..0b478243f6 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
@@ -42,7 +42,7 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
                               val logic: FlowLogic<R>,
                               scheduler: FiberScheduler,
                               override val flowInitiator: FlowInitiator,
-                              // Store the Party rather than the full cert path with PartyAndCertificate
+        // Store the Party rather than the full cert path with PartyAndCertificate
                               val ourIdentity: Party) : Fiber<Unit>(id.toString(), scheduler), FlowStateMachine<R> {
 
     companion object {
@@ -482,7 +482,7 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
     private fun suspend(ioRequest: FlowIORequest) {
         // We have to pass the thread local database transaction across via a transient field as the fiber park
         // swaps them out.
-        txTrampoline =  DatabaseTransactionManager.setThreadLocalTx(null)
+        txTrampoline = DatabaseTransactionManager.setThreadLocalTx(null)
         if (ioRequest is WaitingRequest)
             waitingForResponse = ioRequest
 
@@ -541,28 +541,30 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
     }
 }
 
-val Class<out FlowLogic<*>>.flowVersionAndInitiatingClass: Pair<Int, Class<out FlowLogic<*>>> get() {
-    var current: Class<*> = this
-    var found: Pair<Int, Class<out FlowLogic<*>>>? = null
-    while (true) {
-        val annotation = current.getDeclaredAnnotation(InitiatingFlow::class.java)
-        if (annotation != null) {
-            if (found != null) throw IllegalArgumentException("${InitiatingFlow::class.java.name} can only be annotated once")
-            require(annotation.version > 0) { "Flow versions have to be greater or equal to 1" }
-            found = annotation.version to uncheckedCast(current)
+val Class<out FlowLogic<*>>.flowVersionAndInitiatingClass: Pair<Int, Class<out FlowLogic<*>>>
+    get() {
+        var current: Class<*> = this
+        var found: Pair<Int, Class<out FlowLogic<*>>>? = null
+        while (true) {
+            val annotation = current.getDeclaredAnnotation(InitiatingFlow::class.java)
+            if (annotation != null) {
+                if (found != null) throw IllegalArgumentException("${InitiatingFlow::class.java.name} can only be annotated once")
+                require(annotation.version > 0) { "Flow versions have to be greater or equal to 1" }
+                found = annotation.version to uncheckedCast(current)
+            }
+            current = current.superclass
+                    ?: return found
+                    ?: throw IllegalArgumentException("$name, as a flow that initiates other flows, must be annotated with " +
+                    "${InitiatingFlow::class.java.name}. See https://docs.corda.net/api-flows.html#flowlogic-annotations.")
         }
-        current = current.superclass
-            ?: return found
-            ?: throw IllegalArgumentException("$name, as a flow that initiates other flows, must be annotated with " +
-                "${InitiatingFlow::class.java.name}. See https://docs.corda.net/api-flows.html#flowlogic-annotations.")
     }
-}
 
-val Class<out FlowLogic<*>>.appName: String get() {
-    val jarFile = Paths.get(protectionDomain.codeSource.location.toURI())
-    return if (jarFile.isRegularFile() && jarFile.toString().endsWith(".jar")) {
-        jarFile.fileName.toString().removeSuffix(".jar")
-    } else {
-        "<unknown>"
+val Class<out FlowLogic<*>>.appName: String
+    get() {
+        val jarFile = Paths.get(protectionDomain.codeSource.location.toURI())
+        return if (jarFile.isRegularFile() && jarFile.toString().endsWith(".jar")) {
+            jarFile.fileName.toString().removeSuffix(".jar")
+        } else {
+            "<unknown>"
+        }
     }
-}
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
index c8189063a6..42fd677f65 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
@@ -397,7 +397,7 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
         }
 
         val (ourFlowVersion, appName) = when (initiatedFlowFactory) {
-            // The flow version for the core flows is the platform version
+        // The flow version for the core flows is the platform version
             is InitiatedFlowFactory.Core -> serviceHub.myInfo.platformVersion to "corda"
             is InitiatedFlowFactory.CorDapp -> initiatedFlowFactory.flowVersion to initiatedFlowFactory.appName
         }
@@ -631,8 +631,8 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
         val serialized = try {
             message.serialize()
         } catch (e: Exception) {
-            when(e) {
-                // Handling Kryo and AMQP serialization problems. Unfortunately the two exception types do not share much of a common exception interface.
+            when (e) {
+            // Handling Kryo and AMQP serialization problems. Unfortunately the two exception types do not share much of a common exception interface.
                 is KryoException,
                 is NotSerializableException -> {
                     if (message !is ErrorSessionEnd || message.errorResponse == null) throw e
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/BFTNonValidatingNotaryService.kt b/node/src/main/kotlin/net/corda/node/services/transactions/BFTNonValidatingNotaryService.kt
index 8ea6e6af09..f0c1e17823 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/BFTNonValidatingNotaryService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/BFTNonValidatingNotaryService.kt
@@ -112,7 +112,7 @@ class BFTNonValidatingNotaryService(override val services: ServiceHubInternal,
                                             name = CordaX500Name.parse(it.party.name),
                                             owningKey = parsePublicKeyBase58(it.party.owningKey))))
                 },
-                toPersistentEntity = { (txHash, index) : StateRef, (id, inputIndex, requestingParty): UniquenessProvider.ConsumingTx ->
+                toPersistentEntity = { (txHash, index): StateRef, (id, inputIndex, requestingParty): UniquenessProvider.ConsumingTx ->
                     PersistedCommittedState(
                             id = PersistentStateRef(txHash.toString(), index),
                             consumingTxHash = id.toString(),
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/PersistentUniquenessProvider.kt b/node/src/main/kotlin/net/corda/node/services/transactions/PersistentUniquenessProvider.kt
index b17b9902fc..f669ae3426 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/PersistentUniquenessProvider.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/PersistentUniquenessProvider.kt
@@ -24,7 +24,7 @@ import javax.persistence.*
 class PersistentUniquenessProvider : UniquenessProvider, SingletonSerializeAsToken() {
 
     @MappedSuperclass
-    open class PersistentUniqueness (
+    open class PersistentUniqueness(
             @EmbeddedId
             var id: PersistentStateRef = PersistentStateRef(),
 
@@ -45,11 +45,11 @@ class PersistentUniquenessProvider : UniquenessProvider, SingletonSerializeAsTok
 
             @Column(name = "requesting_party_key", length = 255)
             var owningKey: String = ""
-    ): Serializable
+    ) : Serializable
 
     @Entity
     @javax.persistence.Table(name = "${NODE_DATABASE_PREFIX}notary_commit_log")
-    class PersistentNotaryCommit(id: PersistentStateRef, consumingTxHash: String, consumingIndex: Int, party: PersistentParty):
+    class PersistentNotaryCommit(id: PersistentStateRef, consumingTxHash: String, consumingIndex: Int, party: PersistentParty) :
             PersistentUniqueness(id, consumingTxHash, consumingIndex, party)
 
 
@@ -77,37 +77,37 @@ class PersistentUniquenessProvider : UniquenessProvider, SingletonSerializeAsTok
                                                     name = CordaX500Name.parse(it.party.name),
                                                     owningKey = parsePublicKeyBase58(it.party.owningKey))))
                         },
-                        toPersistentEntity = { (txHash, index) : StateRef, (id, inputIndex, requestingParty) : UniquenessProvider.ConsumingTx ->
+                        toPersistentEntity = { (txHash, index): StateRef, (id, inputIndex, requestingParty): UniquenessProvider.ConsumingTx ->
                             PersistentNotaryCommit(
                                     id = PersistentStateRef(txHash.toString(), index),
                                     consumingTxHash = id.toString(),
                                     consumingIndex = inputIndex,
                                     party = PersistentParty(requestingParty.name.toString(), requestingParty.owningKey.toBase58String())
                             )
-                    },
-                    persistentEntityClass = PersistentNotaryCommit::class.java
-            )
-        }
+                        },
+                        persistentEntityClass = PersistentNotaryCommit::class.java
+                )
+    }
 
     override fun commit(states: List<StateRef>, txId: SecureHash, callerIdentity: Party) {
 
         val conflict = mutex.locked {
-                    val conflictingStates = LinkedHashMap<StateRef, UniquenessProvider.ConsumingTx>()
-                    for (inputState in states) {
-                        val consumingTx = committedStates.get(inputState)
-                        if (consumingTx != null) conflictingStates[inputState] = consumingTx
-                    }
-                    if (conflictingStates.isNotEmpty()) {
-                        log.debug("Failure, input states already committed: ${conflictingStates.keys}")
-                        UniquenessProvider.Conflict(conflictingStates)
-                    } else {
-                        states.forEachIndexed { i, stateRef ->
-                            committedStates[stateRef] = UniquenessProvider.ConsumingTx(txId, i, callerIdentity)
-                        }
-                        log.debug("Successfully committed all input states: $states")
-                        null
-                    }
+            val conflictingStates = LinkedHashMap<StateRef, UniquenessProvider.ConsumingTx>()
+            for (inputState in states) {
+                val consumingTx = committedStates.get(inputState)
+                if (consumingTx != null) conflictingStates[inputState] = consumingTx
+            }
+            if (conflictingStates.isNotEmpty()) {
+                log.debug("Failure, input states already committed: ${conflictingStates.keys}")
+                UniquenessProvider.Conflict(conflictingStates)
+            } else {
+                states.forEachIndexed { i, stateRef ->
+                    committedStates[stateRef] = UniquenessProvider.ConsumingTx(txId, i, callerIdentity)
                 }
+                log.debug("Successfully committed all input states: $states")
+                null
+            }
+        }
 
         if (conflict != null) throw UniquenessException(conflict)
     }
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/RaftUniquenessProvider.kt b/node/src/main/kotlin/net/corda/node/services/transactions/RaftUniquenessProvider.kt
index 93daf5a23a..130f954a50 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/RaftUniquenessProvider.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/RaftUniquenessProvider.kt
@@ -97,7 +97,8 @@ class RaftUniquenessProvider(private val services: ServiceHubInternal, private v
     fun start() {
         log.info("Creating Copycat server, log stored in: ${storagePath.toFile()}")
         val stateMachineFactory = {
-            DistributedImmutableMap(db, RaftUniquenessProvider.Companion::createMap) }
+            DistributedImmutableMap(db, RaftUniquenessProvider.Companion::createMap)
+        }
         val address = raftConfig.nodeAddress.let { Address(it.host, it.port) }
         val storage = buildStorage(storagePath)
         val transport = buildTransport(transportConfiguration)
@@ -110,6 +111,7 @@ class RaftUniquenessProvider(private val services: ServiceHubInternal, private v
                                        serializer: Serializer) {
                         writeMap(obj.entries, buffer, serializer)
                     }
+
                     override fun read(type: Class<DistributedImmutableMap.Commands.PutAll<*, *>>,
                                       buffer: BufferInput<out BufferInput<*>>,
                                       serializer: Serializer): DistributedImmutableMap.Commands.PutAll<Any, Any> {
diff --git a/node/src/main/kotlin/net/corda/node/services/vault/HibernateQueryCriteriaParser.kt b/node/src/main/kotlin/net/corda/node/services/vault/HibernateQueryCriteriaParser.kt
index 30c32220f7..7b8816b361 100644
--- a/node/src/main/kotlin/net/corda/node/services/vault/HibernateQueryCriteriaParser.kt
+++ b/node/src/main/kotlin/net/corda/node/services/vault/HibernateQueryCriteriaParser.kt
@@ -36,11 +36,11 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
     // incrementally build list of root entities (for later use in Sort parsing)
     private val rootEntities = mutableMapOf<Class<out PersistentState>, Root<*>>(Pair(VaultSchemaV1.VaultStates::class.java, vaultStates))
     private val aggregateExpressions = mutableListOf<Expression<*>>()
-    private val commonPredicates = mutableMapOf<Pair<String,Operator>, Predicate>()   // schema attribute Name, operator -> predicate
+    private val commonPredicates = mutableMapOf<Pair<String, Operator>, Predicate>()   // schema attribute Name, operator -> predicate
 
     var stateTypes: Vault.StateStatus = Vault.StateStatus.UNCONSUMED
 
-    override fun parseCriteria(criteria: QueryCriteria.VaultQueryCriteria) : Collection<Predicate> {
+    override fun parseCriteria(criteria: QueryCriteria.VaultQueryCriteria): Collection<Predicate> {
         log.trace { "Parsing VaultQueryCriteria: $criteria" }
         val predicateSet = mutableSetOf<Predicate>()
 
@@ -48,7 +48,7 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
         criteria.softLockingCondition?.let {
             val softLocking = criteria.softLockingCondition
             val type = softLocking!!.type
-            when(type) {
+            when (type) {
                 QueryCriteria.SoftLockingType.UNLOCKED_ONLY ->
                     predicateSet.add(criteriaBuilder.and(vaultStates.get<String>("lockId").isNull))
                 QueryCriteria.SoftLockingType.LOCKED_ONLY ->
@@ -56,7 +56,7 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
                 QueryCriteria.SoftLockingType.UNLOCKED_AND_SPECIFIED -> {
                     require(softLocking.lockIds.isNotEmpty()) { "Must specify one or more lockIds" }
                     predicateSet.add(criteriaBuilder.or(vaultStates.get<String>("lockId").isNull,
-                                                        vaultStates.get<String>("lockId").`in`(softLocking.lockIds.map { it.toString() })))
+                            vaultStates.get<String>("lockId").`in`(softLocking.lockIds.map { it.toString() })))
                 }
                 QueryCriteria.SoftLockingType.SPECIFIED -> {
                     require(softLocking.lockIds.isNotEmpty()) { "Must specify one or more lockIds" }
@@ -154,7 +154,7 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
     }
 
     private fun <O> parseExpression(entityRoot: Root<O>, expression: CriteriaExpression<O, Boolean>, predicateSet: MutableSet<Predicate>) {
-        if (expression is CriteriaExpression.AggregateFunctionExpression<O,*>) {
+        if (expression is CriteriaExpression.AggregateFunctionExpression<O, *>) {
             parseAggregateFunction(entityRoot, expression)
         } else {
             predicateSet.add(parseExpression(entityRoot, expression) as Predicate)
@@ -221,7 +221,7 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
         }
     }
 
-    override fun parseCriteria(criteria: QueryCriteria.FungibleAssetQueryCriteria) : Collection<Predicate> {
+    override fun parseCriteria(criteria: QueryCriteria.FungibleAssetQueryCriteria): Collection<Predicate> {
         log.trace { "Parsing FungibleAssetQueryCriteria: $criteria" }
 
         val predicateSet = mutableSetOf<Predicate>()
@@ -265,7 +265,7 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
         return predicateSet
     }
 
-    override fun parseCriteria(criteria: QueryCriteria.LinearStateQueryCriteria) : Collection<Predicate> {
+    override fun parseCriteria(criteria: QueryCriteria.LinearStateQueryCriteria): Collection<Predicate> {
         log.trace { "Parsing LinearStateQueryCriteria: $criteria" }
 
         val predicateSet = mutableSetOf<Predicate>()
@@ -314,8 +314,7 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
 
             // resolve general criteria expressions
             parseExpression(entityRoot, criteria.expression, predicateSet)
-        }
-        catch (e: Exception) {
+        } catch (e: Exception) {
             e.message?.let { message ->
                 if (message.contains("Not an entity"))
                     throw VaultQueryException("""
@@ -386,8 +385,7 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
                     log.warn("Overriding previous attribute [${VaultSchemaV1.VaultStates::stateStatus.name}] value $existingStatus with ${criteria.status}")
                     commonPredicates.replace(predicateID, criteriaBuilder.equal(vaultStates.get<Vault.StateStatus>(VaultSchemaV1.VaultStates::stateStatus.name), criteria.status))
                 }
-            }
-            else {
+            } else {
                 commonPredicates.put(predicateID, criteriaBuilder.equal(vaultStates.get<Vault.StateStatus>(VaultSchemaV1.VaultStates::stateStatus.name), criteria.status))
             }
         }
@@ -417,7 +415,7 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
 
         sorting.columns.map { (sortAttribute, direction) ->
             val (entityStateClass, entityStateAttributeParent, entityStateAttributeChild) =
-                    when(sortAttribute) {
+                    when (sortAttribute) {
                         is SortAttribute.Standard -> parse(sortAttribute.attribute)
                         is SortAttribute.Custom -> Triple(sortAttribute.entityStateClass, sortAttribute.entityStateColumnName, null)
                     }
@@ -451,8 +449,8 @@ class HibernateQueryCriteriaParser(val contractStateType: Class<out ContractStat
     }
 
     private fun parse(sortAttribute: Sort.Attribute): Triple<Class<out PersistentState>, String, String?> {
-        val entityClassAndColumnName : Triple<Class<out PersistentState>, String, String?> =
-                when(sortAttribute) {
+        val entityClassAndColumnName: Triple<Class<out PersistentState>, String, String?> =
+                when (sortAttribute) {
                     is Sort.CommonStateAttribute -> {
                         Triple(VaultSchemaV1.VaultStates::class.java, sortAttribute.attributeParent, sortAttribute.attributeChild)
                     }
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 6564859865..3b5236d97a 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
@@ -247,7 +247,7 @@ class NodeVaultService(private val clock: Clock, private val keyManagementServic
             val vaultStates = criteriaUpdate.from(VaultSchemaV1.VaultStates::class.java)
             val stateStatusPredication = criteriaBuilder.equal(vaultStates.get<Vault.StateStatus>(VaultSchemaV1.VaultStates::stateStatus.name), Vault.StateStatus.UNCONSUMED)
             val lockIdPredicate = criteriaBuilder.or(vaultStates.get<String>(VaultSchemaV1.VaultStates::lockId.name).isNull,
-                                  criteriaBuilder.equal(vaultStates.get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString()))
+                    criteriaBuilder.equal(vaultStates.get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString()))
             val persistentStateRefs = stateRefs.map { PersistentStateRef(it.txhash.bytes.toHexString(), it.index) }
             val compositeKey = vaultStates.get<PersistentStateRef>(VaultSchemaV1.VaultStates::stateRef.name)
             val stateRefsPredicate = criteriaBuilder.and(compositeKey.`in`(persistentStateRefs))
@@ -468,8 +468,7 @@ class NodeVaultService(private val clock: Clock, private val keyManagementServic
                                         vaultState.lockId,
                                         vaultState.lockUpdateTime))
                                 statesAndRefs.add(StateAndRef(state, stateRef))
-                            }
-                            else {
+                            } else {
                                 // TODO: improve typing of returned other results
                                 log.debug { "OtherResults: ${Arrays.toString(result.toArray())}" }
                                 otherResults.addAll(result.toArray().asList())
diff --git a/node/src/main/kotlin/net/corda/node/services/vault/VaultSchema.kt b/node/src/main/kotlin/net/corda/node/services/vault/VaultSchema.kt
index 8dd74ab76f..0c8ba52a4e 100644
--- a/node/src/main/kotlin/net/corda/node/services/vault/VaultSchema.kt
+++ b/node/src/main/kotlin/net/corda/node/services/vault/VaultSchema.kt
@@ -25,7 +25,7 @@ object VaultSchema
  */
 @CordaSerializable
 object VaultSchemaV1 : MappedSchema(schemaFamily = VaultSchema.javaClass, version = 1,
-                                    mappedTypes = listOf(VaultStates::class.java, VaultLinearStates::class.java, VaultFungibleStates::class.java, VaultTxnNote::class.java)) {
+        mappedTypes = listOf(VaultStates::class.java, VaultLinearStates::class.java, VaultFungibleStates::class.java, VaultTxnNote::class.java)) {
     @Entity
     @Table(name = "vault_states",
             indexes = arrayOf(Index(name = "state_status_idx", columnList = "state_status")))
@@ -90,8 +90,8 @@ object VaultSchemaV1 : MappedSchema(schemaFamily = VaultSchema.javaClass, versio
     ) : PersistentState() {
         constructor(uid: UniqueIdentifier, _participants: List<AbstractParty>) :
                 this(externalId = uid.externalId,
-                     uuid = uid.id,
-                     participants = _participants.toMutableSet())
+                        uuid = uid.id,
+                        participants = _participants.toMutableSet())
     }
 
     @Entity
@@ -131,27 +131,27 @@ object VaultSchemaV1 : MappedSchema(schemaFamily = VaultSchema.javaClass, versio
     ) : PersistentState() {
         constructor(_owner: AbstractParty, _quantity: Long, _issuerParty: AbstractParty, _issuerRef: OpaqueBytes, _participants: List<AbstractParty>) :
                 this(owner = _owner,
-                     quantity = _quantity,
-                     issuer = _issuerParty,
-                     issuerRef = _issuerRef.bytes,
-                     participants = _participants.toMutableSet())
+                        quantity = _quantity,
+                        issuer = _issuerParty,
+                        issuerRef = _issuerRef.bytes,
+                        participants = _participants.toMutableSet())
     }
 
     @Entity
     @Table(name = "vault_transaction_notes",
-           indexes = arrayOf(Index(name = "seq_no_index", columnList = "seq_no"),
-                             Index(name = "transaction_id_index", columnList = "transaction_id")))
+            indexes = arrayOf(Index(name = "seq_no_index", columnList = "seq_no"),
+                    Index(name = "transaction_id_index", columnList = "transaction_id")))
     class VaultTxnNote(
-        @Id
-        @GeneratedValue
-        @Column(name = "seq_no")
-        var seqNo: Int,
+            @Id
+            @GeneratedValue
+            @Column(name = "seq_no")
+            var seqNo: Int,
 
-        @Column(name = "transaction_id", length = 64)
-        var txId: String,
+            @Column(name = "transaction_id", length = 64)
+            var txId: String,
 
-        @Column(name = "note")
-        var note: String
+            @Column(name = "note")
+            var note: String
     ) : Serializable {
         constructor(txId: String, note: String) : this(0, txId, note)
     }
diff --git a/node/src/main/kotlin/net/corda/node/shell/FlowWatchPrintingSubscriber.kt b/node/src/main/kotlin/net/corda/node/shell/FlowWatchPrintingSubscriber.kt
index 32920ffd23..235c2bcbe9 100644
--- a/node/src/main/kotlin/net/corda/node/shell/FlowWatchPrintingSubscriber.kt
+++ b/node/src/main/kotlin/net/corda/node/shell/FlowWatchPrintingSubscriber.kt
@@ -59,7 +59,7 @@ class FlowWatchPrintingSubscriber(private val toStream: RenderPrintWriter) : Sub
     }
 
     private fun createStateMachinesTable(): TableElement {
-        val table = TableElement(1,2,1,2).overflow(Overflow.HIDDEN).rightCellPadding(1)
+        val table = TableElement(1, 2, 1, 2).overflow(Overflow.HIDDEN).rightCellPadding(1)
         val header = RowElement(true).add("Id", "Flow name", "Initiator", "Status").style(Decoration.bold.fg(Color.black).bg(Color.white))
         table.add(header)
         return table
@@ -102,12 +102,12 @@ class FlowWatchPrintingSubscriber(private val toStream: RenderPrintWriter) : Sub
     }
 
     private fun formatFlowId(flowId: StateMachineRunId): String {
-        return flowId.toString().removeSurrounding("[","]")
+        return flowId.toString().removeSurrounding("[", "]")
     }
 
     private fun formatFlowInitiator(flowInitiator: FlowInitiator): String {
         return when (flowInitiator) {
-            is FlowInitiator.Scheduled ->  flowInitiator.scheduledState.ref.toString()
+            is FlowInitiator.Scheduled -> flowInitiator.scheduledState.ref.toString()
             is FlowInitiator.Shell -> "Shell" // TODO Change when we will have more information on shell user.
             is FlowInitiator.Peer -> flowInitiator.party.name.organisation
             is FlowInitiator.RPC -> "RPC: " + flowInitiator.username
@@ -117,7 +117,7 @@ class FlowWatchPrintingSubscriber(private val toStream: RenderPrintWriter) : Sub
 
     private fun formatFlowResult(flowResult: Try<*>): String {
         fun successFormat(value: Any?): String {
-            return when(value) {
+            return when (value) {
                 is SignedTransaction -> "Tx ID: " + value.id.toString()
                 is kotlin.Unit -> "No return value"
                 null -> "No return value"
diff --git a/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt b/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt
index 07ee7e3f96..a671fdb1dd 100644
--- a/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt
+++ b/node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt
@@ -247,11 +247,11 @@ object InteractiveShell {
                 // Wait for the flow to end and the progress tracker to notice. By the time the latch is released
                 // the tracker is done with the screen.
                 latch.await()
-            } catch(e: InterruptedException) {
+            } catch (e: InterruptedException) {
                 ANSIProgressRenderer.progressTracker = null
                 // TODO: When the flow framework allows us to kill flows mid-flight, do so here.
             }
-        } catch(e: NoApplicableConstructor) {
+        } catch (e: NoApplicableConstructor) {
             output.println("No matching constructor found:", Color.red)
             e.errors.forEach { output.println("- $it", Color.red) }
         } finally {
@@ -305,14 +305,14 @@ object InteractiveShell {
                     continue
                 }
                 return invoke(flow)
-            } catch(e: StringToMethodCallParser.UnparseableCallException.MissingParameter) {
+            } catch (e: StringToMethodCallParser.UnparseableCallException.MissingParameter) {
                 errors.add("${getPrototype()}: missing parameter ${e.paramName}")
-            } catch(e: StringToMethodCallParser.UnparseableCallException.TooManyParameters) {
+            } catch (e: StringToMethodCallParser.UnparseableCallException.TooManyParameters) {
                 errors.add("${getPrototype()}: too many parameters")
-            } catch(e: StringToMethodCallParser.UnparseableCallException.ReflectionDataMissing) {
+            } catch (e: StringToMethodCallParser.UnparseableCallException.ReflectionDataMissing) {
                 val argTypes = ctor.parameterTypes.map { it.simpleName }
                 errors.add("$argTypes: <constructor missing parameter reflection data>")
-            } catch(e: StringToMethodCallParser.UnparseableCallException) {
+            } catch (e: StringToMethodCallParser.UnparseableCallException) {
                 val argTypes = ctor.parameterTypes.map { it.simpleName }
                 errors.add("$argTypes: ${e.message}")
             }
@@ -506,7 +506,7 @@ object InteractiveShell {
             } finally {
                 try {
                     value.close()
-                } catch(e: IOException) {
+                } catch (e: IOException) {
                     // Ignore.
                 }
             }
diff --git a/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt b/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt
index ab9f83e884..62508f0e2b 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt
@@ -9,9 +9,9 @@ import java.util.*
  * behaviour is unpredictable! There is a best-effort check for double inserts, but this should *not* be relied on, so
  * ONLY USE THIS IF YOUR TABLE IS APPEND-ONLY
  */
-class AppendOnlyPersistentMap<K, V, E, out EK> (
+class AppendOnlyPersistentMap<K, V, E, out EK>(
         val toPersistentEntityKey: (K) -> EK,
-        val fromPersistentEntity: (E) -> Pair<K,V>,
+        val fromPersistentEntity: (E) -> Pair<K, V>,
         val toPersistentEntity: (key: K, value: V) -> E,
         val persistentEntityClass: Class<E>,
         cacheBound: Long = 1024
@@ -48,10 +48,11 @@ class AppendOnlyPersistentMap<K, V, E, out EK> (
         return result.map { x -> fromPersistentEntity(x) }.asSequence()
     }
 
-    private tailrec fun set(key: K, value: V, logWarning: Boolean, store: (K,V) -> V?): Boolean {
+    private tailrec fun set(key: K, value: V, logWarning: Boolean, store: (K, V) -> V?): Boolean {
         var insertionAttempt = false
         var isUnique = true
-        val existingInCache = cache.get(key) { // Thread safe, if multiple threads may wait until the first one has loaded.
+        val existingInCache = cache.get(key) {
+            // Thread safe, if multiple threads may wait until the first one has loaded.
             insertionAttempt = true
             // Key wasn't in the cache and might be in the underlying storage.
             // Depending on 'store' method, this may insert without checking key duplication or it may avoid inserting a duplicated key.
@@ -85,8 +86,8 @@ class AppendOnlyPersistentMap<K, V, E, out EK> (
      * If the map previously contained a mapping for the key, the behaviour is unpredictable and may throw an error from the underlying storage.
      */
     operator fun set(key: K, value: V) =
-            set(key, value, logWarning = false) {
-                k, v -> DatabaseTransactionManager.current().session.save(toPersistentEntity(k, v))
+            set(key, value, logWarning = false) { k, v ->
+                DatabaseTransactionManager.current().session.save(toPersistentEntity(k, v))
                 null
             }
 
@@ -96,8 +97,7 @@ class AppendOnlyPersistentMap<K, V, E, out EK> (
      * @return true if added key was unique, otherwise false
      */
     fun addWithDuplicatesAllowed(key: K, value: V, logWarning: Boolean = true): Boolean =
-            set(key, value, logWarning) {
-                k, v ->
+            set(key, value, logWarning) { k, v ->
                 val existingEntry = DatabaseTransactionManager.current().session.find(persistentEntityClass, toPersistentEntityKey(k))
                 if (existingEntry == null) {
                     DatabaseTransactionManager.current().session.save(toPersistentEntity(k, v))
@@ -107,7 +107,7 @@ class AppendOnlyPersistentMap<K, V, E, out EK> (
                 }
             }
 
-    fun putAll(entries: Map<K,V>) {
+    fun putAll(entries: Map<K, V>) {
         entries.forEach {
             set(it.key, it.value)
         }
diff --git a/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt b/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
index c1d6d8d0b7..0bf9885945 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
@@ -24,14 +24,14 @@ const val NODE_DATABASE_PREFIX = "node_"
 
 //HikariDataSource implements Closeable which allows CordaPersistence to be Closeable
 class CordaPersistence(var dataSource: HikariDataSource, private val schemaService: SchemaService,
-                       private val createIdentityService: ()-> IdentityService, databaseProperties: Properties): Closeable {
+                       private val createIdentityService: () -> IdentityService, databaseProperties: Properties) : Closeable {
     var transactionIsolationLevel = parserTransactionIsolationLevel(databaseProperties.getProperty("transactionIsolationLevel"))
 
-   val hibernateConfig: HibernateConfiguration by lazy {
+    val hibernateConfig: HibernateConfiguration by lazy {
         transaction {
             HibernateConfiguration(schemaService, databaseProperties, createIdentityService)
         }
-   }
+    }
 
     val entityManagerFactory: SessionFactory by lazy {
         transaction {
@@ -70,8 +70,7 @@ class CordaPersistence(var dataSource: HikariDataSource, private val schemaServi
 
         return if (outer != null) {
             outer.statement()
-        }
-        else {
+        } else {
             inTopLevelTransaction(transactionIsolation, repetitionAttempts, statement)
         }
     }
@@ -84,19 +83,16 @@ class CordaPersistence(var dataSource: HikariDataSource, private val schemaServi
                 val answer = transaction.statement()
                 transaction.commit()
                 return answer
-            }
-            catch (e: SQLException) {
+            } catch (e: SQLException) {
                 transaction.rollback()
                 repetitions++
                 if (repetitions >= repetitionAttempts) {
                     throw e
                 }
-            }
-            catch (e: Throwable) {
+            } catch (e: Throwable) {
                 transaction.rollback()
                 throw e
-            }
-            finally {
+            } finally {
                 transaction.close()
             }
         }
@@ -170,7 +166,7 @@ private class DatabaseTransactionWrappingSubscriber<U>(val db: CordaPersistence?
 }
 
 // A subscriber that wraps another but does not pass on observations to it.
-private class NoOpSubscriber<U>(t: Subscriber<in U>): Subscriber<U>(t) {
+private class NoOpSubscriber<U>(t: Subscriber<in U>) : Subscriber<U>(t) {
     override fun onCompleted() {
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/utilities/DatabaseTransactionManager.kt b/node/src/main/kotlin/net/corda/node/utilities/DatabaseTransactionManager.kt
index f847080433..9016112f7b 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/DatabaseTransactionManager.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/DatabaseTransactionManager.kt
@@ -30,7 +30,7 @@ class DatabaseTransaction(isolation: Int, val threadLocal: ThreadLocal<DatabaseT
     }
 
     val session: Session by sessionDelegate
-    private lateinit var hibernateTransaction : Transaction
+    private lateinit var hibernateTransaction: Transaction
 
     private val outerTransaction: DatabaseTransaction? = threadLocal.get()
 
diff --git a/node/src/main/kotlin/net/corda/node/utilities/KeyStoreUtilities.kt b/node/src/main/kotlin/net/corda/node/utilities/KeyStoreUtilities.kt
index 5966f88599..0257302d6d 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/KeyStoreUtilities.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/KeyStoreUtilities.kt
@@ -147,7 +147,7 @@ fun KeyStore.getCertificateAndKeyPair(alias: String, keyPassword: String): Certi
  */
 fun KeyStore.getX509Certificate(alias: String): X509Certificate {
     val certificate = getCertificate(alias) ?: throw IllegalArgumentException("No certificate under alias \"$alias\".")
-    return certificate as? X509Certificate  ?: throw IllegalArgumentException("Certificate under alias \"$alias\" is not an X.509 certificate.")
+    return certificate as? X509Certificate ?: throw IllegalArgumentException("Certificate under alias \"$alias\" is not an X.509 certificate.")
 }
 
 /**
diff --git a/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingCache.kt b/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingCache.kt
index c456f8af3b..a81ce259e5 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingCache.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingCache.kt
@@ -8,7 +8,7 @@ import com.google.common.util.concurrent.ListenableFuture
 
 class NonInvalidatingCache<K, V> private constructor(
         val cache: LoadingCache<K, V>
-): LoadingCache<K, V> by cache {
+) : LoadingCache<K, V> by cache {
 
     constructor(bound: Long, concurrencyLevel: Int, loadFunction: (K) -> V) :
             this(buildCache(bound, concurrencyLevel, loadFunction))
@@ -25,6 +25,7 @@ class NonInvalidatingCache<K, V> private constructor(
         override fun reload(key: K, oldValue: V): ListenableFuture<V> {
             throw IllegalStateException("Non invalidating cache refreshed")
         }
+
         override fun load(key: K) = loadFunction(key)
         override fun loadAll(keys: Iterable<K>): MutableMap<K, V> {
             return super.loadAll(keys)
diff --git a/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingUnboundCache.kt b/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingUnboundCache.kt
index 44caaa9adb..8719a4e448 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingUnboundCache.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingUnboundCache.kt
@@ -6,10 +6,10 @@ import com.google.common.util.concurrent.ListenableFuture
 
 class NonInvalidatingUnboundCache<K, V> private constructor(
         val cache: LoadingCache<K, V>
-): LoadingCache<K, V> by cache {
+) : LoadingCache<K, V> by cache {
 
     constructor(concurrencyLevel: Int, loadFunction: (K) -> V, removalListener: RemovalListener<K, V> = RemovalListener {},
-                keysToPreload: () -> Iterable<K> = { emptyList() } ) :
+                keysToPreload: () -> Iterable<K> = { emptyList() }) :
             this(buildCache(concurrencyLevel, loadFunction, removalListener, keysToPreload))
 
     private companion object {
@@ -27,6 +27,7 @@ class NonInvalidatingUnboundCache<K, V> private constructor(
         override fun reload(key: K, oldValue: V): ListenableFuture<V> {
             throw IllegalStateException("Non invalidating cache refreshed")
         }
+
         override fun load(key: K) = loadFunction(key)
         override fun loadAll(keys: Iterable<K>): MutableMap<K, V> {
             return super.loadAll(keys)
diff --git a/node/src/main/kotlin/net/corda/node/utilities/PersistentMap.kt b/node/src/main/kotlin/net/corda/node/utilities/PersistentMap.kt
index 55acb14efc..c24ce3c229 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/PersistentMap.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/PersistentMap.kt
@@ -11,9 +11,9 @@ import java.util.*
 /**
  * Implements an unbound caching layer on top of a table accessed via Hibernate mapping.
  */
-class PersistentMap<K, V, E, out EK> (
+class PersistentMap<K, V, E, out EK>(
         val toPersistentEntityKey: (K) -> EK,
-        val fromPersistentEntity: (E) -> Pair<K,V>,
+        val fromPersistentEntity: (E) -> Pair<K, V>,
         val toPersistentEntity: (key: K, value: V) -> E,
         val persistentEntityClass: Class<E>
 ) : MutableMap<K, V>, AbstractMap<K, V>() {
@@ -34,7 +34,7 @@ class PersistentMap<K, V, E, out EK> (
         getAll(session.createQuery(criteriaQuery).resultList.map { e -> fromPersistentEntity(e as E).first }.asIterable())
     }
 
-    class ExplicitRemoval<K, V, E, EK>(private val toPersistentEntityKey: (K) -> EK, private val persistentEntityClass: Class<E>): RemovalListener<K,V> {
+    class ExplicitRemoval<K, V, E, EK>(private val toPersistentEntityKey: (K) -> EK, private val persistentEntityClass: Class<E>) : RemovalListener<K, V> {
         override fun onRemoval(notification: RemovalNotification<K, V>?) {
             when (notification?.cause) {
                 RemovalCause.EXPLICIT -> {
@@ -47,7 +47,8 @@ class PersistentMap<K, V, E, out EK> (
                 RemovalCause.EXPIRED, RemovalCause.SIZE, RemovalCause.COLLECTED -> {
                     log.error("Entry was removed from cache!!!")
                 }
-                RemovalCause.REPLACED -> {}
+                RemovalCause.REPLACED -> {
+                }
             }
         }
     }
@@ -62,10 +63,11 @@ class PersistentMap<K, V, E, out EK> (
 
     override val size get() = cache.size().toInt()
 
-    private tailrec fun set(key: K, value: V, logWarning: Boolean = true, store: (K,V) -> V?, replace: (K, V) -> Unit) : Boolean {
+    private tailrec fun set(key: K, value: V, logWarning: Boolean = true, store: (K, V) -> V?, replace: (K, V) -> Unit): Boolean {
         var insertionAttempt = false
         var isUnique = true
-        val existingInCache = cache.get(key) { // Thread safe, if multiple threads may wait until the first one has loaded.
+        val existingInCache = cache.get(key) {
+            // Thread safe, if multiple threads may wait until the first one has loaded.
             insertionAttempt = true
             // Value wasn't in the cache and wasn't in DB (because the cache is unbound).
             // Store the value, depending on store implementation this may replace existing entry in DB.
@@ -98,7 +100,7 @@ class PersistentMap<K, V, E, out EK> (
     operator fun set(key: K, value: V) =
             set(key, value,
                     logWarning = false,
-                    store =  { k: K, v: V ->
+                    store = { k: K, v: V ->
                         DatabaseTransactionManager.current().session.save(toPersistentEntity(k, v))
                         null
                     },
@@ -145,10 +147,10 @@ class PersistentMap<K, V, E, out EK> (
     private fun merge(key: K, value: V): V? {
         val existingEntry = DatabaseTransactionManager.current().session.find(persistentEntityClass, toPersistentEntityKey(key))
         return if (existingEntry != null) {
-            DatabaseTransactionManager.current().session.merge(toPersistentEntity(key,value))
+            DatabaseTransactionManager.current().session.merge(toPersistentEntity(key, value))
             fromPersistentEntity(existingEntry).second
         } else {
-            DatabaseTransactionManager.current().session.save(toPersistentEntity(key,value))
+            DatabaseTransactionManager.current().session.save(toPersistentEntity(key, value))
             null
         }
     }
@@ -193,56 +195,59 @@ class PersistentMap<K, V, E, out EK> (
         }
     }
 
-    override val keys: MutableSet<K> get() {
-        return object : AbstractSet<K>() {
-            override val size: Int get() = this@PersistentMap.size
-            override fun iterator(): MutableIterator<K> {
-                return object : MutableIterator<K> {
-                    private val entryIterator = EntryIterator()
+    override val keys: MutableSet<K>
+        get() {
+            return object : AbstractSet<K>() {
+                override val size: Int get() = this@PersistentMap.size
+                override fun iterator(): MutableIterator<K> {
+                    return object : MutableIterator<K> {
+                        private val entryIterator = EntryIterator()
 
-                    override fun hasNext(): Boolean = entryIterator.hasNext()
-                    override fun next(): K = entryIterator.next().key
-                    override fun remove() {
-                        entryIterator.remove()
+                        override fun hasNext(): Boolean = entryIterator.hasNext()
+                        override fun next(): K = entryIterator.next().key
+                        override fun remove() {
+                            entryIterator.remove()
+                        }
                     }
                 }
             }
         }
-    }
 
-    override val values: MutableCollection<V> get() {
-        return object : AbstractCollection<V>() {
-            override val size: Int get() = this@PersistentMap.size
-            override fun iterator(): MutableIterator<V> {
-                return object : MutableIterator<V> {
-                    private val entryIterator = EntryIterator()
+    override val values: MutableCollection<V>
+        get() {
+            return object : AbstractCollection<V>() {
+                override val size: Int get() = this@PersistentMap.size
+                override fun iterator(): MutableIterator<V> {
+                    return object : MutableIterator<V> {
+                        private val entryIterator = EntryIterator()
 
-                    override fun hasNext(): Boolean = entryIterator.hasNext()
-                    override fun next(): V = entryIterator.next().value
-                    override fun remove() {
-                        entryIterator.remove()
+                        override fun hasNext(): Boolean = entryIterator.hasNext()
+                        override fun next(): V = entryIterator.next().value
+                        override fun remove() {
+                            entryIterator.remove()
+                        }
                     }
                 }
             }
         }
-    }
 
-    override val entries: MutableSet<MutableMap.MutableEntry<K, V>> get() {
-        return object : AbstractSet<MutableMap.MutableEntry<K, V>>() {
-            override val size: Int get() = this@PersistentMap.size
-            override fun iterator(): MutableIterator<MutableMap.MutableEntry<K, V>> {
-                return object : MutableIterator<MutableMap.MutableEntry<K, V>> {
-                    private val entryIterator = EntryIterator()
+    override val entries: MutableSet<MutableMap.MutableEntry<K, V>>
+        get() {
+            return object : AbstractSet<MutableMap.MutableEntry<K, V>>() {
+                override val size: Int get() = this@PersistentMap.size
+                override fun iterator(): MutableIterator<MutableMap.MutableEntry<K, V>> {
+                    return object : MutableIterator<MutableMap.MutableEntry<K, V>> {
+                        private val entryIterator = EntryIterator()
 
-                    override fun hasNext(): Boolean = entryIterator.hasNext()
-                    override fun next(): MutableMap.MutableEntry<K, V> = entryIterator.next()
-                    override fun remove() {
-                        entryIterator.remove()
+                        override fun hasNext(): Boolean = entryIterator.hasNext()
+                        override fun next(): MutableMap.MutableEntry<K, V> = entryIterator.next()
+                        override fun remove() {
+                            entryIterator.remove()
+                        }
                     }
                 }
             }
         }
-    }
 
     override fun put(key: K, value: V): V? {
         val old = cache.get(key)
diff --git a/node/src/main/kotlin/net/corda/node/utilities/TestClock.kt b/node/src/main/kotlin/net/corda/node/utilities/TestClock.kt
index e582f45147..60af87f895 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/TestClock.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/TestClock.kt
@@ -21,7 +21,8 @@ class TestClock(private var delegateClock: Clock = Clock.systemUTC()) : MutableC
 
     override fun toToken(context: SerializeAsTokenContext) = token.registerWithContext(context, this)
 
-    @Synchronized fun updateDate(date: LocalDate): Boolean {
+    @Synchronized
+    fun updateDate(date: LocalDate): Boolean {
         val currentDate = LocalDate.now(this)
         if (currentDate.isBefore(date)) {
             // It's ok to increment
diff --git a/node/src/main/kotlin/net/corda/node/utilities/X509Utilities.kt b/node/src/main/kotlin/net/corda/node/utilities/X509Utilities.kt
index a9685fd910..4dfa07ec09 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/X509Utilities.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/X509Utilities.kt
@@ -115,7 +115,7 @@ object X509Utilities {
                           subjectPublicKey: PublicKey,
                           validityWindow: Pair<Duration, Duration> = DEFAULT_VALIDITY_WINDOW,
                           nameConstraints: NameConstraints? = null): X509CertificateHolder
-    = createCertificate(certificateType, issuerCertificate, issuerKeyPair, subject.x500Name, subjectPublicKey, validityWindow, nameConstraints)
+            = createCertificate(certificateType, issuerCertificate, issuerKeyPair, subject.x500Name, subjectPublicKey, validityWindow, nameConstraints)
 
     /**
      * Create a X509 v3 certificate for use as a CA or for TLS. This does not require a [CordaX500Name] because the
@@ -267,9 +267,9 @@ object X509Utilities {
      * @param nameConstraints any name constraints to impose on certificates signed by the generated certificate.
      */
     internal fun createCertificate(certificateType: CertificateType, issuer: X500Name, issuerKeyPair: KeyPair,
-                          subject: X500Name, subjectPublicKey: PublicKey,
-                          validityWindow: Pair<Date, Date>,
-                          nameConstraints: NameConstraints? = null): X509CertificateHolder {
+                                   subject: X500Name, subjectPublicKey: PublicKey,
+                                   validityWindow: Pair<Date, Date>,
+                                   nameConstraints: NameConstraints? = null): X509CertificateHolder {
 
         val signatureScheme = Crypto.findSignatureScheme(issuerKeyPair.private)
         val provider = Crypto.findProvider(signatureScheme.providerName)
diff --git a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
index 6a38dde99a..97dab2aaa7 100644
--- a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
+++ b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
@@ -91,10 +91,10 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
     @Test
     public void unconsumedStatesForStateRefsSortedByTxnId() {
         Vault<LinearState> issuedStates =
-            database.transaction(tx -> {
-                VaultFiller.fillWithSomeTestLinearStates(services, 8);
-                return VaultFiller.fillWithSomeTestLinearStates(services, 2);
-            });
+                database.transaction(tx -> {
+                    VaultFiller.fillWithSomeTestLinearStates(services, 8);
+                    return VaultFiller.fillWithSomeTestLinearStates(services, 2);
+                });
         database.transaction(tx -> {
             Stream<StateRef> stateRefsStream = StreamSupport.stream(issuedStates.getStates().spliterator(), false).map(StateAndRef::getRef);
             List<StateRef> stateRefs = stateRefsStream.collect(Collectors.toList());
@@ -120,7 +120,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
         database.transaction(tx -> {
             VaultFiller.fillWithSomeTestCash(services,
                     new Amount<Currency>(100, Currency.getInstance("USD")),
-                                 issuerServices,
+                    issuerServices,
                     TestConstants.getDUMMY_NOTARY(),
                     3,
                     3,
@@ -151,14 +151,14 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
         List<String> dealIds = Arrays.asList("123", "456", "789");
         @SuppressWarnings("unchecked")
         Triple<StateAndRef<LinearState>, UniqueIdentifier, Vault<DealState>> ids =
-            database.transaction((DatabaseTransaction tx) -> {
-                Vault<LinearState> states = VaultFiller.fillWithSomeTestLinearStates(services, 10, null);
-                StateAndRef<LinearState> linearState = states.getStates().iterator().next();
-                UniqueIdentifier uid = linearState.component1().getData().getLinearId();
+                database.transaction((DatabaseTransaction tx) -> {
+                    Vault<LinearState> states = VaultFiller.fillWithSomeTestLinearStates(services, 10, null);
+                    StateAndRef<LinearState> linearState = states.getStates().iterator().next();
+                    UniqueIdentifier uid = linearState.component1().getData().getLinearId();
 
-                Vault<DealState> dealStates = VaultFiller.fillWithSomeTestDeals(services, dealIds);
-                return new Triple(linearState,uid,dealStates);
-            });
+                    Vault<DealState> dealStates = VaultFiller.fillWithSomeTestDeals(services, dealIds);
+                    return new Triple(linearState, uid, dealStates);
+                });
         database.transaction(tx -> {
             // consume states
             VaultFiller.consumeDeals(services, (List<? extends StateAndRef<? extends DealState>>) ids.getThird().getStates(), getDUMMY_NOTARY());
@@ -276,13 +276,13 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
     public void trackDealStatesPagedSorted() {
         List<String> dealIds = Arrays.asList("123", "456", "789");
         UniqueIdentifier uid =
-            database.transaction(tx -> {
-                Vault<LinearState> states = VaultFiller.fillWithSomeTestLinearStates(services, 10, null);
-                UniqueIdentifier _uid = states.getStates().iterator().next().component1().getData().getLinearId();
+                database.transaction(tx -> {
+                    Vault<LinearState> states = VaultFiller.fillWithSomeTestLinearStates(services, 10, null);
+                    UniqueIdentifier _uid = states.getStates().iterator().next().component1().getData().getLinearId();
 
-                VaultFiller.fillWithSomeTestDeals(services, dealIds);
-                return _uid;
-            });
+                    VaultFiller.fillWithSomeTestDeals(services, dealIds);
+                    return _uid;
+                });
         database.transaction(tx -> {
             // DOCSTART VaultJavaQueryExample5
             @SuppressWarnings("unchecked")
diff --git a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
index a33dadfcea..e03fd6972c 100644
--- a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
+++ b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
@@ -272,6 +272,6 @@ class CordaRPCOpsImplTest {
     @StartableByRPC
     class VoidRPCFlow : FlowLogic<Void?>() {
         @Suspendable
-        override fun call() : Void? = null
+        override fun call(): Void? = null
     }
 }
diff --git a/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt b/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt
index d13fda0a4c..f694eec66c 100644
--- a/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt
+++ b/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt
@@ -84,4 +84,4 @@ class InteractiveShellTest {
     fun party() = check("party: \"${MEGA_CORP.name}\"", MEGA_CORP.name.toString())
 
     class DummyFSM(val logic: FlowA) : FlowStateMachine<Any?> by mock()
-        }
+}
diff --git a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
index c1a1b6e5b0..6e8fab1620 100644
--- a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
+++ b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappLoaderTest.kt
@@ -9,25 +9,29 @@ import java.nio.file.Paths
 @InitiatingFlow
 class DummyFlow : FlowLogic<Unit>() {
     @Suspendable
-    override fun call() { }
+    override fun call() {
+    }
 }
 
 @InitiatedBy(DummyFlow::class)
 class LoaderTestFlow(unusedSession: FlowSession) : FlowLogic<Unit>() {
     @Suspendable
-    override fun call() { }
+    override fun call() {
+    }
 }
 
 @SchedulableFlow
 class DummySchedulableFlow : FlowLogic<Unit>() {
     @Suspendable
-    override fun call() { }
+    override fun call() {
+    }
 }
 
 @StartableByRPC
 class DummyRPCFlow : FlowLogic<Unit>() {
     @Suspendable
-    override fun call() { }
+    override fun call() {
+    }
 }
 
 class CordappLoaderTest {
diff --git a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt
index 10dcd4a3ad..877037c387 100644
--- a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt
+++ b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt
@@ -37,7 +37,7 @@ class CordappProviderImplTests {
         val provider = CordappProviderImpl(loader)
 
         provider.start(attachmentStore)
-        
+
         Assert.assertNull(provider.getCordappAttachmentId(provider.cordapps.first()))
     }
 
diff --git a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
index 294d758cf4..ffaafa6246 100644
--- a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
@@ -80,6 +80,7 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
             return listOf(true, false)
         }
     }
+
     private lateinit var mockNet: MockNetwork
 
     @Before
@@ -164,8 +165,8 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
 
             val cashStates = bobNode.database.transaction {
                 bobNode.services.fillWithSomeTestCash(2000.DOLLARS, bankNode.services, notary, 3, 3,
-                            issuedBy = issuer)
-                }
+                        issuedBy = issuer)
+            }
 
             val alicesFakePaper = aliceNode.database.transaction {
                 fillUpForSeller(false, issuer, aliceNode.info.chooseIdentity(),
diff --git a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
index bb7c0d3e92..013eea5d74 100644
--- a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
@@ -153,7 +153,7 @@ class ScheduledFlowTests {
         val statesFromB: List<StateAndRef<ScheduledState>> = nodeB.database.transaction {
             queryStatesWithPaging(nodeB.services.vaultService)
         }
-        assertEquals("Expect all states to be present",2 * N, statesFromA.count())
+        assertEquals("Expect all states to be present", 2 * N, statesFromA.count())
         statesFromA.forEach { ref ->
             if (ref !in statesFromB) {
                 throw IllegalStateException("State $ref is only present on node A.")
diff --git a/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTests.kt b/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTests.kt
index 3d1942c01c..6a1adee86a 100644
--- a/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTests.kt
@@ -40,7 +40,9 @@ import kotlin.test.assertNull
 
 //TODO This needs to be merged into P2PMessagingTest as that creates a more realistic environment
 class ArtemisMessagingTests : TestDependencyInjectionBase() {
-    @Rule @JvmField val temporaryFolder = TemporaryFolder()
+    @Rule
+    @JvmField
+    val temporaryFolder = TemporaryFolder()
 
     val serverPort = freePort()
     val rpcPort = freePort()
diff --git a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
index a8646caad0..5e0f97e770 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
@@ -44,7 +44,7 @@ abstract class AbstractNetworkMapServiceTest<out S : AbstractNetworkMapService>
     lateinit var alice: StartedNode<MockNode>
 
     companion object {
-        val subscriberLegalName = CordaX500Name(organisation ="Subscriber", locality ="New York", country ="US")
+        val subscriberLegalName = CordaX500Name(organisation = "Subscriber", locality = "New York", country = "US")
     }
 
     @Before
@@ -205,7 +205,7 @@ abstract class AbstractNetworkMapServiceTest<out S : AbstractNetworkMapService>
     private var lastSerial = Long.MIN_VALUE
 
     private fun StartedNode<*>.registration(addOrRemove: AddOrRemove,
-                                      serial: Long? = null): CordaFuture<RegistrationResponse> {
+                                            serial: Long? = null): CordaFuture<RegistrationResponse> {
         val distinctSerial = if (serial == null) {
             ++lastSerial
         } else {
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
index f043a4c675..3a3148c0db 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
@@ -42,11 +42,12 @@ class DBTransactionStorageTests : TestDependencyInjectionBase() {
         database.transaction {
 
             services = object : MockServices(BOB_KEY) {
-                override val vaultService: VaultServiceInternal get() {
-                    val vaultService = NodeVaultService(clock, keyManagementService, stateLoader, database.hibernateConfig)
-                    hibernatePersister = HibernateObserver(vaultService.rawUpdates, database.hibernateConfig)
-                    return vaultService
-                }
+                override val vaultService: VaultServiceInternal
+                    get() {
+                        val vaultService = NodeVaultService(clock, keyManagementService, stateLoader, database.hibernateConfig)
+                        hibernatePersister = HibernateObserver(vaultService.rawUpdates, database.hibernateConfig)
+                        return vaultService
+                    }
 
                 override fun recordTransactions(txs: Iterable<SignedTransaction>) {
                     for (stx in txs) {
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
index 7cb537575b..e554ea59be 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
@@ -89,6 +89,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
                     // Refactored to use notifyAll() as we have no other unit test for that method with multiple transactions.
                     vaultService.notifyAll(txs.map { it.tx })
                 }
+
                 override fun jdbcSession() = database.createSession()
             }
             hibernatePersister = services.hibernatePersister
@@ -146,10 +147,10 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
     @Test
     fun `select by composite primary key`() {
         val issuedStates =
-            database.transaction {
-                services.fillWithSomeTestLinearStates(8)
-                services.fillWithSomeTestLinearStates(2)
-            }
+                database.transaction {
+                    services.fillWithSomeTestLinearStates(8)
+                    services.fillWithSomeTestLinearStates(2)
+                }
         val persistentStateRefs = issuedStates.states.map { PersistentStateRef(it.ref) }.toList()
 
         // structure query
@@ -383,7 +384,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
 
         // aggregate function
         criteriaQuery.multiselect(cashStates.get<String>("currency"),
-                                  criteriaBuilder.sum(cashStates.get<Long>("pennies")))
+                criteriaBuilder.sum(cashStates.get<Long>("pennies")))
         // group by
         criteriaQuery.groupBy(cashStates.get<String>("currency"))
 
@@ -627,7 +628,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
 
             services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 2, 2, Random(0L), ownedBy = ALICE)
             val cashStates = services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 2, 2, Random(0L),
-                                            issuedBy = BOB.ref(0), ownedBy = (BOB)).states
+                    issuedBy = BOB.ref(0), ownedBy = (BOB)).states
             // persist additional cash states explicitly with V3 schema
             cashStates.forEach {
                 val cashState = it.state.data
@@ -662,7 +663,8 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
         queryResults.forEach {
             val contractState = it.contractState.deserialize<TransactionState<ContractState>>(context = SerializationDefaults.STORAGE_CONTEXT)
             val cashState = contractState.data as Cash.State
-            println("${it.stateRef} with owner: ${cashState.owner.owningKey.toBase58String()}") }
+            println("${it.stateRef} with owner: ${cashState.owner.owningKey.toBase58String()}")
+        }
 
         assertThat(queryResults).hasSize(12)
     }
@@ -697,32 +699,32 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
     @Test
     fun `query fungible states by participants`() {
         val firstCashState =
-            database.transaction {
-                // persist original cash states explicitly with V3 schema
-                cashStates.forEach {
-                    val cashState = it.state.data
-                    val dummyFungibleState = DummyFungibleContract.State(cashState.amount, cashState.owner)
-                    hibernatePersister.persistStateWithSchema(dummyFungibleState, it.ref, SampleCashSchemaV3)
-                }
+                database.transaction {
+                    // persist original cash states explicitly with V3 schema
+                    cashStates.forEach {
+                        val cashState = it.state.data
+                        val dummyFungibleState = DummyFungibleContract.State(cashState.amount, cashState.owner)
+                        hibernatePersister.persistStateWithSchema(dummyFungibleState, it.ref, SampleCashSchemaV3)
+                    }
 
-                val moreCash = services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 2, 2, Random(0L),
-                        issuedBy = BOB.ref(0), ownedBy = BOB).states
-                // persist additional cash states explicitly with V3 schema
-                moreCash.forEach {
-                    val cashState = it.state.data
-                    val dummyFungibleState = DummyFungibleContract.State(cashState.amount, cashState.owner)
-                    hibernatePersister.persistStateWithSchema(dummyFungibleState, it.ref, SampleCashSchemaV3)
-                }
+                    val moreCash = services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 2, 2, Random(0L),
+                            issuedBy = BOB.ref(0), ownedBy = BOB).states
+                    // persist additional cash states explicitly with V3 schema
+                    moreCash.forEach {
+                        val cashState = it.state.data
+                        val dummyFungibleState = DummyFungibleContract.State(cashState.amount, cashState.owner)
+                        hibernatePersister.persistStateWithSchema(dummyFungibleState, it.ref, SampleCashSchemaV3)
+                    }
 
-                val cashStates = services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 2, 2, Random(0L), ownedBy = (ALICE)).states
-                // persist additional cash states explicitly with V3 schema
-                cashStates.forEach {
-                    val cashState = it.state.data
-                    val dummyFungibleState = DummyFungibleContract.State(cashState.amount, cashState.owner)
-                    hibernatePersister.persistStateWithSchema(dummyFungibleState, it.ref, SampleCashSchemaV3)
+                    val cashStates = services.fillWithSomeTestCash(100.DOLLARS, issuerServices, DUMMY_NOTARY, 2, 2, Random(0L), ownedBy = (ALICE)).states
+                    // persist additional cash states explicitly with V3 schema
+                    cashStates.forEach {
+                        val cashState = it.state.data
+                        val dummyFungibleState = DummyFungibleContract.State(cashState.amount, cashState.owner)
+                        hibernatePersister.persistStateWithSchema(dummyFungibleState, it.ref, SampleCashSchemaV3)
+                    }
+                    cashStates.first()
                 }
-                cashStates.first()
-            }
 
         // structure query
         val criteriaQuery = criteriaBuilder.createQuery(VaultSchemaV1.VaultStates::class.java)
@@ -874,7 +876,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
             val jdbcSession = services.jdbcSession()
             val prepStatement = jdbcSession.prepareStatement(nativeQuery)
             val rs = prepStatement.executeQuery()
-        // DOCEND JdbcSession
+            // DOCEND JdbcSession
             var count = 0
             while (rs.next()) {
                 val stateRef = StateRef(SecureHash.parse(rs.getString(1)), rs.getInt(2))
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt
index 0481ca51cd..46e954ecde 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt
@@ -99,18 +99,18 @@ class NodeAttachmentStorageTest {
     fun `corrupt entry throws exception`() {
         val testJar = makeTestJar()
         val id =
-        database.transaction {
-            val storage = NodeAttachmentService(MetricRegistry())
-            val id = testJar.read { storage.importAttachment(it) }
+                database.transaction {
+                    val storage = NodeAttachmentService(MetricRegistry())
+                    val id = testJar.read { storage.importAttachment(it) }
 
-            // Corrupt the file in the store.
-            val bytes = testJar.readAll()
-            val corruptBytes = "arggghhhh".toByteArray()
-            System.arraycopy(corruptBytes, 0, bytes, 0, corruptBytes.size)
-            val corruptAttachment = NodeAttachmentService.DBAttachment(attId = id.toString(), content = bytes)
-            DatabaseTransactionManager.current().session.merge(corruptAttachment)
-            id
-        }
+                    // Corrupt the file in the store.
+                    val bytes = testJar.readAll()
+                    val corruptBytes = "arggghhhh".toByteArray()
+                    System.arraycopy(corruptBytes, 0, bytes, 0, corruptBytes.size)
+                    val corruptAttachment = NodeAttachmentService.DBAttachment(attId = id.toString(), content = bytes)
+                    DatabaseTransactionManager.current().session.merge(corruptAttachment)
+                    id
+                }
         database.transaction {
             val storage = NodeAttachmentService(MetricRegistry())
             val e = assertFailsWith<NodeAttachmentService.HashMismatchException> {
diff --git a/node/src/test/kotlin/net/corda/node/services/schema/NodeSchemaServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/schema/NodeSchemaServiceTest.kt
index d7b90b8880..73bb252af5 100644
--- a/node/src/test/kotlin/net/corda/node/services/schema/NodeSchemaServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/schema/NodeSchemaServiceTest.kt
@@ -41,7 +41,7 @@ class NodeSchemaServiceTest {
      */
     @Test
     fun `auto scanning of custom schemas for testing with Driver`() {
-        driver (startNodesInProcess = true) {
+        driver(startNodesInProcess = true) {
             val node = startNode()
             val nodeHandle = node.getOrThrow()
             val result = nodeHandle.rpc.startFlow(::MappedSchemasFlow)
@@ -53,7 +53,7 @@ class NodeSchemaServiceTest {
     @StartableByRPC
     class MappedSchemasFlow : FlowLogic<List<String>>() {
         @Suspendable
-        override fun call() : List<String> {
+        override fun call(): List<String> {
             // returning MappedSchema's as String'ified family names to avoid whitelist serialization errors
             return (this.serviceHub as ServiceHubInternal).schemaService.schemaOptions.keys.map { it.name }
         }
diff --git a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
index 42b504a65e..57ca2cebba 100644
--- a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
@@ -702,8 +702,7 @@ class FlowFrameworkTests {
     private inline fun <reified P : FlowLogic<*>> StartedNode<*>.registerFlowFactory(
             initiatingFlowClass: KClass<out FlowLogic<*>>,
             initiatedFlowVersion: Int = 1,
-            noinline flowFactory: (FlowSession) -> P): CordaFuture<P>
-    {
+            noinline flowFactory: (FlowSession) -> P): CordaFuture<P> {
         val observable = internals.internalRegisterFlowFactory(
                 initiatingFlowClass.java,
                 InitiatedFlowFactory.CorDapp(initiatedFlowVersion, "", flowFactory),
@@ -715,6 +714,7 @@ class FlowFrameworkTests {
     private fun sessionInit(clientFlowClass: KClass<out FlowLogic<*>>, flowVersion: Int = 1, payload: Any? = null): SessionInit {
         return SessionInit(0, clientFlowClass.java.name, flowVersion, "", payload)
     }
+
     private fun sessionConfirm(flowVersion: Int = 1) = SessionConfirm(0, 0, flowVersion, "")
     private fun sessionData(payload: Any) = SessionData(0, payload)
     private val normalEnd = NormalSessionEnd(0)
@@ -766,14 +766,15 @@ class FlowFrameworkTests {
     private infix fun StartedNode<MockNode>.sent(message: SessionMessage): Pair<Int, SessionMessage> = Pair(internals.id, message)
     private infix fun Pair<Int, SessionMessage>.to(node: StartedNode<*>): SessionTransfer = SessionTransfer(first, second, node.network.myAddress)
 
-    private val FlowLogic<*>.progressSteps: CordaFuture<List<Notification<ProgressTracker.Step>>> get() {
-        return progressTracker!!.changes
-                .ofType(Change.Position::class.java)
-                .map { it.newStep }
-                .materialize()
-                .toList()
-                .toFuture()
-    }
+    private val FlowLogic<*>.progressSteps: CordaFuture<List<Notification<ProgressTracker.Step>>>
+        get() {
+            return progressTracker!!.changes
+                    .ofType(Change.Position::class.java)
+                    .map { it.newStep }
+                    .materialize()
+                    .toList()
+                    .toFuture()
+        }
 
     private class LazyServiceHubAccessFlow : FlowLogic<Unit>() {
         val lazyTime: Instant by lazy { serviceHub.clock.instant() }
@@ -782,7 +783,8 @@ class FlowFrameworkTests {
     }
 
     private class NoOpFlow(val nonTerminating: Boolean = false) : FlowLogic<Unit>() {
-        @Transient var flowStarted = false
+        @Transient
+        var flowStarted = false
 
         @Suspendable
         override fun call() {
@@ -833,7 +835,8 @@ class FlowFrameworkTests {
 
         override val progressTracker: ProgressTracker = ProgressTracker(START_STEP, RECEIVED_STEP)
         private var nonTerminating: Boolean = false
-        @Transient var receivedPayloads: List<String> = emptyList()
+        @Transient
+        var receivedPayloads: List<String> = emptyList()
 
         @Suspendable
         override fun call() {
@@ -879,6 +882,7 @@ class FlowFrameworkTests {
     @InitiatingFlow
     private class SendAndReceiveFlow(val otherParty: Party, val payload: Any, val otherPartySession: FlowSession? = null) : FlowLogic<Any>() {
         constructor(otherPartySession: FlowSession, payload: Any) : this(otherPartySession.counterparty, payload, otherPartySession)
+
         @Suspendable
         override fun call(): Any = (otherPartySession ?: initiateFlow(otherParty)).sendAndReceive<Any>(payload).unwrap { it }
     }
@@ -891,8 +895,11 @@ class FlowFrameworkTests {
     @InitiatingFlow
     private class PingPongFlow(val otherParty: Party, val payload: Long, val otherPartySession: FlowSession? = null) : FlowLogic<Unit>() {
         constructor(otherPartySession: FlowSession, payload: Long) : this(otherPartySession.counterparty, payload, otherPartySession)
-        @Transient var receivedPayload: Long? = null
-        @Transient var receivedPayload2: Long? = null
+
+        @Transient
+        var receivedPayload: Long? = null
+        @Transient
+        var receivedPayload2: Long? = null
 
         @Suspendable
         override fun call() {
@@ -959,6 +966,7 @@ class FlowFrameworkTests {
     @InitiatingFlow(version = 2)
     private class UpgradedFlow(val otherParty: Party, val otherPartySession: FlowSession? = null) : FlowLogic<Pair<Any, Int>>() {
         constructor(otherPartySession: FlowSession) : this(otherPartySession.counterparty, otherPartySession)
+
         @Suspendable
         override fun call(): Pair<Any, Int> {
             val otherPartySession = this.otherPartySession ?: initiateFlow(otherParty)
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/PersistentUniquenessProviderTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/PersistentUniquenessProviderTests.kt
index 1c1124cb1f..491931ab2a 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/PersistentUniquenessProviderTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/PersistentUniquenessProviderTests.kt
@@ -32,7 +32,8 @@ class PersistentUniquenessProviderTests : TestDependencyInjectionBase() {
         LogHelper.reset(PersistentUniquenessProvider::class)
     }
 
-    @Test fun `should commit a transaction with unused inputs without exception`() {
+    @Test
+    fun `should commit a transaction with unused inputs without exception`() {
         database.transaction {
             val provider = PersistentUniquenessProvider()
             val inputState = generateStateRef()
@@ -41,7 +42,8 @@ class PersistentUniquenessProviderTests : TestDependencyInjectionBase() {
         }
     }
 
-    @Test fun `should report a conflict for a transaction with previously used inputs`() {
+    @Test
+    fun `should report a conflict for a transaction with previously used inputs`() {
         database.transaction {
             val provider = PersistentUniquenessProvider()
             val inputState = generateStateRef()
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
index 8b364eb12b..5250e7f500 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
@@ -55,7 +55,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
         setCordappPackages("net.corda.finance.contracts.asset")
         LogHelper.setLevel(NodeVaultService::class)
         val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(BOC_KEY, DUMMY_CASH_ISSUER_KEY),
-                                                                  customSchemas = setOf(CashSchemaV1))
+                customSchemas = setOf(CashSchemaV1))
         database = databaseAndServices.first
         services = databaseAndServices.second
         issuerServices = MockServices(DUMMY_CASH_ISSUER_KEY, BOC_KEY)
@@ -195,7 +195,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
                     assertThat(vaultService.queryBy<Cash.State>(criteriaByLockId1).states).hasSize(3)
                 }
                 println("SOFT LOCK STATES #1 succeeded")
-            } catch(e: Throwable) {
+            } catch (e: Throwable) {
                 println("SOFT LOCK STATES #1 failed")
             } finally {
                 countDown.countDown()
@@ -211,7 +211,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
                     assertThat(vaultService.queryBy<Cash.State>(criteriaByLockId2).states).hasSize(3)
                 }
                 println("SOFT LOCK STATES #2 succeeded")
-            } catch(e: Throwable) {
+            } catch (e: Throwable) {
                 println("SOFT LOCK STATES #2 failed")
             } finally {
                 countDown.countDown()
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
index 74c799fc57..9e484833d6 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
@@ -65,8 +65,8 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         identitySvc.verifyAndRegisterIdentity(CASH_NOTARY_IDENTITY)
         identitySvc.verifyAndRegisterIdentity(BOC_IDENTITY)
         val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(MEGA_CORP_KEY, DUMMY_NOTARY_KEY),
-                                                                  createIdentityService = { identitySvc },
-                                                                  customSchemas = setOf(CashSchemaV1, CommercialPaperSchemaV1, DummyLinearStateSchemaV1))
+                createIdentityService = { identitySvc },
+                customSchemas = setOf(CashSchemaV1, CommercialPaperSchemaV1, DummyLinearStateSchemaV1))
         database = databaseAndServices.first
         services = databaseAndServices.second
         notaryServices = MockServices(DUMMY_NOTARY_KEY, DUMMY_CASH_ISSUER_KEY, BOC_KEY, MEGA_CORP_KEY)
@@ -1064,7 +1064,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         }
         database.transaction {
             @Suppress("EXPECTED_CONDITION")
-            val pagingSpec = PageSpecification(DEFAULT_PAGE_NUM, @Suppress("INTEGER_OVERFLOW")MAX_PAGE_SIZE + 1)  // overflow = -2147483648
+            val pagingSpec = PageSpecification(DEFAULT_PAGE_NUM, @Suppress("INTEGER_OVERFLOW") MAX_PAGE_SIZE + 1)  // overflow = -2147483648
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
             vaultService.queryBy<ContractState>(criteria, paging = pagingSpec)
         }
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
index a1450132a5..60e853d023 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
@@ -46,7 +46,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
 
         LogHelper.setLevel(VaultWithCashTest::class)
         val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(DUMMY_CASH_ISSUER_KEY, DUMMY_NOTARY_KEY),
-                                                                  customSchemas = setOf(CashSchemaV1))
+                customSchemas = setOf(CashSchemaV1))
         database = databaseAndServices.first
         services = databaseAndServices.second
         issuerServices = MockServices(DUMMY_CASH_ISSUER_KEY, MEGA_CORP_KEY)
@@ -85,24 +85,24 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
         val freshKey = services.keyManagementService.freshKey()
 
         val usefulTX =
-            database.transaction {
-                // A tx that sends us money.
-                val usefulBuilder = TransactionBuilder(null)
-                Cash().generateIssue(usefulBuilder, 100.DOLLARS `issued by` MEGA_CORP.ref(1), AnonymousParty(freshKey), DUMMY_NOTARY)
-                megaCorpServices.signInitialTransaction(usefulBuilder)
-            }
+                database.transaction {
+                    // A tx that sends us money.
+                    val usefulBuilder = TransactionBuilder(null)
+                    Cash().generateIssue(usefulBuilder, 100.DOLLARS `issued by` MEGA_CORP.ref(1), AnonymousParty(freshKey), DUMMY_NOTARY)
+                    megaCorpServices.signInitialTransaction(usefulBuilder)
+                }
         database.transaction {
             assertEquals(0.DOLLARS, services.getCashBalance(USD))
             services.recordTransactions(usefulTX)
         }
         val spendTX =
-            database.transaction {
-                // A tx that spends our money.
-                val spendTXBuilder = TransactionBuilder(DUMMY_NOTARY)
-                Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB)
-                val spendPTX = services.signInitialTransaction(spendTXBuilder, freshKey)
-                notaryServices.addSignature(spendPTX)
-            }
+                database.transaction {
+                    // A tx that spends our money.
+                    val spendTXBuilder = TransactionBuilder(DUMMY_NOTARY)
+                    Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB)
+                    val spendPTX = services.signInitialTransaction(spendTXBuilder, freshKey)
+                    notaryServices.addSignature(spendPTX)
+                }
         database.transaction {
             assertEquals(100.DOLLARS, services.getCashBalance(USD))
         }
@@ -174,7 +174,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
                                 LOCKED: ${lockedStates2.count()} : $lockedStates2
                     """)
                     txn1
-                } catch(e: Exception) {
+                } catch (e: Exception) {
                     println(e)
                 }
             }
@@ -210,7 +210,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
                                 LOCKED: ${lockedStates2.count()} : $lockedStates2
                     """)
                     txn2
-                } catch(e: Exception) {
+                } catch (e: Exception) {
                     println(e)
                 }
             }
@@ -254,18 +254,19 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
         val linearId = UniqueIdentifier()
 
         val dummyIssue =
-            database.transaction {    // Issue a linear state
-            val dummyIssueBuilder = TransactionBuilder(notary = DUMMY_NOTARY)
-                    .addOutputState(DummyLinearContract.State(linearId = linearId, participants = listOf(freshIdentity)), DUMMY_LINEAR_CONTRACT_PROGRAM_ID)
-                    .addCommand(dummyCommand(notaryServices.myInfo.chooseIdentity().owningKey))
-            val dummyIssuePtx = notaryServices.signInitialTransaction(dummyIssueBuilder)
-            val dummyIssue = services.addSignature(dummyIssuePtx)
+                database.transaction {
+                    // Issue a linear state
+                    val dummyIssueBuilder = TransactionBuilder(notary = DUMMY_NOTARY)
+                            .addOutputState(DummyLinearContract.State(linearId = linearId, participants = listOf(freshIdentity)), DUMMY_LINEAR_CONTRACT_PROGRAM_ID)
+                            .addCommand(dummyCommand(notaryServices.myInfo.chooseIdentity().owningKey))
+                    val dummyIssuePtx = notaryServices.signInitialTransaction(dummyIssueBuilder)
+                    val dummyIssue = services.addSignature(dummyIssuePtx)
 
-                dummyIssue.toLedgerTransaction(services).verify()
+                    dummyIssue.toLedgerTransaction(services).verify()
 
-                services.recordTransactions(dummyIssue)
-                dummyIssue
-            }
+                    services.recordTransactions(dummyIssue)
+                    dummyIssue
+                }
         database.transaction {
             assertThat(vaultService.queryBy<DummyLinearContract.State>().states).hasSize(1)
 
@@ -333,9 +334,9 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestDeals(listOf("123", "456", "789"))
         }
         val deals =
-            database.transaction {
-                vaultService.queryBy<DummyDealContract.State>().states
-            }
+                database.transaction {
+                    vaultService.queryBy<DummyDealContract.State>().states
+                }
         database.transaction {
             services.fillWithSomeTestLinearStates(3)
         }
diff --git a/node/src/test/kotlin/net/corda/node/utilities/AffinityExecutorTests.kt b/node/src/test/kotlin/net/corda/node/utilities/AffinityExecutorTests.kt
index 4187645e33..b1994a3d0c 100644
--- a/node/src/test/kotlin/net/corda/node/utilities/AffinityExecutorTests.kt
+++ b/node/src/test/kotlin/net/corda/node/utilities/AffinityExecutorTests.kt
@@ -11,12 +11,14 @@ class AffinityExecutorTests {
     var _executor: AffinityExecutor.ServiceAffinityExecutor? = null
     val executor: AffinityExecutor.ServiceAffinityExecutor get() = _executor!!
 
-    @After fun shutdown() {
+    @After
+    fun shutdown() {
         _executor?.shutdown()
         _executor = null
     }
 
-    @Test fun `flush handles nested executes`() {
+    @Test
+    fun `flush handles nested executes`() {
         _executor = AffinityExecutor.ServiceAffinityExecutor("test4", 1)
         var nestedRan = false
         val latch = CountDownLatch(1)
@@ -29,7 +31,8 @@ class AffinityExecutorTests {
         assertTrue(nestedRan)
     }
 
-    @Test fun `single threaded affinity executor runs on correct thread`() {
+    @Test
+    fun `single threaded affinity executor runs on correct thread`() {
         val thisThread = Thread.currentThread()
         _executor = AffinityExecutor.ServiceAffinityExecutor("test thread", 1)
         assertTrue(!executor.isOnThread)
@@ -50,7 +53,8 @@ class AffinityExecutorTests {
         assertEquals(thread2.get(), thread.get())
     }
 
-    @Test fun `pooled executor`() {
+    @Test
+    fun `pooled executor`() {
         _executor = AffinityExecutor.ServiceAffinityExecutor("test2", 3)
         assertFalse(executor.isOnThread)
 

From f98942d7adcfec6c21761fd60d6421f9d26adb62 Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 15:27:39 +0100
Subject: [PATCH 126/185] Reformat files in `node-api`

---
 .../main/kotlin/net/corda/nodeapi/RPCApi.kt   |  4 +-
 .../corda/nodeapi/config/ConfigUtilities.kt   |  1 +
 .../internal/AttachmentsClassLoader.kt        |  4 +-
 .../internal/serialization/ClientContexts.kt  |  1 +
 .../serialization/CordaClassResolver.kt       |  8 +-
 .../serialization/DefaultKryoCustomizer.kt    |  2 +
 .../nodeapi/internal/serialization/Kryo.kt    |  2 +-
 .../serialization/SerializationScheme.kt      |  4 +-
 .../internal/serialization/ServerContexts.kt  |  1 +
 .../serialization/UseCaseAwareness.kt         |  2 +-
 .../serialization/amqp/ArraySerializer.kt     | 15 ++--
 .../amqp/CollectionSerializer.kt              | 15 ++--
 .../serialization/amqp/CustomSerializer.kt    | 15 ++--
 .../amqp/DeserializationInput.kt              | 16 ++--
 .../serialization/amqp/MapSerializer.kt       | 23 +++--
 .../serialization/amqp/ObjectSerializer.kt    |  4 +-
 .../serialization/amqp/PropertySerializer.kt  | 12 +--
 .../serialization/amqp/SerializationOutput.kt |  5 +-
 .../amqp/custom/ThrowableSerializer.kt        |  2 +-
 .../amqp/custom/ZonedDateTimeSerializer.kt    |  2 +
 .../carpenter/AMQPSchemaExtensions.kt         |  7 +-
 .../serialization/carpenter/Schema.kt         |  8 +-
 .../amqp/ListsSerializationJavaTest.java      |  5 +-
 ...tachmentsClassLoaderStaticContractTests.kt |  4 +-
 .../internal/AttachmentsClassLoaderTests.kt   |  7 +-
 .../serialization/CordaClassResolverTests.kt  |  5 ++
 .../internal/serialization/KryoTests.kt       | 10 +--
 .../serialization/ListsSerializationTest.kt   | 20 ++---
 .../serialization/SerializationTokenTest.kt   | 15 ++--
 .../serialization/amqp/DeserializeMapTests.kt | 51 ++++++-----
 .../amqp/DeserializeSimpleTypesTests.kt       | 30 +++++--
 .../internal/serialization/amqp/EnumTests.kt  | 40 ++++-----
 .../serialization/amqp/EvolvabilityTests.kt   | 86 ++++++++++---------
 .../amqp/SerializationOutputTests.kt          | 25 +++---
 .../amqp/SerializeAndReturnSchemaTest.kt      |  1 +
 ...ticInitialisationOfSerializedObjectTest.kt | 16 ++--
 36 files changed, 256 insertions(+), 212 deletions(-)

diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt b/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt
index d2de3777f6..aa062e3195 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/RPCApi.kt
@@ -68,7 +68,7 @@ object RPCApi {
 
     val RPC_CLIENT_BINDING_REMOVAL_FILTER_EXPRESSION =
             "${ManagementHelper.HDR_NOTIFICATION_TYPE} = '${CoreNotificationType.BINDING_REMOVED.name}' AND " +
-            "${ManagementHelper.HDR_ROUTING_NAME} LIKE '$RPC_CLIENT_QUEUE_NAME_PREFIX.%'"
+                    "${ManagementHelper.HDR_ROUTING_NAME} LIKE '$RPC_CLIENT_QUEUE_NAME_PREFIX.%'"
     val RPC_CLIENT_BINDING_ADDITION_FILTER_EXPRESSION =
             "${ManagementHelper.HDR_NOTIFICATION_TYPE} = '${CoreNotificationType.BINDING_ADDED.name}' AND " +
                     "${ManagementHelper.HDR_ROUTING_NAME} LIKE '$RPC_CLIENT_QUEUE_NAME_PREFIX.%'"
@@ -141,7 +141,7 @@ object RPCApi {
                         val ids = ArrayList<ObservableId>()
                         val buffer = message.bodyBuffer
                         val numberOfIds = buffer.readInt()
-                        for (i in 1 .. numberOfIds) {
+                        for (i in 1..numberOfIds) {
                             ids.add(ObservableId(buffer.readLong()))
                         }
                         ObservablesClosed(ids)
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt b/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
index 78283ea654..a67a55db37 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
@@ -1,4 +1,5 @@
 @file:JvmName("ConfigUtilities")
+
 package net.corda.nodeapi.config
 
 import com.typesafe.config.Config
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoader.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoader.kt
index 749c82b7ef..20d2efca63 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoader.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoader.kt
@@ -72,7 +72,7 @@ class AttachmentsClassLoader(attachments: List<Attachment>, parent: ClassLoader
         val stream = ByteArrayOutputStream()
         try {
             attachment.extractFile(path, stream)
-        } catch(e: FileNotFoundException) {
+        } catch (e: FileNotFoundException) {
             throw ClassNotFoundException(name)
         }
         val bytes = stream.toByteArray()
@@ -99,7 +99,7 @@ class AttachmentsClassLoader(attachments: List<Attachment>, parent: ClassLoader
             val stream = ByteArrayOutputStream()
             attachment.extractFile(path, stream)
             return ByteArrayInputStream(stream.toByteArray())
-        } catch(e: FileNotFoundException) {
+        } catch (e: FileNotFoundException) {
             return null
         }
     }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/ClientContexts.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/ClientContexts.kt
index add6b1465e..bd6135522a 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/ClientContexts.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/ClientContexts.kt
@@ -1,4 +1,5 @@
 @file:JvmName("ClientContexts")
+
 package net.corda.nodeapi.internal.serialization
 
 import net.corda.core.serialization.SerializationContext
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
index afcdcbf0c8..04c43122ec 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
@@ -31,9 +31,9 @@ class CordaClassResolver(serializationContext: SerializationContext) : DefaultCl
      * The point is that we do not want to send Kotlin types "over the wire" via RPC.
      */
     private val javaAliases: Map<Class<*>, Class<*>> = mapOf(
-        listOf<Any>().javaClass to Collections.emptyList<Any>().javaClass,
-        setOf<Any>().javaClass to Collections.emptySet<Any>().javaClass,
-        mapOf<Any, Any>().javaClass to Collections.emptyMap<Any, Any>().javaClass
+            listOf<Any>().javaClass to Collections.emptyList<Any>().javaClass,
+            setOf<Any>().javaClass to Collections.emptySet<Any>().javaClass,
+            mapOf<Any, Any>().javaClass to Collections.emptyMap<Any, Any>().javaClass
     )
 
     private fun typeForSerializationOf(type: Class<*>): Class<*> = javaAliases[type] ?: type
@@ -194,7 +194,7 @@ class LoggingWhitelist(val delegate: ClassWhitelist, val global: Boolean = true)
             if (fileName != null && fileName.isNotEmpty()) {
                 try {
                     return PrintWriter(Files.newBufferedWriter(Paths.get(fileName), StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE), true)
-                } catch(ioEx: Exception) {
+                } catch (ioEx: Exception) {
                     log.error("Could not open/create whitelist journal file for append: $fileName", ioEx)
                 }
             }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt
index 04104533ee..7532ecffe9 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/DefaultKryoCustomizer.kt
@@ -140,6 +140,7 @@ object DefaultKryoCustomizer {
         // Use this to allow construction of objects using a JVM backdoor that skips invoking the constructors, if there
         // is no no-arg constructor available.
         private val defaultStrategy = Kryo.DefaultInstantiatorStrategy(fallbackStrategy)
+
         override fun <T> newInstantiatorOf(type: Class<T>): ObjectInstantiator<T> {
             // However this doesn't work for non-public classes in the java. namespace
             val strat = if (type.name.startsWith("java.") && !isPublic(type.modifiers)) fallbackStrategy else defaultStrategy
@@ -151,6 +152,7 @@ object DefaultKryoCustomizer {
         override fun write(kryo: Kryo, output: Output, obj: PartyAndCertificate) {
             kryo.writeClassAndObject(output, obj.certPath)
         }
+
         override fun read(kryo: Kryo, input: Input, type: Class<PartyAndCertificate>): PartyAndCertificate {
             return PartyAndCertificate(kryo.readClassAndObject(input) as CertPath)
         }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
index 7b998d5cd7..b4d0dc9c8c 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
@@ -546,7 +546,7 @@ class ThrowableSerializer<T>(kryo: Kryo, type: Class<T>) : Serializer<Throwable>
 
     override fun read(kryo: Kryo, input: Input, type: Class<Throwable>): Throwable {
         val throwableRead = delegate.read(kryo, input, type)
-        if(throwableRead.suppressed.isEmpty()) {
+        if (throwableRead.suppressed.isEmpty()) {
             throwableRead.setSuppressedToSentinel()
         }
         return throwableRead
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
index ca6c4c5292..e4deaf2c55 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
@@ -142,8 +142,8 @@ open class SerializationFactoryImpl : SerializationFactory() {
 private object AutoCloseableSerialisationDetector : Serializer<AutoCloseable>() {
     override fun write(kryo: Kryo, output: Output, closeable: AutoCloseable) {
         val message = "${closeable.javaClass.name}, which is a closeable resource, has been detected during flow checkpointing. " +
-                    "Restoring such resources across node restarts is not supported. Make sure code accessing it is " +
-                    "confined to a private method or the reference is nulled out."
+                "Restoring such resources across node restarts is not supported. Make sure code accessing it is " +
+                "confined to a private method or the reference is nulled out."
         throw UnsupportedOperationException(message)
     }
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/ServerContexts.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/ServerContexts.kt
index 89dd6b524d..baab649669 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/ServerContexts.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/ServerContexts.kt
@@ -1,4 +1,5 @@
 @file:JvmName("ServerContexts")
+
 package net.corda.nodeapi.internal.serialization
 
 import net.corda.core.serialization.ClassWhitelist
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/UseCaseAwareness.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/UseCaseAwareness.kt
index fdf57d28be..7f1d8c17b4 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/UseCaseAwareness.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/UseCaseAwareness.kt
@@ -6,7 +6,7 @@ import java.util.*
 
 internal fun checkUseCase(allowedUseCases: EnumSet<SerializationContext.UseCase>) {
     val currentContext: SerializationContext = SerializationFactory.currentFactory?.currentContext ?: throw IllegalStateException("Current context is not set")
-    if(!allowedUseCases.contains(currentContext.useCase)) {
+    if (!allowedUseCases.contains(currentContext.useCase)) {
         throw IllegalStateException("UseCase '${currentContext.useCase}' is not within '$allowedUseCases'")
     }
 }
\ No newline at end of file
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/ArraySerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/ArraySerializer.kt
index e49eafaa96..10f320a55a 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/ArraySerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/ArraySerializer.kt
@@ -23,14 +23,13 @@ open class ArraySerializer(override val type: Type, factory: SerializerFactory)
     //
     // We *need* to retain knowledge for AMQP deserialisation weather that lowest primitive
     // was boxed or unboxed so just infer it recursively
-    private fun calcTypeName(type: Type) : String =
-        if (type.componentType().isArray()) {
-            val typeName = calcTypeName(type.componentType()); "$typeName[]"
-        }
-        else {
-            val arrayType = if (type.asClass()!!.componentType.isPrimitive) "[p]" else "[]"
-            "${type.componentType().typeName}$arrayType"
-        }
+    private fun calcTypeName(type: Type): String =
+            if (type.componentType().isArray()) {
+                val typeName = calcTypeName(type.componentType()); "$typeName[]"
+            } else {
+                val arrayType = if (type.asClass()!!.componentType.isPrimitive) "[p]" else "[]"
+                "${type.componentType().typeName}$arrayType"
+            }
 
     override val typeDescriptor by lazy { Symbol.valueOf("$DESCRIPTOR_DOMAIN:${fingerprintForType(type, factory)}") }
     internal val elementType: Type by lazy { type.componentType() }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CollectionSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CollectionSerializer.kt
index 43a0234f95..fc176cfda7 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CollectionSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CollectionSerializer.kt
@@ -35,11 +35,10 @@ class CollectionSerializer(val declaredType: ParameterizedType, factory: Seriali
         }
 
         fun deriveParameterizedType(declaredType: Type, declaredClass: Class<*>, actualClass: Class<*>?): ParameterizedType {
-            if(supportedTypes.containsKey(declaredClass)) {
+            if (supportedTypes.containsKey(declaredClass)) {
                 // Simple case - it is already known to be a collection.
                 return deriveParametrizedType(declaredType, uncheckedCast(declaredClass))
-            }
-            else if (actualClass != null && Collection::class.java.isAssignableFrom(actualClass)) {
+            } else if (actualClass != null && Collection::class.java.isAssignableFrom(actualClass)) {
                 // Declared class is not collection, but [actualClass] is - represent it accordingly.
                 val collectionClass = findMostSuitableCollectionType(actualClass)
                 return deriveParametrizedType(declaredType, collectionClass)
@@ -49,11 +48,11 @@ class CollectionSerializer(val declaredType: ParameterizedType, factory: Seriali
         }
 
         private fun deriveParametrizedType(declaredType: Type, collectionClass: Class<out Collection<*>>): ParameterizedType =
-            (declaredType as? ParameterizedType) ?: DeserializedParameterizedType(collectionClass, arrayOf(SerializerFactory.AnyType))
+                (declaredType as? ParameterizedType) ?: DeserializedParameterizedType(collectionClass, arrayOf(SerializerFactory.AnyType))
 
 
         private fun findMostSuitableCollectionType(actualClass: Class<*>): Class<out Collection<*>> =
-            supportedTypes.keys.findLast { it.isAssignableFrom(actualClass) }!!
+                supportedTypes.keys.findLast { it.isAssignableFrom(actualClass) }!!
 
     }
 
@@ -61,13 +60,13 @@ class CollectionSerializer(val declaredType: ParameterizedType, factory: Seriali
 
     private val typeNotation: TypeNotation = RestrictedType(SerializerFactory.nameForType(declaredType), null, emptyList(), "list", Descriptor(typeDescriptor), emptyList())
 
-    override fun writeClassInfo(output: SerializationOutput) = ifThrowsAppend({declaredType.typeName}) {
+    override fun writeClassInfo(output: SerializationOutput) = ifThrowsAppend({ declaredType.typeName }) {
         if (output.writeTypeNotations(typeNotation)) {
             output.requireSerializer(declaredType.actualTypeArguments[0])
         }
     }
 
-    override fun writeObject(obj: Any, data: Data, type: Type, output: SerializationOutput) = ifThrowsAppend({declaredType.typeName}) {
+    override fun writeObject(obj: Any, data: Data, type: Type, output: SerializationOutput) = ifThrowsAppend({ declaredType.typeName }) {
         // Write described
         data.withDescribed(typeNotation.descriptor) {
             withList {
@@ -78,7 +77,7 @@ class CollectionSerializer(val declaredType: ParameterizedType, factory: Seriali
         }
     }
 
-    override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): Any = ifThrowsAppend({declaredType.typeName})  {
+    override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): Any = ifThrowsAppend({ declaredType.typeName }) {
         // TODO: Can we verify the entries in the list?
         concreteBuilder((obj as List<*>).map { input.readObjectOrNull(it, schema, declaredType.actualTypeArguments[0]) })
     }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CustomSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CustomSerializer.kt
index 242f829511..e039911ec0 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CustomSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/CustomSerializer.kt
@@ -102,9 +102,9 @@ abstract class CustomSerializer<T : Any> : AMQPSerializer<T> {
      * custom serializers.
      */
     abstract class Proxy<T : Any, P : Any>(clazz: Class<T>,
-                               protected val proxyClass: Class<P>,
-                               protected val factory: SerializerFactory,
-                               withInheritance: Boolean = true) : CustomSerializerImp<T>(clazz, withInheritance) {
+                                           protected val proxyClass: Class<P>,
+                                           protected val factory: SerializerFactory,
+                                           withInheritance: Boolean = true) : CustomSerializerImp<T>(clazz, withInheritance) {
         override fun isSerializerFor(clazz: Class<*>): Boolean = if (withInheritance) this.clazz.isAssignableFrom(clazz) else this.clazz == clazz
 
         private val proxySerializer: ObjectSerializer by lazy { ObjectSerializer(proxyClass, factory) }
@@ -151,11 +151,10 @@ abstract class CustomSerializer<T : Any> : AMQPSerializer<T> {
      * @param unmake A lambda that extracts the string value for an instance, that defaults to the [toString] method.
      */
     abstract class ToString<T : Any>(clazz: Class<T>, withInheritance: Boolean = false,
-                               private val maker: (String) -> T = clazz.getConstructor(String::class.java).let {
-                                   `constructor` ->
-                                   { string -> `constructor`.newInstance(string) }
-                               },
-                               private val unmaker: (T) -> String = { obj -> obj.toString() })
+                                     private val maker: (String) -> T = clazz.getConstructor(String::class.java).let { `constructor` ->
+                                         { string -> `constructor`.newInstance(string) }
+                                     },
+                                     private val unmaker: (T) -> String = { obj -> obj.toString() })
         : CustomSerializerImp<T>(clazz, withInheritance) {
 
         override val schemaForDocumentation = Schema(
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt
index 648f11eeae..7269aa8c40 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializationInput.kt
@@ -80,9 +80,9 @@ class DeserializationInput(internal val serializerFactory: SerializerFactory) {
     private fun <R> des(generator: () -> R): R {
         try {
             return generator()
-        } catch(nse: NotSerializableException) {
+        } catch (nse: NotSerializableException) {
             throw nse
-        } catch(t: Throwable) {
+        } catch (t: Throwable) {
             throw NotSerializableException("Unexpected throwable: ${t.message} ${t.getStackTraceAsString()}")
         } finally {
             objectHistory.clear()
@@ -152,10 +152,10 @@ class DeserializationInput(internal val serializerFactory: SerializerFactory) {
      * In the future tighter control might be needed
      */
     private fun Type.materiallyEquivalentTo(that: Type): Boolean =
-        when(that) {
-            is ParameterizedType -> asClass() == that.asClass()
-            is TypeVariable<*> -> isSubClassOf(that.bounds.first())
-            is WildcardType -> isSubClassOf(that.upperBounds.first())
-            else -> false
-        }
+            when (that) {
+                is ParameterizedType -> asClass() == that.asClass()
+                is TypeVariable<*> -> isSubClassOf(that.bounds.first())
+                is WildcardType -> isSubClassOf(that.upperBounds.first())
+                else -> false
+            }
 }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/MapSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/MapSerializer.kt
index 1fa710d59a..932b641ad2 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/MapSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/MapSerializer.kt
@@ -42,11 +42,10 @@ class MapSerializer(private val declaredType: ParameterizedType, factory: Serial
 
         fun deriveParameterizedType(declaredType: Type, declaredClass: Class<*>, actualClass: Class<*>?): ParameterizedType {
             declaredClass.checkSupportedMapType()
-            if(supportedTypes.containsKey(declaredClass)) {
+            if (supportedTypes.containsKey(declaredClass)) {
                 // Simple case - it is already known to be a map.
                 return deriveParametrizedType(declaredType, uncheckedCast(declaredClass))
-            }
-            else if (actualClass != null && Map::class.java.isAssignableFrom(actualClass)) {
+            } else if (actualClass != null && Map::class.java.isAssignableFrom(actualClass)) {
                 // Declared class is not map, but [actualClass] is - represent it accordingly.
                 val mapClass = findMostSuitableMapType(actualClass)
                 return deriveParametrizedType(declaredType, mapClass)
@@ -67,14 +66,14 @@ class MapSerializer(private val declaredType: ParameterizedType, factory: Serial
 
     private val typeNotation: TypeNotation = RestrictedType(SerializerFactory.nameForType(declaredType), null, emptyList(), "map", Descriptor(typeDescriptor), emptyList())
 
-    override fun writeClassInfo(output: SerializationOutput) = ifThrowsAppend({declaredType.typeName}) {
+    override fun writeClassInfo(output: SerializationOutput) = ifThrowsAppend({ declaredType.typeName }) {
         if (output.writeTypeNotations(typeNotation)) {
             output.requireSerializer(declaredType.actualTypeArguments[0])
             output.requireSerializer(declaredType.actualTypeArguments[1])
         }
     }
 
-    override fun writeObject(obj: Any, data: Data, type: Type, output: SerializationOutput) = ifThrowsAppend({declaredType.typeName}) {
+    override fun writeObject(obj: Any, data: Data, type: Type, output: SerializationOutput) = ifThrowsAppend({ declaredType.typeName }) {
         obj.javaClass.checkSupportedMapType()
         // Write described
         data.withDescribed(typeNotation.descriptor) {
@@ -89,7 +88,7 @@ class MapSerializer(private val declaredType: ParameterizedType, factory: Serial
         }
     }
 
-    override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): Any = ifThrowsAppend({declaredType.typeName}) {
+    override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): Any = ifThrowsAppend({ declaredType.typeName }) {
         // TODO: General generics question. Do we need to validate that entries in Maps and Collections match the generic type?  Is it a security hole?
         val entries: Iterable<Pair<Any?, Any?>> = (obj as Map<*, *>).map { readEntry(schema, input, it) }
         concreteBuilder(entries.toMap())
@@ -108,13 +107,11 @@ internal fun Class<*>.checkSupportedMapType() {
     if (HashMap::class.java.isAssignableFrom(this) && !LinkedHashMap::class.java.isAssignableFrom(this)) {
         throw IllegalArgumentException(
                 "Map type $this is unstable under iteration. Suggested fix: use java.util.LinkedHashMap instead.")
-    }
-    else if (WeakHashMap::class.java.isAssignableFrom(this)) {
-        throw IllegalArgumentException ("Weak references with map types not supported. Suggested fix: "
-                                        + "use java.util.LinkedHashMap instead.")
-    }
-    else if (Dictionary::class.java.isAssignableFrom(this)) {
-        throw IllegalArgumentException (
+    } else if (WeakHashMap::class.java.isAssignableFrom(this)) {
+        throw IllegalArgumentException("Weak references with map types not supported. Suggested fix: "
+                + "use java.util.LinkedHashMap instead.")
+    } else if (Dictionary::class.java.isAssignableFrom(this)) {
+        throw IllegalArgumentException(
                 "Unable to serialise deprecated type $this. Suggested fix: prefer java.util.map implementations")
     }
 }
\ No newline at end of file
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/ObjectSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/ObjectSerializer.kt
index c483e8e126..7dcb450803 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/ObjectSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/ObjectSerializer.kt
@@ -41,7 +41,7 @@ open class ObjectSerializer(val clazz: Type, factory: SerializerFactory) : AMQPS
         }
     }
 
-    override fun writeObject(obj: Any, data: Data, type: Type, output: SerializationOutput) = ifThrowsAppend({clazz.typeName}) {
+    override fun writeObject(obj: Any, data: Data, type: Type, output: SerializationOutput) = ifThrowsAppend({ clazz.typeName }) {
         // Write described
         data.withDescribed(typeNotation.descriptor) {
             // Write list
@@ -53,7 +53,7 @@ open class ObjectSerializer(val clazz: Type, factory: SerializerFactory) : AMQPS
         }
     }
 
-    override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): Any = ifThrowsAppend({clazz.typeName}) {
+    override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): Any = ifThrowsAppend({ clazz.typeName }) {
         if (obj is List<*>) {
             if (obj.size > propertySerializers.size) throw NotSerializableException("Too many properties in described type $typeName")
             val params = obj.zip(propertySerializers).map { it.second.readProperty(it.first, schema, input) }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
index 7c7714b9e9..feb06e123e 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
@@ -52,7 +52,7 @@ sealed class PropertySerializer(val name: String, val readMethod: Method?, val r
         try {
             val returnTypeString = this.declaringClass.kotlin.memberProperties.firstOrNull { it.javaGetter == this }?.returnType?.toString() ?: "?"
             return returnTypeString.endsWith('?') || returnTypeString.endsWith('!')
-        } catch(e: kotlin.reflect.jvm.internal.KotlinReflectionInternalError) {
+        } catch (e: kotlin.reflect.jvm.internal.KotlinReflectionInternalError) {
             // This might happen for some types, e.g. kotlin.Throwable? - the root cause of the issue is: https://youtrack.jetbrains.com/issue/KT-13077
             // TODO: Revisit this when Kotlin issue is fixed.
             logger.error("Unexpected internal Kotlin error", e)
@@ -66,7 +66,7 @@ sealed class PropertySerializer(val name: String, val readMethod: Method?, val r
         fun make(name: String, readMethod: Method?, resolvedType: Type, factory: SerializerFactory): PropertySerializer {
             readMethod?.isAccessible = true
             if (SerializerFactory.isPrimitive(resolvedType)) {
-                return when(resolvedType) {
+                return when (resolvedType) {
                     Char::class.java, Character::class.java -> AMQPCharPropertySerializer(name, readMethod)
                     else -> AMQPPrimitivePropertySerializer(name, readMethod, resolvedType)
                 }
@@ -86,17 +86,17 @@ sealed class PropertySerializer(val name: String, val readMethod: Method?, val r
         // This is lazy so we don't get an infinite loop when a method returns an instance of the class.
         private val typeSerializer: AMQPSerializer<*> by lazy { lazyTypeSerializer() }
 
-        override fun writeClassInfo(output: SerializationOutput) = ifThrowsAppend({nameForDebug}) {
+        override fun writeClassInfo(output: SerializationOutput) = ifThrowsAppend({ nameForDebug }) {
             if (resolvedType != Any::class.java) {
                 typeSerializer.writeClassInfo(output)
             }
         }
 
-        override fun readProperty(obj: Any?, schema: Schema, input: DeserializationInput): Any? = ifThrowsAppend({nameForDebug}) {
+        override fun readProperty(obj: Any?, schema: Schema, input: DeserializationInput): Any? = ifThrowsAppend({ nameForDebug }) {
             input.readObjectOrNull(obj, schema, resolvedType)
         }
 
-        override fun writeProperty(obj: Any?, data: Data, output: SerializationOutput) = ifThrowsAppend({nameForDebug}) {
+        override fun writeProperty(obj: Any?, data: Data, output: SerializationOutput) = ifThrowsAppend({ nameForDebug }) {
             output.writeObjectOrNull(readMethod!!.invoke(obj), data, resolvedType)
         }
 
@@ -133,7 +133,7 @@ sealed class PropertySerializer(val name: String, val readMethod: Method?, val r
         override fun writeClassInfo(output: SerializationOutput) {}
 
         override fun readProperty(obj: Any?, schema: Schema, input: DeserializationInput): Any? {
-            return if(obj == null) null else (obj as Short).toChar()
+            return if (obj == null) null else (obj as Short).toChar()
         }
 
         override fun writeProperty(obj: Any?, data: Data, output: SerializationOutput) {
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutput.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutput.kt
index 5379b5ab84..87a19376c9 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutput.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutput.kt
@@ -82,14 +82,13 @@ open class SerializationOutput(internal val serializerFactory: SerializerFactory
         }
 
         val retrievedRefCount = objectHistory[obj]
-        if(retrievedRefCount == null) {
+        if (retrievedRefCount == null) {
             serializer.writeObject(obj, data, type, this)
             // Important to do it after serialization such that dependent object will have preceding reference numbers
             // assigned to them first as they will be first read from the stream on receiving end.
             // Skip for primitive types as they are too small and overhead of referencing them will be much higher than their content
             if (suitableForObjectReference(obj.javaClass)) objectHistory.put(obj, objectHistory.size)
-        }
-        else {
+        } else {
             data.writeReferencedObject(ReferencedObject(retrievedRefCount))
         }
     }
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ThrowableSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ThrowableSerializer.kt
index ad8394db2d..8697cd98c7 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ThrowableSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ThrowableSerializer.kt
@@ -27,7 +27,7 @@ class ThrowableSerializer(factory: SerializerFactory) : CustomSerializer.Proxy<T
                 for (prop in props) {
                     extraProperties[prop.name] = prop.readMethod!!.invoke(obj)
                 }
-            } catch(e: NotSerializableException) {
+            } catch (e: NotSerializableException) {
                 logger.warn("Unexpected exception", e)
             }
             obj.originalMessage
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ZonedDateTimeSerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ZonedDateTimeSerializer.kt
index 86a5f0b3f4..9e851ac208 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ZonedDateTimeSerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/custom/ZonedDateTimeSerializer.kt
@@ -12,10 +12,12 @@ class ZonedDateTimeSerializer(factory: SerializerFactory) : CustomSerializer.Pro
     // so that any change to internals of `ZonedDateTime` is detected early.
     companion object {
         val ofLenient = ZonedDateTime::class.java.getDeclaredMethod("ofLenient", LocalDateTime::class.java, ZoneOffset::class.java, ZoneId::class.java)
+
         init {
             ofLenient.isAccessible = true
         }
     }
+
     override val additionalSerializers: Iterable<CustomSerializer<out Any>> = listOf(LocalDateTimeSerializer(factory), ZoneIdSerializer(factory))
 
     override fun toProxy(obj: ZonedDateTime): ZonedDateTimeProxy = ZonedDateTimeProxy(obj.toLocalDateTime(), obj.offset, obj.zone)
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/AMQPSchemaExtensions.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/AMQPSchemaExtensions.kt
index 611dbb9788..0bbdf01033 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/AMQPSchemaExtensions.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/AMQPSchemaExtensions.kt
@@ -132,5 +132,10 @@ fun AMQPField.validateType(classloader: ClassLoader) = when (type) {
 }
 
 private fun ClassLoader.exists(clazz: String) = run {
-    try { this.loadClass(clazz); true } catch (e: ClassNotFoundException) { false } }
+    try {
+        this.loadClass(clazz); true
+    } catch (e: ClassNotFoundException) {
+        false
+    }
+}
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt
index e3a3bfab56..352ad498da 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt
@@ -24,7 +24,7 @@ abstract class Schema(
         updater: (String, Field) -> Unit) {
     private fun Map<String, Field>.descriptors() = LinkedHashMap(this.mapValues { it.value.descriptor })
 
-    var flags : EnumMap<SchemaFlags, Boolean> = EnumMap(SchemaFlags::class.java)
+    var flags: EnumMap<SchemaFlags, Boolean> = EnumMap(SchemaFlags::class.java)
 
     init {
         fields.forEach { updater(it.key, it.value) }
@@ -49,15 +49,15 @@ abstract class Schema(
         get() = "[L$jvmName;"
 
     fun unsetCordaSerializable() {
-        flags.replace (SchemaFlags.CordaSerializable, false)
+        flags.replace(SchemaFlags.CordaSerializable, false)
     }
 }
 
-fun EnumMap<SchemaFlags, Boolean>.cordaSerializable() : Boolean {
+fun EnumMap<SchemaFlags, Boolean>.cordaSerializable(): Boolean {
     return this.getOrDefault(SchemaFlags.CordaSerializable, true) == true
 }
 
-fun EnumMap<SchemaFlags, Boolean>.simpleFieldAccess() : Boolean {
+fun EnumMap<SchemaFlags, Boolean>.simpleFieldAccess(): Boolean {
     return this.getOrDefault(SchemaFlags.SimpleFieldAccess, true) == true
 }
 
diff --git a/node-api/src/test/java/net/corda/nodeapi/internal/serialization/amqp/ListsSerializationJavaTest.java b/node-api/src/test/java/net/corda/nodeapi/internal/serialization/amqp/ListsSerializationJavaTest.java
index bcd1d1f1f7..6085546c37 100644
--- a/node-api/src/test/java/net/corda/nodeapi/internal/serialization/amqp/ListsSerializationJavaTest.java
+++ b/node-api/src/test/java/net/corda/nodeapi/internal/serialization/amqp/ListsSerializationJavaTest.java
@@ -12,7 +12,8 @@ import java.util.List;
 public class ListsSerializationJavaTest {
 
     @CordaSerializable
-    interface Parent {}
+    interface Parent {
+    }
 
     public static class Child implements Parent {
         private final int value;
@@ -123,7 +124,7 @@ public class ListsSerializationJavaTest {
     }
 
     // Have to have own version as Kotlin inline functions cannot be easily called from Java
-    private static<T> void assertEqualAfterRoundTripSerialization(T container, Class<T> clazz) throws Exception {
+    private static <T> void assertEqualAfterRoundTripSerialization(T container, Class<T> clazz) throws Exception {
         SerializerFactory factory1 = new SerializerFactory(AllWhitelist.INSTANCE, ClassLoader.getSystemClassLoader());
         SerializationOutput ser = new SerializationOutput(factory1);
         SerializedBytes<Object> bytes = ser.serialize(container);
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderStaticContractTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderStaticContractTests.kt
index 77733ec060..ce95ac21d8 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderStaticContractTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderStaticContractTests.kt
@@ -37,7 +37,7 @@ class AttachmentsClassLoaderStaticContractTests : TestDependencyInjectionBase()
         fun generateInitial(owner: PartyAndReference, magicNumber: Int, notary: Party): TransactionBuilder {
             val state = State(magicNumber)
             return TransactionBuilder(notary)
-                .withItems(StateAndContract(state, ATTACHMENT_PROGRAM_ID), Command(Commands.Create(), owner.party.owningKey))
+                    .withItems(StateAndContract(state, ATTACHMENT_PROGRAM_ID), Command(Commands.Create(), owner.party.owningKey))
         }
     }
 
@@ -45,7 +45,7 @@ class AttachmentsClassLoaderStaticContractTests : TestDependencyInjectionBase()
 
     @Before
     fun `create service hub`() {
-        serviceHub = MockServices(cordappPackages=listOf("net.corda.nodeapi.internal"))
+        serviceHub = MockServices(cordappPackages = listOf("net.corda.nodeapi.internal"))
     }
 
     @After
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
index e51a974936..bf4138379d 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
@@ -45,6 +45,7 @@ class AttachmentsClassLoaderTests : TestDependencyInjectionBase() {
             whenever(serviceHub.attachments).thenReturn(attachmentStorage)
             return this.withServiceHub(serviceHub)
         }
+
         private fun SerializationContext.withServiceHub(serviceHub: ServiceHub): SerializationContext {
             return this.withTokenContext(SerializeAsTokenContextImpl(serviceHub) {}).withProperty(attachmentsClassLoaderEnabledPropertyName, true)
         }
@@ -266,7 +267,7 @@ class AttachmentsClassLoaderTests : TestDependencyInjectionBase() {
 
     @Test
     fun `test serialization of sub-sequence OpaqueBytes`() {
-        val bytesSequence = ByteSequence.of("0123456789".toByteArray(), 3 ,2)
+        val bytesSequence = ByteSequence.of("0123456789".toByteArray(), 3, 2)
         val bytes = bytesSequence.serialize()
         val copiedBytesSequence = bytes.deserialize()
 
@@ -310,8 +311,8 @@ class AttachmentsClassLoaderTests : TestDependencyInjectionBase() {
                 val attachmentRef = serviceHub.attachmentId
                 val bytes = run {
                     val outboundContext = SerializationFactory.defaultFactory.defaultContext
-                        .withServiceHub(serviceHub)
-                        .withClassLoader(child)
+                            .withServiceHub(serviceHub)
+                            .withClassLoader(child)
                     val wireTransaction = tx.toWireTransaction(serviceHub, outboundContext)
                     wireTransaction.serialize(context = outboundContext)
                 }
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolverTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolverTests.kt
index 3a67501191..74a3d574ae 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolverTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolverTests.kt
@@ -271,6 +271,7 @@ class CordaClassResolverTests {
     }
 
     open class SubHashSet<E> : HashSet<E>()
+
     @Test
     fun `Check blacklisted subclass`() {
         expectedEx.expect(IllegalStateException::class.java)
@@ -281,6 +282,7 @@ class CordaClassResolverTests {
     }
 
     class SubSubHashSet<E> : SubHashSet<E>()
+
     @Test
     fun `Check blacklisted subsubclass`() {
         expectedEx.expect(IllegalStateException::class.java)
@@ -291,6 +293,7 @@ class CordaClassResolverTests {
     }
 
     class ConnectionImpl(private val connection: Connection) : Connection by connection
+
     @Test
     fun `Check blacklisted interface impl`() {
         expectedEx.expect(IllegalStateException::class.java)
@@ -302,6 +305,7 @@ class CordaClassResolverTests {
 
     interface SubConnection : Connection
     class SubConnectionImpl(private val subConnection: SubConnection) : SubConnection by subConnection
+
     @Test
     fun `Check blacklisted super-interface impl`() {
         expectedEx.expect(IllegalStateException::class.java)
@@ -320,6 +324,7 @@ class CordaClassResolverTests {
 
     @CordaSerializable
     class CordaSerializableHashSet<E> : HashSet<E>()
+
     @Test
     fun `Check blacklist precedes CordaSerializable`() {
         expectedEx.expect(IllegalStateException::class.java)
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/KryoTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/KryoTests.kt
index bf9c157c86..d6cb313f88 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/KryoTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/KryoTests.kt
@@ -188,10 +188,10 @@ class KryoTests : TestDependencyInjectionBase() {
     @Test
     fun `serialize - deserialize PrivacySalt`() {
         val expected = PrivacySalt(byteArrayOf(
-            1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
-            11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-            21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
-            31, 32
+                1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+                11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+                21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+                31, 32
         ))
         val serializedBytes = expected.serialize(factory, context)
         val actual = serializedBytes.deserialize(factory, context)
@@ -267,7 +267,7 @@ class KryoTests : TestDependencyInjectionBase() {
         assertEquals(exception.message, exception2.message)
 
         assertEquals(1, exception2.suppressed.size)
-        assertNotNull({ exception2.suppressed.find { it.message == toBeSuppressedOnSenderSide.message  }})
+        assertNotNull({ exception2.suppressed.find { it.message == toBeSuppressedOnSenderSide.message } })
 
         val toBeSuppressedOnReceiverSide = IllegalStateException("bazz2")
         exception2.addSuppressed(toBeSuppressedOnReceiverSide)
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
index f8d281392b..ede793b2be 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
@@ -22,12 +22,12 @@ class ListsSerializationTest : TestDependencyInjectionBase() {
     private companion object {
         val javaEmptyListClass = Collections.emptyList<Any>().javaClass
 
-        fun<T : Any> verifyEnvelope(serBytes: SerializedBytes<T>, envVerBody: (Envelope) -> Unit) =
-            amqpSpecific("AMQP specific envelope verification") {
-                val context = SerializationFactory.defaultFactory.defaultContext
-                val envelope = DeserializationInput(SerializerFactory(context.whitelist, context.deserializationClassLoader)).getEnvelope(serBytes)
-                envVerBody(envelope)
-            }
+        fun <T : Any> verifyEnvelope(serBytes: SerializedBytes<T>, envVerBody: (Envelope) -> Unit) =
+                amqpSpecific("AMQP specific envelope verification") {
+                    val context = SerializationFactory.defaultFactory.defaultContext
+                    val envelope = DeserializationInput(SerializerFactory(context.whitelist, context.deserializationClassLoader)).getEnvelope(serBytes)
+                    envVerBody(envelope)
+                }
     }
 
     @Test
@@ -54,7 +54,7 @@ class ListsSerializationTest : TestDependencyInjectionBase() {
     }
 
     @Test
-    fun `check empty list serialises as Java emptyList`() = kryoSpecific("Kryo specific test"){
+    fun `check empty list serialises as Java emptyList`() = kryoSpecific("Kryo specific test") {
         val nameID = 0
         val serializedForm = emptyList<Int>().serialize()
         val output = ByteArrayOutputStream().apply {
@@ -86,7 +86,7 @@ class ListsSerializationTest : TestDependencyInjectionBase() {
     data class Child(val value: Int) : Parent
 
     @CordaSerializable
-    data class CovariantContainer<out T: Parent>(val payload: List<T>)
+    data class CovariantContainer<out T : Parent>(val payload: List<T>)
 
     @Test
     fun `check covariance`() {
@@ -99,11 +99,11 @@ class ListsSerializationTest : TestDependencyInjectionBase() {
             envelope.schema.types.single { typeNotation -> typeNotation.name == java.util.List::class.java.name + "<?>" }
         }
 
-        assertEqualAfterRoundTripSerialization(container, {bytes -> verifyEnvelope(bytes, ::verifyEnvelopeBody)})
+        assertEqualAfterRoundTripSerialization(container, { bytes -> verifyEnvelope(bytes, ::verifyEnvelopeBody) })
     }
 }
 
-internal inline fun<reified T : Any> assertEqualAfterRoundTripSerialization(obj: T, noinline streamValidation: ((SerializedBytes<T>) -> Unit)? = null) {
+internal inline fun <reified T : Any> assertEqualAfterRoundTripSerialization(obj: T, noinline streamValidation: ((SerializedBytes<T>) -> Unit)? = null) {
 
     val serializedForm: SerializedBytes<T> = obj.serialize()
     streamValidation?.invoke(serializedForm)
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SerializationTokenTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SerializationTokenTest.kt
index 2c8a337035..909f672fde 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SerializationTokenTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SerializationTokenTest.kt
@@ -12,7 +12,7 @@ import org.junit.Before
 import org.junit.Test
 import java.io.ByteArrayOutputStream
 
-class SerializationTokenTest  : TestDependencyInjectionBase() {
+class SerializationTokenTest : TestDependencyInjectionBase() {
 
     private lateinit var factory: SerializationFactory
     private lateinit var context: SerializationContext
@@ -58,7 +58,7 @@ class SerializationTokenTest  : TestDependencyInjectionBase() {
         val testContext = this.context.withTokenContext(context)
         val serializedBytes = tokenizableBefore.serialize(factory, testContext)
         val tokenizableAfter = serializedBytes.deserialize(factory, testContext)
-            assertThat(tokenizableAfter).isSameAs(tokenizableBefore)
+        assertThat(tokenizableAfter).isSameAs(tokenizableBefore)
     }
 
     @Test(expected = UnsupportedOperationException::class)
@@ -92,11 +92,11 @@ class SerializationTokenTest  : TestDependencyInjectionBase() {
 
         val kryo: Kryo = DefaultKryoCustomizer.customize(CordaKryo(CordaClassResolver(this.context)))
         val stream = ByteArrayOutputStream()
-            Output(stream).use {
-                it.write(KryoHeaderV0_1.bytes)
-                kryo.writeClass(it, SingletonSerializeAsToken::class.java)
-                kryo.writeObject(it, emptyList<Any>())
-            }
+        Output(stream).use {
+            it.write(KryoHeaderV0_1.bytes)
+            kryo.writeClass(it, SingletonSerializeAsToken::class.java)
+            kryo.writeObject(it, emptyList<Any>())
+        }
         val serializedBytes = SerializedBytes<Any>(stream.toByteArray())
         serializedBytes.deserialize(factory, testContext)
     }
@@ -105,6 +105,7 @@ class SerializationTokenTest  : TestDependencyInjectionBase() {
         object UnitSerializationToken : SerializationToken {
             override fun fromToken(context: SerializeAsTokenContext): Any = UnitSerializeAsToken()
         }
+
         override fun toToken(context: SerializeAsTokenContext): SerializationToken = UnitSerializationToken
     }
 
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializeMapTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializeMapTests.kt
index 8314286d12..68e106fd89 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializeMapTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializeMapTests.kt
@@ -17,25 +17,28 @@ class DeserializeMapTests {
     @Test
     fun mapTest() {
         data class C(val c: Map<String, Int>)
-        val c = C (mapOf("A" to 1, "B" to 2))
+
+        val c = C(mapOf("A" to 1, "B" to 2))
 
         val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(c)
         DeserializationInput(sf).deserialize(serialisedBytes)
     }
 
-    @Test(expected=java.io.NotSerializableException::class)
+    @Test(expected = java.io.NotSerializableException::class)
     fun abstractMapFromMapOf() {
         data class C(val c: AbstractMap<String, Int>)
-        val c = C (mapOf("A" to 1, "B" to 2) as AbstractMap)
+
+        val c = C(mapOf("A" to 1, "B" to 2) as AbstractMap)
 
         val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(c)
         DeserializationInput(sf).deserialize(serialisedBytes)
     }
 
-    @Test(expected=java.io.NotSerializableException::class)
+    @Test(expected = java.io.NotSerializableException::class)
     fun abstractMapFromTreeMap() {
         data class C(val c: AbstractMap<String, Int>)
-        val c = C (TreeMap(mapOf("A" to 1, "B" to 2)))
+
+        val c = C(TreeMap(mapOf("A" to 1, "B" to 2)))
 
         val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(c)
         DeserializationInput(sf).deserialize(serialisedBytes)
@@ -44,7 +47,8 @@ class DeserializeMapTests {
     @Test
     fun sortedMapTest() {
         data class C(val c: SortedMap<String, Int>)
-        val c = C(sortedMapOf ("A" to 1, "B" to 2))
+
+        val c = C(sortedMapOf("A" to 1, "B" to 2))
         val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(c)
         DeserializationInput(sf).deserialize(serialisedBytes)
     }
@@ -52,7 +56,8 @@ class DeserializeMapTests {
     @Test
     fun navigableMapTest() {
         data class C(val c: NavigableMap<String, Int>)
-        val c = C(TreeMap (mapOf("A" to 1, "B" to 2)).descendingMap())
+
+        val c = C(TreeMap(mapOf("A" to 1, "B" to 2)).descendingMap())
 
         val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(c)
         DeserializationInput(sf).deserialize(serialisedBytes)
@@ -61,9 +66,10 @@ class DeserializeMapTests {
     @Test
     fun dictionaryTest() {
         data class C(val c: Dictionary<String, Int>)
-        val v : Hashtable<String, Int> = Hashtable()
-        v.put ("a", 1)
-        v.put ("b", 2)
+
+        val v: Hashtable<String, Int> = Hashtable()
+        v.put("a", 1)
+        v.put("b", 2)
         val c = C(v)
 
         // expected to throw
@@ -74,9 +80,10 @@ class DeserializeMapTests {
     @Test
     fun hashtableTest() {
         data class C(val c: Hashtable<String, Int>)
-        val v : Hashtable<String, Int> = Hashtable()
-        v.put ("a", 1)
-        v.put ("b", 2)
+
+        val v: Hashtable<String, Int> = Hashtable()
+        v.put("a", 1)
+        v.put("b", 2)
         val c = C(v)
 
         // expected to throw
@@ -86,8 +93,9 @@ class DeserializeMapTests {
 
     @Test
     fun hashMapTest() {
-        data class C(val c : HashMap<String, Int>)
-        val c = C (HashMap (mapOf("A" to 1, "B" to 2)))
+        data class C(val c: HashMap<String, Int>)
+
+        val c = C(HashMap(mapOf("A" to 1, "B" to 2)))
 
         // expect this to throw
         Assertions.assertThatThrownBy { TestSerializationOutput(VERBOSE, sf).serialize(c) }
@@ -96,8 +104,9 @@ class DeserializeMapTests {
 
     @Test
     fun weakHashMapTest() {
-        data class C(val c : WeakHashMap<String, Int>)
-        val c = C (WeakHashMap (mapOf("A" to 1, "B" to 2)))
+        data class C(val c: WeakHashMap<String, Int>)
+
+        val c = C(WeakHashMap(mapOf("A" to 1, "B" to 2)))
 
         Assertions.assertThatThrownBy { TestSerializationOutput(VERBOSE, sf).serialize(c) }
                 .isInstanceOf(IllegalArgumentException::class.java).hasMessageContaining("Weak references with map types not supported. Suggested fix: use java.util.LinkedHashMap instead.")
@@ -106,7 +115,8 @@ class DeserializeMapTests {
     @Test
     fun concreteTreeMapTest() {
         data class C(val c: TreeMap<String, Int>)
-        val c = C(TreeMap (mapOf("A" to 1, "B" to 3)))
+
+        val c = C(TreeMap(mapOf("A" to 1, "B" to 3)))
 
         val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(c)
         DeserializationInput(sf).deserialize(serialisedBytes)
@@ -114,8 +124,9 @@ class DeserializeMapTests {
 
     @Test
     fun concreteLinkedHashMapTest() {
-        data class C(val c : LinkedHashMap<String, Int>)
-        val c = C (LinkedHashMap (mapOf("A" to 1, "B" to 2)))
+        data class C(val c: LinkedHashMap<String, Int>)
+
+        val c = C(LinkedHashMap(mapOf("A" to 1, "B" to 2)))
 
         val serialisedBytes = TestSerializationOutput(VERBOSE, sf).serialize(c)
         DeserializationInput(sf).deserialize(serialisedBytes)
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializeSimpleTypesTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializeSimpleTypesTests.kt
index cc05b9b39f..4c5c9311ec 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializeSimpleTypesTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/DeserializeSimpleTypesTests.kt
@@ -402,7 +402,8 @@ class DeserializeSimpleTypesTests {
     @Test
     fun arrayOfArrayOfInt() {
         class C(val c: Array<Array<Int>>)
-        val c = C (arrayOf (arrayOf(1,2,3), arrayOf(4,5,6)))
+
+        val c = C(arrayOf(arrayOf(1, 2, 3), arrayOf(4, 5, 6)))
 
         val serialisedC = TestSerializationOutput(VERBOSE, sf1).serialize(c)
         val deserializedC = DeserializationInput(sf1).deserialize(serialisedC)
@@ -421,7 +422,8 @@ class DeserializeSimpleTypesTests {
     @Test
     fun arrayOfIntArray() {
         class C(val c: Array<IntArray>)
-        val c = C (arrayOf (IntArray(3), IntArray(3)))
+
+        val c = C(arrayOf(IntArray(3), IntArray(3)))
         c.c[0][0] = 1; c.c[0][1] = 2; c.c[0][2] = 3
         c.c[1][0] = 4; c.c[1][1] = 5; c.c[1][2] = 6
 
@@ -444,22 +446,32 @@ class DeserializeSimpleTypesTests {
         class C(val c: Array<Array<IntArray>>)
 
         val c = C(arrayOf(arrayOf(IntArray(3), IntArray(3), IntArray(3)),
-                          arrayOf(IntArray(3), IntArray(3), IntArray(3)),
-                          arrayOf(IntArray(3), IntArray(3), IntArray(3))))
+                arrayOf(IntArray(3), IntArray(3), IntArray(3)),
+                arrayOf(IntArray(3), IntArray(3), IntArray(3))))
 
-        for (i in 0..2) { for (j in 0..2) { for (k in 0..2) { c.c[i][j][k] = i + j + k } } }
+        for (i in 0..2) {
+            for (j in 0..2) {
+                for (k in 0..2) {
+                    c.c[i][j][k] = i + j + k
+                }
+            }
+        }
 
         val serialisedC = TestSerializationOutput(VERBOSE, sf1).serialize(c)
         val deserializedC = DeserializationInput(sf1).deserialize(serialisedC)
 
-        for (i in 0..2) { for (j in 0..2) { for (k in 0..2) {
-            assertEquals(c.c[i][j][k], deserializedC.c[i][j][k])
-        }}}
+        for (i in 0..2) {
+            for (j in 0..2) {
+                for (k in 0..2) {
+                    assertEquals(c.c[i][j][k], deserializedC.c[i][j][k])
+                }
+            }
+        }
     }
 
     @Test
     fun nestedRepeatedTypes() {
-        class A(val a : A?, val b: Int)
+        class A(val a: A?, val b: Int)
 
         var a = A(A(A(A(A(null, 1), 2), 3), 4), 5)
 
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt
index d10152baf0..1f20ac013f 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EnumTests.kt
@@ -49,7 +49,7 @@ class EnumTests {
     }
 
 
-    enum class BrasWithInit (val someList: List<Int>) {
+    enum class BrasWithInit(val someList: List<Int>) {
         TSHIRT(emptyList()),
         UNDERWIRE(listOf(1, 2, 3)),
         PUSHUP(listOf(100, 200)),
@@ -90,7 +90,7 @@ class EnumTests {
         assertEquals(8, schema_bras.choices.size)
         Bras.values().forEach {
             val bra = it
-            assertNotNull (schema_bras.choices.find { it.name == bra.name })
+            assertNotNull(schema_bras.choices.find { it.name == bra.name })
         }
     }
 
@@ -115,7 +115,7 @@ class EnumTests {
         assertEquals(8, schema_bras.choices.size)
         Bras.values().forEach {
             val bra = it
-            assertNotNull (schema_bras.choices.find { it.name == bra.name })
+            assertNotNull(schema_bras.choices.find { it.name == bra.name })
         }
 
         // Test the actual deserialised object
@@ -124,13 +124,13 @@ class EnumTests {
 
     @Test
     fun multiEnum() {
-        data class Support (val top: Bras, val day : DayOfWeek)
-        data class WeeklySupport (val tops: List<Support>)
+        data class Support(val top: Bras, val day: DayOfWeek)
+        data class WeeklySupport(val tops: List<Support>)
 
-        val week = WeeklySupport (listOf(
-            Support (Bras.PUSHUP, DayOfWeek.MONDAY),
-            Support (Bras.UNDERWIRE, DayOfWeek.WEDNESDAY),
-            Support (Bras.PADDED, DayOfWeek.SUNDAY)))
+        val week = WeeklySupport(listOf(
+                Support(Bras.PUSHUP, DayOfWeek.MONDAY),
+                Support(Bras.UNDERWIRE, DayOfWeek.WEDNESDAY),
+                Support(Bras.PADDED, DayOfWeek.SUNDAY)))
 
         val obj = DeserializationInput(sf1).deserialize(TestSerializationOutput(VERBOSE, sf1).serialize(week))
 
@@ -146,7 +146,7 @@ class EnumTests {
     fun enumWithInit() {
         data class C(val c: BrasWithInit)
 
-        val c = C (BrasWithInit.PUSHUP)
+        val c = C(BrasWithInit.PUSHUP)
         val obj = DeserializationInput(sf1).deserialize(TestSerializationOutput(VERBOSE, sf1).serialize(c))
 
         assertEquals(c.c, obj.c)
@@ -157,7 +157,7 @@ class EnumTests {
         val path = EnumTests::class.java.getResource("EnumTests.changedEnum1")
         val f = File(path.toURI())
 
-        data class C (val a: OldBras)
+        data class C(val a: OldBras)
 
         // Original version of the class for the serialised version of this class
         //
@@ -177,7 +177,7 @@ class EnumTests {
         val path = EnumTests::class.java.getResource("EnumTests.changedEnum2")
         val f = File(path.toURI())
 
-        data class C (val a: OldBras2)
+        data class C(val a: OldBras2)
 
         // DO NOT CHANGE THIS, it's important we serialise with a value that doesn't
         // change position in the upated enum class
@@ -197,9 +197,9 @@ class EnumTests {
 
     @Test
     fun enumNotWhitelistedFails() {
-        data class C (val c: Bras)
+        data class C(val c: Bras)
 
-        class WL (val allowed: String): ClassWhitelist {
+        class WL(val allowed: String) : ClassWhitelist {
             override fun hasListed(type: Class<*>): Boolean {
                 return type.name == allowed
             }
@@ -214,7 +214,7 @@ class EnumTests {
 
     @Test
     fun enumWhitelisted() {
-        data class C (val c: Bras)
+        data class C(val c: Bras)
 
         class WL : ClassWhitelist {
             override fun hasListed(type: Class<*>): Boolean {
@@ -231,7 +231,7 @@ class EnumTests {
 
     @Test
     fun enumAnnotated() {
-        @CordaSerializable data class C (val c: AnnotatedBras)
+        @CordaSerializable data class C(val c: AnnotatedBras)
 
         class WL : ClassWhitelist {
             override fun hasListed(type: Class<*>) = false
@@ -245,21 +245,21 @@ class EnumTests {
 
     @Test
     fun deserializeNonWhitlistedEnum() {
-        data class C (val c: Bras)
+        data class C(val c: Bras)
 
-        class WL (val allowed: List<String>) : ClassWhitelist {
+        class WL(val allowed: List<String>) : ClassWhitelist {
             override fun hasListed(type: Class<*>) = type.name in allowed
         }
 
         // first serialise the class using a context in which Bras are whitelisted
-        val factory = SerializerFactory(WL(listOf (classTestName("C"),
+        val factory = SerializerFactory(WL(listOf(classTestName("C"),
                 "net.corda.nodeapi.internal.serialization.amqp.EnumTests\$Bras")),
                 ClassLoader.getSystemClassLoader())
         val bytes = TestSerializationOutput(VERBOSE, factory).serialize(C(Bras.UNDERWIRE))
 
         // then take that serialised object and attempt to deserialize it in a context that
         // disallows the Bras enum
-        val factory2 = SerializerFactory(WL(listOf (classTestName("C"))), ClassLoader.getSystemClassLoader())
+        val factory2 = SerializerFactory(WL(listOf(classTestName("C"))), ClassLoader.getSystemClassLoader())
         Assertions.assertThatThrownBy {
             DeserializationInput(factory2).deserialize(bytes)
         }.isInstanceOf(NotSerializableException::class.java)
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EvolvabilityTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EvolvabilityTests.kt
index 0bf23ae85d..cdf690029c 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EvolvabilityTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/EvolvabilityTests.kt
@@ -32,7 +32,7 @@ class EvolvabilityTests {
         // f.writeBytes(sc.bytes)
 
         // new version of the class, in this case the order of the parameters has been swapped
-        data class C (val b: Int, val a: Int)
+        data class C(val b: Int, val a: Int)
 
         val sc2 = f.readBytes()
         val deserializedC = DeserializationInput(sf).deserialize(SerializedBytes<C>(sc2))
@@ -56,7 +56,7 @@ class EvolvabilityTests {
         // f.writeBytes(sc.bytes)
 
         // new version of the class, in this case the order of the parameters has been swapped
-        data class C (val b: String, val a: Int)
+        data class C(val b: String, val a: Int)
 
         val sc2 = f.readBytes()
         val deserializedC = DeserializationInput(sf).deserialize(SerializedBytes<C>(sc2))
@@ -79,13 +79,13 @@ class EvolvabilityTests {
         // f.writeBytes(sc.bytes)
         // println ("Path = $path")
 
-        data class C (val a: Int, val b: Int?)
+        data class C(val a: Int, val b: Int?)
 
         val sc2 = f.readBytes()
         val deserializedC = DeserializationInput(sf).deserialize(SerializedBytes<C>(sc2))
 
-        assertEquals (A, deserializedC.a)
-        assertEquals (null, deserializedC.b)
+        assertEquals(A, deserializedC.a)
+        assertEquals(null, deserializedC.b)
     }
 
     @Test(expected = NotSerializableException::class)
@@ -104,7 +104,7 @@ class EvolvabilityTests {
         // println ("Path = $path")
 
         // new version of the class, in this case a new parameter has been added (b)
-        data class C (val a: Int, val b: Int)
+        data class C(val a: Int, val b: Int)
 
         val sc2 = f.readBytes()
 
@@ -132,13 +132,13 @@ class EvolvabilityTests {
         // f.writeBytes(scc.bytes)
         // println ("Path = $path")
 
-        data class CC (val b: String, val d: Int)
+        data class CC(val b: String, val d: Int)
 
         val sc2 = f.readBytes()
         val deserializedCC = DeserializationInput(sf).deserialize(SerializedBytes<CC>(sc2))
 
-        assertEquals (B, deserializedCC.b)
-        assertEquals (D, deserializedCC.d)
+        assertEquals(B, deserializedCC.b)
+        assertEquals(D, deserializedCC.d)
     }
 
     @Suppress("UNUSED_VARIABLE")
@@ -185,16 +185,16 @@ class EvolvabilityTests {
         // println ("Path = $path")
 
         @Suppress("UNUSED")
-        data class CC (val a: Int, val b: String) {
+        data class CC(val a: Int, val b: String) {
             @DeprecatedConstructorForDeserialization(1)
-            constructor (a: Int) : this (a, "hello")
+            constructor (a: Int) : this(a, "hello")
         }
 
         val sc2 = f.readBytes()
         val deserializedCC = DeserializationInput(sf).deserialize(SerializedBytes<CC>(sc2))
 
-        assertEquals (A, deserializedCC.a)
-        assertEquals ("hello", deserializedCC.b)
+        assertEquals(A, deserializedCC.a)
+        assertEquals("hello", deserializedCC.b)
     }
 
     @Test(expected = NotSerializableException::class)
@@ -214,9 +214,9 @@ class EvolvabilityTests {
         // f.writeBytes(scc.bytes)
         // println ("Path = $path")
 
-        data class CC (val a: Int, val b: String) {
+        data class CC(val a: Int, val b: String) {
             // constructor annotation purposefully omitted
-            constructor (a: Int) : this (a, "hello")
+            constructor (a: Int) : this(a, "hello")
         }
 
         // we expect this to throw as we should not find any constructors
@@ -242,20 +242,20 @@ class EvolvabilityTests {
         // println ("Path = $path")
 
         @Suppress("UNUSED")
-        data class CC (val a: Int, val b: Int, val c: String, val d: String) {
+        data class CC(val a: Int, val b: Int, val c: String, val d: String) {
             // ensure none of the original parameters align with the initial
             // construction order
             @DeprecatedConstructorForDeserialization(1)
-            constructor (c: String, a: Int, b: Int) : this (a, b, c, "wibble")
+            constructor (c: String, a: Int, b: Int) : this(a, b, c, "wibble")
         }
 
         val sc2 = f.readBytes()
         val deserializedCC = DeserializationInput(sf).deserialize(SerializedBytes<CC>(sc2))
 
-        assertEquals (A, deserializedCC.a)
-        assertEquals (B, deserializedCC.b)
-        assertEquals (C, deserializedCC.c)
-        assertEquals ("wibble", deserializedCC.d)
+        assertEquals(A, deserializedCC.a)
+        assertEquals(B, deserializedCC.b)
+        assertEquals(C, deserializedCC.c)
+        assertEquals("wibble", deserializedCC.d)
     }
 
     @Test
@@ -277,20 +277,20 @@ class EvolvabilityTests {
         // println ("Path = $path")
 
         // b is removed, d is added
-        data class CC (val a: Int, val c: String, val d: String) {
+        data class CC(val a: Int, val c: String, val d: String) {
             // ensure none of the original parameters align with the initial
             // construction order
             @Suppress("UNUSED")
             @DeprecatedConstructorForDeserialization(1)
-            constructor (c: String, a: Int) : this (a, c, "wibble")
+            constructor (c: String, a: Int) : this(a, c, "wibble")
         }
 
         val sc2 = f.readBytes()
         val deserializedCC = DeserializationInput(sf).deserialize(SerializedBytes<CC>(sc2))
 
-        assertEquals (A, deserializedCC.a)
-        assertEquals (C, deserializedCC.c)
-        assertEquals ("wibble", deserializedCC.d)
+        assertEquals(A, deserializedCC.a)
+        assertEquals(C, deserializedCC.c)
+        assertEquals("wibble", deserializedCC.d)
     }
 
     @Test
@@ -322,13 +322,15 @@ class EvolvabilityTests {
         // println ("Path = $path1")
 
         @Suppress("UNUSED")
-        data class C (val e: Int, val c: Int, val b: Int, val a: Int, val d: Int) {
+        data class C(val e: Int, val c: Int, val b: Int, val a: Int, val d: Int) {
             @DeprecatedConstructorForDeserialization(1)
-            constructor (b: Int, a: Int) : this (-1, -1, b, a, -1)
+            constructor (b: Int, a: Int) : this(-1, -1, b, a, -1)
+
             @DeprecatedConstructorForDeserialization(2)
-            constructor (a: Int, c: Int, b: Int) : this (-1, c, b, a, -1)
+            constructor (a: Int, c: Int, b: Int) : this(-1, c, b, a, -1)
+
             @DeprecatedConstructorForDeserialization(3)
-            constructor (a: Int, b: Int, c: Int, d: Int) : this (-1, c, b, a, d)
+            constructor (a: Int, b: Int, c: Int, d: Int) : this(-1, c, b, a, d)
         }
 
         val sb1 = File(path1.toURI()).readBytes()
@@ -376,15 +378,16 @@ class EvolvabilityTests {
         // println ("Path = $path")
 
         // Add a parameter to inner but keep outer unchanged
-        data class Inner (val a: Int, val b: String?)
-        data class Outer (val a: Int, val b: Inner)
+        data class Inner(val a: Int, val b: String?)
+
+        data class Outer(val a: Int, val b: Inner)
 
         val sc2 = f.readBytes()
         val outer = DeserializationInput(sf).deserialize(SerializedBytes<Outer>(sc2))
 
-        assertEquals (oa, outer.a)
-        assertEquals (ia, outer.b.a)
-        assertEquals (null, outer.b.b)
+        assertEquals(oa, outer.a)
+        assertEquals(ia, outer.b.a)
+        assertEquals(null, outer.b.b)
     }
 
     @Test
@@ -416,15 +419,18 @@ class EvolvabilityTests {
         // println ("Path = $path1")
 
         @Suppress("UNUSED")
-        data class C (val b: Int, val c: Int, val d: Int, val e: Int, val f: Int, val g: Int) {
+        data class C(val b: Int, val c: Int, val d: Int, val e: Int, val f: Int, val g: Int) {
             @DeprecatedConstructorForDeserialization(1)
-            constructor (b: Int, c: Int) : this (b, c, -1, -1, -1, -1)
+            constructor (b: Int, c: Int) : this(b, c, -1, -1, -1, -1)
+
             @DeprecatedConstructorForDeserialization(2)
-            constructor (b: Int, c: Int, d: Int) : this (b, c, d, -1, -1, -1)
+            constructor (b: Int, c: Int, d: Int) : this(b, c, d, -1, -1, -1)
+
             @DeprecatedConstructorForDeserialization(3)
-            constructor (b: Int, c: Int, d: Int, e: Int) : this (b, c, d, e, -1, -1)
+            constructor (b: Int, c: Int, d: Int, e: Int) : this(b, c, d, e, -1, -1)
+
             @DeprecatedConstructorForDeserialization(4)
-            constructor (b: Int, c: Int, d: Int, e: Int, f: Int) : this (b, c, d, e, f, -1)
+            constructor (b: Int, c: Int, d: Int, e: Int, f: Int) : this(b, c, d, e, f, -1)
         }
 
         val sb1 = File(path1.toURI()).readBytes()
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutputTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutputTests.kt
index 05cd84c934..4b1011ad49 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutputTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutputTests.kt
@@ -50,7 +50,7 @@ class SerializationOutputTests {
 
     data class testShort(val s: Short)
 
-    data class testBoolean(val b : Boolean)
+    data class testBoolean(val b: Boolean)
 
     interface FooInterface {
         val pub: Int
@@ -145,13 +145,13 @@ class SerializationOutputTests {
 
     data class PolymorphicProperty(val foo: FooInterface?)
 
-    private inline fun<reified T : Any> serdes(obj: T,
-                       factory: SerializerFactory = SerializerFactory (
-                               AllWhitelist, ClassLoader.getSystemClassLoader()),
-                       freshDeserializationFactory: SerializerFactory = SerializerFactory(
-                               AllWhitelist, ClassLoader.getSystemClassLoader()),
-                       expectedEqual: Boolean = true,
-                       expectDeserializedEqual: Boolean = true): T {
+    private inline fun <reified T : Any> serdes(obj: T,
+                                                factory: SerializerFactory = SerializerFactory(
+                                                        AllWhitelist, ClassLoader.getSystemClassLoader()),
+                                                freshDeserializationFactory: SerializerFactory = SerializerFactory(
+                                                        AllWhitelist, ClassLoader.getSystemClassLoader()),
+                                                expectedEqual: Boolean = true,
+                                                expectDeserializedEqual: Boolean = true): T {
         val ser = SerializationOutput(factory)
         val bytes = ser.serialize(obj)
 
@@ -446,10 +446,10 @@ class SerializationOutputTests {
         try {
             try {
                 throw IOException("Layer 1")
-            } catch(t: Throwable) {
+            } catch (t: Throwable) {
                 throw IllegalStateException("Layer 2", t)
             }
-        } catch(t: Throwable) {
+        } catch (t: Throwable) {
             val desThrowable = serdesThrowableWithInternalInfo(t, factory, factory2, false)
             assertSerializedThrowableEquivalent(t, desThrowable)
         }
@@ -476,12 +476,12 @@ class SerializationOutputTests {
         try {
             try {
                 throw IOException("Layer 1")
-            } catch(t: Throwable) {
+            } catch (t: Throwable) {
                 val e = IllegalStateException("Layer 2")
                 e.addSuppressed(t)
                 throw e
             }
-        } catch(t: Throwable) {
+        } catch (t: Throwable) {
             val desThrowable = serdesThrowableWithInternalInfo(t, factory, factory2, false)
             assertSerializedThrowableEquivalent(t, desThrowable)
         }
@@ -535,6 +535,7 @@ class SerializationOutputTests {
     }
 
     val FOO_PROGRAM_ID = "net.corda.nodeapi.internal.serialization.amqp.SerializationOutputTests.FooContract"
+
     class FooState : ContractState {
         override val participants: List<AbstractParty> = emptyList()
     }
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializeAndReturnSchemaTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializeAndReturnSchemaTest.kt
index 86b769a14f..acd8c5b8fe 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializeAndReturnSchemaTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializeAndReturnSchemaTest.kt
@@ -19,6 +19,7 @@ class SerializeAndReturnSchemaTest {
     @Test
     fun getSchema() {
         data class C(val a: Int, val b: Int)
+
         val a = 1
         val b = 2
 
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.kt
index 47decde9c0..2533bdf182 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/StaticInitialisationOfSerializedObjectTest.kt
@@ -12,7 +12,7 @@ import java.lang.reflect.Type
 import java.util.concurrent.ConcurrentHashMap
 import kotlin.test.assertEquals
 
-class InStatic : Exception ("Help!, help!, I'm being repressed")
+class InStatic : Exception("Help!, help!, I'm being repressed")
 
 class C {
     companion object {
@@ -28,7 +28,7 @@ class C {
 // comment out the companion object from here,  comment out the test code and uncomment
 // the generation code, then re-run the test and copy the file shown in the output print
 // to the resource directory
-class C2 (var b: Int) {
+class C2(var b: Int) {
     /*
     companion object {
         init {
@@ -39,14 +39,14 @@ class C2 (var b: Int) {
 }
 
 class StaticInitialisationOfSerializedObjectTest {
-    @Test(expected=java.lang.ExceptionInInitializerError::class)
+    @Test(expected = java.lang.ExceptionInInitializerError::class)
     fun itBlowsUp() {
         C()
     }
 
     @Test
     fun KotlinObjectWithCompanionObject() {
-        data class D (val c : C)
+        data class D(val c: C)
 
         val sf = SerializerFactory(AllWhitelist, ClassLoader.getSystemClassLoader())
 
@@ -71,7 +71,7 @@ class StaticInitialisationOfSerializedObjectTest {
 
     @Test
     fun deserializeTest() {
-        data class D (val c : C2)
+        data class D(val c: C2)
 
         val path = EvolvabilityTests::class.java.getResource("StaticInitialisationOfSerializedObjectTest.deserializeTest")
         val f = File(path.toURI())
@@ -86,7 +86,7 @@ class StaticInitialisationOfSerializedObjectTest {
         class WL : ClassWhitelist {
             override fun hasListed(type: Class<*>) =
                     type.name == "net.corda.nodeapi.internal.serialization.amqp" +
-                    ".StaticInitialisationOfSerializedObjectTest\$deserializeTest\$D"
+                            ".StaticInitialisationOfSerializedObjectTest\$deserializeTest\$D"
         }
 
         val sf2 = SerializerFactory(WL(), ClassLoader.getSystemClassLoader())
@@ -100,14 +100,14 @@ class StaticInitialisationOfSerializedObjectTest {
     // Version of a serializer factory that will allow the class carpenter living on the
     // factory to have a different whitelist applied to it than the factory
     class TestSerializerFactory(wl1: ClassWhitelist, wl2: ClassWhitelist) :
-            SerializerFactory (wl1, ClassLoader.getSystemClassLoader()) {
+            SerializerFactory(wl1, ClassLoader.getSystemClassLoader()) {
         override val classCarpenter = ClassCarpenter(ClassLoader.getSystemClassLoader(), wl2)
     }
 
     // This time have the serilization factory and the carpenter use different whitelists
     @Test
     fun deserializeTest2() {
-        data class D (val c : C2)
+        data class D(val c: C2)
 
         val path = EvolvabilityTests::class.java.getResource("StaticInitialisationOfSerializedObjectTest.deserializeTest2")
         val f = File(path.toURI())

From fcc4bdae7e2d1e172b4e8cc57a0a4ba33b10417a Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 15:32:23 +0100
Subject: [PATCH 127/185] Reformat files in `testing`

---
 .../attachmentdemo/AttachmentDemoTest.kt      |   3 +-
 .../main/kotlin/net/corda/irs/contract/IRS.kt |  11 +-
 .../corda/irs/api/NodeInterestRatesTest.kt    |   2 +-
 .../net/corda/netmap/VisualiserViewModel.kt   |   2 +-
 .../corda/netmap/simulation/IRSSimulation.kt  |   1 +
 .../net/corda/netmap/simulation/Simulation.kt |   6 +-
 .../netmap/simulation/IRSSimulationTest.kt    |   3 +-
 .../kotlin/net/corda/notarydemo/Notarise.kt   |   2 +-
 .../DirectoryMarketDataBuilder.java           |  74 +-
 .../examples/marketdata/ExampleData.java      |  69 +-
 .../marketdata/ExampleMarketData.java         |  39 +-
 .../marketdata/ExampleMarketDataBuilder.java  | 635 +++++++++---------
 .../marketdata/JarMarketDataBuilder.java      | 178 ++---
 .../MarkitIndexCreditCurveDataParser.java     | 366 +++++-----
 .../credit/markit/MarkitRedCode.java          | 124 ++--
 .../markit/MarkitRestructuringClause.java     | 175 ++---
 .../credit/markit/MarkitSeniorityLevel.java   | 127 ++--
 ...MarkitSingleNameCreditCurveDataParser.java | 254 +++----
 .../markit/MarkitYieldCurveDataParser.java    | 179 ++---
 .../credit/markit/package-info.java           |   4 +-
 .../examples/marketdata/package-info.java     |   4 +-
 .../kotlin/net/corda/vega/api/PortfolioApi.kt |   7 +-
 .../kotlin/net/corda/vega/flows/SimmFlow.kt   |   3 +-
 .../net/corda/vega/flows/StateRevisionFlow.kt |   2 +-
 .../java/net/corda/vega/SwapExampleX.java     | 158 ++---
 .../corda/traderdemo/TraderDemoClientApi.kt   |  22 +-
 .../flow/CommercialPaperIssueFlow.kt          |   2 +
 .../net/corda/testing/DriverConstants.kt      |   2 +
 .../kotlin/net/corda/testing/NodeTestUtils.kt |   7 +-
 .../kotlin/net/corda/testing/RPCDriver.kt     |  18 +-
 .../testing/node/InMemoryMessagingNetwork.kt  |   7 +-
 .../corda/testing/node/MockNetworkMapCache.kt |   2 +-
 .../kotlin/net/corda/testing/node/MockNode.kt |   6 +-
 .../net/corda/testing/node/MockServices.kt    |  13 +-
 .../net/corda/testing/node/TestClock.kt       |   6 +-
 .../net/corda/smoketesting/NodeProcess.kt     |   7 +-
 .../kotlin/net/corda/testing/CoreTestUtils.kt |  13 +-
 .../kotlin/net/corda/testing/Eventually.kt    |   7 +-
 .../net/corda/testing/FlowStackSnapshot.kt    |  13 +-
 .../main/kotlin/net/corda/testing/Measure.kt  |   7 +-
 .../corda/testing/SerializationTestHelpers.kt |  12 +-
 .../main/kotlin/net/corda/testing/TestDSL.kt  |   2 +-
 .../testing/TransactionDSLInterpreter.kt      |   4 +-
 .../testing/contracts/DummyDealContract.kt    |   3 +-
 .../corda/testing/contracts/VaultFiller.kt    |  10 +-
 .../kotlin/net/corda/testing/http/HttpApi.kt  |   1 +
 .../schemas/DummyLinearStateSchemaV1.kt       |   4 +-
 47 files changed, 1327 insertions(+), 1269 deletions(-)

diff --git a/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt b/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt
index d0cdb64932..b1c0ace017 100644
--- a/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt
+++ b/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt
@@ -13,7 +13,8 @@ import java.util.concurrent.CompletableFuture.supplyAsync
 
 class AttachmentDemoTest {
     // run with a 10,000,000 bytes in-memory zip file. In practice, a slightly bigger file will be used (~10,002,000 bytes).
-    @Test fun `attachment demo using a 10MB zip file`() {
+    @Test
+    fun `attachment demo using a 10MB zip file`() {
         val numOfExpectedBytes = 10_000_000
         driver(isDebug = true, portAllocation = PortAllocation.Incremental(20000)) {
             val demoUser = listOf(User("demo", "demo", setOf(startFlowPermission<AttachmentDemoFlow>())))
diff --git a/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRS.kt b/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRS.kt
index 097a33c5e8..c81d80592c 100644
--- a/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRS.kt
+++ b/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRS.kt
@@ -141,11 +141,12 @@ class FloatingRatePaymentEvent(date: LocalDate,
         val CSVHeader = RatePaymentEvent.CSVHeader + ",FixingDate"
     }
 
-    override val flow: Amount<Currency> get() {
-        // TODO: Should an uncalculated amount return a zero ? null ? etc.
-        val v = rate.ratioUnit?.value ?: return Amount(0, notional.token)
-        return Amount(dayCountFactor.times(BigDecimal(notional.quantity)).times(v).toLong(), notional.token)
-    }
+    override val flow: Amount<Currency>
+        get() {
+            // TODO: Should an uncalculated amount return a zero ? null ? etc.
+            val v = rate.ratioUnit?.value ?: return Amount(0, notional.token)
+            return Amount(dayCountFactor.times(BigDecimal(notional.quantity)).times(v).toLong(), notional.token)
+        }
 
     override fun toString(): String = "FloatingPaymentEvent $accrualStartDate -> $accrualEndDate : $dayCountFactor : $days : $date : $notional : $rate (fix on $fixingDate): $flow"
 
diff --git a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
index a6b720cf72..ef07a9a5a3 100644
--- a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
+++ b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
@@ -242,7 +242,7 @@ class NodeInterestRatesTest : TestDependencyInjectionBase() {
     }
 
     private fun makePartialTX() = TransactionBuilder(DUMMY_NOTARY).withItems(
-        TransactionState(1000.DOLLARS.CASH `issued by` DUMMY_CASH_ISSUER `owned by` ALICE, Cash.PROGRAM_ID, DUMMY_NOTARY))
+            TransactionState(1000.DOLLARS.CASH `issued by` DUMMY_CASH_ISSUER `owned by` ALICE, Cash.PROGRAM_ID, DUMMY_NOTARY))
 
     private fun makeFullTx() = makePartialTX().withItems(dummyCommand())
 }
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/VisualiserViewModel.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/VisualiserViewModel.kt
index f9751e8d6c..f8f9c1f625 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/VisualiserViewModel.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/VisualiserViewModel.kt
@@ -86,7 +86,7 @@ class VisualiserViewModel {
         // top right: 33.0469,64.3209
         try {
             return node.place.coordinate.project(view.mapImage.fitWidth, view.mapImage.fitHeight, 64.3209, 29.8406, -23.2031, 33.0469)
-        } catch(e: Exception) {
+        } catch (e: Exception) {
             throw Exception("Cannot project ${node.started!!.info.chooseIdentity()}", e)
         }
     }
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt
index af7aae480e..0df1f7cdc2 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt
@@ -141,6 +141,7 @@ class IRSSimulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, laten
         node2.internals.registerInitiatedFlow(FixingFlow.Fixer::class.java)
 
         val notaryId = node1.rpcOps.notaryIdentities().first()
+
         @InitiatingFlow
         class StartDealFlow(val otherParty: Party,
                             val payload: AutoOffer) : FlowLogic<SignedTransaction>() {
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
index 46a38d7f5e..74529cd530 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
@@ -162,8 +162,10 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
     // These are used from the network visualiser tool.
     private val _allFlowSteps = PublishSubject.create<Pair<SimulatedNode, ProgressTracker.Change>>()
     private val _doneSteps = PublishSubject.create<Collection<SimulatedNode>>()
-    @Suppress("unused") val allFlowSteps: Observable<Pair<SimulatedNode, ProgressTracker.Change>> = _allFlowSteps
-    @Suppress("unused") val doneSteps: Observable<Collection<SimulatedNode>> = _doneSteps
+    @Suppress("unused")
+    val allFlowSteps: Observable<Pair<SimulatedNode, ProgressTracker.Change>> = _allFlowSteps
+    @Suppress("unused")
+    val doneSteps: Observable<Collection<SimulatedNode>> = _doneSteps
 
     private var pumpCursor = 0
 
diff --git a/samples/network-visualiser/src/test/kotlin/net/corda/netmap/simulation/IRSSimulationTest.kt b/samples/network-visualiser/src/test/kotlin/net/corda/netmap/simulation/IRSSimulationTest.kt
index 7a329a9ad4..4bd32364a4 100644
--- a/samples/network-visualiser/src/test/kotlin/net/corda/netmap/simulation/IRSSimulationTest.kt
+++ b/samples/network-visualiser/src/test/kotlin/net/corda/netmap/simulation/IRSSimulationTest.kt
@@ -21,7 +21,8 @@ class IRSSimulationTest {
         unsetCordappPackages()
     }
 
-    @Test fun `runs to completion`() {
+    @Test
+    fun `runs to completion`() {
         LogHelper.setLevel("+messages") // FIXME: Don't manipulate static state in tests.
         val sim = IRSSimulation(false, false, null)
         val future = sim.start()
diff --git a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/Notarise.kt b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/Notarise.kt
index c107c44578..cabacf9476 100644
--- a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/Notarise.kt
+++ b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/Notarise.kt
@@ -31,7 +31,7 @@ private class NotaryDemoClientApi(val rpc: CordaRPCOps) {
     private val counterparty by lazy {
         val parties = rpc.networkMapSnapshot()
         parties.fold(ArrayList<PartyAndCertificate>()) { acc, elem ->
-            acc.addAll(elem.legalIdentitiesAndCerts.filter { it.name == BOB.name})
+            acc.addAll(elem.legalIdentitiesAndCerts.filter { it.name == BOB.name })
             acc
         }.single().party
     }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/DirectoryMarketDataBuilder.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/DirectoryMarketDataBuilder.java
index fcb4949773..b9c5f02823 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/DirectoryMarketDataBuilder.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/DirectoryMarketDataBuilder.java
@@ -1,6 +1,6 @@
 /**
  * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
- * 
+ * <p>
  * Please see distribution for license.
  */
 package com.opengamma.strata.examples.marketdata;
@@ -19,46 +19,46 @@ import java.util.stream.Collectors;
  */
 public class DirectoryMarketDataBuilder extends ExampleMarketDataBuilder {
 
-  /**
-   * The path to the root of the directory structure.
-   */
-  private final Path rootPath;
+    /**
+     * The path to the root of the directory structure.
+     */
+    private final Path rootPath;
 
-  /**
-   * Constructs an instance.
-   * 
-   * @param rootPath  the path to the root of the directory structure
-   */
-  public DirectoryMarketDataBuilder(Path rootPath) {
-    this.rootPath = rootPath;
-  }
-
-  //-------------------------------------------------------------------------
-  @Override
-  protected Collection<ResourceLocator> getAllResources(String subdirectoryName) {
-    File dir = rootPath.resolve(subdirectoryName).toFile();
-    if (!dir.exists()) {
-      throw new IllegalArgumentException(Messages.format("Directory does not exist: {}", dir));
+    /**
+     * Constructs an instance.
+     *
+     * @param rootPath  the path to the root of the directory structure
+     */
+    public DirectoryMarketDataBuilder(Path rootPath) {
+        this.rootPath = rootPath;
     }
-    return Arrays.stream(dir.listFiles())
-        .filter(f -> !f.isHidden())
-        .map(ResourceLocator::ofFile)
-        .collect(Collectors.toList());
-  }
 
-  @Override
-  protected ResourceLocator getResource(String subdirectoryName, String resourceName) {
-    File file = rootPath.resolve(subdirectoryName).resolve(resourceName).toFile();
-    if (!file.exists()) {
-      return null;
+    //-------------------------------------------------------------------------
+    @Override
+    protected Collection<ResourceLocator> getAllResources(String subdirectoryName) {
+        File dir = rootPath.resolve(subdirectoryName).toFile();
+        if (!dir.exists()) {
+            throw new IllegalArgumentException(Messages.format("Directory does not exist: {}", dir));
+        }
+        return Arrays.stream(dir.listFiles())
+                .filter(f -> !f.isHidden())
+                .map(ResourceLocator::ofFile)
+                .collect(Collectors.toList());
     }
-    return ResourceLocator.ofFile(file);
-  }
 
-  @Override
-  protected boolean subdirectoryExists(String subdirectoryName) {
-    File file = rootPath.resolve(subdirectoryName).toFile();
-    return file.exists();
-  }
+    @Override
+    protected ResourceLocator getResource(String subdirectoryName, String resourceName) {
+        File file = rootPath.resolve(subdirectoryName).resolve(resourceName).toFile();
+        if (!file.exists()) {
+            return null;
+        }
+        return ResourceLocator.ofFile(file);
+    }
+
+    @Override
+    protected boolean subdirectoryExists(String subdirectoryName) {
+        File file = rootPath.resolve(subdirectoryName).toFile();
+        return file.exists();
+    }
 
 }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleData.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleData.java
index 5780b6c0d9..7073b361b2 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleData.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleData.java
@@ -1,6 +1,6 @@
 /**
  * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
- * 
+ * <p>
  * Please see distribution for license.
  */
 package com.opengamma.strata.examples.marketdata;
@@ -18,40 +18,41 @@ import java.util.Locale;
  */
 public final class ExampleData {
 
-  /**
-   * Restricted constructor.
-   */
-  private ExampleData() {
-  }
-
-  //-------------------------------------------------------------------------
-  /**
-   * Loads a golden copy of expected results from a text file.
-   * 
-   * @param name  the name of the results
-   * @return the loaded results
-   */
-  public static String loadExpectedResults(String name) {
-    String classpathResourceName = String.format(Locale.ENGLISH, "classpath:goldencopy/%s.txt", name);
-    ResourceLocator resourceLocator = ResourceLocator.of(classpathResourceName);
-    try {
-      return resourceLocator.getCharSource().read().trim();
-    } catch (IOException ex) {
-      throw new UncheckedIOException(name, ex);
+    /**
+     * Restricted constructor.
+     */
+    private ExampleData() {
     }
-  }
 
-  /**
-   * Loads a trade report template from the standard INI format.
-   * 
-   * @param templateName  the name of the template
-   * @return the loaded report template
-   */
-  public static TradeReportTemplate loadTradeReportTemplate(String templateName) {
-    String resourceName = String.format(Locale.ENGLISH, "classpath:example-reports/%s.ini", templateName);
-    ResourceLocator resourceLocator = ResourceLocator.of(resourceName);
-    IniFile ini = IniFile.of(resourceLocator.getCharSource());
-    return TradeReportTemplate.load(ini);
-  }
+    //-------------------------------------------------------------------------
+
+    /**
+     * Loads a golden copy of expected results from a text file.
+     *
+     * @param name  the name of the results
+     * @return the loaded results
+     */
+    public static String loadExpectedResults(String name) {
+        String classpathResourceName = String.format(Locale.ENGLISH, "classpath:goldencopy/%s.txt", name);
+        ResourceLocator resourceLocator = ResourceLocator.of(classpathResourceName);
+        try {
+            return resourceLocator.getCharSource().read().trim();
+        } catch (IOException ex) {
+            throw new UncheckedIOException(name, ex);
+        }
+    }
+
+    /**
+     * Loads a trade report template from the standard INI format.
+     *
+     * @param templateName  the name of the template
+     * @return the loaded report template
+     */
+    public static TradeReportTemplate loadTradeReportTemplate(String templateName) {
+        String resourceName = String.format(Locale.ENGLISH, "classpath:example-reports/%s.ini", templateName);
+        ResourceLocator resourceLocator = ResourceLocator.of(resourceName);
+        IniFile ini = IniFile.of(resourceLocator.getCharSource());
+        return TradeReportTemplate.load(ini);
+    }
 
 }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleMarketData.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleMarketData.java
index a0fb78bed6..9ed74a4b23 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleMarketData.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleMarketData.java
@@ -1,6 +1,6 @@
 /**
  * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
- * 
+ * <p>
  * Please see distribution for license.
  */
 package com.opengamma.strata.examples.marketdata;
@@ -10,25 +10,26 @@ package com.opengamma.strata.examples.marketdata;
  */
 public final class ExampleMarketData {
 
-  /**
-   * Root resource directory of the built-in example market data
-   */
-  private static final String EXAMPLE_MARKET_DATA_ROOT = "example-marketdata";
+    /**
+     * Root resource directory of the built-in example market data
+     */
+    private static final String EXAMPLE_MARKET_DATA_ROOT = "example-marketdata";
 
-  /**
-   * Restricted constructor.
-   */
-  private ExampleMarketData() {
-  }
+    /**
+     * Restricted constructor.
+     */
+    private ExampleMarketData() {
+    }
 
-  //-------------------------------------------------------------------------
-  /**
-   * Gets a market data builder for the built-in example market data.
-   * 
-   * @return the market data builder
-   */
-  public static ExampleMarketDataBuilder builder() {
-    return ExampleMarketDataBuilder.ofResource(EXAMPLE_MARKET_DATA_ROOT);
-  }
+    //-------------------------------------------------------------------------
+
+    /**
+     * Gets a market data builder for the built-in example market data.
+     *
+     * @return the market data builder
+     */
+    public static ExampleMarketDataBuilder builder() {
+        return ExampleMarketDataBuilder.ofResource(EXAMPLE_MARKET_DATA_ROOT);
+    }
 
 }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleMarketDataBuilder.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleMarketDataBuilder.java
index a59374c7f6..1f81eb3015 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleMarketDataBuilder.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/ExampleMarketDataBuilder.java
@@ -1,6 +1,6 @@
 /**
  * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
- *
+ * <p>
  * Please see distribution for license.
  */
 package com.opengamma.strata.examples.marketdata;
@@ -67,355 +67,358 @@ import static com.opengamma.strata.collect.Guavate.toImmutableList;
  */
 public abstract class ExampleMarketDataBuilder {
 
-  private static final Logger log = LoggerFactory.getLogger(ExampleMarketDataBuilder.class);
+    private static final Logger log = LoggerFactory.getLogger(ExampleMarketDataBuilder.class);
 
-  /** The name of the subdirectory containing historical fixings. */
-  private static final String HISTORICAL_FIXINGS_DIR = "historical-fixings";
+    /** The name of the subdirectory containing historical fixings. */
+    private static final String HISTORICAL_FIXINGS_DIR = "historical-fixings";
 
-  /** The name of the subdirectory containing calibrated rates curves. */
-  private static final String CURVES_DIR = "curves";
-  /** The name of the curve groups file. */
-  private static final String CURVES_GROUPS_FILE = "groups.csv";
-  /** The name of the curve settings file. */
-  private static final String CURVES_SETTINGS_FILE = "settings.csv";
+    /** The name of the subdirectory containing calibrated rates curves. */
+    private static final String CURVES_DIR = "curves";
+    /** The name of the curve groups file. */
+    private static final String CURVES_GROUPS_FILE = "groups.csv";
+    /** The name of the curve settings file. */
+    private static final String CURVES_SETTINGS_FILE = "settings.csv";
 
-  /** The name of the directory containing CDS ISDA yield curve, credit curve and static data. */
-  private static final String CREDIT_DIR = "credit";
-  private static final String CDS_YIELD_CURVES_FILE = "cds.yieldCurves.csv";
-  private static final String SINGLE_NAME_CREDIT_CURVES_FILE = "singleName.creditCurves.csv";
-  private static final String SINGLE_NAME_STATIC_DATA_FILE = "singleName.staticData.csv";
-  private static final String INDEX_CREDIT_CURVES_FILE = "index.creditCurves.csv";
-  private static final String INDEX_STATIC_DATA_FILE = "index.staticData.csv";
+    /** The name of the directory containing CDS ISDA yield curve, credit curve and static data. */
+    private static final String CREDIT_DIR = "credit";
+    private static final String CDS_YIELD_CURVES_FILE = "cds.yieldCurves.csv";
+    private static final String SINGLE_NAME_CREDIT_CURVES_FILE = "singleName.creditCurves.csv";
+    private static final String SINGLE_NAME_STATIC_DATA_FILE = "singleName.staticData.csv";
+    private static final String INDEX_CREDIT_CURVES_FILE = "index.creditCurves.csv";
+    private static final String INDEX_STATIC_DATA_FILE = "index.staticData.csv";
 
-  /** The name of the subdirectory containing simple market quotes. */
-  private static final String QUOTES_DIR = "quotes";
-  /** The name of the quotes file. */
-  private static final String QUOTES_FILE = "quotes.csv";
+    /** The name of the subdirectory containing simple market quotes. */
+    private static final String QUOTES_DIR = "quotes";
+    /** The name of the quotes file. */
+    private static final String QUOTES_FILE = "quotes.csv";
 
-  //-------------------------------------------------------------------------
-  /**
-   * Creates an instance from a given classpath resource root location using the class loader
-   * which created this class.
-   * <p>
-   * This is designed to handle resource roots which may physically correspond to a directory on
-   * disk, or be located within a jar file.
-   * 
-   * @param resourceRoot  the resource root path
-   * @return the market data builder
-   */
-  public static ExampleMarketDataBuilder ofResource(String resourceRoot) {
-    return ofResource(resourceRoot, ExampleMarketDataBuilder.class.getClassLoader());
-  }
+    //-------------------------------------------------------------------------
 
-  /**
-   * Creates an instance from a given classpath resource root location, using the given class loader
-   * to find the resource.
-   * <p>
-   * This is designed to handle resource roots which may physically correspond to a directory on
-   * disk, or be located within a jar file.
-   * 
-   * @param resourceRoot  the resource root path
-   * @param classLoader  the class loader with which to find the resource
-   * @return the market data builder
-   */
-  public static ExampleMarketDataBuilder ofResource(String resourceRoot, ClassLoader classLoader) {
-    // classpath resources are forward-slash separated
-    String qualifiedRoot = resourceRoot;
-    qualifiedRoot = qualifiedRoot.startsWith("/") ? qualifiedRoot.substring(1) : qualifiedRoot;
-    qualifiedRoot = qualifiedRoot.startsWith("\\") ? qualifiedRoot.substring(1) : qualifiedRoot;
-    qualifiedRoot = qualifiedRoot.endsWith("/") ? qualifiedRoot : qualifiedRoot + "/";
-    URL url = classLoader.getResource(qualifiedRoot);
-    if (url == null) {
-      throw new IllegalArgumentException(Messages.format("Classpath resource not found: {}", qualifiedRoot));
-    }
-    if (url.getProtocol() != null && "jar".equals(url.getProtocol().toLowerCase(Locale.ENGLISH))) {
-      // Inside a JAR
-      int classSeparatorIdx = url.getFile().indexOf("!");
-      if (classSeparatorIdx == -1) {
-        throw new IllegalArgumentException(Messages.format("Unexpected JAR file URL: {}", url));
-      }
-      String jarPath = url.getFile().substring("file:".length(), classSeparatorIdx);
-      File jarFile;
-      try {
-        jarFile = new File(jarPath);
-      } catch (Exception e) {
-        throw new IllegalArgumentException(Messages.format("Unable to create file for JAR: {}", jarPath), e);
-      }
-      return new JarMarketDataBuilder(jarFile, resourceRoot);
-    } else {
-      // Resource is on disk
-      File file;
-      try {
-        file = new File(url.toURI());
-      } catch (URISyntaxException e) {
-        throw new IllegalArgumentException(Messages.format("Unexpected file location: {}", url), e);
-      }
-      return new DirectoryMarketDataBuilder(file.toPath());
-    }
-  }
-
-  /**
-   * Creates an instance from a given directory root.
-   * 
-   * @param rootPath  the root directory
-   * @return the market data builder
-   */
-  public static ExampleMarketDataBuilder ofPath(Path rootPath) {
-    return new DirectoryMarketDataBuilder(rootPath);
-  }
-
-  //-------------------------------------------------------------------------
-  /**
-   * Builds a market data snapshot from this environment.
-   * 
-   * @param marketDataDate  the date of the market data
-   * @return the snapshot
-   */
-  public ImmutableMarketData buildSnapshot(LocalDate marketDataDate) {
-    ImmutableMarketDataBuilder builder = ImmutableMarketData.builder(marketDataDate);
-    loadFixingSeries(builder);
-    loadRatesCurves(builder, marketDataDate);
-    loadQuotes(builder, marketDataDate);
-    loadFxRates(builder);
-    loadCreditMarketData(builder, marketDataDate);
-    return builder.build();
-  }
-
-  /**
-   * Gets the rates market lookup to use with this environment.
-   * 
-   * @param marketDataDate  the date of the market data
-   * @return the rates lookup
-   */
-  public RatesMarketDataLookup ratesLookup(LocalDate marketDataDate) {
-    SortedMap<LocalDate, CurveGroup> curves = loadAllRatesCurves();
-    return RatesMarketDataLookup.of(curves.get(marketDataDate));
-  }
-
-  /**
-   * Gets all rates curves.
-   * 
-   * @return the map of all rates curves
-   */
-  public SortedMap<LocalDate, CurveGroup> loadAllRatesCurves() {
-    if (!subdirectoryExists(CURVES_DIR)) {
-      throw new IllegalArgumentException("No rates curves directory found");
-    }
-    ResourceLocator curveGroupsResource = getResource(CURVES_DIR, CURVES_GROUPS_FILE);
-    if (curveGroupsResource == null) {
-      throw new IllegalArgumentException(Messages.format(
-          "Unable to load rates curves: curve groups file not found at {}/{}", CURVES_DIR, CURVES_GROUPS_FILE));
-    }
-    ResourceLocator curveSettingsResource = getResource(CURVES_DIR, CURVES_SETTINGS_FILE);
-    if (curveSettingsResource == null) {
-      throw new IllegalArgumentException(Messages.format(
-          "Unable to load rates curves: curve settings file not found at {}/{}", CURVES_DIR, CURVES_SETTINGS_FILE));
-    }
-    ListMultimap<LocalDate, CurveGroup> curveGroups =
-        RatesCurvesCsvLoader.loadAllDates(curveGroupsResource, curveSettingsResource, getRatesCurvesResources());
-
-    // There is only one curve group in the market data file so this will always succeed
-    Map<LocalDate, CurveGroup> curveGroupMap = Maps.transformValues(curveGroups.asMap(), groups -> groups.iterator().next());
-    return new TreeMap<>(curveGroupMap);
-  }
-
-  //-------------------------------------------------------------------------
-  private void loadFixingSeries(ImmutableMarketDataBuilder builder) {
-    if (!subdirectoryExists(HISTORICAL_FIXINGS_DIR)) {
-      log.debug("No historical fixings directory found");
-      return;
-    }
-    try {
-      Collection<ResourceLocator> fixingSeriesResources = getAllResources(HISTORICAL_FIXINGS_DIR);
-      Map<ObservableId, LocalDateDoubleTimeSeries> fixingSeries = FixingSeriesCsvLoader.load(fixingSeriesResources);
-      builder.addTimeSeriesMap(fixingSeries);
-    } catch (Exception e) {
-      log.error("Error loading fixing series", e);
-    }
-  }
-
-  private void loadRatesCurves(ImmutableMarketDataBuilder builder, LocalDate marketDataDate) {
-    if (!subdirectoryExists(CURVES_DIR)) {
-      log.debug("No rates curves directory found");
-      return;
+    /**
+     * Creates an instance from a given classpath resource root location using the class loader
+     * which created this class.
+     * <p>
+     * This is designed to handle resource roots which may physically correspond to a directory on
+     * disk, or be located within a jar file.
+     *
+     * @param resourceRoot  the resource root path
+     * @return the market data builder
+     */
+    public static ExampleMarketDataBuilder ofResource(String resourceRoot) {
+        return ofResource(resourceRoot, ExampleMarketDataBuilder.class.getClassLoader());
     }
 
-    ResourceLocator curveGroupsResource = getResource(CURVES_DIR, CURVES_GROUPS_FILE);
-    if (curveGroupsResource == null) {
-      log.error("Unable to load rates curves: curve groups file not found at {}/{}", CURVES_DIR, CURVES_GROUPS_FILE);
-      return;
+    /**
+     * Creates an instance from a given classpath resource root location, using the given class loader
+     * to find the resource.
+     * <p>
+     * This is designed to handle resource roots which may physically correspond to a directory on
+     * disk, or be located within a jar file.
+     *
+     * @param resourceRoot  the resource root path
+     * @param classLoader  the class loader with which to find the resource
+     * @return the market data builder
+     */
+    public static ExampleMarketDataBuilder ofResource(String resourceRoot, ClassLoader classLoader) {
+        // classpath resources are forward-slash separated
+        String qualifiedRoot = resourceRoot;
+        qualifiedRoot = qualifiedRoot.startsWith("/") ? qualifiedRoot.substring(1) : qualifiedRoot;
+        qualifiedRoot = qualifiedRoot.startsWith("\\") ? qualifiedRoot.substring(1) : qualifiedRoot;
+        qualifiedRoot = qualifiedRoot.endsWith("/") ? qualifiedRoot : qualifiedRoot + "/";
+        URL url = classLoader.getResource(qualifiedRoot);
+        if (url == null) {
+            throw new IllegalArgumentException(Messages.format("Classpath resource not found: {}", qualifiedRoot));
+        }
+        if (url.getProtocol() != null && "jar".equals(url.getProtocol().toLowerCase(Locale.ENGLISH))) {
+            // Inside a JAR
+            int classSeparatorIdx = url.getFile().indexOf("!");
+            if (classSeparatorIdx == -1) {
+                throw new IllegalArgumentException(Messages.format("Unexpected JAR file URL: {}", url));
+            }
+            String jarPath = url.getFile().substring("file:".length(), classSeparatorIdx);
+            File jarFile;
+            try {
+                jarFile = new File(jarPath);
+            } catch (Exception e) {
+                throw new IllegalArgumentException(Messages.format("Unable to create file for JAR: {}", jarPath), e);
+            }
+            return new JarMarketDataBuilder(jarFile, resourceRoot);
+        } else {
+            // Resource is on disk
+            File file;
+            try {
+                file = new File(url.toURI());
+            } catch (URISyntaxException e) {
+                throw new IllegalArgumentException(Messages.format("Unexpected file location: {}", url), e);
+            }
+            return new DirectoryMarketDataBuilder(file.toPath());
+        }
     }
 
-    ResourceLocator curveSettingsResource = getResource(CURVES_DIR, CURVES_SETTINGS_FILE);
-    if (curveSettingsResource == null) {
-      log.error("Unable to load rates curves: curve settings file not found at {}/{}", CURVES_DIR, CURVES_SETTINGS_FILE);
-      return;
-    }
-    try {
-      Collection<ResourceLocator> curvesResources = getRatesCurvesResources();
-      List<CurveGroup> ratesCurves =
-          RatesCurvesCsvLoader.load(marketDataDate, curveGroupsResource, curveSettingsResource, curvesResources);
-
-      for (CurveGroup group : ratesCurves) {
-        // add entry for higher level discount curve name
-        group.getDiscountCurves().forEach(
-            (ccy, curve) -> builder.addValue(CurveId.of(group.getName(), curve.getName()), curve));
-        // add entry for higher level forward curve name
-        group.getForwardCurves().forEach(
-            (idx, curve) -> builder.addValue(CurveId.of(group.getName(), curve.getName()), curve));
-      }
-
-    } catch (Exception e) {
-      log.error("Error loading rates curves", e);
-    }
-  }
-
-  // load quotes
-  private void loadQuotes(ImmutableMarketDataBuilder builder, LocalDate marketDataDate) {
-    if (!subdirectoryExists(QUOTES_DIR)) {
-      log.debug("No quotes directory found");
-      return;
+    /**
+     * Creates an instance from a given directory root.
+     *
+     * @param rootPath  the root directory
+     * @return the market data builder
+     */
+    public static ExampleMarketDataBuilder ofPath(Path rootPath) {
+        return new DirectoryMarketDataBuilder(rootPath);
     }
 
-    ResourceLocator quotesResource = getResource(QUOTES_DIR, QUOTES_FILE);
-    if (quotesResource == null) {
-      log.error("Unable to load quotes: quotes file not found at {}/{}", QUOTES_DIR, QUOTES_FILE);
-      return;
+    //-------------------------------------------------------------------------
+
+    /**
+     * Builds a market data snapshot from this environment.
+     *
+     * @param marketDataDate  the date of the market data
+     * @return the snapshot
+     */
+    public ImmutableMarketData buildSnapshot(LocalDate marketDataDate) {
+        ImmutableMarketDataBuilder builder = ImmutableMarketData.builder(marketDataDate);
+        loadFixingSeries(builder);
+        loadRatesCurves(builder, marketDataDate);
+        loadQuotes(builder, marketDataDate);
+        loadFxRates(builder);
+        loadCreditMarketData(builder, marketDataDate);
+        return builder.build();
     }
 
-    try {
-      Map<QuoteId, Double> quotes = QuotesCsvLoader.load(marketDataDate, quotesResource);
-      builder.addValueMap(quotes);
-
-    } catch (Exception ex) {
-      log.error("Error loading quotes", ex);
-    }
-  }
-
-  private void loadFxRates(ImmutableMarketDataBuilder builder) {
-    // TODO - load from CSV file - format to be defined
-    builder.addValue(FxRateId.of(Currency.GBP, Currency.USD), FxRate.of(Currency.GBP, Currency.USD, 1.61));
-  }
-
-  //-------------------------------------------------------------------------
-  private Collection<ResourceLocator> getRatesCurvesResources() {
-    return getAllResources(CURVES_DIR).stream()
-        .filter(res -> !res.getLocator().endsWith(CURVES_GROUPS_FILE))
-        .filter(res -> !res.getLocator().endsWith(CURVES_SETTINGS_FILE))
-        .collect(toImmutableList());
-  }
-
-  private void loadCreditMarketData(ImmutableMarketDataBuilder builder, LocalDate marketDataDate) {
-    if (!subdirectoryExists(CREDIT_DIR)) {
-      log.debug("No credit curves directory found");
-      return;
+    /**
+     * Gets the rates market lookup to use with this environment.
+     *
+     * @param marketDataDate  the date of the market data
+     * @return the rates lookup
+     */
+    public RatesMarketDataLookup ratesLookup(LocalDate marketDataDate) {
+        SortedMap<LocalDate, CurveGroup> curves = loadAllRatesCurves();
+        return RatesMarketDataLookup.of(curves.get(marketDataDate));
     }
 
-    String creditMarketDataDateDirectory = String.format(
-        Locale.ENGLISH,
-        "%s/%s",
-        CREDIT_DIR,
-        marketDataDate.format(DateTimeFormatter.ISO_LOCAL_DATE));
+    /**
+     * Gets all rates curves.
+     *
+     * @return the map of all rates curves
+     */
+    public SortedMap<LocalDate, CurveGroup> loadAllRatesCurves() {
+        if (!subdirectoryExists(CURVES_DIR)) {
+            throw new IllegalArgumentException("No rates curves directory found");
+        }
+        ResourceLocator curveGroupsResource = getResource(CURVES_DIR, CURVES_GROUPS_FILE);
+        if (curveGroupsResource == null) {
+            throw new IllegalArgumentException(Messages.format(
+                    "Unable to load rates curves: curve groups file not found at {}/{}", CURVES_DIR, CURVES_GROUPS_FILE));
+        }
+        ResourceLocator curveSettingsResource = getResource(CURVES_DIR, CURVES_SETTINGS_FILE);
+        if (curveSettingsResource == null) {
+            throw new IllegalArgumentException(Messages.format(
+                    "Unable to load rates curves: curve settings file not found at {}/{}", CURVES_DIR, CURVES_SETTINGS_FILE));
+        }
+        ListMultimap<LocalDate, CurveGroup> curveGroups =
+                RatesCurvesCsvLoader.loadAllDates(curveGroupsResource, curveSettingsResource, getRatesCurvesResources());
 
-    if (!subdirectoryExists(creditMarketDataDateDirectory)) {
-      log.debug("Unable to load market data: directory not found at {}", creditMarketDataDateDirectory);
-      return;
+        // There is only one curve group in the market data file so this will always succeed
+        Map<LocalDate, CurveGroup> curveGroupMap = Maps.transformValues(curveGroups.asMap(), groups -> groups.iterator().next());
+        return new TreeMap<>(curveGroupMap);
     }
 
-    loadCdsYieldCurves(builder, creditMarketDataDateDirectory);
-    loadCdsSingleNameSpreadCurves(builder, creditMarketDataDateDirectory);
-    loadCdsIndexSpreadCurves(builder, creditMarketDataDateDirectory);
-  }
-
-  private void loadCdsYieldCurves(ImmutableMarketDataBuilder builder, String creditMarketDataDateDirectory) {
-    ResourceLocator cdsYieldCurvesResource = getResource(creditMarketDataDateDirectory, CDS_YIELD_CURVES_FILE);
-    if (cdsYieldCurvesResource == null) {
-      log.debug("Unable to load cds yield curves: file not found at {}/{}", creditMarketDataDateDirectory,
-          CDS_YIELD_CURVES_FILE);
-      return;
+    //-------------------------------------------------------------------------
+    private void loadFixingSeries(ImmutableMarketDataBuilder builder) {
+        if (!subdirectoryExists(HISTORICAL_FIXINGS_DIR)) {
+            log.debug("No historical fixings directory found");
+            return;
+        }
+        try {
+            Collection<ResourceLocator> fixingSeriesResources = getAllResources(HISTORICAL_FIXINGS_DIR);
+            Map<ObservableId, LocalDateDoubleTimeSeries> fixingSeries = FixingSeriesCsvLoader.load(fixingSeriesResources);
+            builder.addTimeSeriesMap(fixingSeries);
+        } catch (Exception e) {
+            log.error("Error loading fixing series", e);
+        }
     }
 
-    CharSource inputSource = cdsYieldCurvesResource.getCharSource();
-    Map<IsdaYieldCurveInputsId, IsdaYieldCurveInputs> yieldCuves = MarkitYieldCurveDataParser.parse(inputSource);
+    private void loadRatesCurves(ImmutableMarketDataBuilder builder, LocalDate marketDataDate) {
+        if (!subdirectoryExists(CURVES_DIR)) {
+            log.debug("No rates curves directory found");
+            return;
+        }
 
-    for (IsdaYieldCurveInputsId id : yieldCuves.keySet()) {
-      IsdaYieldCurveInputs curveInputs = yieldCuves.get(id);
-      builder.addValue(id, curveInputs);
-    }
-  }
+        ResourceLocator curveGroupsResource = getResource(CURVES_DIR, CURVES_GROUPS_FILE);
+        if (curveGroupsResource == null) {
+            log.error("Unable to load rates curves: curve groups file not found at {}/{}", CURVES_DIR, CURVES_GROUPS_FILE);
+            return;
+        }
 
-  private void loadCdsSingleNameSpreadCurves(ImmutableMarketDataBuilder builder, String creditMarketDataDateDirectory) {
-    ResourceLocator singleNameCurvesResource = getResource(creditMarketDataDateDirectory, SINGLE_NAME_CREDIT_CURVES_FILE);
-    if (singleNameCurvesResource == null) {
-      log.debug("Unable to load single name spread curves: file not found at {}/{}", creditMarketDataDateDirectory,
-          SINGLE_NAME_CREDIT_CURVES_FILE);
-      return;
+        ResourceLocator curveSettingsResource = getResource(CURVES_DIR, CURVES_SETTINGS_FILE);
+        if (curveSettingsResource == null) {
+            log.error("Unable to load rates curves: curve settings file not found at {}/{}", CURVES_DIR, CURVES_SETTINGS_FILE);
+            return;
+        }
+        try {
+            Collection<ResourceLocator> curvesResources = getRatesCurvesResources();
+            List<CurveGroup> ratesCurves =
+                    RatesCurvesCsvLoader.load(marketDataDate, curveGroupsResource, curveSettingsResource, curvesResources);
+
+            for (CurveGroup group : ratesCurves) {
+                // add entry for higher level discount curve name
+                group.getDiscountCurves().forEach(
+                        (ccy, curve) -> builder.addValue(CurveId.of(group.getName(), curve.getName()), curve));
+                // add entry for higher level forward curve name
+                group.getForwardCurves().forEach(
+                        (idx, curve) -> builder.addValue(CurveId.of(group.getName(), curve.getName()), curve));
+            }
+
+        } catch (Exception e) {
+            log.error("Error loading rates curves", e);
+        }
     }
 
-    ResourceLocator singleNameStaticDataResource = getResource(creditMarketDataDateDirectory, SINGLE_NAME_STATIC_DATA_FILE);
-    if (singleNameStaticDataResource == null) {
-      log.debug("Unable to load single name static data: file not found at {}/{}", creditMarketDataDateDirectory,
-          SINGLE_NAME_STATIC_DATA_FILE);
-      return;
+    // load quotes
+    private void loadQuotes(ImmutableMarketDataBuilder builder, LocalDate marketDataDate) {
+        if (!subdirectoryExists(QUOTES_DIR)) {
+            log.debug("No quotes directory found");
+            return;
+        }
+
+        ResourceLocator quotesResource = getResource(QUOTES_DIR, QUOTES_FILE);
+        if (quotesResource == null) {
+            log.error("Unable to load quotes: quotes file not found at {}/{}", QUOTES_DIR, QUOTES_FILE);
+            return;
+        }
+
+        try {
+            Map<QuoteId, Double> quotes = QuotesCsvLoader.load(marketDataDate, quotesResource);
+            builder.addValueMap(quotes);
+
+        } catch (Exception ex) {
+            log.error("Error loading quotes", ex);
+        }
     }
 
-    try {
-      CharSource inputCreditCurvesSource = singleNameCurvesResource.getCharSource();
-      CharSource inputStaticDataSource = singleNameStaticDataResource.getCharSource();
-      MarkitSingleNameCreditCurveDataParser.parse(builder, inputCreditCurvesSource, inputStaticDataSource);
-    } catch (Exception ex) {
-      throw new RuntimeException(String.format(
-          Locale.ENGLISH,
-          "Unable to read single name spread curves: exception at %s/%s",
-          creditMarketDataDateDirectory, SINGLE_NAME_CREDIT_CURVES_FILE), ex);
-    }
-  }
-
-  private void loadCdsIndexSpreadCurves(ImmutableMarketDataBuilder builder, String creditMarketDataDateDirectory) {
-    ResourceLocator inputCurvesResource = getResource(creditMarketDataDateDirectory, INDEX_CREDIT_CURVES_FILE);
-    if (inputCurvesResource == null) {
-      log.debug("Unable to load single name spread curves: file not found at {}/{}", creditMarketDataDateDirectory,
-          INDEX_CREDIT_CURVES_FILE);
-      return;
+    private void loadFxRates(ImmutableMarketDataBuilder builder) {
+        // TODO - load from CSV file - format to be defined
+        builder.addValue(FxRateId.of(Currency.GBP, Currency.USD), FxRate.of(Currency.GBP, Currency.USD, 1.61));
     }
 
-    ResourceLocator inputStaticDataResource = getResource(creditMarketDataDateDirectory, INDEX_STATIC_DATA_FILE);
-    if (inputStaticDataResource == null) {
-      log.debug("Unable to load index static data: file not found at {}/{}", creditMarketDataDateDirectory,
-          INDEX_STATIC_DATA_FILE);
-      return;
+    //-------------------------------------------------------------------------
+    private Collection<ResourceLocator> getRatesCurvesResources() {
+        return getAllResources(CURVES_DIR).stream()
+                .filter(res -> !res.getLocator().endsWith(CURVES_GROUPS_FILE))
+                .filter(res -> !res.getLocator().endsWith(CURVES_SETTINGS_FILE))
+                .collect(toImmutableList());
     }
 
-    CharSource indexCreditCurvesSource = inputCurvesResource.getCharSource();
-    CharSource indexStaticDataSource = inputStaticDataResource.getCharSource();
-    MarkitIndexCreditCurveDataParser.parse(builder, indexCreditCurvesSource, indexStaticDataSource);
+    private void loadCreditMarketData(ImmutableMarketDataBuilder builder, LocalDate marketDataDate) {
+        if (!subdirectoryExists(CREDIT_DIR)) {
+            log.debug("No credit curves directory found");
+            return;
+        }
 
-  }
+        String creditMarketDataDateDirectory = String.format(
+                Locale.ENGLISH,
+                "%s/%s",
+                CREDIT_DIR,
+                marketDataDate.format(DateTimeFormatter.ISO_LOCAL_DATE));
 
-  //-------------------------------------------------------------------------
-  /**
-   * Gets all available resources from a given subdirectory.
-   * 
-   * @param subdirectoryName  the name of the subdirectory
-   * @return a collection of locators for the resources in the subdirectory
-   */
-  protected abstract Collection<ResourceLocator> getAllResources(String subdirectoryName);
+        if (!subdirectoryExists(creditMarketDataDateDirectory)) {
+            log.debug("Unable to load market data: directory not found at {}", creditMarketDataDateDirectory);
+            return;
+        }
 
-  /**
-   * Gets a specific resource from a given subdirectory.
-   * 
-   * @param subdirectoryName  the name of the subdirectory
-   * @param resourceName  the name of the resource
-   * @return a locator for the requested resource
-   */
-  protected abstract ResourceLocator getResource(String subdirectoryName, String resourceName);
+        loadCdsYieldCurves(builder, creditMarketDataDateDirectory);
+        loadCdsSingleNameSpreadCurves(builder, creditMarketDataDateDirectory);
+        loadCdsIndexSpreadCurves(builder, creditMarketDataDateDirectory);
+    }
 
-  /**
-   * Checks whether a specific subdirectory exists.
-   * 
-   * @param subdirectoryName  the name of the subdirectory
-   * @return whether the subdirectory exists
-   */
-  protected abstract boolean subdirectoryExists(String subdirectoryName);
+    private void loadCdsYieldCurves(ImmutableMarketDataBuilder builder, String creditMarketDataDateDirectory) {
+        ResourceLocator cdsYieldCurvesResource = getResource(creditMarketDataDateDirectory, CDS_YIELD_CURVES_FILE);
+        if (cdsYieldCurvesResource == null) {
+            log.debug("Unable to load cds yield curves: file not found at {}/{}", creditMarketDataDateDirectory,
+                    CDS_YIELD_CURVES_FILE);
+            return;
+        }
+
+        CharSource inputSource = cdsYieldCurvesResource.getCharSource();
+        Map<IsdaYieldCurveInputsId, IsdaYieldCurveInputs> yieldCuves = MarkitYieldCurveDataParser.parse(inputSource);
+
+        for (IsdaYieldCurveInputsId id : yieldCuves.keySet()) {
+            IsdaYieldCurveInputs curveInputs = yieldCuves.get(id);
+            builder.addValue(id, curveInputs);
+        }
+    }
+
+    private void loadCdsSingleNameSpreadCurves(ImmutableMarketDataBuilder builder, String creditMarketDataDateDirectory) {
+        ResourceLocator singleNameCurvesResource = getResource(creditMarketDataDateDirectory, SINGLE_NAME_CREDIT_CURVES_FILE);
+        if (singleNameCurvesResource == null) {
+            log.debug("Unable to load single name spread curves: file not found at {}/{}", creditMarketDataDateDirectory,
+                    SINGLE_NAME_CREDIT_CURVES_FILE);
+            return;
+        }
+
+        ResourceLocator singleNameStaticDataResource = getResource(creditMarketDataDateDirectory, SINGLE_NAME_STATIC_DATA_FILE);
+        if (singleNameStaticDataResource == null) {
+            log.debug("Unable to load single name static data: file not found at {}/{}", creditMarketDataDateDirectory,
+                    SINGLE_NAME_STATIC_DATA_FILE);
+            return;
+        }
+
+        try {
+            CharSource inputCreditCurvesSource = singleNameCurvesResource.getCharSource();
+            CharSource inputStaticDataSource = singleNameStaticDataResource.getCharSource();
+            MarkitSingleNameCreditCurveDataParser.parse(builder, inputCreditCurvesSource, inputStaticDataSource);
+        } catch (Exception ex) {
+            throw new RuntimeException(String.format(
+                    Locale.ENGLISH,
+                    "Unable to read single name spread curves: exception at %s/%s",
+                    creditMarketDataDateDirectory, SINGLE_NAME_CREDIT_CURVES_FILE), ex);
+        }
+    }
+
+    private void loadCdsIndexSpreadCurves(ImmutableMarketDataBuilder builder, String creditMarketDataDateDirectory) {
+        ResourceLocator inputCurvesResource = getResource(creditMarketDataDateDirectory, INDEX_CREDIT_CURVES_FILE);
+        if (inputCurvesResource == null) {
+            log.debug("Unable to load single name spread curves: file not found at {}/{}", creditMarketDataDateDirectory,
+                    INDEX_CREDIT_CURVES_FILE);
+            return;
+        }
+
+        ResourceLocator inputStaticDataResource = getResource(creditMarketDataDateDirectory, INDEX_STATIC_DATA_FILE);
+        if (inputStaticDataResource == null) {
+            log.debug("Unable to load index static data: file not found at {}/{}", creditMarketDataDateDirectory,
+                    INDEX_STATIC_DATA_FILE);
+            return;
+        }
+
+        CharSource indexCreditCurvesSource = inputCurvesResource.getCharSource();
+        CharSource indexStaticDataSource = inputStaticDataResource.getCharSource();
+        MarkitIndexCreditCurveDataParser.parse(builder, indexCreditCurvesSource, indexStaticDataSource);
+
+    }
+
+    //-------------------------------------------------------------------------
+
+    /**
+     * Gets all available resources from a given subdirectory.
+     *
+     * @param subdirectoryName  the name of the subdirectory
+     * @return a collection of locators for the resources in the subdirectory
+     */
+    protected abstract Collection<ResourceLocator> getAllResources(String subdirectoryName);
+
+    /**
+     * Gets a specific resource from a given subdirectory.
+     *
+     * @param subdirectoryName  the name of the subdirectory
+     * @param resourceName  the name of the resource
+     * @return a locator for the requested resource
+     */
+    protected abstract ResourceLocator getResource(String subdirectoryName, String resourceName);
+
+    /**
+     * Checks whether a specific subdirectory exists.
+     *
+     * @param subdirectoryName  the name of the subdirectory
+     * @return whether the subdirectory exists
+     */
+    protected abstract boolean subdirectoryExists(String subdirectoryName);
 
 }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/JarMarketDataBuilder.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/JarMarketDataBuilder.java
index cc599609da..34ed9064e4 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/JarMarketDataBuilder.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/JarMarketDataBuilder.java
@@ -1,6 +1,6 @@
 /**
  * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
- * 
+ * <p>
  * Please see distribution for license.
  */
 package com.opengamma.strata.examples.marketdata;
@@ -22,96 +22,96 @@ import java.util.stream.Collectors;
  */
 public class JarMarketDataBuilder extends ExampleMarketDataBuilder {
 
-  /**
-   * The JAR file containing the expected structure of resources.
-   */
-  private final File jarFile;
-  /**
-   * The root path to the resources within the JAR file.
-   */
-  private final String rootPath;
-  /**
-   * A cache of JAR entries under the root path.
-   */
-  private final ImmutableSet<String> entries;
+    /**
+     * The JAR file containing the expected structure of resources.
+     */
+    private final File jarFile;
+    /**
+     * The root path to the resources within the JAR file.
+     */
+    private final String rootPath;
+    /**
+     * A cache of JAR entries under the root path.
+     */
+    private final ImmutableSet<String> entries;
 
-  /**
-   * Constructs an instance.
-   * 
-   * @param jarFile  the JAR file containing the expected structure of resources
-   * @param rootPath  the root path to the resources within the JAR file
-   */
-  public JarMarketDataBuilder(File jarFile, String rootPath) {
-    // classpath resources are forward-slash separated
-    String jarRoot = rootPath.startsWith("/") ? rootPath.substring(1) : rootPath;
-    if (!jarRoot.endsWith("/")) {
-      jarRoot += "/";
-    }
-    this.jarFile = jarFile;
-    this.rootPath = jarRoot;
-    this.entries = getEntries(jarFile, rootPath);
-  }
-
-  //-------------------------------------------------------------------------
-  @Override
-  protected Collection<ResourceLocator> getAllResources(String subdirectoryName) {
-    String resolvedSubdirectory = subdirectoryName + "/";
-    return entries.stream()
-        .filter(e -> e.startsWith(resolvedSubdirectory) && !e.equals(resolvedSubdirectory))
-        .map(e -> getEntryLocator(rootPath + e))
-        .collect(Collectors.toSet());
-  }
-
-  @Override
-  protected ResourceLocator getResource(String subdirectoryName, String resourceName) {
-    String fullLocation = String.format(Locale.ENGLISH, "%s%s/%s", rootPath, subdirectoryName, resourceName);
-    try (JarFile jar = new JarFile(jarFile)) {
-      JarEntry entry = jar.getJarEntry(fullLocation);
-      if (entry == null) {
-        return null;
-      }
-      return getEntryLocator(entry.getName());
-    } catch (Exception e) {
-      throw new IllegalArgumentException(
-          Messages.format("Error loading resource from JAR file: {}", jarFile), e);
-    }
-  }
-
-  @Override
-  protected boolean subdirectoryExists(String subdirectoryName) {
-    // classpath resources are forward-slash separated
-    String resolvedName = subdirectoryName.startsWith("/") ? subdirectoryName.substring(1) : subdirectoryName;
-    if (!resolvedName.endsWith("/")) {
-      resolvedName += "/";
-    }
-    return entries.contains(resolvedName);
-  }
-
-  //-------------------------------------------------------------------------
-  // Gets the resource locator corresponding to a given entry
-  private ResourceLocator getEntryLocator(String entryName) {
-    return ResourceLocator.of(ResourceLocator.CLASSPATH_URL_PREFIX + entryName);
-  }
-
-  private static ImmutableSet<String> getEntries(File jarFile, String rootPath) {
-    ImmutableSet.Builder<String> builder = ImmutableSet.builder();
-    try (JarFile jar = new JarFile(jarFile)) {
-      Enumeration<JarEntry> jarEntries = jar.entries();
-      while (jarEntries.hasMoreElements()) {
-        JarEntry entry = jarEntries.nextElement();
-        String entryName = entry.getName();
-        if (entryName.startsWith(rootPath) && !entryName.equals(rootPath)) {
-          String relativeEntryPath = entryName.substring(rootPath.length() + 1);
-          if (!relativeEntryPath.trim().isEmpty()) {
-            builder.add(relativeEntryPath);
-          }
+    /**
+     * Constructs an instance.
+     *
+     * @param jarFile  the JAR file containing the expected structure of resources
+     * @param rootPath  the root path to the resources within the JAR file
+     */
+    public JarMarketDataBuilder(File jarFile, String rootPath) {
+        // classpath resources are forward-slash separated
+        String jarRoot = rootPath.startsWith("/") ? rootPath.substring(1) : rootPath;
+        if (!jarRoot.endsWith("/")) {
+            jarRoot += "/";
         }
-      }
-    } catch (Exception e) {
-      throw new IllegalArgumentException(
-          Messages.format("Error scanning entries in JAR file: {}", jarFile), e);
+        this.jarFile = jarFile;
+        this.rootPath = jarRoot;
+        this.entries = getEntries(jarFile, rootPath);
+    }
+
+    //-------------------------------------------------------------------------
+    @Override
+    protected Collection<ResourceLocator> getAllResources(String subdirectoryName) {
+        String resolvedSubdirectory = subdirectoryName + "/";
+        return entries.stream()
+                .filter(e -> e.startsWith(resolvedSubdirectory) && !e.equals(resolvedSubdirectory))
+                .map(e -> getEntryLocator(rootPath + e))
+                .collect(Collectors.toSet());
+    }
+
+    @Override
+    protected ResourceLocator getResource(String subdirectoryName, String resourceName) {
+        String fullLocation = String.format(Locale.ENGLISH, "%s%s/%s", rootPath, subdirectoryName, resourceName);
+        try (JarFile jar = new JarFile(jarFile)) {
+            JarEntry entry = jar.getJarEntry(fullLocation);
+            if (entry == null) {
+                return null;
+            }
+            return getEntryLocator(entry.getName());
+        } catch (Exception e) {
+            throw new IllegalArgumentException(
+                    Messages.format("Error loading resource from JAR file: {}", jarFile), e);
+        }
+    }
+
+    @Override
+    protected boolean subdirectoryExists(String subdirectoryName) {
+        // classpath resources are forward-slash separated
+        String resolvedName = subdirectoryName.startsWith("/") ? subdirectoryName.substring(1) : subdirectoryName;
+        if (!resolvedName.endsWith("/")) {
+            resolvedName += "/";
+        }
+        return entries.contains(resolvedName);
+    }
+
+    //-------------------------------------------------------------------------
+    // Gets the resource locator corresponding to a given entry
+    private ResourceLocator getEntryLocator(String entryName) {
+        return ResourceLocator.of(ResourceLocator.CLASSPATH_URL_PREFIX + entryName);
+    }
+
+    private static ImmutableSet<String> getEntries(File jarFile, String rootPath) {
+        ImmutableSet.Builder<String> builder = ImmutableSet.builder();
+        try (JarFile jar = new JarFile(jarFile)) {
+            Enumeration<JarEntry> jarEntries = jar.entries();
+            while (jarEntries.hasMoreElements()) {
+                JarEntry entry = jarEntries.nextElement();
+                String entryName = entry.getName();
+                if (entryName.startsWith(rootPath) && !entryName.equals(rootPath)) {
+                    String relativeEntryPath = entryName.substring(rootPath.length() + 1);
+                    if (!relativeEntryPath.trim().isEmpty()) {
+                        builder.add(relativeEntryPath);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            throw new IllegalArgumentException(
+                    Messages.format("Error scanning entries in JAR file: {}", jarFile), e);
+        }
+        return builder.build();
     }
-    return builder.build();
-  }
 
 }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitIndexCreditCurveDataParser.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitIndexCreditCurveDataParser.java
index 7b3bdd8c86..9f220e2e58 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitIndexCreditCurveDataParser.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitIndexCreditCurveDataParser.java
@@ -1,6 +1,6 @@
 /**
  * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
- *
+ * <p>
  * Please see distribution for license.
  */
 package com.opengamma.strata.examples.marketdata.credit.markit;
@@ -44,217 +44,219 @@ import java.util.Map;
  */
 public class MarkitIndexCreditCurveDataParser {
 
-  // Markit date format with the month in full caps. e.g. 11-JUL-14
-  private static final DateTimeFormatter DATE_FORMAT = new DateTimeFormatterBuilder()
-      .parseCaseInsensitive().appendPattern("dd-MMM-uu").toFormatter(Locale.ENGLISH);
+    // Markit date format with the month in full caps. e.g. 11-JUL-14
+    private static final DateTimeFormatter DATE_FORMAT = new DateTimeFormatterBuilder()
+            .parseCaseInsensitive().appendPattern("dd-MMM-uu").toFormatter(Locale.ENGLISH);
 
-  enum Columns {
+    enum Columns {
 
-    Series("Series"),
-    Version("Version"),
-    Term("Term"),
-    RedCode("RED Code"),
-    Maturity("Maturity"),
-    CompositeSpread("Composite Spread"),
-    ModelSpread("Model Spread");
+        Series("Series"),
+        Version("Version"),
+        Term("Term"),
+        RedCode("RED Code"),
+        Maturity("Maturity"),
+        CompositeSpread("Composite Spread"),
+        ModelSpread("Model Spread");
 
-    private final String columnName;
+        private final String columnName;
 
-    Columns(String columnName) {
-      this.columnName = columnName;
-    }
-
-    public String getColumnName() {
-      return columnName;
-    }
-  }
-
-  /**
-   * Parses the specified sources.
-   * 
-   * @param builder  the market data builder that the resulting curve and recovery rate items should be loaded into
-   * @param curveSource  the source of curve data to parse
-   * @param staticDataSource  the source of static data to parse
-   */
-  public static void parse(
-      ImmutableMarketDataBuilder builder,
-      CharSource curveSource,
-      CharSource staticDataSource) {
-
-    Map<IsdaIndexCreditCurveInputsId, List<Point>> curveData = Maps.newHashMap();
-    Map<MarkitRedCode, StaticData> staticDataMap = parseStaticData(staticDataSource);
-
-    CsvFile csv = CsvFile.of(curveSource, true);
-    for (CsvRow row : csv.rows()) {
-      String seriesText = row.getField(Columns.Series.getColumnName());
-      String versionText = row.getField(Columns.Version.getColumnName());
-      String termText = row.getField(Columns.Term.getColumnName());
-      String redCodeText = row.getField(Columns.RedCode.getColumnName());
-      String maturityText = row.getField(Columns.Maturity.getColumnName());
-      String compositeSpreadText = row.getField(Columns.CompositeSpread.getColumnName());
-      String modelSpreadText = row.getField(Columns.ModelSpread.getColumnName());
-
-      StandardId indexId = MarkitRedCode.id(redCodeText);
-      int indexSeries = Integer.parseInt(seriesText);
-      int indexAnnexVersion = Integer.parseInt(versionText);
-
-      IsdaIndexCreditCurveInputsId id = IsdaIndexCreditCurveInputsId.of(
-          IndexReferenceInformation.of(
-              indexId,
-              indexSeries,
-              indexAnnexVersion));
-
-      Tenor term = Tenor.parse(termText);
-      LocalDate maturity = LocalDate.parse(maturityText, DATE_FORMAT);
-
-      double spread;
-      if (compositeSpreadText.isEmpty()) {
-        if (modelSpreadText.isEmpty()) {
-          // there is no rate for this row, continue
-          continue;
+        Columns(String columnName) {
+            this.columnName = columnName;
         }
-        // fall back to the model rate is the composite is missing
-        spread = parseRate(modelSpreadText);
-      } else {
-        // prefer the composite rate if it is present
-        spread = parseRate(compositeSpreadText);
-      }
 
-      List<Point> points = curveData.get(id);
-      if (points == null) {
-        points = Lists.newArrayList();
-        curveData.put(id, points);
-      }
-      points.add(new Point(term, maturity, spread));
+        public String getColumnName() {
+            return columnName;
+        }
     }
 
-    for (IsdaIndexCreditCurveInputsId curveId : curveData.keySet()) {
-      MarkitRedCode redCode = MarkitRedCode.from(curveId.getReferenceInformation().getIndexId());
-      StaticData staticData = staticDataMap.get(redCode);
-      ArgChecker.notNull(staticData, "Did not find a static data record for " + redCode);
-      CdsConvention convention = staticData.getConvention();
-      double recoveryRate = staticData.getRecoveryRate();
-      double indexFactor = staticData.getIndexFactor();
-      // TODO add fromDate handling
+    /**
+     * Parses the specified sources.
+     *
+     * @param builder  the market data builder that the resulting curve and recovery rate items should be loaded into
+     * @param curveSource  the source of curve data to parse
+     * @param staticDataSource  the source of static data to parse
+     */
+    public static void parse(
+            ImmutableMarketDataBuilder builder,
+            CharSource curveSource,
+            CharSource staticDataSource) {
 
-      String creditCurveName = curveId.toString();
+        Map<IsdaIndexCreditCurveInputsId, List<Point>> curveData = Maps.newHashMap();
+        Map<MarkitRedCode, StaticData> staticDataMap = parseStaticData(staticDataSource);
 
-      List<Point> points = curveData.get(curveId);
+        CsvFile csv = CsvFile.of(curveSource, true);
+        for (CsvRow row : csv.rows()) {
+            String seriesText = row.getField(Columns.Series.getColumnName());
+            String versionText = row.getField(Columns.Version.getColumnName());
+            String termText = row.getField(Columns.Term.getColumnName());
+            String redCodeText = row.getField(Columns.RedCode.getColumnName());
+            String maturityText = row.getField(Columns.Maturity.getColumnName());
+            String compositeSpreadText = row.getField(Columns.CompositeSpread.getColumnName());
+            String modelSpreadText = row.getField(Columns.ModelSpread.getColumnName());
 
-      Period[] periods = points.stream().map(s -> s.getTenor().getPeriod()).toArray(Period[]::new);
-      LocalDate[] endDates = points.stream().map(s -> s.getDate()).toArray(LocalDate[]::new);
-      double[] rates = points.stream().mapToDouble(s -> s.getRate()).toArray();
+            StandardId indexId = MarkitRedCode.id(redCodeText);
+            int indexSeries = Integer.parseInt(seriesText);
+            int indexAnnexVersion = Integer.parseInt(versionText);
 
-      IsdaCreditCurveInputs curveInputs = IsdaCreditCurveInputs.of(
-          CurveName.of(creditCurveName),
-          periods,
-          endDates,
-          rates,
-          convention,
-          indexFactor);
+            IsdaIndexCreditCurveInputsId id = IsdaIndexCreditCurveInputsId.of(
+                    IndexReferenceInformation.of(
+                            indexId,
+                            indexSeries,
+                            indexAnnexVersion));
 
-      builder.addValue(curveId, curveInputs);
+            Tenor term = Tenor.parse(termText);
+            LocalDate maturity = LocalDate.parse(maturityText, DATE_FORMAT);
 
-      IsdaIndexRecoveryRateId recoveryRateId = IsdaIndexRecoveryRateId.of(curveId.getReferenceInformation());
-      CdsRecoveryRate cdsRecoveryRate = CdsRecoveryRate.of(recoveryRate);
+            double spread;
+            if (compositeSpreadText.isEmpty()) {
+                if (modelSpreadText.isEmpty()) {
+                    // there is no rate for this row, continue
+                    continue;
+                }
+                // fall back to the model rate is the composite is missing
+                spread = parseRate(modelSpreadText);
+            } else {
+                // prefer the composite rate if it is present
+                spread = parseRate(compositeSpreadText);
+            }
 
-      builder.addValue(recoveryRateId, cdsRecoveryRate);
-    }
-  }
+            List<Point> points = curveData.get(id);
+            if (points == null) {
+                points = Lists.newArrayList();
+                curveData.put(id, points);
+            }
+            points.add(new Point(term, maturity, spread));
+        }
 
-  // parses the static data file
-  private static Map<MarkitRedCode, StaticData> parseStaticData(CharSource source) {
-    CsvFile csv = CsvFile.of(source, true);
+        for (IsdaIndexCreditCurveInputsId curveId : curveData.keySet()) {
+            MarkitRedCode redCode = MarkitRedCode.from(curveId.getReferenceInformation().getIndexId());
+            StaticData staticData = staticDataMap.get(redCode);
+            ArgChecker.notNull(staticData, "Did not find a static data record for " + redCode);
+            CdsConvention convention = staticData.getConvention();
+            double recoveryRate = staticData.getRecoveryRate();
+            double indexFactor = staticData.getIndexFactor();
+            // TODO add fromDate handling
 
-    Map<MarkitRedCode, StaticData> result = Maps.newHashMap();
-    for (CsvRow row : csv.rows()) {
-      String redCodeText = row.getField("RedCode");
-      String fromDateText = row.getField("From Date");
-      String conventionText = row.getField("Convention");
-      String recoveryRateText = row.getField("Recovery Rate");
-      String indexFactorText = row.getField("Index Factor");
+            String creditCurveName = curveId.toString();
 
-      MarkitRedCode redCode = MarkitRedCode.of(redCodeText);
-      LocalDate fromDate = LocalDate.parse(fromDateText, DATE_FORMAT);
-      CdsConvention convention = CdsConvention.of(conventionText);
-      double recoveryRate = parseRate(recoveryRateText);
-      double indexFactor = Double.parseDouble(indexFactorText);
+            List<Point> points = curveData.get(curveId);
 
-      result.put(redCode, new StaticData(fromDate, convention, recoveryRate, indexFactor));
-    }
-    return result;
-  }
+            Period[] periods = points.stream().map(s -> s.getTenor().getPeriod()).toArray(Period[]::new);
+            LocalDate[] endDates = points.stream().map(s -> s.getDate()).toArray(LocalDate[]::new);
+            double[] rates = points.stream().mapToDouble(s -> s.getRate()).toArray();
 
-  //-------------------------------------------------------------------------
-  /**
-   * Stores the parsed static data.
-   */
-  private static class StaticData {
+            IsdaCreditCurveInputs curveInputs = IsdaCreditCurveInputs.of(
+                    CurveName.of(creditCurveName),
+                    periods,
+                    endDates,
+                    rates,
+                    convention,
+                    indexFactor);
 
-    private LocalDate fromDate;
-    private CdsConvention convention;
-    private double recoveryRate;
-    private double indexFactor;
+            builder.addValue(curveId, curveInputs);
 
-    private StaticData(LocalDate fromDate, CdsConvention convention, double recoveryRate, double indexFactor) {
-      this.fromDate = fromDate;
-      this.convention = convention;
-      this.recoveryRate = recoveryRate;
-      this.indexFactor = indexFactor;
+            IsdaIndexRecoveryRateId recoveryRateId = IsdaIndexRecoveryRateId.of(curveId.getReferenceInformation());
+            CdsRecoveryRate cdsRecoveryRate = CdsRecoveryRate.of(recoveryRate);
+
+            builder.addValue(recoveryRateId, cdsRecoveryRate);
+        }
     }
 
-    @SuppressWarnings("unused")
-    public LocalDate getFromDate() {
-      return fromDate;
+    // parses the static data file
+    private static Map<MarkitRedCode, StaticData> parseStaticData(CharSource source) {
+        CsvFile csv = CsvFile.of(source, true);
+
+        Map<MarkitRedCode, StaticData> result = Maps.newHashMap();
+        for (CsvRow row : csv.rows()) {
+            String redCodeText = row.getField("RedCode");
+            String fromDateText = row.getField("From Date");
+            String conventionText = row.getField("Convention");
+            String recoveryRateText = row.getField("Recovery Rate");
+            String indexFactorText = row.getField("Index Factor");
+
+            MarkitRedCode redCode = MarkitRedCode.of(redCodeText);
+            LocalDate fromDate = LocalDate.parse(fromDateText, DATE_FORMAT);
+            CdsConvention convention = CdsConvention.of(conventionText);
+            double recoveryRate = parseRate(recoveryRateText);
+            double indexFactor = Double.parseDouble(indexFactorText);
+
+            result.put(redCode, new StaticData(fromDate, convention, recoveryRate, indexFactor));
+        }
+        return result;
     }
 
-    public CdsConvention getConvention() {
-      return convention;
+    //-------------------------------------------------------------------------
+
+    /**
+     * Stores the parsed static data.
+     */
+    private static class StaticData {
+
+        private LocalDate fromDate;
+        private CdsConvention convention;
+        private double recoveryRate;
+        private double indexFactor;
+
+        private StaticData(LocalDate fromDate, CdsConvention convention, double recoveryRate, double indexFactor) {
+            this.fromDate = fromDate;
+            this.convention = convention;
+            this.recoveryRate = recoveryRate;
+            this.indexFactor = indexFactor;
+        }
+
+        @SuppressWarnings("unused")
+        public LocalDate getFromDate() {
+            return fromDate;
+        }
+
+        public CdsConvention getConvention() {
+            return convention;
+        }
+
+        public double getRecoveryRate() {
+            return recoveryRate;
+        }
+
+        public double getIndexFactor() {
+            return indexFactor;
+        }
     }
 
-    public double getRecoveryRate() {
-      return recoveryRate;
+    //-------------------------------------------------------------------------
+
+    /**
+     * Stores the parsed data points.
+     */
+    private static class Point {
+        private final Tenor tenor;
+
+        private final LocalDate date;
+
+        private final double rate;
+
+        private Point(Tenor tenor, LocalDate date, double rate) {
+            this.tenor = tenor;
+            this.date = date;
+            this.rate = rate;
+        }
+
+        public Tenor getTenor() {
+            return tenor;
+        }
+
+        public LocalDate getDate() {
+            return date;
+        }
+
+        public double getRate() {
+            return rate;
+        }
     }
 
-    public double getIndexFactor() {
-      return indexFactor;
+    // Converts from a string percentage rate with a percent sign to a double rate
+    // e.g. 0.12% => 0.0012d
+    private static double parseRate(String input) {
+        return Double.parseDouble(input.replace("%", "")) / 100d;
     }
-  }
-
-  //-------------------------------------------------------------------------
-  /**
-   * Stores the parsed data points.
-   */
-  private static class Point {
-    private final Tenor tenor;
-
-    private final LocalDate date;
-
-    private final double rate;
-
-    private Point(Tenor tenor, LocalDate date, double rate) {
-      this.tenor = tenor;
-      this.date = date;
-      this.rate = rate;
-    }
-
-    public Tenor getTenor() {
-      return tenor;
-    }
-
-    public LocalDate getDate() {
-      return date;
-    }
-
-    public double getRate() {
-      return rate;
-    }
-  }
-
-  // Converts from a string percentage rate with a percent sign to a double rate
-  // e.g. 0.12% => 0.0012d
-  private static double parseRate(String input) {
-    return Double.parseDouble(input.replace("%", "")) / 100d;
-  }
 
 }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitRedCode.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitRedCode.java
index bae17190a3..0581a6c772 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitRedCode.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitRedCode.java
@@ -1,6 +1,6 @@
 /**
  * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
- *
+ * <p>
  * Please see distribution for license.
  */
 package com.opengamma.strata.examples.marketdata.credit.markit;
@@ -19,72 +19,74 @@ import org.joda.convert.FromString;
  * http://www.markit.com/product/reference-data-cds
  */
 public final class MarkitRedCode
-    extends TypedString<MarkitRedCode> {
+        extends TypedString<MarkitRedCode> {
 
-  /**
-   * Serialization version.
-   */
-  private static final long serialVersionUID = 1L;
+    /**
+     * Serialization version.
+     */
+    private static final long serialVersionUID = 1L;
 
-  /**
-   * Scheme used in an OpenGamma {@link StandardId} where the value is a Markit RED code.
-   */
-  public static final String MARKIT_REDCODE_SCHEME = "MarkitRedCode";
+    /**
+     * Scheme used in an OpenGamma {@link StandardId} where the value is a Markit RED code.
+     */
+    public static final String MARKIT_REDCODE_SCHEME = "MarkitRedCode";
 
-  //-------------------------------------------------------------------------
-  /**
-   * Obtains an instance from the specified name.
-   * <p>
-   * RED codes must be 6 or 9 characters long.
-   *
-   * @param name  the name of the field
-   * @return a RED code
-   */
-  @FromString
-  public static MarkitRedCode of(String name) {
-    ArgChecker.isTrue(name.length() == 6 || name.length() == 9, "RED Code must be exactly 6 or 9 characters");
-    return new MarkitRedCode(name);
-  }
+    //-------------------------------------------------------------------------
 
-  /**
-   * Converts from a standard identifier ensuring the scheme is correct.
-   *
-   * @param id standard id identifying a RED code
-   * @return the equivalent RED code
-   */
-  public static MarkitRedCode from(StandardId id) {
-    Preconditions.checkArgument(id.getScheme().equals(MARKIT_REDCODE_SCHEME));
-    return MarkitRedCode.of(id.getValue());
-  }
+    /**
+     * Obtains an instance from the specified name.
+     * <p>
+     * RED codes must be 6 or 9 characters long.
+     *
+     * @param name  the name of the field
+     * @return a RED code
+     */
+    @FromString
+    public static MarkitRedCode of(String name) {
+        ArgChecker.isTrue(name.length() == 6 || name.length() == 9, "RED Code must be exactly 6 or 9 characters");
+        return new MarkitRedCode(name);
+    }
 
-  /**
-   * Creates a standard identifier using the correct Markit RED code scheme.
-   *
-   * @param name  the Markit RED code, 6 or 9 characters long
-   * @return the equivalent standard identifier
-   */
-  public static StandardId id(String name) {
-    ArgChecker.isTrue(name.length() == 6 || name.length() == 9, "RED Code must be exactly 6 or 9 characters");
-    return StandardId.of(MARKIT_REDCODE_SCHEME, name);
-  }
+    /**
+     * Converts from a standard identifier ensuring the scheme is correct.
+     *
+     * @param id standard id identifying a RED code
+     * @return the equivalent RED code
+     */
+    public static MarkitRedCode from(StandardId id) {
+        Preconditions.checkArgument(id.getScheme().equals(MARKIT_REDCODE_SCHEME));
+        return MarkitRedCode.of(id.getValue());
+    }
 
-  /**
-   * Creates an instance.
-   * 
-   * @param name  the RED code
-   */
-  private MarkitRedCode(String name) {
-    super(name);
-  }
+    /**
+     * Creates a standard identifier using the correct Markit RED code scheme.
+     *
+     * @param name  the Markit RED code, 6 or 9 characters long
+     * @return the equivalent standard identifier
+     */
+    public static StandardId id(String name) {
+        ArgChecker.isTrue(name.length() == 6 || name.length() == 9, "RED Code must be exactly 6 or 9 characters");
+        return StandardId.of(MARKIT_REDCODE_SCHEME, name);
+    }
 
-  //-------------------------------------------------------------------------
-  /**
-   * Converts this RED code to a standard identifier.
-   * 
-   * @return the standard identifier
-   */
-  public StandardId toStandardId() {
-    return StandardId.of(MARKIT_REDCODE_SCHEME, getName());
-  }
+    /**
+     * Creates an instance.
+     *
+     * @param name  the RED code
+     */
+    private MarkitRedCode(String name) {
+        super(name);
+    }
+
+    //-------------------------------------------------------------------------
+
+    /**
+     * Converts this RED code to a standard identifier.
+     *
+     * @return the standard identifier
+     */
+    public StandardId toStandardId() {
+        return StandardId.of(MARKIT_REDCODE_SCHEME, getName());
+    }
 
 }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitRestructuringClause.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitRestructuringClause.java
index 35e87365a6..be4cdd1b16 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitRestructuringClause.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitRestructuringClause.java
@@ -1,6 +1,6 @@
 /**
  * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
- *
+ * <p>
  * Please see distribution for license.
  */
 package com.opengamma.strata.examples.marketdata.credit.markit;
@@ -14,96 +14,97 @@ import com.opengamma.strata.product.credit.RestructuringClause;
  */
 public enum MarkitRestructuringClause {
 
-  /**
-   * Modified-Modified Restructuring 2003.
-   */
-  MM,
-  /**
-   * Modified-Modified Restructuring 2014.
-   */
-  MM14,
-  /**
-   * Modified Restructuring 2003.
-   */
-  MR,
-  /**
-   * Modified Restructuring 2014.
-   */
-  MR14,
-  /**
-   * Cum/Old/Full Restructuring 2003.
-   */
-  CR,
-  /**
-   * Cum/Old/Full Restructuring 2014.
-   */
-  CR14,
-  /**
-   * Ex/No restructuring 2003.
-   */
-  XR,
-  /**
-   * Ex/No restructuring 2014.
-   */
-  XR14;
+    /**
+     * Modified-Modified Restructuring 2003.
+     */
+    MM,
+    /**
+     * Modified-Modified Restructuring 2014.
+     */
+    MM14,
+    /**
+     * Modified Restructuring 2003.
+     */
+    MR,
+    /**
+     * Modified Restructuring 2014.
+     */
+    MR14,
+    /**
+     * Cum/Old/Full Restructuring 2003.
+     */
+    CR,
+    /**
+     * Cum/Old/Full Restructuring 2014.
+     */
+    CR14,
+    /**
+     * Ex/No restructuring 2003.
+     */
+    XR,
+    /**
+     * Ex/No restructuring 2014.
+     */
+    XR14;
 
-  //-------------------------------------------------------------------------
-  /**
-   * Converts Markit code to standard restructuring clause.
-   * 
-   * @return the converted clause
-   */
-  public RestructuringClause translate() {
-    switch (this) {
-      case MM:
-        return RestructuringClause.MOD_MOD_RESTRUCTURING_2003;
-      case MM14:
-        return RestructuringClause.MOD_MOD_RESTRUCTURING_2014;
-      case MR:
-        return RestructuringClause.MODIFIED_RESTRUCTURING_2003;
-      case MR14:
-        return RestructuringClause.MODIFIED_RESTRUCTURING_2014;
-      case CR:
-        return RestructuringClause.CUM_RESTRUCTURING_2003;
-      case CR14:
-        return RestructuringClause.CUM_RESTRUCTURING_2014;
-      case XR:
-        return RestructuringClause.NO_RESTRUCTURING_2003;
-      case XR14:
-        return RestructuringClause.NO_RESTRUCTURING_2014;
-      default:
-        throw new IllegalStateException("Unmapped restructuring clause. Do not have mapping for " + this);
+    //-------------------------------------------------------------------------
+
+    /**
+     * Converts Markit code to standard restructuring clause.
+     *
+     * @return the converted clause
+     */
+    public RestructuringClause translate() {
+        switch (this) {
+            case MM:
+                return RestructuringClause.MOD_MOD_RESTRUCTURING_2003;
+            case MM14:
+                return RestructuringClause.MOD_MOD_RESTRUCTURING_2014;
+            case MR:
+                return RestructuringClause.MODIFIED_RESTRUCTURING_2003;
+            case MR14:
+                return RestructuringClause.MODIFIED_RESTRUCTURING_2014;
+            case CR:
+                return RestructuringClause.CUM_RESTRUCTURING_2003;
+            case CR14:
+                return RestructuringClause.CUM_RESTRUCTURING_2014;
+            case XR:
+                return RestructuringClause.NO_RESTRUCTURING_2003;
+            case XR14:
+                return RestructuringClause.NO_RESTRUCTURING_2014;
+            default:
+                throw new IllegalStateException("Unmapped restructuring clause. Do not have mapping for " + this);
+        }
     }
-  }
 
-  /**
-   * Converts restructuring clause to Markit equivalent.
-   * 
-   * @param restructuringClause  the clause to convert
-   * @return the converted clause
-   */
-  public static MarkitRestructuringClause from(RestructuringClause restructuringClause) {
-    switch (restructuringClause) {
-      case MOD_MOD_RESTRUCTURING_2003:
-        return MM;
-      case MOD_MOD_RESTRUCTURING_2014:
-        return MM14;
-      case MODIFIED_RESTRUCTURING_2003:
-        return MR;
-      case MODIFIED_RESTRUCTURING_2014:
-        return MR14;
-      case CUM_RESTRUCTURING_2003:
-        return CR;
-      case CUM_RESTRUCTURING_2014:
-        return CR14;
-      case NO_RESTRUCTURING_2003:
-        return XR;
-      case NO_RESTRUCTURING_2014:
-        return XR14;
-      default:
-        throw new UnsupportedOperationException("Unknown restructuring clause. Do not have mapping for " + restructuringClause);
+    /**
+     * Converts restructuring clause to Markit equivalent.
+     *
+     * @param restructuringClause  the clause to convert
+     * @return the converted clause
+     */
+    public static MarkitRestructuringClause from(RestructuringClause restructuringClause) {
+        switch (restructuringClause) {
+            case MOD_MOD_RESTRUCTURING_2003:
+                return MM;
+            case MOD_MOD_RESTRUCTURING_2014:
+                return MM14;
+            case MODIFIED_RESTRUCTURING_2003:
+                return MR;
+            case MODIFIED_RESTRUCTURING_2014:
+                return MR14;
+            case CUM_RESTRUCTURING_2003:
+                return CR;
+            case CUM_RESTRUCTURING_2014:
+                return CR14;
+            case NO_RESTRUCTURING_2003:
+                return XR;
+            case NO_RESTRUCTURING_2014:
+                return XR14;
+            default:
+                throw new UnsupportedOperationException("Unknown restructuring clause. Do not have mapping for " + restructuringClause);
 
+        }
     }
-  }
 
 }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitSeniorityLevel.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitSeniorityLevel.java
index 53829372d4..8aca3087d0 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitSeniorityLevel.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitSeniorityLevel.java
@@ -1,6 +1,6 @@
 /**
  * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
- *
+ * <p>
  * Please see distribution for license.
  */
 package com.opengamma.strata.examples.marketdata.credit.markit;
@@ -14,75 +14,76 @@ import com.opengamma.strata.product.credit.SeniorityLevel;
  */
 public enum MarkitSeniorityLevel {
 
-  /**
-   * Senior domestic.
-   */
-  SECDOM,
+    /**
+     * Senior domestic.
+     */
+    SECDOM,
 
-  /**
-   * Senior foreign.
-   */
-  SNRFOR,
+    /**
+     * Senior foreign.
+     */
+    SNRFOR,
 
-  /**
-   * Subordinate, Lower Tier 2.
-   */
-  SUBLT2,
+    /**
+     * Subordinate, Lower Tier 2.
+     */
+    SUBLT2,
 
-  /**
-   * Subordinate Tier 1.
-   */
-  PREFT1,
+    /**
+     * Subordinate Tier 1.
+     */
+    PREFT1,
 
-  /**
-   * Subordinate, Upper Tier 2.
-   */
-  JRSUBUT2;
+    /**
+     * Subordinate, Upper Tier 2.
+     */
+    JRSUBUT2;
 
-  //-------------------------------------------------------------------------
-  /**
-   * Converts Markit code to standard seniority level.
-   * 
-   * @return the converted level
-   */
-  public SeniorityLevel translate() {
-    switch (this) {
-      case SECDOM:
-        return SeniorityLevel.SENIOR_SECURED_DOMESTIC;
-      case SNRFOR:
-        return SeniorityLevel.SENIOR_UNSECURED_FOREIGN;
-      case SUBLT2:
-        return SeniorityLevel.SUBORDINATE_LOWER_TIER_2;
-      case PREFT1:
-        return SeniorityLevel.SUBORDINATE_TIER_1;
-      case JRSUBUT2:
-        return SeniorityLevel.SUBORDINATE_UPPER_TIER_2;
-      default:
-        throw new IllegalStateException("Unmapped seniority level. Do not have mapping for " + this);
+    //-------------------------------------------------------------------------
+
+    /**
+     * Converts Markit code to standard seniority level.
+     *
+     * @return the converted level
+     */
+    public SeniorityLevel translate() {
+        switch (this) {
+            case SECDOM:
+                return SeniorityLevel.SENIOR_SECURED_DOMESTIC;
+            case SNRFOR:
+                return SeniorityLevel.SENIOR_UNSECURED_FOREIGN;
+            case SUBLT2:
+                return SeniorityLevel.SUBORDINATE_LOWER_TIER_2;
+            case PREFT1:
+                return SeniorityLevel.SUBORDINATE_TIER_1;
+            case JRSUBUT2:
+                return SeniorityLevel.SUBORDINATE_UPPER_TIER_2;
+            default:
+                throw new IllegalStateException("Unmapped seniority level. Do not have mapping for " + this);
+        }
     }
-  }
 
-  /**
-   * Converts seniority level to Markit equivalent.
-   * 
-   * @param seniorityLevel  the level to convert
-   * @return the converted level
-   */
-  public static MarkitSeniorityLevel from(SeniorityLevel seniorityLevel) {
-    switch (seniorityLevel) {
-      case SENIOR_SECURED_DOMESTIC:
-        return SECDOM;
-      case SENIOR_UNSECURED_FOREIGN:
-        return SNRFOR;
-      case SUBORDINATE_LOWER_TIER_2:
-        return SUBLT2;
-      case SUBORDINATE_TIER_1:
-        return PREFT1;
-      case SUBORDINATE_UPPER_TIER_2:
-        return JRSUBUT2;
-      default:
-        throw new IllegalArgumentException("Unknown seniority level. Do not have mapping for " + seniorityLevel);
+    /**
+     * Converts seniority level to Markit equivalent.
+     *
+     * @param seniorityLevel  the level to convert
+     * @return the converted level
+     */
+    public static MarkitSeniorityLevel from(SeniorityLevel seniorityLevel) {
+        switch (seniorityLevel) {
+            case SENIOR_SECURED_DOMESTIC:
+                return SECDOM;
+            case SENIOR_UNSECURED_FOREIGN:
+                return SNRFOR;
+            case SUBORDINATE_LOWER_TIER_2:
+                return SUBLT2;
+            case SUBORDINATE_TIER_1:
+                return PREFT1;
+            case SUBORDINATE_UPPER_TIER_2:
+                return JRSUBUT2;
+            default:
+                throw new IllegalArgumentException("Unknown seniority level. Do not have mapping for " + seniorityLevel);
+        }
     }
-  }
 
 }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitSingleNameCreditCurveDataParser.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitSingleNameCreditCurveDataParser.java
index 3ad85682a9..1da9114513 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitSingleNameCreditCurveDataParser.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitSingleNameCreditCurveDataParser.java
@@ -1,6 +1,6 @@
 /**
  * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
- *
+ * <p>
  * Please see distribution for license.
  */
 package com.opengamma.strata.examples.marketdata.credit.markit;
@@ -56,141 +56,141 @@ import java.util.Scanner;
  */
 public class MarkitSingleNameCreditCurveDataParser {
 
-  // Markit date format with the month in full caps. e.g. 11-JUL-14
-  private static final DateTimeFormatter DATE_FORMAT = new DateTimeFormatterBuilder()
-      .parseCaseInsensitive().appendPattern("dd-MMM-uu").toFormatter(Locale.ENGLISH);
+    // Markit date format with the month in full caps. e.g. 11-JUL-14
+    private static final DateTimeFormatter DATE_FORMAT = new DateTimeFormatterBuilder()
+            .parseCaseInsensitive().appendPattern("dd-MMM-uu").toFormatter(Locale.ENGLISH);
 
-  // Index used to access the specified columns of string data in the file
-  private static final int DATE = 0;
-  private static final int RED_CODE = 3;
-  private static final int TIER = 4;
-  private static final int CURRENCY = 5;
-  private static final int DOCS_CLAUSE = 6;
-  private static final int FIRST_SPREAD_COLUMN = 8;
-  private static final int RECOVERY = 19;
+    // Index used to access the specified columns of string data in the file
+    private static final int DATE = 0;
+    private static final int RED_CODE = 3;
+    private static final int TIER = 4;
+    private static final int CURRENCY = 5;
+    private static final int DOCS_CLAUSE = 6;
+    private static final int FIRST_SPREAD_COLUMN = 8;
+    private static final int RECOVERY = 19;
 
-  private static final List<Tenor> TENORS = ImmutableList.of(
-      Tenor.TENOR_6M,
-      Tenor.TENOR_1Y,
-      Tenor.TENOR_2Y,
-      Tenor.TENOR_3Y,
-      Tenor.TENOR_4Y,
-      Tenor.TENOR_5Y,
-      Tenor.TENOR_7Y,
-      Tenor.TENOR_10Y,
-      Tenor.TENOR_15Y,
-      Tenor.TENOR_20Y,
-      Tenor.TENOR_30Y);
+    private static final List<Tenor> TENORS = ImmutableList.of(
+            Tenor.TENOR_6M,
+            Tenor.TENOR_1Y,
+            Tenor.TENOR_2Y,
+            Tenor.TENOR_3Y,
+            Tenor.TENOR_4Y,
+            Tenor.TENOR_5Y,
+            Tenor.TENOR_7Y,
+            Tenor.TENOR_10Y,
+            Tenor.TENOR_15Y,
+            Tenor.TENOR_20Y,
+            Tenor.TENOR_30Y);
 
-  /**
-   * Parses the specified sources.
-   * 
-   * @param builder  the market data builder that the resulting curve and recovery rate items should be loaded into
-   * @param curveSource  the source of curve data to parse
-   * @param staticDataSource  the source of static data to parse
-   */
-  public static void parse(
-      ImmutableMarketDataBuilder builder,
-      CharSource curveSource,
-      CharSource staticDataSource) {
+    /**
+     * Parses the specified sources.
+     *
+     * @param builder  the market data builder that the resulting curve and recovery rate items should be loaded into
+     * @param curveSource  the source of curve data to parse
+     * @param staticDataSource  the source of static data to parse
+     */
+    public static void parse(
+            ImmutableMarketDataBuilder builder,
+            CharSource curveSource,
+            CharSource staticDataSource) {
 
-    Map<MarkitRedCode, CdsConvention> conventions = parseStaticData(staticDataSource);
-    try (Scanner scanner = new Scanner(curveSource.openStream())) {
-      while (scanner.hasNextLine()) {
+        Map<MarkitRedCode, CdsConvention> conventions = parseStaticData(staticDataSource);
+        try (Scanner scanner = new Scanner(curveSource.openStream())) {
+            while (scanner.hasNextLine()) {
 
-        String line = scanner.nextLine();
-        // skip over header rows
-        if (line.startsWith("V5 CDS Composites by Convention") ||
-            line.trim().isEmpty() ||
-            line.startsWith("\"Date\",")) {
-          continue;
+                String line = scanner.nextLine();
+                // skip over header rows
+                if (line.startsWith("V5 CDS Composites by Convention") ||
+                        line.trim().isEmpty() ||
+                        line.startsWith("\"Date\",")) {
+                    continue;
+                }
+                String[] columns = line.split(",");
+                for (int i = 0; i < columns.length; i++) {
+                    // get rid of quotes and trim the string
+                    columns[i] = columns[i].replaceFirst("^\"", "").replaceFirst("\"$", "").trim();
+                }
+
+                LocalDate valuationDate = LocalDate.parse(columns[DATE], DATE_FORMAT);
+
+                MarkitRedCode redCode = MarkitRedCode.of(columns[RED_CODE]);
+                SeniorityLevel seniorityLevel = MarkitSeniorityLevel.valueOf(columns[TIER]).translate();
+                Currency currency = Currency.parse(columns[CURRENCY]);
+                RestructuringClause restructuringClause = MarkitRestructuringClause.valueOf(columns[DOCS_CLAUSE]).translate();
+
+                double recoveryRate = parseRate(columns[RECOVERY]);
+
+                SingleNameReferenceInformation referenceInformation = SingleNameReferenceInformation.of(
+                        redCode.toStandardId(),
+                        seniorityLevel,
+                        currency,
+                        restructuringClause);
+
+                IsdaSingleNameCreditCurveInputsId curveId = IsdaSingleNameCreditCurveInputsId.of(referenceInformation);
+
+                List<Period> periodsList = Lists.newArrayList();
+                List<Double> ratesList = Lists.newArrayList();
+                for (int i = 0; i < TENORS.size(); i++) {
+                    String rateString = columns[FIRST_SPREAD_COLUMN + i];
+                    if (rateString.isEmpty()) {
+                        // no data at this point
+                        continue;
+                    }
+                    periodsList.add(TENORS.get(i).getPeriod());
+                    ratesList.add(parseRate(rateString));
+                }
+
+                String creditCurveName = curveId.toString();
+
+                CdsConvention cdsConvention = conventions.get(redCode);
+
+                Period[] periods = periodsList.stream().toArray(Period[]::new);
+                LocalDate[] endDates = Lists
+                        .newArrayList(periods)
+                        .stream()
+                        .map(p -> cdsConvention.calculateUnadjustedMaturityDateFromValuationDate(valuationDate, p))
+                        .toArray(LocalDate[]::new);
+
+                double[] rates = ratesList.stream().mapToDouble(s -> s).toArray();
+                double unitScalingFactor = 1d; // for single name, we don't do any scaling (no index factor)
+
+                IsdaCreditCurveInputs curveInputs = IsdaCreditCurveInputs.of(
+                        CurveName.of(creditCurveName),
+                        periods,
+                        endDates,
+                        rates,
+                        cdsConvention,
+                        unitScalingFactor);
+
+                builder.addValue(curveId, curveInputs);
+
+                IsdaSingleNameRecoveryRateId recoveryRateId = IsdaSingleNameRecoveryRateId.of(referenceInformation);
+                CdsRecoveryRate cdsRecoveryRate = CdsRecoveryRate.of(recoveryRate);
+
+                builder.addValue(recoveryRateId, cdsRecoveryRate);
+
+            }
+        } catch (IOException ex) {
+            throw new UncheckedIOException(ex);
         }
-        String[] columns = line.split(",");
-        for (int i = 0; i < columns.length; i++) {
-          // get rid of quotes and trim the string
-          columns[i] = columns[i].replaceFirst("^\"", "").replaceFirst("\"$", "").trim();
-        }
-
-        LocalDate valuationDate = LocalDate.parse(columns[DATE], DATE_FORMAT);
-
-        MarkitRedCode redCode = MarkitRedCode.of(columns[RED_CODE]);
-        SeniorityLevel seniorityLevel = MarkitSeniorityLevel.valueOf(columns[TIER]).translate();
-        Currency currency = Currency.parse(columns[CURRENCY]);
-        RestructuringClause restructuringClause = MarkitRestructuringClause.valueOf(columns[DOCS_CLAUSE]).translate();
-
-        double recoveryRate = parseRate(columns[RECOVERY]);
-
-        SingleNameReferenceInformation referenceInformation = SingleNameReferenceInformation.of(
-            redCode.toStandardId(),
-            seniorityLevel,
-            currency,
-            restructuringClause);
-
-        IsdaSingleNameCreditCurveInputsId curveId = IsdaSingleNameCreditCurveInputsId.of(referenceInformation);
-
-        List<Period> periodsList = Lists.newArrayList();
-        List<Double> ratesList = Lists.newArrayList();
-        for (int i = 0; i < TENORS.size(); i++) {
-          String rateString = columns[FIRST_SPREAD_COLUMN + i];
-          if (rateString.isEmpty()) {
-            // no data at this point
-            continue;
-          }
-          periodsList.add(TENORS.get(i).getPeriod());
-          ratesList.add(parseRate(rateString));
-        }
-
-        String creditCurveName = curveId.toString();
-
-        CdsConvention cdsConvention = conventions.get(redCode);
-
-        Period[] periods = periodsList.stream().toArray(Period[]::new);
-        LocalDate[] endDates = Lists
-            .newArrayList(periods)
-            .stream()
-            .map(p -> cdsConvention.calculateUnadjustedMaturityDateFromValuationDate(valuationDate, p))
-            .toArray(LocalDate[]::new);
-
-        double[] rates = ratesList.stream().mapToDouble(s -> s).toArray();
-        double unitScalingFactor = 1d; // for single name, we don't do any scaling (no index factor)
-
-        IsdaCreditCurveInputs curveInputs = IsdaCreditCurveInputs.of(
-            CurveName.of(creditCurveName),
-            periods,
-            endDates,
-            rates,
-            cdsConvention,
-            unitScalingFactor);
-
-        builder.addValue(curveId, curveInputs);
-
-        IsdaSingleNameRecoveryRateId recoveryRateId = IsdaSingleNameRecoveryRateId.of(referenceInformation);
-        CdsRecoveryRate cdsRecoveryRate = CdsRecoveryRate.of(recoveryRate);
-
-        builder.addValue(recoveryRateId, cdsRecoveryRate);
-
-      }
-    } catch (IOException ex) {
-      throw new UncheckedIOException(ex);
     }
-  }
 
-  // parses the static data file of RED code to convention
-  private static Map<MarkitRedCode, CdsConvention> parseStaticData(CharSource source) {
-    CsvFile csv = CsvFile.of(source, true);
-    Map<MarkitRedCode, CdsConvention> result = Maps.newHashMap();
-    for (CsvRow row : csv.rows()) {
-      String redCodeText = row.getField("RedCode");
-      String conventionText = row.getField("Convention");
-      result.put(MarkitRedCode.of(redCodeText), CdsConvention.of(conventionText));
+    // parses the static data file of RED code to convention
+    private static Map<MarkitRedCode, CdsConvention> parseStaticData(CharSource source) {
+        CsvFile csv = CsvFile.of(source, true);
+        Map<MarkitRedCode, CdsConvention> result = Maps.newHashMap();
+        for (CsvRow row : csv.rows()) {
+            String redCodeText = row.getField("RedCode");
+            String conventionText = row.getField("Convention");
+            result.put(MarkitRedCode.of(redCodeText), CdsConvention.of(conventionText));
+        }
+        return result;
     }
-    return result;
-  }
 
-  // Converts from a string percentage rate with a percent sign to a double rate
-  // e.g. 0.12% => 0.0012d
-  private static double parseRate(String input) {
-    return Double.parseDouble(input.replace("%", "")) / 100d;
-  }
+    // Converts from a string percentage rate with a percent sign to a double rate
+    // e.g. 0.12% => 0.0012d
+    private static double parseRate(String input) {
+        return Double.parseDouble(input.replace("%", "")) / 100d;
+    }
 
 }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitYieldCurveDataParser.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitYieldCurveDataParser.java
index a928a36a07..c47caacf54 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitYieldCurveDataParser.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/MarkitYieldCurveDataParser.java
@@ -1,6 +1,6 @@
 /**
  * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies
- *
+ * <p>
  * Please see distribution for license.
  */
 package com.opengamma.strata.examples.marketdata.credit.markit;
@@ -31,104 +31,105 @@ import java.util.Map;
  */
 public class MarkitYieldCurveDataParser {
 
-  private static final String DATE = "Valuation Date";
-  private static final String TENOR = "Tenor";
-  private static final String INSTRUMENT = "Instrument Type";
-  private static final String RATE = "Rate";
-  private static final String CONVENTION = "Curve Convention";
+    private static final String DATE = "Valuation Date";
+    private static final String TENOR = "Tenor";
+    private static final String INSTRUMENT = "Instrument Type";
+    private static final String RATE = "Rate";
+    private static final String CONVENTION = "Curve Convention";
 
-  /**
-   * Parses the specified source.
-   * 
-   * @param source the source to parse
-   * @return the map of parsed yield curve par rates
-   */
-  public static Map<IsdaYieldCurveInputsId, IsdaYieldCurveInputs> parse(CharSource source) {
-    // parse the curve data
-    Map<IsdaYieldCurveConvention, List<Point>> curveData = Maps.newHashMap();
-    CsvFile csv = CsvFile.of(source, true);
-    for (CsvRow row : csv.rows()) {
-      String dateText = row.getField(DATE);
-      String tenorText = row.getField(TENOR);
-      String instrumentText = row.getField(INSTRUMENT);
-      String rateText = row.getField(RATE);
-      String conventionText = row.getField(CONVENTION);
+    /**
+     * Parses the specified source.
+     *
+     * @param source the source to parse
+     * @return the map of parsed yield curve par rates
+     */
+    public static Map<IsdaYieldCurveInputsId, IsdaYieldCurveInputs> parse(CharSource source) {
+        // parse the curve data
+        Map<IsdaYieldCurveConvention, List<Point>> curveData = Maps.newHashMap();
+        CsvFile csv = CsvFile.of(source, true);
+        for (CsvRow row : csv.rows()) {
+            String dateText = row.getField(DATE);
+            String tenorText = row.getField(TENOR);
+            String instrumentText = row.getField(INSTRUMENT);
+            String rateText = row.getField(RATE);
+            String conventionText = row.getField(CONVENTION);
 
-      Point point = new Point(
-          Tenor.parse(tenorText),
-          LocalDate.parse(dateText, DateTimeFormatter.ISO_LOCAL_DATE),
-          mapUnderlyingType(instrumentText),
-          Double.parseDouble(rateText));
-      IsdaYieldCurveConvention convention = IsdaYieldCurveConvention.of(conventionText);
+            Point point = new Point(
+                    Tenor.parse(tenorText),
+                    LocalDate.parse(dateText, DateTimeFormatter.ISO_LOCAL_DATE),
+                    mapUnderlyingType(instrumentText),
+                    Double.parseDouble(rateText));
+            IsdaYieldCurveConvention convention = IsdaYieldCurveConvention.of(conventionText);
 
-      List<Point> points = curveData.get(convention);
-      if (points == null) {
-        points = Lists.newArrayList();
-        curveData.put(convention, points);
-      }
-      points.add(point);
+            List<Point> points = curveData.get(convention);
+            if (points == null) {
+                points = Lists.newArrayList();
+                curveData.put(convention, points);
+            }
+            points.add(point);
+        }
+
+        // convert the curve data into the result map
+        Map<IsdaYieldCurveInputsId, IsdaYieldCurveInputs> result = Maps.newHashMap();
+        for (IsdaYieldCurveConvention convention : curveData.keySet()) {
+            List<Point> points = curveData.get(convention);
+            result.put(IsdaYieldCurveInputsId.of(convention.getCurrency()),
+                    IsdaYieldCurveInputs.of(
+                            CurveName.of(convention.getName()),
+                            points.stream().map(s -> s.getTenor().getPeriod()).toArray(Period[]::new),
+                            points.stream().map(s -> s.getDate()).toArray(LocalDate[]::new),
+                            points.stream().map(s -> s.getInstrumentType()).toArray(IsdaYieldCurveUnderlyingType[]::new),
+                            points.stream().mapToDouble(s -> s.getRate()).toArray(),
+                            convention));
+        }
+        return result;
     }
 
-    // convert the curve data into the result map
-    Map<IsdaYieldCurveInputsId, IsdaYieldCurveInputs> result = Maps.newHashMap();
-    for (IsdaYieldCurveConvention convention : curveData.keySet()) {
-      List<Point> points = curveData.get(convention);
-      result.put(IsdaYieldCurveInputsId.of(convention.getCurrency()),
-          IsdaYieldCurveInputs.of(
-              CurveName.of(convention.getName()),
-              points.stream().map(s -> s.getTenor().getPeriod()).toArray(Period[]::new),
-              points.stream().map(s -> s.getDate()).toArray(LocalDate[]::new),
-              points.stream().map(s -> s.getInstrumentType()).toArray(IsdaYieldCurveUnderlyingType[]::new),
-              points.stream().mapToDouble(s -> s.getRate()).toArray(),
-              convention));
-    }
-    return result;
-  }
-
-  // parse the M/S instrument type flag
-  private static IsdaYieldCurveUnderlyingType mapUnderlyingType(String type) {
-    switch (type) {
-      case "M":
-        return IsdaYieldCurveUnderlyingType.ISDA_MONEY_MARKET;
-      case "S":
-        return IsdaYieldCurveUnderlyingType.ISDA_SWAP;
-      default:
-        throw new IllegalStateException("Unknown underlying type, only M or S allowed: " + type);
-    }
-  }
-
-  //-------------------------------------------------------------------------
-  /**
-   * Stores the parsed data points.
-   */
-  private static class Point {
-    private final Tenor tenor;
-    private final LocalDate date;
-    private final IsdaYieldCurveUnderlyingType instrumentType;
-    private final double rate;
-
-    private Point(Tenor tenor, LocalDate baseDate, IsdaYieldCurveUnderlyingType instrumentType, double rate) {
-      this.tenor = tenor;
-      this.date = baseDate.plus(tenor.getPeriod());
-      this.instrumentType = instrumentType;
-      this.rate = rate;
+    // parse the M/S instrument type flag
+    private static IsdaYieldCurveUnderlyingType mapUnderlyingType(String type) {
+        switch (type) {
+            case "M":
+                return IsdaYieldCurveUnderlyingType.ISDA_MONEY_MARKET;
+            case "S":
+                return IsdaYieldCurveUnderlyingType.ISDA_SWAP;
+            default:
+                throw new IllegalStateException("Unknown underlying type, only M or S allowed: " + type);
+        }
     }
 
-    public Tenor getTenor() {
-      return tenor;
-    }
+    //-------------------------------------------------------------------------
 
-    public LocalDate getDate() {
-      return date;
-    }
+    /**
+     * Stores the parsed data points.
+     */
+    private static class Point {
+        private final Tenor tenor;
+        private final LocalDate date;
+        private final IsdaYieldCurveUnderlyingType instrumentType;
+        private final double rate;
 
-    public IsdaYieldCurveUnderlyingType getInstrumentType() {
-      return instrumentType;
-    }
+        private Point(Tenor tenor, LocalDate baseDate, IsdaYieldCurveUnderlyingType instrumentType, double rate) {
+            this.tenor = tenor;
+            this.date = baseDate.plus(tenor.getPeriod());
+            this.instrumentType = instrumentType;
+            this.rate = rate;
+        }
 
-    public double getRate() {
-      return rate;
+        public Tenor getTenor() {
+            return tenor;
+        }
+
+        public LocalDate getDate() {
+            return date;
+        }
+
+        public IsdaYieldCurveUnderlyingType getInstrumentType() {
+            return instrumentType;
+        }
+
+        public double getRate() {
+            return rate;
+        }
     }
-  }
 
 }
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/package-info.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/package-info.java
index e05d86d71e..9e92d72356 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/package-info.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/credit/markit/package-info.java
@@ -1,7 +1,9 @@
 /**
  * Copyright (C) 2016 - present by OpenGamma Inc. and the OpenGamma group of companies
- *
+ * <p>
  * Please see distribution for license.
+ * <p>
+ * Credit market data for examples.
  */
 
 /**
diff --git a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/package-info.java b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/package-info.java
index a0688333c4..c286a8db4b 100644
--- a/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/package-info.java
+++ b/samples/simm-valuation-demo/src/main/java/com/opengamma/strata/examples/marketdata/package-info.java
@@ -1,7 +1,9 @@
 /**
  * Copyright (C) 2016 - present by OpenGamma Inc. and the OpenGamma group of companies
- *
+ * <p>
  * Please see distribution for license.
+ * <p>
+ * Market data for examples.
  */
 
 /**
diff --git a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/api/PortfolioApi.kt b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/api/PortfolioApi.kt
index a10b756319..3fb9118fd5 100644
--- a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/api/PortfolioApi.kt
+++ b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/api/PortfolioApi.kt
@@ -254,13 +254,14 @@ class PortfolioApi(val rpc: CordaRPCOps) {
         val parties = rpc.networkMapSnapshot()
         val notaries = rpc.notaryIdentities()
         // TODO We are not able to filter by network map node now
-        val counterParties = parties.filterNot { it.legalIdentities.any { it in notaries }
-                || ownParty in it.legalIdentities
+        val counterParties = parties.filterNot {
+            it.legalIdentities.any { it in notaries }
+                    || ownParty in it.legalIdentities
         }
         return AvailableParties(
                 self = ApiParty(ownParty.owningKey.toBase58String(), ownParty.name),
                 // TODO It will show all identities including service identities.
-                counterparties = counterParties.flatMap { it.legalIdentitiesAndCerts.map { ApiParty(it.owningKey.toBase58String(), it.name) }}
+                counterparties = counterParties.flatMap { it.legalIdentitiesAndCerts.map { ApiParty(it.owningKey.toBase58String(), it.name) } }
         )
     }
 
diff --git a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmFlow.kt b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmFlow.kt
index eb1198a881..cfccafbc4d 100644
--- a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmFlow.kt
+++ b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/SimmFlow.kt
@@ -70,6 +70,7 @@ object SimmFlow {
                     private val existing: StateAndRef<PortfolioState>?)
         : FlowLogic<RevisionedState<PortfolioState.Update>>() {
         constructor(otherParty: Party, valuationDate: LocalDate) : this(otherParty, valuationDate, null)
+
         lateinit var notary: Party
         lateinit var otherPartySession: FlowSession
 
@@ -318,7 +319,7 @@ object SimmFlow {
             logger.info("Handshake finished, awaiting Simm update")
             replyToSession.send(Ack) // Hack to state that this party is ready.
             subFlow(object : StateRevisionFlow.Receiver<PortfolioState.Update>(replyToSession) {
-                override fun verifyProposal(stx:SignedTransaction, proposal: Proposal<PortfolioState.Update>) {
+                override fun verifyProposal(stx: SignedTransaction, proposal: Proposal<PortfolioState.Update>) {
                     super.verifyProposal(stx, proposal)
                     if (proposal.modification.portfolio != portfolio.refs) throw StateReplacementException()
                 }
diff --git a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/StateRevisionFlow.kt b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/StateRevisionFlow.kt
index 49918f85c3..7616b9e932 100644
--- a/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/StateRevisionFlow.kt
+++ b/samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/flows/StateRevisionFlow.kt
@@ -15,7 +15,7 @@ import net.corda.vega.contracts.RevisionedState
  */
 object StateRevisionFlow {
     open class Requester<T>(curStateRef: StateAndRef<RevisionedState<T>>,
-                       updatedData: T) : AbstractStateReplacementFlow.Instigator<RevisionedState<T>, RevisionedState<T>, T>(curStateRef, updatedData) {
+                            updatedData: T) : AbstractStateReplacementFlow.Instigator<RevisionedState<T>, RevisionedState<T>, T>(curStateRef, updatedData) {
         override fun assembleTx(): AbstractStateReplacementFlow.UpgradeTx {
             val state = originalState.state.data
             val tx = state.generateRevision(originalState.state.notary, originalState, modification)
diff --git a/samples/simm-valuation-demo/src/test/java/net/corda/vega/SwapExampleX.java b/samples/simm-valuation-demo/src/test/java/net/corda/vega/SwapExampleX.java
index 56a2dd2e6e..dfd18bbbd8 100644
--- a/samples/simm-valuation-demo/src/test/java/net/corda/vega/SwapExampleX.java
+++ b/samples/simm-valuation-demo/src/test/java/net/corda/vega/SwapExampleX.java
@@ -48,97 +48,97 @@ import static java.util.stream.Collectors.toList;
  */
 public class SwapExampleX {
 
-  public static final LocalDate VALUATION_DATE = LocalDate.of(2016, 6, 6);
+    public static final LocalDate VALUATION_DATE = LocalDate.of(2016, 6, 6);
 
-  public static void main(String[] args) {
-    CurveGroupDefinition curveGroupDefinition = loadCurveGroup();
-    MarketData marketData = loadMarketData();
-    List<SwapTrade> trades = ImmutableList.of(createVanillaFixedVsLibor3mSwap(), createVanillaFixedVsLibor6mSwap());
-    CurveCalibrator calibrator = CurveCalibrator.of(1e-9, 1e-9, 100, CalibrationMeasures.PAR_SPREAD);
-    ImmutableRatesProvider ratesProvider = calibrator.calibrate(curveGroupDefinition, marketData, ReferenceData.standard());
-    MarketDataFxRateProvider fxRateProvider = MarketDataFxRateProvider.of(marketData);
-    ImmutableRatesProvider combinedRatesProvider = ImmutableRatesProvider.combined(fxRateProvider, ratesProvider);
+    public static void main(String[] args) {
+        CurveGroupDefinition curveGroupDefinition = loadCurveGroup();
+        MarketData marketData = loadMarketData();
+        List<SwapTrade> trades = ImmutableList.of(createVanillaFixedVsLibor3mSwap(), createVanillaFixedVsLibor6mSwap());
+        CurveCalibrator calibrator = CurveCalibrator.of(1e-9, 1e-9, 100, CalibrationMeasures.PAR_SPREAD);
+        ImmutableRatesProvider ratesProvider = calibrator.calibrate(curveGroupDefinition, marketData, ReferenceData.standard());
+        MarketDataFxRateProvider fxRateProvider = MarketDataFxRateProvider.of(marketData);
+        ImmutableRatesProvider combinedRatesProvider = ImmutableRatesProvider.combined(fxRateProvider, ratesProvider);
 
-    List<ResolvedSwapTrade> resolvedTrades = trades.stream().map(trade -> trade.resolve(ReferenceData.standard())).collect(toList());
-    DiscountingSwapProductPricer pricer = DiscountingSwapProductPricer.DEFAULT;
+        List<ResolvedSwapTrade> resolvedTrades = trades.stream().map(trade -> trade.resolve(ReferenceData.standard())).collect(toList());
+        DiscountingSwapProductPricer pricer = DiscountingSwapProductPricer.DEFAULT;
 
-    CurrencyParameterSensitivities totalSensitivities = CurrencyParameterSensitivities.empty();
-    MultiCurrencyAmount totalCurrencyExposure = MultiCurrencyAmount.empty();
+        CurrencyParameterSensitivities totalSensitivities = CurrencyParameterSensitivities.empty();
+        MultiCurrencyAmount totalCurrencyExposure = MultiCurrencyAmount.empty();
 
-    for (ResolvedSwapTrade resolvedTrade : resolvedTrades) {
-      ResolvedSwap swap = resolvedTrade.getProduct();
+        for (ResolvedSwapTrade resolvedTrade : resolvedTrades) {
+            ResolvedSwap swap = resolvedTrade.getProduct();
 
-      PointSensitivities pointSensitivities = pricer.presentValueSensitivity(swap, combinedRatesProvider).build();
-      CurrencyParameterSensitivities sensitivities = combinedRatesProvider.parameterSensitivity(pointSensitivities);
-      MultiCurrencyAmount currencyExposure = pricer.currencyExposure(swap, combinedRatesProvider);
+            PointSensitivities pointSensitivities = pricer.presentValueSensitivity(swap, combinedRatesProvider).build();
+            CurrencyParameterSensitivities sensitivities = combinedRatesProvider.parameterSensitivity(pointSensitivities);
+            MultiCurrencyAmount currencyExposure = pricer.currencyExposure(swap, combinedRatesProvider);
 
-      totalSensitivities = totalSensitivities.combinedWith(sensitivities);
-      totalCurrencyExposure = totalCurrencyExposure.plus(currencyExposure);
+            totalSensitivities = totalSensitivities.combinedWith(sensitivities);
+            totalCurrencyExposure = totalCurrencyExposure.plus(currencyExposure);
+        }
+        //PortfolioNormalizer normalizer = new PortfolioNormalizer(Currency.EUR, combinedRatesProvider);
+        //RwamBimmNotProductClassesCalculator calculatorTotal = new RwamBimmNotProductClassesCalculator(
+        //    fxRateProvider,
+        //    Currency.EUR,
+        //    IsdaConfiguration.INSTANCE);
+//
+        //Triple<Double, Double, Double> margin = BimmAnalysisUtils.computeMargin(
+        //    combinedRatesProvider,
+        //    normalizer,
+        //    calculatorTotal,
+        //    totalSensitivities,
+        //    totalCurrencyExposure);
+//
+        //System.out.println(margin);
     }
-    //PortfolioNormalizer normalizer = new PortfolioNormalizer(Currency.EUR, combinedRatesProvider);
-    //RwamBimmNotProductClassesCalculator calculatorTotal = new RwamBimmNotProductClassesCalculator(
-    //    fxRateProvider,
-    //    Currency.EUR,
-    //    IsdaConfiguration.INSTANCE);
-//
-    //Triple<Double, Double, Double> margin = BimmAnalysisUtils.computeMargin(
-    //    combinedRatesProvider,
-    //    normalizer,
-    //    calculatorTotal,
-    //    totalSensitivities,
-    //    totalCurrencyExposure);
-//
-    //System.out.println(margin);
-  }
 
-  //--------------------------------------------------------------------------------------------------
+    //--------------------------------------------------------------------------------------------------
 
-  /**
-   * Load the market quotes and FX rates from data files.
-   */
-  private static MarketData loadMarketData() {
-    Path dataDir = Paths.get("src/test/resources/data");
-    Path quotesFile = dataDir.resolve("BIMM-MARKET-QUOTES-20160606.csv");
-    Path fxFile = dataDir.resolve("BIMM-FX-RATES-20160606.csv");
+    /**
+     * Load the market quotes and FX rates from data files.
+     */
+    private static MarketData loadMarketData() {
+        Path dataDir = Paths.get("src/test/resources/data");
+        Path quotesFile = dataDir.resolve("BIMM-MARKET-QUOTES-20160606.csv");
+        Path fxFile = dataDir.resolve("BIMM-FX-RATES-20160606.csv");
 
-    Map<QuoteId, Double> quotes = QuotesCsvLoader.load(VALUATION_DATE, ImmutableList.of(ResourceLocator.ofPath(quotesFile)));
-    Map<FxRateId, FxRate> fxRates = FxRatesCsvLoader.load(VALUATION_DATE, ResourceLocator.ofPath(fxFile));
-    return ImmutableMarketData.builder(VALUATION_DATE).addValueMap(quotes).addValueMap(fxRates).build();
-  }
+        Map<QuoteId, Double> quotes = QuotesCsvLoader.load(VALUATION_DATE, ImmutableList.of(ResourceLocator.ofPath(quotesFile)));
+        Map<FxRateId, FxRate> fxRates = FxRatesCsvLoader.load(VALUATION_DATE, ResourceLocator.ofPath(fxFile));
+        return ImmutableMarketData.builder(VALUATION_DATE).addValueMap(quotes).addValueMap(fxRates).build();
+    }
 
-  /**
-   * Loads the curve group definition from data files.
-   *
-   * A curve group maps from curve name to index for forward curves and curve name to currency for discount curves.
-   */
-  private static CurveGroupDefinition loadCurveGroup() {
-    Path settingsDir = Paths.get("src/test/resources/settings");
-    Map<CurveGroupName, CurveGroupDefinition> curveGroups = RatesCalibrationCsvLoader.load(
-        ResourceLocator.ofPath(settingsDir.resolve("BIMM-groups-EUR.csv")),
-        ResourceLocator.ofPath(settingsDir.resolve("BIMM-settings-EUR.csv")),
-        ResourceLocator.ofPath(settingsDir.resolve("BIMM-nodes-EUR.csv")));
-    return curveGroups.get(CurveGroupName.of("BIMM"));
-  }
+    /**
+     * Loads the curve group definition from data files.
+     * <p>
+     * A curve group maps from curve name to index for forward curves and curve name to currency for discount curves.
+     */
+    private static CurveGroupDefinition loadCurveGroup() {
+        Path settingsDir = Paths.get("src/test/resources/settings");
+        Map<CurveGroupName, CurveGroupDefinition> curveGroups = RatesCalibrationCsvLoader.load(
+                ResourceLocator.ofPath(settingsDir.resolve("BIMM-groups-EUR.csv")),
+                ResourceLocator.ofPath(settingsDir.resolve("BIMM-settings-EUR.csv")),
+                ResourceLocator.ofPath(settingsDir.resolve("BIMM-nodes-EUR.csv")));
+        return curveGroups.get(CurveGroupName.of("BIMM"));
+    }
 
-  //--------------------------------------------------------------------------------------------------
+    //--------------------------------------------------------------------------------------------------
 
-  private static SwapTrade createVanillaFixedVsLibor3mSwap() {
-    return FixedIborSwapConventions.EUR_FIXED_1Y_EURIBOR_3M.createTrade(
-            VALUATION_DATE,
-        Tenor.TENOR_4Y,
-        BuySell.BUY,
-        200_000_000,
-        0.015,
-        ReferenceData.standard());
-  }
+    private static SwapTrade createVanillaFixedVsLibor3mSwap() {
+        return FixedIborSwapConventions.EUR_FIXED_1Y_EURIBOR_3M.createTrade(
+                VALUATION_DATE,
+                Tenor.TENOR_4Y,
+                BuySell.BUY,
+                200_000_000,
+                0.015,
+                ReferenceData.standard());
+    }
 
-  private static SwapTrade createVanillaFixedVsLibor6mSwap() {
-    return FixedIborSwapConventions.EUR_FIXED_1Y_EURIBOR_6M.createTrade(
-            VALUATION_DATE,
-        Tenor.TENOR_10Y,
-        BuySell.SELL,
-        100_000_000,
-        0.013,
-        ReferenceData.standard());
-  }
+    private static SwapTrade createVanillaFixedVsLibor6mSwap() {
+        return FixedIborSwapConventions.EUR_FIXED_1Y_EURIBOR_6M.createTrade(
+                VALUATION_DATE,
+                Tenor.TENOR_10Y,
+                BuySell.SELL,
+                100_000_000,
+                0.013,
+                ReferenceData.standard());
+    }
 }
diff --git a/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/TraderDemoClientApi.kt b/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/TraderDemoClientApi.kt
index e373de677d..101171880c 100644
--- a/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/TraderDemoClientApi.kt
+++ b/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/TraderDemoClientApi.kt
@@ -27,19 +27,21 @@ import java.util.*
  * Interface for communicating with nodes running the trader demo.
  */
 class TraderDemoClientApi(val rpc: CordaRPCOps) {
-    val cashCount: Long get() {
-        val count = builder { VaultSchemaV1.VaultStates::recordedTime.count() }
-        val countCriteria = QueryCriteria.VaultCustomQueryCriteria(count)
-        return rpc.vaultQueryBy<Cash.State>(countCriteria).otherResults.single() as Long
-    }
+    val cashCount: Long
+        get() {
+            val count = builder { VaultSchemaV1.VaultStates::recordedTime.count() }
+            val countCriteria = QueryCriteria.VaultCustomQueryCriteria(count)
+            return rpc.vaultQueryBy<Cash.State>(countCriteria).otherResults.single() as Long
+        }
 
     val dollarCashBalance: Amount<Currency> get() = rpc.getCashBalance(USD)
 
-    val commercialPaperCount: Long get() {
-        val count = builder { VaultSchemaV1.VaultStates::recordedTime.count() }
-        val countCriteria = QueryCriteria.VaultCustomQueryCriteria(count)
-        return rpc.vaultQueryBy<CommercialPaper.State>(countCriteria).otherResults.single() as Long
-    }
+    val commercialPaperCount: Long
+        get() {
+            val count = builder { VaultSchemaV1.VaultStates::recordedTime.count() }
+            val countCriteria = QueryCriteria.VaultCustomQueryCriteria(count)
+            return rpc.vaultQueryBy<CommercialPaper.State>(countCriteria).otherResults.single() as Long
+        }
 
     fun runIssuer(amount: Amount<Currency>, buyerName: CordaX500Name, sellerName: CordaX500Name) {
         val ref = OpaqueBytes.of(1)
diff --git a/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/flow/CommercialPaperIssueFlow.kt b/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/flow/CommercialPaperIssueFlow.kt
index 297f033ca1..cd1e7fed4b 100644
--- a/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/flow/CommercialPaperIssueFlow.kt
+++ b/samples/trader-demo/src/main/kotlin/net/corda/traderdemo/flow/CommercialPaperIssueFlow.kt
@@ -31,7 +31,9 @@ class CommercialPaperIssueFlow(private val amount: Amount<Currency>,
 
     companion object {
         val PROSPECTUS_HASH = SecureHash.parse("decd098666b9657314870e192ced0c3519c2c9d395507a238338f8d003929de9")
+
         object ISSUING : ProgressTracker.Step("Issuing and timestamping some commercial paper")
+
         fun tracker() = ProgressTracker(ISSUING)
     }
 
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/DriverConstants.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/DriverConstants.kt
index 1a17d02f3a..73e36aba5e 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/DriverConstants.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/DriverConstants.kt
@@ -39,11 +39,13 @@ class PredefinedTestNode internal constructor(party: Party, driver: DriverDSLExp
  * for it: you won't have [ALICE_KEY].
  */
 fun DriverDSLExposedInterface.alice(): PredefinedTestNode = PredefinedTestNode(ALICE, this, null)
+
 /**
  * Returns a plain, entirely stock node pre-configured with the [BOB] identity. Note that a random key will be generated
  * for it: you won't have [BOB_KEY].
  */
 fun DriverDSLExposedInterface.bob(): PredefinedTestNode = PredefinedTestNode(BOB, this, null)
+
 /**
  * Returns a plain single node notary pre-configured with the [DUMMY_NOTARY] identity. Note that a random key will be generated
  * for it: you won't have [DUMMY_NOTARY_KEY].
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt
index 7f8069e919..7fe3ee5c09 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt
@@ -20,7 +20,8 @@ import java.nio.file.Path
  * Creates and tests a ledger built by the passed in dsl. The provided services can be customised, otherwise a default
  * of a freshly built [MockServices] is used.
  */
-@JvmOverloads fun ledger(
+@JvmOverloads
+fun ledger(
         services: ServiceHub = MockServices(),
         initialiseSerialization: Boolean = true,
         dsl: LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter>.() -> Unit
@@ -40,7 +41,8 @@ import java.nio.file.Path
  *
  * @see LedgerDSLInterpreter._transaction
  */
-@JvmOverloads fun transaction(
+@JvmOverloads
+fun transaction(
         transactionLabel: String? = null,
         transactionBuilder: TransactionBuilder = TransactionBuilder(notary = DUMMY_NOTARY),
         initialiseSerialization: Boolean = true,
@@ -54,6 +56,7 @@ fun testNodeConfiguration(
         myLegalName: CordaX500Name,
         notaryConfig: NotaryConfig? = null): NodeConfiguration {
     abstract class MockableNodeConfiguration : NodeConfiguration // Otherwise Mockito is defeated by val getters.
+
     val nc = spy<MockableNodeConfiguration>()
     whenever(nc.baseDirectory).thenReturn(baseDirectory)
     whenever(nc.myLegalName).thenReturn(myLegalName)
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/RPCDriver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/RPCDriver.kt
index 4aff94842f..c5156c16e2 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/RPCDriver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/RPCDriver.kt
@@ -64,7 +64,7 @@ interface RPCDriverExposedDSLInterface : DriverDSLExposedInterface {
             maxFileSize: Int = ArtemisMessagingServer.MAX_FILE_SIZE,
             maxBufferedBytesPerClient: Long = 10L * ArtemisMessagingServer.MAX_FILE_SIZE,
             configuration: RPCServerConfiguration = RPCServerConfiguration.default,
-            ops : I
+            ops: I
     ): CordaFuture<RpcServerHandle>
 
     /**
@@ -110,8 +110,8 @@ interface RPCDriverExposedDSLInterface : DriverDSLExposedInterface {
             maxBufferedBytesPerClient: Long = 10L * ArtemisMessagingServer.MAX_FILE_SIZE,
             configuration: RPCServerConfiguration = RPCServerConfiguration.default,
             customPort: NetworkHostAndPort? = null,
-            ops : I
-    ) : CordaFuture<RpcServerHandle>
+            ops: I
+    ): CordaFuture<RpcServerHandle>
 
     /**
      * Starts a Netty RPC client.
@@ -180,16 +180,19 @@ interface RPCDriverExposedDSLInterface : DriverDSLExposedInterface {
             brokerHandle: RpcBrokerHandle
     ): RpcServerHandle
 }
+
 inline fun <reified I : RPCOps> RPCDriverExposedDSLInterface.startInVmRpcClient(
         username: String = rpcTestUser.username,
         password: String = rpcTestUser.password,
         configuration: RPCClientConfiguration = RPCClientConfiguration.default
 ) = startInVmRpcClient(I::class.java, username, password, configuration)
+
 inline fun <reified I : RPCOps> RPCDriverExposedDSLInterface.startRandomRpcClient(
         hostAndPort: NetworkHostAndPort,
         username: String = rpcTestUser.username,
         password: String = rpcTestUser.password
 ) = startRandomRpcClient(I::class.java, hostAndPort, username, password)
+
 inline fun <reified I : RPCOps> RPCDriverExposedDSLInterface.startRpcClient(
         rpcAddress: NetworkHostAndPort,
         username: String = rpcTestUser.username,
@@ -200,7 +203,8 @@ inline fun <reified I : RPCOps> RPCDriverExposedDSLInterface.startRpcClient(
 interface RPCDriverInternalDSLInterface : DriverDSLInternalInterface, RPCDriverExposedDSLInterface
 
 data class RpcBrokerHandle(
-        val hostAndPort: NetworkHostAndPort?,/** null if this is an InVM broker */
+        val hostAndPort: NetworkHostAndPort?,
+        /** null if this is an InVM broker */
         val clientTransportConfiguration: TransportConfiguration,
         val serverControl: ActiveMQServerControl
 )
@@ -253,6 +257,7 @@ private class SingleUserSecurityManager(val rpcUser: User) : ActiveMQSecurityMan
     override fun validateUser(user: String?, password: String?, certificates: Array<out X509Certificate>?): String? {
         return validate(user, password)
     }
+
     override fun validateUserAndRole(user: String?, password: String?, roles: MutableSet<Role>?, checkType: CheckType?, address: String?, connection: RemotingConnection?): String? {
         return validate(user, password)
     }
@@ -260,6 +265,7 @@ private class SingleUserSecurityManager(val rpcUser: User) : ActiveMQSecurityMan
     private fun isValid(user: String?, password: String?): Boolean {
         return rpcUser.username == user && rpcUser.password == password
     }
+
     private fun validate(user: String?, password: String?): String? {
         return if (isValid(user, password)) user else null
     }
@@ -303,6 +309,7 @@ data class RPCDriverDSL(
                     }
             )
         }
+
         fun createInVmRpcServerArtemisConfig(maxFileSize: Int, maxBufferedBytesPerClient: Long): Configuration {
             return ConfigurationImpl().apply {
                 acceptorConfigurations = setOf(TransportConfiguration(InVMAcceptorFactory::class.java.name))
@@ -310,6 +317,7 @@ data class RPCDriverDSL(
                 configureCommonSettings(maxFileSize, maxBufferedBytesPerClient)
             }
         }
+
         fun createRpcServerArtemisConfig(maxFileSize: Int, maxBufferedBytesPerClient: Long, baseDirectory: Path, hostAndPort: NetworkHostAndPort): Configuration {
             val connectionDirection = ConnectionDirection.Inbound(acceptorFactoryClassName = NettyAcceptorFactory::class.java.name)
             return ConfigurationImpl().apply {
@@ -321,6 +329,7 @@ data class RPCDriverDSL(
                 configureCommonSettings(maxFileSize, maxBufferedBytesPerClient)
             }
         }
+
         val inVmClientTransportConfiguration = TransportConfiguration(InVMConnectorFactory::class.java.name)
         fun createNettyClientTransportConfiguration(hostAndPort: NetworkHostAndPort): TransportConfiguration {
             return ArtemisTcpTransport.tcpTransport(ConnectionDirection.Outbound(), hostAndPort, null)
@@ -503,6 +512,7 @@ class RandomRpcUser {
             add(Generator.string())
             add(Generator.int())
         }
+
         data class Call(val method: Method, val call: () -> Any?)
 
         @JvmStatic
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/InMemoryMessagingNetwork.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/InMemoryMessagingNetwork.kt
index bf109863eb..4be46a59f5 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/InMemoryMessagingNetwork.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/InMemoryMessagingNetwork.kt
@@ -143,7 +143,8 @@ class InMemoryMessagingNetwork(
     }
 
     /** This can be set to an object which can inject artificial latency between sender/recipient pairs. */
-    @Volatile var latencyCalculator: LatencyCalculator? = null
+    @Volatile
+    var latencyCalculator: LatencyCalculator? = null
     private val timer = Timer()
 
     @Synchronized
@@ -327,7 +328,7 @@ class InMemoryMessagingNetwork(
                 while (!Thread.currentThread().isInterrupted) {
                     try {
                         pumpReceiveInternal(true)
-                    } catch(e: InterruptedException) {
+                    } catch (e: InterruptedException) {
                         break
                     }
                 }
@@ -452,7 +453,7 @@ class InMemoryMessagingNetwork(
                         for (handler in deliverTo) {
                             try {
                                 handler.callback(transfer.toReceivedMessage(), handler)
-                            } catch(e: Exception) {
+                            } catch (e: Exception) {
                                 log.error("Caught exception in handler for $this/${handler.topicSession}", e)
                             }
                         }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNetworkMapCache.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNetworkMapCache.kt
index 1c357a90a6..1b82ca04c1 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNetworkMapCache.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNetworkMapCache.kt
@@ -53,6 +53,6 @@ class MockNetworkMapCache(serviceHub: ServiceHubInternal) : PersistentNetworkMap
      */
     @VisibleForTesting
     fun deleteRegistration(legalIdentity: Party): Boolean {
-        return partyNodes.removeIf { legalIdentity.owningKey in it.legalIdentitiesAndCerts.map { it.owningKey }}
+        return partyNodes.removeIf { legalIdentity.owningKey in it.legalIdentitiesAndCerts.map { it.owningKey } }
     }
 }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index 52989475b3..43471696df 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -247,7 +247,9 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
 
         // This does not indirect through the NodeInfo object so it can be called before the node is started.
         // It is used from the network visualiser tool.
-        @Suppress("unused") val place: WorldMapLocation get() = findMyLocation()!!
+        @Suppress("unused")
+        val place: WorldMapLocation
+            get() = findMyLocation()!!
 
         private var dbCloser: (() -> Any?)? = null
         override fun <T> initialiseDatabasePersistence(schemaService: SchemaService, insideTransaction: () -> T) = super.initialiseDatabasePersistence(schemaService) {
@@ -302,7 +304,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                 legalName = MOCK_NET_MAP.name,
                 notaryIdentity = null,
                 advertisedServices = arrayOf(),
-                entropyRoot  = BigInteger.valueOf(random63BitValue()),
+                entropyRoot = BigInteger.valueOf(random63BitValue()),
                 configOverrides = {},
                 start = true
         ).started!!.apply {
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
index 6263dfbc65..3d49484fef 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
@@ -82,7 +82,9 @@ open class MockServices(
         fun makeTestDatabaseProperties(key: String? = null, value: String? = null): Properties {
             val props = Properties()
             props.setProperty("transactionIsolationLevel", "repeatableRead") //for other possible values see net.corda.node.utilities.CordaPeristence.parserTransactionIsolationLevel(String)
-            if (key != null) { props.setProperty(key, value) }
+            if (key != null) {
+                props.setProperty(key, value)
+            }
             return props
         }
 
@@ -154,10 +156,11 @@ open class MockServices(
     override val contractUpgradeService: ContractUpgradeService get() = throw UnsupportedOperationException()
     override val networkMapCache: NetworkMapCache get() = throw UnsupportedOperationException()
     override val clock: Clock get() = Clock.systemUTC()
-    override val myInfo: NodeInfo get() {
-        val identity = getTestPartyAndCertificate(MEGA_CORP.name, key.public)
-        return NodeInfo(emptyList(), listOf(identity), 1,  serial = 1L)
-    }
+    override val myInfo: NodeInfo
+        get() {
+            val identity = getTestPartyAndCertificate(MEGA_CORP.name, key.public)
+            return NodeInfo(emptyList(), listOf(identity), 1, serial = 1L)
+        }
     override val transactionVerifierService: TransactionVerifierService get() = InMemoryTransactionVerifierService(2)
     val mockCordappProvider: MockCordappProvider = MockCordappProvider(CordappLoader.createWithTestPackages(cordappPackages + CordappLoader.testPackages)).start(attachments) as MockCordappProvider
     override val cordappProvider: CordappProvider = mockCordappProvider
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/TestClock.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/TestClock.kt
index 690f765c3d..e1149b1fda 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/TestClock.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/TestClock.kt
@@ -25,7 +25,8 @@ class TestClock(private var delegateClock: Clock = Clock.systemUTC()) : MutableC
     /**
      * Advance this [Clock] by the specified [Duration] for testing purposes.
      */
-    @Synchronized fun advanceBy(duration: Duration) {
+    @Synchronized
+    fun advanceBy(duration: Duration) {
         delegateClock = offset(delegateClock, duration)
         notifyMutationObservers()
     }
@@ -35,7 +36,8 @@ class TestClock(private var delegateClock: Clock = Clock.systemUTC()) : MutableC
      *
      * This will only be approximate due to the time ticking away, but will be some time shortly after the requested [Instant].
      */
-    @Synchronized fun setTo(newInstant: Instant) = advanceBy(instant() until newInstant)
+    @Synchronized
+    fun setTo(newInstant: Instant) = advanceBy(instant() until newInstant)
 
     @Synchronized override fun instant(): Instant {
         return delegateClock.instant()
diff --git a/testing/smoke-test-utils/src/main/kotlin/net/corda/smoketesting/NodeProcess.kt b/testing/smoke-test-utils/src/main/kotlin/net/corda/smoketesting/NodeProcess.kt
index 6ab3de90d7..ae43e144db 100644
--- a/testing/smoke-test-utils/src/main/kotlin/net/corda/smoketesting/NodeProcess.kt
+++ b/testing/smoke-test-utils/src/main/kotlin/net/corda/smoketesting/NodeProcess.kt
@@ -46,6 +46,7 @@ class NodeProcess(
     class Factory(val buildDirectory: Path = Paths.get("build"),
                   val cordaJar: Path = Paths.get(this::class.java.getResource("/corda.jar").toURI())) {
         val nodesDirectory = buildDirectory / formatter.format(Instant.now())
+
         init {
             nodesDirectory.createDirectories()
         }
@@ -95,11 +96,11 @@ class NodeProcess(
 
         private fun startNode(nodeDir: Path): Process {
             val builder = ProcessBuilder()
-                .command(javaPath.toString(), "-jar", cordaJar.toString())
-                .directory(nodeDir.toFile())
+                    .command(javaPath.toString(), "-jar", cordaJar.toString())
+                    .directory(nodeDir.toFile())
 
             builder.environment().putAll(mapOf(
-                "CAPSULE_CACHE_DIR" to (buildDirectory / "capsule").toString()
+                    "CAPSULE_CACHE_DIR" to (buildDirectory / "capsule").toString()
             ))
 
             return builder.start()
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
index 5bec1a4aeb..4e20194249 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
@@ -117,8 +117,8 @@ fun freePort(): Int = freePortCounter.getAndAccumulate(0) { prev, _ -> 30000 + (
  * to the Node, some other process else could allocate the returned ports.
  */
 fun getFreeLocalPorts(hostName: String, numberToAlloc: Int): List<NetworkHostAndPort> {
-    val freePort =  freePortCounter.getAndAccumulate(0) { prev, _ -> 30000 + (prev - 30000 + numberToAlloc) % 10000 }
-    return (freePort .. freePort + numberToAlloc - 1).map { NetworkHostAndPort(hostName, it) }
+    val freePort = freePortCounter.getAndAccumulate(0) { prev, _ -> 30000 + (prev - 30000 + numberToAlloc) % 10000 }
+    return (freePort..freePort + numberToAlloc - 1).map { NetworkHostAndPort(hostName, it) }
 }
 
 @JvmOverloads
@@ -147,17 +147,17 @@ fun getTestPartyAndCertificate(name: CordaX500Name, publicKey: PublicKey, trustR
 }
 
 @Suppress("unused")
-inline fun <reified T : Any> T.kryoSpecific(reason: String, function: () -> Unit) = if(!AMQP_ENABLED) {
+inline fun <reified T : Any> T.kryoSpecific(reason: String, function: () -> Unit) = if (!AMQP_ENABLED) {
     function()
 } else {
-    loggerFor<T>().info("Ignoring Kryo specific test, reason: $reason" )
+    loggerFor<T>().info("Ignoring Kryo specific test, reason: $reason")
 }
 
 @Suppress("unused")
-inline fun <reified T : Any> T.amqpSpecific(reason: String, function: () -> Unit) = if(AMQP_ENABLED) {
+inline fun <reified T : Any> T.amqpSpecific(reason: String, function: () -> Unit) = if (AMQP_ENABLED) {
     function()
 } else {
-    loggerFor<T>().info("Ignoring AMQP specific test, reason: $reason" )
+    loggerFor<T>().info("Ignoring AMQP specific test, reason: $reason")
 }
 
 /**
@@ -165,6 +165,7 @@ inline fun <reified T : Any> T.amqpSpecific(reason: String, function: () -> Unit
  * TODO: Should be removed after multiple identities are introduced.
  */
 fun NodeInfo.chooseIdentityAndCert(): PartyAndCertificate = legalIdentitiesAndCerts.first()
+
 fun NodeInfo.chooseIdentity(): Party = chooseIdentityAndCert().party
 /** Returns the identity of the first notary found on the network */
 fun ServiceHub.getDefaultNotary(): Party = networkMapCache.notaryIdentities.first()
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/Eventually.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/Eventually.kt
index b3a4588609..693fffeca9 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/Eventually.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/Eventually.kt
@@ -6,15 +6,16 @@ import java.time.Duration
  * Ideas borrowed from "io.kotlintest" with some improvements made
  * This is meant for use from Kotlin code use only mainly due to it's inline/reified nature
  */
-inline fun <reified E : Throwable, R>eventually(duration: Duration, f: () -> R): R {
+inline fun <reified E : Throwable, R> eventually(duration: Duration, f: () -> R): R {
     val end = System.nanoTime() + duration.toNanos()
     var times = 0
     while (System.nanoTime() < end) {
         try {
             return f()
         } catch (e: Throwable) {
-            when(e) {
-                is E -> {}// ignore and continue
+            when (e) {
+                is E -> {
+                }// ignore and continue
                 else -> throw e // unexpected exception type - rethrow
             }
         }
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt
index d79568d693..74f622bc37 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/FlowStackSnapshot.kt
@@ -78,14 +78,15 @@ class FlowStackSnapshotFactoryImpl : FlowStackSnapshotFactory {
         return FlowStackSnapshot(Instant.now(), flowClass.name, frames)
     }
 
-    private val StackTraceElement.instrumentedAnnotation: Instrumented? get() {
-        Class.forName(className).methods.forEach {
-            if (it.name == methodName && it.isAnnotationPresent(Instrumented::class.java)) {
-                return it.getAnnotation(Instrumented::class.java)
+    private val StackTraceElement.instrumentedAnnotation: Instrumented?
+        get() {
+            Class.forName(className).methods.forEach {
+                if (it.name == methodName && it.isAnnotationPresent(Instrumented::class.java)) {
+                    return it.getAnnotation(Instrumented::class.java)
+                }
             }
+            return null
         }
-        return null
-    }
 
     private fun removeConstructorStackTraceElements(stackTrace: List<StackTraceElement>): List<StackTraceElement> {
         val newStackTrace = ArrayList<StackTraceElement>()
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/Measure.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/Measure.kt
index 102cc0f413..91eaecf0a0 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/Measure.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/Measure.kt
@@ -12,10 +12,13 @@ import kotlin.reflect.jvm.reflect
 
 fun <A : Any, R> measure(a: Iterable<A>, f: (A) -> R) =
         measure(listOf(a), f.reflect()!!) { f(uncheckedCast(it[0])) }
+
 fun <A : Any, B : Any, R> measure(a: Iterable<A>, b: Iterable<B>, f: (A, B) -> R) =
         measure(listOf(a, b), f.reflect()!!) { f(uncheckedCast(it[0]), uncheckedCast(it[1])) }
+
 fun <A : Any, B : Any, C : Any, R> measure(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>, f: (A, B, C) -> R) =
         measure(listOf(a, b, c), f.reflect()!!) { f(uncheckedCast(it[0]), uncheckedCast(it[1]), uncheckedCast(it[2])) }
+
 fun <A : Any, B : Any, C : Any, D : Any, R> measure(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>, d: Iterable<D>, f: (A, B, C, D) -> R) =
         measure(listOf(a, b, c, d), f.reflect()!!) { f(uncheckedCast(it[0]), uncheckedCast(it[1]), uncheckedCast(it[2]), uncheckedCast(it[3])) }
 
@@ -30,8 +33,8 @@ private fun <R> measure(paramIterables: List<Iterable<Any?>>, kCallable: KCallab
 }
 
 data class MeasureResult<out R>(
-    val parameters: List<Pair<String, Any?>>,
-    val result: R
+        val parameters: List<Pair<String, Any?>>,
+        val result: R
 )
 
 fun <A> iterateLexical(iterables: List<Iterable<A>>): Iterable<List<A>> {
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt
index c3f5872cd7..891808e4b5 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/SerializationTestHelpers.kt
@@ -22,32 +22,32 @@ fun initialiseTestSerialization() {
     // Check that everything is configured for testing with mutable delegating instances.
     try {
         check(SerializationDefaults.SERIALIZATION_FACTORY is TestSerializationFactory)
-    } catch(e: IllegalStateException) {
+    } catch (e: IllegalStateException) {
         SerializationDefaults.SERIALIZATION_FACTORY = TestSerializationFactory()
     }
     try {
         check(SerializationDefaults.P2P_CONTEXT is TestSerializationContext)
-    } catch(e: IllegalStateException) {
+    } catch (e: IllegalStateException) {
         SerializationDefaults.P2P_CONTEXT = TestSerializationContext()
     }
     try {
         check(SerializationDefaults.RPC_SERVER_CONTEXT is TestSerializationContext)
-    } catch(e: IllegalStateException) {
+    } catch (e: IllegalStateException) {
         SerializationDefaults.RPC_SERVER_CONTEXT = TestSerializationContext()
     }
     try {
         check(SerializationDefaults.RPC_CLIENT_CONTEXT is TestSerializationContext)
-    } catch(e: IllegalStateException) {
+    } catch (e: IllegalStateException) {
         SerializationDefaults.RPC_CLIENT_CONTEXT = TestSerializationContext()
     }
     try {
         check(SerializationDefaults.STORAGE_CONTEXT is TestSerializationContext)
-    } catch(e: IllegalStateException) {
+    } catch (e: IllegalStateException) {
         SerializationDefaults.STORAGE_CONTEXT = TestSerializationContext()
     }
     try {
         check(SerializationDefaults.CHECKPOINT_CONTEXT is TestSerializationContext)
-    } catch(e: IllegalStateException) {
+    } catch (e: IllegalStateException) {
         SerializationDefaults.CHECKPOINT_CONTEXT = TestSerializationContext()
     }
 
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
index 9b4e99b752..48658ea021 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/TestDSL.kt
@@ -274,7 +274,7 @@ data class TestLedgerDSLInterpreter private constructor(
             transactionLabel: String?,
             transactionBuilder: TransactionBuilder,
             dsl: TransactionDSL<TestTransactionDSLInterpreter>.() -> Unit
-    ) = recordTransactionWithTransactionMap(transactionLabel, transactionBuilder, dsl, nonVerifiedTransactionWithLocations, fillTransaction =  true)
+    ) = recordTransactionWithTransactionMap(transactionLabel, transactionBuilder, dsl, nonVerifiedTransactionWithLocations, fillTransaction = true)
 
     override fun tweak(
             dsl: LedgerDSL<TestTransactionDSLInterpreter,
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/TransactionDSLInterpreter.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/TransactionDSLInterpreter.kt
index 4916b32b3c..af6520f4dc 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/TransactionDSLInterpreter.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/TransactionDSLInterpreter.kt
@@ -119,7 +119,7 @@ class TransactionDSL<out T : TransactionDSLInterpreter>(val interpreter: T) : Tr
      */
     @JvmOverloads
     fun output(contractClassName: ContractClassName, contractState: ContractState, attachmentConstraint: AttachmentConstraint = AutomaticHashConstraint) =
-            _output(contractClassName,null, DUMMY_NOTARY, null, attachmentConstraint, contractState)
+            _output(contractClassName, null, DUMMY_NOTARY, null, attachmentConstraint, contractState)
 
     /**
      * Adds a command to the transaction.
@@ -146,5 +146,5 @@ class TransactionDSL<out T : TransactionDSLInterpreter>(val interpreter: T) : Tr
      */
     fun attachment(contractClassName: ContractClassName) = _attachment(contractClassName)
 
-    fun attachments(vararg contractClassNames: ContractClassName) = contractClassNames.forEach { attachment(it)}
+    fun attachments(vararg contractClassNames: ContractClassName) = contractClassNames.forEach { attachment(it) }
 }
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyDealContract.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyDealContract.kt
index 2fb6817d0d..b19bfac076 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyDealContract.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/DummyDealContract.kt
@@ -19,8 +19,7 @@ class DummyDealContract : Contract {
 
     data class State(
             override val participants: List<AbstractParty>,
-            override val linearId: UniqueIdentifier) : DealState, QueryableState
-    {
+            override val linearId: UniqueIdentifier) : DealState, QueryableState {
         constructor(participants: List<AbstractParty> = listOf(),
                     ref: String) : this(participants, UniqueIdentifier(ref))
 
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/VaultFiller.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/VaultFiller.kt
index 8abe70d329..a921cd00c4 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/VaultFiller.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/VaultFiller.kt
@@ -32,7 +32,7 @@ import java.util.*
 @JvmOverloads
 fun ServiceHub.fillWithSomeTestDeals(dealIds: List<String>,
                                      participants: List<AbstractParty> = emptyList(),
-                                     notary: Party = DUMMY_NOTARY) : Vault<DealState> {
+                                     notary: Party = DUMMY_NOTARY): Vault<DealState> {
     val myKey: PublicKey = myInfo.chooseIdentity().owningKey
     val me = AnonymousParty(myKey)
 
@@ -63,7 +63,7 @@ fun ServiceHub.fillWithSomeTestLinearStates(numberToCreate: Int,
                                             linearString: String = "",
                                             linearNumber: Long = 0L,
                                             linearBoolean: Boolean = false,
-                                            linearTimestamp: Instant = now()) : Vault<LinearState> {
+                                            linearTimestamp: Instant = now()): Vault<LinearState> {
     val myKey: PublicKey = myInfo.chooseIdentity().owningKey
     val me = AnonymousParty(myKey)
     val issuerKey = DUMMY_NOTARY_KEY
@@ -196,7 +196,7 @@ fun calculateRandomlySizedAmounts(howMuch: Amount<Currency>, min: Int, max: Int,
 fun <T : LinearState> ServiceHub.consume(states: List<StateAndRef<T>>, notary: Party) {
     // Create a txn consuming different contract types
     states.forEach {
-        val builder =  TransactionBuilder(notary = notary).apply {
+        val builder = TransactionBuilder(notary = notary).apply {
             addInputState(it)
             addCommand(dummyCommand(notary.owningKey))
         }
@@ -238,7 +238,7 @@ fun <T : LinearState> ServiceHub.consumeAndProduce(states: List<StateAndRef<T>>,
 fun ServiceHub.consumeDeals(dealStates: List<StateAndRef<DealState>>, notary: Party) = consume(dealStates, notary)
 fun ServiceHub.consumeLinearStates(linearStates: List<StateAndRef<LinearState>>, notary: Party) = consume(linearStates, notary)
 fun ServiceHub.evolveLinearStates(linearStates: List<StateAndRef<LinearState>>, notary: Party) = consumeAndProduce(linearStates, notary)
-fun ServiceHub.evolveLinearState(linearState: StateAndRef<LinearState>, notary: Party) : StateAndRef<LinearState> = consumeAndProduce(linearState, notary)
+fun ServiceHub.evolveLinearState(linearState: StateAndRef<LinearState>, notary: Party): StateAndRef<LinearState> = consumeAndProduce(linearState, notary)
 
 /**
  * Consume cash, sending any change to the default identity for this node. Only suitable for use in test scenarios,
@@ -254,7 +254,7 @@ fun ServiceHub.consumeCash(amount: Amount<Currency>, to: Party = CHARLIE, notary
  */
 @JvmOverloads
 fun ServiceHub.consumeCash(amount: Amount<Currency>, ourIdentity: PartyAndCertificate, to: Party = CHARLIE, notary: Party): Vault.Update<ContractState> {
-    val update =  vaultService.rawUpdates.toFuture()
+    val update = vaultService.rawUpdates.toFuture()
     val services = this
 
     // A tx that spends our money.
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/http/HttpApi.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/http/HttpApi.kt
index 743934e921..0c283fd844 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/http/HttpApi.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/http/HttpApi.kt
@@ -29,6 +29,7 @@ class HttpApi(val root: URL, val mapper: ObjectMapper = defaultMapper) {
     companion object {
         fun fromHostAndPort(hostAndPort: NetworkHostAndPort, base: String, protocol: String = "http", mapper: ObjectMapper = defaultMapper): HttpApi
                 = HttpApi(URL("$protocol://$hostAndPort/$base/"), mapper)
+
         private val defaultMapper: ObjectMapper by lazy {
             net.corda.client.jackson.JacksonSupport.createNonRpcMapper()
         }
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/schemas/DummyLinearStateSchemaV1.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/schemas/DummyLinearStateSchemaV1.kt
index e25018bd9c..1a610c9372 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/schemas/DummyLinearStateSchemaV1.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/schemas/DummyLinearStateSchemaV1.kt
@@ -20,8 +20,8 @@ object DummyLinearStateSchema
 object DummyLinearStateSchemaV1 : MappedSchema(schemaFamily = DummyLinearStateSchema.javaClass, version = 1, mappedTypes = listOf(PersistentDummyLinearState::class.java)) {
     @Entity
     @Table(name = "dummy_linear_states",
-           indexes = arrayOf(Index(name = "external_id_idx", columnList = "external_id"),
-                             Index(name = "uuid_idx", columnList = "uuid")))
+            indexes = arrayOf(Index(name = "external_id_idx", columnList = "external_id"),
+                    Index(name = "uuid_idx", columnList = "uuid")))
     class PersistentDummyLinearState(
             /** [ContractState] attributes */
 

From b053449b7428ad887fb7425d4afdfa6ff6c0a951 Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 15:36:56 +0100
Subject: [PATCH 128/185] Reformat files in `tools`

---
 .../kotlin/net/corda/demobench/explorer/Explorer.kt   |  2 +-
 .../kotlin/net/corda/demobench/model/NodeConfig.kt    |  2 +-
 .../net/corda/demobench/model/NodeController.kt       |  7 ++++---
 .../net/corda/demobench/model/ServiceController.kt    |  3 +--
 .../net/corda/demobench/views/NodeTerminalView.kt     | 11 +++++++----
 .../main/kotlin/net/corda/demobench/web/WebServer.kt  |  2 +-
 .../kotlin/net/corda/demobench/LoggingTestSuite.kt    |  3 ++-
 .../src/main/kotlin/net/corda/explorer/AmountDiff.kt  |  9 +++++----
 .../kotlin/net/corda/loadtest/ConnectionManager.kt    |  1 +
 .../src/main/kotlin/net/corda/loadtest/Disruption.kt  |  1 +
 .../src/main/kotlin/net/corda/loadtest/LoadTest.kt    |  3 ++-
 11 files changed, 26 insertions(+), 18 deletions(-)

diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt
index 3bf445b827..a03e83d88c 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt
@@ -88,7 +88,7 @@ class Explorer internal constructor(private val explorerController: ExplorerCont
                 try {
                     // Try making a symlink to make things faster and use less disk space.
                     Files.createSymbolicLink(destPath, path)
-                } catch(e: UnsupportedOperationException) {
+                } catch (e: UnsupportedOperationException) {
                     // OS doesn't support symbolic links?
                     Files.copy(path, destPath, REPLACE_EXISTING)
                 } catch (e: java.nio.file.FileAlreadyExistsException) {
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
index 03dda19564..8cde8f3bcf 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
@@ -62,7 +62,7 @@ class NodeConfig constructor(
     fun toText(): String = toFileConfig().root().render(renderOptions)
 
     fun moveTo(baseDir: Path) = NodeConfig(
-        baseDir, legalName, p2pPort, rpcPort, webPort, h2Port, extraServices, users, networkMap
+            baseDir, legalName, p2pPort, rpcPort, webPort, h2Port, extraServices, users, networkMap
     )
 
     fun install(plugins: Collection<Path>) {
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
index 367f04b847..5bd33b700e 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
@@ -33,9 +33,10 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
 
     private var networkMapConfig: NetworkMapConfig? = null
 
-    val activeNodes: List<NodeConfig> get() = nodes.values.filter {
-        (it.state == NodeState.RUNNING) || (it.state == NodeState.STARTING)
-    }
+    val activeNodes: List<NodeConfig>
+        get() = nodes.values.filter {
+            (it.state == NodeState.RUNNING) || (it.state == NodeState.STARTING)
+        }
 
     init {
         log.info("Base directory: $baseDir")
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt
index 2f63b8e1c0..729f305805 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt
@@ -28,8 +28,7 @@ class ServiceController(resourceName: String = "/services.conf") : Controller()
                         val service = line.split(":").map { it.trim() }
                         if (service.size != 2) {
                             log.warning("Encountered corrupted line '$line' while reading services from config: $url")
-                        }
-                        else {
+                        } else {
                             map[service[1]] = service[0]
                             log.info("Supports: $service")
                         }
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt
index a19fcbc484..6046aa0e11 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt
@@ -179,9 +179,9 @@ class NodeTerminalView : Fragment() {
     }
 
     private fun launchRPC(config: NodeConfig) = NodeRPC(
-        config = config,
-        start = this::initialise,
-        invoke = this::pollCashBalances
+            config = config,
+            start = this::initialise,
+            invoke = this::pollCashBalances
     )
 
     private fun initialise(config: NodeConfig, ops: CordaRPCOps) {
@@ -238,7 +238,10 @@ class NodeTerminalView : Fragment() {
         header.isDisable = true
         subscriptions.forEach {
             // Don't allow any exceptions here to halt tab destruction.
-            try { it.unsubscribe() } catch (e: Exception) {}
+            try {
+                it.unsubscribe()
+            } catch (e: Exception) {
+            }
         }
         webServer.close()
         explorer.close()
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/web/WebServer.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/web/WebServer.kt
index 4ff4e23e01..4aec34a73b 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/web/WebServer.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/web/WebServer.kt
@@ -98,7 +98,7 @@ class WebServer internal constructor(private val webServerController: WebServerC
                 conn.connect()
                 conn.disconnect()
                 return url
-            } catch(e: IOException) {
+            } catch (e: IOException) {
             }
         }
         throw TimeoutException("Web server did not start within ${timeout.seconds} seconds")
diff --git a/tools/demobench/src/test/kotlin/net/corda/demobench/LoggingTestSuite.kt b/tools/demobench/src/test/kotlin/net/corda/demobench/LoggingTestSuite.kt
index cd662ace6a..946718c42a 100644
--- a/tools/demobench/src/test/kotlin/net/corda/demobench/LoggingTestSuite.kt
+++ b/tools/demobench/src/test/kotlin/net/corda/demobench/LoggingTestSuite.kt
@@ -25,7 +25,8 @@ class LoggingTestSuite {
      */
     companion object {
         @BeforeClass
-        @JvmStatic fun `setup logging`() {
+        @JvmStatic
+        fun `setup logging`() {
             LoggingConfig()
         }
     }
diff --git a/tools/explorer/src/main/kotlin/net/corda/explorer/AmountDiff.kt b/tools/explorer/src/main/kotlin/net/corda/explorer/AmountDiff.kt
index a77205adb8..24a95ec46b 100644
--- a/tools/explorer/src/main/kotlin/net/corda/explorer/AmountDiff.kt
+++ b/tools/explorer/src/main/kotlin/net/corda/explorer/AmountDiff.kt
@@ -7,10 +7,11 @@ enum class Positivity {
     Negative
 }
 
-val Positivity.sign: String get() = when (this) {
-    Positivity.Positive -> ""
-    Positivity.Negative -> "-"
-}
+val Positivity.sign: String
+    get() = when (this) {
+        Positivity.Positive -> ""
+        Positivity.Negative -> "-"
+    }
 
 data class AmountDiff<T : Any>(
         val positivity: Positivity,
diff --git a/tools/loadtest/src/main/kotlin/net/corda/loadtest/ConnectionManager.kt b/tools/loadtest/src/main/kotlin/net/corda/loadtest/ConnectionManager.kt
index 5b4f0f57ba..fe3e4fc621 100644
--- a/tools/loadtest/src/main/kotlin/net/corda/loadtest/ConnectionManager.kt
+++ b/tools/loadtest/src/main/kotlin/net/corda/loadtest/ConnectionManager.kt
@@ -47,6 +47,7 @@ fun setupJSchWithSshAgent(): JSch {
                         override fun getSignature(data: ByteArray?) = agentProxy.sign(identity.blob, data)
                         @Suppress("OverridingDeprecatedMember")
                         override fun decrypt() = true
+
                         override fun getPublicKeyBlob() = identity.blob
                         override fun setPassphrase(passphrase: ByteArray?) = true
                     }
diff --git a/tools/loadtest/src/main/kotlin/net/corda/loadtest/Disruption.kt b/tools/loadtest/src/main/kotlin/net/corda/loadtest/Disruption.kt
index 87aa80de90..b704f50acd 100644
--- a/tools/loadtest/src/main/kotlin/net/corda/loadtest/Disruption.kt
+++ b/tools/loadtest/src/main/kotlin/net/corda/loadtest/Disruption.kt
@@ -45,6 +45,7 @@ val isNotary = { node: NodeConnection ->
     val notaries = node.proxy.notaryIdentities()
     node.info.legalIdentities.any { it in notaries }
 }
+
 fun <A> ((A) -> Boolean).or(other: (A) -> Boolean): (A) -> Boolean = { this(it) || other(it) }
 
 fun hang(hangIntervalRange: LongRange) = Disruption("Hang randomly") { node, random ->
diff --git a/tools/loadtest/src/main/kotlin/net/corda/loadtest/LoadTest.kt b/tools/loadtest/src/main/kotlin/net/corda/loadtest/LoadTest.kt
index 645b31ad67..a7751ca708 100644
--- a/tools/loadtest/src/main/kotlin/net/corda/loadtest/LoadTest.kt
+++ b/tools/loadtest/src/main/kotlin/net/corda/loadtest/LoadTest.kt
@@ -182,7 +182,8 @@ fun runLoadTests(configuration: LoadTestConfiguration, tests: List<Pair<LoadTest
             val info = connection.info
             log.info("Got node info of ${connection.remoteNode.hostname}: $info!")
             val otherInfo = connection.proxy.networkMapSnapshot()
-            val pubKeysString = otherInfo.map { // TODO Rethink, we loose ability for nice showing of NodeInfos.
+            val pubKeysString = otherInfo.map {
+                // TODO Rethink, we loose ability for nice showing of NodeInfos.
                 "NodeInfo identities set:\n" +
                         it.legalIdentitiesAndCerts.fold("") { acc, elem -> acc + "\n" + elem.name + ": " + elem.owningKey.toBase58String() }
             }.joinToString("\n")

From 3f3ffd50e1939beae42fc61a2588c75450fcbe87 Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 15:37:29 +0100
Subject: [PATCH 129/185] Reformat files in `verifier`

---
 .../kotlin/net/corda/verifier/VerifierTests.kt                | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt b/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
index 6648fdb83d..d12dbc7a41 100644
--- a/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
+++ b/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
@@ -111,8 +111,8 @@ class VerifierTests {
     @Test
     fun `single verifier works with a node`() {
         verifierDriver(
-            networkMapStartStrategy = NetworkMapStartStrategy.Dedicated(startAutomatically = true),
-            extraCordappPackagesToScan = listOf("net.corda.finance.contracts")
+                networkMapStartStrategy = NetworkMapStartStrategy.Dedicated(startAutomatically = true),
+                extraCordappPackagesToScan = listOf("net.corda.finance.contracts")
         ) {
             val aliceFuture = startNode(providedName = ALICE.name)
             val notaryFuture = startNotaryNode(DUMMY_NOTARY.name, verifierType = VerifierType.OutOfProcess)

From f9dc331551aac47b454bf10091333d52005d0df4 Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 15:38:19 +0100
Subject: [PATCH 130/185] Reformat files in `webserver`

---
 .../net/corda/webserver/internal/NodeWebServer.kt      | 10 +++++-----
 .../webserver/servlets/AttachmentDownloadServlet.kt    |  2 +-
 .../net/corda/webserver/servlets/CorDappInfoServlet.kt |  4 ++--
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/webserver/src/main/kotlin/net/corda/webserver/internal/NodeWebServer.kt b/webserver/src/main/kotlin/net/corda/webserver/internal/NodeWebServer.kt
index 462f792c52..8d5bf05a03 100644
--- a/webserver/src/main/kotlin/net/corda/webserver/internal/NodeWebServer.kt
+++ b/webserver/src/main/kotlin/net/corda/webserver/internal/NodeWebServer.kt
@@ -120,7 +120,7 @@ class NodeWebServer(val config: WebServerConfig) {
                 }
 
                 @Throws(IOException::class)
-                override fun writeErrorPageMessage(request: HttpServletRequest, writer: Writer, code: Int, message: String , uri: String) {
+                override fun writeErrorPageMessage(request: HttpServletRequest, writer: Writer, code: Int, message: String, uri: String) {
                     writer.write("<h1>Corda $safeLegalName</h1>\n")
                     super.writeErrorPageMessage(request, writer, code, message, uri)
                 }
@@ -135,10 +135,10 @@ class NodeWebServer(val config: WebServerConfig) {
             }
 
             val resourceConfig = ResourceConfig()
-                .register(ObjectMapperConfig(rpcObjectMapper))
-                .register(ResponseFilter())
-                .register(CordaConverterProvider)
-                .register(APIServerImpl(localRpc))
+                    .register(ObjectMapperConfig(rpcObjectMapper))
+                    .register(ResponseFilter())
+                    .register(CordaConverterProvider)
+                    .register(APIServerImpl(localRpc))
 
             val webAPIsOnClasspath = pluginRegistries.flatMap { x -> x.webApis }
             for (webapi in webAPIsOnClasspath) {
diff --git a/webserver/src/main/kotlin/net/corda/webserver/servlets/AttachmentDownloadServlet.kt b/webserver/src/main/kotlin/net/corda/webserver/servlets/AttachmentDownloadServlet.kt
index 9750f595ac..e23d420059 100644
--- a/webserver/src/main/kotlin/net/corda/webserver/servlets/AttachmentDownloadServlet.kt
+++ b/webserver/src/main/kotlin/net/corda/webserver/servlets/AttachmentDownloadServlet.kt
@@ -55,7 +55,7 @@ class AttachmentDownloadServlet : HttpServlet() {
 
             // Closing the output stream commits our response. We cannot change the status code after this.
             resp.outputStream.close()
-        } catch(e: FileNotFoundException) {
+        } catch (e: FileNotFoundException) {
             log.warn("404 Not Found whilst trying to handle attachment download request for ${servletContext.contextPath}/$reqPath")
             resp.sendError(HttpServletResponse.SC_NOT_FOUND)
             return
diff --git a/webserver/src/main/kotlin/net/corda/webserver/servlets/CorDappInfoServlet.kt b/webserver/src/main/kotlin/net/corda/webserver/servlets/CorDappInfoServlet.kt
index eba6597428..8daa446af9 100644
--- a/webserver/src/main/kotlin/net/corda/webserver/servlets/CorDappInfoServlet.kt
+++ b/webserver/src/main/kotlin/net/corda/webserver/servlets/CorDappInfoServlet.kt
@@ -15,7 +15,7 @@ import javax.servlet.http.HttpServletResponse
  * Dumps some data about the installed CorDapps.
  * TODO: Add registered flow initiators.
  */
-class CorDappInfoServlet(val plugins: List<WebServerPluginRegistry>, val rpc: CordaRPCOps): HttpServlet() {
+class CorDappInfoServlet(val plugins: List<WebServerPluginRegistry>, val rpc: CordaRPCOps) : HttpServlet() {
 
     @Throws(IOException::class)
     override fun doGet(req: HttpServletRequest, resp: HttpServletResponse) {
@@ -73,7 +73,7 @@ class CorDappInfoServlet(val plugins: List<WebServerPluginRegistry>, val rpc: Co
 
         for (method in resource.allMethods) {
             if (method.type == ResourceMethod.JaxrsType.SUB_RESOURCE_LOCATOR) {
-                resources.add( Resource.from(resource.resourceLocator.invocable.definitionMethod.returnType))
+                resources.add(Resource.from(resource.resourceLocator.invocable.definitionMethod.returnType))
             } else {
                 endpoints.add(Endpoint(method.httpMethod, "api$path", resource.path))
             }

From 14f959b4afdd445b6092a821ff8ccea532409abf Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Fri, 6 Oct 2017 16:22:38 +0100
Subject: [PATCH 131/185] Code clean-up run

---
 .../net/corda/client/jfx/model/NetworkIdentityModel.kt   | 2 +-
 .../src/main/kotlin/net/corda/core/flows/FinalityFlow.kt | 2 +-
 .../net/corda/finance/contracts/JavaCommercialPaper.java | 4 +---
 .../net/corda/finance/contracts/asset/Obligation.kt      | 2 +-
 .../net/corda/finance/contracts/CommercialPaperTests.kt  | 3 ++-
 .../net/corda/finance/contracts/asset/CashTests.kt       | 7 ++++---
 .../internal/serialization/SerializationScheme.kt        | 2 +-
 .../internal/serialization/amqp/PropertySerializer.kt    | 6 +++---
 .../corda/node/services/network/NodeInfoWatcherTest.kt   | 2 +-
 .../node/services/statemachine/FlowStateMachineImpl.kt   | 2 +-
 .../net/corda/node/utilities/NonInvalidatingCache.kt     | 3 ---
 .../corda/node/utilities/NonInvalidatingUnboundCache.kt  | 3 ---
 .../resources/net/corda/node/shell/base/login.groovy     | 2 +-
 .../corda/node/services/vault/NodeVaultServiceTest.kt    | 5 +++--
 .../net/corda/node/services/vault/VaultWithCashTest.kt   | 9 +++++----
 .../src/main/kotlin/net/corda/irs/contract/IRSUtils.kt   | 1 -
 .../src/main/kotlin/net/corda/demobench/pty/R3Pty.kt     | 2 +-
 .../src/main/kotlin/net/corda/explorer/views/Network.kt  | 6 +++---
 .../main/kotlin/net/corda/explorer/views/SearchField.kt  | 2 +-
 .../kotlin/net/corda/explorer/views/TransactionViewer.kt | 4 ++--
 .../net/corda/explorer/views/cordapps/cash/CashViewer.kt | 2 +-
 21 files changed, 33 insertions(+), 38 deletions(-)

diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NetworkIdentityModel.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NetworkIdentityModel.kt
index 9ff83660aa..2213d40bbc 100644
--- a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NetworkIdentityModel.kt
+++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NetworkIdentityModel.kt
@@ -38,7 +38,7 @@ class NetworkIdentityModel {
             })
 
     val notaries: ObservableList<Party> = networkIdentities.map {
-        it.legalIdentitiesAndCerts.find { it.name.commonName?.let { ServiceType.parse(it).isNotary() } ?: false }
+        it.legalIdentitiesAndCerts.find { it.name.commonName?.let { ServiceType.parse(it).isNotary() } == true }
     }.map { it?.party }.filterNotNull()
 
     val notaryNodes: ObservableList<NodeInfo> = notaries.map { rpcProxy.value?.nodeInfoFromParty(it) }.filterNotNull()
diff --git a/core/src/main/kotlin/net/corda/core/flows/FinalityFlow.kt b/core/src/main/kotlin/net/corda/core/flows/FinalityFlow.kt
index e2aafc165c..a08654acb9 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FinalityFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FinalityFlow.kt
@@ -88,7 +88,7 @@ class FinalityFlow(val transaction: SignedTransaction,
     private fun hasNoNotarySignature(stx: SignedTransaction): Boolean {
         val notaryKey = stx.tx.notary?.owningKey
         val signers = stx.sigs.map { it.by }.toSet()
-        return !(notaryKey?.isFulfilledBy(signers) ?: false)
+        return notaryKey?.isFulfilledBy(signers) != true
     }
 
     private fun getPartiesToSend(ltx: LedgerTransaction): Set<Party> {
diff --git a/finance/src/main/java/net/corda/finance/contracts/JavaCommercialPaper.java b/finance/src/main/java/net/corda/finance/contracts/JavaCommercialPaper.java
index 02bf2bbd45..221e02427c 100644
--- a/finance/src/main/java/net/corda/finance/contracts/JavaCommercialPaper.java
+++ b/finance/src/main/java/net/corda/finance/contracts/JavaCommercialPaper.java
@@ -101,9 +101,7 @@ public class JavaCommercialPaper implements Contract {
             if (issuance != null ? !issuance.equals(state.issuance) : state.issuance != null) return false;
             if (owner != null ? !owner.equals(state.owner) : state.owner != null) return false;
             if (faceValue != null ? !faceValue.equals(state.faceValue) : state.faceValue != null) return false;
-            if (maturityDate != null ? !maturityDate.equals(state.maturityDate) : state.maturityDate != null)
-                return false;
-            return true;
+            return maturityDate != null ? maturityDate.equals(state.maturityDate) : state.maturityDate == null;
         }
 
         @Override
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt
index e5d45f6d51..c30ddc0875 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Obligation.kt
@@ -454,7 +454,7 @@ class Obligation<P : Any> : Contract {
 
                 requireThat {
                     "there is a time-window from the authority" using (timeWindow != null)
-                    "the due date has passed" using (timeWindow!!.fromTime?.isAfter(deadline) ?: false)
+                    "the due date has passed" using (timeWindow!!.fromTime?.isAfter(deadline) == true)
                     "input state lifecycle is correct" using (input.lifecycle == expectedInputLifecycle)
                     "output state corresponds exactly to input state, with lifecycle changed" using (expectedOutput == actualOutput)
                 }
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
index a1a296eb05..9a8150ef0f 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
@@ -12,6 +12,7 @@ import net.corda.core.utilities.seconds
 import net.corda.finance.DOLLARS
 import net.corda.finance.`issued by`
 import net.corda.finance.contracts.asset.*
+import net.corda.finance.contracts.asset.Cash.Companion.generateSpend
 import net.corda.testing.*
 import net.corda.testing.contracts.fillWithSomeTestCash
 import net.corda.testing.node.MockServices
@@ -269,7 +270,7 @@ class CommercialPaperTestsGeneric {
             // Alice pays $9000 to BigCorp to own some of their debt.
             moveTX = run {
                 val builder = TransactionBuilder(DUMMY_NOTARY)
-                Cash.generateSpend(aliceServices, builder, 9000.DOLLARS, AnonymousParty(bigCorpServices.key.public))
+                generateSpend(aliceServices, builder, 9000.DOLLARS, AnonymousParty(bigCorpServices.key.public), ourIdentity, emptySet())
                 CommercialPaper().generateMove(builder, issueTx.tx.outRef(0), AnonymousParty(aliceServices.key.public))
                 val ptx = aliceServices.signInitialTransaction(builder)
                 val ptx2 = bigCorpServices.addSignature(ptx)
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
index 952aa3d9df..e888d0705b 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
@@ -12,6 +12,7 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.transactions.WireTransaction
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.finance.*
+import net.corda.finance.contracts.asset.Cash.Companion.generateSpend
 import net.corda.finance.utils.sumCash
 import net.corda.finance.utils.sumCashBy
 import net.corda.finance.utils.sumCashOrNull
@@ -505,7 +506,7 @@ class CashTests : TestDependencyInjectionBase() {
     private fun makeSpend(amount: Amount<Currency>, dest: AbstractParty): WireTransaction {
         val tx = TransactionBuilder(DUMMY_NOTARY)
         database.transaction {
-            Cash.generateSpend(miniCorpServices, tx, amount, dest)
+            generateSpend(miniCorpServices, tx, amount, dest, ourIdentity, emptySet())
         }
         return tx.toWireTransaction(miniCorpServices)
     }
@@ -607,7 +608,7 @@ class CashTests : TestDependencyInjectionBase() {
         database.transaction {
 
             val tx = TransactionBuilder(DUMMY_NOTARY)
-            Cash.generateSpend(miniCorpServices, tx, 80.DOLLARS, ALICE, setOf(MINI_CORP))
+            generateSpend(miniCorpServices, tx, 80.DOLLARS, ALICE, ourIdentity, setOf(MINI_CORP))
 
             assertEquals(vaultStatesUnconsumed.elementAt(2).ref, tx.inputStates()[0])
         }
@@ -826,7 +827,7 @@ class CashTests : TestDependencyInjectionBase() {
                     PartyAndAmount(THEIR_IDENTITY_1, 400.DOLLARS),
                     PartyAndAmount(THEIR_IDENTITY_2, 150.DOLLARS)
             )
-            Cash.generateSpend(miniCorpServices, tx, payments)
+            generateSpend(miniCorpServices, tx, amount, to, ourIdentity, emptySet())
         }
         val wtx = tx.toWireTransaction(miniCorpServices)
         fun out(i: Int) = wtx.getOutput(i) as Cash.State
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
index e4deaf2c55..1e7c257a1d 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/SerializationScheme.kt
@@ -52,7 +52,7 @@ data class SerializationContextImpl(override val preferredSerializationVersion:
      * We need to cache the AttachmentClassLoaders to avoid too many contexts, since the class loader is part of cache key for the context.
      */
     override fun withAttachmentsClassLoader(attachmentHashes: List<SecureHash>): SerializationContext {
-        properties[attachmentsClassLoaderEnabledPropertyName] as? Boolean ?: false || return this
+        properties[attachmentsClassLoaderEnabledPropertyName] as? Boolean == true || return this
         val serializationContext = properties[serializationContextKey] as? SerializeAsTokenContextImpl ?: return this // Some tests don't set one.
         try {
             return withClassLoader(cache.get(attachmentHashes) {
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
index feb06e123e..3d9fa8b0a5 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/amqp/PropertySerializer.kt
@@ -21,8 +21,8 @@ sealed class PropertySerializer(val name: String, val readMethod: Method?, val r
     val default: String? = generateDefault()
     val mandatory: Boolean = generateMandatory()
 
-    private val isInterface: Boolean get() = resolvedType.asClass()?.isInterface ?: false
-    private val isJVMPrimitive: Boolean get() = resolvedType.asClass()?.isPrimitive ?: false
+    private val isInterface: Boolean get() = resolvedType.asClass()?.isInterface == true
+    private val isJVMPrimitive: Boolean get() = resolvedType.asClass()?.isPrimitive == true
 
     private fun generateType(): String {
         return if (isInterface || resolvedType == Any::class.java) "*" else SerializerFactory.nameForType(resolvedType)
@@ -45,7 +45,7 @@ sealed class PropertySerializer(val name: String, val readMethod: Method?, val r
     }
 
     private fun generateMandatory(): Boolean {
-        return isJVMPrimitive || !(readMethod?.returnsNullable() ?: true)
+        return isJVMPrimitive || readMethod?.returnsNullable() == false
     }
 
     private fun Method.returnsNullable(): Boolean {
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
index 556e47cb50..268d23d394 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
@@ -35,7 +35,7 @@ class NodeInfoWatcherTest : NodeBasedTest() {
 
     lateinit var keyManagementService: KeyManagementService
     lateinit var nodeInfoPath: Path
-    val scheduler = TestScheduler();
+    val scheduler = TestScheduler()
     val testSubscriber = TestSubscriber<NodeInfo>()
 
     // Object under test
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
index 0b478243f6..dea328709a 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
@@ -265,7 +265,7 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
         // This is a hack to allow cash app access list of permitted issuer currency.
         // TODO: replace this with cordapp configuration.
         val config = serviceHub.configuration as? FullNodeConfiguration
-        val permissionGranted = config?.extraAdvertisedServiceIds?.contains(permissionName) ?: true
+        val permissionGranted = config?.extraAdvertisedServiceIds?.contains(permissionName) != false
         val checkPermissionEvent = FlowPermissionAuditEvent(
                 serviceHub.clock.instant(),
                 flowInitiator,
diff --git a/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingCache.kt b/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingCache.kt
index a81ce259e5..07dd16b936 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingCache.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingCache.kt
@@ -27,8 +27,5 @@ class NonInvalidatingCache<K, V> private constructor(
         }
 
         override fun load(key: K) = loadFunction(key)
-        override fun loadAll(keys: Iterable<K>): MutableMap<K, V> {
-            return super.loadAll(keys)
-        }
     }
 }
\ No newline at end of file
diff --git a/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingUnboundCache.kt b/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingUnboundCache.kt
index 8719a4e448..ea16bfd064 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingUnboundCache.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/NonInvalidatingUnboundCache.kt
@@ -29,8 +29,5 @@ class NonInvalidatingUnboundCache<K, V> private constructor(
         }
 
         override fun load(key: K) = loadFunction(key)
-        override fun loadAll(keys: Iterable<K>): MutableMap<K, V> {
-            return super.loadAll(keys)
-        }
     }
 }
\ No newline at end of file
diff --git a/node/src/main/resources/net/corda/node/shell/base/login.groovy b/node/src/main/resources/net/corda/node/shell/base/login.groovy
index 500704ae69..f6df32b386 100644
--- a/node/src/main/resources/net/corda/node/shell/base/login.groovy
+++ b/node/src/main/resources/net/corda/node/shell/base/login.groovy
@@ -11,5 +11,5 @@ Useful commands include 'help' to see what is available, and 'bye' to shut down
 """
 
 prompt = { ->
-    return "${new Date()}>>> ";
+    return "${new Date()}>>> "
 }
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
index 5250e7f500..9d385d9663 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
@@ -20,6 +20,7 @@ import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.toNonEmptySet
 import net.corda.finance.*
 import net.corda.finance.contracts.asset.Cash
+import net.corda.finance.contracts.asset.Cash.Companion.generateSpend
 import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER
 import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER_KEY
 import net.corda.finance.contracts.getCashBalance
@@ -515,7 +516,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
         database.transaction {
             val moveTx = TransactionBuilder(services.myInfo.chooseIdentity()).apply {
-                Cash.generateSpend(services, this, Amount(1000, GBP), thirdPartyIdentity)
+                generateSpend(services, this, Amount(1000, GBP), thirdPartyIdentity, ourIdentity, emptySet())
             }.toWireTransaction(services)
             service.notify(moveTx)
         }
@@ -560,7 +561,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
         // Move cash
         val moveTx = database.transaction {
             TransactionBuilder(newNotary).apply {
-                Cash.generateSpend(services, this, Amount(1000, GBP), thirdPartyIdentity)
+                generateSpend(services, this, Amount(1000, GBP), thirdPartyIdentity, ourIdentity, emptySet())
             }.toWireTransaction(services)
         }
 
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
index 60e853d023..aacc46ce2b 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
@@ -12,6 +12,7 @@ import net.corda.core.node.services.vault.QueryCriteria.VaultQueryCriteria
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.finance.*
 import net.corda.finance.contracts.asset.Cash
+import net.corda.finance.contracts.asset.Cash.Companion.generateSpend
 import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER
 import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER_KEY
 import net.corda.finance.contracts.getCashBalance
@@ -99,7 +100,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
                 database.transaction {
                     // A tx that spends our money.
                     val spendTXBuilder = TransactionBuilder(DUMMY_NOTARY)
-                    Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB)
+                    generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB, ourIdentity, emptySet())
                     val spendPTX = services.signInitialTransaction(spendTXBuilder, freshKey)
                     notaryServices.addSignature(spendPTX)
                 }
@@ -151,7 +152,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
             database.transaction {
                 try {
                     val txn1Builder = TransactionBuilder(DUMMY_NOTARY)
-                    Cash.generateSpend(services, txn1Builder, 60.DOLLARS, BOB)
+                    generateSpend(services, txn1Builder, 60.DOLLARS, BOB, ourIdentity, emptySet())
                     val ptxn1 = notaryServices.signInitialTransaction(txn1Builder)
                     val txn1 = services.addSignature(ptxn1, freshKey)
                     println("txn1: ${txn1.id} spent ${((txn1.tx.outputs[0].data) as Cash.State).amount}")
@@ -187,7 +188,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
             database.transaction {
                 try {
                     val txn2Builder = TransactionBuilder(DUMMY_NOTARY)
-                    Cash.generateSpend(services, txn2Builder, 80.DOLLARS, BOB)
+                    generateSpend(services, txn2Builder, 80.DOLLARS, BOB, ourIdentity, emptySet())
                     val ptxn2 = notaryServices.signInitialTransaction(txn2Builder)
                     val txn2 = services.addSignature(ptxn2, freshKey)
                     println("txn2: ${txn2.id} spent ${((txn2.tx.outputs[0].data) as Cash.State).amount}")
@@ -311,7 +312,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
         database.transaction {
             // A tx that spends our money.
             val spendTXBuilder = TransactionBuilder(DUMMY_NOTARY)
-            Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB)
+            generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB, ourIdentity, emptySet())
             val spendPTX = notaryServices.signInitialTransaction(spendTXBuilder)
             val spendTX = services.addSignature(spendPTX, freshKey)
             services.recordTransactions(spendTX)
diff --git a/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt b/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt
index fb7e367a3c..c362e602a5 100644
--- a/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt
+++ b/samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRSUtils.kt
@@ -71,7 +71,6 @@ class FixedRate(ratioUnit: RatioUnit) : Rate(ratioUnit) {
     fun isPositive(): Boolean = ratioUnit!!.value > BigDecimal("0.0")
 
     override fun equals(other: Any?) = other?.javaClass == javaClass && super.equals(other)
-    override fun hashCode() = super.hashCode()
 }
 
 /**
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/pty/R3Pty.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/pty/R3Pty.kt
index afc91bb6f4..cd82181367 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/pty/R3Pty.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/pty/R3Pty.kt
@@ -21,7 +21,7 @@ class R3Pty(val name: CordaX500Name, settings: SettingsProvider, dimension: Dime
 
     val terminal = JediTermWidget(dimension, settings)
 
-    val isConnected: Boolean get() = terminal.ttyConnector?.isConnected ?: false
+    val isConnected: Boolean get() = terminal.ttyConnector?.isConnected == true
 
     override fun close() {
         log.info("Closing terminal '{}'", name)
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 cb7f69df1f..de6a41aded 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
@@ -103,7 +103,7 @@ class Network : CordaView() {
                     hgap = 5.0
                     vgap = 5.0
                     for (identity in identities) {
-                        val isNotary = identity.name.commonName?.let { ServiceType.parse(it).isNotary() } ?: false
+                        val isNotary = identity.name.commonName?.let { ServiceType.parse(it).isNotary() } == true
                         row("${if (isNotary) "Notary " else ""}Public Key :") {
                             copyableLabel(SimpleObjectProperty(identity.owningKey.toBase58String()))
                         }
@@ -150,7 +150,7 @@ class Network : CordaView() {
     }
 
     override fun onDock() {
-        centralLabel = mapLabels.firstOrDefault(SimpleObjectProperty(myLabel), { centralPeer?.contains(it.text, true) ?: false })
+        centralLabel = mapLabels.firstOrDefault(SimpleObjectProperty(myLabel), { centralPeer?.contains(it.text, true) == true })
         centralLabel.value?.let { mapScrollPane.centerLabel(it) }
     }
 
@@ -160,7 +160,7 @@ class Network : CordaView() {
     }
 
     init {
-        centralLabel = mapLabels.firstOrDefault(SimpleObjectProperty(myLabel), { centralPeer?.contains(it.text, true) ?: false })
+        centralLabel = mapLabels.firstOrDefault(SimpleObjectProperty(myLabel), { centralPeer?.contains(it.text, true) == true })
         Bindings.bindContent(notaryList.children, notaryButtons)
         Bindings.bindContent(peerList.children, peerButtons)
         // Run once when the screen is ready.
diff --git a/tools/explorer/src/main/kotlin/net/corda/explorer/views/SearchField.kt b/tools/explorer/src/main/kotlin/net/corda/explorer/views/SearchField.kt
index 2feeb8a938..ce06f65318 100644
--- a/tools/explorer/src/main/kotlin/net/corda/explorer/views/SearchField.kt
+++ b/tools/explorer/src/main/kotlin/net/corda/explorer/views/SearchField.kt
@@ -37,7 +37,7 @@ class SearchField<T>(private val data: ObservableList<T>, vararg filterCriteria:
             text.isNullOrBlank() || if (category == ALL) {
                 filterCriteria.any { it.second(data, text) }
             } else {
-                filterCriteria.toMap()[category]?.invoke(data, text) ?: false
+                filterCriteria.toMap()[category]?.invoke(data, text) == true
             }
         }
     }, arrayOf<Observable>(textField.textProperty(), searchCategory.valueProperty())))
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 f528e0ec66..128c2f221b 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
@@ -135,8 +135,8 @@ class TransactionViewer : CordaView("Transactions") {
                 "Transaction ID" to { tx, s -> "${tx.id}".contains(s, true) },
                 "Input" to { tx, s -> tx.inputs.resolved.any { it.state.contract.contains(s, true) } },
                 "Output" to { tx, s -> tx.outputs.any { it.state.contract.contains(s, true) } },
-                "Input Party" to { tx, s -> tx.inputParties.any { it.any { it.value?.name?.organisation?.contains(s, true) ?: false } } },
-                "Output Party" to { tx, s -> tx.outputParties.any { it.any { it.value?.name?.organisation?.contains(s, true) ?: false } } },
+                "Input Party" to { tx, s -> tx.inputParties.any { it.any { it.value?.name?.organisation?.contains(s, true) == true } } },
+                "Output Party" to { tx, s -> tx.outputParties.any { it.any { it.value?.name?.organisation?.contains(s, true) == true } } },
                 "Command Type" to { tx, s -> tx.commandTypes.any { it.simpleName.contains(s, true) } }
         )
         root.top = searchField.root
diff --git a/tools/explorer/src/main/kotlin/net/corda/explorer/views/cordapps/cash/CashViewer.kt b/tools/explorer/src/main/kotlin/net/corda/explorer/views/cordapps/cash/CashViewer.kt
index 480ae1116e..6093a235b1 100644
--- a/tools/explorer/src/main/kotlin/net/corda/explorer/views/cordapps/cash/CashViewer.kt
+++ b/tools/explorer/src/main/kotlin/net/corda/explorer/views/cordapps/cash/CashViewer.kt
@@ -147,7 +147,7 @@ class CashViewer : CordaView("Cash") {
          */
         val searchField = SearchField(cashStates,
                 "Currency" to { state, text -> state.state.data.amount.token.product.toString().contains(text, true) },
-                "Issuer" to { state, text -> state.resolveIssuer().value?.name?.organisation?.contains(text, true) ?: false }
+                "Issuer" to { state, text -> state.resolveIssuer().value?.name?.organisation?.contains(text, true) == true }
         )
         root.top = hbox(5.0) {
             button("New Transaction", FontAwesomeIconView(FontAwesomeIcon.PLUS)) {

From e1458a40cb760a233a75431c6269198e13c8e9eb Mon Sep 17 00:00:00 2001
From: Tommy Lillehagen <tommy.lillehagen@r3.com>
Date: Mon, 9 Oct 2017 10:20:20 +0100
Subject: [PATCH 132/185] Revert code transformation; use of deprecated method

---
 .../net/corda/finance/contracts/CommercialPaperTests.kt  | 3 +--
 .../net/corda/finance/contracts/asset/CashTests.kt       | 7 +++----
 .../corda/node/services/vault/NodeVaultServiceTest.kt    | 5 ++---
 .../net/corda/node/services/vault/VaultWithCashTest.kt   | 9 ++++-----
 4 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
index 9a8150ef0f..a1a296eb05 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
@@ -12,7 +12,6 @@ import net.corda.core.utilities.seconds
 import net.corda.finance.DOLLARS
 import net.corda.finance.`issued by`
 import net.corda.finance.contracts.asset.*
-import net.corda.finance.contracts.asset.Cash.Companion.generateSpend
 import net.corda.testing.*
 import net.corda.testing.contracts.fillWithSomeTestCash
 import net.corda.testing.node.MockServices
@@ -270,7 +269,7 @@ class CommercialPaperTestsGeneric {
             // Alice pays $9000 to BigCorp to own some of their debt.
             moveTX = run {
                 val builder = TransactionBuilder(DUMMY_NOTARY)
-                generateSpend(aliceServices, builder, 9000.DOLLARS, AnonymousParty(bigCorpServices.key.public), ourIdentity, emptySet())
+                Cash.generateSpend(aliceServices, builder, 9000.DOLLARS, AnonymousParty(bigCorpServices.key.public))
                 CommercialPaper().generateMove(builder, issueTx.tx.outRef(0), AnonymousParty(aliceServices.key.public))
                 val ptx = aliceServices.signInitialTransaction(builder)
                 val ptx2 = bigCorpServices.addSignature(ptx)
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
index e888d0705b..952aa3d9df 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
@@ -12,7 +12,6 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.transactions.WireTransaction
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.finance.*
-import net.corda.finance.contracts.asset.Cash.Companion.generateSpend
 import net.corda.finance.utils.sumCash
 import net.corda.finance.utils.sumCashBy
 import net.corda.finance.utils.sumCashOrNull
@@ -506,7 +505,7 @@ class CashTests : TestDependencyInjectionBase() {
     private fun makeSpend(amount: Amount<Currency>, dest: AbstractParty): WireTransaction {
         val tx = TransactionBuilder(DUMMY_NOTARY)
         database.transaction {
-            generateSpend(miniCorpServices, tx, amount, dest, ourIdentity, emptySet())
+            Cash.generateSpend(miniCorpServices, tx, amount, dest)
         }
         return tx.toWireTransaction(miniCorpServices)
     }
@@ -608,7 +607,7 @@ class CashTests : TestDependencyInjectionBase() {
         database.transaction {
 
             val tx = TransactionBuilder(DUMMY_NOTARY)
-            generateSpend(miniCorpServices, tx, 80.DOLLARS, ALICE, ourIdentity, setOf(MINI_CORP))
+            Cash.generateSpend(miniCorpServices, tx, 80.DOLLARS, ALICE, setOf(MINI_CORP))
 
             assertEquals(vaultStatesUnconsumed.elementAt(2).ref, tx.inputStates()[0])
         }
@@ -827,7 +826,7 @@ class CashTests : TestDependencyInjectionBase() {
                     PartyAndAmount(THEIR_IDENTITY_1, 400.DOLLARS),
                     PartyAndAmount(THEIR_IDENTITY_2, 150.DOLLARS)
             )
-            generateSpend(miniCorpServices, tx, amount, to, ourIdentity, emptySet())
+            Cash.generateSpend(miniCorpServices, tx, payments)
         }
         val wtx = tx.toWireTransaction(miniCorpServices)
         fun out(i: Int) = wtx.getOutput(i) as Cash.State
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
index 9d385d9663..5250e7f500 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
@@ -20,7 +20,6 @@ import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.toNonEmptySet
 import net.corda.finance.*
 import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.Cash.Companion.generateSpend
 import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER
 import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER_KEY
 import net.corda.finance.contracts.getCashBalance
@@ -516,7 +515,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
         database.transaction {
             val moveTx = TransactionBuilder(services.myInfo.chooseIdentity()).apply {
-                generateSpend(services, this, Amount(1000, GBP), thirdPartyIdentity, ourIdentity, emptySet())
+                Cash.generateSpend(services, this, Amount(1000, GBP), thirdPartyIdentity)
             }.toWireTransaction(services)
             service.notify(moveTx)
         }
@@ -561,7 +560,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
         // Move cash
         val moveTx = database.transaction {
             TransactionBuilder(newNotary).apply {
-                generateSpend(services, this, Amount(1000, GBP), thirdPartyIdentity, ourIdentity, emptySet())
+                Cash.generateSpend(services, this, Amount(1000, GBP), thirdPartyIdentity)
             }.toWireTransaction(services)
         }
 
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
index aacc46ce2b..60e853d023 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
@@ -12,7 +12,6 @@ import net.corda.core.node.services.vault.QueryCriteria.VaultQueryCriteria
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.finance.*
 import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.Cash.Companion.generateSpend
 import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER
 import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER_KEY
 import net.corda.finance.contracts.getCashBalance
@@ -100,7 +99,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
                 database.transaction {
                     // A tx that spends our money.
                     val spendTXBuilder = TransactionBuilder(DUMMY_NOTARY)
-                    generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB, ourIdentity, emptySet())
+                    Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB)
                     val spendPTX = services.signInitialTransaction(spendTXBuilder, freshKey)
                     notaryServices.addSignature(spendPTX)
                 }
@@ -152,7 +151,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
             database.transaction {
                 try {
                     val txn1Builder = TransactionBuilder(DUMMY_NOTARY)
-                    generateSpend(services, txn1Builder, 60.DOLLARS, BOB, ourIdentity, emptySet())
+                    Cash.generateSpend(services, txn1Builder, 60.DOLLARS, BOB)
                     val ptxn1 = notaryServices.signInitialTransaction(txn1Builder)
                     val txn1 = services.addSignature(ptxn1, freshKey)
                     println("txn1: ${txn1.id} spent ${((txn1.tx.outputs[0].data) as Cash.State).amount}")
@@ -188,7 +187,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
             database.transaction {
                 try {
                     val txn2Builder = TransactionBuilder(DUMMY_NOTARY)
-                    generateSpend(services, txn2Builder, 80.DOLLARS, BOB, ourIdentity, emptySet())
+                    Cash.generateSpend(services, txn2Builder, 80.DOLLARS, BOB)
                     val ptxn2 = notaryServices.signInitialTransaction(txn2Builder)
                     val txn2 = services.addSignature(ptxn2, freshKey)
                     println("txn2: ${txn2.id} spent ${((txn2.tx.outputs[0].data) as Cash.State).amount}")
@@ -312,7 +311,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
         database.transaction {
             // A tx that spends our money.
             val spendTXBuilder = TransactionBuilder(DUMMY_NOTARY)
-            generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB, ourIdentity, emptySet())
+            Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB)
             val spendPTX = notaryServices.signInitialTransaction(spendTXBuilder)
             val spendTX = services.addSignature(spendPTX, freshKey)
             services.recordTransactions(spendTX)

From 7340a2e32f4348a92753a6384374e46af1f71a1d Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Mon, 9 Oct 2017 16:15:27 +0100
Subject: [PATCH 133/185] CORDA-654: Handle non-standard file systems in
 NodeInfoWatcher (#1818)

Handle non-standard file systems such as JimFs, in NodeInfoWatcher. Instead of using `toFile()` to convert a Path to a File, open the Path for writing to directly.
---
 .../services/network/NodeInfoWatcherTest.kt   | 58 ++++++++++++-------
 .../node/services/network/NodeInfoWatcher.kt  | 15 ++---
 2 files changed, 42 insertions(+), 31 deletions(-)

diff --git a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
index 268d23d394..d4436236ef 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
@@ -1,16 +1,16 @@
 package net.corda.node.services.network
 
+import com.google.common.jimfs.Configuration
+import com.google.common.jimfs.Jimfs
 import net.corda.cordform.CordformNode
 import net.corda.core.internal.createDirectories
 import net.corda.core.internal.div
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.services.KeyManagementService
-import net.corda.core.utilities.seconds
 import net.corda.node.services.identity.InMemoryIdentityService
 import net.corda.testing.ALICE
 import net.corda.testing.ALICE_KEY
 import net.corda.testing.DEV_TRUST_ROOT
-import net.corda.testing.eventually
 import net.corda.testing.getTestPartyAndCertificate
 import net.corda.testing.node.MockKeyManagementService
 import net.corda.testing.node.NodeBasedTest
@@ -56,6 +56,7 @@ class NodeInfoWatcherTest : NodeBasedTest() {
 
     @Test
     fun `save a NodeInfo`() {
+        assertEquals(0, folder.root.list().size)
         NodeInfoWatcher.saveToFile(folder.root.toPath(), nodeInfo, keyManagementService)
 
         assertEquals(1, folder.root.list().size)
@@ -66,30 +67,45 @@ class NodeInfoWatcherTest : NodeBasedTest() {
         assertThat(contentOf(file)).isNotEmpty()
     }
 
+    @Test
+    fun `save a NodeInfo to JimFs`() {
+        val jimFs = Jimfs.newFileSystem(Configuration.unix())
+        val jimFolder = jimFs.getPath("/nodeInfo")
+        NodeInfoWatcher.saveToFile(jimFolder, nodeInfo, keyManagementService)
+    }
+
     @Test
     fun `load an empty Directory`() {
         nodeInfoPath.createDirectories()
 
-        nodeInfoWatcher.nodeInfoUpdates()
+        val subscription = nodeInfoWatcher.nodeInfoUpdates()
                 .subscribe(testSubscriber)
-        advanceTime()
+        try {
+            advanceTime()
 
-        val readNodes = testSubscriber.onNextEvents.distinct()
-        assertEquals(0, readNodes.size)
+            val readNodes = testSubscriber.onNextEvents.distinct()
+            assertEquals(0, readNodes.size)
+        } finally {
+            subscription.unsubscribe()
+        }
     }
 
     @Test
     fun `load a non empty Directory`() {
         createNodeInfoFileInPath(nodeInfo)
 
-        nodeInfoWatcher.nodeInfoUpdates()
+        val subscription = nodeInfoWatcher.nodeInfoUpdates()
                 .subscribe(testSubscriber)
         advanceTime()
 
-        val readNodes = testSubscriber.onNextEvents.distinct()
+        try {
+            val readNodes = testSubscriber.onNextEvents.distinct()
 
-        assertEquals(1, readNodes.size)
-        assertEquals(nodeInfo, readNodes.first())
+            assertEquals(1, readNodes.size)
+            assertEquals(nodeInfo, readNodes.first())
+        } finally {
+            subscription.unsubscribe()
+        }
     }
 
     @Test
@@ -97,22 +113,24 @@ class NodeInfoWatcherTest : NodeBasedTest() {
         nodeInfoPath.createDirectories()
 
         // Start polling with an empty folder.
-        nodeInfoWatcher.nodeInfoUpdates()
+        val subscription = nodeInfoWatcher.nodeInfoUpdates()
                 .subscribe(testSubscriber)
-        // Ensure the watch service is started.
-        advanceTime()
-        // Check no nodeInfos are read.
-        assertEquals(0, testSubscriber.valueCount)
-        createNodeInfoFileInPath(nodeInfo)
+        try {
+            // Ensure the watch service is started.
+            advanceTime()
+            // Check no nodeInfos are read.
+            assertEquals(0, testSubscriber.valueCount)
+            createNodeInfoFileInPath(nodeInfo)
 
-        advanceTime()
+            advanceTime()
 
-        // We need the WatchService to report a change and that might not happen immediately.
-        eventually<AssertionError, Unit>(5.seconds) {
+            // We need the WatchService to report a change and that might not happen immediately.
+            testSubscriber.awaitValueCount(1, 5, TimeUnit.SECONDS)
             // The same folder can be reported more than once, so take unique values.
             val readNodes = testSubscriber.onNextEvents.distinct()
-            assertEquals(1, readNodes.size)
             assertEquals(nodeInfo, readNodes.first())
+        } finally {
+            subscription.unsubscribe()
         }
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
index 83121ba969..7d8542d314 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
@@ -1,14 +1,8 @@
 package net.corda.node.services.network
 
 import net.corda.cordform.CordformNode
-import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.SignedData
-import net.corda.core.internal.createDirectories
-import net.corda.core.internal.div
-import net.corda.core.internal.isDirectory
-import net.corda.core.internal.isRegularFile
-import net.corda.core.internal.list
-import net.corda.core.internal.readAll
+import net.corda.core.internal.*
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.services.KeyManagementService
 import net.corda.core.serialization.deserialize
@@ -17,6 +11,7 @@ import net.corda.core.utilities.loggerFor
 import rx.Observable
 import rx.Scheduler
 import rx.schedulers.Schedulers
+import java.nio.file.Files
 import java.nio.file.Path
 import java.util.concurrent.TimeUnit
 import kotlin.streams.toList
@@ -52,11 +47,9 @@ class NodeInfoWatcher(private val nodePath: Path,
             try {
                 path.createDirectories()
                 val serializedBytes = nodeInfo.serialize()
-                val regSig = keyManager.sign(serializedBytes.bytes,
-                        nodeInfo.legalIdentities.first().owningKey)
+                val regSig = keyManager.sign(serializedBytes.bytes, nodeInfo.legalIdentities.first().owningKey)
                 val signedData = SignedData(serializedBytes, regSig)
-                val file = (path / ("nodeInfo-" + SecureHash.sha256(serializedBytes.bytes).toString())).toFile()
-                file.writeBytes(signedData.serialize().bytes)
+                signedData.serialize().open().copyTo(path / "nodeInfo-${serializedBytes.hash}")
             } catch (e: Exception) {
                 logger.warn("Couldn't write node info to file", e)
             }

From 7ad754fe782d5f34ac3ad01323c9d5029c540a2f Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Mon, 9 Oct 2017 17:03:04 +0100
Subject: [PATCH 134/185] Add signature exchange to transaction key flow
 (#1417)

Require a signature on a deterministic data blob (which includes X.500 name and public key) when exchanging new confidential identities, in order to ensure that the owner of the key pair wants it to represent the specified name, not just that the certificate owner states the key represents the given identity.
---
 .../corda/confidential/SwapIdentitiesFlow.kt  | 74 ++++++++++++++++--
 .../confidential/SwapIdentitiesHandler.kt     | 16 +++-
 .../confidential/SwapIdentitiesFlowTests.kt   | 75 +++++++++++++++++--
 .../net/corda/core/crypto/DigitalSignature.kt |  1 +
 .../core/serialization/SerializationAPI.kt    |  1 -
 5 files changed, 148 insertions(+), 19 deletions(-)

diff --git a/confidential-identities/src/main/kotlin/net/corda/confidential/SwapIdentitiesFlow.kt b/confidential-identities/src/main/kotlin/net/corda/confidential/SwapIdentitiesFlow.kt
index 7257620d19..575c1f8d52 100644
--- a/confidential-identities/src/main/kotlin/net/corda/confidential/SwapIdentitiesFlow.kt
+++ b/confidential-identities/src/main/kotlin/net/corda/confidential/SwapIdentitiesFlow.kt
@@ -1,15 +1,32 @@
 package net.corda.confidential
 
 import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.crypto.DigitalSignature
+import net.corda.core.flows.FlowException
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.InitiatingFlow
 import net.corda.core.flows.StartableByRPC
 import net.corda.core.identity.AnonymousParty
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.identity.PartyAndCertificate
+import net.corda.core.internal.toX509CertHolder
 import net.corda.core.node.services.IdentityService
+import net.corda.core.serialization.CordaSerializable
+import net.corda.core.serialization.SerializedBytes
+import net.corda.core.serialization.deserialize
+import net.corda.core.serialization.serialize
 import net.corda.core.utilities.ProgressTracker
 import net.corda.core.utilities.unwrap
+import org.bouncycastle.asn1.DERSet
+import org.bouncycastle.asn1.pkcs.CertificationRequestInfo
+import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo
+import java.io.ByteArrayOutputStream
+import java.nio.charset.Charset
+import java.security.PublicKey
+import java.security.SignatureException
+import java.security.cert.CertPath
+import java.util.*
 
 /**
  * Very basic flow which generates new confidential identities for parties in a transaction and exchanges the transaction
@@ -27,8 +44,32 @@ class SwapIdentitiesFlow(private val otherParty: Party,
         object AWAITING_KEY : ProgressTracker.Step("Awaiting key")
 
         fun tracker() = ProgressTracker(AWAITING_KEY)
-        fun validateAndRegisterIdentity(identityService: IdentityService, otherSide: Party, anonymousOtherSide: PartyAndCertificate): PartyAndCertificate {
-            require(anonymousOtherSide.name == otherSide.name)
+        /**
+         * Generate the determinstic data blob the confidential identity's key holder signs to indicate they want to
+         * represent the subject named in the X.509 certificate. Note that this is never actually sent between nodes,
+         * but only the signature is sent. The blob is built independently on each node and the received signature
+         * verified against the expected blob, rather than exchanging the blob.
+         */
+        fun buildDataToSign(confidentialIdentity: PartyAndCertificate): ByteArray {
+            val certOwnerAssert = CertificateOwnershipAssertion(confidentialIdentity.name, confidentialIdentity.owningKey)
+            return certOwnerAssert.serialize().bytes
+        }
+
+        @Throws(SwapIdentitiesException::class)
+        fun validateAndRegisterIdentity(identityService: IdentityService,
+                                        otherSide: Party,
+                                        anonymousOtherSideBytes: PartyAndCertificate,
+                                        sigBytes: DigitalSignature): PartyAndCertificate {
+            val anonymousOtherSide: PartyAndCertificate = anonymousOtherSideBytes
+            if (anonymousOtherSide.name != otherSide.name) {
+                throw SwapIdentitiesException("Certificate subject must match counterparty's well known identity.")
+            }
+            val signature = DigitalSignature.WithKey(anonymousOtherSide.owningKey, sigBytes.bytes)
+            try {
+                signature.verify(buildDataToSign(anonymousOtherSideBytes))
+            } catch(ex: SignatureException) {
+                throw SwapIdentitiesException("Signature does not match the expected identity ownership assertion.", ex)
+            }
             // Validate then store their identity so that we can prove the key in the transaction is owned by the
             // counterparty.
             identityService.verifyAndRegisterIdentity(anonymousOtherSide)
@@ -40,6 +81,7 @@ class SwapIdentitiesFlow(private val otherParty: Party,
     override fun call(): LinkedHashMap<Party, AnonymousParty> {
         progressTracker.currentStep = AWAITING_KEY
         val legalIdentityAnonymous = serviceHub.keyManagementService.freshKeyAndCert(ourIdentityAndCert, revocationEnabled)
+        val serializedIdentity = SerializedBytes<PartyAndCertificate>(legalIdentityAnonymous.serialize().bytes)
 
         // Special case that if we're both parties, a single identity is generated
         val identities = LinkedHashMap<Party, AnonymousParty>()
@@ -47,13 +89,33 @@ class SwapIdentitiesFlow(private val otherParty: Party,
             identities.put(otherParty, legalIdentityAnonymous.party.anonymise())
         } else {
             val otherSession = initiateFlow(otherParty)
-            val anonymousOtherSide = otherSession.sendAndReceive<PartyAndCertificate>(legalIdentityAnonymous).unwrap { confidentialIdentity ->
-                validateAndRegisterIdentity(serviceHub.identityService, otherSession.counterparty, confidentialIdentity)
-            }
+            val data = buildDataToSign(legalIdentityAnonymous)
+            val ourSig: DigitalSignature.WithKey = serviceHub.keyManagementService.sign(data, legalIdentityAnonymous.owningKey)
+            val ourIdentWithSig = IdentityWithSignature(serializedIdentity, ourSig.withoutKey())
+            val anonymousOtherSide = otherSession.sendAndReceive<IdentityWithSignature>(ourIdentWithSig)
+                    .unwrap { (confidentialIdentityBytes, theirSigBytes) ->
+                        val confidentialIdentity: PartyAndCertificate = confidentialIdentityBytes.bytes.deserialize()
+                        validateAndRegisterIdentity(serviceHub.identityService, otherParty, confidentialIdentity, theirSigBytes)
+                    }
             identities.put(ourIdentity, legalIdentityAnonymous.party.anonymise())
-            identities.put(otherSession.counterparty, anonymousOtherSide.party.anonymise())
+            identities.put(otherParty, anonymousOtherSide.party.anonymise())
         }
         return identities
     }
 
+    @CordaSerializable
+    data class IdentityWithSignature(val identity: SerializedBytes<PartyAndCertificate>, val signature: DigitalSignature)
 }
+
+/**
+ * Data class used only in the context of asserting the owner of the private key for the listed key wants to use it
+ * to represent the named entity. This is pairs with an X.509 certificate (which asserts the signing identity says
+ * the key represents the named entity), but protects against a certificate authority incorrectly claiming others'
+ * keys.
+ */
+@CordaSerializable
+data class CertificateOwnershipAssertion(val x500Name: CordaX500Name,
+                                         val publicKey: PublicKey)
+
+open class SwapIdentitiesException @JvmOverloads constructor(message: String, cause: Throwable? = null)
+    : FlowException(message, cause)
\ No newline at end of file
diff --git a/confidential-identities/src/main/kotlin/net/corda/confidential/SwapIdentitiesHandler.kt b/confidential-identities/src/main/kotlin/net/corda/confidential/SwapIdentitiesHandler.kt
index 753d9a3927..a5a17ccdf8 100644
--- a/confidential-identities/src/main/kotlin/net/corda/confidential/SwapIdentitiesHandler.kt
+++ b/confidential-identities/src/main/kotlin/net/corda/confidential/SwapIdentitiesHandler.kt
@@ -4,6 +4,9 @@ import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.FlowSession
 import net.corda.core.identity.PartyAndCertificate
+import net.corda.core.serialization.SerializedBytes
+import net.corda.core.serialization.deserialize
+import net.corda.core.serialization.serialize
 import net.corda.core.utilities.ProgressTracker
 import net.corda.core.utilities.unwrap
 
@@ -20,9 +23,14 @@ class SwapIdentitiesHandler(val otherSideSession: FlowSession, val revocationEna
     override fun call() {
         val revocationEnabled = false
         progressTracker.currentStep = SENDING_KEY
-        val legalIdentityAnonymous = serviceHub.keyManagementService.freshKeyAndCert(ourIdentityAndCert, revocationEnabled)
-        otherSideSession.sendAndReceive<PartyAndCertificate>(legalIdentityAnonymous).unwrap { confidentialIdentity ->
-            SwapIdentitiesFlow.validateAndRegisterIdentity(serviceHub.identityService, otherSideSession.counterparty, confidentialIdentity)
-        }
+        val ourConfidentialIdentity = serviceHub.keyManagementService.freshKeyAndCert(ourIdentityAndCert, revocationEnabled)
+        val serializedIdentity = SerializedBytes<PartyAndCertificate>(ourConfidentialIdentity.serialize().bytes)
+        val data = SwapIdentitiesFlow.buildDataToSign(ourConfidentialIdentity)
+        val ourSig = serviceHub.keyManagementService.sign(data, ourConfidentialIdentity.owningKey)
+        otherSideSession.sendAndReceive<SwapIdentitiesFlow.IdentityWithSignature>(SwapIdentitiesFlow.IdentityWithSignature(serializedIdentity, ourSig.withoutKey()))
+                .unwrap { (theirConfidentialIdentityBytes, theirSigBytes) ->
+                    val theirConfidentialIdentity = theirConfidentialIdentityBytes.deserialize()
+                    SwapIdentitiesFlow.validateAndRegisterIdentity(serviceHub.identityService, otherSideSession.counterparty, theirConfidentialIdentity, theirSigBytes)
+                }
     }
 }
\ No newline at end of file
diff --git a/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt b/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
index 5554b8ea34..55e9ef9d26 100644
--- a/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
+++ b/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
@@ -4,16 +4,10 @@ import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.AnonymousParty
 import net.corda.core.identity.Party
 import net.corda.core.utilities.getOrThrow
-import net.corda.testing.ALICE
-import net.corda.testing.BOB
-import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.chooseIdentity
+import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import org.junit.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertNotEquals
-import kotlin.test.assertTrue
+import kotlin.test.*
 
 class SwapIdentitiesFlowTests {
     @Test
@@ -52,4 +46,69 @@ class SwapIdentitiesFlowTests {
 
         mockNet.stopNodes()
     }
+
+    /**
+     * Check that flow is actually validating the name on the certificate presented by the counterparty.
+     */
+    @Test
+    fun `verifies identity name`() {
+        // We run this in parallel threads to help catch any race conditions that may exist.
+        val mockNet = MockNetwork(false, true)
+
+        // Set up values we'll need
+        val notaryNode = mockNet.createNotaryNode(DUMMY_NOTARY.name)
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val bobNode = mockNet.createPartyNode(BOB.name)
+        val bob: Party = bobNode.services.myInfo.chooseIdentity()
+        val notBob = notaryNode.database.transaction {
+            notaryNode.services.keyManagementService.freshKeyAndCert(notaryNode.services.myInfo.chooseIdentityAndCert(), false)
+        }
+        val sigData = SwapIdentitiesFlow.buildDataToSign(notBob)
+        val signature = notaryNode.services.keyManagementService.sign(sigData, notBob.owningKey)
+        assertFailsWith<SwapIdentitiesException>("Certificate subject must match counterparty's well known identity.") {
+            SwapIdentitiesFlow.validateAndRegisterIdentity(aliceNode.services.identityService, bob, notBob, signature.withoutKey())
+        }
+
+        mockNet.stopNodes()
+    }
+
+    /**
+     * Check that flow is actually validating its the signature presented by the counterparty.
+     */
+    @Test
+    fun `verifies signature`() {
+        // We run this in parallel threads to help catch any race conditions that may exist.
+        val mockNet = MockNetwork(false, true)
+
+        // Set up values we'll need
+        val notaryNode = mockNet.createNotaryNode(DUMMY_NOTARY.name)
+        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val bobNode = mockNet.createPartyNode(BOB.name)
+        val bob: Party = bobNode.services.myInfo.chooseIdentity()
+        // Check that the wrong signature is rejected
+        notaryNode.database.transaction {
+            notaryNode.services.keyManagementService.freshKeyAndCert(notaryNode.services.myInfo.chooseIdentityAndCert(), false)
+        }.let { anonymousNotary ->
+            val sigData = SwapIdentitiesFlow.buildDataToSign(anonymousNotary)
+            val signature = notaryNode.services.keyManagementService.sign(sigData, anonymousNotary.owningKey)
+            assertFailsWith<SwapIdentitiesException>("Signature does not match the given identity and nonce") {
+                SwapIdentitiesFlow.validateAndRegisterIdentity(aliceNode.services.identityService, bob, anonymousNotary, signature.withoutKey())
+            }
+        }
+        // Check that the right signing key, but wrong identity is rejected
+        val anonymousAlice = aliceNode.database.transaction {
+            aliceNode.services.keyManagementService.freshKeyAndCert(aliceNode.services.myInfo.chooseIdentityAndCert(), false)
+        }
+        bobNode.database.transaction {
+            bobNode.services.keyManagementService.freshKeyAndCert(bobNode.services.myInfo.chooseIdentityAndCert(), false)
+        }.let { anonymousBob ->
+            val sigData = SwapIdentitiesFlow.buildDataToSign(anonymousAlice)
+            val signature = bobNode.services.keyManagementService.sign(sigData, anonymousBob.owningKey)
+            assertFailsWith<SwapIdentitiesException>("Signature does not match the given identity and nonce.") {
+                SwapIdentitiesFlow.validateAndRegisterIdentity(aliceNode.services.identityService, bob, anonymousBob, signature.withoutKey())
+            }
+        }
+
+        mockNet.stopNodes()
+    }
 }
diff --git a/core/src/main/kotlin/net/corda/core/crypto/DigitalSignature.kt b/core/src/main/kotlin/net/corda/core/crypto/DigitalSignature.kt
index d343913712..0db44ba841 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/DigitalSignature.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/DigitalSignature.kt
@@ -46,5 +46,6 @@ open class DigitalSignature(bytes: ByteArray) : OpaqueBytes(bytes) {
          */
         @Throws(InvalidKeyException::class, SignatureException::class)
         fun isValid(content: ByteArray) = by.isValid(content, this)
+        fun withoutKey() : DigitalSignature = DigitalSignature(this.bytes)
     }
 }
diff --git a/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt b/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
index b0499938ef..f77e3ae122 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
@@ -196,7 +196,6 @@ fun <T : Any> T.serialize(serializationFactory: SerializationFactory = Serializa
  * A type safe wrapper around a byte array that contains a serialised object. You can call [SerializedBytes.deserialize]
  * to get the original object back.
  */
-@Suppress("unused") // Type parameter is just for documentation purposes.
 class SerializedBytes<T : Any>(bytes: ByteArray) : OpaqueBytes(bytes) {
     // It's OK to use lazy here because SerializedBytes is configured to use the ImmutableClassSerializer.
     val hash: SecureHash by lazy { bytes.sha256() }

From 70f3d02ce49a4084edadc16d5140b7bbe8d298d2 Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Mon, 9 Oct 2017 17:14:55 +0100
Subject: [PATCH 135/185] Update docs on how IdentitySyncFlow works (#1816)

---
 docs/source/api-identity.rst | 33 ++++++++++++++++++++-------------
 1 file changed, 20 insertions(+), 13 deletions(-)

diff --git a/docs/source/api-identity.rst b/docs/source/api-identity.rst
index c87b50a45f..fb3a18342e 100644
--- a/docs/source/api-identity.rst
+++ b/docs/source/api-identity.rst
@@ -93,7 +93,8 @@ Identity synchronization flow
 
 When constructing a transaction whose input states reference confidential identities, it is common for other signing
 entities (counterparties) to require to know which well known identities those confidential identities map to. The
-``IdentitySyncFlow`` handles this process, and you can see an example of its use in ``TwoPartyTradeFlow.kt``:
+``IdentitySyncFlow`` handles distribution of a node's confidential identities, and you can see an example of its
+use in ``TwoPartyTradeFlow.kt``:
 
 .. container:: codeset
 
@@ -105,27 +106,33 @@ entities (counterparties) to require to know which well known identities those c
 
 The identity synchronization flow goes through the following key steps:
 
-1. Extract participant identities from all input and output states and remove any well known identities. Required signers
-   on commands are currently ignored as they are presumed to be included in the participants on states, or to be well
-   known identities of services (such as an oracle service).
+1. Extract participant identities from all input and output states. Filter this set down to confidential identities
+   of the flow's well known identity. Required signers on commands are currently ignored as they are presumed to be
+   included in the participants on states, or to be well known identities of services (such as an oracle service).
 2. For each counterparty node, send a list of the public keys of the confidential identities, and receive back a list
    of those the counterparty needs the certificate path for.
 3. Verify the requested list of identities contains only confidential identities in the offered list, and abort otherwise.
 4. Send the requested confidential identities as ``PartyAndCertificate`` instances to the counterparty.
 
-.. note:: ``IdentitySyncFlow`` works on a push basis. The initiating node can only send confidential identities it has
-   the X.509 certificates for, and the remote nodes can only request confidential identities being offered (are
-   referenced in the transaction passed to the initiating flow). There is no standard flow for nodes to collect
+.. note:: ``IdentitySyncFlow`` works on a push basis. Receiving nodes can only request confidential identities being
+   offered by the initiating node. There is no standard flow for nodes to collect
    confidential identities before assembling a transaction, and this is left for individual flows to manage if required.
 
-``IdentitySyncFlow`` will serve all confidential identities in the provided transaction, irrespective of well known
-identity. This is important for more complex transaction cases with 3+ parties, for example:
+``IdentitySyncFlow`` will serve only confidential identities in the provided transaction, limited to those that are
+signed by the well known identity the flow is initiated by. This is done to avoid a risk of a node including
+states it doesn't have the well known identity of participants in, to try convincing one of its counterparties to
+reveal the identity. In case of a more complex transaction where multiple well known identities need confidential
+identities distributed this flow should be run by each node in turn. For example:
 
 * Alice is building the transaction, and provides some input state *x* owned by a confidential identity of Alice
 * Bob provides some input state *y* owned by a confidential identity of Bob
 * Charlie provides some input state *z* owned by a confidential identity of Charlie
 
-Alice may know all of the confidential identities ahead of time, but Bob not know about Charlie's and vice-versa.
-The assembled transaction therefore has three input states *x*, *y* and *z*, for which only Alice possesses certificates
-for all confidential identities. ``IdentitySyncFlow`` must send not just Alice's confidential identity but also any other
-identities in the transaction to the Bob and Charlie.
\ No newline at end of file
+Alice, Bob and Charlie must all run ``IdentitySyncFlow`` to send their involved confidential identities to the other
+parties. For an illustration of the security implications of not requiring this, consider:
+
+1. Alice is building the transaction, and provides some input state *x* owned by a confidential identity of Alice
+2. Bob provides some input state *y* owned by a confidential identity it doesn't know the well known identity of, but
+   Alice does.
+3. Alice runs ``IdentitySyncFlow`` and sends not just their confidential identity, but also the confidential identity
+   in state *y*, violating the privacy model.
\ No newline at end of file

From 747830ff90e959ab81778b15efacb7cc7381349c Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Mon, 9 Oct 2017 17:38:45 +0100
Subject: [PATCH 136/185] Scan API for addition of new abstract methods.
 (#1854)

* Scan API for addition of new abstract methods.
* Make sure we ignore blank lines when counting API changes.
* Add 6 new abstract APIs to our API definition.
---
 .ci/api-current.txt      |  8 ++++++++
 .ci/check-api-changes.sh | 38 +++++++++++++++++++++++++++++++++-----
 2 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/.ci/api-current.txt b/.ci/api-current.txt
index cd28b2719a..6892aeae53 100644
--- a/.ci/api-current.txt
+++ b/.ci/api-current.txt
@@ -465,6 +465,7 @@ public interface net.corda.core.cordapp.Cordapp
   @org.jetbrains.annotations.NotNull public abstract List getRpcFlows()
   @org.jetbrains.annotations.NotNull public abstract List getSchedulableFlows()
   @org.jetbrains.annotations.NotNull public abstract List getSerializationWhitelists()
+  @org.jetbrains.annotations.NotNull public abstract List getServiceFlows()
   @org.jetbrains.annotations.NotNull public abstract List getServices()
 ##
 public final class net.corda.core.cordapp.CordappContext extends java.lang.Object
@@ -1353,6 +1354,7 @@ public interface net.corda.core.messaging.CordaRPCOps extends net.corda.core.mes
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.node.NodeInfo nodeInfo()
   @org.jetbrains.annotations.Nullable public abstract net.corda.core.node.NodeInfo nodeInfoFromParty(net.corda.core.identity.AbstractParty)
   @org.jetbrains.annotations.NotNull public abstract List notaryIdentities()
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party notaryPartyFromX500Name(net.corda.core.identity.CordaX500Name)
   @org.jetbrains.annotations.NotNull public abstract java.io.InputStream openAttachment(net.corda.core.crypto.SecureHash)
   @org.jetbrains.annotations.NotNull public abstract Set partiesFromName(String, boolean)
   @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party partyFromKey(java.security.PublicKey)
@@ -1485,6 +1487,10 @@ public static final class net.corda.core.messaging.StateMachineUpdate$Removed ex
   public int hashCode()
   public String toString()
 ##
+public interface net.corda.core.node.AppServiceHub extends net.corda.core.node.ServiceHub
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.FlowHandle startFlow(net.corda.core.flows.FlowLogic)
+  @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.FlowProgressHandle startTrackedFlow(net.corda.core.flows.FlowLogic)
+##
 public final class net.corda.core.node.NodeInfo extends java.lang.Object
   public <init>(List, List, int, long)
   @org.jetbrains.annotations.NotNull public final List component1()
@@ -1579,10 +1585,12 @@ public interface net.corda.core.node.services.NetworkMapCache
   @org.jetbrains.annotations.Nullable public abstract net.corda.core.node.NodeInfo getNodeByLegalName(net.corda.core.identity.CordaX500Name)
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.concurrent.CordaFuture getNodeReady()
   @org.jetbrains.annotations.NotNull public abstract List getNodesByLegalIdentityKey(java.security.PublicKey)
+  @org.jetbrains.annotations.NotNull public abstract List getNodesByLegalName(net.corda.core.identity.CordaX500Name)
   @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party getNotary(net.corda.core.identity.CordaX500Name)
   @org.jetbrains.annotations.NotNull public abstract List getNotaryIdentities()
   @org.jetbrains.annotations.Nullable public abstract net.corda.core.node.services.PartyInfo getPartyInfo(net.corda.core.identity.Party)
   @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.Party getPeerByLegalName(net.corda.core.identity.CordaX500Name)
+  @org.jetbrains.annotations.Nullable public abstract net.corda.core.identity.PartyAndCertificate getPeerCertificateByLegalName(net.corda.core.identity.CordaX500Name)
   public abstract boolean isNotary(net.corda.core.identity.Party)
   public abstract boolean isValidatingNotary(net.corda.core.identity.Party)
   @org.jetbrains.annotations.NotNull public abstract net.corda.core.messaging.DataFeed track()
diff --git a/.ci/check-api-changes.sh b/.ci/check-api-changes.sh
index e2bd6afddc..7694d995dd 100755
--- a/.ci/check-api-changes.sh
+++ b/.ci/check-api-changes.sh
@@ -11,9 +11,37 @@ if [ ! -f $apiCurrent ]; then
 fi
 
 diffContents=`diff -u $apiCurrent $APIHOME/../build/api/api-corda-*.txt`
-echo "Diff contents: " 
+echo "Diff contents:" 
 echo "$diffContents"
-removals=`echo "$diffContents" | grep "^-\s" | wc -l`
-echo "Number of API removals/changes: "$removals
-echo "Exiting with exit code" $removals
-exit $removals
+echo
+
+# A removed line means that an API was either deleted or modified.
+removals=$(echo "$diffContents" | grep "^-\s")
+removalCount=`grep -v "^$" <<EOF | wc -l
+$removals
+EOF
+`
+
+echo "Number of API removals/changes: "$removalCount
+if [ $removalCount -gt 0 ]; then
+    echo "$removals"
+    echo
+fi
+
+# Adding new abstract methods could also break the API.
+newAbstracts=$(echo "$diffContents" | grep "^+\s" | grep "\(public\|protected\) abstract")
+abstractCount=`grep -v "^$" <<EOF | wc -l
+$newAbstracts
+EOF
+`
+
+echo "Number of new abstract APIs: "$abstractCount
+if [ $abstractCount -gt 0 ]; then
+    echo "$newAbstracts"
+    echo
+fi
+
+badChanges=$(($removalCount + $abstractCount))
+
+echo "Exiting with exit code" $badChanges
+exit $badChanges

From 484cf75420d5cb1ce7e881f9fbd6033fa69ff813 Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Mon, 9 Oct 2017 20:08:08 +0100
Subject: [PATCH 137/185] CORDA-686 - Split Cordapp gradle plugin from
 cordformation (#1817)

Added CorDapp gradle plugin written in Kotlin and bumped the version of gradle plugins to 2.0.0 to reflect that this backwards incompatible change is a part of the on going stabilisation of the Corda gradle plugin suite.
---
 .idea/compiler.xml                            |  4 +
 build.gradle                                  | 21 ++---
 confidential-identities/build.gradle          |  5 +-
 constants.properties                          |  2 +-
 docs/source/changelog.rst                     |  4 +
 docs/source/cordapp-build-systems.rst         |  6 +-
 docs/source/example-code/build.gradle         | 13 ++--
 finance/build.gradle                          |  2 +-
 gradle-plugins/build.gradle                   |  4 +-
 gradle-plugins/cordapp/README.md              | 10 +++
 gradle-plugins/cordapp/build.gradle           | 18 +++++
 .../kotlin/net/corda/plugins/CordappPlugin.kt | 76 +++++++++++++++++++
 .../main/kotlin/net/corda/plugins/Utils.kt    | 17 +++++
 .../net.corda.plugins.cordapp.properties      |  1 +
 gradle-plugins/cordformation/build.gradle     |  7 +-
 .../net/corda/plugins/Cordformation.groovy    | 62 +--------------
 gradle-plugins/settings.gradle                |  1 +
 samples/attachment-demo/build.gradle          |  1 +
 samples/bank-of-corda-demo/build.gradle       |  1 +
 samples/irs-demo/build.gradle                 |  1 +
 samples/notary-demo/build.gradle              |  1 +
 samples/simm-valuation-demo/build.gradle      |  1 +
 samples/trader-demo/build.gradle              |  1 +
 23 files changed, 167 insertions(+), 92 deletions(-)
 create mode 100644 gradle-plugins/cordapp/README.md
 create mode 100644 gradle-plugins/cordapp/build.gradle
 create mode 100644 gradle-plugins/cordapp/src/main/kotlin/net/corda/plugins/CordappPlugin.kt
 create mode 100644 gradle-plugins/cordapp/src/main/kotlin/net/corda/plugins/Utils.kt
 create mode 100644 gradle-plugins/cordapp/src/main/resources/META-INF/gradle-plugins/net.corda.plugins.cordapp.properties

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index 2d6467076b..3516efcb93 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -2,6 +2,8 @@
 <project version="4">
   <component name="CompilerConfiguration">
     <bytecodeTargetLevel target="1.8">
+      <module name="api-scanner_main" target="1.8" />
+      <module name="api-scanner_test" target="1.8" />
       <module name="attachment-demo_integrationTest" target="1.8" />
       <module name="attachment-demo_main" target="1.8" />
       <module name="attachment-demo_test" target="1.8" />
@@ -19,6 +21,8 @@
       <module name="corda-webserver_integrationTest" target="1.8" />
       <module name="corda-webserver_main" target="1.8" />
       <module name="corda-webserver_test" target="1.8" />
+      <module name="cordapp_main" target="1.8" />
+      <module name="cordapp_test" target="1.8" />
       <module name="cordform-common_main" target="1.8" />
       <module name="cordform-common_test" target="1.8" />
       <module name="cordformation_main" target="1.8" />
diff --git a/build.gradle b/build.gradle
index bf12b2ff1f..9b19ced795 100644
--- a/build.gradle
+++ b/build.gradle
@@ -59,6 +59,7 @@ buildscript {
         classpath "net.corda.plugins:publish-utils:$gradle_plugins_version"
         classpath "net.corda.plugins:quasar-utils:$gradle_plugins_version"
         classpath "net.corda.plugins:cordformation:$gradle_plugins_version"
+        classpath "net.corda.plugins:cordapp:$gradle_plugins_version"
         classpath "net.corda.plugins:api-scanner:$gradle_plugins_version"
         classpath 'com.github.ben-manes:gradle-versions-plugin:0.15.0'
         classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version"
@@ -180,21 +181,21 @@ repositories {
 
 // Required for building out the fat JAR.
 dependencies {
-    cordaCompile project(':node')
+    compile project(':node')
     compile "com.google.guava:guava:$guava_version"
 
     // Set to corda compile to ensure it exists now deploy nodes no longer relies on build
-    cordaCompile project(path: ":node:capsule", configuration: 'runtimeArtifacts')
-    cordaCompile project(path: ":webserver:webcapsule", configuration: 'runtimeArtifacts')
+    compile project(path: ":node:capsule", configuration: 'runtimeArtifacts')
+    compile project(path: ":webserver:webcapsule", configuration: 'runtimeArtifacts')
 
     // For the buildCordappDependenciesJar task
-    cordaRuntime project(':client:jfx')
-    cordaRuntime project(':client:mock')
-    cordaRuntime project(':client:rpc')
-    cordaRuntime project(':core')
-    cordaRuntime project(':confidential-identities')
-    cordaRuntime project(':finance')
-    cordaRuntime project(':webserver')
+    runtime project(':client:jfx')
+    runtime project(':client:mock')
+    runtime project(':client:rpc')
+    runtime project(':core')
+    runtime project(':confidential-identities')
+    runtime project(':finance')
+    runtime project(':webserver')
     testCompile project(':test-utils')
 }
 
diff --git a/confidential-identities/build.gradle b/confidential-identities/build.gradle
index 04212b3df1..c6a29c0d2e 100644
--- a/confidential-identities/build.gradle
+++ b/confidential-identities/build.gradle
@@ -6,15 +6,12 @@ apply plugin: 'kotlin'
 apply plugin: CanonicalizerPlugin
 apply plugin: 'net.corda.plugins.publish-utils'
 apply plugin: 'net.corda.plugins.quasar-utils'
-apply plugin: 'net.corda.plugins.cordformation'
 apply plugin: 'com.jfrog.artifactory'
 
 description 'Corda Experimental Confidential Identities'
 
 dependencies {
-    // Note the :confidential-identities module is a CorDapp in its own right
-    // and CorDapps using :confidential-identities features should use 'cordapp' not 'compile' linkage.
-    cordaCompile project(':core')
+    compile project(':core')
 
     // Quasar, for suspendable fibres.
     compileOnly "co.paralleluniverse:quasar-core:$quasar_version:jdk8"
diff --git a/constants.properties b/constants.properties
index dd42901d00..165810dcd2 100644
--- a/constants.properties
+++ b/constants.properties
@@ -1,4 +1,4 @@
-gradlePluginsVersion=1.1.2
+gradlePluginsVersion=2.0.0
 kotlinVersion=1.1.50
 guavaVersion=21.0
 bouncycastleVersion=1.57
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index 0955876373..c6bffa9c85 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -8,6 +8,10 @@ UNRELEASED
 ----------
 * ``FlowLogic`` now exposes a series of function called ``receiveAll(...)`` allowing to join ``receive(...)`` instructions.
 
+* The ``Cordformation`` gradle plugin has been split into ``cordformation`` and ``cordapp``. The former builds and
+  deploys nodes for development and testing, the latter turns a project into a cordapp project that generates JARs in
+  the standard CorDapp format.   
+
 * ``Cordform`` and node identity generation
   * Cordform may not specify a value for ``NetworkMap``, when that happens, during the task execution the following happens:
     1. Each node is started and its signed serialized NodeInfo is written to disk in the node base directory.
diff --git a/docs/source/cordapp-build-systems.rst b/docs/source/cordapp-build-systems.rst
index 398bfa0dc1..016d741bf2 100644
--- a/docs/source/cordapp-build-systems.rst
+++ b/docs/source/cordapp-build-systems.rst
@@ -16,7 +16,7 @@ For example if your Cordapp depends on ``corda-core``, ``your-other-cordapp`` an
 JAR will contain all classes and resources from the ``apache-commons`` JAR and its dependencies and *nothing* from the
 other two JARs.
 
-.. note:: The rest of this tutorial assumes you are using ``gradle``, the ``cordformation`` plugin and have forked from
+.. note:: The rest of this tutorial assumes you are using ``gradle``, the ``cordapp`` plugin and have forked from
           one of our cordapp templates.
 
 The ``jar`` task included by default in the cordapp templates will automatically build your JAR in this format as long
@@ -40,7 +40,7 @@ To make use of the Corda test facilities you must;
 
 .. warning:: Never include ``corda-test-utils`` as a ``compile`` or ``cordaCompile`` dependency.
 
-These configurations work by the ``cordformation`` plugin adding ``cordaCompile`` as a new configuration that ``compile``
+These configurations work by the ``cordapp`` plugin adding ``cordaCompile`` as a new configuration that ``compile``
 extends from, and ``cordaRuntime`` which ``runtime`` extends from.
 
 Choosing your Corda version
@@ -57,7 +57,7 @@ can find the latest published version of both here: https://bintray.com/r3/corda
 
 ``corda_gradle_plugins_versions`` are given in the form ``major.minor.patch``. You should use the same ``major`` and
 ``minor`` versions as the Corda version you are using, and the latest ``patch`` version. A list of all the available
-versions can be found here: https://bintray.com/r3/corda/cordformation.
+versions can be found here: https://bintray.com/r3/corda/cordapp.
 
 In certain cases, you may also wish to build against the unstable Master branch. See :doc:`building-against-master`.
 
diff --git a/docs/source/example-code/build.gradle b/docs/source/example-code/build.gradle
index 6709d9fcbe..ae0b57fc34 100644
--- a/docs/source/example-code/build.gradle
+++ b/docs/source/example-code/build.gradle
@@ -1,6 +1,7 @@
 apply plugin: 'kotlin'
 apply plugin: 'application'
 apply plugin: 'net.corda.plugins.cordformation'
+apply plugin: 'net.corda.plugins.cordapp'
 apply plugin: 'net.corda.plugins.quasar-utils'
 
 repositories {
@@ -30,9 +31,9 @@ sourceSets {
 compileTestJava.dependsOn tasks.getByPath(':node:capsule:buildCordaJAR')
 
 dependencies {
-    cordaCompile project(':core')
-    cordaCompile project(':client:jfx')
-    cordaCompile project(':node-driver')
+    compile project(':core')
+    compile project(':client:jfx')
+    compile project(':node-driver')
     testCompile project(':verifier')
     testCompile project(':test-utils')
 
@@ -42,11 +43,11 @@ dependencies {
         exclude group: "junit"
     }
 
-    cordaCompile project(path: ":node:capsule", configuration: 'runtimeArtifacts')
-    cordaCompile project(path: ":webserver:webcapsule", configuration: 'runtimeArtifacts')
+    compile project(path: ":node:capsule", configuration: 'runtimeArtifacts')
+    compile project(path: ":webserver:webcapsule", configuration: 'runtimeArtifacts')
 
     // Corda Plugins: dependent flows and services
-    cordapp project(':finance')
+    compile project(':finance')
 }
 
 mainClassName = "net.corda.docs.ClientRpcTutorialKt"
diff --git a/finance/build.gradle b/finance/build.gradle
index 7ded74b45d..3386d94b40 100644
--- a/finance/build.gradle
+++ b/finance/build.gradle
@@ -5,7 +5,7 @@ apply plugin: 'kotlin-jpa'
 apply plugin: CanonicalizerPlugin
 apply plugin: 'net.corda.plugins.publish-utils'
 apply plugin: 'net.corda.plugins.quasar-utils'
-apply plugin: 'net.corda.plugins.cordformation'
+apply plugin: 'net.corda.plugins.cordapp'
 apply plugin: 'com.jfrog.artifactory'
 
 description 'Corda finance modules'
diff --git a/gradle-plugins/build.gradle b/gradle-plugins/build.gradle
index acfdbb2b05..88169c215c 100644
--- a/gradle-plugins/build.gradle
+++ b/gradle-plugins/build.gradle
@@ -10,6 +10,7 @@ buildscript {
     ext.gradle_plugins_version = constants.getProperty("gradlePluginsVersion")
     ext.bouncycastle_version = constants.getProperty("bouncycastleVersion")
     ext.typesafe_config_version = constants.getProperty("typesafeConfigVersion")
+    ext.kotlin_version = constants.getProperty("kotlinVersion")
 
     repositories {
         mavenLocal()
@@ -19,6 +20,7 @@ buildscript {
     dependencies {
         classpath "net.corda.plugins:publish-utils:$gradle_plugins_version"
         classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.7.3'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
     }
 }
 
@@ -39,7 +41,7 @@ bintrayConfig {
     projectUrl = 'https://github.com/corda/corda'
     gpgSign = true
     gpgPassphrase = System.getenv('CORDA_BINTRAY_GPG_PASSPHRASE')
-    publications = ['cordformation', 'quasar-utils', 'cordform-common', 'api-scanner']
+    publications = ['cordformation', 'quasar-utils', 'cordform-common', 'api-scanner', 'cordapp']
     license {
         name = 'Apache-2.0'
         url = 'https://www.apache.org/licenses/LICENSE-2.0'
diff --git a/gradle-plugins/cordapp/README.md b/gradle-plugins/cordapp/README.md
new file mode 100644
index 0000000000..6b0cebe690
--- /dev/null
+++ b/gradle-plugins/cordapp/README.md
@@ -0,0 +1,10 @@
+# Cordapp Gradle Plugin
+
+## Purpose
+
+To transform any project this plugin is applied to into a cordapp project that generates a cordapp JAR.
+
+## Effects
+
+Will modify the default JAR task to create a CorDapp format JAR instead [see here](https://docs.corda.net/cordapp-build-systems.html) 
+for more information.
\ No newline at end of file
diff --git a/gradle-plugins/cordapp/build.gradle b/gradle-plugins/cordapp/build.gradle
new file mode 100644
index 0000000000..dc284faca1
--- /dev/null
+++ b/gradle-plugins/cordapp/build.gradle
@@ -0,0 +1,18 @@
+apply plugin: 'kotlin'
+apply plugin: 'net.corda.plugins.publish-utils'
+
+description 'Turns a project into a cordapp project that produces cordapp fat JARs'
+
+repositories {
+    mavenCentral()
+    jcenter()
+}
+
+dependencies {
+    compile gradleApi()
+    compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"
+}
+
+publish {
+    name project.name
+}
\ No newline at end of file
diff --git a/gradle-plugins/cordapp/src/main/kotlin/net/corda/plugins/CordappPlugin.kt b/gradle-plugins/cordapp/src/main/kotlin/net/corda/plugins/CordappPlugin.kt
new file mode 100644
index 0000000000..ce65e18e5f
--- /dev/null
+++ b/gradle-plugins/cordapp/src/main/kotlin/net/corda/plugins/CordappPlugin.kt
@@ -0,0 +1,76 @@
+package net.corda.plugins
+
+import org.gradle.api.*
+import org.gradle.api.artifacts.*
+import org.gradle.jvm.tasks.Jar
+import java.io.File
+
+/**
+ * The Cordapp plugin will turn a project into a cordapp project which builds cordapp JARs with the correct format
+ * and with the information needed to run on Corda.
+ */
+class CordappPlugin : Plugin<Project> {
+    override fun apply(project: Project) {
+        project.logger.info("Configuring ${project.name} as a cordapp")
+
+        Utils.createCompileConfiguration("cordapp", project)
+        Utils.createCompileConfiguration("cordaCompile", project)
+
+        val configuration: Configuration = project.configurations.create("cordaRuntime")
+        configuration.isTransitive = false
+        project.configurations.single { it.name == "runtime" }.extendsFrom(configuration)
+
+        configureCordappJar(project)
+    }
+
+    /**
+     * Configures this project's JAR as a Cordapp JAR
+     */
+    private fun configureCordappJar(project: Project) {
+        // Note: project.afterEvaluate did not have full dependency resolution completed, hence a task is used instead
+        val task = project.task("configureCordappFatJar")
+        val jarTask = project.tasks.single { it.name == "jar" } as Jar
+        task.doLast {
+            jarTask.from(getDirectNonCordaDependencies(project).map { project.zipTree(it)}).apply {
+                exclude("META-INF/*.SF")
+                exclude("META-INF/*.DSA")
+                exclude("META-INF/*.RSA")
+            }
+        }
+        jarTask.dependsOn(task)
+    }
+
+    private fun getDirectNonCordaDependencies(project: Project): Set<File> {
+        project.logger.info("Finding direct non-corda dependencies for inclusion in CorDapp JAR")
+        val excludes = listOf(
+                mapOf("group" to "org.jetbrains.kotlin", "name" to "kotlin-stdlib"),
+                mapOf("group" to "org.jetbrains.kotlin", "name" to "kotlin-stdlib-jre8"),
+                mapOf("group" to "org.jetbrains.kotlin", "name" to "kotlin-reflect"),
+                mapOf("group" to "co.paralleluniverse", "name" to "quasar-core")
+        )
+
+        val runtimeConfiguration = project.configuration("runtime")
+        // The direct dependencies of this project
+        val excludeDeps = project.configuration("cordapp").allDependencies +
+                project.configuration("cordaCompile").allDependencies +
+                project.configuration("cordaRuntime").allDependencies
+        val directDeps = runtimeConfiguration.allDependencies - excludeDeps
+        // We want to filter out anything Corda related or provided by Corda, like kotlin-stdlib and quasar
+        val filteredDeps = directDeps.filter { dep ->
+            excludes.none { exclude -> (exclude["group"] == dep.group) && (exclude["name"] == dep.name) }
+        }
+        filteredDeps.forEach {
+            // net.corda or com.r3.corda.enterprise may be a core dependency which shouldn't be included in this cordapp so give a warning
+            if ((it.group.startsWith("net.corda.") || it.group.startsWith("com.r3.corda.enterprise."))) {
+                project.logger.warn("You appear to have included a Corda platform component ($it) using a 'compile' or 'runtime' dependency." +
+                        "This can cause node stability problems. Please use 'corda' instead." +
+                        "See http://docs.corda.net/cordapp-build-systems.html")
+            } else {
+                project.logger.info("Including dependency in CorDapp JAR: $it")
+            }
+        }
+        return filteredDeps.map { runtimeConfiguration.files(it) }.flatten().toSet()
+    }
+
+    private fun Project.configuration(name: String): Configuration = configurations.single { it.name == name }
+}
diff --git a/gradle-plugins/cordapp/src/main/kotlin/net/corda/plugins/Utils.kt b/gradle-plugins/cordapp/src/main/kotlin/net/corda/plugins/Utils.kt
new file mode 100644
index 0000000000..33e552ca7d
--- /dev/null
+++ b/gradle-plugins/cordapp/src/main/kotlin/net/corda/plugins/Utils.kt
@@ -0,0 +1,17 @@
+package net.corda.plugins
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+
+class Utils {
+    companion object {
+        @JvmStatic
+        fun createCompileConfiguration(name: String, project: Project) {
+            if(!project.configurations.any { it.name == name }) {
+                val configuration = project.configurations.create(name)
+                configuration.isTransitive = false
+                project.configurations.single { it.name == "compile" }.extendsFrom(configuration)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/gradle-plugins/cordapp/src/main/resources/META-INF/gradle-plugins/net.corda.plugins.cordapp.properties b/gradle-plugins/cordapp/src/main/resources/META-INF/gradle-plugins/net.corda.plugins.cordapp.properties
new file mode 100644
index 0000000000..90871e27c8
--- /dev/null
+++ b/gradle-plugins/cordapp/src/main/resources/META-INF/gradle-plugins/net.corda.plugins.cordapp.properties
@@ -0,0 +1 @@
+implementation-class=net.corda.plugins.CordappPlugin
diff --git a/gradle-plugins/cordformation/build.gradle b/gradle-plugins/cordformation/build.gradle
index 414aa34b30..828647d434 100644
--- a/gradle-plugins/cordformation/build.gradle
+++ b/gradle-plugins/cordformation/build.gradle
@@ -1,10 +1,4 @@
 buildscript {
-    // For sharing constants between builds
-    Properties constants = new Properties()
-    file("$projectDir/../../constants.properties").withInputStream { constants.load(it) }
-
-    ext.kotlin_version = constants.getProperty("kotlinVersion")
-
     repositories {
         mavenCentral()
     }
@@ -41,6 +35,7 @@ sourceSets {
 dependencies {
     compile gradleApi()
     compile localGroovy()
+    compile project(":cordapp")
 
     noderunner "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"
 
diff --git a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordformation.groovy b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordformation.groovy
index 2fe24a7933..eeb4443801 100644
--- a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordformation.groovy
+++ b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordformation.groovy
@@ -9,40 +9,6 @@ import org.gradle.api.artifacts.Configuration
  * testing, and debugging. It will prepopulate several fields in the configuration and create a simple node runner.
  */
 class Cordformation implements Plugin<Project> {
-    void apply(Project project) {
-        createCompileConfiguration("cordapp", project)
-        createCompileConfiguration("cordaCompile", project)
-
-        Configuration configuration = project.configurations.create("cordaRuntime")
-        configuration.transitive = false
-        project.configurations.runtime.extendsFrom configuration
-
-        configureCordappJar(project)
-    }
-
-    private void createCompileConfiguration(String name, Project project) {
-        Configuration configuration = project.configurations.create(name)
-        configuration.transitive = false
-        project.configurations.compile.extendsFrom configuration
-    }
-
-    /**
-     * Configures this project's JAR as a Cordapp JAR
-     */
-    private void configureCordappJar(Project project) {
-        // Note: project.afterEvaluate did not have full dependency resolution completed, hence a task is used instead
-        def task = project.task('configureCordappFatJar') {
-            doLast {
-                project.tasks.jar.from(getDirectNonCordaDependencies(project).collect { project.zipTree(it)}) {
-                    exclude "META-INF/*.SF"
-                    exclude "META-INF/*.DSA"
-                    exclude "META-INF/*.RSA"
-                }
-            }
-        }
-        project.tasks.jar.dependsOn task
-    }
-
     /**
      * Gets a resource file from this plugin's JAR file.
      *
@@ -56,31 +22,7 @@ class Cordformation implements Plugin<Project> {
         }, filePathInJar).asFile()
     }
 
-    private static Set<File> getDirectNonCordaDependencies(Project project) {
-        def excludes = [
-                [group: 'org.jetbrains.kotlin', name: 'kotlin-stdlib'],
-                [group: 'org.jetbrains.kotlin', name: 'kotlin-stdlib-jre8'],
-                [group: 'org.jetbrains.kotlin', name: 'kotlin-reflect'],
-                [group: 'co.paralleluniverse', name: 'quasar-core']
-        ]
-
-        project.with {
-            // The direct dependencies of this project
-            def excludeDeps = configurations.cordapp.allDependencies + configurations.cordaCompile.allDependencies + configurations.cordaRuntime.allDependencies
-            def directDeps = configurations.runtime.allDependencies - excludeDeps
-            // We want to filter out anything Corda related or provided by Corda, like kotlin-stdlib and quasar
-            def filteredDeps = directDeps.findAll { excludes.collect { exclude -> (exclude.group == it.group) && (exclude.name == it.name) }.findAll { it }.isEmpty() }
-            filteredDeps.each {
-                // net.corda or com.r3.corda.enterprise may be a core dependency which shouldn't be included in this cordapp so give a warning
-                if (it.group && (it.group.startsWith('net.corda.') || it.group.startsWith('com.r3.corda.enterprise.'))) {
-                    logger.warn("You appear to have included a Corda platform component ($it) using a 'compile' or 'runtime' dependency." +
-                                "This can cause node stability problems. Please use 'corda' instead." +
-                                "See http://docs.corda.net/cordapp-build-systems.html")
-                } else {
-                    logger.info("Including dependency in CorDapp JAR: $it")
-                }
-            }
-            return filteredDeps.collect { configurations.runtime.files it }.flatten().toSet()
-        }
+    void apply(Project project) {
+        Utils.createCompileConfiguration("cordapp", project)
     }
 }
diff --git a/gradle-plugins/settings.gradle b/gradle-plugins/settings.gradle
index 64349cda39..995cd8c899 100644
--- a/gradle-plugins/settings.gradle
+++ b/gradle-plugins/settings.gradle
@@ -4,3 +4,4 @@ include 'quasar-utils'
 include 'cordformation'
 include 'cordform-common'
 include 'api-scanner'
+include 'cordapp'
\ No newline at end of file
diff --git a/samples/attachment-demo/build.gradle b/samples/attachment-demo/build.gradle
index 379fcf6af8..5fa296e26d 100644
--- a/samples/attachment-demo/build.gradle
+++ b/samples/attachment-demo/build.gradle
@@ -3,6 +3,7 @@ apply plugin: 'kotlin'
 apply plugin: 'idea'
 apply plugin: 'net.corda.plugins.quasar-utils'
 apply plugin: 'net.corda.plugins.publish-utils'
+apply plugin: 'net.corda.plugins.cordapp'
 apply plugin: 'net.corda.plugins.cordformation'
 apply plugin: 'maven-publish'
 
diff --git a/samples/bank-of-corda-demo/build.gradle b/samples/bank-of-corda-demo/build.gradle
index c673a10da1..043ead8c0b 100644
--- a/samples/bank-of-corda-demo/build.gradle
+++ b/samples/bank-of-corda-demo/build.gradle
@@ -3,6 +3,7 @@ apply plugin: 'kotlin'
 apply plugin: 'idea'
 apply plugin: 'net.corda.plugins.quasar-utils'
 apply plugin: 'net.corda.plugins.publish-utils'
+apply plugin: 'net.corda.plugins.cordapp'
 apply plugin: 'net.corda.plugins.cordformation'
 apply plugin: 'maven-publish'
 
diff --git a/samples/irs-demo/build.gradle b/samples/irs-demo/build.gradle
index bc482b26d7..7d1dccfb8d 100644
--- a/samples/irs-demo/build.gradle
+++ b/samples/irs-demo/build.gradle
@@ -3,6 +3,7 @@ apply plugin: 'kotlin'
 apply plugin: 'idea'
 apply plugin: 'net.corda.plugins.quasar-utils'
 apply plugin: 'net.corda.plugins.publish-utils'
+apply plugin: 'net.corda.plugins.cordapp'
 apply plugin: 'net.corda.plugins.cordformation'
 apply plugin: 'maven-publish'
 apply plugin: 'application'
diff --git a/samples/notary-demo/build.gradle b/samples/notary-demo/build.gradle
index fbbaa6a9a7..a13ab70ad8 100644
--- a/samples/notary-demo/build.gradle
+++ b/samples/notary-demo/build.gradle
@@ -5,6 +5,7 @@ apply plugin: 'kotlin'
 apply plugin: 'idea'
 apply plugin: 'net.corda.plugins.quasar-utils'
 apply plugin: 'net.corda.plugins.publish-utils'
+apply plugin: 'net.corda.plugins.cordapp'
 apply plugin: 'net.corda.plugins.cordformation'
 apply plugin: 'maven-publish'
 
diff --git a/samples/simm-valuation-demo/build.gradle b/samples/simm-valuation-demo/build.gradle
index ffce26eb4f..ec982a20a7 100644
--- a/samples/simm-valuation-demo/build.gradle
+++ b/samples/simm-valuation-demo/build.gradle
@@ -7,6 +7,7 @@ apply plugin: 'kotlin'
 apply plugin: 'idea'
 apply plugin: 'net.corda.plugins.quasar-utils'
 apply plugin: 'net.corda.plugins.publish-utils'
+apply plugin: 'net.corda.plugins.cordapp'
 apply plugin: 'net.corda.plugins.cordformation'
 apply plugin: 'maven-publish'
 
diff --git a/samples/trader-demo/build.gradle b/samples/trader-demo/build.gradle
index 5d6f861e8a..5d0a57663e 100644
--- a/samples/trader-demo/build.gradle
+++ b/samples/trader-demo/build.gradle
@@ -3,6 +3,7 @@ apply plugin: 'kotlin'
 apply plugin: 'idea'
 apply plugin: 'net.corda.plugins.quasar-utils'
 apply plugin: 'net.corda.plugins.publish-utils'
+apply plugin: 'net.corda.plugins.cordapp'
 apply plugin: 'net.corda.plugins.cordformation'
 apply plugin: 'maven-publish'
 

From d1db35c344d193b8352601ee879cfc2999cb7ffb Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Tue, 10 Oct 2017 09:25:45 +0100
Subject: [PATCH 138/185] Removes unnecessary @JVMOverloads annotation.

---
 .../kotlin/net/corda/core/transactions/TransactionBuilder.kt     | 1 -
 1 file changed, 1 deletion(-)

diff --git a/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt b/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt
index 847bdfc31b..b0149dce8d 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/TransactionBuilder.kt
@@ -125,7 +125,6 @@ open class TransactionBuilder(
         return this
     }
 
-    @JvmOverloads
     fun addOutputState(state: TransactionState<*>): TransactionBuilder {
         outputs.add(state)
         return this

From 22b1dead325f10df495e54d777e84c51951174ed Mon Sep 17 00:00:00 2001
From: Alberto Arri <30873160+al-r3@users.noreply.github.com>
Date: Tue, 10 Oct 2017 09:32:43 +0100
Subject: [PATCH 139/185] Remove functions with spaces in their name (#1850)

Remove all the Kotlin functions with spaces in them since the Android doesn't support them.

See https://github.com/corda/corda/issues/1730 for a more in-depth discussion.
---
 .../docs/tutorial/testdsl/TutorialTestDSL.kt  | 15 ++++++------
 .../net/corda/finance/contracts/asset/Cash.kt | 22 ++++-------------
 .../contracts/asset/CommodityContract.kt      |  2 +-
 .../finance/contracts/CommercialPaperTests.kt | 10 ++++----
 .../finance/contracts/asset/CashTests.kt      | 24 +++++++++----------
 .../contracts/asset/ObligationTests.kt        | 14 +++++------
 .../node/messaging/TwoPartyTradeFlowTests.kt  | 13 +++++-----
 .../corda/irs/api/NodeInterestRatesTest.kt    |  5 ++--
 8 files changed, 44 insertions(+), 61 deletions(-)

diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
index a52961b0e0..dd3fd47ff1 100644
--- a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt
@@ -8,8 +8,7 @@ import net.corda.finance.contracts.CommercialPaper
 import net.corda.finance.contracts.ICommercialPaperState
 import net.corda.finance.contracts.asset.CASH
 import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.`issued by`
-import net.corda.finance.contracts.asset.`owned by`
+import net.corda.finance.contracts.asset.ownedBy
 import net.corda.testing.*
 import org.junit.Test
 
@@ -132,7 +131,7 @@ class CommercialPaperTest {
         ledger {
             unverifiedTransaction {
                 attachments(Cash.PROGRAM_ID)
-                output(Cash.PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE)
+                output(Cash.PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH issuedBy issuer ownedBy ALICE)
             }
 
             // Some CP is issued onto the ledger by MegaCorp.
@@ -148,7 +147,7 @@ class CommercialPaperTest {
             transaction("Trade") {
                 input("paper")
                 input("alice's $900")
-                output(Cash.PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP }
+                output(Cash.PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH issuedBy issuer ownedBy MEGA_CORP }
                 output(CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>().withOwner(ALICE) }
                 command(ALICE_PUBKEY) { Cash.Commands.Move() }
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
@@ -165,7 +164,7 @@ class CommercialPaperTest {
         ledger {
             unverifiedTransaction {
                 attachments(Cash.PROGRAM_ID)
-                output(Cash.PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE)
+                output(Cash.PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH issuedBy issuer ownedBy ALICE)
             }
 
             // Some CP is issued onto the ledger by MegaCorp.
@@ -180,7 +179,7 @@ class CommercialPaperTest {
             transaction("Trade") {
                 input("paper")
                 input("alice's $900")
-                output(Cash.PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP }
+                output(Cash.PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH issuedBy issuer ownedBy MEGA_CORP }
                 output(CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>().withOwner(ALICE) }
                 command(ALICE_PUBKEY) { Cash.Commands.Move() }
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
@@ -207,7 +206,7 @@ class CommercialPaperTest {
         ledger {
             unverifiedTransaction {
                 attachments(Cash.PROGRAM_ID)
-                output(Cash.PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE)
+                output(Cash.PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH issuedBy issuer ownedBy ALICE)
             }
 
             // Some CP is issued onto the ledger by MegaCorp.
@@ -222,7 +221,7 @@ class CommercialPaperTest {
             transaction("Trade") {
                 input("paper")
                 input("alice's $900")
-                output(Cash.PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP }
+                output(Cash.PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH issuedBy issuer ownedBy MEGA_CORP }
                 output(CP_PROGRAM_ID, "alice's paper") { "paper".output<ICommercialPaperState>().withOwner(ALICE) }
                 command(ALICE_PUBKEY) { Cash.Commands.Move() }
                 command(MEGA_CORP_PUBKEY) { CommercialPaper.Commands.Move() }
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt
index 13e1725c09..55dffe1d36 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt
@@ -129,10 +129,10 @@ class Cash : OnLedgerAsset<Currency, Cash.Commands, Cash.State>() {
         override fun toString() = "${Emoji.bagOfCash}Cash($amount at ${amount.token.issuer} owned by $owner)"
 
         override fun withNewOwner(newOwner: AbstractParty) = CommandAndState(Commands.Move(), copy(owner = newOwner))
-        fun ownedBy(owner: AbstractParty) = copy(owner = owner)
-        fun issuedBy(party: AbstractParty) = copy(amount = Amount(amount.quantity, amount.token.copy(issuer = amount.token.issuer.copy(party = party))))
-        fun issuedBy(deposit: PartyAndReference) = copy(amount = Amount(amount.quantity, amount.token.copy(issuer = deposit)))
-        fun withDeposit(deposit: PartyAndReference): Cash.State = copy(amount = amount.copy(token = amount.token.copy(issuer = deposit)))
+        infix fun ownedBy(owner: AbstractParty) = copy(owner = owner)
+        infix fun issuedBy(party: AbstractParty) = copy(amount = Amount(amount.quantity, amount.token.copy(issuer = amount.token.issuer.copy(party = party))))
+        infix fun issuedBy(deposit: PartyAndReference) = copy(amount = Amount(amount.quantity, amount.token.copy(issuer = deposit)))
+        infix fun withDeposit(deposit: PartyAndReference): Cash.State = copy(amount = amount.copy(token = amount.token.copy(issuer = deposit)))
 
         /** Object Relational Mapping support. */
         override fun generateMappedObject(schema: MappedSchema): PersistentState {
@@ -399,20 +399,6 @@ class Cash : OnLedgerAsset<Currency, Cash.Commands, Cash.State>() {
     }
 }
 
-// Small DSL extensions.
-
-/** @suppress */
-infix fun Cash.State.`owned by`(owner: AbstractParty) = ownedBy(owner)
-
-/** @suppress */
-infix fun Cash.State.`issued by`(party: AbstractParty) = issuedBy(party)
-
-/** @suppress */
-infix fun Cash.State.`issued by`(deposit: PartyAndReference) = issuedBy(deposit)
-
-/** @suppress */
-infix fun Cash.State.`with deposit`(deposit: PartyAndReference): Cash.State = withDeposit(deposit)
-
 // Unit testing helpers. These could go in a separate file but it's hardly worth it for just a few functions.
 
 /** A randomly generated key. */
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/CommodityContract.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/CommodityContract.kt
index 052223b7e4..677728874b 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/CommodityContract.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/CommodityContract.kt
@@ -139,7 +139,7 @@ class CommodityContract : OnLedgerAsset<Commodity, CommodityContract.Commands, C
         val outputAmount = outputs.sumCommodities()
         val commodityCommands = tx.commands.select<CommodityContract.Commands>()
         requireThat {
-            "output deposits are owned by a command signer" using (issuer.party in issueCommand.signingParties)
+            "output deposits are ownedBy a command signer" using (issuer.party in issueCommand.signingParties)
             "output values sum to more than the inputs" using (outputAmount > inputAmount)
             "there is only a single issue command" using (commodityCommands.count() == 1)
         }
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
index a1a296eb05..6175bca1b7 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
@@ -96,8 +96,8 @@ class CommercialPaperTestsGeneric {
         ledger {
             unverifiedTransaction {
                 attachment(Cash.PROGRAM_ID)
-                output(Cash.PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH `issued by` issuer `owned by` ALICE)
-                output(Cash.PROGRAM_ID, "some profits", someProfits.STATE `owned by` MEGA_CORP)
+                output(Cash.PROGRAM_ID, "alice's $900", 900.DOLLARS.CASH issuedBy issuer ownedBy ALICE)
+                output(Cash.PROGRAM_ID, "some profits", someProfits.STATE ownedBy MEGA_CORP)
             }
 
             // Some CP is issued onto the ledger by MegaCorp.
@@ -115,7 +115,7 @@ class CommercialPaperTestsGeneric {
                 attachments(Cash.PROGRAM_ID, JavaCommercialPaper.JCP_PROGRAM_ID)
                 input("paper")
                 input("alice's $900")
-                output(Cash.PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH `issued by` issuer `owned by` MEGA_CORP }
+                output(Cash.PROGRAM_ID, "borrowed $900") { 900.DOLLARS.CASH issuedBy issuer ownedBy MEGA_CORP }
                 output(thisTest.getContract(), "alice's paper") { "paper".output<ICommercialPaperState>().withOwner(ALICE) }
                 command(ALICE_PUBKEY) { Cash.Commands.Move() }
                 command(MEGA_CORP_PUBKEY) { thisTest.getMoveCommand() }
@@ -130,8 +130,8 @@ class CommercialPaperTestsGeneric {
                 input("some profits")
 
                 fun TransactionDSL<TransactionDSLInterpreter>.outputs(aliceGetsBack: Amount<Issued<Currency>>) {
-                    output(Cash.PROGRAM_ID, "Alice's profit") { aliceGetsBack.STATE `owned by` ALICE }
-                    output(Cash.PROGRAM_ID, "Change") { (someProfits - aliceGetsBack).STATE `owned by` MEGA_CORP }
+                    output(Cash.PROGRAM_ID, "Alice's profit") { aliceGetsBack.STATE ownedBy ALICE }
+                    output(Cash.PROGRAM_ID, "Change") { (someProfits - aliceGetsBack).STATE ownedBy MEGA_CORP }
                 }
 
                 command(MEGA_CORP_PUBKEY) { Cash.Commands.Move() }
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
index 952aa3d9df..fa7eb3c051 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
@@ -105,7 +105,7 @@ class CashTests : TestDependencyInjectionBase() {
             }
             tweak {
                 output(Cash.PROGRAM_ID) { outState }
-                output(Cash.PROGRAM_ID) { outState `issued by` MINI_CORP }
+                output(Cash.PROGRAM_ID) { outState issuedBy MINI_CORP }
                 command(ALICE_PUBKEY) { Cash.Commands.Move() }
                 this `fails with` "at least one cash input"
             }
@@ -309,7 +309,7 @@ class CashTests : TestDependencyInjectionBase() {
         transaction {
             attachment(Cash.PROGRAM_ID)
             input(Cash.PROGRAM_ID) { inState }
-            output(Cash.PROGRAM_ID) { outState `issued by` MINI_CORP }
+            output(Cash.PROGRAM_ID) { outState issuedBy MINI_CORP }
             command(ALICE_PUBKEY) { Cash.Commands.Move() }
             this `fails with` "the amounts balance"
         }
@@ -348,7 +348,7 @@ class CashTests : TestDependencyInjectionBase() {
         transaction {
             attachment(Cash.PROGRAM_ID)
             input(Cash.PROGRAM_ID) { inState }
-            input(Cash.PROGRAM_ID) { inState `issued by` MINI_CORP }
+            input(Cash.PROGRAM_ID) { inState issuedBy MINI_CORP }
             output(Cash.PROGRAM_ID) { outState }
             command(ALICE_PUBKEY) { Cash.Commands.Move() }
             this `fails with` "the amounts balance"
@@ -396,9 +396,9 @@ class CashTests : TestDependencyInjectionBase() {
         transaction {
             attachment(Cash.PROGRAM_ID)
             input(Cash.PROGRAM_ID) { issuerInState }
-            input(Cash.PROGRAM_ID) { issuerInState.copy(owner = MINI_CORP) `issued by` MINI_CORP }
+            input(Cash.PROGRAM_ID) { issuerInState.copy(owner = MINI_CORP) issuedBy MINI_CORP }
 
-            output(Cash.PROGRAM_ID) { issuerInState.copy(amount = issuerInState.amount - (200.DOLLARS `issued by` defaultIssuer)) `issued by` MINI_CORP }
+            output(Cash.PROGRAM_ID) { issuerInState.copy(amount = issuerInState.amount - (200.DOLLARS `issued by` defaultIssuer)) issuedBy MINI_CORP }
             output(Cash.PROGRAM_ID) { issuerInState.copy(owner = MINI_CORP, amount = issuerInState.amount - (200.DOLLARS `issued by` defaultIssuer)) }
 
             command(MEGA_CORP_PUBKEY, MINI_CORP_PUBKEY) { Cash.Commands.Move() }
@@ -432,7 +432,7 @@ class CashTests : TestDependencyInjectionBase() {
             attachment(Cash.PROGRAM_ID)
             // Gather 2000 dollars from two different issuers.
             input(Cash.PROGRAM_ID) { inState }
-            input(Cash.PROGRAM_ID) { inState `issued by` MINI_CORP }
+            input(Cash.PROGRAM_ID) { inState issuedBy MINI_CORP }
             command(ALICE_PUBKEY) { Cash.Commands.Move() }
 
             // Can't merge them together.
@@ -449,7 +449,7 @@ class CashTests : TestDependencyInjectionBase() {
 
             // This works.
             output(Cash.PROGRAM_ID) { inState.copy(owner = AnonymousParty(BOB_PUBKEY)) }
-            output(Cash.PROGRAM_ID) { inState.copy(owner = AnonymousParty(BOB_PUBKEY)) `issued by` MINI_CORP }
+            output(Cash.PROGRAM_ID) { inState.copy(owner = AnonymousParty(BOB_PUBKEY)) issuedBy MINI_CORP }
             this.verifies()
         }
     }
@@ -460,10 +460,10 @@ class CashTests : TestDependencyInjectionBase() {
         transaction {
             attachment(Cash.PROGRAM_ID)
             val pounds = Cash.State(658.POUNDS `issued by` MINI_CORP.ref(3, 4, 5), AnonymousParty(BOB_PUBKEY))
-            input(Cash.PROGRAM_ID) { inState `owned by` AnonymousParty(ALICE_PUBKEY) }
+            input(Cash.PROGRAM_ID) { inState ownedBy AnonymousParty(ALICE_PUBKEY) }
             input(Cash.PROGRAM_ID) { pounds }
-            output(Cash.PROGRAM_ID) { inState `owned by` AnonymousParty(BOB_PUBKEY) }
-            output(Cash.PROGRAM_ID) { pounds `owned by` AnonymousParty(ALICE_PUBKEY) }
+            output(Cash.PROGRAM_ID) { inState ownedBy AnonymousParty(BOB_PUBKEY) }
+            output(Cash.PROGRAM_ID) { pounds ownedBy AnonymousParty(ALICE_PUBKEY) }
             command(ALICE_PUBKEY, BOB_PUBKEY) { Cash.Commands.Move() }
 
             this.verifies()
@@ -718,8 +718,8 @@ class CashTests : TestDependencyInjectionBase() {
                 Cash.State(1000.POUNDS `issued by` MINI_CORP.ref(3), MEGA_CORP).amount.token)
 
         // States cannot be aggregated if the reference differs
-        assertNotEquals(fiveThousandDollarsFromMega.amount.token, (fiveThousandDollarsFromMega `with deposit` defaultIssuer).amount.token)
-        assertNotEquals((fiveThousandDollarsFromMega `with deposit` defaultIssuer).amount.token, fiveThousandDollarsFromMega.amount.token)
+        assertNotEquals(fiveThousandDollarsFromMega.amount.token, (fiveThousandDollarsFromMega withDeposit defaultIssuer).amount.token)
+        assertNotEquals((fiveThousandDollarsFromMega withDeposit defaultIssuer).amount.token, fiveThousandDollarsFromMega.amount.token)
     }
 
     @Test
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt
index 8a293c4009..d5aa6d8cdc 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt
@@ -60,7 +60,7 @@ class ObligationTests {
             output(Obligation.PROGRAM_ID, "Alice's $1,000,000 obligation to Bob", oneMillionDollars.OBLIGATION between Pair(ALICE, BOB))
             output(Obligation.PROGRAM_ID, "Bob's $1,000,000 obligation to Alice", oneMillionDollars.OBLIGATION between Pair(BOB, ALICE))
             output(Obligation.PROGRAM_ID, "MegaCorp's $1,000,000 obligation to Bob", oneMillionDollars.OBLIGATION between Pair(MEGA_CORP, BOB))
-            output(Obligation.PROGRAM_ID, "Alice's $1,000,000", 1000000.DOLLARS.CASH `issued by` defaultIssuer `owned by` ALICE)
+            output(Obligation.PROGRAM_ID, "Alice's $1,000,000", 1000000.DOLLARS.CASH issuedBy defaultIssuer ownedBy ALICE)
         }
     }
 
@@ -484,7 +484,7 @@ class ObligationTests {
                 attachments(Obligation.PROGRAM_ID)
                 input("Alice's $1,000,000 obligation to Bob")
                 input("Alice's $1,000,000")
-                output(Obligation.PROGRAM_ID, "Bob's $1,000,000") { 1000000.DOLLARS.CASH `issued by` defaultIssuer `owned by` BOB }
+                output(Obligation.PROGRAM_ID, "Bob's $1,000,000") { 1000000.DOLLARS.CASH issuedBy defaultIssuer ownedBy BOB }
                 command(ALICE_PUBKEY) { Obligation.Commands.Settle(Amount(oneMillionDollars.quantity, inState.amount.token)) }
                 command(ALICE_PUBKEY) { Cash.Commands.Move(Obligation::class.java) }
                 attachment(attachment(cashContractBytes.inputStream()))
@@ -498,9 +498,9 @@ class ObligationTests {
             transaction("Settlement") {
                 attachments(Obligation.PROGRAM_ID, Cash.PROGRAM_ID)
                 input(Obligation.PROGRAM_ID, oneMillionDollars.OBLIGATION between Pair(ALICE, BOB))
-                input(Cash.PROGRAM_ID, 500000.DOLLARS.CASH `issued by` defaultIssuer `owned by` ALICE)
+                input(Cash.PROGRAM_ID, 500000.DOLLARS.CASH issuedBy defaultIssuer ownedBy ALICE)
                 output(Obligation.PROGRAM_ID, "Alice's $500,000 obligation to Bob") { halfAMillionDollars.OBLIGATION between Pair(ALICE, BOB) }
-                output(Obligation.PROGRAM_ID, "Bob's $500,000") { 500000.DOLLARS.CASH `issued by` defaultIssuer `owned by` BOB }
+                output(Obligation.PROGRAM_ID, "Bob's $500,000") { 500000.DOLLARS.CASH issuedBy defaultIssuer ownedBy BOB }
                 command(ALICE_PUBKEY) { Obligation.Commands.Settle(Amount(oneMillionDollars.quantity / 2, inState.amount.token)) }
                 command(ALICE_PUBKEY) { Cash.Commands.Move(Obligation::class.java) }
                 attachment(attachment(cashContractBytes.inputStream()))
@@ -514,8 +514,8 @@ class ObligationTests {
             transaction("Settlement") {
                 attachments(Obligation.PROGRAM_ID, Cash.PROGRAM_ID)
                 input(Obligation.PROGRAM_ID, defaultedObligation) // Alice's defaulted $1,000,000 obligation to Bob
-                input(Cash.PROGRAM_ID, 1000000.DOLLARS.CASH `issued by` defaultIssuer `owned by` ALICE)
-                output(Obligation.PROGRAM_ID, "Bob's $1,000,000") { 1000000.DOLLARS.CASH `issued by` defaultIssuer `owned by` BOB }
+                input(Cash.PROGRAM_ID, 1000000.DOLLARS.CASH issuedBy defaultIssuer ownedBy ALICE)
+                output(Obligation.PROGRAM_ID, "Bob's $1,000,000") { 1000000.DOLLARS.CASH issuedBy defaultIssuer ownedBy BOB }
                 command(ALICE_PUBKEY) { Obligation.Commands.Settle(Amount(oneMillionDollars.quantity, inState.amount.token)) }
                 command(ALICE_PUBKEY) { Cash.Commands.Move(Obligation::class.java) }
                 this `fails with` "all inputs are in the normal state"
@@ -529,7 +529,7 @@ class ObligationTests {
                 attachments(Obligation.PROGRAM_ID)
                 input("Alice's $1,000,000 obligation to Bob")
                 input("Alice's $1,000,000")
-                output(Obligation.PROGRAM_ID, "Bob's $1,000,000") { 1000000.DOLLARS.CASH `issued by` defaultIssuer `owned by` BOB }
+                output(Obligation.PROGRAM_ID, "Bob's $1,000,000") { 1000000.DOLLARS.CASH issuedBy defaultIssuer ownedBy BOB }
                 command(ALICE_PUBKEY) { Obligation.Commands.Settle(Amount(oneMillionDollars.quantity / 2, inState.amount.token)) }
                 command(ALICE_PUBKEY) { Cash.Commands.Move(Obligation::class.java) }
                 attachment(attachment(cashContractBytes.inputStream()))
diff --git a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
index ffaafa6246..79e224fe76 100644
--- a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
@@ -31,8 +31,7 @@ import net.corda.finance.`issued by`
 import net.corda.finance.contracts.CommercialPaper
 import net.corda.finance.contracts.asset.CASH
 import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.`issued by`
-import net.corda.finance.contracts.asset.`owned by`
+import net.corda.finance.contracts.asset.ownedBy
 import net.corda.finance.flows.TwoPartyTradeFlow.Buyer
 import net.corda.finance.flows.TwoPartyTradeFlow.Seller
 import net.corda.node.internal.StartedNode
@@ -679,8 +678,8 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
         // wants to sell to Bob.
         val eb1 = transaction(transactionBuilder = TransactionBuilder(notary = notary)) {
             // Issued money to itself.
-            output(Cash.PROGRAM_ID, "elbonian money 1", notary = notary) { 800.DOLLARS.CASH `issued by` issuer `owned by` interimOwner }
-            output(Cash.PROGRAM_ID, "elbonian money 2", notary = notary) { 1000.DOLLARS.CASH `issued by` issuer `owned by` interimOwner }
+            output(Cash.PROGRAM_ID, "elbonian money 1", notary = notary) { 800.DOLLARS.CASH issuedBy issuer ownedBy interimOwner }
+            output(Cash.PROGRAM_ID, "elbonian money 2", notary = notary) { 1000.DOLLARS.CASH issuedBy issuer ownedBy interimOwner }
             if (!withError) {
                 command(issuer.party.owningKey) { Cash.Commands.Issue() }
             } else {
@@ -698,15 +697,15 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
         // Bob gets some cash onto the ledger from BoE
         val bc1 = transaction(transactionBuilder = TransactionBuilder(notary = notary)) {
             input("elbonian money 1")
-            output(Cash.PROGRAM_ID, "bob cash 1", notary = notary) { 800.DOLLARS.CASH `issued by` issuer `owned by` owner }
+            output(Cash.PROGRAM_ID, "bob cash 1", notary = notary) { 800.DOLLARS.CASH issuedBy issuer ownedBy owner }
             command(interimOwner.owningKey) { Cash.Commands.Move() }
             this.verifies()
         }
 
         val bc2 = transaction(transactionBuilder = TransactionBuilder(notary = notary)) {
             input("elbonian money 2")
-            output(Cash.PROGRAM_ID, "bob cash 2", notary = notary) { 300.DOLLARS.CASH `issued by` issuer `owned by` owner }
-            output(Cash.PROGRAM_ID, notary = notary) { 700.DOLLARS.CASH `issued by` issuer `owned by` interimOwner }   // Change output.
+            output(Cash.PROGRAM_ID, "bob cash 2", notary = notary) { 300.DOLLARS.CASH issuedBy issuer ownedBy owner }
+            output(Cash.PROGRAM_ID, notary = notary) { 700.DOLLARS.CASH issuedBy issuer ownedBy interimOwner }   // Change output.
             command(interimOwner.owningKey) { Cash.Commands.Move() }
             this.verifies()
         }
diff --git a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
index ef07a9a5a3..38fc4e0b56 100644
--- a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
+++ b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
@@ -14,8 +14,7 @@ import net.corda.finance.contracts.Fix
 import net.corda.finance.contracts.FixOf
 import net.corda.finance.contracts.asset.CASH
 import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.`issued by`
-import net.corda.finance.contracts.asset.`owned by`
+import net.corda.finance.contracts.asset.ownedBy
 import net.corda.irs.flows.RatesFixFlow
 import net.corda.node.utilities.CordaPersistence
 import net.corda.node.utilities.configureDatabase
@@ -242,7 +241,7 @@ class NodeInterestRatesTest : TestDependencyInjectionBase() {
     }
 
     private fun makePartialTX() = TransactionBuilder(DUMMY_NOTARY).withItems(
-            TransactionState(1000.DOLLARS.CASH `issued by` DUMMY_CASH_ISSUER `owned by` ALICE, Cash.PROGRAM_ID, DUMMY_NOTARY))
+            TransactionState(1000.DOLLARS.CASH issuedBy DUMMY_CASH_ISSUER ownedBy ALICE, Cash.PROGRAM_ID, DUMMY_NOTARY))
 
     private fun makeFullTx() = makePartialTX().withItems(dummyCommand())
 }

From 6166fa8358583adcbe2a62f3e9046e06660f3c8e Mon Sep 17 00:00:00 2001
From: cburlinchon <31621751+cburlinchon@users.noreply.github.com>
Date: Tue, 10 Oct 2017 09:51:01 +0100
Subject: [PATCH 140/185] Don't generate Kt classes (#1798)

---
 core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt   | 2 ++
 .../kotlin/net/corda/core/serialization/SerializationAPI.kt     | 2 ++
 core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt    | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
index 3996dee1de..5f26ef2e48 100644
--- a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
@@ -1,3 +1,5 @@
+@file:JvmName("InternalUtils")
+
 package net.corda.core.internal
 
 import net.corda.core.crypto.SecureHash
diff --git a/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt b/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
index f77e3ae122..0eccaf6ffb 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
@@ -1,3 +1,5 @@
+@file:JvmName("SerializationAPI")
+
 package net.corda.core.serialization
 
 import net.corda.core.crypto.SecureHash
diff --git a/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt b/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt
index b12ea8353d..897ae4d1d8 100644
--- a/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt
@@ -1,3 +1,5 @@
+@file:JvmName("KotlinUtils")
+
 package net.corda.core.utilities
 
 import net.corda.core.internal.concurrent.get

From 7af1f02a2d885f6648fb3ed3942a7bef6780a68e Mon Sep 17 00:00:00 2001
From: Alberto Arri <30873160+al-r3@users.noreply.github.com>
Date: Tue, 10 Oct 2017 09:55:20 +0100
Subject: [PATCH 141/185] Add a configuration option to set how often should a
 node check for new nodeinfos on disk (#1851)

* Add a configuration option to set how often should a node check for new NodeInfo files in additional-node-infos
---
 .../node/services/network/NodeInfoWatcherTest.kt     |  2 +-
 .../corda/node/services/config/NodeConfiguration.kt  |  5 ++++-
 .../corda/node/services/network/NodeInfoWatcher.kt   | 12 ++++++++++--
 .../services/network/PersistentNetworkMapCache.kt    |  4 +++-
 .../services/config/FullNodeConfigurationTest.kt     |  4 +++-
 5 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
index d4436236ef..0f102a5e79 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
@@ -50,7 +50,7 @@ class NodeInfoWatcherTest : NodeBasedTest() {
     fun start() {
         val identityService = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
         keyManagementService = MockKeyManagementService(identityService, ALICE_KEY)
-        nodeInfoWatcher = NodeInfoWatcher(folder.root.toPath(), scheduler)
+        nodeInfoWatcher = NodeInfoWatcher(folder.root.toPath(), scheduler = scheduler)
         nodeInfoPath = folder.root.toPath() / CordformNode.NODE_INFO_DIRECTORY
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
index 95467b63bc..64b460b2ba 100644
--- a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
+++ b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
@@ -2,6 +2,7 @@ package net.corda.node.services.config
 
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.utilities.NetworkHostAndPort
+import net.corda.core.utilities.seconds
 import net.corda.node.internal.NetworkMapInfo
 import net.corda.node.services.messaging.CertificateChainCheckPolicy
 import net.corda.nodeapi.User
@@ -33,6 +34,7 @@ interface NodeConfiguration : NodeSSLConfiguration {
     val messageRedeliveryDelaySeconds: Int
     val notary: NotaryConfig?
     val activeMQServer: ActiveMqServerConfiguration
+    val additionalNodeInfoPollingFrequencyMsec: Long
 }
 
 data class NotaryConfig(val validating: Boolean, val raft: RaftConfig? = null, val bftSMaRt: BFTSMaRtConfiguration? = null) {
@@ -86,7 +88,8 @@ data class FullNodeConfiguration(
         override val devMode: Boolean = false,
         val useTestClock: Boolean = false,
         val detectPublicIp: Boolean = true,
-        override val activeMQServer: ActiveMqServerConfiguration
+        override val activeMQServer: ActiveMqServerConfiguration,
+        override val additionalNodeInfoPollingFrequencyMsec: Long = 5.seconds.toMillis()
 ) : NodeConfiguration {
     override val exportJMXto: String get() = "http"
 
diff --git a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
index 7d8542d314..aefd79c2d1 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
@@ -8,10 +8,10 @@ import net.corda.core.node.services.KeyManagementService
 import net.corda.core.serialization.deserialize
 import net.corda.core.serialization.serialize
 import net.corda.core.utilities.loggerFor
+import net.corda.core.utilities.seconds
 import rx.Observable
 import rx.Scheduler
 import rx.schedulers.Schedulers
-import java.nio.file.Files
 import java.nio.file.Path
 import java.util.concurrent.TimeUnit
 import kotlin.streams.toList
@@ -22,13 +22,17 @@ import kotlin.streams.toList
  * - Poll a directory for new serialized [NodeInfo]
  *
  * @param path the base path of a node.
+ * @param pollFrequencyMsec how often to poll the filesystem in milliseconds. Any value smaller than 5 seconds will
+ *        be treated as 5 seconds.
  * @param scheduler a [Scheduler] for the rx [Observable] returned by [nodeInfoUpdates], this is mainly useful for
  *        testing. It defaults to the io scheduler which is the appropriate value for production uses.
  */
 class NodeInfoWatcher(private val nodePath: Path,
+                      pollFrequencyMsec: Long = 5.seconds.toMillis(),
                       private val scheduler: Scheduler = Schedulers.io()) {
 
     private val nodeInfoDirectory = nodePath / CordformNode.NODE_INFO_DIRECTORY
+    private val pollFrequencyMsec: Long
 
     companion object {
         private val logger = loggerFor<NodeInfoWatcher>()
@@ -56,6 +60,10 @@ class NodeInfoWatcher(private val nodePath: Path,
         }
     }
 
+    init {
+        this.pollFrequencyMsec = maxOf(pollFrequencyMsec, 5.seconds.toMillis())
+    }
+
     /**
      * Read all the files contained in [nodePath] / [CordformNode.NODE_INFO_DIRECTORY] and keep watching
      * the folder for further updates.
@@ -67,7 +75,7 @@ class NodeInfoWatcher(private val nodePath: Path,
      *      than once.
      */
     fun nodeInfoUpdates(): Observable<NodeInfo> {
-        return Observable.interval(5, TimeUnit.SECONDS, scheduler)
+        return Observable.interval(pollFrequencyMsec, TimeUnit.MILLISECONDS, scheduler)
                 .flatMapIterable { loadFromDirectory() }
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
index 09b3c8997f..1f24e27526 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
@@ -39,6 +39,7 @@ import rx.Observable
 import rx.subjects.PublishSubject
 import java.security.PublicKey
 import java.security.SignatureException
+import java.time.Duration
 import java.util.*
 import javax.annotation.concurrent.ThreadSafe
 import kotlin.collections.HashMap
@@ -87,7 +88,8 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
                     .sortedBy { it.name.toString() }
         }
 
-    private val nodeInfoSerializer = NodeInfoWatcher(serviceHub.configuration.baseDirectory)
+    private val nodeInfoSerializer = NodeInfoWatcher(serviceHub.configuration.baseDirectory,
+            serviceHub.configuration.additionalNodeInfoPollingFrequencyMsec)
 
     init {
         loadFromFiles()
diff --git a/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
index 2935053699..d46c32c5a0 100644
--- a/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
@@ -1,6 +1,7 @@
 package net.corda.node.services.config
 
 import net.corda.core.utilities.NetworkHostAndPort
+import net.corda.core.utilities.seconds
 import net.corda.nodeapi.User
 import net.corda.testing.ALICE
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
@@ -33,7 +34,8 @@ class FullNodeConfigurationTest {
                 notary = null,
                 certificateChainCheckPolicies = emptyList(),
                 devMode = true,
-                activeMQServer = ActiveMqServerConfiguration(BridgeConfiguration(0, 0, 0.0)))
+                activeMQServer = ActiveMqServerConfiguration(BridgeConfiguration(0, 0, 0.0)),
+                additionalNodeInfoPollingFrequencyMsec = 5.seconds.toMillis())
 
         fun configWithRPCUsername(username: String) {
             testConfiguration.copy(rpcUsers = listOf(User(username, "pass", emptySet())))

From 0e47e53b609a46a0f360b87a6d667db3bc7d6156 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Tue, 10 Oct 2017 12:28:19 +0100
Subject: [PATCH 142/185] Make AttachmentLoadingTests more stable (#1810)

---
 .../node/services/AttachmentLoadingTests.kt   | 64 +++++++++++--------
 1 file changed, 39 insertions(+), 25 deletions(-)

diff --git a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
index e5a79d7d5c..3c15d0aec5 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@@ -16,6 +16,7 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.loggerFor
+import net.corda.core.utilities.seconds
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
 import net.corda.nodeapi.User
@@ -25,6 +26,7 @@ import net.corda.testing.TestDependencyInjectionBase
 import net.corda.testing.driver.DriverDSLExposedInterface
 import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.driver
+import net.corda.testing.eventually
 import net.corda.testing.node.MockServices
 import org.junit.Assert.assertEquals
 import org.junit.Before
@@ -53,6 +55,37 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
         val flowInitiatorClass =
                 Class.forName("net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Initiator", true, URLClassLoader(arrayOf(isolatedJAR)))
                         .asSubclass(FlowLogic::class.java)
+
+        private fun DriverDSLExposedInterface.createTwoNodesAndNotary(): List<NodeHandle> {
+            val adminUser = User("admin", "admin", permissions = setOf("ALL"))
+            val nodes = listOf(
+                    startNode(providedName = bankAName, rpcUsers = listOf(adminUser)),
+                    startNode(providedName = bankBName, rpcUsers = listOf(adminUser)),
+                    startNotaryNode(providedName = notaryName, rpcUsers = listOf(adminUser), validating = false)
+            ).transpose().getOrThrow()   // Wait for all nodes to start up.
+            nodes.forEach { it.rpc.waitUntilNetworkReady().getOrThrow() }
+            return nodes
+        }
+
+        private fun DriverDSLExposedInterface.installIsolatedCordappTo(nodeName: CordaX500Name) {
+            // Copy the app jar to the first node. The second won't have it.
+            val path = (baseDirectory(nodeName.toString()) / "plugins").createDirectories() / "isolated.jar"
+            logger.info("Installing isolated jar to $path")
+            isolatedJAR.openStream().buffered().use { input ->
+                Files.newOutputStream(path).buffered().use { output ->
+                    input.copyTo(output)
+                }
+            }
+        }
+
+        // Due to cluster instability after nodes been started it may take some time to all the nodes to become available
+        // *and* discover each other to reliably communicate. Hence, eventual nature of the test.
+        // TODO: Remove this method and usages of it once NetworkMap service been re-worked
+        private fun eventuallyPassingTest(block: () -> Unit) {
+            eventually<Throwable, Unit>(30.seconds) {
+                block()
+            }
+        }
     }
 
     private lateinit var services: Services
@@ -85,9 +118,10 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
         driver(initialiseSerialization = false) {
             installIsolatedCordappTo(bankAName)
             val (bankA, bankB, _) = createTwoNodesAndNotary()
-
-            assertFailsWith<UnexpectedFlowEndException>("Party C=CH,L=Zurich,O=BankB rejected session request: Don't know net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Initiator") {
-                bankA.rpc.startFlowDynamic(flowInitiatorClass, bankB.nodeInfo.legalIdentities.first()).returnValue.getOrThrow()
+            eventuallyPassingTest {
+                assertFailsWith<UnexpectedFlowEndException>("Party C=CH,L=Zurich,O=BankB rejected session request: Don't know net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Initiator") {
+                    bankA.rpc.startFlowDynamic(flowInitiatorClass, bankB.nodeInfo.legalIdentities.first()).returnValue.getOrThrow()
+                }
             }
         }
     }
@@ -98,29 +132,9 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
             installIsolatedCordappTo(bankAName)
             installIsolatedCordappTo(bankBName)
             val (bankA, bankB, _) = createTwoNodesAndNotary()
-            bankA.rpc.startFlowDynamic(flowInitiatorClass, bankB.nodeInfo.legalIdentities.first()).returnValue.getOrThrow()
-        }
-    }
-
-    private fun DriverDSLExposedInterface.installIsolatedCordappTo(nodeName: CordaX500Name) {
-        // Copy the app jar to the first node. The second won't have it.
-        val path = (baseDirectory(nodeName.toString()) / "plugins").createDirectories() / "isolated.jar"
-        logger.info("Installing isolated jar to $path")
-        isolatedJAR.openStream().buffered().use { input ->
-            Files.newOutputStream(path).buffered().use { output ->
-                input.copyTo(output)
+            eventuallyPassingTest {
+                bankA.rpc.startFlowDynamic(flowInitiatorClass, bankB.nodeInfo.legalIdentities.first()).returnValue.getOrThrow()
             }
         }
     }
-
-    private fun DriverDSLExposedInterface.createTwoNodesAndNotary(): List<NodeHandle> {
-        val adminUser = User("admin", "admin", permissions = setOf("ALL"))
-        val nodes = listOf(
-                startNode(providedName = bankAName, rpcUsers = listOf(adminUser)),
-                startNode(providedName = bankBName, rpcUsers = listOf(adminUser)),
-                startNotaryNode(providedName = notaryName, rpcUsers = listOf(adminUser), validating = false)
-        ).transpose().getOrThrow()   // Wait for all nodes to start up.
-        nodes.forEach { it.rpc.waitUntilNetworkReady().getOrThrow() }
-        return nodes
-    }
 }

From 242b019dc2ce31f000a3e67193ef7a46cb9aa2fc Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Tue, 10 Oct 2017 13:23:31 +0100
Subject: [PATCH 143/185] CORDA-641: Remove special case handling of notary
 transactions (#1675)

Move special case handling of notary transactions into `SignedTransaction`
---
 .../flows/AbstractStateReplacementFlow.kt     | 22 +++-------------
 .../kotlin/net/corda/core/flows/NotaryFlow.kt |  6 +----
 .../kotlin/net/corda/core/node/ServiceHub.kt  |  6 +----
 .../core/transactions/SignedTransaction.kt    | 26 +++++++++++++++++++
 .../transactions/TransactionWithSignatures.kt |  2 ++
 .../net/corda/docs/CustomNotaryTutorial.kt    | 12 ++++-----
 .../net/corda/node/internal/StartedNode.kt    |  4 +--
 .../transactions/ValidatingNotaryFlow.kt      | 12 ++++-----
 8 files changed, 44 insertions(+), 46 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/flows/AbstractStateReplacementFlow.kt b/core/src/main/kotlin/net/corda/core/flows/AbstractStateReplacementFlow.kt
index 82a960cfc7..af0c406410 100644
--- a/core/src/main/kotlin/net/corda/core/flows/AbstractStateReplacementFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/AbstractStateReplacementFlow.kt
@@ -70,15 +70,7 @@ abstract class AbstractStateReplacementFlow {
             val finalTx = stx + signatures
             serviceHub.recordTransactions(finalTx)
 
-            val newOutput = run {
-                if (stx.isNotaryChangeTransaction()) {
-                    stx.resolveNotaryChangeTransaction(serviceHub).outRef<T>(0)
-                } else {
-                    stx.tx.outRef<T>(0)
-                }
-            }
-
-            return newOutput
+            return stx.resolveBaseTransaction(serviceHub).outRef<T>(0)
         }
 
         /**
@@ -174,11 +166,7 @@ abstract class AbstractStateReplacementFlow {
             }
 
             val finalTx = stx + allSignatures
-            if (finalTx.isNotaryChangeTransaction()) {
-                finalTx.resolveNotaryChangeTransaction(serviceHub).verifyRequiredSignatures()
-            } else {
-                finalTx.verifyRequiredSignatures()
-            }
+            finalTx.resolveTransactionWithSignatures(serviceHub).verifyRequiredSignatures()
             serviceHub.recordTransactions(finalTx)
         }
 
@@ -195,11 +183,7 @@ abstract class AbstractStateReplacementFlow {
             // TODO Check the set of multiple identities?
             val myKey = ourIdentity.owningKey
 
-            val requiredKeys = if (stx.isNotaryChangeTransaction()) {
-                stx.resolveNotaryChangeTransaction(serviceHub).requiredSigningKeys
-            } else {
-                stx.tx.requiredSigningKeys
-            }
+            val requiredKeys = stx.resolveTransactionWithSignatures(serviceHub).requiredSigningKeys
 
             require(myKey in requiredKeys) { "Party is not a participant for any of the input states of transaction ${stx.id}" }
         }
diff --git a/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt b/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt
index c59986c61b..c96070fba7 100644
--- a/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/NotaryFlow.kt
@@ -54,11 +54,7 @@ class NotaryFlow {
             }
 
             try {
-                if (stx.isNotaryChangeTransaction()) {
-                    stx.resolveNotaryChangeTransaction(serviceHub).verifySignaturesExcept(notaryParty.owningKey)
-                } else {
-                    stx.verifySignaturesExcept(notaryParty.owningKey)
-                }
+                stx.resolveTransactionWithSignatures(serviceHub).verifySignaturesExcept(notaryParty.owningKey)
             } catch (ex: SignatureException) {
                 throw NotaryException(NotaryError.TransactionInvalid(ex))
             }
diff --git a/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt b/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
index c278ac16a3..7114e6c843 100644
--- a/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
+++ b/core/src/main/kotlin/net/corda/core/node/ServiceHub.kt
@@ -164,11 +164,7 @@ interface ServiceHub : ServicesForResolution {
     @Throws(TransactionResolutionException::class)
     fun <T : ContractState> toStateAndRef(stateRef: StateRef): StateAndRef<T> {
         val stx = validatedTransactions.getTransaction(stateRef.txhash) ?: throw TransactionResolutionException(stateRef.txhash)
-        return if (stx.isNotaryChangeTransaction()) {
-            stx.resolveNotaryChangeTransaction(this).outRef(stateRef.index)
-        } else {
-            stx.tx.outRef(stateRef.index)
-        }
+        return stx.resolveBaseTransaction(this).outRef<T>(stateRef.index)
     }
 
     private val legalIdentityKey: PublicKey get() = this.myInfo.legalIdentitiesAndCerts.first().owningKey
diff --git a/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
index d583a5f386..c34fd26065 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/SignedTransaction.kt
@@ -179,6 +179,32 @@ data class SignedTransaction(val txBits: SerializedBytes<CoreTransaction>,
 
     fun isNotaryChangeTransaction() = transaction is NotaryChangeWireTransaction
 
+    /**
+     * Resolves the underlying base transaction and then returns it, handling any special case transactions such as
+     * [NotaryChangeWireTransaction].
+     */
+    fun resolveBaseTransaction(services: StateLoader): BaseTransaction {
+        return when (transaction) {
+            is NotaryChangeWireTransaction -> resolveNotaryChangeTransaction(services)
+            is WireTransaction -> this.tx
+            is FilteredTransaction -> throw IllegalStateException("Persistence of filtered transactions is not supported.")
+            else -> throw IllegalStateException("Unknown transaction type ${transaction::class.qualifiedName}")
+        }
+    }
+
+    /**
+     * Resolves the underlying transaction with signatures and then returns it, handling any special case transactions
+     * such as [NotaryChangeWireTransaction].
+     */
+    fun resolveTransactionWithSignatures(services: ServiceHub): TransactionWithSignatures {
+        return when (transaction) {
+            is NotaryChangeWireTransaction -> resolveNotaryChangeTransaction(services)
+            is WireTransaction -> this
+            is FilteredTransaction -> throw IllegalStateException("Persistence of filtered transactions is not supported.")
+            else -> throw IllegalStateException("Unknown transaction type ${transaction::class.qualifiedName}")
+        }
+    }
+
     /**
      * If [transaction] is a [NotaryChangeWireTransaction], loads the input states and resolves it to a
      * [NotaryChangeLedgerTransaction] so the signatures can be verified.
diff --git a/core/src/main/kotlin/net/corda/core/transactions/TransactionWithSignatures.kt b/core/src/main/kotlin/net/corda/core/transactions/TransactionWithSignatures.kt
index ab25d68064..1909168198 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/TransactionWithSignatures.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/TransactionWithSignatures.kt
@@ -1,6 +1,8 @@
 package net.corda.core.transactions
 
+import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.NamedByHash
+import net.corda.core.contracts.TransactionState
 import net.corda.core.crypto.TransactionSignature
 import net.corda.core.crypto.isFulfilledBy
 import net.corda.core.transactions.SignedTransaction.SignaturesMissingException
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
index bf1e504bf3..8d1c0d0274 100644
--- a/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
@@ -38,13 +38,11 @@ class MyValidatingNotaryFlow(otherSide: FlowSession, service: MyCustomValidating
             val stx = subFlow(ReceiveTransactionFlow(otherSideSession, checkSufficientSignatures = false))
             val notary = stx.notary
             checkNotary(notary)
-            var timeWindow: TimeWindow? = null
-            val transactionWithSignatures = if (stx.isNotaryChangeTransaction()) {
-                stx.resolveNotaryChangeTransaction(serviceHub)
-            } else {
-                timeWindow = stx.tx.timeWindow
-                stx
-            }
+            val timeWindow: TimeWindow? = if (stx.isNotaryChangeTransaction())
+                null
+            else
+                stx.tx.timeWindow
+            val transactionWithSignatures = stx.resolveTransactionWithSignatures(serviceHub)
             checkSignatures(transactionWithSignatures)
             return TransactionParts(stx.id, stx.inputs, timeWindow, notary!!)
         } catch (e: Exception) {
diff --git a/node/src/main/kotlin/net/corda/node/internal/StartedNode.kt b/node/src/main/kotlin/net/corda/node/internal/StartedNode.kt
index 501b8f926a..e0320d9c62 100644
--- a/node/src/main/kotlin/net/corda/node/internal/StartedNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/StartedNode.kt
@@ -35,8 +35,6 @@ class StateLoaderImpl(private val validatedTransactions: TransactionStorage) : S
     @Throws(TransactionResolutionException::class)
     override fun loadState(stateRef: StateRef): TransactionState<*> {
         val stx = validatedTransactions.getTransaction(stateRef.txhash) ?: throw TransactionResolutionException(stateRef.txhash)
-        return if (stx.isNotaryChangeTransaction()) {
-            stx.resolveNotaryChangeTransaction(this).outputs[stateRef.index]
-        } else stx.tx.outputs[stateRef.index]
+        return stx.resolveBaseTransaction(this).outputs[stateRef.index]
     }
 }
diff --git a/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryFlow.kt b/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryFlow.kt
index 2cee47aa89..8ce7ba6365 100644
--- a/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryFlow.kt
+++ b/node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryFlow.kt
@@ -25,13 +25,11 @@ class ValidatingNotaryFlow(otherSideSession: FlowSession, service: TrustedAuthor
             val stx = subFlow(ReceiveTransactionFlow(otherSideSession, checkSufficientSignatures = false))
             val notary = stx.notary
             checkNotary(notary)
-            var timeWindow: TimeWindow? = null
-            val transactionWithSignatures = if (stx.isNotaryChangeTransaction()) {
-                stx.resolveNotaryChangeTransaction(serviceHub)
-            } else {
-                timeWindow = stx.tx.timeWindow
-                stx
-            }
+            val timeWindow: TimeWindow? = if (stx.isNotaryChangeTransaction())
+                null
+            else
+                stx.tx.timeWindow
+            val transactionWithSignatures = stx.resolveTransactionWithSignatures(serviceHub)
             checkSignatures(transactionWithSignatures)
             return TransactionParts(stx.id, stx.inputs, timeWindow, notary!!)
         } catch (e: Exception) {

From 34dbbe626bbea8bb1e8500b8f3c120ea6c58a69c Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Tue, 10 Oct 2017 13:46:25 +0100
Subject: [PATCH 144/185] Add confidential identity support to cash exit logic
 (#1849)

generateExit() previously required all states to have a single owner, which was used as the change output's owner. This deprecates that function but enables it to work as expected using `firstOrNull()` instead of `singleOrNull()`, and adds new functions which take in the change output's owner.
---
 .../finance/contracts/asset/OnLedgerAsset.kt  | 65 +++++++++++++++++--
 .../finance/contracts/asset/CashTests.kt      | 36 ++++++----
 2 files changed, 80 insertions(+), 21 deletions(-)

diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/OnLedgerAsset.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/OnLedgerAsset.kt
index 9f93a80a8c..d64bb817b2 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/OnLedgerAsset.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/OnLedgerAsset.kt
@@ -230,12 +230,36 @@ abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : C
          */
         @Throws(InsufficientBalanceException::class)
         @JvmStatic
-        fun <S : FungibleAsset<T>, T : Any> generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>,
-                                                         assetStates: List<StateAndRef<S>>,
-                                                         deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>,
-                                                         generateMoveCommand: () -> CommandData,
-                                                         generateExitCommand: (Amount<Issued<T>>) -> CommandData): Set<PublicKey> {
-            val owner = assetStates.map { it.state.data.owner }.toSet().singleOrNull() ?: throw InsufficientBalanceException(amountIssued)
+        @Deprecated("Replaced with generateExit() which takes in a party to pay change to")
+        fun <S : FungibleAsset<T>, T: Any> generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>,
+                                                        assetStates: List<StateAndRef<S>>,
+                                                        deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>,
+                                                        generateMoveCommand: () -> CommandData,
+                                                        generateExitCommand: (Amount<Issued<T>>) -> CommandData): Set<PublicKey> {
+            val owner = assetStates.map { it.state.data.owner }.toSet().firstOrNull() ?: throw InsufficientBalanceException(amountIssued)
+            return generateExit(tx, amountIssued, assetStates, owner, deriveState, generateMoveCommand, generateExitCommand)
+        }
+
+        /**
+         * Generate an transaction exiting fungible assets from the ledger.
+         *
+         * @param tx transaction builder to add states and commands to.
+         * @param amountIssued the amount to be exited, represented as a quantity of issued currency.
+         * @param assetStates the asset states to take funds from. No checks are done about ownership of these states, it is
+         * the responsibility of the caller to check that they do not attempt to exit funds held by others.
+         * @param payChangeTo party to pay any change to; this is normally a confidential identity of the calling
+         * party.
+         * @return the public keys which must sign the transaction for it to be valid.
+         */
+        @Throws(InsufficientBalanceException::class)
+        @JvmStatic
+        fun <S : FungibleAsset<T>, T: Any> generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>,
+                                                        assetStates: List<StateAndRef<S>>,
+                                                        payChangeTo: AbstractParty,
+                                                        deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>,
+                                                        generateMoveCommand: () -> CommandData,
+                                                        generateExitCommand: (Amount<Issued<T>>) -> CommandData): Set<PublicKey> {
+            require(assetStates.isNotEmpty()) { "List of states to exit cannot be empty." }
             val currency = amountIssued.token.product
             val amount = Amount(amountIssued.quantity, currency)
             var acceptableCoins = assetStates.filter { ref -> ref.state.data.amount.token == amountIssued.token }
@@ -255,7 +279,7 @@ abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : C
 
             val outputs = if (change != null) {
                 // Add a change output and adjust the last output downwards.
-                listOf(deriveState(gathered.last().state, change, owner))
+                listOf(deriveState(gathered.last().state, change, payChangeTo))
             } else emptyList()
 
             for (state in gathered) tx.addInputState(state)
@@ -295,9 +319,12 @@ abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : C
      * @param amountIssued the amount to be exited, represented as a quantity of issued currency.
      * @param assetStates the asset states to take funds from. No checks are done about ownership of these states, it is
      * the responsibility of the caller to check that they do not exit funds held by others.
+     * @param payChangeTo party to pay any change to; this is normally a confidential identity of the calling
+     * party.
      * @return the public keys which must sign the transaction for it to be valid.
      */
     @Throws(InsufficientBalanceException::class)
+    @Deprecated("Replaced with generateExit() which takes in a party to pay change to")
     fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>,
                      assetStates: List<StateAndRef<S>>): Set<PublicKey> {
         return generateExit(
@@ -310,6 +337,30 @@ abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : C
         )
     }
 
+    /**
+     * Generate an transaction exiting assets from the ledger.
+     *
+     * @param tx transaction builder to add states and commands to.
+     * @param amountIssued the amount to be exited, represented as a quantity of issued currency.
+     * @param assetStates the asset states to take funds from. No checks are done about ownership of these states, it is
+     * the responsibility of the caller to check that they do not exit funds held by others.
+     * @return the public keys which must sign the transaction for it to be valid.
+     */
+    @Throws(InsufficientBalanceException::class)
+    fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>,
+                     assetStates: List<StateAndRef<S>>,
+                     payChangeTo: AbstractParty): Set<PublicKey> {
+        return generateExit(
+                tx,
+                amountIssued,
+                assetStates,
+                payChangeTo,
+                deriveState = { state, amount, owner -> deriveState(state, amount, owner) },
+                generateMoveCommand = { -> generateMoveCommand() },
+                generateExitCommand = { amount -> generateExitCommand(amount) }
+        )
+    }
+
     abstract fun generateExitCommand(amount: Amount<Issued<T>>): CommandData
     abstract fun generateMoveCommand(): MoveCommand
 
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
index fa7eb3c051..537f347bd6 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
@@ -6,6 +6,7 @@ import net.corda.core.crypto.generateKeyPair
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.AnonymousParty
 import net.corda.core.identity.Party
+import net.corda.core.node.ServiceHub
 import net.corda.core.node.services.VaultService
 import net.corda.core.node.services.queryBy
 import net.corda.core.transactions.TransactionBuilder
@@ -480,9 +481,9 @@ class CashTests : TestDependencyInjectionBase() {
     val THEIR_IDENTITY_1 = AnonymousParty(MINI_CORP_PUBKEY)
     val THEIR_IDENTITY_2 = AnonymousParty(CHARLIE_PUBKEY)
 
-    fun makeCash(amount: Amount<Currency>, corp: Party, depositRef: Byte = 1) =
+    fun makeCash(amount: Amount<Currency>, issuer: AbstractParty, depositRef: Byte = 1) =
             StateAndRef(
-                    TransactionState<Cash.State>(Cash.State(amount `issued by` corp.ref(depositRef), OUR_IDENTITY_1), Cash.PROGRAM_ID, DUMMY_NOTARY),
+                    TransactionState<Cash.State>(Cash.State(amount `issued by` issuer.ref(depositRef), OUR_IDENTITY_1), Cash.PROGRAM_ID, DUMMY_NOTARY),
                     StateRef(SecureHash.randomSHA256(), Random().nextInt(32))
             )
 
@@ -496,10 +497,11 @@ class CashTests : TestDependencyInjectionBase() {
     /**
      * Generate an exit transaction, removing some amount of cash from the ledger.
      */
-    private fun makeExit(amount: Amount<Currency>, corp: Party, depositRef: Byte = 1): WireTransaction {
+    private fun makeExit(serviceHub: ServiceHub, amount: Amount<Currency>, issuer: Party, depositRef: Byte = 1): WireTransaction {
         val tx = TransactionBuilder(DUMMY_NOTARY)
-        Cash().generateExit(tx, Amount(amount.quantity, Issued(corp.ref(depositRef), amount.token)), WALLET)
-        return tx.toWireTransaction(miniCorpServices)
+        val payChangeTo = serviceHub.keyManagementService.freshKeyAndCert(MINI_CORP_IDENTITY, false).party
+        Cash().generateExit(tx, Amount(amount.quantity, Issued(issuer.ref(depositRef), amount.token)), WALLET, payChangeTo)
+        return tx.toWireTransaction(serviceHub)
     }
 
     private fun makeSpend(amount: Amount<Currency>, dest: AbstractParty): WireTransaction {
@@ -516,7 +518,7 @@ class CashTests : TestDependencyInjectionBase() {
     @Test
     fun generateSimpleExit() {
         initialiseTestSerialization()
-        val wtx = makeExit(100.DOLLARS, MEGA_CORP, 1)
+        val wtx = makeExit(miniCorpServices, 100.DOLLARS, MEGA_CORP, 1)
         assertEquals(WALLET[0].ref, wtx.inputs[0])
         assertEquals(0, wtx.outputs.size)
 
@@ -532,10 +534,16 @@ class CashTests : TestDependencyInjectionBase() {
     @Test
     fun generatePartialExit() {
         initialiseTestSerialization()
-        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.getOutput(0))
+        val wtx = makeExit(miniCorpServices, 50.DOLLARS, MEGA_CORP, 1)
+        val actualInput = wtx.inputs.single()
+        // Filter the available inputs and confirm exactly one has been used
+        val expectedInputs = WALLET.filter { it.ref == actualInput }
+        assertEquals(1, expectedInputs.size)
+        val inputState = expectedInputs.single()
+        val actualChange = wtx.outputs.single().data as Cash.State
+        val expectedChangeAmount = (inputState.state.data as Cash.State).amount.quantity - 50.DOLLARS.quantity
+        val expectedChange = WALLET[0].state.data.copy(amount = WALLET[0].state.data.amount.copy(quantity = expectedChangeAmount), owner = actualChange.owner)
+        assertEquals(expectedChange, wtx.getOutput(0))
     }
 
     /**
@@ -544,7 +552,7 @@ class CashTests : TestDependencyInjectionBase() {
     @Test
     fun generateAbsentExit() {
         initialiseTestSerialization()
-        assertFailsWith<InsufficientBalanceException> { makeExit(100.POUNDS, MEGA_CORP, 1) }
+        assertFailsWith<InsufficientBalanceException> { makeExit(miniCorpServices, 100.POUNDS, MEGA_CORP, 1) }
     }
 
     /**
@@ -553,7 +561,7 @@ class CashTests : TestDependencyInjectionBase() {
     @Test
     fun generateInvalidReferenceExit() {
         initialiseTestSerialization()
-        assertFailsWith<InsufficientBalanceException> { makeExit(100.POUNDS, MEGA_CORP, 2) }
+        assertFailsWith<InsufficientBalanceException> { makeExit(miniCorpServices, 100.POUNDS, MEGA_CORP, 2) }
     }
 
     /**
@@ -562,7 +570,7 @@ class CashTests : TestDependencyInjectionBase() {
     @Test
     fun generateInsufficientExit() {
         initialiseTestSerialization()
-        assertFailsWith<InsufficientBalanceException> { makeExit(1000.DOLLARS, MEGA_CORP, 1) }
+        assertFailsWith<InsufficientBalanceException> { makeExit(miniCorpServices, 1000.DOLLARS, MEGA_CORP, 1) }
     }
 
     /**
@@ -571,7 +579,7 @@ class CashTests : TestDependencyInjectionBase() {
     @Test
     fun generateOwnerWithNoStatesExit() {
         initialiseTestSerialization()
-        assertFailsWith<InsufficientBalanceException> { makeExit(100.POUNDS, CHARLIE, 1) }
+        assertFailsWith<InsufficientBalanceException> { makeExit(miniCorpServices, 100.POUNDS, CHARLIE, 1) }
     }
 
     /**

From bd53a22efaf4d7a05d260e6fd859a2be28952198 Mon Sep 17 00:00:00 2001
From: Shams Asari <shams.asari@r3.com>
Date: Mon, 9 Oct 2017 18:57:09 +0100
Subject: [PATCH 145/185] Removed extraAdvertisedServiceIds config

The remaining use for it was the finance CorDapp for permissioning CCY issuers. Instead this is now taken from a custom config in node.conf.
---
 .idea/compiler.xml                            |   1 +
 build.gradle                                  |   3 -
 config/dev/generalnodea.conf                  |   1 -
 config/dev/generalnodeb.conf                  |   1 -
 constants.properties                          |   2 +-
 .../net/corda/core/flows/AttachmentTests.kt   |   5 +-
 .../AttachmentSerializationTest.kt            |   5 +-
 docs/source/deploying-a-node.rst              |   4 -
 docs/source/example-code/build.gradle         |   2 -
 .../resources/example-network-map-node.conf   |   1 -
 .../src/main/resources/example-node.conf      |   1 -
 docs/source/hello-world-running.rst           |   3 -
 docs/source/node-services.rst                 |   8 +-
 finance/build.gradle                          |  20 ++
 .../finance/flows/CashConfigDataFlowTest.kt   |  20 ++
 .../corda/finance/flows/CashConfigDataFlow.kt |  53 +++--
 .../AbstractStateReplacementFlowTest.java     |  22 --
 .../java/net/corda/cordform/CordformNode.java |   7 +-
 .../main/groovy/net/corda/plugins/Node.groovy |   4 +-
 .../corda/nodeapi/config/ConfigUtilities.kt   |   3 +-
 .../corda/nodeapi/config/ConfigParsingTest.kt |  11 +
 .../kotlin/net/corda/node/BootTests.kt        |  10 +-
 .../net/corda/node/internal/AbstractNode.kt   |   2 -
 .../kotlin/net/corda/node/internal/Node.kt    |   6 +-
 .../net/corda/node/internal/NodeStartup.kt    |   8 +-
 .../node/services/config/NodeConfiguration.kt |   9 -
 .../statemachine/FlowStateMachineImpl.kt      |  17 +-
 .../node/messaging/TwoPartyTradeFlowTests.kt  |  26 +--
 .../config/FullNodeConfigurationTest.kt       |   1 -
 .../network/AbstractNetworkMapServiceTest.kt  |   5 +-
 .../PersistentNetworkMapServiceTest.kt        |   6 +-
 .../statemachine/FlowFrameworkTests.kt        |  10 +-
 samples/attachment-demo/build.gradle          |   3 -
 samples/bank-of-corda-demo/build.gradle       |   4 +-
 samples/irs-demo/build.gradle                 |   3 -
 .../net/corda/netmap/simulation/Simulation.kt |  29 +--
 samples/simm-valuation-demo/build.gradle      |   4 -
 samples/trader-demo/build.gradle              |   4 -
 .../kotlin/net/corda/testing/driver/Driver.kt |  10 +-
 .../testing/internal/demorun/CordformUtils.kt |   5 -
 .../kotlin/net/corda/testing/node/MockNode.kt |  29 +--
 .../net/corda/testing/node/NodeBasedTest.kt   |  12 +-
 tools/demobench/README.md                     |   3 -
 tools/demobench/build.gradle                  |   1 +
 .../net/corda/demobench/explorer/Explorer.kt  |  32 +--
 .../corda/demobench/model/InstallFactory.kt   |  64 ++---
 .../corda/demobench/model/NetworkMapConfig.kt |  10 -
 .../net/corda/demobench/model/NodeConfig.kt   | 124 +++++-----
 .../corda/demobench/model/NodeController.kt   | 113 +++++----
 .../net/corda/demobench/model/NodeData.kt     |  10 +-
 .../demobench/model/ServiceController.kt      |  44 ----
 .../kotlin/net/corda/demobench/model/User.kt  |  15 --
 .../demobench/plugin/PluginController.kt      |  10 +-
 .../demobench/profile/ProfileController.kt    |   6 +-
 .../kotlin/net/corda/demobench/rpc/NodeRPC.kt |  11 +-
 .../net/corda/demobench/views/NodeTabView.kt  |  31 ++-
 .../corda/demobench/views/NodeTerminalView.kt |  29 +--
 .../net/corda/demobench/web/WebServer.kt      |  19 +-
 .../src/main/resources/services.conf          |   6 -
 .../net/corda/demobench/LoggingTestSuite.kt   |   2 -
 .../demobench/model/NetworkMapConfigTest.kt   |  22 --
 .../corda/demobench/model/NodeConfigTest.kt   | 221 +++---------------
 .../demobench/model/NodeControllerTest.kt     |  57 +++--
 .../demobench/model/ServiceControllerTest.kt  |  44 ----
 .../net/corda/demobench/model/UserTest.kt     |  47 ----
 .../test/resources/duplicate-services.conf    |   3 -
 .../src/test/resources/empty-services.conf    |   0
 .../src/test/resources/notary-services.conf   |   2 -
 .../net/corda/explorer/ExplorerSimulation.kt  |  14 +-
 .../corda/explorer/model/IssuerModelTest.kt   |  27 ---
 70 files changed, 441 insertions(+), 906 deletions(-)
 create mode 100644 finance/src/integration-test/kotlin/net/corda/finance/flows/CashConfigDataFlowTest.kt
 delete mode 100644 finance/src/test/java/net/corda/finance/flows/AbstractStateReplacementFlowTest.java
 delete mode 100644 tools/demobench/src/main/kotlin/net/corda/demobench/model/NetworkMapConfig.kt
 delete mode 100644 tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt
 delete mode 100644 tools/demobench/src/main/kotlin/net/corda/demobench/model/User.kt
 delete mode 100644 tools/demobench/src/main/resources/services.conf
 delete mode 100644 tools/demobench/src/test/kotlin/net/corda/demobench/model/NetworkMapConfigTest.kt
 delete mode 100644 tools/demobench/src/test/kotlin/net/corda/demobench/model/ServiceControllerTest.kt
 delete mode 100644 tools/demobench/src/test/kotlin/net/corda/demobench/model/UserTest.kt
 delete mode 100644 tools/demobench/src/test/resources/duplicate-services.conf
 delete mode 100644 tools/demobench/src/test/resources/empty-services.conf
 delete mode 100644 tools/demobench/src/test/resources/notary-services.conf
 delete mode 100644 tools/explorer/src/test/kotlin/net/corda/explorer/model/IssuerModelTest.kt

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index 3516efcb93..5df761b918 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -43,6 +43,7 @@
       <module name="explorer-capsule_test" target="1.6" />
       <module name="explorer_main" target="1.8" />
       <module name="explorer_test" target="1.8" />
+      <module name="finance_integrationTest" target="1.8" />
       <module name="finance_main" target="1.8" />
       <module name="finance_test" target="1.8" />
       <module name="gradle-plugins-cordform-common_main" target="1.8" />
diff --git a/build.gradle b/build.gradle
index 9b19ced795..f8a21b7789 100644
--- a/build.gradle
+++ b/build.gradle
@@ -235,13 +235,11 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     node {
         name "O=Controller,OU=corda,L=London,C=GB"
         notary = [validating : true]
-        advertisedServices = []
         p2pPort 10002
         cordapps = []
     }
     node {
         name "O=Bank A,OU=corda,L=London,C=GB"
-        advertisedServices = []
         p2pPort 10012
         rpcPort 10013
         webPort 10014
@@ -249,7 +247,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     }
     node {
         name "O=Bank B,OU=corda,L=London,C=GB"
-        advertisedServices = []
         p2pPort 10007
         rpcPort 10008
         webPort 10009
diff --git a/config/dev/generalnodea.conf b/config/dev/generalnodea.conf
index 16eb90f526..0089d1cb24 100644
--- a/config/dev/generalnodea.conf
+++ b/config/dev/generalnodea.conf
@@ -4,7 +4,6 @@ trustStorePassword : "trustpass"
 p2pAddress : "localhost:10002"
 rpcAddress : "localhost:10003"
 webAddress : "localhost:10004"
-extraAdvertisedServiceIds : [ "corda.interest_rates" ]
 networkMapService : {
   address : "localhost:10000"
   legalName : "O=Network Map Service,OU=corda,L=London,C=GB"
diff --git a/config/dev/generalnodeb.conf b/config/dev/generalnodeb.conf
index 1eb839aece..af4e26cc27 100644
--- a/config/dev/generalnodeb.conf
+++ b/config/dev/generalnodeb.conf
@@ -4,7 +4,6 @@ trustStorePassword : "trustpass"
 p2pAddress : "localhost:10005"
 rpcAddress : "localhost:10006"
 webAddress : "localhost:10007"
-extraAdvertisedServiceIds : [ "corda.interest_rates" ]
 networkMapService : {
   address : "localhost:10000"
   legalName : "O=Network Map Service,OU=corda,L=London,C=GB"
diff --git a/constants.properties b/constants.properties
index 165810dcd2..4591e03dea 100644
--- a/constants.properties
+++ b/constants.properties
@@ -1,4 +1,4 @@
-gradlePluginsVersion=2.0.0
+gradlePluginsVersion=2.0.1
 kotlinVersion=1.1.50
 guavaVersion=21.0
 bouncycastleVersion=1.57
diff --git a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
index 034c28c834..6a2bf1ef8b 100644
--- a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
@@ -118,10 +118,9 @@ class AttachmentTests {
         // Make a node that doesn't do sanity checking at load time.
         val aliceNode = mockNet.createNotaryNode(legalName = ALICE.name, nodeFactory = object : MockNetwork.Factory<MockNetwork.MockNode> {
             override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                                advertisedServices: Set<ServiceInfo>, id: Int,
-                                notaryIdentity: Pair<ServiceInfo, KeyPair>?,
+                                id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                                 entropyRoot: BigInteger): MockNetwork.MockNode {
-                return object : MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
+                return object : MockNetwork.MockNode(config, network, networkMapAddr, id, notaryIdentity, entropyRoot) {
                     override fun start() = super.start().apply { attachments.checkAttachmentsOnLoad = false }
                 }
             }
diff --git a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
index 4b14705669..89bc81dad9 100644
--- a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
+++ b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
@@ -162,9 +162,8 @@ class AttachmentSerializationTest {
         client.dispose()
         client = mockNet.createNode(client.internals.id, object : MockNetwork.Factory<MockNetwork.MockNode> {
             override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                                advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
-                                entropyRoot: BigInteger): MockNetwork.MockNode {
-                return object : MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
+                                id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): MockNetwork.MockNode {
+                return object : MockNetwork.MockNode(config, network, networkMapAddr, id, notaryIdentity, entropyRoot) {
                     override fun start() = super.start().apply { attachments.checkAttachmentsOnLoad = checkAttachmentsOnLoad }
                 }
             }
diff --git a/docs/source/deploying-a-node.rst b/docs/source/deploying-a-node.rst
index ec15b75d8b..4457b7d38c 100644
--- a/docs/source/deploying-a-node.rst
+++ b/docs/source/deploying-a-node.rst
@@ -21,7 +21,6 @@ notary/network map node:
         node {
             name "O=Controller,OU=corda,L=London,C=UK"
             notary = [validating : true]
-            advertisedServices = []
             p2pPort 10002
             rpcPort 10003
             webPort 10004
@@ -29,7 +28,6 @@ notary/network map node:
         }
         node {
             name "CN=NodeA,O=NodeA,L=London,C=UK"
-            advertisedServices = []
             p2pPort 10005
             rpcPort 10006
             webPort 10007
@@ -38,7 +36,6 @@ notary/network map node:
         }
         node {
             name "CN=NodeB,O=NodeB,L=New York,C=US"
-            advertisedServices = []
             p2pPort 10008
             rpcPort 10009
             webPort 10010
@@ -47,7 +44,6 @@ notary/network map node:
         }
         node {
             name "CN=NodeC,O=NodeC,L=Paris,C=FR"
-            advertisedServices = []
             p2pPort 10011
             rpcPort 10012
             webPort 10013
diff --git a/docs/source/example-code/build.gradle b/docs/source/example-code/build.gradle
index ae0b57fc34..a3ea77f4d8 100644
--- a/docs/source/example-code/build.gradle
+++ b/docs/source/example-code/build.gradle
@@ -77,7 +77,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     node {
         name "O=Notary Service,OU=corda,L=London,C=GB"
         notary = [validating : true]
-        advertisedServices = []
         p2pPort 10002
         rpcPort 10003
         webPort 10004
@@ -85,7 +84,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     }
     node {
         name "O=Alice Corp,L=London,C=GB"
-        advertisedServices = []
         p2pPort 10005
         rpcPort 10006
         webPort 10007
diff --git a/docs/source/example-code/src/main/resources/example-network-map-node.conf b/docs/source/example-code/src/main/resources/example-network-map-node.conf
index fe00d9aa38..e75807bbc7 100644
--- a/docs/source/example-code/src/main/resources/example-network-map-node.conf
+++ b/docs/source/example-code/src/main/resources/example-network-map-node.conf
@@ -4,5 +4,4 @@ trustStorePassword : "trustpass"
 p2pAddress : "my-network-map:10000"
 webAddress : "localhost:10001"
 sshdAddress : "localhost:10002"
-extraAdvertisedServiceIds : []
 useHTTPS : false
diff --git a/docs/source/example-code/src/main/resources/example-node.conf b/docs/source/example-code/src/main/resources/example-node.conf
index d12273c18a..c9bad1eb5b 100644
--- a/docs/source/example-code/src/main/resources/example-node.conf
+++ b/docs/source/example-code/src/main/resources/example-node.conf
@@ -10,7 +10,6 @@ dataSourceProperties : {
 p2pAddress : "my-corda-node:10002"
 rpcAddress : "my-corda-node:10003"
 webAddress : "localhost:10004"
-extraAdvertisedServiceIds : [ "corda.interest_rates" ]
 networkMapService : {
     address : "my-network-map:10000"
     legalName : "O=Network Map Service,OU=corda,L=London,C=GB"
diff --git a/docs/source/hello-world-running.rst b/docs/source/hello-world-running.rst
index ae91fe0907..ae1592fa82 100644
--- a/docs/source/hello-world-running.rst
+++ b/docs/source/hello-world-running.rst
@@ -29,14 +29,12 @@ Let's take a look at the nodes we're going to deploy. Open the project's ``build
             node {
                 name "O=Controller,L=London,C=GB"
                 notary = [validating : true]
-                advertisedServices = []
                 p2pPort 10002
                 rpcPort 10003
                 cordapps = ["net.corda:corda-finance:$corda_release_version"]
             }
             node {
                 name "O=PartyA,L=London,C=GB"
-                advertisedServices = []
                 p2pPort 10005
                 rpcPort 10006
                 webPort 10007
@@ -45,7 +43,6 @@ Let's take a look at the nodes we're going to deploy. Open the project's ``build
             }
             node {
                 name "O=PartyB,L=New York,C=US"
-                advertisedServices = []
                 p2pPort 10008
                 rpcPort 10009
                 webPort 10010
diff --git a/docs/source/node-services.rst b/docs/source/node-services.rst
index 8e25eb6115..3ab92255b6 100644
--- a/docs/source/node-services.rst
+++ b/docs/source/node-services.rst
@@ -295,12 +295,8 @@ NotaryService (SimpleNotaryService, ValidatingNotaryService, RaftValidatingNotar
 
 The ``NotaryService`` is an abstract base class for the various concrete 
 implementations of the Notary server flow. By default, a node does 
-not run any ``NotaryService`` server component. However, the appropriate 
-implementation service is automatically started if the relevant 
-``ServiceType`` id is included in the node's 
-``extraAdvertisedServiceIds`` configuration property. The node will then 
-advertise itself as a Notary via the ``NetworkMapService`` and may then 
-participate in controlling state uniqueness when contacted by nodes 
+not run any ``NotaryService`` server component. For that you need to specify the ``notary`` config.
+The node may then participate in controlling state uniqueness when contacted by nodes
 using the ``NotaryFlow.Client`` ``subFlow``. The 
 ``SimpleNotaryService`` only offers protection against double spend, but 
 does no further verification. The ``ValidatingNotaryService`` checks 
diff --git a/finance/build.gradle b/finance/build.gradle
index 3386d94b40..c642969785 100644
--- a/finance/build.gradle
+++ b/finance/build.gradle
@@ -10,12 +10,25 @@ apply plugin: 'com.jfrog.artifactory'
 
 description 'Corda finance modules'
 
+sourceSets {
+    integrationTest {
+        kotlin {
+            compileClasspath += main.output + test.output
+            runtimeClasspath += main.output + test.output
+            srcDir file('src/integration-test/kotlin')
+        }
+    }
+}
+
 dependencies {
     // Note the :finance module is a CorDapp in its own right
     // and CorDapps using :finance features should use 'cordapp' not 'compile' linkage.
     cordaCompile project(':core')
     cordaCompile project(':confidential-identities')
 
+    // TODO Remove this once we have app configs
+    compile "com.typesafe:config:$typesafe_config_version"
+
     testCompile project(':test-utils')
     testCompile project(path: ':core', configuration: 'testArtifacts')
     testCompile "junit:junit:$junit_version"
@@ -23,6 +36,8 @@ dependencies {
 
 configurations {
     testArtifacts.extendsFrom testRuntime
+    integrationTestCompile.extendsFrom testCompile
+    integrationTestRuntime.extendsFrom testRuntime
 }
 
 task testJar(type: Jar) {
@@ -30,6 +45,11 @@ task testJar(type: Jar) {
     from sourceSets.test.output
 }
 
+task integrationTest(type: Test, dependsOn: []) {
+    testClassesDirs = sourceSets.integrationTest.output.classesDirs
+    classpath = sourceSets.integrationTest.runtimeClasspath
+}
+
 artifacts {
     testArtifacts testJar
 }
diff --git a/finance/src/integration-test/kotlin/net/corda/finance/flows/CashConfigDataFlowTest.kt b/finance/src/integration-test/kotlin/net/corda/finance/flows/CashConfigDataFlowTest.kt
new file mode 100644
index 0000000000..49351f1e13
--- /dev/null
+++ b/finance/src/integration-test/kotlin/net/corda/finance/flows/CashConfigDataFlowTest.kt
@@ -0,0 +1,20 @@
+package net.corda.finance.flows
+
+import net.corda.core.messaging.startFlow
+import net.corda.core.utilities.getOrThrow
+import net.corda.finance.EUR
+import net.corda.finance.USD
+import net.corda.testing.driver.driver
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class CashConfigDataFlowTest {
+    @Test
+    fun `issuable currencies are read in from node config`() {
+        driver {
+            val node = startNode(customOverrides = mapOf("issuableCurrencies" to listOf("EUR", "USD"))).getOrThrow()
+            val config = node.rpc.startFlow(::CashConfigDataFlow).returnValue.getOrThrow()
+            assertThat(config.issuableCurrencies).containsExactly(EUR, USD)
+        }
+    }
+}
\ No newline at end of file
diff --git a/finance/src/main/kotlin/net/corda/finance/flows/CashConfigDataFlow.kt b/finance/src/main/kotlin/net/corda/finance/flows/CashConfigDataFlow.kt
index 59d50403ca..c202d5633c 100644
--- a/finance/src/main/kotlin/net/corda/finance/flows/CashConfigDataFlow.kt
+++ b/finance/src/main/kotlin/net/corda/finance/flows/CashConfigDataFlow.kt
@@ -1,38 +1,59 @@
 package net.corda.finance.flows
 
 import co.paralleluniverse.fibers.Suspendable
-import net.corda.core.flows.FlowException
+import com.typesafe.config.ConfigFactory
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.StartableByRPC
+import net.corda.core.internal.declaredField
+import net.corda.core.internal.div
+import net.corda.core.internal.read
+import net.corda.core.node.AppServiceHub
+import net.corda.core.node.services.CordaService
 import net.corda.core.serialization.CordaSerializable
+import net.corda.core.serialization.SingletonSerializeAsToken
 import net.corda.finance.CHF
 import net.corda.finance.EUR
 import net.corda.finance.GBP
 import net.corda.finance.USD
+import net.corda.finance.flows.ConfigHolder.Companion.supportedCurrencies
+import java.nio.file.Path
 import java.util.*
 
+// TODO Until apps have access to their own config, we'll hack things by first getting the baseDirectory, read the node.conf
+// again to get our config and store it here for access by our flow
+@CordaService
+class ConfigHolder(services: AppServiceHub) : SingletonSerializeAsToken() {
+    companion object {
+        val supportedCurrencies = listOf(USD, GBP, CHF, EUR)
+    }
+
+    val issuableCurrencies: List<Currency>
+
+    init {
+        // Warning!! You are about to see a major hack!
+        val baseDirectory = services.declaredField<Any>("serviceHub").value
+                .let { it.javaClass.getMethod("getConfiguration").apply { isAccessible = true }.invoke(it) }
+                .declaredField<Path>("baseDirectory").value
+        val config = (baseDirectory / "node.conf").read { ConfigFactory.parseReader(it.reader()) }
+        if (config.hasPath("issuableCurrencies")) {
+            issuableCurrencies = config.getStringList("issuableCurrencies").map { Currency.getInstance(it) }
+            require(supportedCurrencies.containsAll(issuableCurrencies))
+        } else {
+            issuableCurrencies = emptyList()
+        }
+    }
+}
+
+
 /**
  * Flow to obtain cash cordapp app configuration.
  */
 @StartableByRPC
 class CashConfigDataFlow : FlowLogic<CashConfiguration>() {
-    companion object {
-        private val supportedCurrencies = listOf(USD, GBP, CHF, EUR)
-    }
-
     @Suspendable
     override fun call(): CashConfiguration {
-        val issuableCurrencies = supportedCurrencies.mapNotNull {
-            try {
-                // Currently it uses checkFlowPermission to determine the list of issuable currency as a temporary hack.
-                // TODO: get the config from proper configuration source.
-                checkFlowPermission("corda.issuer.$it", emptyMap())
-                it
-            } catch (e: FlowException) {
-                null
-            }
-        }
-        return CashConfiguration(issuableCurrencies, supportedCurrencies)
+        val configHolder = serviceHub.cordaService(ConfigHolder::class.java)
+        return CashConfiguration(configHolder.issuableCurrencies, supportedCurrencies)
     }
 }
 
diff --git a/finance/src/test/java/net/corda/finance/flows/AbstractStateReplacementFlowTest.java b/finance/src/test/java/net/corda/finance/flows/AbstractStateReplacementFlowTest.java
deleted file mode 100644
index b753141ac5..0000000000
--- a/finance/src/test/java/net/corda/finance/flows/AbstractStateReplacementFlowTest.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package net.corda.finance.flows;
-
-import net.corda.core.flows.AbstractStateReplacementFlow;
-import net.corda.core.flows.FlowSession;
-import net.corda.core.transactions.SignedTransaction;
-import net.corda.core.utilities.ProgressTracker;
-import org.jetbrains.annotations.NotNull;
-
-@SuppressWarnings("unused")
-public class AbstractStateReplacementFlowTest {
-
-    // Acceptor used to have a type parameter of Unit which prevented Java code from subclassing it (https://youtrack.jetbrains.com/issue/KT-15964).
-    private static class TestAcceptorCanBeInheritedInJava extends AbstractStateReplacementFlow.Acceptor {
-        public TestAcceptorCanBeInheritedInJava(@NotNull FlowSession otherSideSession, @NotNull ProgressTracker progressTracker) {
-            super(otherSideSession, progressTracker);
-        }
-
-        @Override
-        protected void verifyProposal(@NotNull SignedTransaction stx, @NotNull AbstractStateReplacementFlow.Proposal proposal) {
-        }
-    }
-}
diff --git a/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java b/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
index 7ecaa9fce9..bca75347d8 100644
--- a/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
+++ b/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
@@ -23,11 +23,6 @@ public class CordformNode implements NodeDefinition {
         return name;
     }
 
-    /**
-     * A list of advertised services ID strings.
-     */
-    public List<String> advertisedServices = emptyList();
-
     /**
      * Set the RPC users for this node. This configuration block allows arbitrary configuration.
      * The recommended current structure is:
@@ -44,6 +39,8 @@ public class CordformNode implements NodeDefinition {
      */
     public Map<String, Object> notary = null;
 
+    public Map<String, Object> extraConfig = null;
+
     protected Config config = ConfigFactory.empty();
 
     public Config getConfig() {
diff --git a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
index 262f4df38c..f4169bf456 100644
--- a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
+++ b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
@@ -123,7 +123,9 @@ class Node extends CordformNode {
         if (notary) {
             config = config.withValue("notary", ConfigValueFactory.fromMap(notary))
         }
-        config = config.withValue('extraAdvertisedServiceIds', ConfigValueFactory.fromIterable(advertisedServices*.toString()))
+        if (extraConfig) {
+            config = config.withFallback(ConfigFactory.parseMap(extraConfig))
+        }
     }
 
     /**
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt b/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
index a67a55db37..cd1118928c 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/config/ConfigUtilities.kt
@@ -12,6 +12,7 @@ import net.corda.core.internal.uncheckedCast
 import net.corda.core.utilities.NetworkHostAndPort
 import org.slf4j.LoggerFactory
 import java.lang.reflect.Field
+import java.lang.reflect.Modifier.isStatic
 import java.lang.reflect.ParameterizedType
 import java.net.Proxy
 import java.net.URL
@@ -142,7 +143,7 @@ fun Any.toConfig(): Config = ConfigValueFactory.fromMap(toConfigMap()).toConfig(
 private fun Any.toConfigMap(): Map<String, Any> {
     val values = HashMap<String, Any>()
     for (field in javaClass.declaredFields) {
-        if (field.isSynthetic) continue
+        if (isStatic(field.modifiers) || field.isSynthetic) continue
         field.isAccessible = true
         val value = field.get(this) ?: continue
         val configValue = if (value is String || value is Boolean || value is Number) {
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/config/ConfigParsingTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/config/ConfigParsingTest.kt
index 8737ac9160..452e25ce78 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/config/ConfigParsingTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/config/ConfigParsingTest.kt
@@ -181,6 +181,11 @@ class ConfigParsingTest {
         assertThat(OldData("old").toConfig()).isEqualTo(config("newValue" to "old"))
     }
 
+    @Test
+    fun `static field`() {
+        assertThat(DataWithCompanion(3).toConfig()).isEqualTo(config("value" to 3))
+    }
+
     private inline fun <reified S : SingleData<V>, reified L : ListData<V>, V : Any> testPropertyType(
             value1: V,
             value2: V,
@@ -259,6 +264,12 @@ class ConfigParsingTest {
     data class OldData(
             @OldConfig("oldValue")
             val newValue: String)
+    data class DataWithCompanion(val value: Int) {
+        companion object {
+            @Suppress("unused")
+            val companionValue = 2
+        }
+    }
 
     enum class TestEnum { Value1, Value2 }
 }
\ No newline at end of file
diff --git a/node/src/integration-test/kotlin/net/corda/node/BootTests.kt b/node/src/integration-test/kotlin/net/corda/node/BootTests.kt
index 4b5c17a069..525790ea22 100644
--- a/node/src/integration-test/kotlin/net/corda/node/BootTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/BootTests.kt
@@ -1,20 +1,20 @@
 package net.corda.node
 
 import co.paralleluniverse.fibers.Suspendable
-import net.corda.core.internal.div
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.StartableByRPC
+import net.corda.core.internal.div
 import net.corda.core.messaging.startFlow
 import net.corda.core.utilities.getOrThrow
-import net.corda.testing.ALICE
 import net.corda.node.internal.NodeStartup
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
+import net.corda.nodeapi.User
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.nodeapi.internal.ServiceType
-import net.corda.nodeapi.User
+import net.corda.testing.ALICE
+import net.corda.testing.ProjectStructure.projectRootDir
 import net.corda.testing.driver.ListenProcessDeathException
 import net.corda.testing.driver.NetworkMapStartStrategy
-import net.corda.testing.ProjectStructure.projectRootDir
 import net.corda.testing.driver.driver
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
@@ -60,7 +60,7 @@ class BootTests {
     fun `node quits on failure to register with network map`() {
         val tooManyAdvertisedServices = (1..100).map { ServiceInfo(ServiceType.notary.getSubType("$it")) }.toSet()
         driver(networkMapStartStrategy = NetworkMapStartStrategy.Nominated(ALICE.name)) {
-            val future = startNode(providedName = ALICE.name, advertisedServices = tooManyAdvertisedServices)
+            val future = startNode(providedName = ALICE.name)
             assertFailsWith(ListenProcessDeathException::class) { future.getOrThrow() }
         }
     }
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 779604259d..0d92fe6df5 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -70,7 +70,6 @@ import net.corda.node.services.vault.NodeVaultService
 import net.corda.node.services.vault.VaultSoftLockManager
 import net.corda.node.utilities.*
 import net.corda.node.utilities.AddOrRemove.ADD
-import net.corda.nodeapi.internal.ServiceInfo
 import org.apache.activemq.artemis.utils.ReusableLatch
 import org.slf4j.Logger
 import rx.Observable
@@ -101,7 +100,6 @@ import net.corda.core.crypto.generateKeyPair as cryptoGenerateKeyPair
 // In theory the NodeInfo for the node should be passed in, instead, however currently this is constructed by the
 // AbstractNode. It should be possible to generate the NodeInfo outside of AbstractNode, so it can be passed in.
 abstract class AbstractNode(config: NodeConfiguration,
-                            val advertisedServices: Set<ServiceInfo>,
                             val platformClock: Clock,
                             protected val versionInfo: VersionInfo,
                             @VisibleForTesting val busyNodeLatch: ReusableLatch = ReusableLatch()) : SingletonSerializeAsToken() {
diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt
index 696098df29..84b126980a 100644
--- a/node/src/main/kotlin/net/corda/node/internal/Node.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt
@@ -21,7 +21,6 @@ import net.corda.node.services.RPCUserService
 import net.corda.node.services.RPCUserServiceImpl
 import net.corda.node.services.api.NetworkMapCacheInternal
 import net.corda.node.services.api.SchemaService
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.config.FullNodeConfiguration
 import net.corda.node.services.messaging.ArtemisMessagingServer
 import net.corda.node.services.messaging.ArtemisMessagingServer.Companion.ipDetectRequestProperty
@@ -60,14 +59,11 @@ import kotlin.system.exitProcess
  * loads important data off disk and starts listening for connections.
  *
  * @param configuration This is typically loaded from a TypeSafe HOCON configuration file.
- * @param advertisedServices The services this node advertises. This must be a subset of the services it runs,
- * but nodes are not required to advertise services they run (hence subset).
  */
 open class Node(override val configuration: FullNodeConfiguration,
-                advertisedServices: Set<ServiceInfo>,
                 versionInfo: VersionInfo,
                 val initialiseSerialization: Boolean = true
-) : AbstractNode(configuration, advertisedServices, createClock(configuration), versionInfo) {
+) : AbstractNode(configuration, createClock(configuration), versionInfo) {
     companion object {
         private val logger = loggerFor<Node>()
         var renderBasicInfoToConsole = true
diff --git a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
index 2294024e90..67a06aa2e9 100644
--- a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
@@ -12,7 +12,6 @@ import net.corda.node.services.transactions.bftSMaRtSerialFilter
 import net.corda.node.shell.InteractiveShell
 import net.corda.node.utilities.registration.HTTPNetworkRegistrationService
 import net.corda.node.utilities.registration.NetworkRegistrationHelper
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.nodeapi.internal.addShutdownHook
 import org.fusesource.jansi.Ansi
 import org.fusesource.jansi.AnsiConsole
@@ -86,13 +85,10 @@ open class NodeStartup(val args: Array<String>) {
 
     open protected fun preNetworkRegistration(conf: FullNodeConfiguration) = Unit
 
-    open protected fun createNode(conf: FullNodeConfiguration, versionInfo: VersionInfo, services: Set<ServiceInfo>): Node {
-        return Node(conf, services, versionInfo)
-    }
+    open protected fun createNode(conf: FullNodeConfiguration, versionInfo: VersionInfo): Node = Node(conf, versionInfo)
 
     open protected fun startNode(conf: FullNodeConfiguration, versionInfo: VersionInfo, startTime: Long, cmdlineOptions: CmdLineOptions) {
-        val advertisedServices = conf.calculateServices()
-        val node = createNode(conf, versionInfo, advertisedServices)
+        val node = createNode(conf, versionInfo)
         if (cmdlineOptions.justGenerateNodeInfo) {
             // Perform the minimum required start-up logic to be able to write a nodeInfo to disk
             node.generateNodeInfo()
diff --git a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
index 64b460b2ba..a72465ccee 100644
--- a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
+++ b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
@@ -7,7 +7,6 @@ import net.corda.node.internal.NetworkMapInfo
 import net.corda.node.services.messaging.CertificateChainCheckPolicy
 import net.corda.nodeapi.User
 import net.corda.nodeapi.config.NodeSSLConfiguration
-import net.corda.nodeapi.internal.ServiceInfo
 import java.net.URL
 import java.nio.file.Path
 import java.util.*
@@ -82,7 +81,6 @@ data class FullNodeConfiguration(
         // TODO This field is slightly redundant as p2pAddress is sufficient to hold the address of the node's MQ broker.
         // Instead this should be a Boolean indicating whether that broker is an internal one started by the node or an external one
         val messagingServerAddress: NetworkHostAndPort?,
-        val extraAdvertisedServiceIds: List<String>,
         override val notary: NotaryConfig?,
         override val certificateChainCheckPolicies: List<CertChainPolicyConfig>,
         override val devMode: Boolean = false,
@@ -103,13 +101,6 @@ data class FullNodeConfiguration(
         require(myLegalName.commonName == null) { "Common name must be null: $myLegalName" }
         require(minimumPlatformVersion >= 1) { "minimumPlatformVersion cannot be less than 1" }
     }
-
-    fun calculateServices(): Set<ServiceInfo> {
-        return extraAdvertisedServiceIds
-                .filter(String::isNotBlank)
-                .map { ServiceInfo.parse(it) }
-                .toSet()
-    }
 }
 
 enum class VerifierType {
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
index dea328709a..c61ef66ead 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
@@ -24,7 +24,6 @@ import net.corda.core.utilities.*
 import net.corda.node.services.api.FlowAppAuditEvent
 import net.corda.node.services.api.FlowPermissionAuditEvent
 import net.corda.node.services.api.ServiceHubInternal
-import net.corda.node.services.config.FullNodeConfiguration
 import net.corda.node.services.statemachine.FlowSessionState.Initiating
 import net.corda.node.utilities.CordaPersistence
 import net.corda.node.utilities.DatabaseTransaction
@@ -262,10 +261,7 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
 
     // TODO Dummy implementation of access to application specific permission controls and audit logging
     override fun checkFlowPermission(permissionName: String, extraAuditData: Map<String, String>) {
-        // This is a hack to allow cash app access list of permitted issuer currency.
-        // TODO: replace this with cordapp configuration.
-        val config = serviceHub.configuration as? FullNodeConfiguration
-        val permissionGranted = config?.extraAdvertisedServiceIds?.contains(permissionName) != false
+        val permissionGranted = true // TODO define permission control service on ServiceHubInternal and actually check authorization.
         val checkPermissionEvent = FlowPermissionAuditEvent(
                 serviceHub.clock.instant(),
                 flowInitiator,
@@ -276,6 +272,7 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
                 permissionName,
                 permissionGranted)
         serviceHub.auditService.recordAuditEvent(checkPermissionEvent)
+        @Suppress("ConstantConditionIf")
         if (!permissionGranted) {
             throw FlowPermissionException("User $flowInitiator not permissioned for $permissionName on flow $id")
         }
@@ -398,14 +395,8 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
             waitForConfirmation: Boolean,
             retryable: Boolean = false
     ): FlowSessionInternal {
-        val session = openSessions[Pair(sessionFlow, otherParty)]
-        if (session == null) {
-            throw IllegalStateException("Expected an Uninitiated session for $otherParty")
-        }
-        val state = session.state
-        if (state !is FlowSessionState.Uninitiated) {
-            throw IllegalStateException("Tried to initiate a session $session, but it's already initiating/initiated")
-        }
+        val session = openSessions[Pair(sessionFlow, otherParty)] ?: throw IllegalStateException("Expected an Uninitiated session for $otherParty")
+        val state = session.state as? FlowSessionState.Uninitiated ?: throw IllegalStateException("Tried to initiate a session $session, but it's already initiating/initiated")
         logger.trace { "Initiating a new session with ${state.otherParty}" }
         session.state = FlowSessionState.Initiating(state.otherParty)
         session.retryable = retryable
diff --git a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
index 79e224fe76..1d19ed5833 100644
--- a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
@@ -275,9 +275,8 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
             // that Bob was waiting on before the reboot occurred.
             bobNode = mockNet.createNode(bobAddr.id, object : MockNetwork.Factory<MockNetwork.MockNode> {
                 override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                                    advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
-                                    entropyRoot: BigInteger): MockNetwork.MockNode {
-                    return MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, bobAddr.id, notaryIdentity, entropyRoot)
+                                    id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): MockNetwork.MockNode {
+                    return MockNetwork.MockNode(config, network, networkMapAddr, bobAddr.id, notaryIdentity, entropyRoot)
                 }
             }, BOB.name)
 
@@ -312,18 +311,15 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
 
     // Creates a mock node with an overridden storage service that uses a RecordingMap, that lets us test the order
     // of gets and puts.
-    private fun makeNodeWithTracking(
-            networkMapAddress: SingleMessageRecipient?,
-            name: CordaX500Name): StartedNode<MockNetwork.MockNode> {
+    private fun makeNodeWithTracking(name: CordaX500Name): StartedNode<MockNetwork.MockNode> {
         // Create a node in the mock network ...
         return mockNet.createNode(nodeFactory = object : MockNetwork.Factory<MockNetwork.MockNode> {
             override fun create(config: NodeConfiguration,
                                 network: MockNetwork,
                                 networkMapAddr: SingleMessageRecipient?,
-                                advertisedServices: Set<ServiceInfo>, id: Int,
-                                notaryIdentity: Pair<ServiceInfo, KeyPair>?,
+                                id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                                 entropyRoot: BigInteger): MockNetwork.MockNode {
-                return object : MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
+                return object : MockNetwork.MockNode(config, network, networkMapAddr, id, notaryIdentity, entropyRoot) {
                     // That constructs a recording tx storage
                     override fun makeTransactionStorage(): WritableTransactionStorage {
                         return RecordingTransactionStorage(database, super.makeTransactionStorage())
@@ -338,9 +334,9 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
         mockNet = MockNetwork(false)
 
         val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = makeNodeWithTracking(notaryNode.network.myAddress, ALICE.name)
-        val bobNode = makeNodeWithTracking(notaryNode.network.myAddress, BOB.name)
-        val bankNode = makeNodeWithTracking(notaryNode.network.myAddress, BOC.name)
+        val aliceNode = makeNodeWithTracking(ALICE.name)
+        val bobNode = makeNodeWithTracking(BOB.name)
+        val bankNode = makeNodeWithTracking(BOC.name)
         val issuer = bankNode.info.chooseIdentity().ref(1, 2, 3)
         mockNet.runNetwork()
         notaryNode.internals.ensureRegistered()
@@ -443,9 +439,9 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
         mockNet = MockNetwork(false)
 
         val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = makeNodeWithTracking(notaryNode.network.myAddress, ALICE.name)
-        val bobNode = makeNodeWithTracking(notaryNode.network.myAddress, BOB.name)
-        val bankNode = makeNodeWithTracking(notaryNode.network.myAddress, BOC.name)
+        val aliceNode = makeNodeWithTracking(ALICE.name)
+        val bobNode = makeNodeWithTracking(BOB.name)
+        val bankNode = makeNodeWithTracking(BOC.name)
         val issuer = bankNode.info.chooseIdentity().ref(1, 2, 3)
 
         mockNet.runNetwork()
diff --git a/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
index d46c32c5a0..bc40165c06 100644
--- a/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/config/FullNodeConfigurationTest.kt
@@ -30,7 +30,6 @@ class FullNodeConfigurationTest {
                 p2pAddress = NetworkHostAndPort("localhost", 0),
                 rpcAddress = NetworkHostAndPort("localhost", 1),
                 messagingServerAddress = null,
-                extraAdvertisedServiceIds = emptyList(),
                 notary = null,
                 certificateChainCheckPolicies = emptyList(),
                 devMode = true,
diff --git a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
index 5e0f97e770..b3b9a9f769 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt
@@ -8,7 +8,6 @@ import net.corda.core.serialization.deserialize
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.api.NetworkMapCacheInternal
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.messaging.MessagingService
 import net.corda.node.services.messaging.send
@@ -25,6 +24,7 @@ import net.corda.node.services.network.NetworkMapService.Companion.SUBSCRIPTION_
 import net.corda.node.utilities.AddOrRemove
 import net.corda.node.utilities.AddOrRemove.ADD
 import net.corda.node.utilities.AddOrRemove.REMOVE
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
@@ -270,11 +270,10 @@ abstract class AbstractNetworkMapServiceTest<out S : AbstractNetworkMapService>
         override fun create(config: NodeConfiguration,
                             network: MockNetwork,
                             networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>,
                             id: Int,
                             notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): MockNode {
-            return object : MockNode(config, network, null, advertisedServices, id, notaryIdentity, entropyRoot) {
+            return object : MockNode(config, network, null, id, notaryIdentity, entropyRoot) {
                 override fun makeNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal) = NullNetworkMapService
             }
         }
diff --git a/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt
index 7e8e6a34a1..612c8e943a 100644
--- a/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt
@@ -2,12 +2,11 @@ package net.corda.node.services.network
 
 import net.corda.core.messaging.SingleMessageRecipient
 import net.corda.node.services.api.NetworkMapCacheInternal
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.messaging.MessagingService
+import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
-import net.corda.testing.node.MockServices.Companion.MOCK_VERSION_INFO
 import java.math.BigInteger
 import java.security.KeyPair
 
@@ -32,11 +31,10 @@ class PersistentNetworkMapServiceTest : AbstractNetworkMapServiceTest<Persistent
         override fun create(config: NodeConfiguration,
                             network: MockNetwork,
                             networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>,
                             id: Int,
                             notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                             entropyRoot: BigInteger): MockNode {
-            return object : MockNode(config, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
+            return object : MockNode(config, network, networkMapAddr, id, notaryIdentity, entropyRoot) {
                 override fun makeNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal) = SwizzleNetworkMapService(network, networkMapCache)
             }
         }
diff --git a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
index 57ca2cebba..00b66b30b9 100644
--- a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
@@ -135,7 +135,7 @@ class FlowFrameworkTests {
         node2.internals.acceptableLiveFiberCountOnStop = 1
         node2.dispose()
         mockNet.runNetwork()
-        val restoredFlow = node2.restartAndGetRestoredFlow<InitiatedReceiveFlow>(node1)
+        val restoredFlow = node2.restartAndGetRestoredFlow<InitiatedReceiveFlow>()
         assertThat(restoredFlow.receivedPayloads[0]).isEqualTo("Hello")
     }
 
@@ -184,7 +184,7 @@ class FlowFrameworkTests {
         node2.smm.executor.flush()
         node2.internals.disableDBCloseOnStop()
         node2.dispose() // kill receiver
-        val restoredFlow = node2.restartAndGetRestoredFlow<ReceiveFlow>(node1)
+        val restoredFlow = node2.restartAndGetRestoredFlow<ReceiveFlow>()
         assertThat(restoredFlow.receivedPayloads[0]).isEqualTo("Hello")
     }
 
@@ -214,7 +214,7 @@ class FlowFrameworkTests {
             assertEquals(1, node2.checkpointStorage.checkpoints().size) // confirm checkpoint
             node2.services.networkMapCache.clearNetworkMapCache()
         }
-        val node2b = mockNet.createNode(node2.internals.id, advertisedServices = *node2.internals.advertisedServices.toTypedArray())
+        val node2b = mockNet.createNode(node2.internals.id)
         node2.internals.manuallyCloseDB()
         val (firstAgain, fut1) = node2b.getSingleFlow<PingPongFlow>()
         // Run the network which will also fire up the second flow. First message should get deduped. So message data stays in sync.
@@ -685,10 +685,10 @@ class FlowFrameworkTests {
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //region Helpers
 
-    private inline fun <reified P : FlowLogic<*>> StartedNode<MockNode>.restartAndGetRestoredFlow(networkMapNode: StartedNode<*>? = null) = internals.run {
+    private inline fun <reified P : FlowLogic<*>> StartedNode<MockNode>.restartAndGetRestoredFlow() = internals.run {
         disableDBCloseOnStop() // Handover DB to new node copy
         stop()
-        val newNode = mockNet.createNode(id, advertisedServices = *advertisedServices.toTypedArray())
+        val newNode = mockNet.createNode(id)
         newNode.internals.acceptableLiveFiberCountOnStop = 1
         manuallyCloseDB()
         mockNet.runNetwork() // allow NetworkMapService messages to stabilise and thus start the state machine
diff --git a/samples/attachment-demo/build.gradle b/samples/attachment-demo/build.gradle
index 5fa296e26d..c331834529 100644
--- a/samples/attachment-demo/build.gradle
+++ b/samples/attachment-demo/build.gradle
@@ -42,7 +42,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     node {
         name "O=Notary Service,L=Zurich,C=CH"
         notary = [validating : true]
-        advertisedServices = []
         p2pPort 10002
         rpcPort 10003
         cordapps = []
@@ -50,7 +49,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     }
     node {
         name "O=Bank A,L=London,C=GB"
-        advertisedServices = []
         p2pPort 10005
         rpcPort 10006
         cordapps = []
@@ -58,7 +56,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     }
     node {
         name "O=Bank B,L=New York,C=US"
-        advertisedServices = []
         p2pPort 10008
         rpcPort 10009
         webPort 10010
diff --git a/samples/bank-of-corda-demo/build.gradle b/samples/bank-of-corda-demo/build.gradle
index 043ead8c0b..da04426168 100644
--- a/samples/bank-of-corda-demo/build.gradle
+++ b/samples/bank-of-corda-demo/build.gradle
@@ -55,14 +55,13 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     node {
         name "O=Notary Service,L=Zurich,C=CH"
         notary = [validating : true]
-        advertisedServices = []
         p2pPort 10002
         rpcPort 10003
         cordapps = ["net.corda:finance:$corda_release_version"]
     }
     node {
         name "O=BankOfCorda,L=London,C=GB"
-        advertisedServices = ["corda.issuer.USD"]
+        extraConfig = [issuableCurrencies : ["USD"]]
         p2pPort 10005
         rpcPort 10006
         webPort 10007
@@ -79,7 +78,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     }
     node {
         name "O=BigCorporation,L=New York,C=US"
-        advertisedServices = []
         p2pPort 10008
         rpcPort 10009
         webPort 10010
diff --git a/samples/irs-demo/build.gradle b/samples/irs-demo/build.gradle
index 7d1dccfb8d..2341793e1f 100644
--- a/samples/irs-demo/build.gradle
+++ b/samples/irs-demo/build.gradle
@@ -55,7 +55,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     node {
         name "O=Notary Service,L=Zurich,C=CH"
         notary = [validating : true]
-        advertisedServices = ["corda.interest_rates"]
         p2pPort 10002
         rpcPort 10003
         webPort 10004
@@ -64,7 +63,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     }
     node {
         name "O=Bank A,L=London,C=GB"
-        advertisedServices = []
         p2pPort 10005
         rpcPort 10006
         webPort 10007
@@ -73,7 +71,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     }
     node {
         name "O=Bank B,L=New York,C=US"
-        advertisedServices = []
         p2pPort 10008
         rpcPort 10009
         webPort 10010
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
index 74529cd530..6c929c47b7 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
@@ -49,9 +49,9 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
     // This puts together a mock network of SimulatedNodes.
 
     open class SimulatedNode(config: NodeConfiguration, mockNet: MockNetwork, networkMapAddress: SingleMessageRecipient?,
-                             advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
+                             id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                              entropyRoot: BigInteger)
-        : MockNetwork.MockNode(config, mockNet, networkMapAddress, advertisedServices, id, notaryIdentity, entropyRoot) {
+        : MockNetwork.MockNode(config, mockNet, networkMapAddress, id, notaryIdentity, entropyRoot) {
         override val started: StartedNode<SimulatedNode>? get() = uncheckedCast(super.started)
         override fun findMyLocation(): WorldMapLocation? {
             return configuration.myLegalName.locality.let { CityDatabase[it] }
@@ -62,15 +62,14 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
         var counter = 0
 
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
-                            entropyRoot: BigInteger): SimulatedNode {
+                            id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): SimulatedNode {
             val letter = 'A' + counter
             val (city, country) = bankLocations[counter++ % bankLocations.size]
 
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
                     myLegalName = CordaX500Name(organisation = "Bank $letter", locality = city, country = country))
-            return SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot)
+            return SimulatedNode(cfg, network, networkMapAddr, id, notaryIdentity, entropyRoot)
         }
 
         fun createAll(): List<SimulatedNode> {
@@ -85,25 +84,23 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
 
     object NetworkMapNodeFactory : MockNetwork.Factory<SimulatedNode> {
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
-                            entropyRoot: BigInteger): SimulatedNode {
+                            id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): SimulatedNode {
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
                     myLegalName = DUMMY_MAP.name)
-            return object : SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {}
+            return object : SimulatedNode(cfg, network, networkMapAddr, id, notaryIdentity, entropyRoot) {}
         }
     }
 
     object NotaryNodeFactory : MockNetwork.Factory<SimulatedNode> {
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
-                            entropyRoot: BigInteger): SimulatedNode {
+                            id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): SimulatedNode {
             requireNotNull(config.notary)
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
                     myLegalName = DUMMY_NOTARY.name,
                     notaryConfig = config.notary)
-            return SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot)
+            return SimulatedNode(cfg, network, networkMapAddr, id, notaryIdentity, entropyRoot)
         }
     }
 
@@ -112,12 +109,11 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
         val RATES_SERVICE_NAME = CordaX500Name(organisation = "Rates Service Provider", locality = "Madrid", country = "ES")
 
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
-                            entropyRoot: BigInteger): SimulatedNode {
+                            id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): SimulatedNode {
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
                     myLegalName = RATES_SERVICE_NAME)
-            return object : SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
+            return object : SimulatedNode(cfg, network, networkMapAddr, id, notaryIdentity, entropyRoot) {
                 override fun start() = super.start().apply {
                     registerInitiatedFlow(NodeInterestRates.FixQueryHandler::class.java)
                     registerInitiatedFlow(NodeInterestRates.FixSignHandler::class.java)
@@ -133,12 +129,11 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
 
     object RegulatorFactory : MockNetwork.Factory<SimulatedNode> {
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
-                            entropyRoot: BigInteger): SimulatedNode {
+                            id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): SimulatedNode {
             val cfg = testNodeConfiguration(
                     baseDirectory = config.baseDirectory,
                     myLegalName = DUMMY_REGULATOR.name)
-            return object : SimulatedNode(cfg, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot) {
+            return object : SimulatedNode(cfg, network, networkMapAddr, id, notaryIdentity, entropyRoot) {
                 // TODO: Regulatory nodes don't actually exist properly, this is a last minute demo request.
                 //       So we just fire a message at a node that doesn't know how to handle it, and it'll ignore it.
                 //       But that's fine for visualisation purposes.
diff --git a/samples/simm-valuation-demo/build.gradle b/samples/simm-valuation-demo/build.gradle
index ec982a20a7..502b2bdee8 100644
--- a/samples/simm-valuation-demo/build.gradle
+++ b/samples/simm-valuation-demo/build.gradle
@@ -68,13 +68,11 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     node {
         name "O=Notary Service,L=Zurich,C=CH"
         notary = [validating : true]
-        advertisedServices = []
         p2pPort 10002
         cordapps = ["net.corda:finance:$corda_release_version"]
     }
     node {
         name "O=Bank A,L=London,C=GB"
-        advertisedServices = []
         p2pPort 10004
         webPort 10005
         rpcPort 10006
@@ -83,7 +81,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     }
     node {
         name "O=Bank B,L=New York,C=US"
-        advertisedServices = []
         p2pPort 10007
         webPort 10008
         rpcPort 10009
@@ -92,7 +89,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     }
     node {
         name "O=Bank C,L=Tokyo,C=JP"
-        advertisedServices = []
         p2pPort 10010
         webPort 10011
         rpcPort 10012
diff --git a/samples/trader-demo/build.gradle b/samples/trader-demo/build.gradle
index 5d0a57663e..8d224d11ab 100644
--- a/samples/trader-demo/build.gradle
+++ b/samples/trader-demo/build.gradle
@@ -56,13 +56,11 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     node {
         name "O=Notary Service,L=Zurich,C=CH"
         notary = [validating : true]
-        advertisedServices = []
         p2pPort 10002
         cordapps = ["net.corda:finance:$corda_release_version"]
     }
     node {
         name "O=Bank A,L=London,C=GB"
-        advertisedServices = []
         p2pPort 10005
         rpcPort 10006
         cordapps = ["net.corda:finance:$corda_release_version"]
@@ -70,7 +68,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     }
     node {
         name "O=Bank B,L=New York,C=US"
-        advertisedServices = []
         p2pPort 10008
         rpcPort 10009
         cordapps = ["net.corda:finance:$corda_release_version"]
@@ -78,7 +75,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     }
     node {
         name "O=BankOfCorda,L=New York,C=US"
-        advertisedServices = []
         p2pPort 10011
         rpcPort 10012
         cordapps = ["net.corda:finance:$corda_release_version"]
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
index 9382ce4b3a..9a1ce481ca 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
@@ -30,7 +30,6 @@ import net.corda.node.utilities.ServiceIdentityGenerator
 import net.corda.nodeapi.User
 import net.corda.nodeapi.config.parseAs
 import net.corda.nodeapi.config.toConfig
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.nodeapi.internal.addShutdownHook
 import net.corda.testing.*
 import net.corda.testing.node.MockServices.Companion.MOCK_VERSION_INFO
@@ -78,7 +77,6 @@ interface DriverDSLExposedInterface : CordformContext {
      *   when called from Java code.
      * @param providedName Optional name of the node, which will be its legal name in [Party]. Defaults to something
      *     random. Note that this must be unique as the driver uses it as a primary key!
-     * @param advertisedServices The set of services to be advertised by the node. Defaults to empty set.
      * @param verifierType The type of transaction verifier to use. See: [VerifierType]
      * @param rpcUsers List of users who are authorised to use the RPC system. Defaults to empty list.
      * @param startInSameProcess Determines if the node should be started inside the same process the Driver is running
@@ -88,7 +86,6 @@ interface DriverDSLExposedInterface : CordformContext {
     fun startNode(
             defaultParameters: NodeParameters = NodeParameters(),
             providedName: CordaX500Name? = defaultParameters.providedName,
-            advertisedServices: Set<ServiceInfo> = defaultParameters.advertisedServices,
             rpcUsers: List<User> = defaultParameters.rpcUsers,
             verifierType: VerifierType = defaultParameters.verifierType,
             customOverrides: Map<String, Any?> = defaultParameters.customOverrides,
@@ -267,7 +264,6 @@ sealed class PortAllocation {
  */
 data class NodeParameters(
         val providedName: CordaX500Name? = null,
-        val advertisedServices: Set<ServiceInfo> = emptySet(),
         val rpcUsers: List<User> = emptyList(),
         val verifierType: VerifierType = VerifierType.InMemory,
         val customOverrides: Map<String, Any?> = emptyMap(),
@@ -275,7 +271,6 @@ data class NodeParameters(
         val maximumHeapSize: String = "200m"
 ) {
     fun setProvidedName(providedName: CordaX500Name?) = copy(providedName = providedName)
-    fun setAdvertisedServices(advertisedServices: Set<ServiceInfo>) = copy(advertisedServices = advertisedServices)
     fun setRpcUsers(rpcUsers: List<User>) = copy(rpcUsers = rpcUsers)
     fun setVerifierType(verifierType: VerifierType) = copy(verifierType = verifierType)
     fun setCustomerOverrides(customOverrides: Map<String, Any?>) = copy(customOverrides = customOverrides)
@@ -686,7 +681,6 @@ class DriverDSL(
     override fun startNode(
             defaultParameters: NodeParameters,
             providedName: CordaX500Name?,
-            advertisedServices: Set<ServiceInfo>,
             rpcUsers: List<User>,
             verifierType: VerifierType,
             customOverrides: Map<String, Any?>,
@@ -710,7 +704,6 @@ class DriverDSL(
                         "p2pAddress" to p2pAddress.toString(),
                         "rpcAddress" to rpcAddress.toString(),
                         "webAddress" to webAddress.toString(),
-                        "extraAdvertisedServiceIds" to advertisedServices.map { it.toString() },
                         "networkMapService" to networkMapServiceConfigLookup(name),
                         "useTestClock" to useTestClock,
                         "rpcUsers" to if (rpcUsers.isEmpty()) defaultRpcUserList else rpcUsers.map { it.toMap() },
@@ -741,7 +734,6 @@ class DriverDSL(
                     baseDirectory = baseDirectory(name),
                     allowMissingConfig = true,
                     configOverrides = node.config + notary + mapOf(
-                            "extraAdvertisedServiceIds" to node.advertisedServices,
                             "networkMapService" to networkMapServiceConfigLookup(name),
                             "rpcUsers" to if (rpcUsers.isEmpty()) defaultRpcUserList else rpcUsers
                     )
@@ -935,7 +927,7 @@ class DriverDSL(
                 // Write node.conf
                 writeConfig(nodeConf.baseDirectory, "node.conf", config)
                 // TODO pass the version in?
-                val node = Node(nodeConf, nodeConf.calculateServices(), MOCK_VERSION_INFO, initialiseSerialization = false).start()
+                val node = Node(nodeConf, MOCK_VERSION_INFO, initialiseSerialization = false).start()
                 val nodeThread = thread(name = nodeConf.myLegalName.organisation) {
                     node.internals.run()
                 }
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/CordformUtils.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/CordformUtils.kt
index 80f078d2bf..dcf0255a9a 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/CordformUtils.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/CordformUtils.kt
@@ -8,7 +8,6 @@ import net.corda.core.identity.CordaX500Name
 import net.corda.node.services.config.NotaryConfig
 import net.corda.nodeapi.User
 import net.corda.nodeapi.config.toConfig
-import net.corda.nodeapi.internal.ServiceInfo
 
 fun CordformDefinition.node(configure: CordformNode.() -> Unit) {
     addNode { cordformNode -> cordformNode.configure() }
@@ -23,7 +22,3 @@ fun CordformNode.rpcUsers(vararg users: User) {
 fun CordformNode.notary(notaryConfig: NotaryConfig) {
     notary = notaryConfig.toConfig().root().unwrapped()
 }
-
-fun CordformNode.advertisedServices(vararg services: ServiceInfo) {
-    advertisedServices = services.map { it.toString() }
-}
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index 43471696df..88824e118e 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -115,15 +115,13 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
          * but can be overriden to cause nodes to have stable or colliding identity/service keys.
          */
         fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                   advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
-                   entropyRoot: BigInteger): N
+                   id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): N
     }
 
     object DefaultFactory : Factory<MockNode> {
         override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
-                            advertisedServices: Set<ServiceInfo>, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
-                            entropyRoot: BigInteger): MockNode {
-            return MockNode(config, network, networkMapAddr, advertisedServices, id, notaryIdentity, entropyRoot)
+                            id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): MockNode {
+            return MockNode(config, network, networkMapAddr, id, notaryIdentity, entropyRoot)
         }
     }
 
@@ -159,11 +157,10 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
     open class MockNode(config: NodeConfiguration,
                         val mockNet: MockNetwork,
                         override val networkMapAddress: SingleMessageRecipient?,
-                        advertisedServices: Set<ServiceInfo>,
                         val id: Int,
                         internal val notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                         val entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue())) :
-            AbstractNode(config, advertisedServices, TestClock(), MOCK_VERSION_INFO, mockNet.busyLatch) {
+            AbstractNode(config, TestClock(), MOCK_VERSION_INFO, mockNet.busyLatch) {
         var counter = entropyRoot
         override val log: Logger = loggerFor<MockNode>()
         override val serverThread: AffinityExecutor =
@@ -303,7 +300,6 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                 nodeFactory = nodeFactory ?: defaultFactory,
                 legalName = MOCK_NET_MAP.name,
                 notaryIdentity = null,
-                advertisedServices = arrayOf(),
                 entropyRoot = BigInteger.valueOf(random63BitValue()),
                 configOverrides = {},
                 start = true
@@ -315,18 +311,16 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
     fun createUnstartedNode(forcedID: Int? = null,
                             legalName: CordaX500Name? = null, notaryIdentity: Pair<ServiceInfo, KeyPair>? = null,
                             entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue()),
-                            vararg advertisedServices: ServiceInfo,
                             configOverrides: (NodeConfiguration) -> Any? = {}): MockNode {
-        return createUnstartedNode(forcedID, defaultFactory, legalName, notaryIdentity, entropyRoot, *advertisedServices, configOverrides = configOverrides)
+        return createUnstartedNode(forcedID, defaultFactory, legalName, notaryIdentity, entropyRoot, configOverrides = configOverrides)
     }
 
     fun <N : MockNode> createUnstartedNode(forcedID: Int? = null, nodeFactory: Factory<N>,
                                            legalName: CordaX500Name? = null, notaryIdentity: Pair<ServiceInfo, KeyPair>? = null,
                                            entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue()),
-                                           vararg advertisedServices: ServiceInfo,
                                            configOverrides: (NodeConfiguration) -> Any? = {}): N {
         val networkMapAddress = networkMapNode.network.myAddress
-        return createNodeImpl(networkMapAddress, forcedID, nodeFactory, false, legalName, notaryIdentity, entropyRoot, advertisedServices, configOverrides)
+        return createNodeImpl(networkMapAddress, forcedID, nodeFactory, false, legalName, notaryIdentity, entropyRoot, configOverrides)
     }
 
     /**
@@ -340,25 +334,22 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
     fun createNode(forcedID: Int? = null,
                    legalName: CordaX500Name? = null, notaryIdentity: Pair<ServiceInfo, KeyPair>? = null,
                    entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue()),
-                   vararg advertisedServices: ServiceInfo,
                    configOverrides: (NodeConfiguration) -> Any? = {}): StartedNode<MockNode> {
-        return createNode(forcedID, defaultFactory, legalName, notaryIdentity, entropyRoot, *advertisedServices, configOverrides = configOverrides)
+        return createNode(forcedID, defaultFactory, legalName, notaryIdentity, entropyRoot, configOverrides = configOverrides)
     }
 
     /** Like the other [createNode] but takes a [Factory] and propagates its [MockNode] subtype. */
     fun <N : MockNode> createNode(forcedID: Int? = null, nodeFactory: Factory<N>,
                                   legalName: CordaX500Name? = null, notaryIdentity: Pair<ServiceInfo, KeyPair>? = null,
                                   entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue()),
-                                  vararg advertisedServices: ServiceInfo,
                                   configOverrides: (NodeConfiguration) -> Any? = {}): StartedNode<N> {
         val networkMapAddress = networkMapNode.network.myAddress
-        return uncheckedCast(createNodeImpl(networkMapAddress, forcedID, nodeFactory, true, legalName, notaryIdentity, entropyRoot, advertisedServices, configOverrides).started)!!
+        return uncheckedCast(createNodeImpl(networkMapAddress, forcedID, nodeFactory, true, legalName, notaryIdentity, entropyRoot, configOverrides).started)!!
     }
 
     private fun <N : MockNode> createNodeImpl(networkMapAddress: SingleMessageRecipient?, forcedID: Int?, nodeFactory: Factory<N>,
                                               start: Boolean, legalName: CordaX500Name?, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                                               entropyRoot: BigInteger,
-                                              advertisedServices: Array<out ServiceInfo>,
                                               configOverrides: (NodeConfiguration) -> Any?): N {
         val id = forcedID ?: nextNodeId++
         val config = testNodeConfiguration(
@@ -367,7 +358,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
             whenever(it.dataSourceProperties).thenReturn(makeTestDataSourceProperties("node_${id}_net_$networkId"))
             configOverrides(it)
         }
-        return nodeFactory.create(config, this, networkMapAddress, advertisedServices.toSet(), id, notaryIdentity, entropyRoot).apply {
+        return nodeFactory.create(config, this, networkMapAddress, id, notaryIdentity, entropyRoot).apply {
             if (start) {
                 start()
                 if (threadPerNode && networkMapAddress != null) nodeReadyFuture.getOrThrow() // XXX: What about manually-started nodes?
@@ -425,7 +416,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
         return when (msgRecipient) {
             is SingleMessageRecipient -> nodes.single { it.started!!.network.myAddress == msgRecipient }
             is InMemoryMessagingNetwork.ServiceHandle -> {
-                nodes.firstOrNull { it.advertisedServices.any { it.name == msgRecipient.party.name } }
+                nodes.firstOrNull { it.started!!.info.isLegalIdentity(msgRecipient.party) }
                         ?: throw IllegalArgumentException("Couldn't find node advertising service with owning party name: ${msgRecipient.party.name} ")
             }
             else -> throw IllegalArgumentException("Method not implemented for different type of message recipients")
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
index 3a8f838ffb..3d4d4e9d63 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
@@ -14,7 +14,6 @@ import net.corda.node.utilities.ServiceIdentityGenerator
 import net.corda.nodeapi.User
 import net.corda.nodeapi.config.parseAs
 import net.corda.nodeapi.config.toConfig
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.DUMMY_MAP
 import net.corda.testing.TestDependencyInjectionBase
 import net.corda.testing.driver.addressMustNotBeBoundFuture
@@ -83,11 +82,10 @@ abstract class NodeBasedTest : TestDependencyInjectionBase() {
      */
     fun startNetworkMapNode(legalName: CordaX500Name = DUMMY_MAP.name,
                             platformVersion: Int = 1,
-                            advertisedServices: Set<ServiceInfo> = emptySet(),
                             rpcUsers: List<User> = emptyList(),
                             configOverrides: Map<String, Any> = emptyMap()): StartedNode<Node> {
         check(_networkMapNode == null || _networkMapNode!!.info.legalIdentitiesAndCerts.first().name == legalName)
-        return startNodeInternal(legalName, platformVersion, advertisedServices, rpcUsers, configOverrides).apply {
+        return startNodeInternal(legalName, platformVersion, rpcUsers, configOverrides).apply {
             _networkMapNode = this
         }
     }
@@ -95,7 +93,6 @@ abstract class NodeBasedTest : TestDependencyInjectionBase() {
     @JvmOverloads
     fun startNode(legalName: CordaX500Name,
                   platformVersion: Int = 1,
-                  advertisedServices: Set<ServiceInfo> = emptySet(),
                   rpcUsers: List<User> = emptyList(),
                   configOverrides: Map<String, Any> = emptyMap(),
                   noNetworkMap: Boolean = false,
@@ -119,7 +116,6 @@ abstract class NodeBasedTest : TestDependencyInjectionBase() {
         val node = startNodeInternal(
                 legalName,
                 platformVersion,
-                advertisedServices,
                 rpcUsers,
                 networkMapConf + configOverrides,
                 noNetworkMap)
@@ -175,7 +171,6 @@ abstract class NodeBasedTest : TestDependencyInjectionBase() {
 
     private fun startNodeInternal(legalName: CordaX500Name,
                                   platformVersion: Int,
-                                  advertisedServices: Set<ServiceInfo>,
                                   rpcUsers: List<User>,
                                   configOverrides: Map<String, Any>,
                                   noNetworkMap: Boolean = false): StartedNode<Node> {
@@ -189,14 +184,15 @@ abstract class NodeBasedTest : TestDependencyInjectionBase() {
                         "myLegalName" to legalName.toString(),
                         "p2pAddress" to p2pAddress,
                         "rpcAddress" to localPort[1].toString(),
-                        "extraAdvertisedServiceIds" to advertisedServices.map { it.toString() },
                         "rpcUsers" to rpcUsers.map { it.toMap() },
                         "noNetworkMap" to noNetworkMap
                 ) + configOverrides
         )
 
         val parsedConfig = config.parseAs<FullNodeConfiguration>()
-        val node = Node(parsedConfig, parsedConfig.calculateServices(), MOCK_VERSION_INFO.copy(platformVersion = platformVersion),
+        val node = Node(
+                parsedConfig,
+                MOCK_VERSION_INFO.copy(platformVersion = platformVersion),
                 initialiseSerialization = false).start()
         nodes += node
         thread(name = legalName.organisation) {
diff --git a/tools/demobench/README.md b/tools/demobench/README.md
index dc42716039..ad1550b9e5 100644
--- a/tools/demobench/README.md
+++ b/tools/demobench/README.md
@@ -70,9 +70,6 @@ node in a new tab.
 
 ![Configure Bank Node](demobench-configure-bank.png)
 
-This time, there will be additional services available. Select `corda.cash` and
-`corda.issuer.GBP`, and then press the `Start node` button.
-
 When you press the `Launch Web Server` this time, your browser should open to a
 page saying:
 > ### Installed CorDapps
diff --git a/tools/demobench/build.gradle b/tools/demobench/build.gradle
index 727a5c8237..c2d1142cc7 100644
--- a/tools/demobench/build.gradle
+++ b/tools/demobench/build.gradle
@@ -71,6 +71,7 @@ dependencies {
 
     testCompile "junit:junit:$junit_version"
     testCompile "org.jetbrains.kotlin:kotlin-test:$kotlin_version"
+    testCompile "org.assertj:assertj-core:${assertj_version}"
     testCompile "org.mockito:mockito-core:$mockito_version"
 }
 
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt
index a03e83d88c..165388b2b0 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt
@@ -5,13 +5,12 @@ import net.corda.core.internal.div
 import net.corda.core.internal.list
 import net.corda.core.utilities.loggerFor
 import net.corda.demobench.model.JVMConfig
-import net.corda.demobench.model.NodeConfig
-import net.corda.demobench.model.forceDirectory
+import net.corda.demobench.model.NodeConfigWrapper
 import net.corda.demobench.readErrorLines
 import tornadofx.*
 import java.io.IOException
 import java.nio.file.Files
-import java.nio.file.StandardCopyOption.*
+import java.nio.file.StandardCopyOption.REPLACE_EXISTING
 import java.util.concurrent.Executors
 
 class Explorer internal constructor(private val explorerController: ExplorerController) : AutoCloseable {
@@ -23,29 +22,32 @@ class Explorer internal constructor(private val explorerController: ExplorerCont
     private var process: Process? = null
 
     @Throws(IOException::class)
-    fun open(config: NodeConfig, onExit: (NodeConfig) -> Unit) {
-        val explorerDir = config.explorerDir.toFile()
+    fun open(config: NodeConfigWrapper, onExit: (NodeConfigWrapper) -> Unit) {
+        val explorerDir = config.explorerDir
 
-        if (!explorerDir.forceDirectory()) {
-            log.warn("Failed to create working directory '{}'", explorerDir.absolutePath)
+        try {
+            explorerDir.createDirectories()
+        } catch (e: IOException) {
+            log.warn("Failed to create working directory '{}'", explorerDir.toAbsolutePath())
             onExit(config)
             return
         }
 
+        val legalName = config.nodeConfig.myLegalName
         try {
             installApps(config)
 
-            val user = config.users.elementAt(0)
+            val user = config.nodeConfig.rpcUsers[0]
             val p = explorerController.process(
                     "--host=localhost",
-                    "--port=${config.rpcPort}",
+                    "--port=${config.nodeConfig.rpcAddress.port}",
                     "--username=${user.username}",
                     "--password=${user.password}")
-                    .directory(explorerDir)
+                    .directory(explorerDir.toFile())
                     .start()
             process = p
 
-            log.info("Launched Node Explorer for '{}'", config.legalName)
+            log.info("Launched Node Explorer for '{}'", legalName)
 
             // Close these streams because no-one is using them.
             safeClose(p.outputStream)
@@ -57,21 +59,21 @@ class Explorer internal constructor(private val explorerController: ExplorerCont
                 process = null
 
                 if (errors.isEmpty()) {
-                    log.info("Node Explorer for '{}' has exited (value={})", config.legalName, exitValue)
+                    log.info("Node Explorer for '{}' has exited (value={})", legalName, exitValue)
                 } else {
-                    log.error("Node Explorer for '{}' has exited (value={}, {})", config.legalName, exitValue, errors)
+                    log.error("Node Explorer for '{}' has exited (value={}, {})", legalName, exitValue, errors)
                 }
 
                 onExit(config)
             }
         } catch (e: IOException) {
-            log.error("Failed to launch Node Explorer for '{}': {}", config.legalName, e.message)
+            log.error("Failed to launch Node Explorer for '{}': {}", legalName, e.message)
             onExit(config)
             throw e
         }
     }
 
-    private fun installApps(config: NodeConfig) {
+    private fun installApps(config: NodeConfigWrapper) {
         // Make sure that the explorer has cordapps on its class path. This is only necessary because currently apps
         // require the original class files to deserialise states: Kryo serialisation doesn't let us write generic
         // tools that work with serialised data structures. But the AMQP serialisation revamp will fix this by
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
index 4d8876b2ed..f34ebfef6d 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
@@ -1,76 +1,46 @@
 package net.corda.demobench.model
 
 import com.typesafe.config.Config
-import net.corda.core.identity.CordaX500Name
+import net.corda.core.internal.div
 import net.corda.core.utilities.NetworkHostAndPort
+import net.corda.nodeapi.config.parseAs
 import tornadofx.*
 import java.io.IOException
 import java.nio.file.Files
 import java.nio.file.Path
 
 class InstallFactory : Controller() {
-
     private val nodeController by inject<NodeController>()
-    private val serviceController by inject<ServiceController>()
 
     @Throws(IOException::class)
     fun toInstallConfig(config: Config, baseDir: Path): InstallConfig {
-        val p2pPort = config.parsePort("p2pAddress")
-        val rpcPort = config.parsePort("rpcAddress")
-        val webPort = config.parsePort("webAddress")
-        val h2Port = config.getInt("h2port")
-        val x500name = CordaX500Name.parse(config.getString("myLegalName"))
-        val extraServices = config.parseExtraServices("extraAdvertisedServiceIds")
-        val tempDir = Files.createTempDirectory(baseDir, ".node")
-
-        val nodeConfig = NodeConfig(
-                tempDir,
-                x500name,
-                p2pPort,
-                rpcPort,
-                webPort,
-                h2Port,
-                extraServices,
-                config.getObjectList("rpcUsers").map { toUser(it.unwrapped()) }.toList()
-        )
-
-        if (config.hasPath("networkMapService")) {
-            val nmap = config.getConfig("networkMapService")
-            nodeConfig.networkMap = NetworkMapConfig(CordaX500Name.parse(nmap.getString("legalName")), nmap.parsePort("address"))
-        } else {
-            log.info("Node '${nodeConfig.legalName}' is the network map")
+        fun NetworkHostAndPort.checkPort() {
+            require(nodeController.isPortValid(port)) { "Invalid port $port" }
         }
 
-        return InstallConfig(tempDir, nodeConfig)
-    }
+        val nodeConfig = config.parseAs<NodeConfig>()
+        nodeConfig.p2pAddress.checkPort()
+        nodeConfig.rpcAddress.checkPort()
+        nodeConfig.webAddress.checkPort()
 
-    private fun Config.parsePort(path: String): Int {
-        val address = this.getString(path)
-        val port = NetworkHostAndPort.parse(address).port
-        require(nodeController.isPortValid(port), { "Invalid port $port from '$path'." })
-        return port
-    }
+        val tempDir = Files.createTempDirectory(baseDir, ".node")
 
-    private fun Config.parseExtraServices(path: String): MutableList<String> {
-        val services = serviceController.services.values.toSortedSet()
-        return this.getStringList(path)
-                .filter { !it.isNullOrEmpty() }
-                .map { svc ->
-                    require(svc in services, { "Unknown service '$svc'." })
-                    svc
-                }.toMutableList()
-    }
+        if (nodeConfig.isNetworkMap) {
+            log.info("Node '${nodeConfig.myLegalName}' is the network map")
+        }
 
+        return InstallConfig(tempDir, NodeConfigWrapper(tempDir, nodeConfig))
+    }
 }
 
 /**
  * Wraps the configuration information for a Node
  * which isn't ready to be instantiated yet.
  */
-class InstallConfig internal constructor(val baseDir: Path, private val config: NodeConfig) : HasPlugins {
+class InstallConfig internal constructor(val baseDir: Path, private val config: NodeConfigWrapper) : HasPlugins {
     val key = config.key
-    override val pluginDir: Path = baseDir.resolve("plugins")
+    override val pluginDir: Path = baseDir / "plugins"
 
     fun deleteBaseDir(): Boolean = baseDir.toFile().deleteRecursively()
-    fun installTo(installDir: Path) = config.moveTo(installDir)
+    fun installTo(installDir: Path) = config.copy(baseDir = installDir)
 }
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NetworkMapConfig.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NetworkMapConfig.kt
deleted file mode 100644
index 3960ee9a24..0000000000
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NetworkMapConfig.kt
+++ /dev/null
@@ -1,10 +0,0 @@
-package net.corda.demobench.model
-
-import net.corda.core.identity.CordaX500Name
-
-open class NetworkMapConfig(val legalName: CordaX500Name, val p2pPort: Int) {
-    val key: String = legalName.organisation.toKey()
-}
-
-fun String.stripWhitespace() = String(this.filter { !it.isWhitespace() }.toCharArray())
-fun String.toKey() = stripWhitespace().toLowerCase()
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
index 8cde8f3bcf..e536b3bfb4 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
@@ -1,87 +1,77 @@
 package net.corda.demobench.model
 
-import com.typesafe.config.*
+import com.typesafe.config.ConfigRenderOptions
 import net.corda.core.identity.CordaX500Name
+import net.corda.core.internal.copyToDirectory
+import net.corda.core.internal.createDirectories
+import net.corda.core.internal.div
+import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.nodeapi.User
-import java.io.File
-import java.nio.file.Files
+import net.corda.nodeapi.config.toConfig
 import java.nio.file.Path
 import java.nio.file.StandardCopyOption
 
-class NodeConfig constructor(
-        baseDir: Path,
-        legalName: CordaX500Name,
-        p2pPort: Int,
-        val rpcPort: Int,
-        val webPort: Int,
-        val h2Port: Int,
-        val extraServices: MutableList<String> = mutableListOf(),
-        val users: List<User> = listOf(defaultUser),
-        var networkMap: NetworkMapConfig? = null
-) : NetworkMapConfig(legalName, p2pPort), HasPlugins {
-
+/**
+ * This is a subset of FullNodeConfiguration, containing only those configs which we need. The node uses reference.conf
+ * to fill in the defaults so we're not required to specify them here.
+ */
+data class NodeConfig(
+        val myLegalName: CordaX500Name,
+        val p2pAddress: NetworkHostAndPort,
+        val rpcAddress: NetworkHostAndPort,
+        /** This is not used by the node but by the webserver which looks at node.conf. */
+        val webAddress: NetworkHostAndPort,
+        val notary: NotaryService?,
+        val networkMapService: NetworkMapConfig?,
+        val h2port: Int,
+        val rpcUsers: List<User> = listOf(defaultUser),
+        /** This is an extra config used by the Cash app. */
+        val issuableCurrencies: List<String> = emptyList()
+) {
     companion object {
         val renderOptions: ConfigRenderOptions = ConfigRenderOptions.defaults().setOriginComments(false)
         val defaultUser = user("guest")
     }
 
-    val nearestCity: String = legalName.locality
-    val nodeDir: Path = baseDir.resolve(key)
-    override val pluginDir: Path = nodeDir.resolve("plugins")
-    val explorerDir: Path = baseDir.resolve("$key-explorer")
+    @Suppress("unused")
+    private val detectPublicIp = false
+    @Suppress("unused")
+    private val useTestClock = true
 
+    val isNetworkMap: Boolean get() = networkMapService == null
+
+    fun toText(): String = toConfig().root().render(renderOptions)
+}
+
+/**
+ * This is a mirror of NetworkMapInfo.
+ */
+data class NetworkMapConfig(val legalName: CordaX500Name, val address: NetworkHostAndPort)
+
+/**
+ * This is a subset of NotaryConfig. It implements [ExtraService] to avoid unnecessary copying.
+ */
+data class NotaryService(val validating: Boolean) : ExtraService {
+    override fun toString(): String = "${if (validating) "V" else "Non-v"}alidating Notary"
+}
+
+// TODO Think of a better name
+data class NodeConfigWrapper(val baseDir: Path, val nodeConfig: NodeConfig) : HasPlugins {
+    val key: String = nodeConfig.myLegalName.organisation.toKey()
+    val nodeDir: Path = baseDir / key
+    val explorerDir: Path = baseDir / "$key-explorer"
+    override val pluginDir: Path = nodeDir / "plugins"
     var state: NodeState = NodeState.STARTING
 
-    val isCashIssuer: Boolean = extraServices.any {
-        it.startsWith("corda.issuer.")
-    }
-
-    fun isNetworkMap(): Boolean = networkMap == null
-
-    /*
-     * The configuration object depends upon the networkMap,
-     * which is mutable.
-     */
-    fun toFileConfig(): Config {
-        return ConfigFactory.empty()
-                .withValue("myLegalName", valueFor(legalName.toString()))
-                .withValue("p2pAddress", addressValueFor(p2pPort))
-                .withValue("extraAdvertisedServiceIds", valueFor(extraServices))
-                .withFallback(optional("networkMapService", networkMap, { c, n ->
-                    c.withValue("address", addressValueFor(n.p2pPort))
-                            .withValue("legalName", valueFor(n.legalName.toString()))
-                }))
-                .withValue("webAddress", addressValueFor(webPort))
-                .withValue("rpcAddress", addressValueFor(rpcPort))
-                .withValue("rpcUsers", valueFor(users.map(User::toMap).toList()))
-                .withValue("h2port", valueFor(h2Port))
-                .withValue("useTestClock", valueFor(true))
-                .withValue("detectPublicIp", valueFor(false))
-    }
-
-    fun toText(): String = toFileConfig().root().render(renderOptions)
-
-    fun moveTo(baseDir: Path) = NodeConfig(
-            baseDir, legalName, p2pPort, rpcPort, webPort, h2Port, extraServices, users, networkMap
-    )
-
-    fun install(plugins: Collection<Path>) {
-        if (plugins.isNotEmpty() && pluginDir.toFile().forceDirectory()) {
-            plugins.forEach {
-                Files.copy(it, pluginDir.resolve(it.fileName.toString()), StandardCopyOption.REPLACE_EXISTING)
-            }
+    fun install(cordapps: Collection<Path>) {
+        if (cordapps.isEmpty()) return
+        pluginDir.createDirectories()
+        for (cordapp in cordapps) {
+            cordapp.copyToDirectory(pluginDir, StandardCopyOption.REPLACE_EXISTING)
         }
     }
-
 }
 
-private fun <T> valueFor(any: T): ConfigValue? = ConfigValueFactory.fromAnyRef(any)
+fun user(name: String) = User(name, "letmein", setOf("ALL"))
 
-private fun addressValueFor(port: Int) = valueFor("localhost:$port")
-
-private inline fun <T> optional(path: String, obj: T?, body: (Config, T) -> Config): Config {
-    val config = ConfigFactory.empty()
-    return if (obj == null) config else body(config, obj).atPath(path)
-}
-
-fun File.forceDirectory(): Boolean = this.isDirectory || this.mkdirs()
+fun String.toKey() = filter { !it.isWhitespace() }.toLowerCase()
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
index 5bd33b700e..4e7b6a6cc7 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
@@ -1,6 +1,12 @@
 package net.corda.demobench.model
 
+import javafx.beans.binding.IntegerExpression
 import net.corda.core.identity.CordaX500Name
+import net.corda.core.internal.copyToDirectory
+import net.corda.core.internal.createDirectories
+import net.corda.core.internal.div
+import net.corda.core.internal.noneOrSingle
+import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.demobench.plugin.PluginController
 import net.corda.demobench.pty.R3Pty
 import tornadofx.*
@@ -22,18 +28,17 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
 
     private val jvm by inject<JVMConfig>()
     private val pluginController by inject<PluginController>()
-    private val serviceController by inject<ServiceController>()
 
     private var baseDir: Path = baseDirFor(ManagementFactory.getRuntimeMXBean().startTime)
     private val cordaPath: Path = jvm.applicationDir.resolve("corda").resolve("corda.jar")
     private val command = jvm.commandFor(cordaPath).toTypedArray()
 
-    private val nodes = LinkedHashMap<String, NodeConfig>()
+    private val nodes = LinkedHashMap<String, NodeConfigWrapper>()
     private val port = AtomicInteger(firstPort)
 
     private var networkMapConfig: NetworkMapConfig? = null
 
-    val activeNodes: List<NodeConfig>
+    val activeNodes: List<NodeConfigWrapper>
         get() = nodes.values.filter {
             (it.state == NodeState.RUNNING) || (it.state == NodeState.STARTING)
         }
@@ -50,38 +55,45 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
     /**
      * Validate a Node configuration provided by [net.corda.demobench.views.NodeTabView].
      */
-    fun validate(nodeData: NodeData): NodeConfig? {
+    fun validate(nodeData: NodeData): NodeConfigWrapper? {
+        fun IntegerExpression.toLocalAddress() = NetworkHostAndPort("localhost", value)
+
         val location = nodeData.nearestCity.value
-        val config = NodeConfig(
-                baseDir,
-                CordaX500Name(
+        val nodeConfig = NodeConfig(
+                myLegalName = CordaX500Name(
                         organisation = nodeData.legalName.value.trim(),
                         locality = location.description,
                         country = location.countryCode
                 ),
-                nodeData.p2pPort.value,
-                nodeData.rpcPort.value,
-                nodeData.webPort.value,
-                nodeData.h2Port.value,
-                nodeData.extraServices.map { serviceController.services[it]!! }.toMutableList()
+                p2pAddress = nodeData.p2pPort.toLocalAddress(),
+                rpcAddress = nodeData.rpcPort.toLocalAddress(),
+                webAddress = nodeData.webPort.toLocalAddress(),
+                notary = nodeData.extraServices.filterIsInstance<NotaryService>().noneOrSingle(),
+                networkMapService = networkMapConfig,  // The first node becomes the network map
+                h2port = nodeData.h2Port.value,
+                issuableCurrencies = nodeData.extraServices.filterIsInstance<CurrencyIssuer>().map { it.currency.toString() }
         )
 
-        if (nodes.putIfAbsent(config.key, config) != null) {
-            log.warning("Node with key '${config.key}' already exists.")
+        val wrapper = NodeConfigWrapper(baseDir, nodeConfig)
+
+        if (nodes.putIfAbsent(wrapper.key, wrapper) != null) {
+            log.warning("Node with key '${wrapper.key}' already exists.")
             return null
         }
 
-        // The first node becomes our network map
-        chooseNetworkMap(config)
+        if (nodeConfig.isNetworkMap) {
+            networkMapConfig = nodeConfig.let { NetworkMapConfig(it.myLegalName, it.p2pAddress) }
+            log.info("Network map provided by: ${nodeConfig.myLegalName}")
+        }
 
-        return config
+        return wrapper
     }
 
-    fun dispose(config: NodeConfig) {
+    fun dispose(config: NodeConfigWrapper) {
         config.state = NodeState.DEAD
 
-        if (config.networkMap == null) {
-            log.warning("Network map service (Node '${config.legalName}') has exited.")
+        if (config.nodeConfig.isNetworkMap) {
+            log.warning("Network map service (Node '${config.nodeConfig.myLegalName}') has exited.")
         }
     }
 
@@ -95,39 +107,26 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
 
     fun hasNetworkMap(): Boolean = networkMapConfig != null
 
-    private fun chooseNetworkMap(config: NodeConfig) {
-        if (hasNetworkMap()) {
-            config.networkMap = networkMapConfig
-        } else {
-            networkMapConfig = config
-            log.info("Network map provided by: ${config.legalName}")
-        }
-    }
+    fun runCorda(pty: R3Pty, config: NodeConfigWrapper): Boolean {
+        try {
+            config.nodeDir.createDirectories()
 
-    fun runCorda(pty: R3Pty, config: NodeConfig): Boolean {
-        val nodeDir = config.nodeDir.toFile()
+            // Install any built-in plugins into the working directory.
+            pluginController.populate(config)
 
-        if (nodeDir.forceDirectory()) {
-            try {
-                // Install any built-in plugins into the working directory.
-                pluginController.populate(config)
+            // Write this node's configuration file into its working directory.
+            val confFile = config.nodeDir / "node.conf"
+            Files.write(confFile, config.nodeConfig.toText().toByteArray())
 
-                // Write this node's configuration file into its working directory.
-                val confFile = nodeDir.resolve("node.conf")
-                confFile.writeText(config.toText())
-
-                // Execute the Corda node
-                val cordaEnv = System.getenv().toMutableMap().apply {
-                    jvm.setCapsuleCacheDir(this)
-                }
-                pty.run(command, cordaEnv, nodeDir.toString())
-                log.info("Launched node: ${config.legalName}")
-                return true
-            } catch (e: Exception) {
-                log.log(Level.SEVERE, "Failed to launch Corda: ${e.message}", e)
-                return false
+            // Execute the Corda node
+            val cordaEnv = System.getenv().toMutableMap().apply {
+                jvm.setCapsuleCacheDir(this)
             }
-        } else {
+            pty.run(command, cordaEnv, config.nodeDir.toString())
+            log.info("Launched node: ${config.nodeConfig.myLegalName}")
+            return true
+        } catch (e: Exception) {
+            log.log(Level.SEVERE, "Failed to launch Corda: ${e.message}", e)
             return false
         }
     }
@@ -144,15 +143,15 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
     /**
      * Add a [NodeConfig] object that has been loaded from a profile.
      */
-    fun register(config: NodeConfig): Boolean {
+    fun register(config: NodeConfigWrapper): Boolean {
         if (nodes.putIfAbsent(config.key, config) != null) {
             return false
         }
 
-        updatePort(config)
+        updatePort(config.nodeConfig)
 
-        if ((networkMapConfig == null) && config.isNetworkMap()) {
-            networkMapConfig = config
+        if (networkMapConfig == null && config.nodeConfig.isNetworkMap) {
+            networkMapConfig = config.nodeConfig.let { NetworkMapConfig(it.myLegalName, it.p2pAddress) }
         }
 
         return true
@@ -162,12 +161,12 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
      * Creates a node directory that can host a running instance of Corda.
      */
     @Throws(IOException::class)
-    fun install(config: InstallConfig): NodeConfig {
+    fun install(config: InstallConfig): NodeConfigWrapper {
         val installed = config.installTo(baseDir)
 
         pluginController.userPluginsFor(config).forEach {
-            val pluginDir = Files.createDirectories(installed.pluginDir)
-            val plugin = Files.copy(it, pluginDir.resolve(it.fileName.toString()))
+            installed.pluginDir.createDirectories()
+            val plugin = it.copyToDirectory(installed.pluginDir)
             log.info("Installed: $plugin")
         }
 
@@ -179,7 +178,7 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
     }
 
     private fun updatePort(config: NodeConfig) {
-        val nextPort = 1 + arrayOf(config.p2pPort, config.rpcPort, config.webPort, config.h2Port).max() as Int
+        val nextPort = 1 + arrayOf(config.p2pAddress.port, config.rpcAddress.port, config.webAddress.port, config.h2port).max() as Int
         port.getAndUpdate { Math.max(nextPort, it) }
     }
 
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeData.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeData.kt
index 90147c5b43..7abdd09775 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeData.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeData.kt
@@ -4,8 +4,10 @@ import javafx.beans.property.SimpleIntegerProperty
 import javafx.beans.property.SimpleListProperty
 import javafx.beans.property.SimpleObjectProperty
 import javafx.beans.property.SimpleStringProperty
+import javafx.collections.FXCollections.observableArrayList
 import net.corda.finance.utils.CityDatabase
 import tornadofx.*
+import java.util.*
 
 object SuggestedDetails {
     val banks = listOf(
@@ -35,7 +37,7 @@ class NodeData {
     val rpcPort = SimpleIntegerProperty()
     val webPort = SimpleIntegerProperty()
     val h2Port = SimpleIntegerProperty()
-    val extraServices = SimpleListProperty(mutableListOf<String>().observable())
+    val extraServices = SimpleListProperty(observableArrayList<ExtraService>())
 }
 
 class NodeDataModel : ItemViewModel<NodeData>(NodeData()) {
@@ -46,3 +48,9 @@ class NodeDataModel : ItemViewModel<NodeData>(NodeData()) {
     val webPort = bind { item?.webPort }
     val h2Port = bind { item?.h2Port }
 }
+
+interface ExtraService
+
+data class CurrencyIssuer(val currency: Currency) : ExtraService {
+    override fun toString(): String = "Issuer $currency"
+}
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt
deleted file mode 100644
index 729f305805..0000000000
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/ServiceController.kt
+++ /dev/null
@@ -1,44 +0,0 @@
-package net.corda.demobench.model
-
-import tornadofx.*
-import java.io.IOException
-import java.io.InputStreamReader
-import java.net.URL
-import java.util.logging.Level
-
-class ServiceController(resourceName: String = "/services.conf") : Controller() {
-
-    val services: Map<String, String> = loadConf(resources.url(resourceName))
-
-    val notaries: Map<String, String> = services.filter { it.value.startsWith("corda.notary.") }
-
-    val issuers: Map<String, String> = services.filter { it.value.startsWith("corda.issuer.") }
-
-    /*
-     * Load our list of known extra Corda services.
-     */
-    private fun loadConf(url: URL?): Map<String, String> {
-        return if (url == null) {
-            emptyMap()
-        } else {
-            try {
-                val map = linkedMapOf<String, String>()
-                InputStreamReader(url.openStream()).useLines { sq ->
-                    sq.forEach { line ->
-                        val service = line.split(":").map { it.trim() }
-                        if (service.size != 2) {
-                            log.warning("Encountered corrupted line '$line' while reading services from config: $url")
-                        } else {
-                            map[service[1]] = service[0]
-                            log.info("Supports: $service")
-                        }
-                    }
-                    map
-                }
-            } catch (e: IOException) {
-                log.log(Level.SEVERE, "Failed to load $url: ${e.message}", e)
-                emptyMap<String, String>()
-            }
-        }
-    }
-}
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/User.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/User.kt
deleted file mode 100644
index c55f3bc5d3..0000000000
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/User.kt
+++ /dev/null
@@ -1,15 +0,0 @@
-@file:JvmName("User")
-
-package net.corda.demobench.model
-
-import net.corda.core.internal.uncheckedCast
-import net.corda.nodeapi.User
-import java.util.*
-
-fun toUser(map: Map<String, Any>) = User(
-        map.getOrElse("username", { "none" }) as String,
-        map.getOrElse("password", { "none" }) as String,
-        LinkedHashSet(uncheckedCast<Any, Collection<String>>(map.getOrElse("permissions", { emptyList<String>() })))
-)
-
-fun user(name: String) = User(name, "letmein", setOf("ALL"))
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/plugin/PluginController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/plugin/PluginController.kt
index 3e9d52f5ca..ac25d72c55 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/plugin/PluginController.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/plugin/PluginController.kt
@@ -5,7 +5,7 @@ import net.corda.core.internal.createDirectories
 import net.corda.core.internal.exists
 import net.corda.demobench.model.HasPlugins
 import net.corda.demobench.model.JVMConfig
-import net.corda.demobench.model.NodeConfig
+import net.corda.demobench.model.NodeConfigWrapper
 import tornadofx.*
 import java.io.IOException
 import java.nio.file.Files
@@ -24,16 +24,14 @@ class PluginController : Controller() {
      * Install any built-in plugins that this node requires.
      */
     @Throws(IOException::class)
-    fun populate(config: NodeConfig) {
-        if (!config.pluginDir.exists()) {
-            config.pluginDir.createDirectories()
-        }
+    fun populate(config: NodeConfigWrapper) {
+        config.pluginDir.createDirectories()
         if (finance.exists()) {
             finance.copyToDirectory(config.pluginDir, StandardCopyOption.REPLACE_EXISTING)
             log.info("Installed 'Finance' plugin")
         }
         // Nodes cannot issue cash unless they contain the "Bank of Corda" plugin.
-        if (config.isCashIssuer && bankOfCorda.exists()) {
+        if (config.nodeConfig.issuableCurrencies.isNotEmpty() && bankOfCorda.exists()) {
             bankOfCorda.copyToDirectory(config.pluginDir, StandardCopyOption.REPLACE_EXISTING)
             log.info("Installed 'Bank of Corda' plugin")
         }
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/profile/ProfileController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/profile/ProfileController.kt
index 5d9a773466..c963a1c9ae 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/profile/ProfileController.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/profile/ProfileController.kt
@@ -4,6 +4,8 @@ import com.typesafe.config.Config
 import com.typesafe.config.ConfigFactory
 import javafx.stage.FileChooser
 import javafx.stage.FileChooser.ExtensionFilter
+import net.corda.core.internal.createDirectories
+import net.corda.core.internal.div
 import net.corda.demobench.model.InstallConfig
 import net.corda.demobench.model.InstallFactory
 import net.corda.demobench.model.JVMConfig
@@ -58,8 +60,8 @@ class ProfileController : Controller() {
             FileSystems.newFileSystem(URI.create("jar:" + target.toURI()), mapOf("create" to "true")).use { fs ->
                 configs.forEach { config ->
                     // Write the configuration file.
-                    val nodeDir = Files.createDirectories(fs.getPath(config.key))
-                    val file = Files.write(nodeDir.resolve("node.conf"), config.toText().toByteArray(UTF_8))
+                    val nodeDir = fs.getPath(config.key).createDirectories()
+                    val file = Files.write(nodeDir / "node.conf", config.nodeConfig.toText().toByteArray(UTF_8))
                     log.info("Wrote: $file")
 
                     // Write all of the non-built-in plugins.
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/rpc/NodeRPC.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/rpc/NodeRPC.kt
index 339eed00ad..a92dbd4a3d 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/rpc/NodeRPC.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/rpc/NodeRPC.kt
@@ -5,18 +5,17 @@ import net.corda.client.rpc.CordaRPCConnection
 import net.corda.core.messaging.CordaRPCOps
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.loggerFor
-import net.corda.demobench.model.NodeConfig
+import net.corda.demobench.model.NodeConfigWrapper
 import java.util.*
 import java.util.concurrent.TimeUnit.SECONDS
 
-class NodeRPC(config: NodeConfig, start: (NodeConfig, CordaRPCOps) -> Unit, invoke: (CordaRPCOps) -> Unit) : AutoCloseable {
-
+class NodeRPC(config: NodeConfigWrapper, start: (NodeConfigWrapper, CordaRPCOps) -> Unit, invoke: (CordaRPCOps) -> Unit) : AutoCloseable {
     private companion object {
         val log = loggerFor<NodeRPC>()
         val oneSecond = SECONDS.toMillis(1)
     }
 
-    private val rpcClient = CordaRPCClient(NetworkHostAndPort("localhost", config.rpcPort))
+    private val rpcClient = CordaRPCClient(NetworkHostAndPort("localhost", config.nodeConfig.rpcAddress.port))
     private var rpcConnection: CordaRPCConnection? = null
     private val timer = Timer()
 
@@ -24,7 +23,7 @@ class NodeRPC(config: NodeConfig, start: (NodeConfig, CordaRPCOps) -> Unit, invo
         val setupTask = object : TimerTask() {
             override fun run() {
                 try {
-                    val user = config.users.elementAt(0)
+                    val user = config.nodeConfig.rpcUsers[0]
                     val connection = rpcClient.start(user.username, user.password)
                     rpcConnection = connection
                     val ops = connection.proxy
@@ -42,7 +41,7 @@ class NodeRPC(config: NodeConfig, start: (NodeConfig, CordaRPCOps) -> Unit, invo
                         }
                     }, 0, oneSecond)
                 } catch (e: Exception) {
-                    log.warn("Node '{}' not ready yet (Error: {})", config.legalName, e.message)
+                    log.warn("Node '{}' not ready yet (Error: {})", config.nodeConfig.myLegalName, e.message)
                 }
             }
         }
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTabView.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTabView.kt
index f36edea872..c9f993a5c2 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTabView.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTabView.kt
@@ -16,10 +16,14 @@ import javafx.scene.layout.Priority
 import javafx.stage.FileChooser
 import javafx.util.StringConverter
 import net.corda.core.internal.*
-import net.corda.finance.utils.CityDatabase
-import net.corda.finance.utils.WorldMapLocation
 import net.corda.demobench.model.*
 import net.corda.demobench.ui.CloseableTab
+import net.corda.finance.CHF
+import net.corda.finance.EUR
+import net.corda.finance.GBP
+import net.corda.finance.USD
+import net.corda.finance.utils.CityDatabase
+import net.corda.finance.utils.WorldMapLocation
 import org.controlsfx.control.CheckListView
 import tornadofx.*
 import java.nio.file.Path
@@ -39,10 +43,10 @@ class NodeTabView : Fragment() {
         val cordappPathsFile: Path = jvm.dataHome / "cordapp-paths.txt"
 
         fun loadDefaultCordappPaths(): MutableList<Path> {
-            if (cordappPathsFile.exists())
-                return cordappPathsFile.readAllLines().map { Paths.get(it) }.filter { it.exists() }.toMutableList()
+            return if (cordappPathsFile.exists())
+                cordappPathsFile.readAllLines().map { Paths.get(it) }.filter { it.exists() }.toMutableList()
             else
-                return ArrayList()
+                ArrayList()
         }
 
         // This is shared between tabs.
@@ -58,11 +62,9 @@ class NodeTabView : Fragment() {
     }
 
     private val nodeController by inject<NodeController>()
-    private val serviceController by inject<ServiceController>()
     private val chooser = FileChooser()
 
     private val model = NodeDataModel()
-    private val availableServices: List<String> = if (nodeController.hasNetworkMap()) serviceController.issuers.keys.toList() else serviceController.notaries.keys.toList()
 
     private val nodeTerminalView = find<NodeTerminalView>()
     private val nodeConfigView = stackpane {
@@ -112,8 +114,13 @@ class NodeTabView : Fragment() {
 
                 fieldset("Additional configuration") {
                     styleClass.addAll("services-panel")
+                    val extraServices = if (nodeController.hasNetworkMap()) {
+                        listOf(USD, GBP, CHF, EUR).map { CurrencyIssuer(it) }
+                    } else {
+                        listOf(NotaryService(true), NotaryService(false))
+                    }
 
-                    val servicesList = CheckListView(availableServices.observable()).apply {
+                    val servicesList = CheckListView(extraServices.observable()).apply {
                         vboxConstraints { vGrow = Priority.ALWAYS }
                         model.item.extraServices.set(checkModel.checkedItems)
                         if (!nodeController.hasNetworkMap()) {
@@ -263,17 +270,17 @@ class NodeTabView : Fragment() {
     /**
      * Launches a preconfigured Corda node, e.g. from a saved profile.
      */
-    fun launch(config: NodeConfig) {
+    fun launch(config: NodeConfigWrapper) {
         nodeController.register(config)
         launchNode(config)
     }
 
-    private fun launchNode(config: NodeConfig) {
-        val countryCode = CityDatabase.cityMap[config.nearestCity]?.countryCode
+    private fun launchNode(config: NodeConfigWrapper) {
+        val countryCode = CityDatabase.cityMap[config.nodeConfig.myLegalName.locality]?.countryCode
         if (countryCode != null) {
             nodeTab.graphic = ImageView(flags.get()[countryCode]).apply { fitWidth = 24.0; isPreserveRatio = true }
         }
-        nodeTab.text = config.legalName.organisation
+        nodeTab.text = config.nodeConfig.myLegalName.organisation
         nodeTerminalView.open(config) { exitCode ->
             Platform.runLater {
                 if (exitCode == 0) {
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt
index 6046aa0e11..d1e2f59492 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt
@@ -20,6 +20,7 @@ import net.corda.core.messaging.vaultTrackBy
 import net.corda.core.node.services.vault.PageSpecification
 import net.corda.demobench.explorer.ExplorerController
 import net.corda.demobench.model.NodeConfig
+import net.corda.demobench.model.NodeConfigWrapper
 import net.corda.demobench.model.NodeController
 import net.corda.demobench.model.NodeState
 import net.corda.demobench.pty.R3Pty
@@ -69,8 +70,8 @@ class NodeTerminalView : Fragment() {
     private lateinit var logo: ImageView
     private lateinit var swingTerminal: SwingNode
 
-    fun open(config: NodeConfig, onExit: (Int) -> Unit) {
-        nodeName.text = config.legalName.organisation
+    fun open(config: NodeConfigWrapper, onExit: (Int) -> Unit) {
+        nodeName.text = config.nodeConfig.myLegalName.organisation
 
         swingTerminal = SwingNode()
         swingTerminal.setOnMouseClicked {
@@ -85,13 +86,13 @@ class NodeTerminalView : Fragment() {
         root.isVisible = true
 
         SwingUtilities.invokeLater({
-            val r3pty = R3Pty(config.legalName, TerminalSettingsProvider(), Dimension(160, 80), onExit)
+            val r3pty = R3Pty(config.nodeConfig.myLegalName, TerminalSettingsProvider(), Dimension(160, 80), onExit)
             pty = r3pty
 
             if (nodeController.runCorda(r3pty, config)) {
                 swingTerminal.content = r3pty.terminal
 
-                configureDatabaseButton(config)
+                configureDatabaseButton(config.nodeConfig)
                 configureExplorerButton(config)
                 configureWebButton(config)
 
@@ -105,7 +106,7 @@ class NodeTerminalView : Fragment() {
                  * and close the RPC client if it has.
                  */
                 if (!r3pty.isConnected) {
-                    log.severe("Node '${config.legalName}' has failed to start.")
+                    log.severe("Node '${config.nodeConfig.myLegalName}' has failed to start.")
                     swingTerminal.content = null
                     rpc?.close()
                 }
@@ -119,7 +120,7 @@ class NodeTerminalView : Fragment() {
      * launched the explorer and only reenable it when
      * the explorer has exited.
      */
-    private fun configureExplorerButton(config: NodeConfig) {
+    private fun configureExplorerButton(config: NodeConfigWrapper) {
         launchExplorerButton.setOnAction {
             launchExplorerButton.isDisable = true
 
@@ -131,7 +132,7 @@ class NodeTerminalView : Fragment() {
 
     private fun configureDatabaseButton(config: NodeConfig) {
         viewDatabaseButton.setOnAction {
-            viewer.openBrowser(config.h2Port)
+            viewer.openBrowser(config.h2port)
         }
     }
 
@@ -144,7 +145,7 @@ class NodeTerminalView : Fragment() {
      * launched the web server and only reenable it when
      * the web server has exited.
      */
-    private fun configureWebButton(config: NodeConfig) {
+    private fun configureWebButton(config: NodeConfigWrapper) {
         launchWebButton.setOnAction {
             if (webURL != null) {
                 app.hostServices.showDocument(webURL.toString())
@@ -161,12 +162,12 @@ class NodeTerminalView : Fragment() {
             launchWebButton.text = ""
             launchWebButton.graphic = ProgressIndicator()
 
-            log.info("Starting web server for ${config.legalName}")
+            log.info("Starting web server for ${config.nodeConfig.myLegalName}")
             webServer.open(config).then {
                 Platform.runLater {
                     launchWebButton.graphic = null
                     it.match(success = {
-                        log.info("Web server for ${config.legalName} started on $it")
+                        log.info("Web server for ${config.nodeConfig.myLegalName} started on $it")
                         webURL = it
                         launchWebButton.text = "Reopen\nweb site"
                         app.hostServices.showDocument(it.toString())
@@ -178,13 +179,13 @@ class NodeTerminalView : Fragment() {
         }
     }
 
-    private fun launchRPC(config: NodeConfig) = NodeRPC(
+    private fun launchRPC(config: NodeConfigWrapper) = NodeRPC(
             config = config,
             start = this::initialise,
             invoke = this::pollCashBalances
     )
 
-    private fun initialise(config: NodeConfig, ops: CordaRPCOps) {
+    private fun initialise(config: NodeConfigWrapper, ops: CordaRPCOps) {
         try {
             val (txInit, txNext) = ops.internalVerifiedTransactionsFeed()
             val (stateInit, stateNext) = ops.vaultTrackBy<ContractState>(paging = pageSpecification)
@@ -212,7 +213,7 @@ class NodeTerminalView : Fragment() {
         }
 
         config.state = NodeState.RUNNING
-        log.info("Node '${config.legalName}' is now ready.")
+        log.info("Node '${config.nodeConfig.myLegalName}' is now ready.")
 
         header.isDisable = false
     }
@@ -225,7 +226,7 @@ class NodeTerminalView : Fragment() {
             )
 
             Platform.runLater {
-                balance.value = if (cashBalances.isNullOrEmpty()) "0" else cashBalances
+                balance.value = if (cashBalances.isEmpty()) "0" else cashBalances
             }
         } catch (e: ClassNotFoundException) {
             // TODO: Remove this special case once Rick's serialisation work means we can deserialise states that weren't on our own classpath.
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/web/WebServer.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/web/WebServer.kt
index 4aec34a73b..5fe5f96fe1 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/web/WebServer.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/web/WebServer.kt
@@ -2,11 +2,11 @@ package net.corda.demobench.web
 
 import com.google.common.util.concurrent.RateLimiter
 import net.corda.core.concurrent.CordaFuture
-import net.corda.core.utilities.minutes
 import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.internal.until
 import net.corda.core.utilities.loggerFor
-import net.corda.demobench.model.NodeConfig
+import net.corda.core.utilities.minutes
+import net.corda.demobench.model.NodeConfigWrapper
 import net.corda.demobench.readErrorLines
 import java.io.IOException
 import java.net.HttpURLConnection
@@ -25,7 +25,7 @@ class WebServer internal constructor(private val webServerController: WebServerC
     private var process: Process? = null
 
     @Throws(IOException::class)
-    fun open(config: NodeConfig): CordaFuture<URI> {
+    fun open(config: NodeConfigWrapper): CordaFuture<URI> {
         val nodeDir = config.nodeDir.toFile()
 
         if (!nodeDir.isDirectory) {
@@ -33,13 +33,14 @@ class WebServer internal constructor(private val webServerController: WebServerC
             return openFuture()
         }
 
+        val legalName = config.nodeConfig.myLegalName
         try {
             val p = webServerController.process()
                     .directory(nodeDir)
                     .start()
             process = p
 
-            log.info("Launched Web Server for '{}'", config.legalName)
+            log.info("Launched Web Server for '{}'", legalName)
 
             // Close these streams because no-one is using them.
             safeClose(p.outputStream)
@@ -51,22 +52,22 @@ class WebServer internal constructor(private val webServerController: WebServerC
                 process = null
 
                 if (errors.isEmpty()) {
-                    log.info("Web Server for '{}' has exited (value={})", config.legalName, exitValue)
+                    log.info("Web Server for '{}' has exited (value={})", legalName, exitValue)
                 } else {
-                    log.error("Web Server for '{}' has exited (value={}, {})", config.legalName, exitValue, errors)
+                    log.error("Web Server for '{}' has exited (value={}, {})", legalName, exitValue, errors)
                 }
             }
 
             val future = openFuture<URI>()
             thread {
                 future.capture {
-                    log.info("Waiting for web server for ${config.legalName} to start ...")
-                    waitForStart(config.webPort)
+                    log.info("Waiting for web server for $legalName to start ...")
+                    waitForStart(config.nodeConfig.webAddress.port)
                 }
             }
             return future
         } catch (e: IOException) {
-            log.error("Failed to launch Web Server for '{}': {}", config.legalName, e.message)
+            log.error("Failed to launch Web Server for '{}': {}", legalName, e.message)
             throw e
         }
     }
diff --git a/tools/demobench/src/main/resources/services.conf b/tools/demobench/src/main/resources/services.conf
deleted file mode 100644
index d8319ddccb..0000000000
--- a/tools/demobench/src/main/resources/services.conf
+++ /dev/null
@@ -1,6 +0,0 @@
-corda.notary.validating : Validating Notary
-corda.notary.simple : Non-validating Notary
-corda.issuer.USD : Issuer USD
-corda.issuer.GBP : Issuer GBP
-corda.issuer.CHF : Issuer CHF
-corda.issuer.EUR : Issuer EUR
\ No newline at end of file
diff --git a/tools/demobench/src/test/kotlin/net/corda/demobench/LoggingTestSuite.kt b/tools/demobench/src/test/kotlin/net/corda/demobench/LoggingTestSuite.kt
index 946718c42a..33e9d4169b 100644
--- a/tools/demobench/src/test/kotlin/net/corda/demobench/LoggingTestSuite.kt
+++ b/tools/demobench/src/test/kotlin/net/corda/demobench/LoggingTestSuite.kt
@@ -3,7 +3,6 @@ package net.corda.demobench
 import net.corda.demobench.config.LoggingConfig
 import net.corda.demobench.model.JVMConfigTest
 import net.corda.demobench.model.NodeControllerTest
-import net.corda.demobench.model.ServiceControllerTest
 import org.junit.BeforeClass
 import org.junit.runner.RunWith
 import org.junit.runners.Suite
@@ -13,7 +12,6 @@ import org.junit.runners.Suite
  */
 @RunWith(Suite::class)
 @Suite.SuiteClasses(
-        ServiceControllerTest::class,
         NodeControllerTest::class,
         JVMConfigTest::class
 )
diff --git a/tools/demobench/src/test/kotlin/net/corda/demobench/model/NetworkMapConfigTest.kt b/tools/demobench/src/test/kotlin/net/corda/demobench/model/NetworkMapConfigTest.kt
deleted file mode 100644
index 0c9892f340..0000000000
--- a/tools/demobench/src/test/kotlin/net/corda/demobench/model/NetworkMapConfigTest.kt
+++ /dev/null
@@ -1,22 +0,0 @@
-package net.corda.demobench.model
-
-import net.corda.core.identity.CordaX500Name
-import org.bouncycastle.asn1.x500.X500Name
-import org.junit.Ignore
-import org.junit.Test
-import kotlin.test.assertEquals
-
-class NetworkMapConfigTest {
-    @Ignore("This has been superseded by validation logic in CordaX500Name")
-    @Test
-    fun keyValue() {
-        val config = NetworkMapConfig(CordaX500Name.parse("O=My\tNasty Little\rLabel\n,L=London,C=GB"), 10000)
-        assertEquals("mynastylittlelabel", config.key)
-    }
-
-    @Test
-    fun removeWhitespace() {
-        assertEquals("OneTwoThreeFour!", "One\tTwo   \rThree\r\nFour!".stripWhitespace())
-    }
-
-}
diff --git a/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeConfigTest.kt b/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeConfigTest.kt
index 4970d68c11..e8fb14dff4 100644
--- a/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeConfigTest.kt
+++ b/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeConfigTest.kt
@@ -1,190 +1,30 @@
 package net.corda.demobench.model
 
-import com.fasterxml.jackson.annotation.JsonInclude
-import com.fasterxml.jackson.databind.ObjectMapper
-import com.fasterxml.jackson.databind.SerializationFeature
 import com.typesafe.config.ConfigFactory
 import com.typesafe.config.ConfigValueFactory
 import net.corda.core.identity.CordaX500Name
-import net.corda.core.internal.div
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.node.internal.NetworkMapInfo
 import net.corda.node.services.config.FullNodeConfiguration
 import net.corda.nodeapi.User
 import net.corda.nodeapi.config.parseAs
+import net.corda.nodeapi.config.toConfig
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.webserver.WebServerConfig
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
-import java.io.StringWriter
 import java.nio.file.Path
 import java.nio.file.Paths
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
-import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
-
 class NodeConfigTest {
-
     companion object {
         private val baseDir: Path = Paths.get(".").toAbsolutePath()
         private val myLegalName = CordaX500Name(organisation = "My Name", locality = "New York", country = "US")
     }
 
-    @Test
-    fun `test name`() {
-        val config = createConfig(legalName = myLegalName)
-        assertEquals(myLegalName, config.legalName)
-        assertEquals("myname", config.key)
-    }
-
-    @Test
-    fun `test node directory`() {
-        val config = createConfig(legalName = myLegalName)
-        assertEquals(baseDir / "myname", config.nodeDir)
-    }
-
-    @Test
-    fun `test explorer directory`() {
-        val config = createConfig(legalName = myLegalName)
-        assertEquals(baseDir / "myname-explorer", config.explorerDir)
-    }
-
-    @Test
-    fun `test plugin directory`() {
-        val config = createConfig(legalName = myLegalName)
-        assertEquals(baseDir / "myname" / "plugins", config.pluginDir)
-    }
-
-    @Test
-    fun `test P2P port`() {
-        val config = createConfig(p2pPort = 10001)
-        assertEquals(10001, config.p2pPort)
-    }
-
-    @Test
-    fun `test rpc port`() {
-        val config = createConfig(rpcPort = 40002)
-        assertEquals(40002, config.rpcPort)
-    }
-
-    @Test
-    fun `test web port`() {
-        val config = createConfig(webPort = 20001)
-        assertEquals(20001, config.webPort)
-    }
-
-    @Test
-    fun `test H2 port`() {
-        val config = createConfig(h2Port = 30001)
-        assertEquals(30001, config.h2Port)
-    }
-
-    @Test
-    fun `test services`() {
-        val config = createConfig(services = mutableListOf("my.service"))
-        assertEquals(listOf("my.service"), config.extraServices)
-    }
-
-    @Test
-    fun `test users`() {
-        val config = createConfig(users = listOf(user("myuser")))
-        assertEquals(listOf(user("myuser")), config.users)
-    }
-
-    @Test
-    fun `test default state`() {
-        val config = createConfig()
-        assertEquals(NodeState.STARTING, config.state)
-    }
-
-    @Test
-    fun `test network map`() {
-        val config = createConfig()
-        assertNull(config.networkMap)
-        assertTrue(config.isNetworkMap())
-    }
-
-    @Test
-    fun `test cash issuer`() {
-        val config = createConfig(services = mutableListOf("corda.issuer.GBP"))
-        assertTrue(config.isCashIssuer)
-    }
-
-    @Test
-    fun `test not cash issuer`() {
-        val config = createConfig(services = mutableListOf("corda.issuerubbish"))
-        assertFalse(config.isCashIssuer)
-    }
-
-    /**
-     * Reformat JSON via Jackson to ensure a consistent format for comparison purposes.
-     */
-    private fun prettyPrint(content: String): String {
-        val mapper = ObjectMapper()
-        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL)
-        mapper.enable(SerializationFeature.INDENT_OUTPUT)
-        val sw = StringWriter()
-        val parsed = mapper.readTree(content)
-        mapper.writeValue(sw, parsed)
-        return sw.toString()
-    }
-
-    @Test
-    fun `test config text`() {
-        val config = createConfig(
-                legalName = myLegalName,
-                p2pPort = 10001,
-                rpcPort = 40002,
-                webPort = 20001,
-                h2Port = 30001,
-                services = mutableListOf("my.service"),
-                users = listOf(user("jenny"))
-        )
-        assertEquals(prettyPrint("{"
-                + "\"detectPublicIp\":false,"
-                + "\"extraAdvertisedServiceIds\":[\"my.service\"],"
-                + "\"h2port\":30001,"
-                + "\"myLegalName\":\"C=US,L=New York,O=My Name\","
-                + "\"p2pAddress\":\"localhost:10001\","
-                + "\"rpcAddress\":\"localhost:40002\","
-                + "\"rpcUsers\":["
-                + "{\"password\":\"letmein\",\"permissions\":[\"ALL\"],\"username\":\"jenny\"}"
-                + "],"
-                + "\"useTestClock\":true,"
-                + "\"webAddress\":\"localhost:20001\""
-                + "}"), prettyPrint(config.toText()))
-    }
-
-    @Test
-    fun `test config text with network map`() {
-        val config = createConfig(
-                legalName = myLegalName,
-                p2pPort = 10001,
-                rpcPort = 40002,
-                webPort = 20001,
-                h2Port = 30001,
-                services = mutableListOf("my.service"),
-                users = listOf(user("jenny"))
-        )
-        config.networkMap = NetworkMapConfig(DUMMY_NOTARY.name, 12345)
-
-        assertEquals(prettyPrint("{"
-                + "\"detectPublicIp\":false,"
-                + "\"extraAdvertisedServiceIds\":[\"my.service\"],"
-                + "\"h2port\":30001,"
-                + "\"myLegalName\":\"C=US,L=New York,O=My Name\","
-                + "\"networkMapService\":{\"address\":\"localhost:12345\",\"legalName\":\"C=CH,L=Zurich,O=Notary Service\"},"
-                + "\"p2pAddress\":\"localhost:10001\","
-                + "\"rpcAddress\":\"localhost:40002\","
-                + "\"rpcUsers\":["
-                + "{\"password\":\"letmein\",\"permissions\":[\"ALL\"],\"username\":\"jenny\"}"
-                + "],"
-                + "\"useTestClock\":true,"
-                + "\"webAddress\":\"localhost:20001\""
-                + "}"), prettyPrint(config.toText()))
-    }
-
     @Test
     fun `reading node configuration`() {
         val config = createConfig(
@@ -192,13 +32,13 @@ class NodeConfigTest {
                 p2pPort = 10001,
                 rpcPort = 40002,
                 webPort = 20001,
-                h2Port = 30001,
-                services = mutableListOf("my.service"),
+                h2port = 30001,
+                notary = NotaryService(validating = false),
+                networkMap = NetworkMapConfig(DUMMY_NOTARY.name, localPort(12345)),
                 users = listOf(user("jenny"))
         )
-        config.networkMap = NetworkMapConfig(DUMMY_NOTARY.name, 12345)
 
-        val nodeConfig = config.toFileConfig()
+        val nodeConfig = config.toConfig()
                 .withValue("baseDirectory", ConfigValueFactory.fromAnyRef(baseDir.toString()))
                 .withFallback(ConfigFactory.parseResources("reference.conf"))
                 .resolve()
@@ -207,10 +47,9 @@ class NodeConfigTest {
         assertEquals(myLegalName, fullConfig.myLegalName)
         assertEquals(localPort(40002), fullConfig.rpcAddress)
         assertEquals(localPort(10001), fullConfig.p2pAddress)
-        assertEquals(listOf("my.service"), fullConfig.extraAdvertisedServiceIds)
         assertEquals(listOf(user("jenny")), fullConfig.rpcUsers)
         assertEquals(NetworkMapInfo(localPort(12345), DUMMY_NOTARY.name), fullConfig.networkMapService)
-        assertTrue((fullConfig.dataSourceProperties["dataSource.url"] as String).contains("AUTO_SERVER_PORT=30001"))
+        assertThat(fullConfig.dataSourceProperties["dataSource.url"] as String).contains("AUTO_SERVER_PORT=30001")
         assertTrue(fullConfig.useTestClock)
         assertFalse(fullConfig.detectPublicIp)
     }
@@ -222,13 +61,13 @@ class NodeConfigTest {
                 p2pPort = 10001,
                 rpcPort = 40002,
                 webPort = 20001,
-                h2Port = 30001,
-                services = mutableListOf("my.service"),
+                h2port = 30001,
+                notary = NotaryService(validating = false),
+                networkMap = NetworkMapConfig(DUMMY_NOTARY.name, localPort(12345)),
                 users = listOf(user("jenny"))
         )
-        config.networkMap = NetworkMapConfig(DUMMY_NOTARY.name, 12345)
 
-        val nodeConfig = config.toFileConfig()
+        val nodeConfig = config.toConfig()
                 .withValue("baseDirectory", ConfigValueFactory.fromAnyRef(baseDir.toString()))
                 .withFallback(ConfigFactory.parseResources("web-reference.conf"))
                 .resolve()
@@ -240,35 +79,27 @@ class NodeConfigTest {
         assertEquals("cordacadevpass", webConfig.keyStorePassword)
     }
 
-    @Test
-    fun `test moving`() {
-        val config = createConfig(legalName = myLegalName)
-
-        val elsewhere = baseDir / "elsewhere"
-        val moved = config.moveTo(elsewhere)
-        assertEquals(elsewhere / "myname", moved.nodeDir)
-        assertEquals(elsewhere / "myname-explorer", moved.explorerDir)
-        assertEquals(elsewhere / "myname" / "plugins", moved.pluginDir)
-    }
-
     private fun createConfig(
             legalName: CordaX500Name = CordaX500Name(organisation = "Unknown", locality = "Nowhere", country = "GB"),
             p2pPort: Int = -1,
             rpcPort: Int = -1,
             webPort: Int = -1,
-            h2Port: Int = -1,
-            services: MutableList<String> = mutableListOf("extra.service"),
+            h2port: Int = -1,
+            notary: NotaryService?,
+            networkMap: NetworkMapConfig?,
             users: List<User> = listOf(user("guest"))
-    ) = NodeConfig(
-            baseDir,
-            legalName = legalName,
-            p2pPort = p2pPort,
-            rpcPort = rpcPort,
-            webPort = webPort,
-            h2Port = h2Port,
-            extraServices = services,
-            users = users
-    )
+    ): NodeConfig {
+        return NodeConfig(
+                myLegalName = legalName,
+                p2pAddress = localPort(p2pPort),
+                rpcAddress = localPort(rpcPort),
+                webAddress = localPort(webPort),
+                h2port = h2port,
+                notary = notary,
+                networkMapService = networkMap,
+                rpcUsers = users
+        )
+    }
 
     private fun localPort(port: Int) = NetworkHostAndPort("localhost", port)
 }
diff --git a/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeControllerTest.kt b/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeControllerTest.kt
index f6c73aba2d..bae103a317 100644
--- a/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeControllerTest.kt
+++ b/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeControllerTest.kt
@@ -1,6 +1,7 @@
 package net.corda.demobench.model
 
 import net.corda.core.identity.CordaX500Name
+import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.nodeapi.User
 import net.corda.testing.DUMMY_NOTARY
 import org.junit.Test
@@ -51,7 +52,7 @@ class NodeControllerTest {
     fun `test first validated node becomes network map`() {
         val data = NodeData()
         data.legalName.value = node1Name
-        data.p2pPort.value = 100000
+        data.p2pPort.value = 10000
 
         assertFalse(controller.hasNetworkMap())
         controller.validate(data)
@@ -90,7 +91,7 @@ class NodeControllerTest {
     @Test
     fun `test register network map node`() {
         val config = createConfig(commonName = "Organisation is Network Map")
-        assertTrue(config.isNetworkMap())
+        assertTrue(config.nodeConfig.isNetworkMap)
 
         assertFalse(controller.hasNetworkMap())
         controller.register(config)
@@ -99,9 +100,10 @@ class NodeControllerTest {
 
     @Test
     fun `test register non-network-map node`() {
-        val config = createConfig(commonName = "Organisation is not Network Map")
-        config.networkMap = NetworkMapConfig(DUMMY_NOTARY.name, 10000)
-        assertFalse(config.isNetworkMap())
+        val config = createConfig(
+                commonName = "Organisation is not Network Map",
+                networkMap = NetworkMapConfig(DUMMY_NOTARY.name, localPort(10000)))
+        assertFalse(config.nodeConfig.isNetworkMap)
 
         assertFalse(controller.hasNetworkMap())
         controller.register(config)
@@ -146,7 +148,7 @@ class NodeControllerTest {
     @Test
     fun `test H2 port is max`() {
         val portNumber = NodeController.firstPort + 3478
-        val config = createConfig(h2Port = portNumber)
+        val config = createConfig(h2port = portNumber)
         assertEquals(NodeController.firstPort, controller.nextPort)
         controller.register(config)
         assertEquals(portNumber + 1, controller.nextPort)
@@ -166,25 +168,30 @@ class NodeControllerTest {
 
     private fun createConfig(
             commonName: String = "Unknown",
-            p2pPort: Int = -1,
-            rpcPort: Int = -1,
-            webPort: Int = -1,
-            h2Port: Int = -1,
-            services: MutableList<String> = mutableListOf("extra.service"),
+            p2pPort: Int = 0,
+            rpcPort: Int = 0,
+            webPort: Int = 0,
+            h2port: Int = 0,
+            notary: NotaryService? = null,
+            networkMap: NetworkMapConfig? = null,
             users: List<User> = listOf(user("guest"))
-    ) = NodeConfig(
-            baseDir,
-            legalName = CordaX500Name(
-                    organisation = commonName,
-                    locality = "New York",
-                    country = "US"
-            ),
-            p2pPort = p2pPort,
-            rpcPort = rpcPort,
-            webPort = webPort,
-            h2Port = h2Port,
-            extraServices = services,
-            users = users
-    )
+    ): NodeConfigWrapper {
+        val nodeConfig = NodeConfig(
+                myLegalName = CordaX500Name(
+                        organisation = commonName,
+                        locality = "New York",
+                        country = "US"
+                ),
+                p2pAddress = localPort(p2pPort),
+                rpcAddress = localPort(rpcPort),
+                webAddress = localPort(webPort),
+                h2port = h2port,
+                notary = notary,
+                networkMapService = networkMap,
+                rpcUsers = users
+        )
+        return NodeConfigWrapper(baseDir, nodeConfig)
+    }
 
+    private fun localPort(port: Int) = NetworkHostAndPort("localhost", port)
 }
diff --git a/tools/demobench/src/test/kotlin/net/corda/demobench/model/ServiceControllerTest.kt b/tools/demobench/src/test/kotlin/net/corda/demobench/model/ServiceControllerTest.kt
deleted file mode 100644
index f80f13b165..0000000000
--- a/tools/demobench/src/test/kotlin/net/corda/demobench/model/ServiceControllerTest.kt
+++ /dev/null
@@ -1,44 +0,0 @@
-package net.corda.demobench.model
-
-import org.junit.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertNotNull
-import kotlin.test.assertTrue
-
-class ServiceControllerTest {
-
-    @Test
-    fun `test empty`() {
-        val controller = ServiceController("/empty-services.conf")
-        assertNotNull(controller.services)
-        assertTrue(controller.services.isEmpty())
-
-        assertNotNull(controller.notaries)
-        assertTrue(controller.notaries.isEmpty())
-    }
-
-    @Test
-    fun `test duplicates`() {
-        val controller = ServiceController("/duplicate-services.conf")
-        assertNotNull(controller.services)
-        assertEquals(listOf("corda.example"), controller.services.map { it.value })
-    }
-
-    @Test
-    fun `test notaries`() {
-        val controller = ServiceController("/notary-services.conf")
-        assertNotNull(controller.notaries)
-        assertEquals(listOf("corda.notary.simple"), controller.notaries.map { it.value })
-    }
-
-    @Test
-    fun `test services`() {
-        val controller = ServiceController()
-        assertNotNull(controller.services)
-        assertTrue(controller.services.isNotEmpty())
-
-        assertNotNull(controller.notaries)
-        assertTrue(controller.notaries.isNotEmpty())
-    }
-
-}
\ No newline at end of file
diff --git a/tools/demobench/src/test/kotlin/net/corda/demobench/model/UserTest.kt b/tools/demobench/src/test/kotlin/net/corda/demobench/model/UserTest.kt
deleted file mode 100644
index 5376c0915e..0000000000
--- a/tools/demobench/src/test/kotlin/net/corda/demobench/model/UserTest.kt
+++ /dev/null
@@ -1,47 +0,0 @@
-package net.corda.demobench.model
-
-import net.corda.nodeapi.User
-import org.junit.Test
-import kotlin.test.assertEquals
-
-class UserTest {
-
-    @Test
-    fun createFromEmptyMap() {
-        val user = toUser(emptyMap())
-        assertEquals("none", user.username)
-        assertEquals("none", user.password)
-        assertEquals(emptySet(), user.permissions)
-    }
-
-    @Test
-    fun createFromMap() {
-        val map = mapOf(
-                "username" to "MyName",
-                "password" to "MyPassword",
-                "permissions" to listOf("Flow.MyFlow")
-        )
-        val user = toUser(map)
-        assertEquals("MyName", user.username)
-        assertEquals("MyPassword", user.password)
-        assertEquals(setOf("Flow.MyFlow"), user.permissions)
-    }
-
-    @Test
-    fun userToMap() {
-        val user = User("MyName", "MyPassword", setOf("Flow.MyFlow"))
-        val map = user.toMap()
-        assertEquals("MyName", map["username"])
-        assertEquals("MyPassword", map["password"])
-        assertEquals(listOf("Flow.MyFlow"), map["permissions"])
-    }
-
-    @Test
-    fun `default user`() {
-        val user = user("guest")
-        assertEquals("guest", user.username)
-        assertEquals("letmein", user.password)
-        assertEquals(setOf("ALL"), user.permissions)
-    }
-
-}
diff --git a/tools/demobench/src/test/resources/duplicate-services.conf b/tools/demobench/src/test/resources/duplicate-services.conf
deleted file mode 100644
index f7faf80aed..0000000000
--- a/tools/demobench/src/test/resources/duplicate-services.conf
+++ /dev/null
@@ -1,3 +0,0 @@
-corda.example : Example
-corda.example : Example
-corda.example : Example
diff --git a/tools/demobench/src/test/resources/empty-services.conf b/tools/demobench/src/test/resources/empty-services.conf
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/tools/demobench/src/test/resources/notary-services.conf b/tools/demobench/src/test/resources/notary-services.conf
deleted file mode 100644
index 79c6835073..0000000000
--- a/tools/demobench/src/test/resources/notary-services.conf
+++ /dev/null
@@ -1,2 +0,0 @@
-corda.notary.simple : Notary Simple
-corda.example : Example
diff --git a/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt b/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt
index 5dbb09753c..d22e628596 100644
--- a/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt
+++ b/tools/explorer/src/main/kotlin/net/corda/explorer/ExplorerSimulation.kt
@@ -22,8 +22,6 @@ import net.corda.finance.flows.CashExitFlow.ExitRequest
 import net.corda.finance.flows.CashIssueAndPaymentFlow.IssueAndPaymentRequest
 import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
 import net.corda.nodeapi.User
-import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.testing.ALICE
 import net.corda.testing.BOB
 import net.corda.testing.DUMMY_NOTARY
@@ -71,19 +69,19 @@ class ExplorerSimulation(val options: OptionSet) {
             // TODO : Supported flow should be exposed somehow from the node instead of set of ServiceInfo.
             val notary = startNotaryNode(DUMMY_NOTARY.name, customOverrides = mapOf("nearestCity" to "Zurich"), validating = false)
             val alice = startNode(providedName = ALICE.name, rpcUsers = arrayListOf(user),
-                    advertisedServices = setOf(ServiceInfo(ServiceType.corda.getSubType("cash"))),
                     customOverrides = mapOf("nearestCity" to "Milan"))
             val bob = startNode(providedName = BOB.name, rpcUsers = arrayListOf(user),
-                    advertisedServices = setOf(ServiceInfo(ServiceType.corda.getSubType("cash"))),
                     customOverrides = mapOf("nearestCity" to "Madrid"))
             val ukBankName = CordaX500Name(organisation = "UK Bank Plc", locality = "London", country = "GB")
             val usaBankName = CordaX500Name(organisation = "USA Bank Corp", locality = "New York", country = "US")
             val issuerGBP = startNode(providedName = ukBankName, rpcUsers = arrayListOf(manager),
-                    advertisedServices = setOf(ServiceInfo(ServiceType.corda.getSubType("issuer.GBP"))),
-                    customOverrides = mapOf("nearestCity" to "London"))
+                    customOverrides = mapOf(
+                            "issuableCurrencies" to listOf("GBP"),
+                            "nearestCity" to "London"))
             val issuerUSD = startNode(providedName = usaBankName, rpcUsers = arrayListOf(manager),
-                    advertisedServices = setOf(ServiceInfo(ServiceType.corda.getSubType("issuer.USD"))),
-                    customOverrides = mapOf("nearestCity" to "New York"))
+                    customOverrides = mapOf(
+                            "issuableCurrencies" to listOf("USD"),
+                            "nearestCity" to "New York"))
 
             notaryNode = notary.get()
             aliceNode = alice.get()
diff --git a/tools/explorer/src/test/kotlin/net/corda/explorer/model/IssuerModelTest.kt b/tools/explorer/src/test/kotlin/net/corda/explorer/model/IssuerModelTest.kt
deleted file mode 100644
index a363e8cd3f..0000000000
--- a/tools/explorer/src/test/kotlin/net/corda/explorer/model/IssuerModelTest.kt
+++ /dev/null
@@ -1,27 +0,0 @@
-package net.corda.explorer.model
-
-import net.corda.finance.USD
-import org.junit.Test
-import java.util.*
-import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
-
-class IssuerModelTest {
-    @Test
-    fun `test issuer regex`() {
-        val regex = Regex("corda.issuer.(USD|GBP|CHF)")
-        assertTrue("corda.issuer.USD".matches(regex))
-        assertTrue("corda.issuer.GBP".matches(regex))
-
-        assertFalse("corda.issuer.USD.GBP".matches(regex))
-        assertFalse("corda.issuer.EUR".matches(regex))
-        assertFalse("corda.issuer".matches(regex))
-
-        assertEquals(USD, Currency.getInstance("corda.issuer.USD".substringAfterLast(".")))
-        assertFailsWith(IllegalArgumentException::class) {
-            Currency.getInstance("corda.issuer.DOLLAR".substringBeforeLast("."))
-        }
-    }
-}
\ No newline at end of file

From 8c9045bd733012fbb995c81cf5763dae61e19272 Mon Sep 17 00:00:00 2001
From: szymonsztuka <szymon.sztuka@yahoo.com>
Date: Tue, 10 Oct 2017 15:03:05 +0100
Subject: [PATCH 146/185] deployNodes Gradle task appends properties from an
 optional file to node.conf (#1444)

* deployNodes Gradle task appends properties from an optional file to node.conf
---
 docs/source/changelog.rst                     |  8 ++++++-
 .../java/net/corda/cordform/CordformNode.java |  9 +++++++
 .../main/groovy/net/corda/plugins/Node.groovy | 24 +++++++++++++++++++
 3 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index c6bffa9c85..7f1e76f915 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -10,7 +10,7 @@ UNRELEASED
 
 * The ``Cordformation`` gradle plugin has been split into ``cordformation`` and ``cordapp``. The former builds and
   deploys nodes for development and testing, the latter turns a project into a cordapp project that generates JARs in
-  the standard CorDapp format.   
+  the standard CorDapp format.
 
 * ``Cordform`` and node identity generation
   * Cordform may not specify a value for ``NetworkMap``, when that happens, during the task execution the following happens:
@@ -30,6 +30,12 @@ UNRELEASED
   ``notaryNodeAddress``, ``notaryClusterAddresses`` and ``bftSMaRt`` have also been removed and replaced by a single
   ``notary`` config object. See :doc:`corda-configuration-file` for more details.
 
+* Gradle task ``deployNodes`` can have an additional parameter `configFile` with the path to a properties file
+  to be appended to node.conf.
+
+* Cordformation node building DSL can have an additional parameter `configFile` with the path to a properties file
+  to be appended to node.conf.
+
 .. _changelog_v1:
 
 Release 1.0
diff --git a/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java b/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
index bca75347d8..7421fee251 100644
--- a/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
+++ b/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformNode.java
@@ -74,4 +74,13 @@ public class CordformNode implements NodeDefinition {
     public void rpcPort(Integer rpcPort) {
         config = config.withValue("rpcAddress", ConfigValueFactory.fromAnyRef(DEFAULT_HOST + ':' + rpcPort));
     }
+
+    /**
+     * Set the path to a file with optional properties, which are appended to the generated node.conf file.
+     *
+     * @param configFile The file path.
+     */
+    public void configFile(String configFile) {
+        config = config.withValue("configFile", ConfigValueFactory.fromAnyRef(configFile));
+    }
 }
diff --git a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
index f4169bf456..f6963541d4 100644
--- a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
+++ b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
@@ -107,6 +107,7 @@ class Node extends CordformNode {
         installBuiltPlugin()
         installCordapps()
         installConfig()
+        appendOptionalConfig()
     }
 
     /**
@@ -193,6 +194,29 @@ class Node extends CordformNode {
         }
     }
 
+    /**
+     * Appends installed config file with properties from an optional file.
+     */
+    private void appendOptionalConfig() {
+        final configFileProperty = "configFile"
+        File optionalConfig
+        if (project.findProperty(configFileProperty)) { //provided by -PconfigFile command line property when running Gradle task
+            optionalConfig = new File(project.findProperty(configFileProperty))
+        } else if (config.hasPath(configFileProperty)) {
+            optionalConfig = new File(config.getString(configFileProperty))
+        }
+        if (optionalConfig) {
+            if (!optionalConfig.exists()) {
+               println "$configFileProperty '$optionalConfig' not found"
+            } else {
+                def confFile = new File(project.buildDir.getPath() + "/../" + nodeDir, 'node.conf')
+                optionalConfig.withInputStream {
+                    input -> confFile << input
+                }
+            }
+        }
+    }
+
     /**
      * Find the corda JAR amongst the dependencies.
      *

From 3bee830604f0a808744f23a1316cd13d8c87c33b Mon Sep 17 00:00:00 2001
From: Alberto Arri <30873160+al-r3@users.noreply.github.com>
Date: Tue, 10 Oct 2017 15:45:42 +0100
Subject: [PATCH 147/185] =?UTF-8?q?[CORDA-442]=20Removed=20the=20NetworkMa?=
 =?UTF-8?q?p=20option=20from=20Cordform,=20changed=20all=20the=20examples?=
 =?UTF-8?q?=E2=80=A6=20(#1827)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

[CORDA-442]
Removed the option for Cordformation to specify a networkMap.

All the samples have been migrated to not specify a networkMap.
---
 build.gradle                                  |  1 -
 docs/source/changelog.rst                     |  4 +-
 docs/source/deploying-a-node.rst              | 18 ++++----
 docs/source/example-code/build.gradle         |  1 -
 docs/source/hello-world-running.rst           |  2 +-
 docs/source/tutorial-cordapp.rst              |  7 +---
 .../corda/cordform/CordformDefinition.java    |  4 +-
 .../groovy/net/corda/plugins/Cordform.groovy  | 42 +++----------------
 samples/attachment-demo/build.gradle          |  1 -
 samples/bank-of-corda-demo/build.gradle       |  2 -
 samples/irs-demo/build.gradle                 |  1 -
 .../net/corda/notarydemo/BFTNotaryCordform.kt |  8 +++-
 .../corda/notarydemo/RaftNotaryCordform.kt    |  2 +-
 .../corda/notarydemo/SingleNotaryCordform.kt  |  8 +++-
 samples/simm-valuation-demo/build.gradle      |  1 -
 samples/trader-demo/build.gradle              |  2 -
 .../testing/internal/demorun/DemoRunner.kt    |  3 --
 17 files changed, 35 insertions(+), 72 deletions(-)

diff --git a/build.gradle b/build.gradle
index f8a21b7789..31740da52f 100644
--- a/build.gradle
+++ b/build.gradle
@@ -231,7 +231,6 @@ tasks.withType(Test) {
 
 task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     directory "./build/nodes"
-    networkMap "O=Controller,OU=corda,L=London,C=GB"
     node {
         name "O=Controller,OU=corda,L=London,C=GB"
         notary = [validating : true]
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index 7f1e76f915..9f989db79a 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -12,8 +12,8 @@ UNRELEASED
   deploys nodes for development and testing, the latter turns a project into a cordapp project that generates JARs in
   the standard CorDapp format.
 
-* ``Cordform`` and node identity generation
-  * Cordform may not specify a value for ``NetworkMap``, when that happens, during the task execution the following happens:
+* ``Cordform`` and node identity generation:
+  * Removed the parameter ``NetworkMap`` from Cordform. Now at the end of the deployment the following happens:
     1. Each node is started and its signed serialized NodeInfo is written to disk in the node base directory.
     2. Every serialized ``NodeInfo`` above is copied in every other node "additional-node-info" folder under the NodeInfo folder.
 
diff --git a/docs/source/deploying-a-node.rst b/docs/source/deploying-a-node.rst
index 4457b7d38c..4125947fd8 100644
--- a/docs/source/deploying-a-node.rst
+++ b/docs/source/deploying-a-node.rst
@@ -11,13 +11,12 @@ Cordform is the local node deployment system for CorDapps. The nodes generated a
 debugging, and testing node configurations, but not for production or testnet deployment.
 
 Here is an example Gradle task called ``deployNodes`` that uses the Cordform plugin to deploy three nodes, plus a
-notary/network map node:
+notary node:
 
 .. sourcecode:: groovy
 
     task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
         directory "./build/nodes"
-        networkMap "O=Controller,OU=corda,L=London,C=UK"
         node {
             name "O=Controller,OU=corda,L=London,C=UK"
             notary = [validating : true]
@@ -52,9 +51,7 @@ notary/network map node:
         }
     }
 
-You can extend ``deployNodes`` to generate any number of nodes you like. The only requirement is that you must specify
-one node as running the network map service, by putting their name in the ``networkMap`` field. In our example, the
-``Controller`` is set as the network map service.
+You can extend ``deployNodes`` to generate any number of nodes you like.
 
 .. warning:: When adding nodes, make sure that there are no port clashes!
 
@@ -85,9 +82,14 @@ run all the nodes at once. Each node in the ``nodes`` folder has the following s
 .. sourcecode:: none
 
     . nodeName
-    ├── corda.jar       // The Corda runtime
-    ├── node.conf       // The node's configuration
-    └── plugins         // Any installed CorDapps
+    ├── corda.jar               // The Corda runtime
+    ├── node.conf               // The node's configuration
+    ├── plugins                 // Any installed CorDapps
+    └── additional-node-infos   // Directory containing all the addresses and certificates of the other nodes.
+
+.. note:: During the build process each node generates a NodeInfo file which is written in its own root directory,
+the plug-in proceeds and copies each node NodeInfo to every other node ``additional-node-infos`` directory.
+The NodeInfo file contains a node hostname and port, legal name and security certificate.
 
 .. note:: Outside of development environments, do not store your node directories in the build folder.
 
diff --git a/docs/source/example-code/build.gradle b/docs/source/example-code/build.gradle
index a3ea77f4d8..0568552add 100644
--- a/docs/source/example-code/build.gradle
+++ b/docs/source/example-code/build.gradle
@@ -73,7 +73,6 @@ task integrationTest(type: Test) {
 
 task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     directory "./build/nodes"
-    networkMap "O=Notary Service,OU=corda,L=London,C=GB"
     node {
         name "O=Notary Service,OU=corda,L=London,C=GB"
         notary = [validating : true]
diff --git a/docs/source/hello-world-running.rst b/docs/source/hello-world-running.rst
index ae1592fa82..b5bf916e18 100644
--- a/docs/source/hello-world-running.rst
+++ b/docs/source/hello-world-running.rst
@@ -25,7 +25,6 @@ Let's take a look at the nodes we're going to deploy. Open the project's ``build
 
         task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
             directory "./build/nodes"
-            networkMap "O=Controller,L=London,C=GB"
             node {
                 name "O=Controller,L=London,C=GB"
                 notary = [validating : true]
@@ -82,6 +81,7 @@ the three node folders. Each node folder has the following structure:
         |____corda-webserver.jar           // The node's webserver
         |____dependencies
         |____node.conf                     // The node's configuration file
+        |____additional-node-infos/        // Directory containing all the other nodes' addresses and identities
         |____plugins
           |____java/kotlin-source-0.1.jar  // Our IOU CorDapp
 
diff --git a/docs/source/tutorial-cordapp.rst b/docs/source/tutorial-cordapp.rst
index ed203a66e5..c61e20f4be 100644
--- a/docs/source/tutorial-cordapp.rst
+++ b/docs/source/tutorial-cordapp.rst
@@ -17,7 +17,7 @@ if:
 
 We will deploy the CorDapp on 4 test nodes:
 
-* **Controller**, which hosts the network map service and a validating notary service
+* **Controller**, which hosts a validating notary service
 * **PartyA**
 * **PartyB**
 * **PartyC**
@@ -276,7 +276,7 @@ IntelliJ
 
   The node driver defined in ``/src/test/kotlin/com/example/Main.kt`` allows you to specify how many nodes you would like
   to run and the configuration settings for each node. For the example CorDapp, the driver starts up four nodes
-  and adds an RPC user for all but the "Controller" node (which serves as the notary and network map service):
+  and adds an RPC user for all but the "Controller" node (which serves as the notary):
 
   .. sourcecode:: kotlin
 
@@ -489,9 +489,6 @@ You must now edit the configuration file for each node, including the controller
 and make the following changes:
 
 * Change the Artemis messaging address to the machine's IP address (e.g. ``p2pAddress="10.18.0.166:10006"``)
-* Change the network map service's address to the IP address of the machine where the controller node is running
-  (e.g. ``networkMapService { address="10.18.0.166:10002" legalName="O=Controller,L=London,C=GB" ``). The controller
-  will not have the ``networkMapService`` configuration entry
 
 After starting each node, the nodes will be able to see one another and agree IOUs among themselves.
 
diff --git a/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformDefinition.java b/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformDefinition.java
index 51d44def93..047d7e6289 100644
--- a/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformDefinition.java
+++ b/gradle-plugins/cordform-common/src/main/java/net/corda/cordform/CordformDefinition.java
@@ -7,11 +7,9 @@ import java.util.function.Consumer;
 public abstract class CordformDefinition {
     public final Path driverDirectory;
     public final ArrayList<Consumer<? super CordformNode>> nodeConfigurers = new ArrayList<>();
-    public final String networkMapNodeName;
 
-    public CordformDefinition(Path driverDirectory, String networkMapNodeName) {
+    public CordformDefinition(Path driverDirectory) {
         this.driverDirectory = driverDirectory;
-        this.networkMapNodeName = networkMapNodeName;
     }
 
     public void addNode(Consumer<? super CordformNode> configurer) {
diff --git a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordform.groovy b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordform.groovy
index 7bfd9e0f0d..7baf20a45a 100644
--- a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordform.groovy
+++ b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Cordform.groovy
@@ -3,9 +3,7 @@ package net.corda.plugins
 import static org.gradle.api.tasks.SourceSet.MAIN_SOURCE_SET_NAME
 import net.corda.cordform.CordformContext
 import net.corda.cordform.CordformDefinition
-import net.corda.cordform.CordformNode
 import org.apache.tools.ant.filters.FixCrLfFilter
-import org.bouncycastle.asn1.x500.X500Name
 import org.gradle.api.DefaultTask
 import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.TaskAction
@@ -24,7 +22,6 @@ class Cordform extends DefaultTask {
     String definitionClass
     protected def directory = Paths.get("build", "nodes")
     private def nodes = new ArrayList<Node>()
-    protected String networkMapNodeName
 
     /**
      * Set the directory to install nodes into.
@@ -36,16 +33,6 @@ class Cordform extends DefaultTask {
         this.directory = Paths.get(directory)
     }
 
-    /**
-     * Set the network map node.
-     *
-     * @warning Ensure the node name is one of the configured nodes.
-     * @param nodeName The name of the node that will host the network map.
-     */
-    void networkMap(String nodeName) {
-        networkMapNodeName = nodeName
-    }
-
     /**
      * Add a node configuration.
      *
@@ -110,12 +97,15 @@ class Cordform extends DefaultTask {
      */
     @TaskAction
     void build() {
-        String networkMapNodeName = initializeConfigurationAndGetNetworkMapNodeName()
+        initializeConfiguration()
         installRunScript()
-        finalizeConfiguration(networkMapNodeName)
+        nodes.each {
+            it.build()
+        }
+        generateNodeInfos()
     }
 
-    private initializeConfigurationAndGetNetworkMapNodeName() {
+    private initializeConfiguration() {
         if (null != definitionClass) {
             def cd = loadCordformDefinition()
             cd.nodeConfigurers.each { nc ->
@@ -129,30 +119,10 @@ class Cordform extends DefaultTask {
                     project.projectDir.toPath().resolve(getNodeByName(nodeName).nodeDir.toPath())
                 }
             }
-            return cd.networkMapNodeName.toString()
         } else {
             nodes.each {
                 it.rootDir directory
             }
-            return this.networkMapNodeName
-        }
-    }
-
-    private finalizeConfiguration(String networkMapNodeName) {
-        Node networkMapNode = getNodeByName(networkMapNodeName)
-        if (networkMapNode == null) {
-            nodes.each {
-                it.build()
-            }
-            generateNodeInfos()
-            logger.info("Starting without networkMapNode, this an experimental feature")
-        } else {
-            nodes.each {
-                if (it != networkMapNode) {
-                    it.networkMapAddress(networkMapNode.getP2PAddress(), networkMapNodeName)
-                }
-                it.build()
-            }
         }
     }
 
diff --git a/samples/attachment-demo/build.gradle b/samples/attachment-demo/build.gradle
index c331834529..b977d45ffb 100644
--- a/samples/attachment-demo/build.gradle
+++ b/samples/attachment-demo/build.gradle
@@ -38,7 +38,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     ext.rpcUsers = [['username': "demo", 'password': "demo", 'permissions': ["StartFlow.net.corda.attachmentdemo.AttachmentDemoFlow"]]]
 
     directory "./build/nodes"
-    networkMap "O=Notary Service,L=Zurich,C=CH"
     node {
         name "O=Notary Service,L=Zurich,C=CH"
         notary = [validating : true]
diff --git a/samples/bank-of-corda-demo/build.gradle b/samples/bank-of-corda-demo/build.gradle
index da04426168..be0c49807d 100644
--- a/samples/bank-of-corda-demo/build.gradle
+++ b/samples/bank-of-corda-demo/build.gradle
@@ -50,8 +50,6 @@ dependencies {
 task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     directory "./build/nodes"
     // This name "Notary" is hard-coded into BankOfCordaClientApi so if you change it here, change it there too.
-    // In this demo the node that runs a standalone notary also acts as the network map server.
-    networkMap "O=Notary Service,L=Zurich,C=CH"
     node {
         name "O=Notary Service,L=Zurich,C=CH"
         notary = [validating : true]
diff --git a/samples/irs-demo/build.gradle b/samples/irs-demo/build.gradle
index 2341793e1f..abbfaf3772 100644
--- a/samples/irs-demo/build.gradle
+++ b/samples/irs-demo/build.gradle
@@ -51,7 +51,6 @@ dependencies {
 
 task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     directory "./build/nodes"
-    networkMap "O=Notary Service,L=Zurich,C=CH"
     node {
         name "O=Notary Service,L=Zurich,C=CH"
         notary = [validating : true]
diff --git a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/BFTNotaryCordform.kt b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/BFTNotaryCordform.kt
index 477adecd20..92669b5714 100644
--- a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/BFTNotaryCordform.kt
+++ b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/BFTNotaryCordform.kt
@@ -13,7 +13,11 @@ import net.corda.node.services.transactions.minCorrectReplicas
 import net.corda.node.utilities.ServiceIdentityGenerator
 import net.corda.testing.ALICE
 import net.corda.testing.BOB
-import net.corda.testing.internal.demorun.*
+import net.corda.testing.internal.demorun.name
+import net.corda.testing.internal.demorun.node
+import net.corda.testing.internal.demorun.notary
+import net.corda.testing.internal.demorun.rpcUsers
+import net.corda.testing.internal.demorun.runNodes
 
 fun main(args: Array<String>) = BFTNotaryCordform.runNodes()
 
@@ -22,7 +26,7 @@ private val notaryNames = createNotaryNames(clusterSize)
 
 // This is not the intended final design for how to use CordformDefinition, please treat this as experimental and DO
 // NOT use this as a design to copy.
-object BFTNotaryCordform : CordformDefinition("build" / "notary-demo-nodes", notaryNames[0].toString()) {
+object BFTNotaryCordform : CordformDefinition("build" / "notary-demo-nodes") {
     private val clusterName = CordaX500Name(BFTNonValidatingNotaryService.id, "BFT", "Zurich", "CH")
 
     init {
diff --git a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/RaftNotaryCordform.kt b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/RaftNotaryCordform.kt
index 1d78c51266..198867dcf1 100644
--- a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/RaftNotaryCordform.kt
+++ b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/RaftNotaryCordform.kt
@@ -22,7 +22,7 @@ private val notaryNames = createNotaryNames(3)
 
 // This is not the intended final design for how to use CordformDefinition, please treat this as experimental and DO
 // NOT use this as a design to copy.
-object RaftNotaryCordform : CordformDefinition("build" / "notary-demo-nodes", notaryNames[0].toString()) {
+object RaftNotaryCordform : CordformDefinition("build" / "notary-demo-nodes") {
     private val clusterName = CordaX500Name(RaftValidatingNotaryService.id, "Raft", "Zurich", "CH")
 
     init {
diff --git a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/SingleNotaryCordform.kt b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/SingleNotaryCordform.kt
index beec66a8fc..22cc63540d 100644
--- a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/SingleNotaryCordform.kt
+++ b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/SingleNotaryCordform.kt
@@ -11,7 +11,11 @@ import net.corda.notarydemo.flows.RPCStartableNotaryFlowClient
 import net.corda.testing.ALICE
 import net.corda.testing.BOB
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.internal.demorun.*
+import net.corda.testing.internal.demorun.name
+import net.corda.testing.internal.demorun.node
+import net.corda.testing.internal.demorun.notary
+import net.corda.testing.internal.demorun.rpcUsers
+import net.corda.testing.internal.demorun.runNodes
 
 fun main(args: Array<String>) = SingleNotaryCordform.runNodes()
 
@@ -19,7 +23,7 @@ val notaryDemoUser = User("demou", "demop", setOf(startFlowPermission<DummyIssue
 
 // This is not the intended final design for how to use CordformDefinition, please treat this as experimental and DO
 // NOT use this as a design to copy.
-object SingleNotaryCordform : CordformDefinition("build" / "notary-demo-nodes", DUMMY_NOTARY.name.toString()) {
+object SingleNotaryCordform : CordformDefinition("build" / "notary-demo-nodes") {
     init {
         node {
             name(ALICE.name)
diff --git a/samples/simm-valuation-demo/build.gradle b/samples/simm-valuation-demo/build.gradle
index 502b2bdee8..5ad72562d2 100644
--- a/samples/simm-valuation-demo/build.gradle
+++ b/samples/simm-valuation-demo/build.gradle
@@ -64,7 +64,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
     ext.rpcUsers = [['username': "default", 'password': "default", 'permissions': [ 'ALL' ]]]
 
     directory "./build/nodes"
-    networkMap "O=Notary Service,L=Zurich,C=CH"
     node {
         name "O=Notary Service,L=Zurich,C=CH"
         notary = [validating : true]
diff --git a/samples/trader-demo/build.gradle b/samples/trader-demo/build.gradle
index 8d224d11ab..e3d363e516 100644
--- a/samples/trader-demo/build.gradle
+++ b/samples/trader-demo/build.gradle
@@ -51,8 +51,6 @@ task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
 
     directory "./build/nodes"
     // This name "Notary" is hard-coded into TraderDemoClientApi so if you change it here, change it there too.
-    // In this demo the node that runs a standalone notary also acts as the network map server.
-    networkMap "O=Notary Service,L=Zurich,C=CH"
     node {
         name "O=Notary Service,L=Zurich,C=CH"
         notary = [validating : true]
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/DemoRunner.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/DemoRunner.kt
index 2897c3e92f..cf452a9116 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/DemoRunner.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/internal/demorun/DemoRunner.kt
@@ -4,8 +4,6 @@ package net.corda.testing.internal.demorun
 
 import net.corda.cordform.CordformDefinition
 import net.corda.cordform.CordformNode
-import net.corda.core.identity.CordaX500Name
-import net.corda.testing.driver.NetworkMapStartStrategy
 import net.corda.testing.driver.PortAllocation
 import net.corda.testing.driver.driver
 
@@ -20,7 +18,6 @@ fun CordformDefinition.clean() {
 fun CordformDefinition.runNodes() = driver(
         isDebug = true,
         driverDirectory = driverDirectory,
-        networkMapStartStrategy = NetworkMapStartStrategy.Nominated(CordaX500Name.parse(networkMapNodeName)),
         portAllocation = PortAllocation.Incremental(10001)
 ) {
     setup(this)

From daa6caeee285aff7c4c9f9a7bcc66d348f089175 Mon Sep 17 00:00:00 2001
From: Clinton Alexander <admin@clintonio.com>
Date: Tue, 10 Oct 2017 15:50:23 +0100
Subject: [PATCH 148/185] Bumped gradle plugins to 2.0.2 to publish latest
 changes.

---
 constants.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/constants.properties b/constants.properties
index 4591e03dea..f0fbe73c08 100644
--- a/constants.properties
+++ b/constants.properties
@@ -1,4 +1,4 @@
-gradlePluginsVersion=2.0.1
+gradlePluginsVersion=2.0.2
 kotlinVersion=1.1.50
 guavaVersion=21.0
 bouncycastleVersion=1.57

From f19ff141dd780143a4069a0b78e3f91807b24fa0 Mon Sep 17 00:00:00 2001
From: Matthew Nesbit <matthew.nesbit@r3cev.com>
Date: Mon, 9 Oct 2017 10:44:32 +0100
Subject: [PATCH 149/185] Update code to use AppServiceHub in services and
 support for services when using MockServices hub.

---
 docs/source/changelog.rst                     |  4 +++
 .../net/corda/docs/CustomNotaryTutorial.kt    |  4 +--
 .../kotlin/net/corda/docs/CustomVaultQuery.kt |  6 ++--
 docs/source/tutorial-custom-notary.rst        |  2 +-
 .../net/corda/irs/api/NodeInterestRates.kt    |  5 ++-
 .../corda/irs/api/NodeInterestRatesTest.kt    |  4 ++-
 .../net/corda/testing/node/MockServices.kt    | 31 ++++++++++++++++++-
 7 files changed, 45 insertions(+), 11 deletions(-)

diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index 9f989db79a..8b17db03ac 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -36,6 +36,10 @@ UNRELEASED
 * Cordformation node building DSL can have an additional parameter `configFile` with the path to a properties file
   to be appended to node.conf.
 
+* ``CordaService`` annotated classes should be upgraded to take a constructor parameter of type ``AppServiceHub`` which
+  allows services to start flows marked with the ``StartableByService`` annotation. For backwards compatability
+  service classes with only ``ServiceHub`` constructors will still work.
+
 .. _changelog_v1:
 
 Release 1.0
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
index 8d1c0d0274..d7331d146c 100644
--- a/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
@@ -4,7 +4,7 @@ import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.contracts.TimeWindow
 import net.corda.core.contracts.TransactionVerificationException
 import net.corda.core.flows.*
-import net.corda.core.node.ServiceHub
+import net.corda.core.node.AppServiceHub
 import net.corda.core.node.services.CordaService
 import net.corda.core.node.services.TimeWindowChecker
 import net.corda.core.node.services.TrustedAuthorityNotaryService
@@ -15,7 +15,7 @@ import java.security.SignatureException
 
 // START 1
 @CordaService
-class MyCustomValidatingNotaryService(override val services: ServiceHub, override val notaryIdentityKey: PublicKey) : TrustedAuthorityNotaryService() {
+class MyCustomValidatingNotaryService(override val services: AppServiceHub, override val notaryIdentityKey: PublicKey) : TrustedAuthorityNotaryService() {
     override val timeWindowChecker = TimeWindowChecker(services.clock)
     override val uniquenessProvider = PersistentUniquenessProvider()
 
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomVaultQuery.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomVaultQuery.kt
index 47a5ca00a0..1ae88a6015 100644
--- a/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomVaultQuery.kt
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomVaultQuery.kt
@@ -4,7 +4,7 @@ import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.contracts.Amount
 import net.corda.core.flows.*
 import net.corda.core.identity.Party
-import net.corda.core.node.ServiceHub
+import net.corda.core.node.AppServiceHub
 import net.corda.core.node.services.CordaService
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.serialization.SingletonSerializeAsToken
@@ -23,7 +23,7 @@ import java.util.*
 object CustomVaultQuery {
 
     @CordaService
-    class Service(val services: ServiceHub) : SingletonSerializeAsToken() {
+    class Service(val services: AppServiceHub) : SingletonSerializeAsToken() {
         private companion object {
             val log = loggerFor<Service>()
         }
@@ -49,7 +49,7 @@ object CustomVaultQuery {
             val session = services.jdbcSession()
             val prepStatement = session.prepareStatement(nativeQuery)
             val rs = prepStatement.executeQuery()
-            var topUpLimits: MutableList<Amount<Currency>> = mutableListOf()
+            val topUpLimits: MutableList<Amount<Currency>> = mutableListOf()
             while (rs.next()) {
                 val currencyStr = rs.getString(1)
                 val amount = rs.getLong(2)
diff --git a/docs/source/tutorial-custom-notary.rst b/docs/source/tutorial-custom-notary.rst
index 01e5da1b71..cabefdd203 100644
--- a/docs/source/tutorial-custom-notary.rst
+++ b/docs/source/tutorial-custom-notary.rst
@@ -9,7 +9,7 @@ Writing a custom notary service
 
 Similarly to writing an oracle service, the first step is to create a service class in your CorDapp and annotate it
 with ``@CordaService``. The Corda node scans for any class with this annotation and initialises them. The only requirement
-is that the class provide a constructor with a single parameter of type ``ServiceHub``.
+is that the class provide a constructor with a single parameter of type ``AppServiceHub``.
 
 .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
    :language: kotlin
diff --git a/samples/irs-demo/src/main/kotlin/net/corda/irs/api/NodeInterestRates.kt b/samples/irs-demo/src/main/kotlin/net/corda/irs/api/NodeInterestRates.kt
index a28d299d24..579de8cde6 100644
--- a/samples/irs-demo/src/main/kotlin/net/corda/irs/api/NodeInterestRates.kt
+++ b/samples/irs-demo/src/main/kotlin/net/corda/irs/api/NodeInterestRates.kt
@@ -2,11 +2,10 @@ package net.corda.irs.api
 
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.contracts.Command
-import net.corda.core.crypto.MerkleTreeException
 import net.corda.core.crypto.TransactionSignature
 import net.corda.core.flows.*
 import net.corda.core.internal.ThreadBox
-import net.corda.core.node.ServiceHub
+import net.corda.core.node.AppServiceHub
 import net.corda.core.node.services.CordaService
 import net.corda.core.serialization.SingletonSerializeAsToken
 import net.corda.core.transactions.FilteredTransaction
@@ -78,7 +77,7 @@ object NodeInterestRates {
     @ThreadSafe
     // DOCSTART 3
     @CordaService
-    class Oracle(private val services: ServiceHub) : SingletonSerializeAsToken() {
+    class Oracle(private val services: AppServiceHub) : SingletonSerializeAsToken() {
         private val mutex = ThreadBox(InnerState())
 
         init {
diff --git a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
index 38fc4e0b56..3af7044caa 100644
--- a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
+++ b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
@@ -24,6 +24,7 @@ import net.corda.testing.node.MockServices
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
 import net.corda.testing.node.MockServices.Companion.makeTestDatabaseProperties
 import net.corda.testing.node.MockServices.Companion.makeTestIdentityService
+import net.corda.testing.node.createMockCordaService
 import org.junit.After
 import org.junit.Assert.*
 import org.junit.Before
@@ -65,7 +66,8 @@ class NodeInterestRatesTest : TestDependencyInjectionBase() {
         setCordappPackages("net.corda.finance.contracts")
         database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), createIdentityService = ::makeTestIdentityService)
         database.transaction {
-            oracle = NodeInterestRates.Oracle(services).apply { knownFixes = TEST_DATA }
+            oracle = createMockCordaService(services, NodeInterestRates::Oracle)
+            oracle.knownFixes = TEST_DATA
         }
     }
 
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
index 3d49484fef..ae838119a2 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
@@ -1,10 +1,15 @@
 package net.corda.testing.node
 
+import com.google.common.collect.MutableClassToInstanceMap
 import net.corda.core.cordapp.CordappProvider
 import net.corda.core.crypto.*
+import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.StateMachineRunId
 import net.corda.core.identity.PartyAndCertificate
 import net.corda.core.messaging.DataFeed
+import net.corda.core.messaging.FlowHandle
+import net.corda.core.messaging.FlowProgressHandle
+import net.corda.core.node.AppServiceHub
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.ServiceHub
 import net.corda.core.node.StateLoader
@@ -173,7 +178,11 @@ open class MockServices(
         return vaultService
     }
 
-    override fun <T : SerializeAsToken> cordaService(type: Class<T>): T = throw IllegalArgumentException("${type.name} not found")
+    val cordappServices = MutableClassToInstanceMap.create<SerializeAsToken>()
+    override fun <T : SerializeAsToken> cordaService(type: Class<T>): T {
+        require(type.isAnnotationPresent(CordaService::class.java)) { "${type.name} is not a Corda service" }
+        return cordappServices.getInstance(type) ?: throw IllegalArgumentException("Corda service ${type.name} does not exist")
+    }
 
     override fun jdbcSession(): Connection = throw UnsupportedOperationException()
 }
@@ -244,3 +253,23 @@ open class MockTransactionStorage : WritableTransactionStorage, SingletonSeriali
 
     override fun getTransaction(id: SecureHash): SignedTransaction? = txns[id]
 }
+
+fun <T : SerializeAsToken> createMockCordaService(serviceHub: MockServices, serviceConstructor: (AppServiceHub) -> T): T {
+    class MockAppServiceHubImpl<T : SerializeAsToken>(val serviceHub: MockServices, serviceConstructor: (AppServiceHub) -> T) : AppServiceHub, ServiceHub by serviceHub {
+        val serviceInstance: T
+
+        init {
+            serviceInstance = serviceConstructor(this)
+            serviceHub.cordappServices.putInstance(serviceInstance.javaClass, serviceInstance)
+        }
+
+        override fun <T> startFlow(flow: FlowLogic<T>): FlowHandle<T> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <T> startTrackedFlow(flow: FlowLogic<T>): FlowProgressHandle<T> {
+            throw UnsupportedOperationException()
+        }
+    }
+    return MockAppServiceHubImpl(serviceHub, serviceConstructor).serviceInstance
+}
\ No newline at end of file

From 16b26970a9f84c002df46e0b0c1ce76393022327 Mon Sep 17 00:00:00 2001
From: Andras Slemmer <andras.slemmer@r3cev.com>
Date: Wed, 11 Oct 2017 09:54:19 +0100
Subject: [PATCH 150/185] Add kryo-hook javaagent

---
 experimental/kryo-hook/build.gradle           |  53 ++++++
 .../kotlin/net/corda/kryohook/KryoHook.kt     | 159 ++++++++++++++++++
 2 files changed, 212 insertions(+)
 create mode 100644 experimental/kryo-hook/build.gradle
 create mode 100644 experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt

diff --git a/experimental/kryo-hook/build.gradle b/experimental/kryo-hook/build.gradle
new file mode 100644
index 0000000000..cf52f3c9bb
--- /dev/null
+++ b/experimental/kryo-hook/build.gradle
@@ -0,0 +1,53 @@
+buildscript {
+    // For sharing constants between builds
+    Properties constants = new Properties()
+    file("$projectDir/../../constants.properties").withInputStream { constants.load(it) }
+
+    ext.kotlin_version = constants.getProperty("kotlinVersion")
+    ext.javaassist_version = "3.12.1.GA"
+
+    repositories {
+        mavenLocal()
+        mavenCentral()
+        jcenter()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+    jcenter()
+}
+
+apply plugin: 'kotlin'
+apply plugin: 'kotlin-kapt'
+apply plugin: 'idea'
+
+description 'A javaagent to allow hooking into Kryo'
+
+dependencies {
+    compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"
+    compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
+    compile "javassist:javassist:$javaassist_version"
+    compile "com.esotericsoftware:kryo:4.0.0"
+    compile "co.paralleluniverse:quasar-core:$quasar_version:jdk8"
+}
+
+jar {
+    archiveName = "${project.name}.jar"
+    manifest {
+        attributes(
+                'Premain-Class': 'net.corda.kryohook.KryoHookAgent',
+                'Can-Redefine-Classes': 'true',
+                'Can-Retransform-Classes': 'true',
+                'Can-Set-Native-Method-Prefix': 'true',
+                'Implementation-Title': "KryoHook",
+                'Implementation-Version': rootProject.version
+        )
+    }
+    from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
+}
diff --git a/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt b/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt
new file mode 100644
index 0000000000..8d57dc8dbc
--- /dev/null
+++ b/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt
@@ -0,0 +1,159 @@
+package net.corda.kryohook
+
+import co.paralleluniverse.strands.Strand
+import com.esotericsoftware.kryo.Kryo
+import com.esotericsoftware.kryo.io.Output
+import javassist.ClassPool
+import javassist.CtClass
+import java.io.ByteArrayInputStream
+import java.lang.StringBuilder
+import java.lang.instrument.ClassFileTransformer
+import java.lang.instrument.Instrumentation
+import java.security.ProtectionDomain
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicInteger
+
+class KryoHookAgent {
+    companion object {
+        @JvmStatic
+        fun premain(argumentsString: String?, instrumentation: Instrumentation) {
+            Runtime.getRuntime().addShutdownHook(Thread {
+                val statsTrees = KryoHook.events.values.flatMap {
+                    readTrees(it, 0).second
+                }
+                val builder = StringBuilder()
+                statsTrees.forEach {
+                    prettyStatsTree(0, it, builder)
+                }
+                print(builder.toString())
+            })
+            instrumentation.addTransformer(KryoHook)
+        }
+    }
+}
+
+fun prettyStatsTree(indent: Int, statsTree: StatsTree, builder: StringBuilder) {
+    when (statsTree) {
+        is StatsTree.Object -> {
+            builder.append(kotlin.CharArray(indent) { ' ' })
+            builder.append(statsTree.className)
+            builder.append(" ")
+            builder.append(statsTree.size)
+            builder.append("\n")
+            for (child in statsTree.children) {
+                prettyStatsTree(indent + 2, child, builder)
+            }
+        }
+    }
+}
+
+object KryoHook : ClassFileTransformer {
+    val classPool = ClassPool.getDefault()
+
+    val hookClassName = javaClass.name
+
+    override fun transform(
+            loader: ClassLoader?,
+            className: String,
+            classBeingRedefined: Class<*>?,
+            protectionDomain: ProtectionDomain?,
+            classfileBuffer: ByteArray
+    ): ByteArray? {
+        if (className.startsWith("java") || className.startsWith("javassist") || className.startsWith("kotlin")) {
+            return null
+        }
+        return try {
+            val clazz = classPool.makeClass(ByteArrayInputStream(classfileBuffer))
+            instrumentClass(clazz)?.toBytecode()
+        } catch (throwable: Throwable) {
+            println("SOMETHING WENT WRONG")
+            throwable.printStackTrace(System.out)
+            null
+        }
+    }
+
+    private fun instrumentClass(clazz: CtClass): CtClass? {
+        for (method in clazz.declaredBehaviors) {
+            if (method.name == "write") {
+                val parameterTypeNames = method.parameterTypes.map { it.name }
+                if (parameterTypeNames == listOf("com.esotericsoftware.kryo.Kryo", "com.esotericsoftware.kryo.io.Output", "java.lang.Object")) {
+                    if (method.isEmpty) continue
+                    println("Instrumenting ${clazz.name}")
+                    method.insertBefore("$hookClassName.${this::writeEnter.name}($1, $2, $3);")
+                    method.insertAfter("$hookClassName.${this::writeExit.name}($1, $2, $3);")
+                    return clazz
+                }
+            }
+        }
+        return null
+    }
+
+    val events = ConcurrentHashMap<Long, ArrayList<StatsEvent>>()
+    val eventCount = AtomicInteger(0)
+
+    @JvmStatic
+    fun writeEnter(kryo: Kryo, output: Output, obj: Any) {
+        events.getOrPut(Strand.currentStrand().id) { ArrayList() }.add(
+                StatsEvent.Enter(obj.javaClass.name, output.total())
+        )
+        if (eventCount.incrementAndGet() % 100 == 0) {
+            println("EVENT COUNT ${eventCount}")
+        }
+    }
+    @JvmStatic
+    fun writeExit(kryo: Kryo, output: Output, obj: Any) {
+        events.get(Strand.currentStrand().id)!!.add(
+                StatsEvent.Exit(obj.javaClass.name, output.total())
+        )
+    }
+}
+
+sealed class StatsEvent {
+    data class Enter(val className: String, val offset: Long) : StatsEvent()
+    data class Exit(val className: String, val offset: Long) : StatsEvent()
+}
+
+sealed class StatsTree {
+    data class Object(
+            val className: String,
+            val size: Long,
+            val children: List<StatsTree>
+    ) : StatsTree()
+}
+
+
+fun readTree(events: List<StatsEvent>, index: Int): Pair<Int, StatsTree> {
+    val event = events[index]
+    when (event) {
+        is StatsEvent.Enter -> {
+            val (nextIndex, children) = readTrees(events, index + 1)
+            val exit = events[nextIndex] as StatsEvent.Exit
+            require(event.className == exit.className)
+            return Pair(nextIndex + 1, StatsTree.Object(event.className, exit.offset - event.offset, children))
+        }
+        is StatsEvent.Exit -> {
+            throw IllegalStateException("Wasn't expecting Exit")
+        }
+    }
+}
+
+fun readTrees(events: List<StatsEvent>, index: Int): Pair<Int, List<StatsTree>> {
+    val trees = ArrayList<StatsTree>()
+    var i = index
+    while (true) {
+        val event = events.getOrNull(i)
+        when (event) {
+            is StatsEvent.Enter -> {
+                val (nextIndex, tree) = readTree(events, i)
+                trees.add(tree)
+                i = nextIndex
+            }
+            is StatsEvent.Exit -> {
+                return Pair(i, trees)
+            }
+            null -> {
+                return Pair(i, trees)
+            }
+        }
+    }
+}

From c56c9fd455542ebcf8dbb5b76b97bbcb7f453d25 Mon Sep 17 00:00:00 2001
From: Andras Slemmer <andras.slemmer@r3cev.com>
Date: Wed, 11 Oct 2017 10:06:27 +0100
Subject: [PATCH 151/185] Add README.md, some docs

---
 .../kotlin/net/corda/kryohook/KryoHook.kt     | 17 ++++++++++----
 .../main/kotlin/net/corda/kryohook/README.md  | 23 +++++++++++++++++++
 2 files changed, 36 insertions(+), 4 deletions(-)
 create mode 100644 experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/README.md

diff --git a/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt b/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt
index 8d57dc8dbc..e9c6f61e34 100644
--- a/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt
+++ b/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt
@@ -47,6 +47,12 @@ fun prettyStatsTree(indent: Int, statsTree: StatsTree, builder: StringBuilder) {
     }
 }
 
+/**
+ * The hook simply records the write() entries and exits together with the output offset at the time of the call.
+ * This is recorded in a StrandID -> List<StatsEvent> map.
+ *
+ * Later we "parse" these lists into a tree.
+ */
 object KryoHook : ClassFileTransformer {
     val classPool = ClassPool.getDefault()
 
@@ -88,17 +94,14 @@ object KryoHook : ClassFileTransformer {
         return null
     }
 
+    // StrandID -> StatsEvent map
     val events = ConcurrentHashMap<Long, ArrayList<StatsEvent>>()
-    val eventCount = AtomicInteger(0)
 
     @JvmStatic
     fun writeEnter(kryo: Kryo, output: Output, obj: Any) {
         events.getOrPut(Strand.currentStrand().id) { ArrayList() }.add(
                 StatsEvent.Enter(obj.javaClass.name, output.total())
         )
-        if (eventCount.incrementAndGet() % 100 == 0) {
-            println("EVENT COUNT ${eventCount}")
-        }
     }
     @JvmStatic
     fun writeExit(kryo: Kryo, output: Output, obj: Any) {
@@ -108,11 +111,17 @@ object KryoHook : ClassFileTransformer {
     }
 }
 
+/**
+ * TODO we could add events on entries/exits to field serializers to get more info on what's being serialised.
+ */
 sealed class StatsEvent {
     data class Enter(val className: String, val offset: Long) : StatsEvent()
     data class Exit(val className: String, val offset: Long) : StatsEvent()
 }
 
+/**
+ * TODO add Field constructor.
+ */
 sealed class StatsTree {
     data class Object(
             val className: String,
diff --git a/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/README.md b/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/README.md
new file mode 100644
index 0000000000..ec7899a290
--- /dev/null
+++ b/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/README.md
@@ -0,0 +1,23 @@
+What is this
+------------
+
+This is a javaagent that hooks into Kryo serializers to record a breakdown of how many bytes objects take in the output.
+
+The dump is quite ugly now, but the in-memory representation is a simple tree so we could put some nice visualisation on
+top if we want. 
+
+How do I run it
+---------------
+
+Build the agent:
+```
+./gradlew experimental:kryo-hook:jar
+```
+
+Add this JVM flag to what you're running:
+
+```
+-javaagent:<PROJECT>/experimental/kryo-hook/build/libs/kryo-hook.jar
+```
+
+The agent will dump the output when the JVM shuts down.

From c2cda569e15ce300abbd023fe5c40bf1957eef21 Mon Sep 17 00:00:00 2001
From: Andras Slemmer <andras.slemmer@r3cev.com>
Date: Wed, 11 Oct 2017 10:06:52 +0100
Subject: [PATCH 152/185] Add kryo-hook to settings.gradle

---
 settings.gradle | 1 +
 1 file changed, 1 insertion(+)

diff --git a/settings.gradle b/settings.gradle
index a3b8270486..ec0d5adcc6 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -18,6 +18,7 @@ include 'webserver:webcapsule'
 include 'experimental'
 include 'experimental:sandbox'
 include 'experimental:quasar-hook'
+include 'experimental:kryo-hook'
 include 'verifier'
 include 'test-common'
 include 'test-utils'

From b354d335a330b5668fd692fc0971228788bc5e89 Mon Sep 17 00:00:00 2001
From: Andras Slemmer <andras.slemmer@r3cev.com>
Date: Wed, 11 Oct 2017 10:35:11 +0100
Subject: [PATCH 153/185] Remove extra blank line

---
 .../kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt     | 1 -
 1 file changed, 1 deletion(-)

diff --git a/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt b/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt
index e9c6f61e34..5afbd0e4ff 100644
--- a/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt
+++ b/experimental/kryo-hook/src/main/kotlin/net/corda/kryohook/KryoHook.kt
@@ -130,7 +130,6 @@ sealed class StatsTree {
     ) : StatsTree()
 }
 
-
 fun readTree(events: List<StatsEvent>, index: Int): Pair<Int, StatsTree> {
     val event = events[index]
     when (event) {

From 4ee250a19b04291e5d24dd5336ba5a008e856aa2 Mon Sep 17 00:00:00 2001
From: Andrzej Cichocki <andrzej.cichocki@r3.com>
Date: Wed, 11 Oct 2017 10:35:21 +0100
Subject: [PATCH 154/185] Retire setCordappPackages. (#1860)

---
 .../client/rpc/CordaRPCJavaClientTest.java    |  8 ++---
 .../client/rpc/BlacklistKotlinClosureTest.kt  |  4 +--
 .../corda/client/rpc/CordaRPCClientTest.kt    |  6 +---
 .../confidential/IdentitySyncFlowTests.kt     |  4 +--
 .../core/flows/CollectSignaturesFlowTests.kt  | 10 +++---
 .../core/flows/ContractUpgradeFlowTest.kt     |  4 +--
 .../net/corda/core/flows/FinalityFlowTests.kt |  4 +--
 .../internal/ResolveTransactionsFlowTest.kt   |  4 +--
 .../net/corda/docs/CustomVaultQueryTest.kt    |  4 +--
 .../docs/FxTransactionBuildTutorialTest.kt    |  4 +--
 .../WorkflowTransactionBuildTutorialTest.kt   |  6 +---
 .../corda/finance/contracts/universal/Cap.kt  | 22 ++++--------
 .../finance/contracts/universal/Caplet.kt     | 16 ---------
 .../contracts/universal/FXFwdTimeOption.kt    | 16 ---------
 .../finance/contracts/universal/FXSwap.kt     | 16 ---------
 .../corda/finance/contracts/universal/IRS.kt  | 16 ---------
 .../contracts/universal/RollOutTests.kt       | 15 --------
 .../finance/contracts/universal/Swaption.kt   | 16 ---------
 .../contracts/universal/ZeroCouponBond.kt     | 16 ---------
 .../finance/contracts/CommercialPaperTests.kt |  1 -
 .../contracts/asset/ObligationTests.kt        |  1 -
 .../corda/finance/flows/CashExitFlowTests.kt  |  4 +--
 .../corda/finance/flows/CashIssueFlowTests.kt |  5 +--
 .../finance/flows/CashPaymentFlowTests.kt     |  3 +-
 ...tachmentsClassLoaderStaticContractTests.kt |  6 ----
 .../node/services/RaftNotaryServiceTests.kt   | 14 +-------
 .../net/corda/node/internal/AbstractNode.kt   | 16 +--------
 .../kotlin/net/corda/node/internal/Node.kt    | 14 ++++++--
 .../node/internal/cordapp/CordappLoader.kt    | 19 ++++-------
 .../services/vault/VaultQueryJavaTests.java   |  7 ++--
 .../net/corda/node/CordaRPCOpsImplTest.kt     |  6 +---
 .../corda/node/internal/CordaServiceTest.kt   | 10 ++----
 .../node/messaging/TwoPartyTradeFlowTests.kt  | 34 ++++++++-----------
 .../corda/node/services/NotaryChangeTests.kt  |  4 +--
 .../events/NodeSchedulerServiceTest.kt        |  4 +--
 .../services/events/ScheduledFlowTests.kt     |  4 +--
 .../persistence/HibernateConfigurationTest.kt |  7 ++--
 .../statemachine/FlowFrameworkTests.kt        |  4 +--
 .../transactions/NotaryServiceTests.kt        |  4 +--
 .../ValidatingNotaryServiceTests.kt           |  4 +--
 .../services/vault/NodeVaultServiceTest.kt    | 16 +++++----
 .../node/services/vault/VaultQueryTests.kt    | 19 +++++------
 .../node/services/vault/VaultWithCashTest.kt  | 18 +++++-----
 .../corda/irs/api/NodeInterestRatesTest.kt    |  5 +--
 .../net/corda/netmap/simulation/Simulation.kt |  3 +-
 .../netmap/simulation/IRSSimulationTest.kt    | 15 --------
 .../net/corda/vega/SimmValuationTest.kt       | 14 +-------
 .../net/corda/traderdemo/TraderDemoTest.kt    | 15 +-------
 .../kotlin/net/corda/testing/NodeTestUtils.kt |  3 +-
 .../kotlin/net/corda/testing/driver/Driver.kt | 21 ++++++------
 .../kotlin/net/corda/testing/node/MockNode.kt |  6 ++--
 .../net/corda/testing/node/MockServices.kt    |  5 ++-
 .../net/corda/testing/node/NodeBasedTest.kt   |  6 ++--
 .../kotlin/net/corda/testing/CoreTestUtils.kt | 16 ---------
 54 files changed, 132 insertions(+), 392 deletions(-)

diff --git a/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java b/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
index e596a61418..714b0d4316 100644
--- a/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
+++ b/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
@@ -28,11 +28,13 @@ import static kotlin.test.AssertionsKt.assertEquals;
 import static net.corda.finance.Currencies.DOLLARS;
 import static net.corda.finance.contracts.GetBalances.getCashBalance;
 import static net.corda.node.services.FlowPermissions.startFlowPermission;
-import static net.corda.testing.CoreTestUtils.setCordappPackages;
-import static net.corda.testing.CoreTestUtils.unsetCordappPackages;
 import static net.corda.testing.TestConstants.getALICE;
 
 public class CordaRPCJavaClientTest extends NodeBasedTest {
+    public CordaRPCJavaClientTest() {
+        super(Collections.singletonList("net.corda.finance.contracts"));
+    }
+
     private List<String> perms = Arrays.asList(startFlowPermission(CashPaymentFlow.class), startFlowPermission(CashIssueFlow.class));
     private Set<String> permSet = new HashSet<>(perms);
     private User rpcUser = new User("user1", "test", permSet);
@@ -49,7 +51,6 @@ public class CordaRPCJavaClientTest extends NodeBasedTest {
 
     @Before
     public void setUp() throws ExecutionException, InterruptedException {
-        setCordappPackages("net.corda.finance.contracts");
         CordaFuture<StartedNode<Node>> nodeFuture = startNotaryNode(getALICE().getName(), singletonList(rpcUser), true);
         node = nodeFuture.get();
         node.getInternals().registerCustomSchemas(Collections.singleton(CashSchemaV1.INSTANCE));
@@ -59,7 +60,6 @@ public class CordaRPCJavaClientTest extends NodeBasedTest {
     @After
     public void done() throws IOException {
         connection.close();
-        unsetCordappPackages();
     }
 
     @Test
diff --git a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/BlacklistKotlinClosureTest.kt b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/BlacklistKotlinClosureTest.kt
index 776b96f87f..89264f2e05 100644
--- a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/BlacklistKotlinClosureTest.kt
+++ b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/BlacklistKotlinClosureTest.kt
@@ -23,7 +23,7 @@ import org.junit.rules.ExpectedException
 @CordaSerializable
 data class Packet(val x: () -> Long)
 
-class BlacklistKotlinClosureTest : NodeBasedTest() {
+class BlacklistKotlinClosureTest : NodeBasedTest(listOf("net.corda.client.rpc")) {
     companion object {
         @Suppress("UNUSED") val logger = loggerFor<BlacklistKotlinClosureTest>()
         const val EVIL: Long = 666
@@ -66,7 +66,6 @@ class BlacklistKotlinClosureTest : NodeBasedTest() {
 
     @Before
     fun setUp() {
-        setCordappPackages("net.corda.client.rpc")
         aliceNode = startNode(ALICE.name, rpcUsers = listOf(rpcUser)).getOrThrow()
         bobNode = startNode(BOB.name, rpcUsers = listOf(rpcUser)).getOrThrow()
         bobNode.registerInitiatedFlow(RemoteFlowC::class.java)
@@ -78,7 +77,6 @@ class BlacklistKotlinClosureTest : NodeBasedTest() {
         connection?.close()
         bobNode.internals.stop()
         aliceNode.internals.stop()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
index 422f08f8f3..be6f05715a 100644
--- a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
+++ b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
@@ -23,8 +23,6 @@ import net.corda.nodeapi.User
 import net.corda.testing.ALICE
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.NodeBasedTest
-import net.corda.testing.setCordappPackages
-import net.corda.testing.unsetCordappPackages
 import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.After
@@ -34,7 +32,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 
-class CordaRPCClientTest : NodeBasedTest() {
+class CordaRPCClientTest : NodeBasedTest(listOf("net.corda.finance.contracts")) {
     private val rpcUser = User("user1", "test", permissions = setOf(
             startFlowPermission<CashIssueFlow>(),
             startFlowPermission<CashPaymentFlow>()
@@ -49,7 +47,6 @@ class CordaRPCClientTest : NodeBasedTest() {
 
     @Before
     fun setUp() {
-        setCordappPackages("net.corda.finance.contracts")
         node = startNotaryNode(ALICE.name, rpcUsers = listOf(rpcUser)).getOrThrow()
         node.internals.registerCustomSchemas(setOf(CashSchemaV1))
         client = CordaRPCClient(node.internals.configuration.rpcAddress!!)
@@ -58,7 +55,6 @@ class CordaRPCClientTest : NodeBasedTest() {
     @After
     fun done() {
         connection?.close()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt b/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
index 7482825440..ef276ef07e 100644
--- a/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
+++ b/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
@@ -28,15 +28,13 @@ class IdentitySyncFlowTests {
 
     @Before
     fun before() {
-        setCordappPackages("net.corda.finance.contracts.asset")
         // We run this in parallel threads to help catch any race conditions that may exist.
-        mockNet = MockNetwork(networkSendManuallyPumped = false, threadPerNode = true)
+        mockNet = MockNetwork(networkSendManuallyPumped = false, threadPerNode = true, cordappPackages = listOf("net.corda.finance.contracts.asset"))
     }
 
     @After
     fun cleanUp() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
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 619ddec8a6..984646750c 100644
--- a/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
@@ -23,6 +23,10 @@ import kotlin.reflect.KClass
 import kotlin.test.assertFailsWith
 
 class CollectSignaturesFlowTests {
+    companion object {
+        private val cordappPackages = listOf("net.corda.testing.contracts")
+    }
+
     lateinit var mockNet: MockNetwork
     lateinit var aliceNode: StartedNode<MockNetwork.MockNode>
     lateinit var bobNode: StartedNode<MockNetwork.MockNode>
@@ -31,8 +35,7 @@ class CollectSignaturesFlowTests {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.testing.contracts")
-        mockNet = MockNetwork()
+        mockNet = MockNetwork(cordappPackages = cordappPackages)
         val notaryNode = mockNet.createNotaryNode()
         aliceNode = mockNet.createPartyNode(ALICE.name)
         bobNode = mockNet.createPartyNode(BOB.name)
@@ -45,7 +48,6 @@ class CollectSignaturesFlowTests {
     @After
     fun tearDown() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     private fun registerFlowOnAllNodes(flowClass: KClass<out FlowLogic<*>>) {
@@ -174,7 +176,7 @@ class CollectSignaturesFlowTests {
     @Test
     fun `fails when not signed by initiator`() {
         val onePartyDummyContract = DummyContract.generateInitial(1337, notary, aliceNode.info.chooseIdentity().ref(1))
-        val miniCorpServices = MockServices(MINI_CORP_KEY)
+        val miniCorpServices = MockServices(cordappPackages, MINI_CORP_KEY)
         val ptx = miniCorpServices.signInitialTransaction(onePartyDummyContract)
         val flow = aliceNode.services.startFlow(CollectSignaturesFlow(ptx, emptySet()))
         mockNet.runNetwork()
diff --git a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
index 0720557b1f..782d3ee35f 100644
--- a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
@@ -40,8 +40,7 @@ class ContractUpgradeFlowTest {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.testing.contracts", "net.corda.finance.contracts.asset", "net.corda.core.flows")
-        mockNet = MockNetwork()
+        mockNet = MockNetwork(cordappPackages = listOf("net.corda.testing.contracts", "net.corda.finance.contracts.asset", "net.corda.core.flows"))
         val notaryNode = mockNet.createNotaryNode()
         aliceNode = mockNet.createPartyNode(ALICE.name)
         bobNode = mockNet.createPartyNode(BOB.name)
@@ -56,7 +55,6 @@ class ContractUpgradeFlowTest {
     @After
     fun tearDown() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt b/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
index fb865fd291..e17da0775b 100644
--- a/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
@@ -23,8 +23,7 @@ class FinalityFlowTests {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.finance.contracts.asset")
-        mockNet = MockNetwork()
+        mockNet = MockNetwork(cordappPackages = listOf("net.corda.finance.contracts.asset"))
         mockNet.createNotaryNode()
         aliceNode = mockNet.createPartyNode(ALICE.name)
         bobNode = mockNet.createPartyNode(BOB.name)
@@ -36,7 +35,6 @@ class FinalityFlowTests {
     @After
     fun tearDown() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
index bf16c93f53..e7f43c3096 100644
--- a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
@@ -36,8 +36,7 @@ class ResolveTransactionsFlowTest {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.testing.contracts")
-        mockNet = MockNetwork()
+        mockNet = MockNetwork(cordappPackages = listOf("net.corda.testing.contracts"))
         notaryNode = mockNet.createNotaryNode()
         megaCorpNode = mockNet.createPartyNode(MEGA_CORP.name)
         miniCorpNode = mockNet.createPartyNode(MINI_CORP.name)
@@ -52,7 +51,6 @@ class ResolveTransactionsFlowTest {
     @After
     fun tearDown() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 // DOCEND 3
 
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
index d313217f40..847675db13 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
@@ -26,8 +26,7 @@ class CustomVaultQueryTest {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.finance.contracts.asset")
-        mockNet = MockNetwork(threadPerNode = true)
+        mockNet = MockNetwork(threadPerNode = true, cordappPackages = listOf("net.corda.finance.contracts.asset"))
         mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         nodeA = mockNet.createPartyNode()
         nodeB = mockNet.createPartyNode()
@@ -42,7 +41,6 @@ class CustomVaultQueryTest {
     @After
     fun cleanUp() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
index be28ddbec0..97ddbc598c 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
@@ -24,8 +24,7 @@ class FxTransactionBuildTutorialTest {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.finance.contracts.asset")
-        mockNet = MockNetwork(threadPerNode = true)
+        mockNet = MockNetwork(threadPerNode = true, cordappPackages = listOf("net.corda.finance.contracts.asset"))
         mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         nodeA = mockNet.createPartyNode()
         nodeB = mockNet.createPartyNode()
@@ -38,7 +37,6 @@ class FxTransactionBuildTutorialTest {
     @After
     fun cleanUp() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
index 6b9f0d279d..089885d5f5 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
@@ -12,8 +12,6 @@ import net.corda.node.internal.StartedNode
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.MockNetwork
-import net.corda.testing.setCordappPackages
-import net.corda.testing.unsetCordappPackages
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -32,8 +30,7 @@ class WorkflowTransactionBuildTutorialTest {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.docs")
-        mockNet = MockNetwork(threadPerNode = true)
+        mockNet = MockNetwork(threadPerNode = true, cordappPackages = listOf("net.corda.docs"))
         mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         nodeA = mockNet.createPartyNode()
         nodeB = mockNet.createPartyNode()
@@ -43,7 +40,6 @@ class WorkflowTransactionBuildTutorialTest {
     @After
     fun cleanUp() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Cap.kt b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Cap.kt
index 95c7e983fd..bedc953058 100644
--- a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Cap.kt
+++ b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Cap.kt
@@ -5,16 +5,18 @@ import net.corda.finance.contracts.FixOf
 import net.corda.finance.contracts.Frequency
 import net.corda.finance.contracts.Tenor
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.setCordappPackages
-import net.corda.testing.transaction
-import net.corda.testing.unsetCordappPackages
-import org.junit.After
-import org.junit.Before
+import net.corda.testing.EnforceVerifyOrFail
+import net.corda.testing.TransactionDSL
+import net.corda.testing.TransactionDSLInterpreter
 import org.junit.Ignore
 import org.junit.Test
 import java.time.Instant
 import java.time.LocalDate
 
+fun transaction(script: TransactionDSL<TransactionDSLInterpreter>.() -> EnforceVerifyOrFail) = run {
+    net.corda.testing.transaction(cordappPackages = listOf("net.corda.finance.contracts.universal"), dsl = script)
+}
+
 class Cap {
 
     val TEST_TX_TIME_1: Instant get() = Instant.parse("2017-09-02T12:00:00.00Z")
@@ -167,16 +169,6 @@ class Cap {
         }
     }
 
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.finance.contracts.universal")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun issue() {
         transaction {
diff --git a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Caplet.kt b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Caplet.kt
index 8793dd65b9..390ea97154 100644
--- a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Caplet.kt
+++ b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Caplet.kt
@@ -3,11 +3,6 @@ package net.corda.finance.contracts.universal
 import net.corda.finance.contracts.FixOf
 import net.corda.finance.contracts.Tenor
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.setCordappPackages
-import net.corda.testing.transaction
-import net.corda.testing.unsetCordappPackages
-import org.junit.After
-import org.junit.Before
 import org.junit.Ignore
 import org.junit.Test
 import java.time.Instant
@@ -53,17 +48,6 @@ class Caplet {
     val stateFixed = UniversalContract.State(listOf(DUMMY_NOTARY), contractFixed)
 
     val stateFinal = UniversalContract.State(listOf(DUMMY_NOTARY), contractFinal)
-
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.finance.contracts.universal")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun issue() {
         transaction {
diff --git a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/FXFwdTimeOption.kt b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/FXFwdTimeOption.kt
index ec78fc1b0c..7117b22b74 100644
--- a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/FXFwdTimeOption.kt
+++ b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/FXFwdTimeOption.kt
@@ -1,11 +1,6 @@
 package net.corda.finance.contracts.universal
 
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.setCordappPackages
-import net.corda.testing.transaction
-import net.corda.testing.unsetCordappPackages
-import org.junit.After
-import org.junit.Before
 import org.junit.Ignore
 import org.junit.Test
 import java.time.Instant
@@ -50,17 +45,6 @@ class FXFwdTimeOption
     val inState = UniversalContract.State(listOf(DUMMY_NOTARY), initialContract)
     val outState1 = UniversalContract.State(listOf(DUMMY_NOTARY), outContract1)
     val outState2 = UniversalContract.State(listOf(DUMMY_NOTARY), outContract2)
-
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.finance.contracts.universal")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun `issue - signature`() {
         transaction {
diff --git a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/FXSwap.kt b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/FXSwap.kt
index 26189d2424..67983a6c0e 100644
--- a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/FXSwap.kt
+++ b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/FXSwap.kt
@@ -1,11 +1,6 @@
 package net.corda.finance.contracts.universal
 
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.setCordappPackages
-import net.corda.testing.transaction
-import net.corda.testing.unsetCordappPackages
-import org.junit.After
-import org.junit.Before
 import org.junit.Ignore
 import org.junit.Test
 import java.time.Instant
@@ -41,17 +36,6 @@ class FXSwap {
     val outStateBad3 = UniversalContract.State(listOf(DUMMY_NOTARY), transferBad3)
 
     val inState = UniversalContract.State(listOf(DUMMY_NOTARY), contract)
-
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.finance.contracts.universal")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun `issue - signature`() {
 
diff --git a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/IRS.kt b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/IRS.kt
index ae55271902..9239146e8c 100644
--- a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/IRS.kt
+++ b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/IRS.kt
@@ -4,11 +4,6 @@ import net.corda.finance.contracts.FixOf
 import net.corda.finance.contracts.Frequency
 import net.corda.finance.contracts.Tenor
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.setCordappPackages
-import net.corda.testing.transaction
-import net.corda.testing.unsetCordappPackages
-import org.junit.After
-import org.junit.Before
 import org.junit.Ignore
 import org.junit.Test
 import java.time.Instant
@@ -132,17 +127,6 @@ class IRS {
     val stateAfterExecutionFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterExecutionFirst)
 
     val statePaymentFirst = UniversalContract.State(listOf(DUMMY_NOTARY), paymentFirst)
-
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.finance.contracts.universal")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun issue() {
         transaction {
diff --git a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/RollOutTests.kt b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/RollOutTests.kt
index 40d4b7bb94..3a86f41cfa 100644
--- a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/RollOutTests.kt
+++ b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/RollOutTests.kt
@@ -2,11 +2,6 @@ package net.corda.finance.contracts.universal
 
 import net.corda.finance.contracts.Frequency
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.setCordappPackages
-import net.corda.testing.transaction
-import net.corda.testing.unsetCordappPackages
-import org.junit.After
-import org.junit.Before
 import org.junit.Test
 import java.time.Instant
 import kotlin.test.assertEquals
@@ -122,16 +117,6 @@ class RollOutTests {
         next()
     }
 
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.finance.contracts.universal")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun `arrangement equality transfer`() {
         assertEquals(contract_transfer1, contract_transfer2)
diff --git a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Swaption.kt b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Swaption.kt
index 590e7a47ac..c0b464af33 100644
--- a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Swaption.kt
+++ b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/Swaption.kt
@@ -3,11 +3,6 @@ package net.corda.finance.contracts.universal
 import net.corda.finance.contracts.Frequency
 import net.corda.finance.contracts.Tenor
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.setCordappPackages
-import net.corda.testing.transaction
-import net.corda.testing.unsetCordappPackages
-import org.junit.After
-import org.junit.Before
 import org.junit.Ignore
 import org.junit.Test
 import java.time.Instant
@@ -59,17 +54,6 @@ class Swaption {
     }
 
     val stateInitial = UniversalContract.State(listOf(DUMMY_NOTARY), contractInitial)
-
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.finance.contracts.universal")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun issue() {
         transaction {
diff --git a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/ZeroCouponBond.kt b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/ZeroCouponBond.kt
index 3d79d0df1b..8692518724 100644
--- a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/ZeroCouponBond.kt
+++ b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/ZeroCouponBond.kt
@@ -1,11 +1,6 @@
 package net.corda.finance.contracts.universal
 
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.setCordappPackages
-import net.corda.testing.transaction
-import net.corda.testing.unsetCordappPackages
-import org.junit.After
-import org.junit.Before
 import org.junit.Test
 import java.time.Instant
 import kotlin.test.assertEquals
@@ -43,17 +38,6 @@ class ZeroCouponBond {
     val outStateWrong = UniversalContract.State(listOf(DUMMY_NOTARY), transferWrong)
 
     val outStateMove = UniversalContract.State(listOf(DUMMY_NOTARY), contractMove)
-
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.finance.contracts.universal")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun basic() {
         assertEquals(Zero(), Zero())
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
index 6175bca1b7..d1d6751aa1 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt
@@ -231,7 +231,6 @@ class CommercialPaperTestsGeneric {
     //    @Test
     @Ignore
     fun `issue move and then redeem`() {
-        setCordappPackages("net.corda.finance.contracts")
         initialiseTestSerialization()
         val aliceDatabaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(ALICE_KEY))
         val databaseAlice = aliceDatabaseAndServices.first
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt
index d5aa6d8cdc..c2d683a74b 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt
@@ -593,7 +593,6 @@ class ObligationTests {
         }
 
         // Try defaulting an obligation that is now in the past
-        unsetCordappPackages()
         ledger {
             transaction("Settlement") {
                 attachments(Obligation.PROGRAM_ID)
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
index c8c92fad91..94b3f83658 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt
@@ -28,8 +28,7 @@ class CashExitFlowTests {
 
     @Before
     fun start() {
-        setCordappPackages("net.corda.finance.contracts.asset")
-        mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
+        mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin(), cordappPackages = listOf("net.corda.finance.contracts.asset"))
         notaryNode = mockNet.createNotaryNode()
         bankOfCordaNode = mockNet.createPartyNode(BOC.name)
         notary = notaryNode.services.getDefaultNotary()
@@ -45,7 +44,6 @@ class CashExitFlowTests {
     @After
     fun cleanUp() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
index 3aeb782a1d..911a014d5f 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt
@@ -10,11 +10,9 @@ import net.corda.node.internal.StartedNode
 import net.corda.testing.chooseIdentity
 import net.corda.testing.getDefaultNotary
 import net.corda.testing.BOC
-import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.node.InMemoryMessagingNetwork.ServicePeerAllocationStrategy.RoundRobin
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
-import net.corda.testing.setCordappPackages
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -30,8 +28,7 @@ class CashIssueFlowTests {
 
     @Before
     fun start() {
-        setCordappPackages("net.corda.finance.contracts.asset")
-        mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
+        mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin(), cordappPackages = listOf("net.corda.finance.contracts.asset"))
         notaryNode = mockNet.createNotaryNode()
         bankOfCordaNode = mockNet.createPartyNode(BOC.name)
         bankOfCorda = bankOfCordaNode.info.chooseIdentity()
diff --git a/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt b/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
index a9b1352646..0c5b1e5efa 100644
--- a/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt
@@ -31,8 +31,7 @@ class CashPaymentFlowTests {
 
     @Before
     fun start() {
-        setCordappPackages("net.corda.finance.contracts.asset")
-        mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
+        mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin(), cordappPackages = listOf("net.corda.finance.contracts.asset"))
         notaryNode = mockNet.createNotaryNode()
         bankOfCordaNode = mockNet.createPartyNode(BOC.name)
         bankOfCorda = bankOfCordaNode.info.chooseIdentity()
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderStaticContractTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderStaticContractTests.kt
index ce95ac21d8..3e72b1d0d4 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderStaticContractTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderStaticContractTests.kt
@@ -9,7 +9,6 @@ import net.corda.core.transactions.LedgerTransaction
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.testing.*
 import net.corda.testing.node.MockServices
-import org.junit.After
 import org.junit.Assert.*
 import org.junit.Before
 import org.junit.Test
@@ -48,11 +47,6 @@ class AttachmentsClassLoaderStaticContractTests : TestDependencyInjectionBase()
         serviceHub = MockServices(cordappPackages = listOf("net.corda.nodeapi.internal"))
     }
 
-    @After
-    fun `clear packages`() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun `test serialization of WireTransaction with statically loaded contract`() {
         val tx = AttachmentDummyContract().generateInitial(MEGA_CORP.ref(0), 42, DUMMY_NOTARY)
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/RaftNotaryServiceTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/RaftNotaryServiceTests.kt
index 0b5d72d858..3ba78ff7bd 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/RaftNotaryServiceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/RaftNotaryServiceTests.kt
@@ -16,26 +16,14 @@ import net.corda.node.services.transactions.RaftValidatingNotaryService
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.NodeBasedTest
-import org.junit.After
-import org.junit.Before
 import org.junit.Test
 import java.util.*
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
-class RaftNotaryServiceTests : NodeBasedTest() {
+class RaftNotaryServiceTests : NodeBasedTest(listOf("net.corda.testing.contracts")) {
     private val notaryName = CordaX500Name(RaftValidatingNotaryService.id, "RAFT Notary Service", "London", "GB")
 
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.testing.contracts")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun `detect double spend`() {
         val (bankA) = listOf(
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 0d92fe6df5..e08b457c37 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -102,6 +102,7 @@ import net.corda.core.crypto.generateKeyPair as cryptoGenerateKeyPair
 abstract class AbstractNode(config: NodeConfiguration,
                             val platformClock: Clock,
                             protected val versionInfo: VersionInfo,
+                            protected val cordappLoader: CordappLoader,
                             @VisibleForTesting val busyNodeLatch: ReusableLatch = ReusableLatch()) : SingletonSerializeAsToken() {
     open val configuration = config.apply {
         require(minimumPlatformVersion <= versionInfo.platformVersion) {
@@ -151,8 +152,6 @@ abstract class AbstractNode(config: NodeConfiguration,
     protected val runOnStop = ArrayList<() -> Any?>()
     protected lateinit var database: CordaPersistence
     lateinit var cordappProvider: CordappProviderImpl
-    protected val cordappLoader by lazy { makeCordappLoader() }
-
     protected val _nodeReadyFuture = openFuture<Unit>()
     /** Completes once the node has successfully registered with the network map service
      * or has loaded network map data from local database */
@@ -472,19 +471,6 @@ abstract class AbstractNode(config: NodeConfiguration,
         return tokenizableServices
     }
 
-    private fun makeCordappLoader(): CordappLoader {
-        val scanPackages = System.getProperty("net.corda.node.cordapp.scan.packages")
-        return if (CordappLoader.testPackages.isNotEmpty()) {
-            check(configuration.devMode) { "Package scanning can only occur in dev mode" }
-            CordappLoader.createDefaultWithTestPackages(configuration.baseDirectory, CordappLoader.testPackages)
-        } else if (scanPackages != null) {
-            check(configuration.devMode) { "Package scanning can only occur in dev mode" }
-            CordappLoader.createDefaultWithTestPackages(configuration.baseDirectory, scanPackages.split(","))
-        } else {
-            CordappLoader.createDefault(configuration.baseDirectory)
-        }
-    }
-
     protected open fun makeTransactionStorage(): WritableTransactionStorage = DBTransactionStorage()
 
     private fun makeVaultObservers() {
diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt
index 84b126980a..7257eea773 100644
--- a/node/src/main/kotlin/net/corda/node/internal/Node.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt
@@ -15,6 +15,7 @@ import net.corda.core.node.ServiceHub
 import net.corda.core.serialization.SerializationDefaults
 import net.corda.core.utilities.*
 import net.corda.node.VersionInfo
+import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.serialization.KryoServerSerializationScheme
 import net.corda.node.serialization.NodeClock
 import net.corda.node.services.RPCUserService
@@ -22,6 +23,7 @@ import net.corda.node.services.RPCUserServiceImpl
 import net.corda.node.services.api.NetworkMapCacheInternal
 import net.corda.node.services.api.SchemaService
 import net.corda.node.services.config.FullNodeConfiguration
+import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.messaging.ArtemisMessagingServer
 import net.corda.node.services.messaging.ArtemisMessagingServer.Companion.ipDetectRequestProperty
 import net.corda.node.services.messaging.ArtemisMessagingServer.Companion.ipDetectResponseProperty
@@ -62,8 +64,9 @@ import kotlin.system.exitProcess
  */
 open class Node(override val configuration: FullNodeConfiguration,
                 versionInfo: VersionInfo,
-                val initialiseSerialization: Boolean = true
-) : AbstractNode(configuration, createClock(configuration), versionInfo) {
+                val initialiseSerialization: Boolean = true,
+                cordappLoader: CordappLoader = makeCordappLoader(configuration)
+) : AbstractNode(configuration, createClock(configuration), versionInfo, cordappLoader) {
     companion object {
         private val logger = loggerFor<Node>()
         var renderBasicInfoToConsole = true
@@ -86,6 +89,13 @@ open class Node(override val configuration: FullNodeConfiguration,
         }
 
         private val sameVmNodeCounter = AtomicInteger()
+        val scanPackagesSystemProperty = "net.corda.node.cordapp.scan.packages"
+        val scanPackagesSeparator = ","
+        private fun makeCordappLoader(configuration: NodeConfiguration): CordappLoader {
+            return System.getProperty(scanPackagesSystemProperty)?.let { scanPackages ->
+                CordappLoader.createDefaultWithTestPackages(configuration, scanPackages.split(scanPackagesSeparator))
+            } ?: CordappLoader.createDefault(configuration.baseDirectory)
+        }
     }
 
     override val log: Logger get() = logger
diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
index 493b965ba6..7cdba9ca71 100644
--- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
@@ -14,6 +14,7 @@ import net.corda.core.serialization.SerializationWhitelist
 import net.corda.core.serialization.SerializeAsToken
 import net.corda.core.utilities.loggerFor
 import net.corda.node.internal.classloading.requireAnnotation
+import net.corda.node.services.config.NodeConfiguration
 import net.corda.nodeapi.internal.serialization.DefaultWhitelist
 import java.io.File
 import java.io.FileOutputStream
@@ -64,14 +65,12 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
         /**
          * Create a dev mode CordappLoader for test environments that creates and loads cordapps from the classpath
          * and plugins directory. This is intended mostly for use by the driver.
-         *
-         * @param baseDir See [createDefault.baseDir]
-         * @param testPackages See [createWithTestPackages.testPackages]
          */
         @VisibleForTesting
-        @JvmOverloads
-        fun createDefaultWithTestPackages(baseDir: Path, testPackages: List<String> = CordappLoader.testPackages)
-                = CordappLoader(getCordappsInDirectory(getPluginsPath(baseDir)) + testPackages.flatMap(this::createScanPackage))
+        fun createDefaultWithTestPackages(configuration: NodeConfiguration, testPackages: List<String>): CordappLoader {
+            check(configuration.devMode) { "Package scanning can only occur in dev mode" }
+            return CordappLoader(getCordappsInDirectory(getPluginsPath(configuration.baseDirectory)) + testPackages.flatMap(this::createScanPackage))
+        }
 
         /**
          * Create a dev mode CordappLoader for test environments that creates and loads cordapps from the classpath.
@@ -81,8 +80,7 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
          * CorDapps.
          */
         @VisibleForTesting
-        @JvmOverloads
-        fun createWithTestPackages(testPackages: List<String> = CordappLoader.testPackages)
+        fun createWithTestPackages(testPackages: List<String>)
                 = CordappLoader(testPackages.flatMap(this::createScanPackage))
 
         /**
@@ -147,11 +145,6 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
             }
         }
 
-        /**
-         * A list of test packages that will be scanned as CorDapps and compiled into CorDapp JARs for use in tests only.
-         */
-        @VisibleForTesting
-        var testPackages: List<String> = emptyList()
         private val generatedCordapps = mutableMapOf<URL, URI>()
 
         /** A list of the core RPC flows present in Corda */
diff --git a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
index 97dab2aaa7..0568b45a3e 100644
--- a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
+++ b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
@@ -43,15 +43,15 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
 
     @Before
     public void setUp() {
-        setCordappPackages("net.corda.testing.contracts", "net.corda.finance.contracts.asset");
+        List<String> cordappPackages = Arrays.asList("net.corda.testing.contracts", "net.corda.finance.contracts.asset");
         ArrayList<KeyPair> keys = new ArrayList<>();
         keys.add(getMEGA_CORP_KEY());
         keys.add(getDUMMY_NOTARY_KEY());
         Set<MappedSchema> requiredSchemas = Collections.singleton(CashSchemaV1.INSTANCE);
         IdentityService identitySvc = makeTestIdentityService();
         @SuppressWarnings("unchecked")
-        Pair<CordaPersistence, MockServices> databaseAndServices = makeTestDatabaseAndMockServices(requiredSchemas, keys, () -> identitySvc, Collections.EMPTY_LIST);
-        issuerServices = new MockServices(getDUMMY_CASH_ISSUER_KEY(), getBOC_KEY());
+        Pair<CordaPersistence, MockServices> databaseAndServices = makeTestDatabaseAndMockServices(requiredSchemas, keys, () -> identitySvc, cordappPackages);
+        issuerServices = new MockServices(cordappPackages, getDUMMY_CASH_ISSUER_KEY(), getBOC_KEY());
         database = databaseAndServices.getFirst();
         services = databaseAndServices.getSecond();
         vaultService = services.getVaultService();
@@ -60,7 +60,6 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
     @After
     public void cleanUp() throws IOException {
         database.close();
-        unsetCordappPackages();
     }
 
     /**
diff --git a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
index e03fd6972c..0020970296 100644
--- a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
+++ b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
@@ -62,9 +62,7 @@ class CordaRPCOpsImplTest {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.finance.contracts.asset")
-
-        mockNet = MockNetwork()
+        mockNet = MockNetwork(cordappPackages = listOf("net.corda.finance.contracts.asset"))
         aliceNode = mockNet.createNode()
         notaryNode = mockNet.createNotaryNode(validating = false)
         rpc = CordaRPCOpsImpl(aliceNode.services, aliceNode.smm, aliceNode.database)
@@ -81,7 +79,6 @@ class CordaRPCOpsImplTest {
     @After
     fun cleanUp() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
@@ -100,7 +97,6 @@ class CordaRPCOpsImplTest {
         }
 
         // Tell the monitoring service node to issue some cash
-        val recipient = aliceNode.info.chooseIdentity()
         val result = rpc.startFlow(::CashIssueFlow, Amount(quantity, GBP), ref, notary)
         mockNet.runNetwork()
 
diff --git a/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt b/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt
index 1a08a04e76..6135863388 100644
--- a/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/internal/CordaServiceTest.kt
@@ -15,8 +15,6 @@ import net.corda.finance.flows.CashIssueFlow
 import net.corda.node.internal.cordapp.DummyRPCFlow
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.node.MockNetwork
-import net.corda.testing.setCordappPackages
-import net.corda.testing.unsetCordappPackages
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -74,9 +72,7 @@ class TestCordaService2(val appServiceHub: AppServiceHub): SingletonSerializeAsT
 }
 
 @CordaService
-class LegacyCordaService(val simpleServiceHub: ServiceHub): SingletonSerializeAsToken() {
-
-}
+class LegacyCordaService(@Suppress("UNUSED_PARAMETER") simpleServiceHub: ServiceHub) : SingletonSerializeAsToken()
 
 class CordaServiceTest {
     lateinit var mockNet: MockNetwork
@@ -85,8 +81,7 @@ class CordaServiceTest {
 
     @Before
     fun start() {
-        setCordappPackages("net.corda.node.internal","net.corda.finance")
-        mockNet = MockNetwork(threadPerNode = true)
+        mockNet = MockNetwork(threadPerNode = true, cordappPackages = listOf("net.corda.node.internal","net.corda.finance"))
         notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name, validating = true)
         nodeA = mockNet.createNode()
         mockNet.startNodes()
@@ -95,7 +90,6 @@ class CordaServiceTest {
     @After
     fun cleanUp() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
index 1d19ed5833..9677213a16 100644
--- a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
@@ -45,6 +45,7 @@ import net.corda.testing.*
 import net.corda.testing.contracts.fillWithSomeTestCash
 import net.corda.testing.node.InMemoryMessagingNetwork
 import net.corda.testing.node.MockNetwork
+import net.corda.testing.node.MockServices
 import net.corda.testing.node.pumpReceive
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.After
@@ -73,6 +74,7 @@ import kotlin.test.assertTrue
 @RunWith(Parameterized::class)
 class TwoPartyTradeFlowTests(val anonymous: Boolean) {
     companion object {
+        private val cordappPackages = listOf("net.corda.finance.contracts")
         @JvmStatic
         @Parameterized.Parameters
         fun data(): Collection<Boolean> {
@@ -84,7 +86,6 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
 
     @Before
     fun before() {
-        setCordappPackages("net.corda.finance.contracts")
         LogHelper.setLevel("platform.trade", "core.contract.TransactionGroup", "recordingmap")
     }
 
@@ -92,7 +93,6 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
     fun after() {
         mockNet.stopNodes()
         LogHelper.reset("platform.trade", "core.contract.TransactionGroup", "recordingmap")
-        unsetCordappPackages()
     }
 
     @Test
@@ -100,9 +100,8 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
         // We run this in parallel threads to help catch any race conditions that may exist. The other tests
         // we run in the unit test thread exclusively to speed things up, ensure deterministic results and
         // allow interruption half way through.
-        mockNet = MockNetwork(false, true)
-
-        ledger(initialiseSerialization = false) {
+        mockNet = MockNetwork(false, true, cordappPackages = cordappPackages)
+        ledger(MockServices(cordappPackages), initialiseSerialization = false) {
             val notaryNode = mockNet.createNotaryNode()
             val aliceNode = mockNet.createPartyNode(ALICE.name)
             val bobNode = mockNet.createPartyNode(BOB.name)
@@ -149,9 +148,8 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
 
     @Test(expected = InsufficientBalanceException::class)
     fun `trade cash for commercial paper fails using soft locking`() {
-        mockNet = MockNetwork(false, true)
-
-        ledger(initialiseSerialization = false) {
+        mockNet = MockNetwork(false, true, cordappPackages = cordappPackages)
+        ledger(MockServices(cordappPackages), initialiseSerialization = false) {
             val notaryNode = mockNet.createNotaryNode()
             val aliceNode = mockNet.createPartyNode(ALICE.name)
             val bobNode = mockNet.createPartyNode(BOB.name)
@@ -204,8 +202,8 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
 
     @Test
     fun `shutdown and restore`() {
-        mockNet = MockNetwork(false)
-        ledger(initialiseSerialization = false) {
+        mockNet = MockNetwork(false, cordappPackages = cordappPackages)
+        ledger(MockServices(cordappPackages), initialiseSerialization = false) {
             val notaryNode = mockNet.createNotaryNode()
             val aliceNode = mockNet.createPartyNode(ALICE.name)
             var bobNode = mockNet.createPartyNode(BOB.name)
@@ -222,8 +220,6 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
             bobNode.internals.disableDBCloseOnStop()
 
             val bobAddr = bobNode.network.myAddress as InMemoryMessagingNetwork.PeerHandle
-            val networkMapAddress = notaryNode.network.myAddress
-
             mockNet.runNetwork() // Clear network map registration messages
             val notary = aliceNode.services.getDefaultNotary()
 
@@ -331,8 +327,7 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
 
     @Test
     fun `check dependencies of sale asset are resolved`() {
-        mockNet = MockNetwork(false)
-
+        mockNet = MockNetwork(false, cordappPackages = cordappPackages)
         val notaryNode = mockNet.createNotaryNode()
         val aliceNode = makeNodeWithTracking(ALICE.name)
         val bobNode = makeNodeWithTracking(BOB.name)
@@ -436,8 +431,7 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
 
     @Test
     fun `track works`() {
-        mockNet = MockNetwork(false)
-
+        mockNet = MockNetwork(false, cordappPackages = cordappPackages)
         val notaryNode = mockNet.createNotaryNode()
         val aliceNode = makeNodeWithTracking(ALICE.name)
         val bobNode = makeNodeWithTracking(BOB.name)
@@ -517,16 +511,16 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
 
     @Test
     fun `dependency with error on buyer side`() {
-        mockNet = MockNetwork(false)
-        ledger(initialiseSerialization = false) {
+        mockNet = MockNetwork(false, cordappPackages = cordappPackages)
+        ledger(MockServices(cordappPackages), initialiseSerialization = false) {
             runWithError(true, false, "at least one cash input")
         }
     }
 
     @Test
     fun `dependency with error on seller side`() {
-        mockNet = MockNetwork(false)
-        ledger(initialiseSerialization = false) {
+        mockNet = MockNetwork(false, cordappPackages = cordappPackages)
+        ledger(MockServices(cordappPackages), initialiseSerialization = false) {
             runWithError(false, true, "Issuances have a time-window")
         }
     }
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 a758655ff8..957d6ac442 100644
--- a/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
@@ -35,8 +35,7 @@ class NotaryChangeTests {
 
     @Before
     fun setUp() {
-        setCordappPackages("net.corda.testing.contracts")
-        mockNet = MockNetwork()
+        mockNet = MockNetwork(cordappPackages = listOf("net.corda.testing.contracts"))
         oldNotaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         clientNodeA = mockNet.createNode()
         clientNodeB = mockNet.createNode()
@@ -50,7 +49,6 @@ class NotaryChangeTests {
     @After
     fun cleanUp() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
index ad05ba1ad2..d5c966d31c 100644
--- a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
@@ -72,7 +72,6 @@ class NodeSchedulerServiceTest : SingletonSerializeAsToken() {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.testing.contracts")
         initialiseTestSerialization()
         countDown = CountDownLatch(1)
         smmHasRemovedAllFlows = CountDownLatch(1)
@@ -98,7 +97,7 @@ class NodeSchedulerServiceTest : SingletonSerializeAsToken() {
                     network = mockMessagingService), TestReference {
                 override val vaultService: VaultServiceInternal = NodeVaultService(testClock, kms, stateLoader, database.hibernateConfig)
                 override val testReference = this@NodeSchedulerServiceTest
-                override val cordappProvider: CordappProviderImpl = CordappProviderImpl(CordappLoader.createWithTestPackages()).start(attachments)
+                override val cordappProvider = CordappProviderImpl(CordappLoader.createWithTestPackages(listOf("net.corda.testing.contracts"))).start(attachments)
             }
             smmExecutor = AffinityExecutor.ServiceAffinityExecutor("test", 1)
             scheduler = NodeSchedulerService(services, schedulerGatedExecutor, serverThread = smmExecutor)
@@ -124,7 +123,6 @@ class NodeSchedulerServiceTest : SingletonSerializeAsToken() {
         smmExecutor.awaitTermination(60, TimeUnit.SECONDS)
         database.close()
         resetTestSerialization()
-        unsetCordappPackages()
     }
 
     class TestState(val flowLogicRef: FlowLogicRef, val instant: Instant, val myIdentity: Party) : LinearState, SchedulableState {
diff --git a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
index 013eea5d74..be2fc12b96 100644
--- a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
@@ -91,8 +91,7 @@ class ScheduledFlowTests {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.testing.contracts")
-        mockNet = MockNetwork(threadPerNode = true)
+        mockNet = MockNetwork(threadPerNode = true, cordappPackages = listOf("net.corda.testing.contracts"))
         notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         val a = mockNet.createUnstartedNode()
         val b = mockNet.createUnstartedNode()
@@ -107,7 +106,6 @@ class ScheduledFlowTests {
     @After
     fun cleanUp() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
index e554ea59be..f0a381c411 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
@@ -73,14 +73,14 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
 
     @Before
     fun setUp() {
-        setCordappPackages("net.corda.testing.contracts", "net.corda.finance.contracts.asset")
-        issuerServices = MockServices(DUMMY_CASH_ISSUER_KEY, BOB_KEY, BOC_KEY)
+        val cordappPackages = listOf("net.corda.testing.contracts", "net.corda.finance.contracts.asset")
+        issuerServices = MockServices(cordappPackages, DUMMY_CASH_ISSUER_KEY, BOB_KEY, BOC_KEY)
         val dataSourceProps = makeTestDataSourceProperties()
         val defaultDatabaseProperties = makeTestDatabaseProperties()
         database = configureDatabase(dataSourceProps, defaultDatabaseProperties, NodeSchemaService(), ::makeTestIdentityService)
         database.transaction {
             hibernateConfig = database.hibernateConfig
-            services = object : MockServices(BOB_KEY, BOC_KEY, DUMMY_NOTARY_KEY) {
+            services = object : MockServices(cordappPackages, BOB_KEY, BOC_KEY, DUMMY_NOTARY_KEY) {
                 override val vaultService = makeVaultService(database.hibernateConfig)
                 override fun recordTransactions(notifyVault: Boolean, txs: Iterable<SignedTransaction>) {
                     for (stx in txs) {
@@ -105,7 +105,6 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
     @After
     fun cleanUp() {
         database.close()
-        unsetCordappPackages()
     }
 
     private fun setUpDb() {
diff --git a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
index 00b66b30b9..d4391109e3 100644
--- a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
@@ -65,8 +65,7 @@ class FlowFrameworkTests {
 
     @Before
     fun start() {
-        setCordappPackages("net.corda.finance.contracts", "net.corda.testing.contracts")
-        mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin())
+        mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin(), cordappPackages = listOf("net.corda.finance.contracts", "net.corda.testing.contracts"))
         node1 = mockNet.createNode()
         node2 = mockNet.createNode()
 
@@ -87,7 +86,6 @@ class FlowFrameworkTests {
     fun cleanUp() {
         mockNet.stopNodes()
         receivedSessionMessages.clear()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
index 579f653018..f30063aac8 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
@@ -33,8 +33,7 @@ class NotaryServiceTests {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.testing.contracts")
-        mockNet = MockNetwork()
+        mockNet = MockNetwork(cordappPackages = listOf("net.corda.testing.contracts"))
         notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name, validating = false)
         clientNode = mockNet.createNode()
         mockNet.runNetwork() // Clear network map registration messages
@@ -45,7 +44,6 @@ class NotaryServiceTests {
     @After
     fun cleanUp() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
index 87410fecb8..740c51be74 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
@@ -33,8 +33,7 @@ class ValidatingNotaryServiceTests {
 
     @Before
     fun setup() {
-        setCordappPackages("net.corda.testing.contracts")
-        mockNet = MockNetwork()
+        mockNet = MockNetwork(cordappPackages = listOf("net.corda.testing.contracts"))
         notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         clientNode = mockNet.createNode()
         mockNet.runNetwork() // Clear network map registration messages
@@ -45,7 +44,6 @@ class ValidatingNotaryServiceTests {
     @After
     fun cleanUp() {
         mockNet.stopNodes()
-        unsetCordappPackages()
     }
 
     @Test
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
index 5250e7f500..4740ac776d 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
@@ -45,27 +45,30 @@ import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 
 class NodeVaultServiceTest : TestDependencyInjectionBase() {
+    companion object {
+        private val cordappPackages = listOf("net.corda.finance.contracts.asset")
+    }
+
     lateinit var services: MockServices
-    lateinit var issuerServices: MockServices
+    private lateinit var issuerServices: MockServices
     val vaultService get() = services.vaultService as NodeVaultService
     lateinit var database: CordaPersistence
 
     @Before
     fun setUp() {
-        setCordappPackages("net.corda.finance.contracts.asset")
         LogHelper.setLevel(NodeVaultService::class)
         val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(BOC_KEY, DUMMY_CASH_ISSUER_KEY),
-                customSchemas = setOf(CashSchemaV1))
+                customSchemas = setOf(CashSchemaV1),
+                cordappPackages = cordappPackages)
         database = databaseAndServices.first
         services = databaseAndServices.second
-        issuerServices = MockServices(DUMMY_CASH_ISSUER_KEY, BOC_KEY)
+        issuerServices = MockServices(cordappPackages, DUMMY_CASH_ISSUER_KEY, BOC_KEY)
     }
 
     @After
     fun tearDown() {
         database.close()
         LogHelper.reset(NodeVaultService::class)
-        unsetCordappPackages()
     }
 
     @Suspendable
@@ -440,8 +443,7 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
 
     @Test
     fun addNoteToTransaction() {
-        val megaCorpServices = MockServices(MEGA_CORP_KEY)
-
+        val megaCorpServices = MockServices(cordappPackages, MEGA_CORP_KEY)
         database.transaction {
             val freshKey = services.myInfo.chooseIdentity().owningKey
 
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
index 9e484833d6..56d6e90992 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
@@ -45,6 +45,9 @@ import java.time.temporal.ChronoUnit
 import java.util.*
 
 class VaultQueryTests : TestDependencyInjectionBase() {
+    companion object {
+        private val cordappPackages = listOf("net.corda.testing.contracts", "net.corda.finance.contracts")
+    }
 
     private lateinit var services: MockServices
     private lateinit var notaryServices: MockServices
@@ -59,23 +62,21 @@ class VaultQueryTests : TestDependencyInjectionBase() {
 
     @Before
     fun setUp() {
-        setCordappPackages("net.corda.testing.contracts", "net.corda.finance.contracts")
-
         // register additional identities
         identitySvc.verifyAndRegisterIdentity(CASH_NOTARY_IDENTITY)
         identitySvc.verifyAndRegisterIdentity(BOC_IDENTITY)
         val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(MEGA_CORP_KEY, DUMMY_NOTARY_KEY),
                 createIdentityService = { identitySvc },
-                customSchemas = setOf(CashSchemaV1, CommercialPaperSchemaV1, DummyLinearStateSchemaV1))
+                customSchemas = setOf(CashSchemaV1, CommercialPaperSchemaV1, DummyLinearStateSchemaV1),
+                cordappPackages = cordappPackages)
         database = databaseAndServices.first
         services = databaseAndServices.second
-        notaryServices = MockServices(DUMMY_NOTARY_KEY, DUMMY_CASH_ISSUER_KEY, BOC_KEY, MEGA_CORP_KEY)
+        notaryServices = MockServices(cordappPackages, DUMMY_NOTARY_KEY, DUMMY_CASH_ISSUER_KEY, BOC_KEY, MEGA_CORP_KEY)
     }
 
     @After
     fun tearDown() {
         database.close()
-        unsetCordappPackages()
     }
 
     /**
@@ -1490,18 +1491,16 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         // GBP issuer
         val gbpCashIssuerKey = entropyToKeyPair(BigInteger.valueOf(1001))
         val gbpCashIssuer = Party(CordaX500Name(organisation = "British Pounds Cash Issuer", locality = "London", country = "GB"), gbpCashIssuerKey.public).ref(1)
-        val gbpCashIssuerServices = MockServices(gbpCashIssuerKey)
+        val gbpCashIssuerServices = MockServices(cordappPackages, gbpCashIssuerKey)
         // USD issuer
         val usdCashIssuerKey = entropyToKeyPair(BigInteger.valueOf(1002))
         val usdCashIssuer = Party(CordaX500Name(organisation = "US Dollars Cash Issuer", locality = "New York", country = "US"), usdCashIssuerKey.public).ref(1)
-        val usdCashIssuerServices = MockServices(usdCashIssuerKey)
+        val usdCashIssuerServices = MockServices(cordappPackages, usdCashIssuerKey)
         // CHF issuer
         val chfCashIssuerKey = entropyToKeyPair(BigInteger.valueOf(1003))
         val chfCashIssuer = Party(CordaX500Name(organisation = "Swiss Francs Cash Issuer", locality = "Zurich", country = "CH"), chfCashIssuerKey.public).ref(1)
-        val chfCashIssuerServices = MockServices(chfCashIssuerKey)
-
+        val chfCashIssuerServices = MockServices(cordappPackages, chfCashIssuerKey)
         database.transaction {
-
             services.fillWithSomeTestCash(100.POUNDS, gbpCashIssuerServices, DUMMY_NOTARY, 1, 1, Random(0L), issuedBy = (gbpCashIssuer))
             services.fillWithSomeTestCash(100.DOLLARS, usdCashIssuerServices, DUMMY_NOTARY, 1, 1, Random(0L), issuedBy = (usdCashIssuer))
             services.fillWithSomeTestCash(100.SWISS_FRANCS, chfCashIssuerServices, DUMMY_NOTARY, 1, 1, Random(0L), issuedBy = (chfCashIssuer))
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
index 60e853d023..a42e13d55c 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
@@ -1,4 +1,4 @@
-package net.corda.node.services.vaultService
+package net.corda.node.services.vault
 
 import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.LinearState
@@ -34,6 +34,10 @@ import kotlin.test.assertEquals
 // TODO: Move this to the cash contract tests once mock services are further split up.
 
 class VaultWithCashTest : TestDependencyInjectionBase() {
+    companion object {
+        private val cordappPackages = listOf("net.corda.testing.contracts", "net.corda.finance.contracts.asset")
+    }
+
     lateinit var services: MockServices
     lateinit var issuerServices: MockServices
     val vaultService: VaultService get() = services.vaultService
@@ -42,22 +46,20 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
 
     @Before
     fun setUp() {
-        setCordappPackages("net.corda.testing.contracts", "net.corda.finance.contracts.asset")
-
         LogHelper.setLevel(VaultWithCashTest::class)
         val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(DUMMY_CASH_ISSUER_KEY, DUMMY_NOTARY_KEY),
-                customSchemas = setOf(CashSchemaV1))
+                customSchemas = setOf(CashSchemaV1),
+                cordappPackages = cordappPackages)
         database = databaseAndServices.first
         services = databaseAndServices.second
-        issuerServices = MockServices(DUMMY_CASH_ISSUER_KEY, MEGA_CORP_KEY)
-        notaryServices = MockServices(DUMMY_NOTARY_KEY)
+        issuerServices = MockServices(cordappPackages, DUMMY_CASH_ISSUER_KEY, MEGA_CORP_KEY)
+        notaryServices = MockServices(cordappPackages, DUMMY_NOTARY_KEY)
     }
 
     @After
     fun tearDown() {
         LogHelper.reset(VaultWithCashTest::class)
         database.close()
-        unsetCordappPackages()
     }
 
     @Test
@@ -81,7 +83,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
 
     @Test
     fun `issue and spend total correctly and irrelevant ignored`() {
-        val megaCorpServices = MockServices(MEGA_CORP_KEY)
+        val megaCorpServices = MockServices(cordappPackages, MEGA_CORP_KEY)
         val freshKey = services.keyManagementService.freshKey()
 
         val usefulTX =
diff --git a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
index 3af7044caa..4e9d129c26 100644
--- a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
+++ b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
@@ -14,7 +14,6 @@ import net.corda.finance.contracts.Fix
 import net.corda.finance.contracts.FixOf
 import net.corda.finance.contracts.asset.CASH
 import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.ownedBy
 import net.corda.irs.flows.RatesFixFlow
 import net.corda.node.utilities.CordaPersistence
 import net.corda.node.utilities.configureDatabase
@@ -63,7 +62,6 @@ class NodeInterestRatesTest : TestDependencyInjectionBase() {
 
     @Before
     fun setUp() {
-        setCordappPackages("net.corda.finance.contracts")
         database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), createIdentityService = ::makeTestIdentityService)
         database.transaction {
             oracle = createMockCordaService(services, NodeInterestRates::Oracle)
@@ -74,7 +72,6 @@ class NodeInterestRatesTest : TestDependencyInjectionBase() {
     @After
     fun tearDown() {
         database.close()
-        unsetCordappPackages()
     }
 
     @Test
@@ -203,7 +200,7 @@ class NodeInterestRatesTest : TestDependencyInjectionBase() {
 
     @Test
     fun `network tearoff`() {
-        val mockNet = MockNetwork(initialiseSerialization = false)
+        val mockNet = MockNetwork(initialiseSerialization = false, cordappPackages = listOf("net.corda.finance.contracts"))
         val n1 = mockNet.createNotaryNode()
         val oracleNode = mockNet.createNode().apply {
             internals.registerInitiatedFlow(NodeInterestRates.FixQueryHandler::class.java)
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
index 6c929c47b7..90a3ca2d8b 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
@@ -141,7 +141,7 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
         }
     }
 
-    val mockNet = MockNetwork(networkSendManuallyPumped, runAsync)
+    val mockNet = MockNetwork(networkSendManuallyPumped, runAsync, cordappPackages = listOf("net.corda.irs.contract", "net.corda.finance.contract"))
     // This one must come first.
     val networkMap = mockNet.startNetworkMapNode(nodeFactory = NetworkMapNodeFactory)
     val notary = mockNet.createNotaryNode(validating = false, nodeFactory = NotaryNodeFactory)
@@ -255,7 +255,6 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
     val networkInitialisationFinished = allOf(*mockNet.nodes.map { it.nodeReadyFuture.toCompletableFuture() }.toTypedArray())
 
     fun start(): Future<Unit> {
-        setCordappPackages("net.corda.irs.contract", "net.corda.finance.contract")
         mockNet.startNodes()
         // Wait for all the nodes to have finished registering with the network map service.
         return networkInitialisationFinished.thenCompose { startMainSimulation() }
diff --git a/samples/network-visualiser/src/test/kotlin/net/corda/netmap/simulation/IRSSimulationTest.kt b/samples/network-visualiser/src/test/kotlin/net/corda/netmap/simulation/IRSSimulationTest.kt
index 4bd32364a4..6da9d13091 100644
--- a/samples/network-visualiser/src/test/kotlin/net/corda/netmap/simulation/IRSSimulationTest.kt
+++ b/samples/network-visualiser/src/test/kotlin/net/corda/netmap/simulation/IRSSimulationTest.kt
@@ -2,25 +2,10 @@ package net.corda.netmap.simulation
 
 import net.corda.core.utilities.getOrThrow
 import net.corda.testing.LogHelper
-import net.corda.testing.setCordappPackages
-import net.corda.testing.unsetCordappPackages
-import org.junit.After
-import org.junit.Before
 import org.junit.Test
 
 class IRSSimulationTest {
     // TODO: These tests should be a lot more complete.
-
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.irs.contract")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun `runs to completion`() {
         LogHelper.setLevel("+messages") // FIXME: Don't manipulate static state in tests.
diff --git a/samples/simm-valuation-demo/src/integration-test/kotlin/net/corda/vega/SimmValuationTest.kt b/samples/simm-valuation-demo/src/integration-test/kotlin/net/corda/vega/SimmValuationTest.kt
index e113f235b7..87b9fa7839 100644
--- a/samples/simm-valuation-demo/src/integration-test/kotlin/net/corda/vega/SimmValuationTest.kt
+++ b/samples/simm-valuation-demo/src/integration-test/kotlin/net/corda/vega/SimmValuationTest.kt
@@ -11,8 +11,6 @@ import net.corda.vega.api.PortfolioApiUtils
 import net.corda.vega.api.SwapDataModel
 import net.corda.vega.api.SwapDataView
 import org.assertj.core.api.Assertions.assertThat
-import org.junit.After
-import org.junit.Before
 import org.junit.Test
 import java.math.BigDecimal
 import java.time.LocalDate
@@ -26,19 +24,9 @@ class SimmValuationTest : IntegrationTestCategory {
         val testTradeId = "trade1"
     }
 
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.vega.contracts")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
     @Test
     fun `runs SIMM valuation demo`() {
-        driver(isDebug = true) {
+        driver(isDebug = true, extraCordappPackagesToScan = listOf("net.corda.vega.contracts")) {
             startNotaryNode(DUMMY_NOTARY.name, validating = false).getOrThrow()
             val nodeAFuture = startNode(providedName = nodeALegalName)
             val nodeBFuture = startNode(providedName = nodeBLegalName)
diff --git a/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt b/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
index 0efa101ec7..6fb3556c25 100644
--- a/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
+++ b/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
@@ -17,23 +17,10 @@ import net.corda.traderdemo.flow.BuyerFlow
 import net.corda.traderdemo.flow.CommercialPaperIssueFlow
 import net.corda.traderdemo.flow.SellerFlow
 import org.assertj.core.api.Assertions.assertThat
-import org.junit.After
-import org.junit.Before
 import org.junit.Test
 import java.util.concurrent.Executors
 
-class TraderDemoTest : NodeBasedTest() {
-
-    @Before
-    fun setup() {
-        setCordappPackages("net.corda.finance.contracts.asset", "net.corda.finance.contracts")
-    }
-
-    @After
-    fun tearDown() {
-        unsetCordappPackages()
-    }
-
+class TraderDemoTest : NodeBasedTest(listOf("net.corda.finance.contracts.asset", "net.corda.finance.contracts")) {
     @Test
     fun `runs trader demo`() {
         val demoUser = User("demo", "demo", setOf(startFlowPermission<SellerFlow>()))
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt
index 7fe3ee5c09..551a8075b8 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/NodeTestUtils.kt
@@ -46,8 +46,9 @@ fun transaction(
         transactionLabel: String? = null,
         transactionBuilder: TransactionBuilder = TransactionBuilder(notary = DUMMY_NOTARY),
         initialiseSerialization: Boolean = true,
+        cordappPackages: List<String> = emptyList(),
         dsl: TransactionDSL<TransactionDSLInterpreter>.() -> EnforceVerifyOrFail
-) = ledger(initialiseSerialization = initialiseSerialization) {
+) = ledger(services = MockServices(cordappPackages), initialiseSerialization = initialiseSerialization) {
     dsl(TransactionDSL(TestTransactionDSLInterpreter(this.interpreter, transactionBuilder)))
 }
 
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
index 9a1ce481ca..0a8cf4ecbe 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
@@ -24,6 +24,7 @@ import net.corda.core.utilities.*
 import net.corda.node.internal.Node
 import net.corda.node.internal.NodeStartup
 import net.corda.node.internal.StartedNode
+import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.services.config.*
 import net.corda.node.services.network.NetworkMapService
 import net.corda.node.utilities.ServiceIdentityGenerator
@@ -511,7 +512,6 @@ class ShutdownManager(private val executorService: ExecutorService) {
     }
 
     fun shutdown() {
-        unsetCordappPackages()
         val shutdownActionFutures = state.locked {
             if (isShutdown) {
                 emptyList<CordaFuture<() -> Unit>>()
@@ -595,14 +595,14 @@ class DriverDSL(
         val isDebug: Boolean,
         val networkMapStartStrategy: NetworkMapStartStrategy,
         val startNodesInProcess: Boolean,
-        val extraCordappPackagesToScan: List<String>
+        extraCordappPackagesToScan: List<String>
 ) : DriverDSLInternalInterface {
     private val dedicatedNetworkMapAddress = portAllocation.nextHostAndPort()
     private var _executorService: ScheduledExecutorService? = null
     val executorService get() = _executorService!!
     private var _shutdownManager: ShutdownManager? = null
     override val shutdownManager get() = _shutdownManager!!
-    private val packagesToScanString = extraCordappPackagesToScan + getCallerPackage()
+    private val cordappPackages = extraCordappPackagesToScan + getCallerPackage()
 
     class State {
         val processes = ArrayList<CordaFuture<Process>>()
@@ -821,8 +821,6 @@ class DriverDSL(
     override fun start() {
         _executorService = Executors.newScheduledThreadPool(2, ThreadFactoryBuilder().setNameFormat("driver-pool-thread-%d").build())
         _shutdownManager = ShutdownManager(executorService)
-        // We set this property so that in-process nodes find cordapps. Out-of-process nodes need this passed in when started.
-        setCordappPackages(*packagesToScanString.toTypedArray())
         if (networkMapStartStrategy.startDedicated) {
             startDedicatedNetworkMapService().andForget(log) // Allow it to start concurrently with other nodes.
         }
@@ -859,7 +857,7 @@ class DriverDSL(
     private fun startNodeInternal(config: Config, webAddress: NetworkHostAndPort, startInProcess: Boolean?, maximumHeapSize: String): CordaFuture<NodeHandle> {
         val nodeConfiguration = config.parseAs<FullNodeConfiguration>()
         if (startInProcess ?: startNodesInProcess) {
-            val nodeAndThreadFuture = startInProcessNode(executorService, nodeConfiguration, config)
+            val nodeAndThreadFuture = startInProcessNode(executorService, nodeConfiguration, config, cordappPackages)
             shutdownManager.registerShutdown(
                     nodeAndThreadFuture.map { (node, thread) ->
                         {
@@ -877,7 +875,7 @@ class DriverDSL(
             }
         } else {
             val debugPort = if (isDebug) debugPortAllocation.nextPort() else null
-            val processFuture = startOutOfProcessNode(executorService, nodeConfiguration, config, quasarJarPath, debugPort, systemProperties, packagesToScanString.joinToString(","), maximumHeapSize)
+            val processFuture = startOutOfProcessNode(executorService, nodeConfiguration, config, quasarJarPath, debugPort, systemProperties, cordappPackages, maximumHeapSize)
             registerProcess(processFuture)
             return processFuture.flatMap { process ->
                 val processDeathFuture = poll(executorService, "process death") {
@@ -920,14 +918,15 @@ class DriverDSL(
         private fun startInProcessNode(
                 executorService: ScheduledExecutorService,
                 nodeConf: FullNodeConfiguration,
-                config: Config
+                config: Config,
+                cordappPackages: List<String>
         ): CordaFuture<Pair<StartedNode<Node>, Thread>> {
             return executorService.fork {
                 log.info("Starting in-process Node ${nodeConf.myLegalName.organisation}")
                 // Write node.conf
                 writeConfig(nodeConf.baseDirectory, "node.conf", config)
                 // TODO pass the version in?
-                val node = Node(nodeConf, MOCK_VERSION_INFO, initialiseSerialization = false).start()
+                val node = Node(nodeConf, MOCK_VERSION_INFO, initialiseSerialization = false, cordappLoader = CordappLoader.createDefaultWithTestPackages(nodeConf, cordappPackages)).start()
                 val nodeThread = thread(name = nodeConf.myLegalName.organisation) {
                     node.internals.run()
                 }
@@ -942,7 +941,7 @@ class DriverDSL(
                 quasarJarPath: String,
                 debugPort: Int?,
                 overriddenSystemProperties: Map<String, String>,
-                packagesToScanString: String,
+                cordappPackages: List<String>,
                 maximumHeapSize: String
         ): CordaFuture<Process> {
             val processFuture = executorService.fork {
@@ -953,7 +952,7 @@ class DriverDSL(
                 val systemProperties = overriddenSystemProperties + mapOf(
                         "name" to nodeConf.myLegalName,
                         "visualvm.display.name" to "corda-${nodeConf.myLegalName}",
-                        "net.corda.node.cordapp.scan.packages" to packagesToScanString,
+                        Node.scanPackagesSystemProperty to cordappPackages.joinToString(Node.scanPackagesSeparator),
                         "java.io.tmpdir" to System.getProperty("java.io.tmpdir") // Inherit from parent process
                 )
                 // See experimental/quasar-hook/README.md for how to generate.
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index 88824e118e..84dc90fe02 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -26,6 +26,7 @@ import net.corda.core.utilities.loggerFor
 import net.corda.finance.utils.WorldMapLocation
 import net.corda.node.internal.AbstractNode
 import net.corda.node.internal.StartedNode
+import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.services.api.NetworkMapCacheInternal
 import net.corda.node.services.api.SchemaService
 import net.corda.node.services.config.BFTSMaRtConfiguration
@@ -82,7 +83,8 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                   servicePeerAllocationStrategy: InMemoryMessagingNetwork.ServicePeerAllocationStrategy =
                   InMemoryMessagingNetwork.ServicePeerAllocationStrategy.Random(),
                   private val defaultFactory: Factory<*> = MockNetwork.DefaultFactory,
-                  private val initialiseSerialization: Boolean = true) : Closeable {
+                  private val initialiseSerialization: Boolean = true,
+                  private val cordappPackages: List<String> = emptyList()) : Closeable {
     companion object {
         // TODO In future PR we're removing the concept of network map node so the details of this mock are not important.
         val MOCK_NET_MAP = Party(CordaX500Name(organisation = "Mock Network Map", locality = "Madrid", country = "ES"), DUMMY_KEY_1.public)
@@ -160,7 +162,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
                         val id: Int,
                         internal val notaryIdentity: Pair<ServiceInfo, KeyPair>?,
                         val entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue())) :
-            AbstractNode(config, TestClock(), MOCK_VERSION_INFO, mockNet.busyLatch) {
+            AbstractNode(config, TestClock(), MOCK_VERSION_INFO, CordappLoader.createDefaultWithTestPackages(config, mockNet.cordappPackages), mockNet.busyLatch) {
         var counter = entropyRoot
         override val log: Logger = loggerFor<MockNode>()
         override val serverThread: AffinityExecutor =
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
index ae838119a2..47fd8589a3 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
@@ -167,9 +167,8 @@ open class MockServices(
             return NodeInfo(emptyList(), listOf(identity), 1, serial = 1L)
         }
     override val transactionVerifierService: TransactionVerifierService get() = InMemoryTransactionVerifierService(2)
-    val mockCordappProvider: MockCordappProvider = MockCordappProvider(CordappLoader.createWithTestPackages(cordappPackages + CordappLoader.testPackages)).start(attachments) as MockCordappProvider
-    override val cordappProvider: CordappProvider = mockCordappProvider
-
+    val mockCordappProvider = MockCordappProvider(CordappLoader.createWithTestPackages(cordappPackages)).start(attachments) as MockCordappProvider
+    override val cordappProvider: CordappProvider get() = mockCordappProvider
     lateinit var hibernatePersister: HibernateObserver
 
     fun makeVaultService(hibernateConfig: HibernateConfiguration = HibernateConfiguration(NodeSchemaService(), makeTestDatabaseProperties(), { identityService })): VaultServiceInternal {
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
index 3d4d4e9d63..36dfb43a45 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/NodeBasedTest.kt
@@ -9,6 +9,7 @@ import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.Node
 import net.corda.node.internal.StartedNode
+import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.services.config.*
 import net.corda.node.utilities.ServiceIdentityGenerator
 import net.corda.nodeapi.User
@@ -31,7 +32,7 @@ import kotlin.concurrent.thread
  * purposes. Use the driver if you need to run the nodes in separate processes otherwise this class will suffice.
  */
 // TODO Some of the logic here duplicates what's in the driver
-abstract class NodeBasedTest : TestDependencyInjectionBase() {
+abstract class NodeBasedTest(private val cordappPackages: List<String> = emptyList()) : TestDependencyInjectionBase() {
     companion object {
         private val WHITESPACE = "\\s++".toRegex()
     }
@@ -193,7 +194,8 @@ abstract class NodeBasedTest : TestDependencyInjectionBase() {
         val node = Node(
                 parsedConfig,
                 MOCK_VERSION_INFO.copy(platformVersion = platformVersion),
-                initialiseSerialization = false).start()
+                initialiseSerialization = false,
+                cordappLoader = CordappLoader.createDefaultWithTestPackages(parsedConfig, cordappPackages)).start()
         nodes += node
         thread(name = legalName.organisation) {
             node.internals.run()
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
index 4e20194249..385b195e04 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
@@ -17,7 +17,6 @@ import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.loggerFor
 import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER
-import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.services.config.configureDevKeyAndTrustStores
 import net.corda.node.services.identity.InMemoryIdentityService
 import net.corda.node.utilities.CertificateAndKeyPair
@@ -169,18 +168,3 @@ fun NodeInfo.chooseIdentityAndCert(): PartyAndCertificate = legalIdentitiesAndCe
 fun NodeInfo.chooseIdentity(): Party = chooseIdentityAndCert().party
 /** Returns the identity of the first notary found on the network */
 fun ServiceHub.getDefaultNotary(): Party = networkMapCache.notaryIdentities.first()
-
-/**
- * Set the package to scan for cordapps - this overrides the default behaviour of scanning the cordapps directory
- * @param packageNames A package name that you wish to scan for cordapps
- */
-fun setCordappPackages(vararg packageNames: String) {
-    CordappLoader.testPackages = packageNames.toList()
-}
-
-/**
- * Unsets the default overriding behaviour of [setCordappPackages]
- */
-fun unsetCordappPackages() {
-    CordappLoader.testPackages = emptyList()
-}
\ No newline at end of file

From ef0f0acc4a02b960d79648d61bf92e5022d99d65 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Wed, 11 Oct 2017 11:13:46 +0100
Subject: [PATCH 155/185] Make integration tests pass in AMQP mode, part 1
 (#1855)

---
 docs/source/serialization.rst                    |  9 +++++----
 .../amqp/SerializationOutputTests.kt             | 16 +++++++++++++++-
 .../corda/node/services/messaging/Messaging.kt   |  1 +
 .../services/messaging/NodeMessagingClient.kt    | 13 ++++++-------
 .../testing/node/InMemoryMessagingNetwork.kt     |  2 --
 5 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/docs/source/serialization.rst b/docs/source/serialization.rst
index 92d542dd71..b9eb1b7e78 100644
--- a/docs/source/serialization.rst
+++ b/docs/source/serialization.rst
@@ -63,7 +63,7 @@ The long term goal is to migrate the current serialization format for everything
     #.  A desire to support open-ended polymorphism, where the number of subclasses of a superclass can expand over time
         and do not need to be defined in the schema *upfront*, which is key to many Corda concepts, such as contract states.
     #.  Increased security from deserialized objects being constructed through supported constructors rather than having
-        data poked directy into their fields without an opportunity to validate consistency or intercept attempts to manipulate
+        data poked directly into their fields without an opportunity to validate consistency or intercept attempts to manipulate
         supposed invariants.
 
 Documentation on that format, and how JVM classes are translated to AMQP, will be linked here when it is available.
@@ -259,9 +259,10 @@ Kotlin Objects
 ``````````````
 
     #.  Kotlin ``object`` s are singletons and treated differently.  They are recorded into the stream with no properties
-        and deserialize back to the singleton instance.
-
-Currently, the same is not true of Java singletons, and they will deserialize to new instances of the class.
+        and deserialize back to the singleton instance. Currently, the same is not true of Java singletons,
+        and they will deserialize to new instances of the class.
+    #.  Kotlin's anonymous ``object`` s are not currently supported. I.e. constructs like:
+        ``object : Contract {...}`` will not serialize correctly and need to be re-written as an explicit class declaration.
 
 The Carpenter
 `````````````
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutputTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutputTests.kt
index 4b1011ad49..31136f0723 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutputTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutputTests.kt
@@ -534,8 +534,22 @@ class SerializationOutputTests {
         }
     }
 
-    val FOO_PROGRAM_ID = "net.corda.nodeapi.internal.serialization.amqp.SerializationOutputTests.FooContract"
+    @Test
+    fun `test custom object`() {
+        serdes(FooContract)
+    }
 
+    @Test
+    @Ignore("Cannot serialize due to known Kotlin/serialization limitation")
+    fun `test custom anonymous object`() {
+        val anonymous: Contract = object : Contract {
+            override fun verify(tx: LedgerTransaction) {
+            }
+        }
+        serdes(anonymous)
+    }
+
+    private val FOO_PROGRAM_ID = "net.corda.nodeapi.internal.serialization.amqp.SerializationOutputTests.FooContract"
     class FooState : ContractState {
         override val participants: List<AbstractParty> = emptyList()
     }
diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/Messaging.kt b/node/src/main/kotlin/net/corda/node/services/messaging/Messaging.kt
index b05dc10c02..a708166239 100644
--- a/node/src/main/kotlin/net/corda/node/services/messaging/Messaging.kt
+++ b/node/src/main/kotlin/net/corda/node/services/messaging/Messaging.kt
@@ -213,6 +213,7 @@ data class TopicSession(val topic: String, val sessionID: Long = MessagingServic
  * These IDs and timestamps should not be assumed to be globally unique, although due to the nanosecond precision of
  * the timestamp field they probably will be, even if an implementation just uses a hash prefix as the message id.
  */
+@CordaSerializable
 interface Message {
     val topicSession: TopicSession
     val data: ByteArray
diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/NodeMessagingClient.kt b/node/src/main/kotlin/net/corda/node/services/messaging/NodeMessagingClient.kt
index 02ee5500ec..5a9cd04730 100644
--- a/node/src/main/kotlin/net/corda/node/services/messaging/NodeMessagingClient.kt
+++ b/node/src/main/kotlin/net/corda/node/services/messaging/NodeMessagingClient.kt
@@ -133,6 +133,11 @@ class NodeMessagingClient(override val config: NodeConfiguration,
                     persistentEntityClass = RetryMessage::class.java
             )
         }
+
+        private class NodeClientMessage(override val topicSession: TopicSession, override val data: ByteArray, override val uniqueMessageId: UUID) : Message {
+            override val debugTimestamp: Instant = Instant.now()
+            override fun toString() = "$topicSession#${String(data)}"
+        }
     }
 
     private class InnerState {
@@ -599,13 +604,7 @@ class NodeMessagingClient(override val config: NodeConfiguration,
 
     override fun createMessage(topicSession: TopicSession, data: ByteArray, uuid: UUID): Message {
         // TODO: We could write an object that proxies directly to an underlying MQ message here and avoid copying.
-        return object : Message {
-            override val topicSession: TopicSession = topicSession
-            override val data: ByteArray = data
-            override val debugTimestamp: Instant = Instant.now()
-            override val uniqueMessageId: UUID = uuid
-            override fun toString() = "$topicSession#${String(data)}"
-        }
+        return NodeClientMessage(topicSession, data, uuid)
     }
 
     private fun createOutOfProcessVerifierService(): TransactionVerifierService {
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/InMemoryMessagingNetwork.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/InMemoryMessagingNetwork.kt
index 4be46a59f5..a44cf1c4a5 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/InMemoryMessagingNetwork.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/InMemoryMessagingNetwork.kt
@@ -279,7 +279,6 @@ class InMemoryMessagingNetwork(
         _sentMessages.onNext(transfer)
     }
 
-    @CordaSerializable
     private data class InMemoryMessage(override val topicSession: TopicSession,
                                        override val data: ByteArray,
                                        override val uniqueMessageId: UUID,
@@ -287,7 +286,6 @@ class InMemoryMessagingNetwork(
         override fun toString() = "$topicSession#${String(data)}"
     }
 
-    @CordaSerializable
     private data class InMemoryReceivedMessage(override val topicSession: TopicSession,
                                                override val data: ByteArray,
                                                override val platformVersion: Int,

From 9cec137a31fd3b3bac014c6b62d4196baad8605d Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Wed, 11 Oct 2017 11:17:14 +0100
Subject: [PATCH 156/185] CORDA-702: Don't whitelist certain non-annotated
 types (#1864)

* Don't whitelist arrays of non-serialisable types for RPC.
* Don't whitelist enums which have not been annotated as serialisable.
---
 .../serialization/CordaClassResolver.kt       |  5 ++-
 .../serialization/CordaClassResolverTests.kt  | 40 ++++++++++++++++++-
 2 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
index 04c43122ec..97c50dcd67 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolver.kt
@@ -57,12 +57,13 @@ class CordaClassResolver(serializationContext: SerializationContext) : DefaultCl
     private fun checkClass(type: Class<*>): Registration? {
         // If call path has disabled whitelisting (see [CordaKryo.register]), just return without checking.
         if (!whitelistEnabled) return null
-        // Allow primitives, abstracts and interfaces
-        if (type.isPrimitive || type == Any::class.java || isAbstract(type.modifiers) || type == String::class.java) return null
         // If array, recurse on element type
         if (type.isArray) return checkClass(type.componentType)
         // Specialised enum entry, so just resolve the parent Enum type since cannot annotate the specialised entry.
         if (!type.isEnum && Enum::class.java.isAssignableFrom(type)) return checkClass(type.superclass)
+        // Allow primitives, abstracts and interfaces. Note that we can also create abstract Enum types,
+        // but we don't want to whitelist those here.
+        if (type.isPrimitive || type == Any::class.java || type == String::class.java || (!type.isEnum && isAbstract(type.modifiers))) return null
         // It's safe to have the Class already, since Kryo loads it with initialisation off.
         // If we use a whitelist with blacklisting capabilities, whitelist.hasListed(type) may throw an IllegalStateException if input class is blacklisted.
         // Thus, blacklisting precedes annotation checking.
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolverTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolverTests.kt
index 74a3d574ae..e684ef1f29 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolverTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolverTests.kt
@@ -34,6 +34,23 @@ enum class Foo {
     abstract val value: Int
 }
 
+enum class BadFood {
+    Mud {
+        override val value = -1
+    };
+
+    abstract val value: Int
+}
+
+@CordaSerializable
+enum class Simple {
+    Easy
+}
+
+enum class BadSimple {
+    Nasty
+}
+
 @CordaSerializable
 open class Element
 
@@ -106,17 +123,36 @@ class CordaClassResolverTests {
 
     @Test
     fun `Annotation on enum works for specialised entries`() {
-        // TODO: Remove this suppress when we upgrade to kotlin 1.1 or when JetBrain fixes the bug.
-        @Suppress("UNSUPPORTED_FEATURE")
         CordaClassResolver(emptyWhitelistContext).getRegistration(Foo.Bar::class.java)
     }
 
+    @Test(expected = KryoException::class)
+    fun `Unannotated specialised enum does not work`() {
+        CordaClassResolver(emptyWhitelistContext).getRegistration(BadFood.Mud::class.java)
+    }
+
+    @Test
+    fun `Annotation on simple enum works`() {
+        CordaClassResolver(emptyWhitelistContext).getRegistration(Simple.Easy::class.java)
+    }
+
+    @Test(expected = KryoException::class)
+    fun `Unannotated simple enum does not work`() {
+        CordaClassResolver(emptyWhitelistContext).getRegistration(BadSimple.Nasty::class.java)
+    }
+
     @Test
     fun `Annotation on array element works`() {
         val values = arrayOf(Element())
         CordaClassResolver(emptyWhitelistContext).getRegistration(values.javaClass)
     }
 
+    @Test(expected = KryoException::class)
+    fun `Unannotated array elements do not work`() {
+        val values = arrayOf(NotSerializable())
+        CordaClassResolver(emptyWhitelistContext).getRegistration(values.javaClass)
+    }
+
     @Test
     fun `Annotation not needed on abstract class`() {
         CordaClassResolver(emptyWhitelistContext).getRegistration(AbstractClass::class.java)

From 15d29d79824a177cb6acc7ee86f2c3e79ec4ecaf Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Wed, 11 Oct 2017 12:41:11 +0100
Subject: [PATCH 157/185] Fixed the dozens of artifactory warnings at gradle
 initialisation. (#1862)

* Fixed the dozens of artifactory warnings at gradle initialisation.
---
 build.gradle                                              | 8 ++++++--
 constants.properties                                      | 2 +-
 .../net/corda/plugins/ProjectPublishExtension.groovy      | 7 +++++++
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/build.gradle b/build.gradle
index 31740da52f..ca5904ba95 100644
--- a/build.gradle
+++ b/build.gradle
@@ -293,12 +293,16 @@ artifactory {
     publish {
         contextUrl = 'https://ci-artifactory.corda.r3cev.com/artifactory'
         repository {
-            repoKey = 'corda-releases'
+            repoKey = 'corda-dev'
             username = 'teamcity'
             password = System.getenv('CORDA_ARTIFACTORY_PASSWORD')
         }
+
         defaults {
-            publications('corda-jfx', 'corda-mock', 'corda-rpc', 'corda-core', 'corda', 'cordform-common', 'corda-finance', 'corda-node', 'corda-node-api', 'corda-test-common', 'corda-test-utils', 'corda-jackson', 'corda-verifier', 'corda-webserver-impl', 'corda-webserver', 'corda-node-driver', 'corda-confidential-identities')
+            // Root project applies the plugin (for this block) but does not need to be published
+            if(project != rootProject) {
+                publications(project.extensions.publish.name())
+            }
         }
     }
 }
diff --git a/constants.properties b/constants.properties
index f0fbe73c08..deebebf5d5 100644
--- a/constants.properties
+++ b/constants.properties
@@ -1,4 +1,4 @@
-gradlePluginsVersion=2.0.2
+gradlePluginsVersion=2.0.3
 kotlinVersion=1.1.50
 guavaVersion=21.0
 bouncycastleVersion=1.57
diff --git a/gradle-plugins/publish-utils/src/main/groovy/net/corda/plugins/ProjectPublishExtension.groovy b/gradle-plugins/publish-utils/src/main/groovy/net/corda/plugins/ProjectPublishExtension.groovy
index ee978bdbb8..97029028e3 100644
--- a/gradle-plugins/publish-utils/src/main/groovy/net/corda/plugins/ProjectPublishExtension.groovy
+++ b/gradle-plugins/publish-utils/src/main/groovy/net/corda/plugins/ProjectPublishExtension.groovy
@@ -15,6 +15,13 @@ class ProjectPublishExtension {
         task.setPublishName(name)
     }
 
+    /**
+     * Get the publishing name for this project.
+     */
+    String name() {
+        return task.getPublishName()
+    }
+
     /**
      * True when we do not want to publish default Java components
      */

From d0d0f132df43e1a550c154003db52e76580d3489 Mon Sep 17 00:00:00 2001
From: Alberto Arri <30873160+al-r3@users.noreply.github.com>
Date: Wed, 11 Oct 2017 12:54:30 +0100
Subject: [PATCH 158/185] Create nodeInfoDirectory in NodeInfoWatcher
 initialization, and make NodeInfoWatcher logging less verbose and less
 frequent (#1857)

Let NodeInfoWatcher create the directory it wants to poll at startup.
Also log failure in creating the directory, but don't log anything if it can be found at poll time.
---
 .../services/network/NodeInfoWatcherTest.kt   |  7 ++---
 .../node/services/network/NodeInfoWatcher.kt  | 27 +++++++++++++------
 2 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
index 0f102a5e79..97e2deb364 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt
@@ -56,11 +56,12 @@ class NodeInfoWatcherTest : NodeBasedTest() {
 
     @Test
     fun `save a NodeInfo`() {
-        assertEquals(0, folder.root.list().size)
+        assertEquals(0, folder.root.list().filter { it.matches(nodeInfoFileRegex) }.size)
         NodeInfoWatcher.saveToFile(folder.root.toPath(), nodeInfo, keyManagementService)
 
-        assertEquals(1, folder.root.list().size)
-        val fileName = folder.root.list()[0]
+        val nodeInfoFiles = folder.root.list().filter { it.matches(nodeInfoFileRegex) }
+        assertEquals(1, nodeInfoFiles.size)
+        val fileName = nodeInfoFiles.first()
         assertTrue(fileName.matches(nodeInfoFileRegex))
         val file = (folder.root.path / fileName).toFile()
         // Just check that something is written, another tests verifies that the written value can be read back.
diff --git a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
index aefd79c2d1..65ef358c6d 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/NodeInfoWatcher.kt
@@ -12,6 +12,7 @@ import net.corda.core.utilities.seconds
 import rx.Observable
 import rx.Scheduler
 import rx.schedulers.Schedulers
+import java.io.IOException
 import java.nio.file.Path
 import java.util.concurrent.TimeUnit
 import kotlin.streams.toList
@@ -32,7 +33,8 @@ class NodeInfoWatcher(private val nodePath: Path,
                       private val scheduler: Scheduler = Schedulers.io()) {
 
     private val nodeInfoDirectory = nodePath / CordformNode.NODE_INFO_DIRECTORY
-    private val pollFrequencyMsec: Long
+    private val pollFrequencyMsec: Long = maxOf(pollFrequencyMsec, 5.seconds.toMillis())
+    private val successfullyProcessedFiles = mutableSetOf<Path>()
 
     companion object {
         private val logger = loggerFor<NodeInfoWatcher>()
@@ -61,7 +63,13 @@ class NodeInfoWatcher(private val nodePath: Path,
     }
 
     init {
-        this.pollFrequencyMsec = maxOf(pollFrequencyMsec, 5.seconds.toMillis())
+        if (!nodeInfoDirectory.isDirectory()) {
+            try {
+                nodeInfoDirectory.createDirectories()
+            } catch (e: IOException) {
+                logger.info("Failed to create $nodeInfoDirectory", e)
+            }
+        }
     }
 
     /**
@@ -71,8 +79,7 @@ class NodeInfoWatcher(private val nodePath: Path,
      * We simply list the directory content every 5 seconds, the Java implementation of WatchService has been proven to
      * be unreliable on MacOs and given the fairly simple use case we have, this simple implementation should do.
      *
-     * @return an [Observable] returning [NodeInfo]s, there is no guarantee that the same value isn't returned more
-     *      than once.
+     * @return an [Observable] returning [NodeInfo]s, at most one [NodeInfo] is returned for each processed file.
      */
     fun nodeInfoUpdates(): Observable<NodeInfo> {
         return Observable.interval(pollFrequencyMsec, TimeUnit.MILLISECONDS, scheduler)
@@ -87,16 +94,20 @@ class NodeInfoWatcher(private val nodePath: Path,
      */
     private fun loadFromDirectory(): List<NodeInfo> {
         if (!nodeInfoDirectory.isDirectory()) {
-            logger.info("$nodeInfoDirectory isn't a Directory, not loading NodeInfo from files")
             return emptyList()
         }
         val result = nodeInfoDirectory.list { paths ->
-            paths.filter { it.isRegularFile() }
-                    .map { processFile(it) }
+            paths.filter { it !in successfullyProcessedFiles }
+                    .filter { it.isRegularFile() }
+                    .map { path ->
+                        processFile(path)?.apply { successfullyProcessedFiles.add(path) }
+                    }
                     .toList()
                     .filterNotNull()
         }
-        logger.info("Successfully read ${result.size} NodeInfo files.")
+        if (result.isNotEmpty()) {
+            logger.info("Successfully read ${result.size} NodeInfo files from disk.")
+        }
         return result
     }
 

From 3fdc69e54199b9eedddc82b597c95c73870cc998 Mon Sep 17 00:00:00 2001
From: Rick Parker <rick.parker@r3.com>
Date: Wed, 11 Oct 2017 14:33:20 +0100
Subject: [PATCH 159/185] Fix coin selection with Flow-friendly sleep (#1847)

---
 .../kotlin/net/corda/core/flows/FlowLogic.kt  |  31 ++++
 .../corda/core/internal/FlowStateMachine.kt   |   5 +
 docs/source/changelog.rst                     |   6 +
 finance/build.gradle                          |   3 +
 .../cash/selection/CashSelectionH2Impl.kt     | 147 +++++++++---------
 .../contracts/asset/CashSelectionH2Test.kt    |  40 +++++
 .../services/statemachine/FlowIORequest.kt    |   6 +
 .../statemachine/FlowStateMachineImpl.kt      |  38 ++---
 .../statemachine/StateMachineManager.kt       |   6 +
 .../net/corda/node/InteractiveShellTest.kt    |   4 +-
 10 files changed, 191 insertions(+), 95 deletions(-)
 create mode 100644 finance/src/test/kotlin/net/corda/finance/contracts/asset/CashSelectionH2Test.kt

diff --git a/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt b/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
index 419c918753..0239c81f20 100644
--- a/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
+++ b/core/src/main/kotlin/net/corda/core/flows/FlowLogic.kt
@@ -1,6 +1,7 @@
 package net.corda.core.flows
 
 import co.paralleluniverse.fibers.Suspendable
+import co.paralleluniverse.strands.Strand
 import net.corda.core.crypto.SecureHash
 import net.corda.core.identity.Party
 import net.corda.core.identity.PartyAndCertificate
@@ -16,6 +17,8 @@ import net.corda.core.utilities.ProgressTracker
 import net.corda.core.utilities.UntrustworthyData
 import net.corda.core.utilities.debug
 import org.slf4j.Logger
+import java.time.Duration
+import java.time.Instant
 
 /**
  * A sub-class of [FlowLogic<T>] implements a flow using direct, straight line blocking code. Thus you
@@ -43,6 +46,34 @@ abstract class FlowLogic<out T> {
     /** This is where you should log things to. */
     val logger: Logger get() = stateMachine.logger
 
+    companion object {
+        /**
+         * Return the outermost [FlowLogic] instance, or null if not in a flow.
+         */
+        @JvmStatic
+        val currentTopLevel: FlowLogic<*>? get() = (Strand.currentStrand() as? FlowStateMachine<*>)?.logic
+
+        /**
+         * If on a flow, suspends the flow and only wakes it up after at least [duration] time has passed.  Otherwise,
+         * just sleep for [duration].  This sleep function is not designed to aid scheduling, for which you should
+         * consider using [SchedulableState].  It is designed to aid with managing contention for which you have not
+         * managed via another means.
+         *
+         * Warning: long sleeps and in general long running flows are highly discouraged, as there is currently no
+         * support for flow migration! This method will throw an exception if you attempt to sleep for longer than
+         * 5 minutes.
+         */
+        @Suspendable
+        @JvmStatic
+        @Throws(FlowException::class)
+        fun sleep(duration: Duration) {
+            if (duration.compareTo(Duration.ofMinutes(5)) > 0) {
+                throw FlowException("Attempt to sleep for longer than 5 minutes is not supported.  Consider using SchedulableState.")
+            }
+            (Strand.currentStrand() as? FlowStateMachine<*>)?.sleepUntil(Instant.now() + duration) ?: Strand.sleep(duration.toMillis())
+        }
+    }
+
     /**
      * Returns a wrapped [java.util.UUID] object that identifies this state machine run (i.e. subflows have the same
      * identifier as their parents).
diff --git a/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt b/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt
index 261af49f02..a2b0e2fd15 100644
--- a/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt
@@ -10,6 +10,7 @@ import net.corda.core.node.ServiceHub
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.utilities.UntrustworthyData
 import org.slf4j.Logger
+import java.time.Instant
 
 /** This is an internal interface that is implemented by code in the node module. You should look at [FlowLogic]. */
 interface FlowStateMachine<R> {
@@ -35,6 +36,9 @@ interface FlowStateMachine<R> {
     @Suspendable
     fun waitForLedgerCommit(hash: SecureHash, sessionFlow: FlowLogic<*>): SignedTransaction
 
+    @Suspendable
+    fun sleepUntil(until: Instant)
+
     fun checkFlowPermission(permissionName: String, extraAuditData: Map<String, String>)
 
     fun recordAuditEvent(eventType: String, comment: String, extraAuditData: Map<String, String>)
@@ -45,6 +49,7 @@ interface FlowStateMachine<R> {
     @Suspendable
     fun persistFlowStackSnapshot(flowClass: Class<out FlowLogic<*>>)
 
+    val logic: FlowLogic<R>
     val serviceHub: ServiceHub
     val logger: Logger
     val id: StateMachineRunId
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index 8b17db03ac..0931e57561 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -36,6 +36,12 @@ UNRELEASED
 * Cordformation node building DSL can have an additional parameter `configFile` with the path to a properties file
   to be appended to node.conf.
 
+* ``FlowLogic`` now has a static method called ``sleep`` which can be used in certain circumstances to help with resolving
+  contention over states in flows.  This should be used in place of any other sleep primitive since these are not compatible
+  with flows and their use will be prevented at some point in the future.  Pay attention to the warnings and limitations
+  described in the documentation for this method.  This helps resolve a bug in ``Cash`` coin selection.
+  A new static property `currentTopLevel` returns the top most `FlowLogic` instance, or null if not in a flow.
+
 * ``CordaService`` annotated classes should be upgraded to take a constructor parameter of type ``AppServiceHub`` which
   allows services to start flows marked with the ``StartableByService`` annotation. For backwards compatability
   service classes with only ``ServiceHub`` constructors will still work.
diff --git a/finance/build.gradle b/finance/build.gradle
index c642969785..662e7c9aa5 100644
--- a/finance/build.gradle
+++ b/finance/build.gradle
@@ -32,6 +32,9 @@ dependencies {
     testCompile project(':test-utils')
     testCompile project(path: ':core', configuration: 'testArtifacts')
     testCompile "junit:junit:$junit_version"
+
+    // AssertJ: for fluent assertions for testing
+    testCompile "org.assertj:assertj-core:$assertj_version"
 }
 
 configurations {
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
index a447827205..8be96121c8 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
@@ -1,12 +1,12 @@
 package net.corda.finance.contracts.asset.cash.selection
 
 import co.paralleluniverse.fibers.Suspendable
-import co.paralleluniverse.strands.Strand
 import net.corda.core.contracts.Amount
 import net.corda.core.contracts.StateAndRef
 import net.corda.core.contracts.StateRef
 import net.corda.core.contracts.TransactionState
 import net.corda.core.crypto.SecureHash
+import net.corda.core.flows.FlowLogic
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.Party
 import net.corda.core.node.ServiceHub
@@ -34,8 +34,9 @@ class CashSelectionH2Impl : CashSelection {
     }
 
     // coin selection retry loop counter, sleep (msecs) and lock for selecting states
-    private val MAX_RETRIES = 5
+    private val MAX_RETRIES = 8
     private val RETRY_SLEEP = 100
+    private val RETRY_CAP = 2000
     private val spendLock: ReentrantLock = ReentrantLock()
 
     /**
@@ -73,78 +74,84 @@ class CashSelectionH2Impl : CashSelection {
         //       3) H2 does not support JOIN's in FOR UPDATE (hence we are forced to execute 2 queries)
 
         for (retryCount in 1..MAX_RETRIES) {
-
-            spendLock.withLock {
-                val statement = services.jdbcSession().createStatement()
-                try {
-                    statement.execute("CALL SET(@t, CAST(0 AS BIGINT));")
-
-                    // we select spendable states irrespective of lock but prioritised by unlocked ones (Eg. null)
-                    // the softLockReserve update will detect whether we try to lock states locked by others
-                    val selectJoin = """
-                    SELECT vs.transaction_id, vs.output_index, vs.contract_state, ccs.pennies, SET(@t, ifnull(@t,0)+ccs.pennies) total_pennies, vs.lock_id
-                    FROM vault_states AS vs, contract_cash_states AS ccs
-                    WHERE vs.transaction_id = ccs.transaction_id AND vs.output_index = ccs.output_index
-                    AND vs.state_status = 0
-                    AND ccs.ccy_code = '${amount.token}' and @t < ${amount.quantity}
-                    AND (vs.lock_id = '$lockId' OR vs.lock_id is null)
-                    """ +
-                            (if (notary != null)
-                                " AND vs.notary_name = '${notary.name}'" else "") +
-                            (if (onlyFromIssuerParties.isNotEmpty())
-                                " AND ccs.issuer_key IN ($issuerKeysStr)" else "") +
-                            (if (withIssuerRefs.isNotEmpty())
-                                " AND ccs.issuer_ref IN ($issuerRefsStr)" else "")
-
-                    // Retrieve spendable state refs
-                    val rs = statement.executeQuery(selectJoin)
+            if (!attemptSpend(services, amount, lockId, notary, onlyFromIssuerParties, issuerKeysStr, withIssuerRefs, issuerRefsStr, stateAndRefs)) {
+                log.warn("Coin selection failed on attempt $retryCount")
+                // TODO: revisit the back off strategy for contended spending.
+                if (retryCount != MAX_RETRIES) {
                     stateAndRefs.clear()
-                    log.debug(selectJoin)
-                    var totalPennies = 0L
-                    while (rs.next()) {
-                        val txHash = SecureHash.parse(rs.getString(1))
-                        val index = rs.getInt(2)
-                        val stateRef = StateRef(txHash, index)
-                        val state = rs.getBytes(3).deserialize<TransactionState<Cash.State>>(context = SerializationDefaults.STORAGE_CONTEXT)
-                        val pennies = rs.getLong(4)
-                        totalPennies = rs.getLong(5)
-                        val rowLockId = rs.getString(6)
-                        stateAndRefs.add(StateAndRef(state, stateRef))
-                        log.trace { "ROW: $rowLockId ($lockId): $stateRef : $pennies ($totalPennies)" }
-                    }
-
-                    if (stateAndRefs.isNotEmpty() && totalPennies >= amount.quantity) {
-                        // we should have a minimum number of states to satisfy our selection `amount` criteria
-                        log.trace("Coin selection for $amount retrieved ${stateAndRefs.count()} states totalling $totalPennies pennies: $stateAndRefs")
-
-                        // With the current single threaded state machine available states are guaranteed to lock.
-                        // TODO However, we will have to revisit these methods in the future multi-threaded.
-                        services.vaultService.softLockReserve(lockId, (stateAndRefs.map { it.ref }).toNonEmptySet())
-                        return stateAndRefs
-                    }
-                    log.trace("Coin selection requested $amount but retrieved $totalPennies pennies with state refs: ${stateAndRefs.map { it.ref }}")
-                    // retry as more states may become available
-                } catch (e: SQLException) {
-                    log.error("""Failed retrieving unconsumed states for: amount [$amount], onlyFromIssuerParties [$onlyFromIssuerParties], notary [$notary], lockId [$lockId]
-                        $e.
-                    """)
-                } catch (e: StatesNotAvailableException) { // Should never happen with single threaded state machine
-                    stateAndRefs.clear()
-                    log.warn(e.message)
-                    // retry only if there are locked states that may become available again (or consumed with change)
-                } finally {
-                    statement.close()
+                    val durationMillis = (minOf(RETRY_SLEEP.shl(retryCount), RETRY_CAP / 2) * (1.0 + Math.random())).toInt()
+                    FlowLogic.sleep(durationMillis.millis)
+                } else {
+                    log.warn("Insufficient spendable states identified for $amount")
                 }
-            }
-
-            log.warn("Coin selection failed on attempt $retryCount")
-            // TODO: revisit the back off strategy for contended spending.
-            if (retryCount != MAX_RETRIES) {
-                Strand.sleep(RETRY_SLEEP * retryCount.toLong())
+            } else {
+                break
             }
         }
-
-        log.warn("Insufficient spendable states identified for $amount")
         return stateAndRefs
     }
+
+    private fun attemptSpend(services: ServiceHub, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, issuerKeysStr: String, withIssuerRefs: Set<OpaqueBytes>, issuerRefsStr: String, stateAndRefs: MutableList<StateAndRef<Cash.State>>): Boolean {
+        spendLock.withLock {
+            val statement = services.jdbcSession().createStatement()
+            try {
+                statement.execute("CALL SET(@t, CAST(0 AS BIGINT));")
+
+                // we select spendable states irrespective of lock but prioritised by unlocked ones (Eg. null)
+                // the softLockReserve update will detect whether we try to lock states locked by others
+                val selectJoin = """
+                        SELECT vs.transaction_id, vs.output_index, vs.contract_state, ccs.pennies, SET(@t, ifnull(@t,0)+ccs.pennies) total_pennies, vs.lock_id
+                        FROM vault_states AS vs, contract_cash_states AS ccs
+                        WHERE vs.transaction_id = ccs.transaction_id AND vs.output_index = ccs.output_index
+                        AND vs.state_status = 0
+                        AND ccs.ccy_code = '${amount.token}' and @t < ${amount.quantity}
+                        AND (vs.lock_id = '$lockId' OR vs.lock_id is null)
+                        """ +
+                        (if (notary != null)
+                            " AND vs.notary_name = '${notary.name}'" else "") +
+                        (if (onlyFromIssuerParties.isNotEmpty())
+                            " AND ccs.issuer_key IN ($issuerKeysStr)" else "") +
+                        (if (withIssuerRefs.isNotEmpty())
+                            " AND ccs.issuer_ref IN ($issuerRefsStr)" else "")
+
+                // Retrieve spendable state refs
+                val rs = statement.executeQuery(selectJoin)
+                log.debug(selectJoin)
+                var totalPennies = 0L
+                while (rs.next()) {
+                    val txHash = SecureHash.parse(rs.getString(1))
+                    val index = rs.getInt(2)
+                    val stateRef = StateRef(txHash, index)
+                    val state = rs.getBytes(3).deserialize<TransactionState<Cash.State>>(context = SerializationDefaults.STORAGE_CONTEXT)
+                    val pennies = rs.getLong(4)
+                    totalPennies = rs.getLong(5)
+                    val rowLockId = rs.getString(6)
+                    stateAndRefs.add(StateAndRef(state, stateRef))
+                    log.trace { "ROW: $rowLockId ($lockId): $stateRef : $pennies ($totalPennies)" }
+                }
+
+                if (stateAndRefs.isNotEmpty() && totalPennies >= amount.quantity) {
+                    // we should have a minimum number of states to satisfy our selection `amount` criteria
+                    log.trace("Coin selection for $amount retrieved ${stateAndRefs.count()} states totalling $totalPennies pennies: $stateAndRefs")
+
+                    // With the current single threaded state machine available states are guaranteed to lock.
+                    // TODO However, we will have to revisit these methods in the future multi-threaded.
+                    services.vaultService.softLockReserve(lockId, (stateAndRefs.map { it.ref }).toNonEmptySet())
+                    return true
+                }
+                log.trace("Coin selection requested $amount but retrieved $totalPennies pennies with state refs: ${stateAndRefs.map { it.ref }}")
+                // retry as more states may become available
+            } catch (e: SQLException) {
+                log.error("""Failed retrieving unconsumed states for: amount [$amount], onlyFromIssuerParties [$onlyFromIssuerParties], notary [$notary], lockId [$lockId]
+                            $e.
+                        """)
+            } catch (e: StatesNotAvailableException) { // Should never happen with single threaded state machine
+                log.warn(e.message)
+                // retry only if there are locked states that may become available again (or consumed with change)
+            } finally {
+                statement.close()
+            }
+        }
+        return false
+    }
 }
\ No newline at end of file
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashSelectionH2Test.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashSelectionH2Test.kt
new file mode 100644
index 0000000000..ef85dead0a
--- /dev/null
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashSelectionH2Test.kt
@@ -0,0 +1,40 @@
+package net.corda.finance.contracts.asset
+
+import net.corda.core.utilities.getOrThrow
+import net.corda.finance.DOLLARS
+import net.corda.finance.flows.CashException
+import net.corda.finance.flows.CashPaymentFlow
+import net.corda.testing.chooseIdentity
+import net.corda.testing.node.MockNetwork
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.Test
+
+
+class CashSelectionH2Test {
+
+    @Test
+    fun `check does not hold connection over retries`() {
+        val mockNet = MockNetwork(threadPerNode = true)
+        try {
+            val notaryNode = mockNet.createNotaryNode()
+            val bankA = mockNet.createNode(configOverrides = { existingConfig ->
+                // Tweak connections to be minimal to make this easier (1 results in a hung node during start up, so use 2 connections).
+                existingConfig.dataSourceProperties.setProperty("maximumPoolSize", "2")
+                existingConfig
+            })
+
+            mockNet.startNodes()
+
+            // Start more cash spends than we have connections.  If spend leaks a connection on retry, we will run out of connections.
+            val flow1 = bankA.services.startFlow(CashPaymentFlow(amount = 100.DOLLARS, anonymous = false, recipient = notaryNode.info.chooseIdentity()))
+            val flow2 = bankA.services.startFlow(CashPaymentFlow(amount = 100.DOLLARS, anonymous = false, recipient = notaryNode.info.chooseIdentity()))
+            val flow3 = bankA.services.startFlow(CashPaymentFlow(amount = 100.DOLLARS, anonymous = false, recipient = notaryNode.info.chooseIdentity()))
+
+            assertThatThrownBy { flow1.resultFuture.getOrThrow() }.isInstanceOf(CashException::class.java)
+            assertThatThrownBy { flow2.resultFuture.getOrThrow() }.isInstanceOf(CashException::class.java)
+            assertThatThrownBy { flow3.resultFuture.getOrThrow() }.isInstanceOf(CashException::class.java)
+        } finally {
+            mockNet.stopNodes()
+        }
+    }
+}
\ No newline at end of file
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowIORequest.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowIORequest.kt
index cd56d786ad..bd29525072 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowIORequest.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowIORequest.kt
@@ -2,6 +2,7 @@ package net.corda.node.services.statemachine
 
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.crypto.SecureHash
+import java.time.Instant
 
 interface FlowIORequest {
     // This is used to identify where we suspended, in case of message mismatch errors and other things where we
@@ -112,4 +113,9 @@ data class WaitForLedgerCommit(val hash: SecureHash, val fiber: FlowStateMachine
     override fun shouldResume(message: ExistingSessionMessage, session: FlowSessionInternal): Boolean = message is ErrorSessionEnd
 }
 
+data class Sleep(val until: Instant, val fiber: FlowStateMachineImpl<*>) : FlowIORequest {
+    @Transient
+    override val stackTraceInCaseOfProblems: StackSnapshot = StackSnapshot()
+}
+
 class StackSnapshot : Throwable("This is a stack trace to help identify the source of the underlying problem")
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
index c61ef66ead..019940363b 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
@@ -12,13 +12,9 @@ import net.corda.core.crypto.random63BitValue
 import net.corda.core.flows.*
 import net.corda.core.identity.Party
 import net.corda.core.identity.PartyAndCertificate
-import net.corda.core.internal.FlowStateMachine
-import net.corda.core.internal.abbreviate
+import net.corda.core.internal.*
 import net.corda.core.internal.concurrent.OpenFuture
 import net.corda.core.internal.concurrent.openFuture
-import net.corda.core.internal.isRegularFile
-import net.corda.core.internal.staticField
-import net.corda.core.internal.uncheckedCast
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.utilities.*
 import net.corda.node.services.api.FlowAppAuditEvent
@@ -32,13 +28,15 @@ import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import java.nio.file.Paths
 import java.sql.SQLException
+import java.time.Duration
+import java.time.Instant
 import java.util.*
 import java.util.concurrent.TimeUnit
 
 class FlowPermissionException(message: String) : FlowException(message)
 
 class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
-                              val logic: FlowLogic<R>,
+                              override val logic: FlowLogic<R>,
                               scheduler: FiberScheduler,
                               override val flowInitiator: FlowInitiator,
         // Store the Party rather than the full cert path with PartyAndCertificate
@@ -52,23 +50,6 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
          * Return the current [FlowStateMachineImpl] or null if executing outside of one.
          */
         fun currentStateMachine(): FlowStateMachineImpl<*>? = Strand.currentStrand() as? FlowStateMachineImpl<*>
-
-        /**
-         * Provide a mechanism to sleep within a Strand without locking any transactional state
-         */
-        // TODO: inlined due to an intermittent Quasar error (to be fully investigated)
-        @Suppress("NOTHING_TO_INLINE")
-        @Suspendable
-        inline fun sleep(millis: Long) {
-            if (currentStateMachine() != null) {
-                val db = DatabaseTransactionManager.dataSource
-                DatabaseTransactionManager.current().commit()
-                DatabaseTransactionManager.current().close()
-                Strand.sleep(millis)
-                DatabaseTransactionManager.dataSource = db
-                DatabaseTransactionManager.newTransaction()
-            } else Strand.sleep(millis)
-        }
     }
 
     // These fields shouldn't be serialised, so they are marked @Transient.
@@ -259,6 +240,13 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
         throw IllegalStateException("We were resumed after waiting for $hash but it wasn't found in our local storage")
     }
 
+    // Provide a mechanism to sleep within a Strand without locking any transactional state.
+    // This checkpoints, since we cannot undo any database writes up to this point.
+    @Suspendable
+    override fun sleepUntil(until: Instant) {
+        suspend(Sleep(until, this))
+    }
+
     // TODO Dummy implementation of access to application specific permission controls and audit logging
     override fun checkFlowPermission(permissionName: String, extraAuditData: Map<String, String>) {
         val permissionGranted = true // TODO define permission control service on ServiceHubInternal and actually check authorization.
@@ -494,6 +482,10 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
             }
         }
 
+        if (exceptionDuringSuspend == null && ioRequest is Sleep) {
+            // Sleep on the fiber.  This will not sleep if it's in the past.
+            Strand.sleep(Duration.between(Instant.now(), ioRequest.until).toNanos(), TimeUnit.NANOSECONDS)
+        }
         createTransaction()
         // TODO Now that we're throwing outside of the suspend the FlowLogic can catch it. We need Quasar to terminate
         // the fiber when exceptions occur inside a suspend.
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
index 42fd677f65..2215354b07 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
@@ -584,6 +584,7 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
         when (ioRequest) {
             is SendRequest -> processSendRequest(ioRequest)
             is WaitForLedgerCommit -> processWaitForCommitRequest(ioRequest)
+            is Sleep -> processSleepRequest(ioRequest)
         }
     }
 
@@ -621,6 +622,11 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
         }
     }
 
+    private fun processSleepRequest(ioRequest: Sleep) {
+        // Resume the fiber now we have checkpointed, so we can sleep on the Fiber.
+        resumeFiber(ioRequest.fiber)
+    }
+
     private fun sendSessionMessage(party: Party, message: SessionMessage, fiber: FlowStateMachineImpl<*>? = null, retryId: Long? = null) {
         val partyInfo = serviceHub.networkMapCache.getPartyInfo(party)
                 ?: throw IllegalArgumentException("Don't know about party $party")
diff --git a/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt b/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt
index f694eec66c..3d4005d6fc 100644
--- a/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt
+++ b/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt
@@ -52,7 +52,7 @@ class InteractiveShellTest {
     private fun check(input: String, expected: String) {
         var output: DummyFSM? = null
         InteractiveShell.runFlowFromString({ DummyFSM(it as FlowA).apply { output = this } }, input, FlowA::class.java, om)
-        assertEquals(expected, output!!.logic.a, input)
+        assertEquals(expected, output!!.flowA.a, input)
     }
 
     @Test
@@ -83,5 +83,5 @@ class InteractiveShellTest {
     @Test
     fun party() = check("party: \"${MEGA_CORP.name}\"", MEGA_CORP.name.toString())
 
-    class DummyFSM(val logic: FlowA) : FlowStateMachine<Any?> by mock()
+    class DummyFSM(val flowA: FlowA) : FlowStateMachine<Any?> by mock()
 }

From e232d111ea153da027ccb9b13dc0a3a7b3ab9632 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Wed, 11 Oct 2017 14:46:04 +0100
Subject: [PATCH 160/185] Applies release-V1 vault docs fixes to master.

---
 docs/source/api-persistence.rst |   2 +
 docs/source/api-vault-query.rst | 219 +++++++++++++++++++++++---------
 2 files changed, 161 insertions(+), 60 deletions(-)

diff --git a/docs/source/api-persistence.rst b/docs/source/api-persistence.rst
index 84afad26a5..add8f1b785 100644
--- a/docs/source/api-persistence.rst
+++ b/docs/source/api-persistence.rst
@@ -7,6 +7,8 @@
 API: Persistence
 ================
 
+.. contents::
+
 Corda offers developers the option to expose all or some part of a contract state to an *Object Relational Mapping*
 (ORM) tool to be persisted in a RDBMS.  The purpose of this is to assist *vault* development by effectively indexing
 persisted contract states held in the vault for the purpose of running queries over them and to allow relational joins
diff --git a/docs/source/api-vault-query.rst b/docs/source/api-vault-query.rst
index 0b9944948d..a525a8b413 100644
--- a/docs/source/api-vault-query.rst
+++ b/docs/source/api-vault-query.rst
@@ -1,33 +1,42 @@
 API: Vault Query
 ================
 
-Corda has been architected from the ground up to encourage usage of industry standard, proven query frameworks and libraries for accessing RDBMS backed transactional stores (including the Vault).
+.. contents::
+
+Overview
+--------
+Corda has been architected from the ground up to encourage usage of industry standard, proven query frameworks and
+libraries for accessing RDBMS backed transactional stores (including the Vault).
 
 Corda provides a number of flexible query mechanisms for accessing the Vault:
 
 - Vault Query API
-- using a JDBC session (as described in :ref:`Persistence <jdbc_session_ref>`)
-- custom JPA_/JPQL_ queries
-- custom 3rd party Data Access frameworks such as `Spring Data <http://projects.spring.io/spring-data>`_
+- Using a JDBC session (as described in :ref:`Persistence <jdbc_session_ref>`)
+- Custom JPA_/JPQL_ queries
+- Custom 3rd party Data Access frameworks such as `Spring Data <http://projects.spring.io/spring-data>`_
 
-The majority of query requirements can be satisfied by using the Vault Query API, which is exposed via the ``VaultService`` for use directly by flows:
+The majority of query requirements can be satisfied by using the Vault Query API, which is exposed via the
+``VaultService`` for use directly by flows:
 
 .. literalinclude:: ../../core/src/main/kotlin/net/corda/core/node/services/VaultService.kt
     :language: kotlin
     :start-after: DOCSTART VaultQueryAPI
     :end-before: DOCEND VaultQueryAPI
+    :dedent: 4
 
-and via ``CordaRPCOps`` for use by RPC client applications:
+And via ``CordaRPCOps`` for use by RPC client applications:
 
 .. literalinclude:: ../../core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
     :language: kotlin
     :start-after: DOCSTART VaultQueryByAPI
     :end-before: DOCEND VaultQueryByAPI
+    :dedent: 4
 
 .. literalinclude:: ../../core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
     :language: kotlin
     :start-after: DOCSTART VaultTrackByAPI
     :end-before: DOCEND VaultTrackByAPI
+    :dedent: 4
 
 Helper methods are also provided with default values for arguments:
 
@@ -35,51 +44,84 @@ Helper methods are also provided with default values for arguments:
     :language: kotlin
     :start-after: DOCSTART VaultQueryAPIHelpers
     :end-before: DOCEND VaultQueryAPIHelpers
+    :dedent: 4
 
 .. literalinclude:: ../../core/src/main/kotlin/net/corda/core/messaging/CordaRPCOps.kt
     :language: kotlin
     :start-after: DOCSTART VaultTrackAPIHelpers
     :end-before: DOCEND VaultTrackAPIHelpers
+    :dedent: 4
 
-The API provides both static (snapshot) and dynamic (snapshot with streaming updates) methods for a defined set of filter criteria.
+The API provides both static (snapshot) and dynamic (snapshot with streaming updates) methods for a defined set of
+filter criteria:
 
 - Use ``queryBy`` to obtain a only current snapshot of data (for a given ``QueryCriteria``)
 - Use ``trackBy`` to obtain a both a current snapshot and a future stream of updates (for a given ``QueryCriteria``)
   
 .. note:: Streaming updates are only filtered based on contract type and state status (UNCONSUMED, CONSUMED, ALL)
 
-Simple pagination (page number and size) and sorting (directional ordering using standard or custom property attributes) is also specifiable.
-Defaults are defined for Paging (pageNumber = 1, pageSize = 200) and Sorting (direction = ASC).
+Simple pagination (page number and size) and sorting (directional ordering using standard or custom property
+attributes) is also specifiable. Defaults are defined for paging (pageNumber = 1, pageSize = 200) and sorting
+(direction = ASC).
 
-The ``QueryCriteria`` interface provides a flexible mechanism for specifying different filtering criteria, including and/or composition and a rich set of operators to include: binary logical (AND, OR), comparison (LESS_THAN, LESS_THAN_OR_EQUAL, GREATER_THAN, GREATER_THAN_OR_EQUAL), equality (EQUAL, NOT_EQUAL), likeness (LIKE, NOT_LIKE), nullability (IS_NULL, NOT_NULL), and collection based (IN, NOT_IN). Standard SQL-92 aggregate functions (SUM, AVG, MIN, MAX, COUNT) are also supported.
+The ``QueryCriteria`` interface provides a flexible mechanism for specifying different filtering criteria, including
+and/or composition and a rich set of operators to include:
+
+* Binary logical (AND, OR)
+* Comparison (LESS_THAN, LESS_THAN_OR_EQUAL, GREATER_THAN, GREATER_THAN_OR_EQUAL)
+* Equality (EQUAL, NOT_EQUAL)
+* Likeness (LIKE, NOT_LIKE)
+* Nullability (IS_NULL, NOT_NULL)
+* Collection based (IN, NOT_IN)
+* Standard SQL-92 aggregate functions (SUM, AVG, MIN, MAX, COUNT)
 
 There are four implementations of this interface which can be chained together to define advanced filters.
 
-1. ``VaultQueryCriteria`` provides filterable criteria on attributes within the Vault states table: status (UNCONSUMED, CONSUMED), state reference(s), contract state type(s), notaries, soft locked states, timestamps (RECORDED, CONSUMED).
+1. ``VaultQueryCriteria`` provides filterable criteria on attributes within the Vault states table: status (UNCONSUMED,
+   CONSUMED), state reference(s), contract state type(s), notaries, soft locked states, timestamps (RECORDED, CONSUMED).
 
-	.. note:: Sensible defaults are defined for frequently used attributes (status = UNCONSUMED, always include soft locked states).
+	.. note:: Sensible defaults are defined for frequently used attributes (status = UNCONSUMED, always include soft
+	   locked states).
 
-2. ``FungibleAssetQueryCriteria`` provides filterable criteria on attributes defined in the Corda Core ``FungibleAsset`` contract state interface, used to represent assets that are fungible, countable and issued by a specific party (eg. ``Cash.State`` and ``CommodityContract.State`` in the Corda finance module). Filterable attributes include: participants(s), owner(s), quantity, issuer party(s) and issuer reference(s).
+2. ``FungibleAssetQueryCriteria`` provides filterable criteria on attributes defined in the Corda Core
+   ``FungibleAsset`` contract state interface, used to represent assets that are fungible, countable and issued by a
+   specific party (eg. ``Cash.State`` and ``CommodityContract.State`` in the Corda finance module). Filterable
+   attributes include: participants(s), owner(s), quantity, issuer party(s) and issuer reference(s).
 	   
-	.. note:: All contract states that extend the ``FungibleAsset`` now automatically persist that interfaces common state attributes to the **vault_fungible_states** table.
+	.. note:: All contract states that extend the ``FungibleAsset`` now automatically persist that interfaces common
+	   state attributes to the **vault_fungible_states** table.
 
-3. ``LinearStateQueryCriteria`` provides filterable criteria on attributes defined in the Corda Core ``LinearState`` and ``DealState`` contract state interfaces, used to represent entities that continuously supercede themselves, all of which share the same *linearId* (eg. trade entity states such as the ``IRSState`` defined in the SIMM valuation demo). Filterable attributes include: participant(s), linearId(s), uuid(s), and externalId(s).
+3. ``LinearStateQueryCriteria`` provides filterable criteria on attributes defined in the Corda Core ``LinearState``
+   and ``DealState`` contract state interfaces, used to represent entities that continuously supersede themselves, all
+   of which share the same ``linearId`` (e.g. trade entity states such as the ``IRSState`` defined in the SIMM
+   valuation demo). Filterable attributes include: participant(s), linearId(s), uuid(s), and externalId(s).
 	   
-	.. note:: All contract states that extend ``LinearState`` or ``DealState`` now automatically persist those interfaces common state attributes to the **vault_linear_states** table.
+	.. note:: All contract states that extend ``LinearState`` or ``DealState`` now automatically persist those
+	   interfaces common state attributes to the **vault_linear_states** table.
 
-4. ``VaultCustomQueryCriteria`` provides the means to specify one or many arbitrary expressions on attributes defined by a custom contract state that implements its own schema as described in the :doc:`Persistence </api-persistence>` documentation and associated examples. Custom criteria expressions are expressed using one of several type-safe ``CriteriaExpression``: BinaryLogical, Not, ColumnPredicateExpression, AggregateFunctionExpression. The ``ColumnPredicateExpression`` allows for specification arbitrary criteria using the previously enumerated operator types. The ``AggregateFunctionExpression`` allows for the specification of an aggregate function type (sum, avg, max, min, count) with optional grouping and sorting. Furthermore, a rich DSL is provided to enable simple construction of custom criteria using any combination of ``ColumnPredicate``. See the ``Builder`` object in ``QueryCriteriaUtils`` for a complete specification of the DSL. 
+4. ``VaultCustomQueryCriteria`` provides the means to specify one or many arbitrary expressions on attributes defined
+   by a custom contract state that implements its own schema as described in the :doc:`Persistence </api-persistence>`
+   documentation and associated examples. Custom criteria expressions are expressed using one of several type-safe
+   ``CriteriaExpression``: BinaryLogical, Not, ColumnPredicateExpression, AggregateFunctionExpression. The
+   ``ColumnPredicateExpression`` allows for specification arbitrary criteria using the previously enumerated operator
+   types. The ``AggregateFunctionExpression`` allows for the specification of an aggregate function type (sum, avg,
+   max, min, count) with optional grouping and sorting. Furthermore, a rich DSL is provided to enable simple
+   construction of custom criteria using any combination of ``ColumnPredicate``. See the ``Builder`` object in
+   ``QueryCriteriaUtils`` for a complete specification of the DSL.
 
-    .. note:: custom contract schemas are automatically registered upon node startup for CorDapps. Please refer to
-    :doc:`Persistence </api-persistence>` for mechanisms of registering custom schemas for different testing purposes.
+    .. note:: Custom contract schemas are automatically registered upon node startup for CorDapps. Please refer to
+       :doc:`Persistence </api-persistence>` for mechanisms of registering custom schemas for different testing
+       purposes.
 
 All ``QueryCriteria`` implementations are composable using ``and`` and ``or`` operators.
 
 All ``QueryCriteria`` implementations provide an explicitly specifiable set of common attributes:
 
 1. State status attribute (``Vault.StateStatus``), which defaults to filtering on UNCONSUMED states.
-   When chaining several criterias using AND / OR, the last value of this attribute will override any previous.
-2. Contract state types (``<Set<Class<out ContractState>>``), which will contain at minimum one type (by default this will be ``ContractState`` which resolves to all state types).
-   When chaining several criteria using ``and`` and ``or`` operators, all specified contract state types are combined into a single set.
+   When chaining several criterias using AND / OR, the last value of this attribute will override any previous
+2. Contract state types (``<Set<Class<out ContractState>>``), which will contain at minimum one type (by default this
+   will be ``ContractState`` which resolves to all state types). When chaining several criteria using ``and`` and
+   ``or`` operators, all specified contract state types are combined into a single set
 
 An example of a custom query is illustrated here:
 
@@ -87,20 +129,30 @@ An example of a custom query is illustrated here:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample20
     :end-before: DOCEND VaultQueryExample20
+    :dedent: 12
 
-.. note:: Custom contract states that implement the ``Queryable`` interface may now extend common schemas types ``FungiblePersistentState`` or, ``LinearPersistentState``.  Previously, all custom contracts extended the root ``PersistentState`` class and defined repeated mappings of ``FungibleAsset`` and ``LinearState`` attributes. See ``SampleCashSchemaV2`` and ``DummyLinearStateSchemaV2`` as examples.
+.. note:: Custom contract states that implement the ``Queryable`` interface may now extend common schemas types
+   ``FungiblePersistentState`` or, ``LinearPersistentState``.  Previously, all custom contracts extended the root
+   ``PersistentState`` class and defined repeated mappings of ``FungibleAsset`` and ``LinearState`` attributes. See
+   ``SampleCashSchemaV2`` and ``DummyLinearStateSchemaV2`` as examples.
 
 Examples of these ``QueryCriteria`` objects are presented below for Kotlin and Java.
 
-.. note:: When specifying the Contract Type as a parameterised type to the QueryCriteria in Kotlin, queries now include all concrete implementations of that type if this is an interface. Previously, it was only possible to query on Concrete types (or the universe of all Contract States).
+.. note:: When specifying the ``ContractType`` as a parameterised type to the ``QueryCriteria`` in Kotlin, queries now
+   include all concrete implementations of that type if this is an interface. Previously, it was only possible to query
+   on concrete types (or the universe of all ``ContractState``).
 
-The Vault Query API leverages the rich semantics of the underlying JPA Hibernate_ based :doc:`Persistence </api-persistence>` framework adopted by Corda.
+The Vault Query API leverages the rich semantics of the underlying JPA Hibernate_ based
+:doc:`Persistence </api-persistence>` framework adopted by Corda.
 
 .. _Hibernate: https://docs.jboss.org/hibernate/jpa/2.1/api/
 
-.. note:: Permissioning at the database level will be enforced at a later date to ensure authenticated, role-based, read-only access to underlying Corda tables.
+.. note:: Permissioning at the database level will be enforced at a later date to ensure authenticated, role-based,
+   read-only access to underlying Corda tables.
 
-.. note:: API's now provide ease of use calling semantics from both Java and Kotlin. However, it should be noted that Java custom queries are significantly more verbose due to the use of reflection fields to reference schema attribute types.
+.. note:: API's now provide ease of use calling semantics from both Java and Kotlin. However, it should be noted that
+   Java custom queries are significantly more verbose due to the use of reflection fields to reference schema attribute
+   types.
 
 An example of a custom query in Java is illustrated here:
 
@@ -108,17 +160,24 @@ An example of a custom query in Java is illustrated here:
     :language: java
     :start-after: DOCSTART VaultJavaQueryExample3
     :end-before: DOCEND VaultJavaQueryExample3
+    :dedent: 16
 
-.. note:: Queries by ``Party`` specify the ``AbstractParty`` which may be concrete or anonymous. In the later case, where an anonymous party does not resolve to an X500Name via the IdentityService, no query results will ever be produced. For performance reasons, queries do not use PublicKey as search criteria.
+.. note:: Queries by ``Party`` specify the ``AbstractParty`` which may be concrete or anonymous. In the later case,
+   where an anonymous party does not resolve to an X500 name via the ``IdentityService``, no query results will ever be
+   produced. For performance reasons, queries do not use ``PublicKey`` as search criteria.
 
 Pagination
 ----------
-The API provides support for paging where large numbers of results are expected (by default, a page size is set to 200 results).
-Defining a sensible default page size enables efficient checkpointing within flows, and frees the developer from worrying about pagination where
-result sets are expected to be constrained to 200 or fewer entries. Where large result sets are expected (such as using the RPC API for reporting and/or UI display), it is strongly recommended to define a ``PageSpecification`` to correctly process results with efficient memory utilistion. A fail-fast mode is in place to alert API users to the need for pagination where a single query returns more than 200 results and no ``PageSpecification``
-has been supplied.
+The API provides support for paging where large numbers of results are expected (by default, a page size is set to 200
+results). Defining a sensible default page size enables efficient checkpointing within flows, and frees the developer
+from worrying about pagination where result sets are expected to be constrained to 200 or fewer entries. Where large
+result sets are expected (such as using the RPC API for reporting and/or UI display), it is strongly recommended to
+define a ``PageSpecification`` to correctly process results with efficient memory utilisation. A fail-fast mode is in
+place to alert API users to the need for pagination where a single query returns more than 200 results and no
+``PageSpecification`` has been supplied.
 
-.. note:: A pages maximum size ``MAX_PAGE_SIZE`` is defined as ``Int.MAX_VALUE`` and should be used with extreme caution as results returned may exceed your JVM's memory footprint.
+.. note:: A pages maximum size ``MAX_PAGE_SIZE`` is defined as ``Int.MAX_VALUE`` and should be used with extreme
+   caution as results returned may exceed your JVM's memory footprint.
 
 Example usage
 -------------
@@ -126,7 +185,7 @@ Example usage
 Kotlin
 ^^^^^^
 
-**General snapshot queries using** ``VaultQueryCriteria``
+**General snapshot queries using** ``VaultQueryCriteria``:
 
 Query for all unconsumed states (simplest query possible):
 
@@ -134,6 +193,7 @@ Query for all unconsumed states (simplest query possible):
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample1
     :end-before: DOCEND VaultQueryExample1
+    :dedent: 12
 
 Query for unconsumed states for some state references:
 
@@ -141,6 +201,7 @@ Query for unconsumed states for some state references:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample2
     :end-before: DOCEND VaultQueryExample2
+    :dedent: 12
 
 Query for unconsumed states for several contract state types:
 
@@ -148,6 +209,7 @@ Query for unconsumed states for several contract state types:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample3
     :end-before: DOCEND VaultQueryExample3
+    :dedent: 12
 
 Query for unconsumed states for a given notary:
 
@@ -155,6 +217,7 @@ Query for unconsumed states for a given notary:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample4
     :end-before: DOCEND VaultQueryExample4
+    :dedent: 12
 
 Query for unconsumed states for a given set of participants:
 
@@ -162,6 +225,7 @@ Query for unconsumed states for a given set of participants:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample5
     :end-before: DOCEND VaultQueryExample5
+    :dedent: 12
 
 Query for unconsumed states recorded between two time intervals:
 
@@ -169,6 +233,7 @@ Query for unconsumed states recorded between two time intervals:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample6
     :end-before: DOCEND VaultQueryExample6
+    :dedent: 12
 
 .. note:: This example illustrates usage of a ``Between`` ``ColumnPredicate``.
 
@@ -178,17 +243,21 @@ Query for all states with pagination specification (10 results per page):
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample7
     :end-before: DOCEND VaultQueryExample7
+    :dedent: 12
 
-.. note:: The result set metadata field `totalStatesAvailable` allows you to further paginate accordingly as demonstrated in the following example.
+.. note:: The result set metadata field `totalStatesAvailable` allows you to further paginate accordingly as
+   demonstrated in the following example.
 
-Query for all states using pagination specification and iterate using `totalStatesAvailable` field until no further pages available:
+Query for all states using pagination specification and iterate using `totalStatesAvailable` field until no further
+pages available:
 
 .. literalinclude:: ../../node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt
     :language: kotlin
     :start-after: DOCSTART VaultQueryExamplePaging
     :end-before: DOCEND VaultQueryExamplePaging
+    :dedent: 8
 
-**LinearState and DealState queries using** ``LinearStateQueryCriteria``
+**LinearState and DealState queries using** ``LinearStateQueryCriteria``:
 
 Query for unconsumed linear states for given linear ids:
 
@@ -196,6 +265,7 @@ Query for unconsumed linear states for given linear ids:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample8
     :end-before: DOCEND VaultQueryExample8
+    :dedent: 12
 
 Query for all linear states associated with a linear id:
 
@@ -203,6 +273,7 @@ Query for all linear states associated with a linear id:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample9
     :end-before: DOCEND VaultQueryExample9
+    :dedent: 12
 
 Query for unconsumed deal states with deals references:
 
@@ -210,6 +281,7 @@ Query for unconsumed deal states with deals references:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample10
     :end-before: DOCEND VaultQueryExample10
+    :dedent: 12
 
 Query for unconsumed deal states with deals parties:
 
@@ -217,8 +289,9 @@ Query for unconsumed deal states with deals parties:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample11
     :end-before: DOCEND VaultQueryExample11
+    :dedent: 12
 
-**FungibleAsset and DealState queries using** ``FungibleAssetQueryCriteria``
+**FungibleAsset and DealState queries using** ``FungibleAssetQueryCriteria``:
 
 Query for fungible assets for a given currency:
 
@@ -226,6 +299,7 @@ Query for fungible assets for a given currency:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample12
     :end-before: DOCEND VaultQueryExample12
+    :dedent: 12
 
 Query for fungible assets for a minimum quantity:
 
@@ -233,19 +307,21 @@ Query for fungible assets for a minimum quantity:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample13
     :end-before: DOCEND VaultQueryExample13
+    :dedent: 12
 
 .. note:: This example uses the builder DSL.
 
-Query for fungible assets for a specifc issuer party:
+Query for fungible assets for a specific issuer party:
 
 .. literalinclude:: ../../node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample14
     :end-before: DOCEND VaultQueryExample14
+    :dedent: 12
 
-**Aggregate Function queries using** ``VaultCustomQueryCriteria``
+**Aggregate Function queries using** ``VaultCustomQueryCriteria``:
 
-.. note:: Query results for aggregate functions are contained in the `otherResults` attribute of a results Page.
+.. note:: Query results for aggregate functions are contained in the ``otherResults`` attribute of a results Page.
 
 Aggregations on cash using various functions:
 
@@ -253,8 +329,9 @@ Aggregations on cash using various functions:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample21
     :end-before: DOCEND VaultQueryExample21
+    :dedent: 12
 
-.. note:: `otherResults` will contain 5 items, one per calculated aggregate function.
+.. note:: ``otherResults`` will contain 5 items, one per calculated aggregate function.
 
 Aggregations on cash grouped by currency for various functions:
 
@@ -262,8 +339,10 @@ Aggregations on cash grouped by currency for various functions:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample22
     :end-before: DOCEND VaultQueryExample22
+    :dedent: 12
 
-.. note:: `otherResults` will contain 24 items, one result per calculated aggregate function per currency (the grouping attribute - currency in this case - is returned per aggregate result).
+.. note:: ``otherResults`` will contain 24 items, one result per calculated aggregate function per currency (the
+   grouping attribute - currency in this case - is returned per aggregate result).
 
 Sum aggregation on cash grouped by issuer party and currency and sorted by sum:
 
@@ -271,10 +350,15 @@ Sum aggregation on cash grouped by issuer party and currency and sorted by sum:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample23
     :end-before: DOCEND VaultQueryExample23
+    :dedent: 12
 
-.. note:: `otherResults` will contain 12 items sorted from largest summed cash amount to smallest, one result per calculated aggregate function per issuer party and currency (grouping attributes are returned per aggregate result).
+.. note:: ``otherResults`` will contain 12 items sorted from largest summed cash amount to smallest, one result per
+   calculated aggregate function per issuer party and currency (grouping attributes are returned per aggregate result).
 
-**Dynamic queries** (also using ``VaultQueryCriteria``) are an extension to the snapshot queries by returning an additional ``QueryResults`` return type in the form of an ``Observable<Vault.Update>``. Refer to `ReactiveX Observable <http://reactivex.io/documentation/observable.html>`_ for a detailed understanding and usage of this type. 
+Dynamic queries (also using ``VaultQueryCriteria``) are an extension to the snapshot queries by returning an
+additional ``QueryResults`` return type in the form of an ``Observable<Vault.Update>``. Refer to
+`ReactiveX Observable <http://reactivex.io/documentation/observable.html>`_ for a detailed understanding and usage of
+this type.
 
 Track unconsumed cash states:
 
@@ -282,6 +366,7 @@ Track unconsumed cash states:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample15
     :end-before: DOCEND VaultQueryExample15
+    :dedent: 20
 
 Track unconsumed linear states:
 
@@ -289,8 +374,9 @@ Track unconsumed linear states:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample16
     :end-before: DOCEND VaultQueryExample16
+    :dedent: 20
 
-.. note:: This will return both Deal and Linear states.
+.. note:: This will return both ``DealState`` and ``LinearState`` states.
 
 Track unconsumed deal states:
 
@@ -298,8 +384,9 @@ Track unconsumed deal states:
     :language: kotlin
     :start-after: DOCSTART VaultQueryExample17
     :end-before: DOCEND VaultQueryExample17
+    :dedent: 20
 
-.. note:: This will return only Deal states.
+.. note:: This will return only ``DealState`` states.
 
 Java examples
 ^^^^^^^^^^^^^
@@ -310,6 +397,7 @@ Query for all unconsumed linear states:
     :language: java
     :start-after: DOCSTART VaultJavaQueryExample0
     :end-before: DOCEND VaultJavaQueryExample0
+    :dedent: 12
 
 Query for all consumed cash states:
 
@@ -317,6 +405,7 @@ Query for all consumed cash states:
     :language: java
     :start-after: DOCSTART VaultJavaQueryExample1
     :end-before: DOCEND VaultJavaQueryExample1
+    :dedent: 12
 
 Query for consumed deal states or linear ids, specify a paging specification and sort by unique identifier:
 
@@ -324,8 +413,9 @@ Query for consumed deal states or linear ids, specify a paging specification and
     :language: java
     :start-after: DOCSTART VaultJavaQueryExample2
     :end-before: DOCEND VaultJavaQueryExample2
+    :dedent: 12
 
-**Aggregate Function queries using** ``VaultCustomQueryCriteria``
+**Aggregate Function queries using** ``VaultCustomQueryCriteria``:
 
 Aggregations on cash using various functions:
 
@@ -333,6 +423,7 @@ Aggregations on cash using various functions:
     :language: java
     :start-after: DOCSTART VaultJavaQueryExample21
     :end-before: DOCEND VaultJavaQueryExample21
+    :dedent: 16
 
 Aggregations on cash grouped by currency for various functions:
 
@@ -340,6 +431,7 @@ Aggregations on cash grouped by currency for various functions:
     :language: java
     :start-after: DOCSTART VaultJavaQueryExample22
     :end-before: DOCEND VaultJavaQueryExample22
+    :dedent: 16
 
 Sum aggregation on cash grouped by issuer party and currency and sorted by sum:
 
@@ -347,6 +439,7 @@ Sum aggregation on cash grouped by issuer party and currency and sorted by sum:
     :language: java
     :start-after: DOCSTART VaultJavaQueryExample23
     :end-before: DOCEND VaultJavaQueryExample23
+    :dedent: 16
 
 Track unconsumed cash states:
 
@@ -354,13 +447,16 @@ Track unconsumed cash states:
     :language: java
     :start-after: DOCSTART VaultJavaQueryExample4
     :end-before: DOCEND VaultJavaQueryExample4
+    :dedent: 12
 
-Track unconsumed deal states or linear states (with snapshot including specification of paging and sorting by unique identifier):
+Track unconsumed deal states or linear states (with snapshot including specification of paging and sorting by unique
+identifier):
 
 .. literalinclude:: ../../node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
     :language: java
     :start-after: DOCSTART VaultJavaQueryExample4
     :end-before: DOCEND VaultJavaQueryExample4
+    :dedent: 12
 
 Troubleshooting
 ---------------
@@ -373,24 +469,27 @@ If the results your were expecting do not match actual returned query results we
 
 Behavioural notes
 -----------------
-1. **TrackBy** updates do not take into account the full criteria specification due to different and more restrictive syntax
-   in `observables <https://github.com/ReactiveX/RxJava/wiki>`_ filtering (vs full SQL-92 JDBC filtering as used in snapshot views).
-   Specifically, dynamic updates are filtered by ``contractStateType`` and ``stateType`` (UNCONSUMED, CONSUMED, ALL) only.
-2. **QueryBy** and **TrackBy snapshot views** using pagination may return different result sets as each paging request is a
-   separate SQL query on the underlying database, and it is entirely conceivable that state modifications are taking
-   place in between and/or in parallel to paging requests.
-   When using pagination, always check the value of the ``totalStatesAvailable`` (from the ``Vault.Page`` result) and
-   adjust further paging requests appropriately.
+1. ``TrackBy`` updates do not take into account the full criteria specification due to different and more restrictive
+   syntax in `observables <https://github.com/ReactiveX/RxJava/wiki>`_ filtering (vs full SQL-92 JDBC filtering as used
+   in snapshot views). Specifically, dynamic updates are filtered by ``contractStateType`` and ``stateType``
+   (UNCONSUMED, CONSUMED, ALL) only
+2. ``QueryBy`` and ``TrackBy`` snapshot views using pagination may return different result sets as each paging request
+   is a separate SQL query on the underlying database, and it is entirely conceivable that state modifications are
+   taking place in between and/or in parallel to paging requests. When using pagination, always check the value of the
+   ``totalStatesAvailable`` (from the ``Vault.Page`` result) and adjust further paging requests appropriately.
 
 Other use case scenarios
 ------------------------
 
-For advanced use cases that require sophisticated pagination, sorting, grouping, and aggregation functions, it is recommended that the CorDapp developer utilise one of the many proven frameworks that ship with this capability out of the box. Namely, implementations of JPQL (JPA Query Language) such as **Hibernate** for advanced SQL access, and **Spring Data** for advanced pagination and ordering constructs.
+For advanced use cases that require sophisticated pagination, sorting, grouping, and aggregation functions, it is
+recommended that the CorDapp developer utilise one of the many proven frameworks that ship with this capability out of
+the box. Namely, implementations of JPQL (JPA Query Language) such as Hibernate for advanced SQL access, and
+Spring Data for advanced pagination and ordering constructs.
 
 The Corda Tutorials provide examples satisfying these additional Use Cases:
 
-     1. Template / Tutorial CorDapp service using Vault API Custom Query to access attributes of IOU State
-     2. Template / Tutorial CorDapp service query extension executing Named Queries via JPQL_
+     1. Example CorDapp service using Vault API Custom Query to access attributes of IOU State
+     2. Example CorDapp service query extension executing Named Queries via JPQL_
      3. `Advanced pagination <https://docs.spring.io/spring-data/commons/docs/current/api/org/springframework/data/repository/PagingAndSortingRepository.html>`_ queries using Spring Data JPA_
         
  .. _JPQL: http://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html#hql

From 899f7f9d0d45ebbfaacb779cec372324dd512f1e Mon Sep 17 00:00:00 2001
From: Matthew Nesbit <matthew.nesbit@r3cev.com>
Date: Mon, 9 Oct 2017 15:04:00 +0100
Subject: [PATCH 161/185] Change the serialization/deserialization code of
 SessionMessage data to add more validation.

Address PR comments

As pointed out by Shams the SessionInit must be well formed at this point.
---
 .../serialization/ListsSerializationTest.kt   | 14 ++++++++-----
 .../serialization/MapsSerializationTest.kt    |  7 +++++--
 .../serialization/SetsSerializationTest.kt    | 13 ++++++++----
 .../statemachine/FlowStateMachineImpl.kt      |  7 +++++--
 .../services/statemachine/SessionMessage.kt   | 20 ++++++++++++++-----
 .../statemachine/StateMachineManager.kt       | 20 ++++++++-----------
 .../statemachine/FlowFrameworkTests.kt        |  4 ++--
 7 files changed, 53 insertions(+), 32 deletions(-)

diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
index ede793b2be..d9d0f58e0c 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ListsSerializationTest.kt
@@ -11,11 +11,12 @@ import net.corda.testing.TestDependencyInjectionBase
 import net.corda.testing.amqpSpecific
 import net.corda.testing.kryoSpecific
 import org.assertj.core.api.Assertions
-import org.junit.Assert.*
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
 import org.junit.Test
 import java.io.ByteArrayOutputStream
 import java.io.NotSerializableException
-import java.nio.charset.StandardCharsets.*
+import java.nio.charset.StandardCharsets.US_ASCII
 import java.util.*
 
 class ListsSerializationTest : TestDependencyInjectionBase() {
@@ -40,16 +41,19 @@ class ListsSerializationTest : TestDependencyInjectionBase() {
     @Test
     fun `check list can be serialized as part of SessionData`() {
         run {
-            val sessionData = SessionData(123, listOf(1))
+            val sessionData = SessionData(123, listOf(1).serialize())
             assertEqualAfterRoundTripSerialization(sessionData)
+            assertEquals(listOf(1), sessionData.payload.deserialize())
         }
         run {
-            val sessionData = SessionData(123, listOf(1, 2))
+            val sessionData = SessionData(123, listOf(1, 2).serialize())
             assertEqualAfterRoundTripSerialization(sessionData)
+            assertEquals(listOf(1, 2), sessionData.payload.deserialize())
         }
         run {
-            val sessionData = SessionData(123, emptyList<Int>())
+            val sessionData = SessionData(123, emptyList<Int>().serialize())
             assertEqualAfterRoundTripSerialization(sessionData)
+            assertEquals(emptyList<Int>(), sessionData.payload.deserialize())
         }
     }
 
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/MapsSerializationTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/MapsSerializationTest.kt
index 9788885420..4e9f598eab 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/MapsSerializationTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/MapsSerializationTest.kt
@@ -3,17 +3,19 @@ package net.corda.nodeapi.internal.serialization
 import com.esotericsoftware.kryo.Kryo
 import com.esotericsoftware.kryo.util.DefaultClassResolver
 import net.corda.core.serialization.CordaSerializable
+import net.corda.core.serialization.deserialize
 import net.corda.core.serialization.serialize
 import net.corda.node.services.statemachine.SessionData
 import net.corda.testing.TestDependencyInjectionBase
 import net.corda.testing.amqpSpecific
 import net.corda.testing.kryoSpecific
 import org.assertj.core.api.Assertions
+import org.bouncycastle.asn1.x500.X500Name
 import org.junit.Assert.assertArrayEquals
 import org.junit.Test
-import org.bouncycastle.asn1.x500.X500Name
 import java.io.ByteArrayOutputStream
 import java.util.*
+import kotlin.test.assertEquals
 
 class MapsSerializationTest : TestDependencyInjectionBase() {
     private companion object {
@@ -33,8 +35,9 @@ class MapsSerializationTest : TestDependencyInjectionBase() {
 
     @Test
     fun `check list can be serialized as part of SessionData`() {
-        val sessionData = SessionData(123, smallMap)
+        val sessionData = SessionData(123, smallMap.serialize())
         assertEqualAfterRoundTripSerialization(sessionData)
+        assertEquals(smallMap, sessionData.payload.deserialize())
     }
 
     @CordaSerializable
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SetsSerializationTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SetsSerializationTest.kt
index 4a652a7521..210a0cd800 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SetsSerializationTest.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/SetsSerializationTest.kt
@@ -2,11 +2,13 @@ package net.corda.nodeapi.internal.serialization
 
 import com.esotericsoftware.kryo.Kryo
 import com.esotericsoftware.kryo.util.DefaultClassResolver
+import net.corda.core.serialization.deserialize
 import net.corda.core.serialization.serialize
 import net.corda.node.services.statemachine.SessionData
 import net.corda.testing.TestDependencyInjectionBase
 import net.corda.testing.kryoSpecific
-import org.junit.Assert.*
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
 import org.junit.Test
 import java.io.ByteArrayOutputStream
 import java.util.*
@@ -26,16 +28,19 @@ class SetsSerializationTest : TestDependencyInjectionBase() {
     @Test
     fun `check set can be serialized as part of SessionData`() {
         run {
-            val sessionData = SessionData(123, setOf(1))
+            val sessionData = SessionData(123, setOf(1).serialize())
             assertEqualAfterRoundTripSerialization(sessionData)
+            assertEquals(setOf(1), sessionData.payload.deserialize())
         }
         run {
-            val sessionData = SessionData(123, setOf(1, 2))
+            val sessionData = SessionData(123, setOf(1, 2).serialize())
             assertEqualAfterRoundTripSerialization(sessionData)
+            assertEquals(setOf(1, 2), sessionData.payload.deserialize())
         }
         run {
-            val sessionData = SessionData(123, emptySet<Int>())
+            val sessionData = SessionData(123, emptySet<Int>().serialize())
             assertEqualAfterRoundTripSerialization(sessionData)
+            assertEquals(emptySet<Int>(), sessionData.payload.deserialize())
         }
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
index 019940363b..89f0bf6dc6 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/FlowStateMachineImpl.kt
@@ -15,6 +15,8 @@ import net.corda.core.identity.PartyAndCertificate
 import net.corda.core.internal.*
 import net.corda.core.internal.concurrent.OpenFuture
 import net.corda.core.internal.concurrent.openFuture
+import net.corda.core.serialization.SerializationDefaults
+import net.corda.core.serialization.serialize
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.utilities.*
 import net.corda.node.services.api.FlowAppAuditEvent
@@ -327,7 +329,7 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
             is FlowSessionState.Initiated -> sessionState.peerSessionId
             else -> throw IllegalStateException("We've somehow held onto a non-initiated session: $session")
         }
-        return SessionData(peerSessionId, payload)
+        return SessionData(peerSessionId, payload.serialize(context = SerializationDefaults.P2P_CONTEXT))
     }
 
     @Suspendable
@@ -389,7 +391,8 @@ class FlowStateMachineImpl<R>(override val id: StateMachineRunId,
         session.state = FlowSessionState.Initiating(state.otherParty)
         session.retryable = retryable
         val (version, initiatingFlowClass) = session.flow.javaClass.flowVersionAndInitiatingClass
-        val sessionInit = SessionInit(session.ourSessionId, initiatingFlowClass.name, version, session.flow.javaClass.appName, firstPayload)
+        val payloadBytes = firstPayload?.serialize(context = SerializationDefaults.P2P_CONTEXT)
+        val sessionInit = SessionInit(session.ourSessionId, initiatingFlowClass.name, version, session.flow.javaClass.appName, payloadBytes)
         sendInternal(session, sessionInit)
         if (waitForConfirmation) {
             session.waitForConfirmation()
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/SessionMessage.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/SessionMessage.kt
index fc103e6dca..c321d3768a 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/SessionMessage.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/SessionMessage.kt
@@ -5,7 +5,10 @@ import net.corda.core.flows.UnexpectedFlowEndException
 import net.corda.core.identity.Party
 import net.corda.core.internal.castIfPossible
 import net.corda.core.serialization.CordaSerializable
+import net.corda.core.serialization.SerializationDefaults
+import net.corda.core.serialization.SerializedBytes
 import net.corda.core.utilities.UntrustworthyData
+import java.io.IOException
 
 @CordaSerializable
 interface SessionMessage
@@ -25,7 +28,7 @@ data class SessionInit(val initiatorSessionId: Long,
                        val initiatingFlowClass: String,
                        val flowVersion: Int,
                        val appName: String,
-                       val firstPayload: Any?) : SessionMessage
+                       val firstPayload: SerializedBytes<Any>?) : SessionMessage
 
 data class SessionConfirm(override val initiatorSessionId: Long,
                           val initiatedSessionId: Long,
@@ -34,7 +37,7 @@ data class SessionConfirm(override val initiatorSessionId: Long,
 
 data class SessionReject(override val initiatorSessionId: Long, val errorMessage: String) : SessionInitResponse
 
-data class SessionData(override val recipientSessionId: Long, val payload: Any) : ExistingSessionMessage
+data class SessionData(override val recipientSessionId: Long, val payload: SerializedBytes<Any>) : ExistingSessionMessage
 
 data class NormalSessionEnd(override val recipientSessionId: Long) : SessionEnd
 
@@ -42,8 +45,15 @@ data class ErrorSessionEnd(override val recipientSessionId: Long, val errorRespo
 
 data class ReceivedSessionMessage<out M : ExistingSessionMessage>(val sender: Party, val message: M)
 
-fun <T> ReceivedSessionMessage<SessionData>.checkPayloadIs(type: Class<T>): UntrustworthyData<T> {
-    return type.castIfPossible(message.payload)?.let { UntrustworthyData(it) } ?:
+fun <T : Any> ReceivedSessionMessage<SessionData>.checkPayloadIs(type: Class<T>): UntrustworthyData<T> {
+    val payloadData: T = try {
+        val serializer = SerializationDefaults.SERIALIZATION_FACTORY
+        serializer.deserialize<T>(message.payload, type, SerializationDefaults.P2P_CONTEXT)
+    } catch (ex: Exception) {
+        throw IOException("Payload invalid", ex)
+    }
+    return type.castIfPossible(payloadData)?.let { UntrustworthyData(it) } ?:
             throw UnexpectedFlowEndException("We were expecting a ${type.name} from $sender but we instead got a " +
-                    "${message.payload.javaClass.name} (${message.payload})")
+                    "${payloadData.javaClass.name} (${payloadData})")
+
 }
diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
index 2215354b07..74697821e9 100644
--- a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
+++ b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineManager.kt
@@ -15,11 +15,7 @@ import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.random63BitValue
 import net.corda.core.flows.*
 import net.corda.core.identity.Party
-import net.corda.core.internal.FlowStateMachine
-import net.corda.core.internal.ThreadBox
-import net.corda.core.internal.bufferUntilSubscribed
-import net.corda.core.internal.castIfPossible
-import net.corda.core.internal.uncheckedCast
+import net.corda.core.internal.*
 import net.corda.core.messaging.DataFeed
 import net.corda.core.serialization.SerializationDefaults.CHECKPOINT_CONTEXT
 import net.corda.core.serialization.SerializationDefaults.SERIALIZATION_FACTORY
@@ -290,7 +286,12 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
     }
 
     private fun onSessionMessage(message: ReceivedMessage) {
-        val sessionMessage = message.data.deserialize<SessionMessage>()
+        val sessionMessage = try {
+            message.data.deserialize<SessionMessage>()
+        } catch (ex: Exception) {
+            logger.error("Received corrupt SessionMessage data from ${message.peer}")
+            return
+        }
         val sender = serviceHub.networkMapCache.getPeerByLegalName(message.peer)
         if (sender != null) {
             when (sessionMessage) {
@@ -382,12 +383,7 @@ class StateMachineManager(val serviceHub: ServiceHubInternal,
             updateCheckpoint(fiber)
             session to initiatedFlowFactory
         } catch (e: SessionRejectException) {
-            // TODO: Handle this more gracefully
-            try {
-                logger.warn("${e.logMessage}: $sessionInit")
-            } catch (e: Throwable) {
-                logger.warn("Problematic session init message during logging", e)
-            }
+            logger.warn("${e.logMessage}: $sessionInit")
             sendSessionReject(e.rejectMessage)
             return
         } catch (e: Exception) {
diff --git a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
index d4391109e3..418ffb5142 100644
--- a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
@@ -710,11 +710,11 @@ class FlowFrameworkTests {
     }
 
     private fun sessionInit(clientFlowClass: KClass<out FlowLogic<*>>, flowVersion: Int = 1, payload: Any? = null): SessionInit {
-        return SessionInit(0, clientFlowClass.java.name, flowVersion, "", payload)
+        return SessionInit(0, clientFlowClass.java.name, flowVersion, "", payload?.serialize())
     }
 
     private fun sessionConfirm(flowVersion: Int = 1) = SessionConfirm(0, 0, flowVersion, "")
-    private fun sessionData(payload: Any) = SessionData(0, payload)
+    private fun sessionData(payload: Any) = SessionData(0, payload.serialize())
     private val normalEnd = NormalSessionEnd(0)
     private fun erroredEnd(errorResponse: FlowException? = null) = ErrorSessionEnd(0, errorResponse)
 

From de391dc9f006ce658e714dd1ccd592ab37bb3d21 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Wed, 11 Oct 2017 16:15:24 +0100
Subject: [PATCH 162/185] Adds a length method to calculate a time-window's
 length.

---
 .../net/corda/core/contracts/TimeWindow.kt    | 11 ++++++++++
 .../corda/core/contracts/TimeWindowTest.kt    | 22 ++++++++++++++-----
 docs/source/changelog.rst                     |  3 +++
 3 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/contracts/TimeWindow.kt b/core/src/main/kotlin/net/corda/core/contracts/TimeWindow.kt
index c8c650257d..8126292138 100644
--- a/core/src/main/kotlin/net/corda/core/contracts/TimeWindow.kt
+++ b/core/src/main/kotlin/net/corda/core/contracts/TimeWindow.kt
@@ -64,6 +64,17 @@ abstract class TimeWindow {
      */
     abstract val midpoint: Instant?
 
+    /**
+     * Returns the duration between [fromTime] and [untilTime] if both are non-null. Otherwise returns null.
+     */
+    val length: Duration? get() {
+        return if (fromTime == null || untilTime == null) {
+            null
+        } else {
+            Duration.between(fromTime, untilTime)
+        }
+    }
+
     /** Returns true iff the given [instant] is within the time interval of this [TimeWindow]. */
     abstract operator fun contains(instant: Instant): Boolean
 
diff --git a/core/src/test/kotlin/net/corda/core/contracts/TimeWindowTest.kt b/core/src/test/kotlin/net/corda/core/contracts/TimeWindowTest.kt
index 453b01eb65..f0da2499b9 100644
--- a/core/src/test/kotlin/net/corda/core/contracts/TimeWindowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/contracts/TimeWindowTest.kt
@@ -1,9 +1,12 @@
 package net.corda.core.contracts
 
+import net.corda.core.internal.div
+import net.corda.core.internal.times
 import net.corda.core.utilities.millis
 import net.corda.core.utilities.minutes
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
+import java.time.Duration
 import java.time.Instant
 import java.time.LocalDate
 import java.time.ZoneOffset.UTC
@@ -17,6 +20,7 @@ class TimeWindowTest {
         assertThat(timeWindow.fromTime).isEqualTo(now)
         assertThat(timeWindow.untilTime).isNull()
         assertThat(timeWindow.midpoint).isNull()
+        assertThat(timeWindow.length).isNull()
         assertThat(timeWindow.contains(now - 1.millis)).isFalse()
         assertThat(timeWindow.contains(now)).isTrue()
         assertThat(timeWindow.contains(now + 1.millis)).isTrue()
@@ -28,6 +32,7 @@ class TimeWindowTest {
         assertThat(timeWindow.fromTime).isNull()
         assertThat(timeWindow.untilTime).isEqualTo(now)
         assertThat(timeWindow.midpoint).isNull()
+        assertThat(timeWindow.length).isNull()
         assertThat(timeWindow.contains(now - 1.millis)).isTrue()
         assertThat(timeWindow.contains(now)).isFalse()
         assertThat(timeWindow.contains(now + 1.millis)).isFalse()
@@ -42,6 +47,7 @@ class TimeWindowTest {
         assertThat(timeWindow.fromTime).isEqualTo(fromTime)
         assertThat(timeWindow.untilTime).isEqualTo(untilTime)
         assertThat(timeWindow.midpoint).isEqualTo(today.atTime(12, 15).toInstant(UTC))
+        assertThat(timeWindow.length).isEqualTo(Duration.between(fromTime, untilTime))
         assertThat(timeWindow.contains(fromTime - 1.millis)).isFalse()
         assertThat(timeWindow.contains(fromTime)).isTrue()
         assertThat(timeWindow.contains(fromTime + 1.millis)).isTrue()
@@ -51,17 +57,21 @@ class TimeWindowTest {
 
     @Test
     fun fromStartAndDuration() {
-        val timeWindow = TimeWindow.fromStartAndDuration(now, 10.minutes)
+        val duration = 10.minutes
+        val timeWindow = TimeWindow.fromStartAndDuration(now, duration)
         assertThat(timeWindow.fromTime).isEqualTo(now)
-        assertThat(timeWindow.untilTime).isEqualTo(now + 10.minutes)
-        assertThat(timeWindow.midpoint).isEqualTo(now + 5.minutes)
+        assertThat(timeWindow.untilTime).isEqualTo(now + duration)
+        assertThat(timeWindow.midpoint).isEqualTo(now + duration / 2)
+        assertThat(timeWindow.length).isEqualTo(duration)
     }
 
     @Test
     fun withTolerance() {
-        val timeWindow = TimeWindow.withTolerance(now, 10.minutes)
-        assertThat(timeWindow.fromTime).isEqualTo(now - 10.minutes)
-        assertThat(timeWindow.untilTime).isEqualTo(now + 10.minutes)
+        val tolerance = 10.minutes
+        val timeWindow = TimeWindow.withTolerance(now, tolerance)
+        assertThat(timeWindow.fromTime).isEqualTo(now - tolerance)
+        assertThat(timeWindow.untilTime).isEqualTo(now + tolerance)
         assertThat(timeWindow.midpoint).isEqualTo(now)
+        assertThat(timeWindow.length).isEqualTo(tolerance * 2)
     }
 }
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index 0931e57561..ddc74beb2a 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -46,6 +46,9 @@ UNRELEASED
   allows services to start flows marked with the ``StartableByService`` annotation. For backwards compatability
   service classes with only ``ServiceHub`` constructors will still work.
 
+* ``TimeWindow`` now has a ``length`` property that returns the length of the time-window, or ``null`` if the
+  time-window is open-ended.
+
 .. _changelog_v1:
 
 Release 1.0

From ed79db68641d7a90b4ee8d231fa0124b11f7661d Mon Sep 17 00:00:00 2001
From: Konstantinos Chalkias <konstantinos.chalkias@r3.com>
Date: Wed, 11 Oct 2017 17:47:48 +0100
Subject: [PATCH 163/185] Clean up Crypto  (#1866)

clean up Crypto comments + PublicKey.toSHA256Bytes() uses .encoded
---
 .../kotlin/net/corda/core/crypto/Crypto.kt    | 20 +++++------
 .../net/corda/core/crypto/CryptoUtils.kt      | 34 ++++++++++++++-----
 .../net/corda/core/utilities/EncodingUtils.kt | 21 ++++++++----
 3 files changed, 51 insertions(+), 24 deletions(-)

diff --git a/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt b/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt
index 58b68bb176..f2c0a45918 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/Crypto.kt
@@ -2,7 +2,10 @@ package net.corda.core.crypto
 
 import net.corda.core.internal.X509EdDSAEngine
 import net.corda.core.serialization.serialize
-import net.i2p.crypto.eddsa.*
+import net.i2p.crypto.eddsa.EdDSAEngine
+import net.i2p.crypto.eddsa.EdDSAPrivateKey
+import net.i2p.crypto.eddsa.EdDSAPublicKey
+import net.i2p.crypto.eddsa.EdDSASecurityProvider
 import net.i2p.crypto.eddsa.math.GroupElement
 import net.i2p.crypto.eddsa.spec.EdDSANamedCurveSpec
 import net.i2p.crypto.eddsa.spec.EdDSANamedCurveTable
@@ -39,8 +42,6 @@ import org.bouncycastle.pqc.jcajce.provider.sphincs.BCSphincs256PublicKey
 import org.bouncycastle.pqc.jcajce.spec.SPHINCS256KeyGenParameterSpec
 import java.math.BigInteger
 import java.security.*
-import java.security.KeyFactory
-import java.security.KeyPairGenerator
 import java.security.spec.InvalidKeySpecException
 import java.security.spec.PKCS8EncodedKeySpec
 import java.security.spec.X509EncodedKeySpec
@@ -148,7 +149,7 @@ object Crypto {
                     "at the cost of larger key sizes and loss of compatibility."
     )
 
-    /** Corda composite key type */
+    /** Corda composite key type. */
     @JvmField
     val COMPOSITE_KEY = SignatureScheme(
             6,
@@ -823,7 +824,7 @@ object Crypto {
     @JvmStatic
     fun deriveKeyPairFromEntropy(entropy: BigInteger): KeyPair = deriveKeyPairFromEntropy(DEFAULT_SIGNATURE_SCHEME, entropy)
 
-    // custom key pair generator from entropy.
+    // Custom key pair generator from entropy.
     private fun deriveEdDSAKeyPairFromEntropy(entropy: BigInteger): KeyPair {
         val params = EDDSA_ED25519_SHA512.algSpec as EdDSANamedCurveSpec
         val bytes = entropy.toByteArray().copyOf(params.curve.field.getb() / 8) // Need to pad the entropy to the valid seed length.
@@ -882,7 +883,7 @@ object Crypto {
         }
     }
 
-    // return true if EdDSA publicKey is point at infinity.
+    // Return true if EdDSA publicKey is point at infinity.
     // For EdDSA a custom function is required as it is not supported by the I2P implementation.
     private fun isEdDSAPointAtInfinity(publicKey: EdDSAPublicKey): Boolean {
         return publicKey.a.toP3() == (EDDSA_ED25519_SHA512.algSpec as EdDSANamedCurveSpec).curve.getZero(GroupElement.Representation.P3)
@@ -894,7 +895,7 @@ object Crypto {
         return signatureScheme.schemeCodeName in signatureSchemeMap
     }
 
-    // validate a key, by checking its algorithmic params.
+    // Validate a key, by checking its algorithmic params.
     private fun validateKey(signatureScheme: SignatureScheme, key: Key): Boolean {
         return when (key) {
             is PublicKey -> validatePublicKey(signatureScheme, key)
@@ -903,7 +904,7 @@ object Crypto {
         }
     }
 
-    // check if a public key satisfies algorithm specs (for ECC: key should lie on the curve and not being point-at-infinity).
+    // Check if a public key satisfies algorithm specs (for ECC: key should lie on the curve and not being point-at-infinity).
     private fun validatePublicKey(signatureScheme: SignatureScheme, key: PublicKey): Boolean {
         return when (key) {
             is BCECPublicKey, is EdDSAPublicKey -> publicKeyOnCurve(signatureScheme, key)
@@ -912,7 +913,7 @@ object Crypto {
         }
     }
 
-    // check if a private key satisfies algorithm specs.
+    // Check if a private key satisfies algorithm specs.
     private fun validatePrivateKey(signatureScheme: SignatureScheme, key: PrivateKey): Boolean {
         return when (key) {
             is BCECPrivateKey -> key.parameters == signatureScheme.algSpec
@@ -924,7 +925,6 @@ object Crypto {
 
     /**
      * Convert a public key to a supported implementation.
-     *
      * @param key a public key.
      * @return a supported implementation of the input public key.
      * @throws IllegalArgumentException on not supported scheme or if the given key specification
diff --git a/core/src/main/kotlin/net/corda/core/crypto/CryptoUtils.kt b/core/src/main/kotlin/net/corda/core/crypto/CryptoUtils.kt
index 32b14cffcd..17bd078862 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/CryptoUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/CryptoUtils.kt
@@ -20,9 +20,19 @@ import java.security.*
  * @throws InvalidKeyException if the private key is invalid.
  * @throws SignatureException if signing is not possible due to malformed data or private key.
  */
-@Throws(IllegalArgumentException::class, InvalidKeyException::class, SignatureException::class)
+@Throws(InvalidKeyException::class, SignatureException::class)
 fun PrivateKey.sign(bytesToSign: ByteArray): DigitalSignature = DigitalSignature(Crypto.doSign(this, bytesToSign))
 
+/**
+ * Utility to simplify the act of signing a byte array and return a [DigitalSignature.WithKey] object.
+ * Note that there is no check if the public key matches with the signing private key.
+ * @param bytesToSign the data/message to be signed in [ByteArray] form (usually the Merkle root).
+ * @return the [DigitalSignature.WithKey] object on the input message [bytesToSign] and [publicKey].
+ * @throws IllegalArgumentException if the signature scheme is not supported for this private key.
+ * @throws InvalidKeyException if the private key is invalid.
+ * @throws SignatureException if signing is not possible due to malformed data or private key.
+ */
+@Throws(InvalidKeyException::class, SignatureException::class)
 fun PrivateKey.sign(bytesToSign: ByteArray, publicKey: PublicKey) = DigitalSignature.WithKey(publicKey, this.sign(bytesToSign).bytes)
 
 /**
@@ -33,10 +43,13 @@ fun PrivateKey.sign(bytesToSign: ByteArray, publicKey: PublicKey) = DigitalSigna
  * @throws InvalidKeyException if the private key is invalid.
  * @throws SignatureException if signing is not possible due to malformed data or private key.
  */
-@Throws(IllegalArgumentException::class, InvalidKeyException::class, SignatureException::class)
+@Throws(InvalidKeyException::class, SignatureException::class)
 fun KeyPair.sign(bytesToSign: ByteArray) = private.sign(bytesToSign, public)
 
+/** Helper function to sign the bytes of [bytesToSign] with a key pair. */
+@Throws(InvalidKeyException::class, SignatureException::class)
 fun KeyPair.sign(bytesToSign: OpaqueBytes) = sign(bytesToSign.bytes)
+
 /**
  * Helper function for signing a [SignableData] object.
  * @param signableData the object to be signed.
@@ -56,8 +69,8 @@ fun KeyPair.sign(signableData: SignableData): TransactionSignature = Crypto.doSi
  * @throws SignatureException if the signature is invalid (i.e. damaged), or does not match the key (incorrect).
  * @throws IllegalArgumentException if the signature scheme is not supported or if any of the clear or signature data is empty.
  */
-// TODO: SignatureException should be used only for a damaged signature, as per `java.security.Signature.verify()`,
-@Throws(SignatureException::class, IllegalArgumentException::class, InvalidKeyException::class)
+// TODO: SignatureException should be used only for a damaged signature, as per `java.security.Signature.verify()`.
+@Throws(SignatureException::class, InvalidKeyException::class)
 fun PublicKey.verify(content: ByteArray, signature: DigitalSignature) = Crypto.doVerify(this, signature.bytes, content)
 
 /**
@@ -70,9 +83,10 @@ fun PublicKey.verify(content: ByteArray, signature: DigitalSignature) = Crypto.d
  * signature).
  * @throws SignatureException if the signature is invalid (i.e. damaged).
  * @throws IllegalArgumentException if the signature scheme is not supported or if any of the clear or signature data is empty.
+ * @throws IllegalStateException if this is a [CompositeKey], because verification of composite key signatures is not supported.
  * @return whether the signature is correct for this key.
  */
-@Throws(IllegalStateException::class, SignatureException::class, IllegalArgumentException::class)
+@Throws(SignatureException::class, InvalidKeyException::class)
 fun PublicKey.isValid(content: ByteArray, signature: DigitalSignature): Boolean {
     if (this is CompositeKey)
         throw IllegalStateException("Verification of CompositeKey signatures currently not supported.") // TODO CompositeSignature verification.
@@ -82,9 +96,12 @@ fun PublicKey.isValid(content: ByteArray, signature: DigitalSignature): Boolean
 /** Render a public key to its hash (in Base58) of its serialised form using the DL prefix. */
 fun PublicKey.toStringShort(): String = "DL" + this.toSHA256Bytes().toBase58()
 
+/** Return a [Set] of the contained keys if this is a [CompositeKey]; otherwise, return a [Set] with a single element (this [PublicKey]). */
 val PublicKey.keys: Set<PublicKey> get() = (this as? CompositeKey)?.leafKeys ?: setOf(this)
 
+/** Return true if [otherKey] fulfils the requirements of this [PublicKey]. */
 fun PublicKey.isFulfilledBy(otherKey: PublicKey): Boolean = isFulfilledBy(setOf(otherKey))
+/** Return true if [otherKeys] fulfil the requirements of this [PublicKey]. */
 fun PublicKey.isFulfilledBy(otherKeys: Iterable<PublicKey>): Boolean = (this as? CompositeKey)?.isFulfilledBy(otherKeys) ?: (this in otherKeys)
 
 /** Checks whether any of the given [keys] matches a leaf on the [CompositeKey] tree or a single [PublicKey]. */
@@ -98,8 +115,9 @@ fun Iterable<TransactionSignature>.byKeys() = map { it.by }.toSet()
 
 // Allow Kotlin destructuring:
 // val (private, public) = keyPair
+/* The [PrivateKey] of this [KeyPair] .*/
 operator fun KeyPair.component1(): PrivateKey = this.private
-
+/* The [PublicKey] of this [KeyPair] .*/
 operator fun KeyPair.component2(): PublicKey = this.public
 
 /** A simple wrapper that will make it easier to swap out the EC algorithm we use in future. */
@@ -122,7 +140,7 @@ fun entropyToKeyPair(entropy: BigInteger): KeyPair = Crypto.deriveKeyPairFromEnt
  * if this signatureData algorithm is unable to process the input data provided, etc.
  * @throws IllegalArgumentException if the signature scheme is not supported for this private key or if any of the clear or signature data is empty.
  */
-@Throws(InvalidKeyException::class, SignatureException::class, IllegalArgumentException::class)
+@Throws(InvalidKeyException::class, SignatureException::class)
 fun PublicKey.verify(signatureData: ByteArray, clearData: ByteArray): Boolean = Crypto.doVerify(this, signatureData, clearData)
 
 /**
@@ -135,7 +153,7 @@ fun PublicKey.verify(signatureData: ByteArray, clearData: ByteArray): Boolean =
  * if this signatureData algorithm is unable to process the input data provided, etc.
  * @throws IllegalArgumentException if the signature scheme is not supported for this private key or if any of the clear or signature data is empty.
  */
-@Throws(InvalidKeyException::class, SignatureException::class, IllegalArgumentException::class)
+@Throws(InvalidKeyException::class, SignatureException::class)
 fun KeyPair.verify(signatureData: ByteArray, clearData: ByteArray): Boolean = Crypto.doVerify(this.public, signatureData, clearData)
 
 /**
diff --git a/core/src/main/kotlin/net/corda/core/utilities/EncodingUtils.kt b/core/src/main/kotlin/net/corda/core/utilities/EncodingUtils.kt
index 2c1854c897..2fd31c9590 100644
--- a/core/src/main/kotlin/net/corda/core/utilities/EncodingUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/utilities/EncodingUtils.kt
@@ -3,9 +3,8 @@
 package net.corda.core.utilities
 
 import net.corda.core.crypto.Base58
+import net.corda.core.crypto.Crypto
 import net.corda.core.crypto.sha256
-import net.corda.core.serialization.deserialize
-import net.corda.core.serialization.serialize
 import java.nio.charset.Charset
 import java.security.PublicKey
 import java.util.*
@@ -15,11 +14,13 @@ import javax.xml.bind.DatatypeConverter
 
 // [ByteArray] encoders
 
+/** Convert a byte array to a Base58 encoded [String]. */
 fun ByteArray.toBase58(): String = Base58.encode(this)
 
+/** Convert a byte array to a Base64 encoded [String]. */
 fun ByteArray.toBase64(): String = Base64.getEncoder().encodeToString(this)
 
-/** Convert a byte array to a hex (base 16) capitalized encoded string.*/
+/** Convert a byte array to a hex (Base16) capitalized encoded [String]. */
 fun ByteArray.toHex(): String = DatatypeConverter.printHexBinary(this)
 
 
@@ -65,7 +66,15 @@ fun String.hexToBase64(): String = hexToByteArray().toBase64()
 // TODO We use for both CompositeKeys and EdDSAPublicKey custom serializers and deserializers. We need to specify encoding.
 // TODO: follow the crypto-conditions ASN.1 spec, some changes are needed to be compatible with the condition
 //       structure, e.g. mapping a PublicKey to a condition with the specific feature (ED25519).
-fun parsePublicKeyBase58(base58String: String): PublicKey = base58String.base58ToByteArray().deserialize<PublicKey>()
+/**
+ * Method to return the [PublicKey] object given its Base58-[String] representation.
+ * @param base58String the Base58 encoded format of the serialised [PublicKey].
+ * @return the resulted [PublicKey] after decoding the [base58String] input and then deserialising to a [PublicKey] object.
+ */
+fun parsePublicKeyBase58(base58String: String): PublicKey = Crypto.decodePublicKey(base58String.base58ToByteArray())
 
-fun PublicKey.toBase58String(): String = this.serialize().bytes.toBase58()
-fun PublicKey.toSHA256Bytes(): ByteArray = this.serialize().bytes.sha256().bytes // TODO: decide on the format of hashed key (encoded Vs serialised).
+/** Return the Base58 representation of the serialised public key. */
+fun PublicKey.toBase58String(): String = this.encoded.toBase58()
+
+/** Return the bytes of the SHA-256 output for this public key. */
+fun PublicKey.toSHA256Bytes(): ByteArray = this.encoded.sha256().bytes

From 327f0ebd7363a66b258f0c82b3b90ee2019dc045 Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Wed, 11 Oct 2017 18:26:09 +0100
Subject: [PATCH 164/185] CORDA-654: Migrate test APIs to match identity
 changes (#1744)

Rework identity usage in tests to extract identity from nodes by name, rather than just arbitrarily choosing the first identity. This better models the intended design for production (future work).
---
 .../confidential/SwapIdentitiesFlowTests.kt   |  4 +-
 .../kotlin/net/corda/core/node/NodeInfo.kt    |  6 ++
 .../net/corda/core/flows/AttachmentTests.kt   | 15 ++---
 .../core/flows/CollectSignaturesFlowTests.kt  | 23 +++++---
 .../net/corda/core/flows/FinalityFlowTests.kt | 42 ++++++++------
 .../WorkflowTransactionBuildTutorialTest.kt   | 57 +++++++++++--------
 .../corda/node/services/NotaryChangeTests.kt  | 16 +++---
 .../ValidatingNotaryServiceTests.kt           | 39 +++++++------
 .../corda/bank/BankOfCordaRPCClientTest.kt    |  4 +-
 .../kotlin/net/corda/testing/node/MockNode.kt |  9 +--
 .../kotlin/net/corda/testing/TestConstants.kt | 10 +++-
 .../net/corda/verifier/VerifierTests.kt       | 18 +++---
 12 files changed, 142 insertions(+), 101 deletions(-)

diff --git a/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt b/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
index 55e9ef9d26..3a0e6602fe 100644
--- a/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
+++ b/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
@@ -19,8 +19,8 @@ class SwapIdentitiesFlowTests {
         val notaryNode = mockNet.createNotaryNode()
         val aliceNode = mockNet.createPartyNode(ALICE.name)
         val bobNode = mockNet.createPartyNode(BOB.name)
-        val alice: Party = aliceNode.services.myInfo.chooseIdentity()
-        val bob: Party = bobNode.services.myInfo.chooseIdentity()
+        val alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
+        val bob = bobNode.services.myInfo.identityFromX500Name(BOB_NAME)
 
         // Run the flows
         val requesterFlow = aliceNode.services.startFlow(SwapIdentitiesFlow(bob))
diff --git a/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt b/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
index cf3e5aed2e..07e6c550be 100644
--- a/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
+++ b/core/src/main/kotlin/net/corda/core/node/NodeInfo.kt
@@ -1,5 +1,6 @@
 package net.corda.core.node
 
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.identity.PartyAndCertificate
 import net.corda.core.serialization.CordaSerializable
@@ -42,4 +43,9 @@ data class NodeInfo(val addresses: List<NetworkHostAndPort>,
 
     /** Returns true if [party] is one of the identities of this node, else false. */
     fun isLegalIdentity(party: Party): Boolean = party in legalIdentities
+
+    fun identityFromX500Name(name: CordaX500Name): Party  {
+        val identity = legalIdentitiesAndCerts.singleOrNull { it.name == name } ?: throw IllegalArgumentException("Node does not have an identity \"$name\"")
+        return identity.party
+    }
 }
diff --git a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
index 6a2bf1ef8b..ab4936d6fc 100644
--- a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
@@ -15,8 +15,8 @@ import net.corda.node.services.persistence.NodeAttachmentService
 import net.corda.node.utilities.DatabaseTransactionManager
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.ALICE
+import net.corda.testing.ALICE_NAME
 import net.corda.testing.BOB
-import net.corda.testing.chooseIdentity
 import net.corda.testing.node.MockNetwork
 import org.junit.After
 import org.junit.Before
@@ -55,13 +55,13 @@ class AttachmentTests {
 
     @Test
     fun `download and store`() {
-        mockNet.createNotaryNode()
         val aliceNode = mockNet.createPartyNode(ALICE.name)
         val bobNode = mockNet.createPartyNode(BOB.name)
 
         // Ensure that registration was successful before progressing any further
         mockNet.runNetwork()
         aliceNode.internals.ensureRegistered()
+        val alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
 
         aliceNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
         bobNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
@@ -73,7 +73,7 @@ class AttachmentTests {
 
         // Get node one to run a flow to fetch it and insert it.
         mockNet.runNetwork()
-        val bobFlow = bobNode.startAttachmentFlow(setOf(id), aliceNode.info.chooseIdentity())
+        val bobFlow = bobNode.startAttachmentFlow(setOf(id), alice)
         mockNet.runNetwork()
         assertEquals(0, bobFlow.resultFuture.getOrThrow().fromDisk.size)
 
@@ -87,13 +87,12 @@ class AttachmentTests {
         // Shut down node zero and ensure node one can still resolve the attachment.
         aliceNode.dispose()
 
-        val response: FetchDataFlow.Result<Attachment> = bobNode.startAttachmentFlow(setOf(id), aliceNode.info.chooseIdentity()).resultFuture.getOrThrow()
+        val response: FetchDataFlow.Result<Attachment> = bobNode.startAttachmentFlow(setOf(id), alice).resultFuture.getOrThrow()
         assertEquals(attachment, response.fromDisk[0])
     }
 
     @Test
     fun `missing`() {
-        mockNet.createNotaryNode()
         val aliceNode = mockNet.createPartyNode(ALICE.name)
         val bobNode = mockNet.createPartyNode(BOB.name)
 
@@ -107,7 +106,8 @@ class AttachmentTests {
         // Get node one to fetch a non-existent attachment.
         val hash = SecureHash.randomSHA256()
         mockNet.runNetwork()
-        val bobFlow = bobNode.startAttachmentFlow(setOf(hash), aliceNode.info.chooseIdentity())
+        val alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
+        val bobFlow = bobNode.startAttachmentFlow(setOf(hash), alice)
         mockNet.runNetwork()
         val e = assertFailsWith<FetchDataFlow.HashNotFound> { bobFlow.resultFuture.getOrThrow() }
         assertEquals(hash, e.requested)
@@ -130,6 +130,7 @@ class AttachmentTests {
         // Ensure that registration was successful before progressing any further
         mockNet.runNetwork()
         aliceNode.internals.ensureRegistered()
+        val alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
 
         aliceNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
         bobNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
@@ -151,7 +152,7 @@ class AttachmentTests {
 
         // Get n1 to fetch the attachment. Should receive corrupted bytes.
         mockNet.runNetwork()
-        val bobFlow = bobNode.startAttachmentFlow(setOf(id), aliceNode.info.chooseIdentity())
+        val bobFlow = bobNode.startAttachmentFlow(setOf(id), alice)
         mockNet.runNetwork()
         assertFailsWith<FetchDataFlow.DownloadedVsRequestedDataMismatch> { bobFlow.resultFuture.getOrThrow() }
     }
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 984646750c..d2c2a846ac 100644
--- a/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
@@ -31,6 +31,9 @@ class CollectSignaturesFlowTests {
     lateinit var aliceNode: StartedNode<MockNetwork.MockNode>
     lateinit var bobNode: StartedNode<MockNetwork.MockNode>
     lateinit var charlieNode: StartedNode<MockNetwork.MockNode>
+    lateinit var alice: Party
+    lateinit var bob: Party
+    lateinit var charlie: Party
     lateinit var notary: Party
 
     @Before
@@ -41,8 +44,11 @@ class CollectSignaturesFlowTests {
         bobNode = mockNet.createPartyNode(BOB.name)
         charlieNode = mockNet.createPartyNode(CHARLIE.name)
         mockNet.runNetwork()
-        notary = notaryNode.services.getDefaultNotary()
         aliceNode.internals.ensureRegistered()
+        alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
+        bob = bobNode.services.myInfo.identityFromX500Name(BOB_NAME)
+        charlie = charlieNode.services.myInfo.identityFromX500Name(CHARLIE_NAME)
+        notary = notaryNode.services.networkMapCache.getNotary(DUMMY_NOTARY_SERVICE_NAME)!!
     }
 
     @After
@@ -143,7 +149,8 @@ class CollectSignaturesFlowTests {
     @Test
     fun `successfully collects two signatures`() {
         val bConfidentialIdentity = bobNode.database.transaction {
-            bobNode.services.keyManagementService.freshKeyAndCert(bobNode.info.chooseIdentityAndCert(), false)
+            val bobCert = bobNode.services.myInfo.legalIdentitiesAndCerts.single { it.name == bob.name }
+            bobNode.services.keyManagementService.freshKeyAndCert(bobCert, false)
         }
         aliceNode.database.transaction {
             // Normally this is handled by TransactionKeyFlow, but here we have to manually let A know about the identity
@@ -151,7 +158,7 @@ class CollectSignaturesFlowTests {
         }
         registerFlowOnAllNodes(TestFlowTwo.Responder::class)
         val magicNumber = 1337
-        val parties = listOf(aliceNode.info.chooseIdentity(), bConfidentialIdentity.party, charlieNode.info.chooseIdentity())
+        val parties = listOf(alice, bConfidentialIdentity.party, charlie)
         val state = DummyContract.MultiOwnerState(magicNumber, parties)
         val flow = aliceNode.services.startFlow(TestFlowTwo.Initiator(state))
         mockNet.runNetwork()
@@ -163,7 +170,7 @@ class CollectSignaturesFlowTests {
 
     @Test
     fun `no need to collect any signatures`() {
-        val onePartyDummyContract = DummyContract.generateInitial(1337, notary, aliceNode.info.chooseIdentity().ref(1))
+        val onePartyDummyContract = DummyContract.generateInitial(1337, notary, alice.ref(1))
         val ptx = aliceNode.services.signInitialTransaction(onePartyDummyContract)
         val flow = aliceNode.services.startFlow(CollectSignaturesFlow(ptx, emptySet()))
         mockNet.runNetwork()
@@ -175,7 +182,7 @@ class CollectSignaturesFlowTests {
 
     @Test
     fun `fails when not signed by initiator`() {
-        val onePartyDummyContract = DummyContract.generateInitial(1337, notary, aliceNode.info.chooseIdentity().ref(1))
+        val onePartyDummyContract = DummyContract.generateInitial(1337, notary, alice.ref(1))
         val miniCorpServices = MockServices(cordappPackages, MINI_CORP_KEY)
         val ptx = miniCorpServices.signInitialTransaction(onePartyDummyContract)
         val flow = aliceNode.services.startFlow(CollectSignaturesFlow(ptx, emptySet()))
@@ -188,9 +195,9 @@ class CollectSignaturesFlowTests {
     @Test
     fun `passes with multiple initial signatures`() {
         val twoPartyDummyContract = DummyContract.generateInitial(1337, notary,
-                aliceNode.info.chooseIdentity().ref(1),
-                bobNode.info.chooseIdentity().ref(2),
-                bobNode.info.chooseIdentity().ref(3))
+                alice.ref(1),
+                bob.ref(2),
+                bob.ref(3))
         val signedByA = aliceNode.services.signInitialTransaction(twoPartyDummyContract)
         val signedByBoth = bobNode.services.addSignature(signedByA)
         val flow = aliceNode.services.startFlow(CollectSignaturesFlow(signedByBoth, emptySet()))
diff --git a/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt b/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
index e17da0775b..a68d4542c8 100644
--- a/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
@@ -6,7 +6,7 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.finance.POUNDS
 import net.corda.finance.contracts.asset.Cash
 import net.corda.finance.issuedBy
-import net.corda.node.internal.StartedNode
+import net.corda.node.services.api.ServiceHubInternal
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import org.junit.After
@@ -16,20 +16,26 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class FinalityFlowTests {
-    lateinit var mockNet: MockNetwork
-    lateinit var aliceNode: StartedNode<MockNetwork.MockNode>
-    lateinit var bobNode: StartedNode<MockNetwork.MockNode>
-    lateinit var notary: Party
+    private lateinit var mockNet: MockNetwork
+    private lateinit var aliceServices: ServiceHubInternal
+    private lateinit var bobServices: ServiceHubInternal
+    private lateinit var alice: Party
+    private lateinit var bob: Party
+    private lateinit var notary: Party
 
     @Before
     fun setup() {
         mockNet = MockNetwork(cordappPackages = listOf("net.corda.finance.contracts.asset"))
-        mockNet.createNotaryNode()
-        aliceNode = mockNet.createPartyNode(ALICE.name)
-        bobNode = mockNet.createPartyNode(BOB.name)
+        val notaryNode = mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
         mockNet.runNetwork()
         aliceNode.internals.ensureRegistered()
-        notary = aliceNode.services.getDefaultNotary()
+        aliceServices = aliceNode.services
+        bobServices = bobNode.services
+        alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
+        bob = bobNode.services.myInfo.identityFromX500Name(BOB_NAME)
+        notary = notaryNode.services.networkMapCache.getNotary(DUMMY_NOTARY_SERVICE_NAME)!!
     }
 
     @After
@@ -39,28 +45,28 @@ class FinalityFlowTests {
 
     @Test
     fun `finalise a simple transaction`() {
-        val amount = 1000.POUNDS.issuedBy(aliceNode.info.chooseIdentity().ref(0))
+        val amount = 1000.POUNDS.issuedBy(alice.ref(0))
         val builder = TransactionBuilder(notary)
-        Cash().generateIssue(builder, amount, bobNode.info.chooseIdentity(), notary)
-        val stx = aliceNode.services.signInitialTransaction(builder)
-        val flow = aliceNode.services.startFlow(FinalityFlow(stx))
+        Cash().generateIssue(builder, amount, bob, notary)
+        val stx = aliceServices.signInitialTransaction(builder)
+        val flow = aliceServices.startFlow(FinalityFlow(stx))
         mockNet.runNetwork()
         val notarisedTx = flow.resultFuture.getOrThrow()
         notarisedTx.verifyRequiredSignatures()
-        val transactionSeenByB = bobNode.services.database.transaction {
-            bobNode.services.validatedTransactions.getTransaction(notarisedTx.id)
+        val transactionSeenByB = bobServices.database.transaction {
+            bobServices.validatedTransactions.getTransaction(notarisedTx.id)
         }
         assertEquals(notarisedTx, transactionSeenByB)
     }
 
     @Test
     fun `reject a transaction with unknown parties`() {
-        val amount = 1000.POUNDS.issuedBy(aliceNode.info.chooseIdentity().ref(0))
+        val amount = 1000.POUNDS.issuedBy(alice.ref(0))
         val fakeIdentity = CHARLIE // Charlie isn't part of this network, so node A won't recognise them
         val builder = TransactionBuilder(notary)
         Cash().generateIssue(builder, amount, fakeIdentity, notary)
-        val stx = aliceNode.services.signInitialTransaction(builder)
-        val flow = aliceNode.services.startFlow(FinalityFlow(stx))
+        val stx = aliceServices.signInitialTransaction(builder)
+        val flow = aliceServices.startFlow(FinalityFlow(stx))
         mockNet.runNetwork()
         assertFailsWith<IllegalArgumentException> {
             flow.resultFuture.getOrThrow()
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
index 089885d5f5..f7b99ead79 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
@@ -3,14 +3,14 @@ package net.corda.docs
 import net.corda.core.contracts.LinearState
 import net.corda.core.contracts.StateAndRef
 import net.corda.core.contracts.UniqueIdentifier
+import net.corda.core.identity.Party
 import net.corda.core.node.ServiceHub
 import net.corda.core.node.services.queryBy
 import net.corda.core.node.services.vault.QueryCriteria
 import net.corda.core.toFuture
 import net.corda.core.utilities.getOrThrow
-import net.corda.node.internal.StartedNode
-import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.chooseIdentity
+import net.corda.node.services.api.ServiceHubInternal
+import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import org.junit.After
 import org.junit.Before
@@ -19,8 +19,10 @@ import kotlin.test.assertEquals
 
 class WorkflowTransactionBuildTutorialTest {
     lateinit var mockNet: MockNetwork
-    lateinit var nodeA: StartedNode<MockNetwork.MockNode>
-    lateinit var nodeB: StartedNode<MockNetwork.MockNode>
+    lateinit var aliceServices: ServiceHubInternal
+    lateinit var bobServices: ServiceHubInternal
+    lateinit var alice: Party
+    lateinit var bob: Party
 
     // Helper method to locate the latest Vault version of a LinearState
     private inline fun <reified T : LinearState> ServiceHub.latest(ref: UniqueIdentifier): StateAndRef<T> {
@@ -31,10 +33,15 @@ class WorkflowTransactionBuildTutorialTest {
     @Before
     fun setup() {
         mockNet = MockNetwork(threadPerNode = true, cordappPackages = listOf("net.corda.docs"))
+        // While we don't use the notary, we need there to be one on the network
         mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
-        nodeA = mockNet.createPartyNode()
-        nodeB = mockNet.createPartyNode()
-        nodeA.internals.registerInitiatedFlow(RecordCompletionFlow::class.java)
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
+        aliceNode.internals.registerInitiatedFlow(RecordCompletionFlow::class.java)
+        aliceServices = aliceNode.services
+        bobServices = bobNode.services
+        alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
+        bob = bobNode.services.myInfo.identityFromX500Name(BOB_NAME)
     }
 
     @After
@@ -45,50 +52,50 @@ class WorkflowTransactionBuildTutorialTest {
     @Test
     fun `Run workflow to completion`() {
         // Setup a vault subscriber to wait for successful upload of the proposal to NodeB
-        val nodeBVaultUpdate = nodeB.services.vaultService.updates.toFuture()
+        val nodeBVaultUpdate = bobServices.vaultService.updates.toFuture()
         // Kick of the proposal flow
-        val flow1 = nodeA.services.startFlow(SubmitTradeApprovalFlow("1234", nodeB.info.chooseIdentity()))
+        val flow1 = aliceServices.startFlow(SubmitTradeApprovalFlow("1234", bob))
         // Wait for the flow to finish
         val proposalRef = flow1.resultFuture.getOrThrow()
         val proposalLinearId = proposalRef.state.data.linearId
         // Wait for NodeB to include it's copy in the vault
         nodeBVaultUpdate.get()
         // Fetch the latest copy of the state from both nodes
-        val latestFromA = nodeA.database.transaction {
-            nodeA.services.latest<TradeApprovalContract.State>(proposalLinearId)
+        val latestFromA = aliceServices.database.transaction {
+            aliceServices.latest<TradeApprovalContract.State>(proposalLinearId)
         }
-        val latestFromB = nodeB.database.transaction {
-            nodeB.services.latest<TradeApprovalContract.State>(proposalLinearId)
+        val latestFromB = bobServices.database.transaction {
+            bobServices.latest<TradeApprovalContract.State>(proposalLinearId)
         }
         // Confirm the state as as expected
         assertEquals(WorkflowState.NEW, proposalRef.state.data.state)
         assertEquals("1234", proposalRef.state.data.tradeId)
-        assertEquals(nodeA.info.chooseIdentity(), proposalRef.state.data.source)
-        assertEquals(nodeB.info.chooseIdentity(), proposalRef.state.data.counterparty)
+        assertEquals(alice, proposalRef.state.data.source)
+        assertEquals(bob, proposalRef.state.data.counterparty)
         assertEquals(proposalRef, latestFromA)
         assertEquals(proposalRef, latestFromB)
         // Setup a vault subscriber to pause until the final update is in NodeA and NodeB
-        val nodeAVaultUpdate = nodeA.services.vaultService.updates.toFuture()
-        val secondNodeBVaultUpdate = nodeB.services.vaultService.updates.toFuture()
+        val nodeAVaultUpdate = aliceServices.vaultService.updates.toFuture()
+        val secondNodeBVaultUpdate = bobServices.vaultService.updates.toFuture()
         // Run the manual completion flow from NodeB
-        val flow2 = nodeB.services.startFlow(SubmitCompletionFlow(latestFromB.ref, WorkflowState.APPROVED))
+        val flow2 = bobServices.startFlow(SubmitCompletionFlow(latestFromB.ref, WorkflowState.APPROVED))
         // wait for the flow to end
         val completedRef = flow2.resultFuture.getOrThrow()
         // wait for the vault updates to stabilise
         nodeAVaultUpdate.get()
         secondNodeBVaultUpdate.get()
         // Fetch the latest copies from the vault
-        val finalFromA = nodeA.database.transaction {
-            nodeA.services.latest<TradeApprovalContract.State>(proposalLinearId)
+        val finalFromA = aliceServices.database.transaction {
+            aliceServices.latest<TradeApprovalContract.State>(proposalLinearId)
         }
-        val finalFromB = nodeB.database.transaction {
-            nodeB.services.latest<TradeApprovalContract.State>(proposalLinearId)
+        val finalFromB = bobServices.database.transaction {
+            bobServices.latest<TradeApprovalContract.State>(proposalLinearId)
         }
         // Confirm the state is as expected
         assertEquals(WorkflowState.APPROVED, completedRef.state.data.state)
         assertEquals("1234", completedRef.state.data.tradeId)
-        assertEquals(nodeA.info.chooseIdentity(), completedRef.state.data.source)
-        assertEquals(nodeB.info.chooseIdentity(), completedRef.state.data.counterparty)
+        assertEquals(alice, completedRef.state.data.source)
+        assertEquals(bob, completedRef.state.data.counterparty)
         assertEquals(completedRef, finalFromA)
         assertEquals(completedRef, finalFromB)
     }
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 957d6ac442..58aea5fac8 100644
--- a/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
@@ -7,11 +7,13 @@ import net.corda.core.flows.NotaryFlow
 import net.corda.core.flows.StateReplacementException
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
+import net.corda.core.node.ServiceHub
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.transactions.WireTransaction
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.seconds
 import net.corda.node.internal.StartedNode
+import net.corda.node.services.api.ServiceHubInternal
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
@@ -39,11 +41,11 @@ class NotaryChangeTests {
         oldNotaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         clientNodeA = mockNet.createNode()
         clientNodeB = mockNet.createNode()
-        newNotaryNode = mockNet.createNotaryNode()
+        newNotaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name.copy(organisation = "Dummy Notary 2"))
         mockNet.runNetwork() // Clear network map registration messages
         oldNotaryNode.internals.ensureRegistered()
-        newNotaryParty = newNotaryNode.info.legalIdentities[1]
-        oldNotaryParty = oldNotaryNode.info.legalIdentities[1]
+        oldNotaryParty = newNotaryNode.services.networkMapCache.getNotary(DUMMY_NOTARY_SERVICE_NAME)!!
+        newNotaryParty = newNotaryNode.services.networkMapCache.getNotary(DUMMY_NOTARY_SERVICE_NAME.copy(organisation = "Dummy Notary 2"))!!
     }
 
     @After
@@ -211,10 +213,10 @@ fun issueMultiPartyState(nodeA: StartedNode<*>, nodeB: StartedNode<*>, notaryNod
     return stx.tx.outRef(0)
 }
 
-fun issueInvalidState(node: StartedNode<*>, notary: Party): StateAndRef<DummyContract.SingleOwnerState> {
-    val tx = DummyContract.generateInitial(Random().nextInt(), notary, node.info.chooseIdentity().ref(0))
+fun issueInvalidState(services: ServiceHub, identity: Party, notary: Party): StateAndRef<DummyContract.SingleOwnerState> {
+    val tx = DummyContract.generateInitial(Random().nextInt(), notary, identity.ref(0))
     tx.setTimeWindow(Instant.now(), 30.seconds)
-    val stx = node.services.signInitialTransaction(tx)
-    node.services.recordTransactions(stx)
+    val stx = services.signInitialTransaction(tx)
+    services.recordTransactions(stx)
     return stx.tx.outRef(0)
 }
\ No newline at end of file
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
index 740c51be74..a137cc41e9 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
@@ -9,10 +9,11 @@ import net.corda.core.flows.NotaryError
 import net.corda.core.flows.NotaryException
 import net.corda.core.flows.NotaryFlow
 import net.corda.core.identity.Party
+import net.corda.core.node.ServiceHub
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.getOrThrow
-import net.corda.node.internal.StartedNode
+import net.corda.node.services.api.ServiceHubInternal
 import net.corda.node.services.issueInvalidState
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
@@ -27,18 +28,22 @@ import kotlin.test.assertFailsWith
 
 class ValidatingNotaryServiceTests {
     lateinit var mockNet: MockNetwork
-    lateinit var notaryNode: StartedNode<MockNetwork.MockNode>
-    lateinit var clientNode: StartedNode<MockNetwork.MockNode>
+    lateinit var notaryServices: ServiceHubInternal
+    lateinit var aliceServices: ServiceHubInternal
     lateinit var notary: Party
+    lateinit var alice: Party
 
     @Before
     fun setup() {
         mockNet = MockNetwork(cordappPackages = listOf("net.corda.testing.contracts"))
-        notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
-        clientNode = mockNet.createNode()
+        val notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
+        val aliceNode = mockNet.createNode(legalName = ALICE_NAME)
         mockNet.runNetwork() // Clear network map registration messages
         notaryNode.internals.ensureRegistered()
-        notary = clientNode.services.getDefaultNotary()
+        notaryServices = notaryNode.services
+        aliceServices = aliceNode.services
+        notary = notaryServices.networkMapCache.getNotary(DUMMY_NOTARY_SERVICE_NAME)!!
+        alice = aliceServices.myInfo.identityFromX500Name(ALICE_NAME)
     }
 
     @After
@@ -49,11 +54,11 @@ class ValidatingNotaryServiceTests {
     @Test
     fun `should report error for invalid transaction dependency`() {
         val stx = run {
-            val inputState = issueInvalidState(clientNode, notary)
+            val inputState = issueInvalidState(aliceServices, alice, notary)
             val tx = TransactionBuilder(notary)
                     .addInputState(inputState)
-                    .addCommand(dummyCommand(clientNode.info.chooseIdentity().owningKey))
-            clientNode.services.signInitialTransaction(tx)
+                    .addCommand(dummyCommand(alice.owningKey))
+            aliceServices.signInitialTransaction(tx)
         }
 
         val future = runClient(stx)
@@ -67,11 +72,11 @@ class ValidatingNotaryServiceTests {
     fun `should report error for missing signatures`() {
         val expectedMissingKey = MEGA_CORP_KEY.public
         val stx = run {
-            val inputState = issueState(clientNode)
+            val inputState = issueState(aliceServices, alice)
 
             val command = Command(DummyContract.Commands.Move(), expectedMissingKey)
             val tx = TransactionBuilder(notary).withItems(inputState, command)
-            clientNode.services.signInitialTransaction(tx)
+            aliceServices.signInitialTransaction(tx)
         }
 
         val ex = assertFailsWith(NotaryException::class) {
@@ -87,16 +92,16 @@ class ValidatingNotaryServiceTests {
 
     private fun runClient(stx: SignedTransaction): CordaFuture<List<TransactionSignature>> {
         val flow = NotaryFlow.Client(stx)
-        val future = clientNode.services.startFlow(flow).resultFuture
+        val future = aliceServices.startFlow(flow).resultFuture
         mockNet.runNetwork()
         return future
     }
 
-    fun issueState(node: StartedNode<*>): StateAndRef<*> {
-        val tx = DummyContract.generateInitial(Random().nextInt(), notary, node.info.chooseIdentity().ref(0))
-        val signedByNode = node.services.signInitialTransaction(tx)
-        val stx = notaryNode.services.addSignature(signedByNode, notary.owningKey)
-        node.services.recordTransactions(stx)
+    fun issueState(serviceHub: ServiceHub, identity: Party): StateAndRef<*> {
+        val tx = DummyContract.generateInitial(Random().nextInt(), notary, identity.ref(0))
+        val signedByNode = serviceHub.signInitialTransaction(tx)
+        val stx = notaryServices.addSignature(signedByNode, notary.owningKey)
+        serviceHub.recordTransactions(stx)
         return StateAndRef(tx.outputStates().first(), StateRef(stx.id, 0))
     }
 }
diff --git a/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt b/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt
index d379e3b98a..147d6a65e0 100644
--- a/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt
+++ b/samples/bank-of-corda-demo/src/integration-test/kotlin/net/corda/bank/BankOfCordaRPCClientTest.kt
@@ -41,12 +41,14 @@ class BankOfCordaRPCClientTest {
             // Register for Big Corporation Vault updates
             val vaultUpdatesBigCorp = bigCorpProxy.vaultTrackByCriteria(Cash.State::class.java, criteria).updates
 
+            val bigCorporation = bigCorpProxy.wellKnownPartyFromX500Name(BIGCORP_LEGAL_NAME)!!
+
             // Kick-off actual Issuer Flow
             val anonymous = true
             val notary = bocProxy.notaryIdentities().first()
             bocProxy.startFlow(::CashIssueAndPaymentFlow,
                     1000.DOLLARS, BIG_CORP_PARTY_REF,
-                    nodeBigCorporation.nodeInfo.chooseIdentity(),
+                    bigCorporation,
                     anonymous,
                     notary).returnValue.getOrThrow()
 
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
index 84dc90fe02..ae810b581a 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockNode.kt
@@ -44,12 +44,9 @@ import net.corda.node.utilities.AffinityExecutor
 import net.corda.node.utilities.AffinityExecutor.ServiceAffinityExecutor
 import net.corda.node.utilities.CertificateAndKeyPair
 import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.testing.DUMMY_KEY_1
-import net.corda.testing.initialiseTestSerialization
+import net.corda.testing.*
 import net.corda.testing.node.MockServices.Companion.MOCK_VERSION_INFO
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
-import net.corda.testing.resetTestSerialization
-import net.corda.testing.testNodeConfiguration
 import org.apache.activemq.artemis.utils.ReusableLatch
 import org.slf4j.Logger
 import java.io.Closeable
@@ -393,13 +390,13 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false,
     }
 
     @JvmOverloads
-    fun createNotaryNode(legalName: CordaX500Name? = null, validating: Boolean = true): StartedNode<MockNode> {
+    fun createNotaryNode(legalName: CordaX500Name = DUMMY_NOTARY.name, validating: Boolean = true): StartedNode<MockNode> {
         return createNode(legalName = legalName, configOverrides = {
             whenever(it.notary).thenReturn(NotaryConfig(validating))
         })
     }
 
-    fun <N : MockNode> createNotaryNode(legalName: CordaX500Name? = null,
+    fun <N : MockNode> createNotaryNode(legalName: CordaX500Name = DUMMY_NOTARY.name,
                                         validating: Boolean = true,
                                         nodeFactory: Factory<N>): StartedNode<N> {
         return createNode(legalName = legalName, nodeFactory = nodeFactory, configOverrides = {
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/TestConstants.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/TestConstants.kt
index a7f7e11157..9e73764f06 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/TestConstants.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/TestConstants.kt
@@ -31,6 +31,7 @@ val DUMMY_NOTARY_KEY: KeyPair by lazy { entropyToKeyPair(BigInteger.valueOf(20))
 /** Dummy notary identity for tests and simulations */
 val DUMMY_NOTARY_IDENTITY: PartyAndCertificate get() = getTestPartyAndCertificate(DUMMY_NOTARY)
 val DUMMY_NOTARY: Party get() = Party(CordaX500Name(organisation = "Notary Service", locality = "Zurich", country = "CH"), DUMMY_NOTARY_KEY.public)
+val DUMMY_NOTARY_SERVICE_NAME: CordaX500Name = DUMMY_NOTARY.name.copy(commonName = "corda.notary.validating")
 
 val DUMMY_MAP_KEY: KeyPair by lazy { entropyToKeyPair(BigInteger.valueOf(30)) }
 /** Dummy network map service identity for tests and simulations */
@@ -51,17 +52,20 @@ val DUMMY_BANK_C: Party get() = Party(CordaX500Name(organisation = "Bank C", loc
 val ALICE_KEY: KeyPair by lazy { entropyToKeyPair(BigInteger.valueOf(70)) }
 /** Dummy individual identity for tests and simulations */
 val ALICE_IDENTITY: PartyAndCertificate get() = getTestPartyAndCertificate(ALICE)
-val ALICE: Party get() = Party(CordaX500Name(organisation = "Alice Corp", locality = "Madrid", country = "ES"), ALICE_KEY.public)
+val ALICE_NAME = CordaX500Name(organisation = "Alice Corp", locality = "Madrid", country = "ES")
+val ALICE: Party get() = Party(ALICE_NAME, ALICE_KEY.public)
 
 val BOB_KEY: KeyPair by lazy { entropyToKeyPair(BigInteger.valueOf(80)) }
 /** Dummy individual identity for tests and simulations */
 val BOB_IDENTITY: PartyAndCertificate get() = getTestPartyAndCertificate(BOB)
-val BOB: Party get() = Party(CordaX500Name(organisation = "Bob Plc", locality = "Rome", country = "IT"), BOB_KEY.public)
+val BOB_NAME = CordaX500Name(organisation = "Bob Plc", locality = "Rome", country = "IT")
+val BOB: Party get() = Party(BOB_NAME, BOB_KEY.public)
 
 val CHARLIE_KEY: KeyPair by lazy { entropyToKeyPair(BigInteger.valueOf(90)) }
 /** Dummy individual identity for tests and simulations */
 val CHARLIE_IDENTITY: PartyAndCertificate get() = getTestPartyAndCertificate(CHARLIE)
-val CHARLIE: Party get() = Party(CordaX500Name(organisation = "Charlie Ltd", locality = "Athens", country = "GR"), CHARLIE_KEY.public)
+val CHARLIE_NAME = CordaX500Name(organisation = "Charlie Ltd", locality = "Athens", country = "GR")
+val CHARLIE: Party get() = Party(CHARLIE_NAME, CHARLIE_KEY.public)
 
 val DUMMY_REGULATOR_KEY: KeyPair by lazy { entropyToKeyPair(BigInteger.valueOf(100)) }
 /** Dummy regulator for tests and simulations */
diff --git a/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt b/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
index d12dbc7a41..7bdbecaf17 100644
--- a/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
+++ b/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
@@ -13,6 +13,9 @@ import net.corda.node.services.config.VerifierType
 import net.corda.testing.ALICE
 import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.chooseIdentity
+import net.corda.node.services.transactions.ValidatingNotaryService
+import net.corda.nodeapi.internal.ServiceInfo
+import net.corda.testing.*
 import net.corda.testing.driver.NetworkMapStartStrategy
 import org.junit.Test
 import java.util.*
@@ -116,14 +119,15 @@ class VerifierTests {
         ) {
             val aliceFuture = startNode(providedName = ALICE.name)
             val notaryFuture = startNotaryNode(DUMMY_NOTARY.name, verifierType = VerifierType.OutOfProcess)
-            val alice = aliceFuture.get()
-            val notary = notaryFuture.get()
-            val notaryIdentity = notary.nodeInfo.legalIdentities[1]
-            startVerifier(notary)
-            alice.rpc.startFlow(::CashIssueFlow, 10.DOLLARS, OpaqueBytes.of(0), notaryIdentity).returnValue.get()
-            notary.waitUntilNumberOfVerifiers(1)
+            val aliceNode = aliceFuture.get()
+            val notaryNode = notaryFuture.get()
+            val alice = notaryNode.rpc.wellKnownPartyFromX500Name(ALICE_NAME)!!
+            val notary = notaryNode.rpc.notaryPartyFromX500Name(DUMMY_NOTARY_SERVICE_NAME)!!
+            startVerifier(notaryNode)
+            aliceNode.rpc.startFlow(::CashIssueFlow, 10.DOLLARS, OpaqueBytes.of(0), notary).returnValue.get()
+            notaryNode.waitUntilNumberOfVerifiers(1)
             for (i in 1..10) {
-                alice.rpc.startFlow(::CashPaymentFlow, 10.DOLLARS, alice.nodeInfo.chooseIdentity()).returnValue.get()
+                aliceNode.rpc.startFlow(::CashPaymentFlow, 10.DOLLARS, alice).returnValue.get()
             }
         }
     }

From d1c51115675d7c7e3edf1f34ff60084b210043fc Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Thu, 12 Oct 2017 11:39:22 +0100
Subject: [PATCH 165/185] =?UTF-8?q?Remove=20the=20two=20header=20lines=20f?=
 =?UTF-8?q?rom=20the=20diff=20output=20to=20simplify=20the=20+/-=20?=
 =?UTF-8?q?=E2=80=A6=20(#1875)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Remove the two header lines from the diff output to simplify the +/- check.
* Revert Kt class changes as they alter the public API.
---
 .ci/check-api-changes.sh                                 | 9 +++++----
 .../net/corda/core/serialization/SerializationAPI.kt     | 2 --
 .../main/kotlin/net/corda/core/utilities/KotlinUtils.kt  | 2 --
 3 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/.ci/check-api-changes.sh b/.ci/check-api-changes.sh
index 7694d995dd..e9ac25cf6d 100755
--- a/.ci/check-api-changes.sh
+++ b/.ci/check-api-changes.sh
@@ -10,13 +10,14 @@ if [ ! -f $apiCurrent ]; then
    exit -1
 fi
 
-diffContents=`diff -u $apiCurrent $APIHOME/../build/api/api-corda-*.txt`
-echo "Diff contents:" 
+# Remove the two header lines from the diff output.
+diffContents=`diff -u $apiCurrent $APIHOME/../build/api/api-corda-*.txt | tail --lines=+3`
+echo "Diff contents:"
 echo "$diffContents"
 echo
 
 # A removed line means that an API was either deleted or modified.
-removals=$(echo "$diffContents" | grep "^-\s")
+removals=$(echo "$diffContents" | grep "^-")
 removalCount=`grep -v "^$" <<EOF | wc -l
 $removals
 EOF
@@ -29,7 +30,7 @@ if [ $removalCount -gt 0 ]; then
 fi
 
 # Adding new abstract methods could also break the API.
-newAbstracts=$(echo "$diffContents" | grep "^+\s" | grep "\(public\|protected\) abstract")
+newAbstracts=$(echo "$diffContents" | grep "^+" | grep "\(public\|protected\) abstract")
 abstractCount=`grep -v "^$" <<EOF | wc -l
 $newAbstracts
 EOF
diff --git a/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt b/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
index 0eccaf6ffb..f77e3ae122 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
@@ -1,5 +1,3 @@
-@file:JvmName("SerializationAPI")
-
 package net.corda.core.serialization
 
 import net.corda.core.crypto.SecureHash
diff --git a/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt b/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt
index 897ae4d1d8..b12ea8353d 100644
--- a/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/utilities/KotlinUtils.kt
@@ -1,5 +1,3 @@
-@file:JvmName("KotlinUtils")
-
 package net.corda.core.utilities
 
 import net.corda.core.internal.concurrent.get

From 544b7616822e51846a426a586cf234842a166159 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Thu, 12 Oct 2017 13:21:00 +0100
Subject: [PATCH 166/185] Remove broken link.

---
 docs/source/corda-api.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/source/corda-api.rst b/docs/source/corda-api.rst
index 57863be4b7..8b5dd94053 100644
--- a/docs/source/corda-api.rst
+++ b/docs/source/corda-api.rst
@@ -74,7 +74,7 @@ The following modules are available but we do not commit to their stability or c
 * **net.corda.samples.demos.bankofcorda**: simulates the role of an asset issuing authority (eg. central bank for cash)
 * **net.corda.samples.demos.irs**: demonstrates an Interest Rate Swap agreement between two banks
 * **net.corda.samples.demos.notary**: a simple demonstration of a node getting multiple transactions notarised by a distributed (Raft or BFT SMaRt) notary
-* **net.corda.samples.demos.simmvaluation**: See our [main documentation site](https://docs.corda.net/initial-margin-agreement.html) regarding the SIMM valuation and agreement on a distributed ledger
+* **net.corda.samples.demos.simmvaluation**: A demo of SIMM valuation and agreement on a distributed ledger
 * **net.corda.samples.demos.trader**: demonstrates four nodes, a notary, an issuer of cash (Bank of Corda), and two parties trading with each other, exchanging cash for a commercial paper
 * **net.corda.node.smoke.test.utils**: test utilities for smoke testing
 * **net.corda.node.test.common**: common test functionality
@@ -90,4 +90,4 @@ The following modules are available but we do not commit to their stability or c
 .. warning:: Code inside any package in the ``net.corda`` namespace which contains ``.internal`` or in ``net.corda.node`` for internal use only.
    Future releases will reject any CorDapps that use types from these packages.
 
-.. warning:: The web server module will be removed in future. You should call Corda nodes through RPC from your web server of choice e.g., Spring Boot, Vertx, Undertow.
\ No newline at end of file
+.. warning:: The web server module will be removed in future. You should call Corda nodes through RPC from your web server of choice e.g., Spring Boot, Vertx, Undertow.

From 7b10e92819c29b75bd17582f83630ad24b26beca Mon Sep 17 00:00:00 2001
From: Andrius Dagys <andrius.dagys@r3.com>
Date: Fri, 13 Oct 2017 10:36:25 +0100
Subject: [PATCH 167/185] Fixed AbstractNode to load custom notary services
 properly (#1720)

* Fixed AbstractNode to load custom notary services properly.
Added a custom notary sample.

* Prevent multiple custom notaries from being loaded

* Throw if more than once custom notary service is loaded
---
 .../corda/core/node/services/NotaryService.kt |  6 ++-
 docs/source/corda-configuration-file.rst      | 12 ++++--
 docs/source/running-the-demos.rst             | 22 +++++-----
 docs/source/tutorial-custom-notary.rst        | 23 +++++++----
 docs/source/tutorials-index.rst               |  1 +
 .../net/corda/node/internal/AbstractNode.kt   | 40 ++++++++++++++-----
 .../node/services/config/NodeConfiguration.kt | 17 +++++---
 .../net/corda/bank/BankOfCordaDriver.kt       |  2 +-
 samples/notary-demo/build.gradle              |  7 +++-
 .../corda/notarydemo/CustomNotaryCordform.kt  | 36 +++++++++++++++++
 .../corda/notarydemo/MyCustomNotaryService.kt | 27 ++++++++++---
 11 files changed, 148 insertions(+), 45 deletions(-)
 create mode 100644 samples/notary-demo/src/main/kotlin/net/corda/notarydemo/CustomNotaryCordform.kt
 rename docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt => samples/notary-demo/src/main/kotlin/net/corda/notarydemo/MyCustomNotaryService.kt (74%)

diff --git a/core/src/main/kotlin/net/corda/core/node/services/NotaryService.kt b/core/src/main/kotlin/net/corda/core/node/services/NotaryService.kt
index 574008d6d8..8241fcd13c 100644
--- a/core/src/main/kotlin/net/corda/core/node/services/NotaryService.kt
+++ b/core/src/main/kotlin/net/corda/core/node/services/NotaryService.kt
@@ -1,5 +1,6 @@
 package net.corda.core.node.services
 
+import com.google.common.primitives.Booleans
 import net.corda.core.contracts.StateRef
 import net.corda.core.contracts.TimeWindow
 import net.corda.core.crypto.*
@@ -15,12 +16,13 @@ import java.security.PublicKey
 abstract class NotaryService : SingletonSerializeAsToken() {
     companion object {
         const val ID_PREFIX = "corda.notary."
-        fun constructId(validating: Boolean, raft: Boolean = false, bft: Boolean = false): String {
-            require(!raft || !bft)
+        fun constructId(validating: Boolean, raft: Boolean = false, bft: Boolean = false, custom: Boolean = false): String {
+            require(Booleans.countTrue(raft, bft, custom) <= 1) { "At most one of raft, bft or custom may be true" }
             return StringBuffer(ID_PREFIX).apply {
                 append(if (validating) "validating" else "simple")
                 if (raft) append(".raft")
                 if (bft) append(".bft")
+                if (custom) append(".custom")
             }.toString()
         }
     }
diff --git a/docs/source/corda-configuration-file.rst b/docs/source/corda-configuration-file.rst
index 8511b2d486..2b2627f56e 100644
--- a/docs/source/corda-configuration-file.rst
+++ b/docs/source/corda-configuration-file.rst
@@ -94,7 +94,7 @@ path to the node's base directory.
     .. note:: The driver will not automatically create a webserver instance, but the Cordformation will. If this field
               is present the web server will start.
 
-:notary: Optional config object which if present configures the node to run as a notary. If part of a Raft or BFT SMaRt
+:notary: Optional configuration object which if present configures the node to run as a notary. If part of a Raft or BFT SMaRt
     cluster then specify ``raft`` or ``bftSMaRt`` respectively as described below. If a single node notary then omit both.
 
         :validating: Boolean to determine whether the notary is a validating or non-validating one.
@@ -108,11 +108,15 @@ path to the node's base directory.
                     members must be active and be able to communicate with the cluster leader for joining. If empty, a new
                     cluster will be bootstrapped.
 
-        :bftSMaRt: If part of a distributed BFT SMaRt cluster specify this config object, with the following settings:
+        :bftSMaRt: If part of a distributed BFT-SMaRt cluster specify this config object, with the following settings:
 
-                :replicaId:
+                :replicaId: The zero-based index of the current replica. All replicas must specify a unique replica id.
 
-                :clusterAddresses:
+                :clusterAddresses: List of all BFT-SMaRt cluster member addresses.
+
+        :custom: If `true`, will load and install a notary service from a CorDapp. See :doc:`tutorial-custom-notary`.
+
+    Only one of ``raft``, ``bftSMaRt`` or ``custom`` configuration values may be specified.
 
 :networkMapService: If `null`, or missing the node is declaring itself as the NetworkMapService host. Otherwise this is
     a config object with the details of the network map service:
diff --git a/docs/source/running-the-demos.rst b/docs/source/running-the-demos.rst
index f9e78737d1..11ebb794c2 100644
--- a/docs/source/running-the-demos.rst
+++ b/docs/source/running-the-demos.rst
@@ -35,7 +35,7 @@ To run from the command line in Unix:
 2. Run ``./samples/trader-demo/build/nodes/runnodes`` to open up four new terminals with the four nodes
 3. Run ``./gradlew samples:trader-demo:runBank`` to instruct the bank node to issue cash and commercial paper to the buyer and seller nodes respectively.
 4. Run ``./gradlew samples:trader-demo:runSeller`` to trigger the transaction. If you entered ``flow watch``
-      
+
 you can see flows running on both sides of transaction. Additionally you should see final trade information displayed
 to your terminal.
 
@@ -45,7 +45,7 @@ To run from the command line in Windows:
 2. Run ``samples\trader-demo\build\nodes\runnodes`` to open up four new terminals with the four nodes
 3. Run ``gradlew samples:trader-demo:runBank`` to instruct the buyer node to request issuance of some cash from the Bank of Corda node
 4. Run ``gradlew samples:trader-demo:runSeller`` to trigger the transaction. If you entered ``flow watch``
-      
+
 you can see flows running on both sides of transaction. Additionally you should see final trade information displayed
 to your terminal.
 
@@ -112,8 +112,11 @@ Notary demo
 This demo shows a party getting transactions notarised by either a single-node or a distributed notary service.
 All versions of the demo start two counterparty nodes.
 One of the counterparties will generate transactions that transfer a self-issued asset to the other party and submit them for notarisation.
-The `Raft <https://raft.github.io/>`_ version of the demo will start three distributed notary nodes.
-The `BFT SMaRt <https://bft-smart.github.io/library/>`_ version of the demo will start four distributed notary nodes.
+
+* The `Raft <https://raft.github.io/>`_ version of the demo will start three distributed notary nodes.
+* The `BFT SMaRt <https://bft-smart.github.io/library/>`_ version of the demo will start four distributed notary nodes.
+* The Single version of the demo will start a single-node validating notary service.
+* The Custom version of the demo will load and start a custom single-node notary service that is defined the demo CorDapp.
 
 The output will display a list of notarised transaction IDs and corresponding signer public keys. In the Raft distributed notary,
 every node in the cluster can service client requests, and one signature is sufficient to satisfy the notary composite key requirement.
@@ -122,9 +125,9 @@ You will notice that successive transactions get signed by different members of
 
 To run the Raft version of the demo from the command line in Unix:
 
-1. Run ``./gradlew samples:notary-demo:deployNodes``, which will create all three types of notaries' node directories
-   with configs under ``samples/notary-demo/build/nodes/nodesRaft`` (``nodesBFT`` and ``nodesSingle`` for BFT and
-   Single notaries).
+1. Run ``./gradlew samples:notary-demo:deployNodes``, which will create node directories for all versions of the demo,
+   with configs under ``samples/notary-demo/build/nodes/nodesRaft`` (``nodesBFT``, ``nodesSingle``, and ``nodesCustom`` for
+   BFT, Single and Custom notaries respectively).
 2. Run ``./samples/notary-demo/build/nodes/nodesRaft/runnodes``, which will start the nodes in separate terminal windows/tabs.
    Wait until a "Node started up and registered in ..." message appears on each of the terminals
 3. Run ``./gradlew samples:notary-demo:notarise`` to make a call to the "Party" node to initiate notarisation requests
@@ -133,8 +136,8 @@ To run the Raft version of the demo from the command line in Unix:
 To run from the command line in Windows:
 
 1. Run ``gradlew samples:notary-demo:deployNodes``, which will create all three types of notaries' node directories
-   with configs under ``samples/notary-demo/build/nodes/nodesRaft`` (``nodesBFT`` and ``nodesSingle`` for BFT and
-   Single notaries).
+   with configs under ``samples/notary-demo/build/nodes/nodesRaft`` (``nodesBFT``, ``nodesSingle``, and ``nodesCustom`` for
+   BFT, Single and Custom notaries respectively).
 2. Run ``samples\notary-demo\build\nodes\nodesRaft\runnodes``, which will start the nodes in separate terminal windows/tabs.
    Wait until a "Node started up and registered in ..." message appears on each of the terminals
 3. Run ``gradlew samples:notary-demo:notarise`` to make a call to the "Party" node to initiate notarisation requests
@@ -142,6 +145,7 @@ To run from the command line in Windows:
 
 To run the BFT SMaRt notary demo, use ``nodesBFT`` instead of ``nodesRaft`` in the path (you will see messages from notary nodes
 trying to communicate each other sometime with connection errors, that's normal). For a single notary node, use ``nodesSingle``.
+For the custom notary service use ``nodesCustom`.
 
 Distributed notary nodes store consumed states in a replicated commit log, which is backed by a H2 database on each node.
 You can ascertain that the commit log is synchronised across the cluster by accessing and comparing each of the nodes' backing stores
diff --git a/docs/source/tutorial-custom-notary.rst b/docs/source/tutorial-custom-notary.rst
index cabefdd203..28d5dc1158 100644
--- a/docs/source/tutorial-custom-notary.rst
+++ b/docs/source/tutorial-custom-notary.rst
@@ -1,17 +1,17 @@
 .. highlight:: kotlin
 
-Writing a custom notary service
-===============================
+Writing a custom notary service (experimental)
+==============================================
 
-.. warning:: Customising a notary service is an advanced feature and not recommended for most use-cases. Currently,
+.. warning:: Customising a notary service is still an experimental feature and not recommended for most use-cases. Currently,
    customising Raft or BFT notaries is not yet fully supported. If you want to write your own Raft notary you will have to
    implement a custom database connector (or use a separate database for the notary), and use a custom configuration file.
 
 Similarly to writing an oracle service, the first step is to create a service class in your CorDapp and annotate it
-with ``@CordaService``. The Corda node scans for any class with this annotation and initialises them. The only requirement
-is that the class provide a constructor with a single parameter of type ``AppServiceHub``.
+with ``@CordaService``. The Corda node scans for any class with this annotation and initialises them. The custom notary
+service class should provide a constructor with two parameters of types ``AppServiceHub`` and ``PublicKey``.
 
-.. literalinclude:: example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
+.. literalinclude:: ../../samples/notary-demo/src/main/kotlin/net/corda/notarydemo/MyCustomNotaryService.kt
    :language: kotlin
    :start-after: START 1
    :end-before: END 1
@@ -20,7 +20,16 @@ The next step is to write a notary service flow. You are free to copy and modify
 as ``ValidatingNotaryFlow``, ``NonValidatingNotaryFlow``, or implement your own from scratch (following the
 ``NotaryFlow.Service`` template). Below is an example of a custom flow for a *validating* notary service:
 
-.. literalinclude:: example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
+.. literalinclude:: ../../samples/notary-demo/src/main/kotlin/net/corda/notarydemo/MyCustomNotaryService.kt
    :language: kotlin
    :start-after: START 2
    :end-before: END 2
+
+To enable the service, add the following to the node configuration:
+
+.. parsed-literal::
+
+    notary : {
+        validating : true # Set to false if your service is non-validating
+        custom : true
+    }
\ No newline at end of file
diff --git a/docs/source/tutorials-index.rst b/docs/source/tutorials-index.rst
index c0b1a5af14..f14be4385f 100644
--- a/docs/source/tutorials-index.rst
+++ b/docs/source/tutorials-index.rst
@@ -16,6 +16,7 @@ Tutorials
    flow-testing
    running-a-notary
    oracles
+   tutorial-custom-notary
    tutorial-tear-offs
    tutorial-attachments
    event-scheduling
\ No newline at end of file
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index e08b457c37..9a7e5cbbeb 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -19,14 +19,11 @@ import net.corda.core.internal.concurrent.flatMap
 import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.internal.toX509CertHolder
 import net.corda.core.internal.uncheckedCast
-import net.corda.core.messaging.CordaRPCOps
-import net.corda.core.messaging.RPCOps
-import net.corda.core.messaging.SingleMessageRecipient
-import net.corda.core.node.*
 import net.corda.core.messaging.*
 import net.corda.core.node.AppServiceHub
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.ServiceHub
+import net.corda.core.node.StateLoader
 import net.corda.core.node.services.*
 import net.corda.core.node.services.NetworkMapCache.MapChange
 import net.corda.core.schemas.MappedSchema
@@ -257,7 +254,8 @@ abstract class AbstractNode(config: NodeConfiguration,
     private class ServiceInstantiationException(cause: Throwable?) : CordaException("Service Instantiation Error", cause)
 
     private fun installCordaServices() {
-        cordappProvider.cordapps.flatMap { it.services }.forEach {
+        val loadedServices = cordappProvider.cordapps.flatMap { it.services }
+        filterServicesToInstall(loadedServices).forEach {
             try {
                 installCordaService(it)
             } catch (e: NoSuchMethodException) {
@@ -271,6 +269,25 @@ abstract class AbstractNode(config: NodeConfiguration,
         }
     }
 
+    private fun filterServicesToInstall(loadedServices: List<Class<out SerializeAsToken>>): List<Class<out SerializeAsToken>> {
+        val customNotaryServiceList = loadedServices.filter { isNotaryService(it) }
+        if (customNotaryServiceList.isNotEmpty()) {
+            if (configuration.notary?.custom == true) {
+                require(customNotaryServiceList.size == 1) {
+                    "Attempting to install more than one notary service: ${customNotaryServiceList.joinToString()}"
+                }
+            }
+            else return loadedServices - customNotaryServiceList
+        }
+        return loadedServices
+    }
+
+    /**
+     * If the [serviceClass] is a notary service, it will only be enable if the "custom" flag is set in
+     * the notary configuration.
+     */
+    private fun isNotaryService(serviceClass: Class<*>) = NotaryService::class.java.isAssignableFrom(serviceClass)
+
     /**
      * This customizes the ServiceHub for each CordaService that is initiating flows
      */
@@ -321,14 +338,15 @@ abstract class AbstractNode(config: NodeConfiguration,
     fun <T : SerializeAsToken> installCordaService(serviceClass: Class<T>): T {
         serviceClass.requireAnnotation<CordaService>()
         val service = try {
-            if (NotaryService::class.java.isAssignableFrom(serviceClass)) {
+            val serviceContext = AppServiceHubImpl<T>(services)
+            if (isNotaryService(serviceClass)) {
                 check(myNotaryIdentity != null) { "Trying to install a notary service but no notary identity specified" }
-                val constructor = serviceClass.getDeclaredConstructor(ServiceHub::class.java, PublicKey::class.java).apply { isAccessible = true }
-                constructor.newInstance(services, myNotaryIdentity!!.owningKey)
+                val constructor = serviceClass.getDeclaredConstructor(AppServiceHub::class.java, PublicKey::class.java).apply { isAccessible = true }
+                serviceContext.serviceInstance = constructor.newInstance(serviceContext, myNotaryIdentity!!.owningKey)
+                serviceContext.serviceInstance
             } else {
                 try {
                     val extendedServiceConstructor = serviceClass.getDeclaredConstructor(AppServiceHub::class.java).apply { isAccessible = true }
-                    val serviceContext = AppServiceHubImpl<T>(services)
                     serviceContext.serviceInstance = extendedServiceConstructor.newInstance(serviceContext)
                     serviceContext.serviceInstance
                 } catch (ex: NoSuchMethodException) {
@@ -688,7 +706,9 @@ abstract class AbstractNode(config: NodeConfiguration,
             // Node's main identity
             Pair("identity", myLegalName)
         } else {
-            val notaryId = notaryConfig.run { NotaryService.constructId(validating, raft != null, bftSMaRt != null) }
+            val notaryId = notaryConfig.run {
+                NotaryService.constructId(validating, raft != null, bftSMaRt != null, custom)
+            }
             if (notaryConfig.bftSMaRt == null && notaryConfig.raft == null) {
                 // Node's notary identity
                 Pair(notaryId, myLegalName.copy(commonName = notaryId))
diff --git a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
index a72465ccee..782064bf76 100644
--- a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
+++ b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt
@@ -36,9 +36,15 @@ interface NodeConfiguration : NodeSSLConfiguration {
     val additionalNodeInfoPollingFrequencyMsec: Long
 }
 
-data class NotaryConfig(val validating: Boolean, val raft: RaftConfig? = null, val bftSMaRt: BFTSMaRtConfiguration? = null) {
+data class NotaryConfig(val validating: Boolean,
+                        val raft: RaftConfig? = null,
+                        val bftSMaRt: BFTSMaRtConfiguration? = null,
+                        val custom: Boolean = false
+) {
     init {
-        require(raft == null || bftSMaRt == null) { "raft and bftSMaRt configs cannot be specified together" }
+        require(raft == null || bftSMaRt == null || !custom) {
+            "raft, bftSMaRt, and custom configs cannot be specified together"
+        }
     }
 }
 
@@ -46,9 +52,10 @@ data class RaftConfig(val nodeAddress: NetworkHostAndPort, val clusterAddresses:
 
 /** @param exposeRaces for testing only, so its default is not in reference.conf but here. */
 data class BFTSMaRtConfiguration constructor(val replicaId: Int,
-                                 val clusterAddresses: List<NetworkHostAndPort>,
-                                 val debug: Boolean = false,
-                                 val exposeRaces: Boolean = false) {
+                                             val clusterAddresses: List<NetworkHostAndPort>,
+                                             val debug: Boolean = false,
+                                             val exposeRaces: Boolean = false
+) {
     init {
         require(replicaId >= 0) { "replicaId cannot be negative" }
     }
diff --git a/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/BankOfCordaDriver.kt b/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/BankOfCordaDriver.kt
index ac2e890f09..81dbf12166 100644
--- a/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/BankOfCordaDriver.kt
+++ b/samples/bank-of-corda-demo/src/main/kotlin/net/corda/bank/BankOfCordaDriver.kt
@@ -69,7 +69,7 @@ private class BankOfCordaDriver {
                         val bigCorpUser = User(BIGCORP_USERNAME, "test",
                                 permissions = setOf(
                                         startFlowPermission<CashPaymentFlow>()))
-                        startNotaryNode(DUMMY_NOTARY.name, validating = false)
+                        startNotaryNode(DUMMY_NOTARY.name, validating = true)
                         val bankOfCorda = startNode(
                                 providedName = BOC.name,
                                 rpcUsers = listOf(bankUser))
diff --git a/samples/notary-demo/build.gradle b/samples/notary-demo/build.gradle
index a13ab70ad8..4d3f97f065 100644
--- a/samples/notary-demo/build.gradle
+++ b/samples/notary-demo/build.gradle
@@ -46,13 +46,18 @@ publishing {
     }
 }
 
-task deployNodes(dependsOn: ['deployNodesSingle', 'deployNodesRaft', 'deployNodesBFT'])
+task deployNodes(dependsOn: ['deployNodesSingle', 'deployNodesRaft', 'deployNodesBFT', 'deployNodesCustom'])
 
 task deployNodesSingle(type: Cordform, dependsOn: 'jar') {
     directory "./build/nodes/nodesSingle"
     definitionClass = 'net.corda.notarydemo.SingleNotaryCordform'
 }
 
+task deployNodesCustom(type: Cordform, dependsOn: 'jar') {
+    directory "./build/nodes/nodesCustom"
+    definitionClass = 'net.corda.notarydemo.CustomNotaryCordform'
+}
+
 task deployNodesRaft(type: Cordform, dependsOn: 'jar') {
     directory "./build/nodes/nodesRaft"
     definitionClass = 'net.corda.notarydemo.RaftNotaryCordform'
diff --git a/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/CustomNotaryCordform.kt b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/CustomNotaryCordform.kt
new file mode 100644
index 0000000000..900150da69
--- /dev/null
+++ b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/CustomNotaryCordform.kt
@@ -0,0 +1,36 @@
+package net.corda.notarydemo
+
+import net.corda.cordform.CordformContext
+import net.corda.cordform.CordformDefinition
+import net.corda.core.internal.div
+import net.corda.node.services.config.NotaryConfig
+import net.corda.testing.ALICE
+import net.corda.testing.BOB
+import net.corda.testing.DUMMY_NOTARY
+import net.corda.testing.internal.demorun.*
+
+fun main(args: Array<String>) = CustomNotaryCordform.runNodes()
+
+object CustomNotaryCordform : CordformDefinition("build" / "notary-demo-nodes") {
+    init {
+        node {
+            name(ALICE.name)
+            p2pPort(10002)
+            rpcPort(10003)
+            rpcUsers(notaryDemoUser)
+        }
+        node {
+            name(BOB.name)
+            p2pPort(10005)
+            rpcPort(10006)
+        }
+        node {
+            name(DUMMY_NOTARY.name)
+            p2pPort(10009)
+            rpcPort(10010)
+            notary(NotaryConfig(validating = true, custom = true))
+        }
+    }
+
+    override fun setup(context: CordformContext) {}
+}
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/MyCustomNotaryService.kt
similarity index 74%
rename from docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
rename to samples/notary-demo/src/main/kotlin/net/corda/notarydemo/MyCustomNotaryService.kt
index d7331d146c..55adae9ee2 100644
--- a/docs/source/example-code/src/main/kotlin/net/corda/docs/CustomNotaryTutorial.kt
+++ b/samples/notary-demo/src/main/kotlin/net/corda/notarydemo/MyCustomNotaryService.kt
@@ -1,4 +1,4 @@
-package net.corda.docs
+package net.corda.notarydemo
 
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.contracts.TimeWindow
@@ -8,11 +8,17 @@ import net.corda.core.node.AppServiceHub
 import net.corda.core.node.services.CordaService
 import net.corda.core.node.services.TimeWindowChecker
 import net.corda.core.node.services.TrustedAuthorityNotaryService
+import net.corda.core.transactions.LedgerTransaction
 import net.corda.core.transactions.TransactionWithSignatures
 import net.corda.node.services.transactions.PersistentUniquenessProvider
 import java.security.PublicKey
 import java.security.SignatureException
 
+/**
+ * A custom notary service should provide a constructor that accepts two parameters of types [AppServiceHub] and [PublicKey].
+ *
+ * Note that at present only a single-node notary service can be customised.
+ */
 // START 1
 @CordaService
 class MyCustomValidatingNotaryService(override val services: AppServiceHub, override val notaryIdentityKey: PublicKey) : TrustedAuthorityNotaryService() {
@@ -26,6 +32,7 @@ class MyCustomValidatingNotaryService(override val services: AppServiceHub, over
 }
 // END 1
 
+@Suppress("UNUSED_PARAMETER")
 // START 2
 class MyValidatingNotaryFlow(otherSide: FlowSession, service: MyCustomValidatingNotaryService) : NotaryFlow.Service(otherSide, service) {
     /**
@@ -38,11 +45,15 @@ class MyValidatingNotaryFlow(otherSide: FlowSession, service: MyCustomValidating
             val stx = subFlow(ReceiveTransactionFlow(otherSideSession, checkSufficientSignatures = false))
             val notary = stx.notary
             checkNotary(notary)
-            val timeWindow: TimeWindow? = if (stx.isNotaryChangeTransaction())
-                null
-            else
-                stx.tx.timeWindow
-            val transactionWithSignatures = stx.resolveTransactionWithSignatures(serviceHub)
+            var timeWindow: TimeWindow? = null
+            val transactionWithSignatures = if (stx.isNotaryChangeTransaction()) {
+                stx.resolveNotaryChangeTransaction(serviceHub)
+            } else {
+                val wtx = stx.tx
+                customVerify(wtx.toLedgerTransaction(serviceHub))
+                timeWindow = wtx.timeWindow
+                stx
+            }
             checkSignatures(transactionWithSignatures)
             return TransactionParts(stx.id, stx.inputs, timeWindow, notary!!)
         } catch (e: Exception) {
@@ -54,6 +65,10 @@ class MyValidatingNotaryFlow(otherSide: FlowSession, service: MyCustomValidating
         }
     }
 
+    private fun customVerify(transaction: LedgerTransaction) {
+        // Add custom verification logic
+    }
+
     private fun checkSignatures(tx: TransactionWithSignatures) {
         try {
             tx.verifySignaturesExcept(service.notaryIdentityKey)

From ce5b7de71801a557bb57602e8af2e5ec8ba63959 Mon Sep 17 00:00:00 2001
From: Andrzej Cichocki <andrzej.cichocki@r3.com>
Date: Fri, 13 Oct 2017 12:15:52 +0100
Subject: [PATCH 168/185] CORDA-530 Unduplicate code (#1791)

---
 .../net/corda/core/flows/AttachmentTests.kt   |   3 +-
 .../AttachmentSerializationTest.kt            |   4 +-
 .../network/PersistentNetworkMapCache.kt      | 132 ++++++++----------
 .../persistence/DBCheckpointStorage.kt        |   9 +-
 .../persistence/NodeAttachmentService.kt      |   8 +-
 .../node/services/vault/NodeVaultService.kt   | 100 ++++++-------
 .../node/utilities/AppendOnlyPersistentMap.kt |  16 ++-
 .../utilities/DatabaseTransactionManager.kt   |   1 +
 .../net/corda/node/utilities/PersistentMap.kt |  22 +--
 .../persistence/NodeAttachmentStorageTest.kt  |  24 ++--
 10 files changed, 152 insertions(+), 167 deletions(-)

diff --git a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
index ab4936d6fc..c9974d5dc3 100644
--- a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
@@ -12,7 +12,6 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.persistence.NodeAttachmentService
-import net.corda.node.utilities.DatabaseTransactionManager
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.ALICE
 import net.corda.testing.ALICE_NAME
@@ -147,7 +146,7 @@ class AttachmentTests {
 
         val corruptAttachment = NodeAttachmentService.DBAttachment(attId = id.toString(), content = attachment)
         aliceNode.database.transaction {
-            DatabaseTransactionManager.current().session.update(corruptAttachment)
+            session.update(corruptAttachment)
         }
 
         // Get n1 to fetch the attachment. Should receive corrupted bytes.
diff --git a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
index 89bc81dad9..f6d1eec6b2 100644
--- a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
+++ b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt
@@ -16,7 +16,7 @@ import net.corda.node.internal.InitiatedFlowFactory
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.persistence.NodeAttachmentService
-import net.corda.node.utilities.DatabaseTransactionManager
+import net.corda.node.utilities.currentDBSession
 import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.MockNetwork
@@ -54,7 +54,7 @@ private fun StartedNode<*>.hackAttachment(attachmentId: SecureHash, content: Str
  * @see NodeAttachmentService.importAttachment
  */
 private fun updateAttachment(attachmentId: SecureHash, data: ByteArray) {
-    val session = DatabaseTransactionManager.current().session
+    val session = currentDBSession()
     val attachment = session.get<NodeAttachmentService.DBAttachment>(NodeAttachmentService.DBAttachment::class.java, attachmentId.toString())
     attachment?.let {
         attachment.content = data
diff --git a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
index 1f24e27526..eb45e7a0df 100644
--- a/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
+++ b/node/src/main/kotlin/net/corda/node/services/network/PersistentNetworkMapCache.kt
@@ -31,7 +31,6 @@ import net.corda.node.services.messaging.sendRequest
 import net.corda.node.services.network.NetworkMapService.FetchMapResponse
 import net.corda.node.services.network.NetworkMapService.SubscribeResponse
 import net.corda.node.utilities.AddOrRemove
-import net.corda.node.utilities.DatabaseTransactionManager
 import net.corda.node.utilities.bufferUntilDatabaseCommit
 import net.corda.node.utilities.wrapWithDatabaseTransaction
 import org.hibernate.Session
@@ -39,7 +38,6 @@ import rx.Observable
 import rx.subjects.PublishSubject
 import java.security.PublicKey
 import java.security.SignatureException
-import java.time.Duration
 import java.util.*
 import javax.annotation.concurrent.ThreadSafe
 import kotlin.collections.HashMap
@@ -93,7 +91,7 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
 
     init {
         loadFromFiles()
-        serviceHub.database.transaction { loadFromDB() }
+        serviceHub.database.transaction { loadFromDB(session) }
     }
 
     private fun loadFromFiles() {
@@ -102,7 +100,7 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
     }
 
     override fun getPartyInfo(party: Party): PartyInfo? {
-        val nodes = serviceHub.database.transaction { queryByIdentityKey(party.owningKey) }
+        val nodes = serviceHub.database.transaction { queryByIdentityKey(session, party.owningKey) }
         if (nodes.size == 1 && nodes[0].isLegalIdentity(party)) {
             return PartyInfo.SingleNode(party, nodes[0].addresses)
         }
@@ -117,9 +115,9 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
     }
 
     override fun getNodeByLegalName(name: CordaX500Name): NodeInfo? = getNodesByLegalName(name).firstOrNull()
-    override fun getNodesByLegalName(name: CordaX500Name): List<NodeInfo> = serviceHub.database.transaction { queryByLegalName(name) }
+    override fun getNodesByLegalName(name: CordaX500Name): List<NodeInfo> = serviceHub.database.transaction { queryByLegalName(session, name) }
     override fun getNodesByLegalIdentityKey(identityKey: PublicKey): List<NodeInfo> =
-            serviceHub.database.transaction { queryByIdentityKey(identityKey) }
+            serviceHub.database.transaction { queryByIdentityKey(session, identityKey) }
 
     override fun getNodeByLegalIdentity(party: AbstractParty): NodeInfo? {
         val wellKnownParty = serviceHub.identityService.wellKnownPartyFromAnonymous(party)
@@ -128,9 +126,9 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
         }
     }
 
-    override fun getNodeByAddress(address: NetworkHostAndPort): NodeInfo? = serviceHub.database.transaction { queryByAddress(address) }
+    override fun getNodeByAddress(address: NetworkHostAndPort): NodeInfo? = serviceHub.database.transaction { queryByAddress(session, address) }
 
-    override fun getPeerCertificateByLegalName(name: CordaX500Name): PartyAndCertificate? = serviceHub.database.transaction { queryIdentityByLegalName(name) }
+    override fun getPeerCertificateByLegalName(name: CordaX500Name): PartyAndCertificate? = serviceHub.database.transaction { queryIdentityByLegalName(session, name) }
 
     override fun track(): DataFeed<List<NodeInfo>, MapChange> {
         synchronized(_changed) {
@@ -204,7 +202,7 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
         synchronized(_changed) {
             registeredNodes.remove(node.legalIdentities.first().owningKey)
             serviceHub.database.transaction {
-                removeInfoDB(node)
+                removeInfoDB(session, node)
                 changePublisher.onNext(MapChange.Removed(node))
             }
         }
@@ -238,10 +236,8 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
     }
 
     override val allNodes: List<NodeInfo>
-        get () = serviceHub.database.transaction {
-            createSession {
-                getAllInfos(it).map { it.toNodeInfo() }
-            }
+        get() = serviceHub.database.transaction {
+            getAllInfos(session).map { it.toNodeInfo() }
         }
 
     private fun processRegistration(reg: NodeRegistration) {
@@ -259,10 +255,6 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
     // Changes related to NetworkMap redesign
     // TODO It will be properly merged into network map cache after services removal.
 
-    private inline fun <T> createSession(block: (Session) -> T): T {
-        return DatabaseTransactionManager.current().session.let { block(it) }
-    }
-
     private fun getAllInfos(session: Session): List<NodeInfoSchemaV1.PersistentNodeInfo> {
         val criteria = session.criteriaBuilder.createQuery(NodeInfoSchemaV1.PersistentNodeInfo::class.java)
         criteria.select(criteria.from(NodeInfoSchemaV1.PersistentNodeInfo::class.java))
@@ -272,24 +264,22 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
     /**
      * Load NetworkMap data from the database if present. Node can start without having NetworkMapService configured.
      */
-    private fun loadFromDB() {
+    private fun loadFromDB(session: Session) {
         logger.info("Loading network map from database...")
-        createSession {
-            val result = getAllInfos(it)
-            for (nodeInfo in result) {
-                try {
-                    logger.info("Loaded node info: $nodeInfo")
-                    val node = nodeInfo.toNodeInfo()
-                    addNode(node)
-                    _loadDBSuccess = true // This is used in AbstractNode to indicate that node is ready.
-                } catch (e: Exception) {
-                    logger.warn("Exception parsing network map from the database.", e)
-                }
-            }
-            if (loadDBSuccess) {
-                _registrationFuture.set(null) // Useful only if we don't have NetworkMapService configured so StateMachineManager can start.
+        val result = getAllInfos(session)
+        for (nodeInfo in result) {
+            try {
+                logger.info("Loaded node info: $nodeInfo")
+                val node = nodeInfo.toNodeInfo()
+                addNode(node)
+                _loadDBSuccess = true // This is used in AbstractNode to indicate that node is ready.
+            } catch (e: Exception) {
+                logger.warn("Exception parsing network map from the database.", e)
             }
         }
+        if (loadDBSuccess) {
+            _registrationFuture.set(null) // Useful only if we don't have NetworkMapService configured so StateMachineManager can start.
+        }
     }
 
     private fun updateInfoDB(nodeInfo: NodeInfo) {
@@ -313,11 +303,9 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
         }
     }
 
-    private fun removeInfoDB(nodeInfo: NodeInfo) {
-        createSession {
-            val info = findByIdentityKey(it, nodeInfo.legalIdentitiesAndCerts.first().owningKey).single()
-            it.remove(info)
-        }
+    private fun removeInfoDB(session: Session, nodeInfo: NodeInfo) {
+        val info = findByIdentityKey(session, nodeInfo.legalIdentitiesAndCerts.first().owningKey).single()
+        session.remove(info)
     }
 
     private fun findByIdentityKey(session: Session, identityKey: PublicKey): List<NodeInfoSchemaV1.PersistentNodeInfo> {
@@ -328,48 +316,40 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
         return query.resultList
     }
 
-    private fun queryByIdentityKey(identityKey: PublicKey): List<NodeInfo> {
-        createSession {
-            val result = findByIdentityKey(it, identityKey)
-            return result.map { it.toNodeInfo() }
-        }
+    private fun queryByIdentityKey(session: Session, identityKey: PublicKey): List<NodeInfo> {
+        val result = findByIdentityKey(session, identityKey)
+        return result.map { it.toNodeInfo() }
     }
 
-    private fun queryIdentityByLegalName(name: CordaX500Name): PartyAndCertificate? {
-        createSession {
-            val query = it.createQuery(
-                    // We do the JOIN here to restrict results to those present in the network map
-                    "SELECT DISTINCT l FROM ${NodeInfoSchemaV1.PersistentNodeInfo::class.java.name} n JOIN n.legalIdentitiesAndCerts l WHERE l.name = :name",
-                    NodeInfoSchemaV1.DBPartyAndCertificate::class.java)
-            query.setParameter("name", name.toString())
-            val candidates = query.resultList.map { it.toLegalIdentityAndCert() }
-            // The map is restricted to holding a single identity for any X.500 name, so firstOrNull() is correct here.
-            return candidates.firstOrNull()
-        }
+    private fun queryIdentityByLegalName(session: Session, name: CordaX500Name): PartyAndCertificate? {
+        val query = session.createQuery(
+                // We do the JOIN here to restrict results to those present in the network map
+                "SELECT DISTINCT l FROM ${NodeInfoSchemaV1.PersistentNodeInfo::class.java.name} n JOIN n.legalIdentitiesAndCerts l WHERE l.name = :name",
+                NodeInfoSchemaV1.DBPartyAndCertificate::class.java)
+        query.setParameter("name", name.toString())
+        val candidates = query.resultList.map { it.toLegalIdentityAndCert() }
+        // The map is restricted to holding a single identity for any X.500 name, so firstOrNull() is correct here.
+        return candidates.firstOrNull()
     }
 
-    private fun queryByLegalName(name: CordaX500Name): List<NodeInfo> {
-        createSession {
-            val query = it.createQuery(
-                    "SELECT n FROM ${NodeInfoSchemaV1.PersistentNodeInfo::class.java.name} n JOIN n.legalIdentitiesAndCerts l WHERE l.name = :name",
-                    NodeInfoSchemaV1.PersistentNodeInfo::class.java)
-            query.setParameter("name", name.toString())
-            val result = query.resultList
-            return result.map { it.toNodeInfo() }
-        }
+    private fun queryByLegalName(session: Session, name: CordaX500Name): List<NodeInfo> {
+        val query = session.createQuery(
+                "SELECT n FROM ${NodeInfoSchemaV1.PersistentNodeInfo::class.java.name} n JOIN n.legalIdentitiesAndCerts l WHERE l.name = :name",
+                NodeInfoSchemaV1.PersistentNodeInfo::class.java)
+        query.setParameter("name", name.toString())
+        val result = query.resultList
+        return result.map { it.toNodeInfo() }
     }
 
-    private fun queryByAddress(hostAndPort: NetworkHostAndPort): NodeInfo? {
-        createSession {
-            val query = it.createQuery(
-                    "SELECT n FROM ${NodeInfoSchemaV1.PersistentNodeInfo::class.java.name} n JOIN n.addresses a WHERE a.pk.host = :host AND a.pk.port = :port",
-                    NodeInfoSchemaV1.PersistentNodeInfo::class.java)
-            query.setParameter("host", hostAndPort.host)
-            query.setParameter("port", hostAndPort.port)
-            val result = query.resultList
-            return if (result.isEmpty()) null
-            else result.map { it.toNodeInfo() }.singleOrNull() ?: throw IllegalStateException("More than one node with the same host and port")
-        }
+    private fun queryByAddress(session: Session, hostAndPort: NetworkHostAndPort): NodeInfo? {
+        val query = session.createQuery(
+                "SELECT n FROM ${NodeInfoSchemaV1.PersistentNodeInfo::class.java.name} n JOIN n.addresses a WHERE a.pk.host = :host AND a.pk.port = :port",
+                NodeInfoSchemaV1.PersistentNodeInfo::class.java)
+        query.setParameter("host", hostAndPort.host)
+        query.setParameter("port", hostAndPort.port)
+        val result = query.resultList
+        return if (result.isEmpty()) null
+        else result.map { it.toNodeInfo() }.singleOrNull() ?: throw IllegalStateException("More than one node with the same host and port")
     }
 
     /** Object Relational Mapping support. */
@@ -388,10 +368,8 @@ open class PersistentNetworkMapCache(private val serviceHub: ServiceHubInternal)
 
     override fun clearNetworkMapCache() {
         serviceHub.database.transaction {
-            createSession {
-                val result = getAllInfos(it)
-                for (nodeInfo in result) it.remove(nodeInfo)
-            }
+            val result = getAllInfos(session)
+            for (nodeInfo in result) session.remove(nodeInfo)
         }
     }
 }
diff --git a/node/src/main/kotlin/net/corda/node/services/persistence/DBCheckpointStorage.kt b/node/src/main/kotlin/net/corda/node/services/persistence/DBCheckpointStorage.kt
index a82642adf7..b9b5f0bbdc 100644
--- a/node/src/main/kotlin/net/corda/node/services/persistence/DBCheckpointStorage.kt
+++ b/node/src/main/kotlin/net/corda/node/services/persistence/DBCheckpointStorage.kt
@@ -3,8 +3,8 @@ package net.corda.node.services.persistence
 import net.corda.core.serialization.SerializedBytes
 import net.corda.node.services.api.Checkpoint
 import net.corda.node.services.api.CheckpointStorage
-import net.corda.node.utilities.DatabaseTransactionManager
 import net.corda.node.utilities.NODE_DATABASE_PREFIX
+import net.corda.node.utilities.currentDBSession
 import javax.persistence.Column
 import javax.persistence.Entity
 import javax.persistence.Id
@@ -28,15 +28,14 @@ class DBCheckpointStorage : CheckpointStorage {
     )
 
     override fun addCheckpoint(checkpoint: Checkpoint) {
-        val session = DatabaseTransactionManager.current().session
-        session.save(DBCheckpoint().apply {
+        currentDBSession().save(DBCheckpoint().apply {
             checkpointId = checkpoint.id.toString()
             this.checkpoint = checkpoint.serializedFiber.bytes
         })
     }
 
     override fun removeCheckpoint(checkpoint: Checkpoint) {
-        val session = DatabaseTransactionManager.current().session
+        val session = currentDBSession()
         val criteriaBuilder = session.criteriaBuilder
         val delete = criteriaBuilder.createCriteriaDelete(DBCheckpoint::class.java)
         val root = delete.from(DBCheckpoint::class.java)
@@ -45,7 +44,7 @@ class DBCheckpointStorage : CheckpointStorage {
     }
 
     override fun forEach(block: (Checkpoint) -> Boolean) {
-        val session = DatabaseTransactionManager.current().session
+        val session = currentDBSession()
         val criteriaQuery = session.criteriaBuilder.createQuery(DBCheckpoint::class.java)
         val root = criteriaQuery.from(DBCheckpoint::class.java)
         criteriaQuery.select(root)
diff --git a/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt b/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt
index c864521d7b..c95fe2bf94 100644
--- a/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/persistence/NodeAttachmentService.kt
@@ -13,8 +13,8 @@ import net.corda.core.crypto.SecureHash
 import net.corda.core.node.services.AttachmentStorage
 import net.corda.core.serialization.*
 import net.corda.core.utilities.loggerFor
-import net.corda.node.utilities.DatabaseTransactionManager
 import net.corda.node.utilities.NODE_DATABASE_PREFIX
+import net.corda.node.utilities.currentDBSession
 import java.io.*
 import java.nio.file.Paths
 import java.util.jar.JarInputStream
@@ -50,7 +50,7 @@ class NodeAttachmentService(metrics: MetricRegistry) : AttachmentStorage, Single
     private val attachmentCount = metrics.counter("Attachments")
 
     init {
-        val session = DatabaseTransactionManager.current().session
+        val session = currentDBSession()
         val criteriaBuilder = session.criteriaBuilder
         val criteriaQuery = criteriaBuilder.createQuery(Long::class.java)
         criteriaQuery.select(criteriaBuilder.count(criteriaQuery.from(NodeAttachmentService.DBAttachment::class.java)))
@@ -140,7 +140,7 @@ class NodeAttachmentService(metrics: MetricRegistry) : AttachmentStorage, Single
     }
 
     override fun openAttachment(id: SecureHash): Attachment? {
-        val attachment = DatabaseTransactionManager.current().session.get(NodeAttachmentService.DBAttachment::class.java, id.toString())
+        val attachment = currentDBSession().get(NodeAttachmentService.DBAttachment::class.java, id.toString())
         attachment?.let {
             return AttachmentImpl(id, { attachment.content }, checkAttachmentsOnLoad)
         }
@@ -161,7 +161,7 @@ class NodeAttachmentService(metrics: MetricRegistry) : AttachmentStorage, Single
         checkIsAValidJAR(ByteArrayInputStream(bytes))
         val id = SecureHash.SHA256(hs.hash().asBytes())
 
-        val session = DatabaseTransactionManager.current().session
+        val session = currentDBSession()
         val criteriaBuilder = session.criteriaBuilder
         val criteriaQuery = criteriaBuilder.createQuery(Long::class.java)
         val attachments = criteriaQuery.from(NodeAttachmentService.DBAttachment::class.java)
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 3b5236d97a..864da2bd50 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
@@ -29,6 +29,7 @@ import net.corda.node.services.persistence.HibernateConfiguration
 import net.corda.node.services.statemachine.FlowStateMachineImpl
 import net.corda.node.utilities.DatabaseTransactionManager
 import net.corda.node.utilities.bufferUntilDatabaseCommit
+import net.corda.node.utilities.currentDBSession
 import net.corda.node.utilities.wrapWithDatabaseTransaction
 import org.hibernate.Session
 import rx.Observable
@@ -38,6 +39,15 @@ import java.time.Clock
 import java.time.Instant
 import java.util.*
 import javax.persistence.Tuple
+import javax.persistence.criteria.CriteriaBuilder
+import javax.persistence.criteria.CriteriaUpdate
+import javax.persistence.criteria.Predicate
+import javax.persistence.criteria.Root
+
+private fun CriteriaBuilder.executeUpdate(session: Session, configure: Root<*>.(CriteriaUpdate<*>) -> Any?) = createCriteriaUpdate(VaultSchemaV1.VaultStates::class.java).let { update ->
+    update.from(VaultSchemaV1.VaultStates::class.java).run { configure(update) }
+    session.createQuery(update).executeUpdate()
+}
 
 /**
  * Currently, the node vault service is a very simple RDBMS backed implementation.  It will change significantly when
@@ -73,7 +83,7 @@ class NodeVaultService(private val clock: Clock, private val keyManagementServic
             val consumedStateRefs = update.consumed.map { it.ref }
             log.trace { "Removing $consumedStateRefs consumed contract states and adding $producedStateRefs produced contract states to the database." }
 
-            val session = DatabaseTransactionManager.current().session
+            val session = currentDBSession()
             producedStateRefsMap.forEach { stateAndRef ->
                 val state = VaultSchemaV1.VaultStates(
                         notary = stateAndRef.value.state.notary,
@@ -189,7 +199,7 @@ class NodeVaultService(private val clock: Clock, private val keyManagementServic
     private fun loadStates(refs: Collection<StateRef>): HashSet<StateAndRef<ContractState>> {
         val states = HashSet<StateAndRef<ContractState>>()
         if (refs.isNotEmpty()) {
-            val session = DatabaseTransactionManager.current().session
+            val session = currentDBSession()
             val criteriaBuilder = session.criteriaBuilder
             val criteriaQuery = criteriaBuilder.createQuery(VaultSchemaV1.VaultStates::class.java)
             val vaultStates = criteriaQuery.from(VaultSchemaV1.VaultStates::class.java)
@@ -223,11 +233,11 @@ class NodeVaultService(private val clock: Clock, private val keyManagementServic
 
     override fun addNoteToTransaction(txnId: SecureHash, noteText: String) {
         val txnNoteEntity = VaultSchemaV1.VaultTxnNote(txnId.toString(), noteText)
-        DatabaseTransactionManager.current().session.save(txnNoteEntity)
+        currentDBSession().save(txnNoteEntity)
     }
 
     override fun getTransactionNotes(txnId: SecureHash): Iterable<String> {
-        val session = DatabaseTransactionManager.current().session
+        val session = currentDBSession()
         val criteriaBuilder = session.criteriaBuilder
         val criteriaQuery = criteriaBuilder.createQuery(VaultSchemaV1.VaultTxnNote::class.java)
         val vaultStates = criteriaQuery.from(VaultSchemaV1.VaultTxnNote::class.java)
@@ -241,35 +251,34 @@ class NodeVaultService(private val clock: Clock, private val keyManagementServic
     override fun softLockReserve(lockId: UUID, stateRefs: NonEmptySet<StateRef>) {
         val softLockTimestamp = clock.instant()
         try {
-            val session = DatabaseTransactionManager.current().session
+            val session = currentDBSession()
             val criteriaBuilder = session.criteriaBuilder
-            val criteriaUpdate = criteriaBuilder.createCriteriaUpdate(VaultSchemaV1.VaultStates::class.java)
-            val vaultStates = criteriaUpdate.from(VaultSchemaV1.VaultStates::class.java)
-            val stateStatusPredication = criteriaBuilder.equal(vaultStates.get<Vault.StateStatus>(VaultSchemaV1.VaultStates::stateStatus.name), Vault.StateStatus.UNCONSUMED)
-            val lockIdPredicate = criteriaBuilder.or(vaultStates.get<String>(VaultSchemaV1.VaultStates::lockId.name).isNull,
-                    criteriaBuilder.equal(vaultStates.get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString()))
-            val persistentStateRefs = stateRefs.map { PersistentStateRef(it.txhash.bytes.toHexString(), it.index) }
-            val compositeKey = vaultStates.get<PersistentStateRef>(VaultSchemaV1.VaultStates::stateRef.name)
-            val stateRefsPredicate = criteriaBuilder.and(compositeKey.`in`(persistentStateRefs))
-            criteriaUpdate.set(vaultStates.get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString())
-            criteriaUpdate.set(vaultStates.get<Instant>(VaultSchemaV1.VaultStates::lockUpdateTime.name), softLockTimestamp)
-            criteriaUpdate.where(stateStatusPredication, lockIdPredicate, stateRefsPredicate)
-            val updatedRows = session.createQuery(criteriaUpdate).executeUpdate()
+            fun execute(configure: Root<*>.(CriteriaUpdate<*>, Array<Predicate>) -> Any?) = criteriaBuilder.executeUpdate(session) { update ->
+                val persistentStateRefs = stateRefs.map { PersistentStateRef(it.txhash.bytes.toHexString(), it.index) }
+                val compositeKey = get<PersistentStateRef>(VaultSchemaV1.VaultStates::stateRef.name)
+                val stateRefsPredicate = criteriaBuilder.and(compositeKey.`in`(persistentStateRefs))
+                configure(update, arrayOf(stateRefsPredicate))
+            }
+
+            val updatedRows = execute { update, commonPredicates ->
+                val stateStatusPredication = criteriaBuilder.equal(get<Vault.StateStatus>(VaultSchemaV1.VaultStates::stateStatus.name), Vault.StateStatus.UNCONSUMED)
+                val lockIdPredicate = criteriaBuilder.or(get<String>(VaultSchemaV1.VaultStates::lockId.name).isNull,
+                        criteriaBuilder.equal(get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString()))
+                update.set(get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString())
+                update.set(get<Instant>(VaultSchemaV1.VaultStates::lockUpdateTime.name), softLockTimestamp)
+                update.where(stateStatusPredication, lockIdPredicate, *commonPredicates)
+            }
             if (updatedRows > 0 && updatedRows == stateRefs.size) {
                 log.trace("Reserving soft lock states for $lockId: $stateRefs")
                 FlowStateMachineImpl.currentStateMachine()?.hasSoftLockedStates = true
             } else {
                 // revert partial soft locks
-                val criteriaRevertUpdate = criteriaBuilder.createCriteriaUpdate(VaultSchemaV1.VaultStates::class.java)
-                val vaultStatesRevert = criteriaRevertUpdate.from(VaultSchemaV1.VaultStates::class.java)
-                val lockIdPredicateRevert = criteriaBuilder.equal(vaultStatesRevert.get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString())
-                val lockUpdateTime = criteriaBuilder.equal(vaultStatesRevert.get<Instant>(VaultSchemaV1.VaultStates::lockUpdateTime.name), softLockTimestamp)
-                val persistentStateRefsRevert = stateRefs.map { PersistentStateRef(it.txhash.bytes.toHexString(), it.index) }
-                val compositeKeyRevert = vaultStatesRevert.get<PersistentStateRef>(VaultSchemaV1.VaultStates::stateRef.name)
-                val stateRefsPredicateRevert = criteriaBuilder.and(compositeKeyRevert.`in`(persistentStateRefsRevert))
-                criteriaRevertUpdate.set(vaultStatesRevert.get<String>(VaultSchemaV1.VaultStates::lockId.name), criteriaBuilder.nullLiteral(String::class.java))
-                criteriaRevertUpdate.where(lockUpdateTime, lockIdPredicateRevert, stateRefsPredicateRevert)
-                val revertUpdatedRows = session.createQuery(criteriaRevertUpdate).executeUpdate()
+                val revertUpdatedRows = execute { update, commonPredicates ->
+                    val lockIdPredicate = criteriaBuilder.equal(get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString())
+                    val lockUpdateTime = criteriaBuilder.equal(get<Instant>(VaultSchemaV1.VaultStates::lockUpdateTime.name), softLockTimestamp)
+                    update.set(get<String>(VaultSchemaV1.VaultStates::lockId.name), criteriaBuilder.nullLiteral(String::class.java))
+                    update.where(lockUpdateTime, lockIdPredicate, *commonPredicates)
+                }
                 if (revertUpdatedRows > 0) {
                     log.trace("Reverting $revertUpdatedRows partially soft locked states for $lockId")
                 }
@@ -286,33 +295,30 @@ class NodeVaultService(private val clock: Clock, private val keyManagementServic
 
     override fun softLockRelease(lockId: UUID, stateRefs: NonEmptySet<StateRef>?) {
         val softLockTimestamp = clock.instant()
-        val session = DatabaseTransactionManager.current().session
+        val session = currentDBSession()
         val criteriaBuilder = session.criteriaBuilder
+        fun execute(configure: Root<*>.(CriteriaUpdate<*>, Array<Predicate>) -> Any?) = criteriaBuilder.executeUpdate(session) { update ->
+            val stateStatusPredication = criteriaBuilder.equal(get<Vault.StateStatus>(VaultSchemaV1.VaultStates::stateStatus.name), Vault.StateStatus.UNCONSUMED)
+            val lockIdPredicate = criteriaBuilder.equal(get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString())
+            update.set<String>(get<String>(VaultSchemaV1.VaultStates::lockId.name), criteriaBuilder.nullLiteral(String::class.java))
+            update.set(get<Instant>(VaultSchemaV1.VaultStates::lockUpdateTime.name), softLockTimestamp)
+            configure(update, arrayOf(stateStatusPredication, lockIdPredicate))
+        }
         if (stateRefs == null) {
-            val criteriaUpdate = criteriaBuilder.createCriteriaUpdate(VaultSchemaV1.VaultStates::class.java)
-            val vaultStates = criteriaUpdate.from(VaultSchemaV1.VaultStates::class.java)
-            val stateStatusPredication = criteriaBuilder.equal(vaultStates.get<Vault.StateStatus>(VaultSchemaV1.VaultStates::stateStatus.name), Vault.StateStatus.UNCONSUMED)
-            val lockIdPredicate = criteriaBuilder.equal(vaultStates.get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString())
-            criteriaUpdate.set<String>(vaultStates.get<String>(VaultSchemaV1.VaultStates::lockId.name), criteriaBuilder.nullLiteral(String::class.java))
-            criteriaUpdate.set(vaultStates.get<Instant>(VaultSchemaV1.VaultStates::lockUpdateTime.name), softLockTimestamp)
-            criteriaUpdate.where(stateStatusPredication, lockIdPredicate)
-            val update = session.createQuery(criteriaUpdate).executeUpdate()
+            val update = execute { update, commonPredicates ->
+                update.where(*commonPredicates)
+            }
             if (update > 0) {
                 log.trace("Releasing $update soft locked states for $lockId")
             }
         } else {
             try {
-                val criteriaUpdate = criteriaBuilder.createCriteriaUpdate(VaultSchemaV1.VaultStates::class.java)
-                val vaultStates = criteriaUpdate.from(VaultSchemaV1.VaultStates::class.java)
-                val stateStatusPredication = criteriaBuilder.equal(vaultStates.get<Vault.StateStatus>(VaultSchemaV1.VaultStates::stateStatus.name), Vault.StateStatus.UNCONSUMED)
-                val lockIdPredicate = criteriaBuilder.equal(vaultStates.get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString())
-                val persistentStateRefs = stateRefs.map { PersistentStateRef(it.txhash.bytes.toHexString(), it.index) }
-                val compositeKey = vaultStates.get<PersistentStateRef>(VaultSchemaV1.VaultStates::stateRef.name)
-                val stateRefsPredicate = criteriaBuilder.and(compositeKey.`in`(persistentStateRefs))
-                criteriaUpdate.set<String>(vaultStates.get<String>(VaultSchemaV1.VaultStates::lockId.name), criteriaBuilder.nullLiteral(String::class.java))
-                criteriaUpdate.set(vaultStates.get<Instant>(VaultSchemaV1.VaultStates::lockUpdateTime.name), softLockTimestamp)
-                criteriaUpdate.where(stateStatusPredication, lockIdPredicate, stateRefsPredicate)
-                val updatedRows = session.createQuery(criteriaUpdate).executeUpdate()
+                val updatedRows = execute { update, commonPredicates ->
+                    val persistentStateRefs = stateRefs.map { PersistentStateRef(it.txhash.bytes.toHexString(), it.index) }
+                    val compositeKey = get<PersistentStateRef>(VaultSchemaV1.VaultStates::stateRef.name)
+                    val stateRefsPredicate = criteriaBuilder.and(compositeKey.`in`(persistentStateRefs))
+                    update.where(*commonPredicates, stateRefsPredicate)
+                }
                 if (updatedRows > 0) {
                     log.trace("Releasing $updatedRows soft locked states for $lockId and stateRefs $stateRefs")
                 }
diff --git a/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt b/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt
index 62508f0e2b..a90f77d171 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt
@@ -40,10 +40,11 @@ class AppendOnlyPersistentMap<K, V, E, out EK>(
      * Returns all key/value pairs from the underlying storage.
      */
     fun allPersisted(): Sequence<Pair<K, V>> {
-        val criteriaQuery = DatabaseTransactionManager.current().session.criteriaBuilder.createQuery(persistentEntityClass)
+        val session = currentDBSession()
+        val criteriaQuery = session.criteriaBuilder.createQuery(persistentEntityClass)
         val root = criteriaQuery.from(persistentEntityClass)
         criteriaQuery.select(root)
-        val query = DatabaseTransactionManager.current().session.createQuery(criteriaQuery)
+        val query = session.createQuery(criteriaQuery)
         val result = query.resultList
         return result.map { x -> fromPersistentEntity(x) }.asSequence()
     }
@@ -87,7 +88,7 @@ class AppendOnlyPersistentMap<K, V, E, out EK>(
      */
     operator fun set(key: K, value: V) =
             set(key, value, logWarning = false) { k, v ->
-                DatabaseTransactionManager.current().session.save(toPersistentEntity(k, v))
+                currentDBSession().save(toPersistentEntity(k, v))
                 null
             }
 
@@ -98,9 +99,10 @@ class AppendOnlyPersistentMap<K, V, E, out EK>(
      */
     fun addWithDuplicatesAllowed(key: K, value: V, logWarning: Boolean = true): Boolean =
             set(key, value, logWarning) { k, v ->
-                val existingEntry = DatabaseTransactionManager.current().session.find(persistentEntityClass, toPersistentEntityKey(k))
+                val session = currentDBSession()
+                val existingEntry = session.find(persistentEntityClass, toPersistentEntityKey(k))
                 if (existingEntry == null) {
-                    DatabaseTransactionManager.current().session.save(toPersistentEntity(k, v))
+                    session.save(toPersistentEntity(k, v))
                     null
                 } else {
                     fromPersistentEntity(existingEntry).second
@@ -114,7 +116,7 @@ class AppendOnlyPersistentMap<K, V, E, out EK>(
     }
 
     private fun loadValue(key: K): V? {
-        val result = DatabaseTransactionManager.current().session.find(persistentEntityClass, toPersistentEntityKey(key))
+        val result = currentDBSession().find(persistentEntityClass, toPersistentEntityKey(key))
         return result?.let(fromPersistentEntity)?.second
     }
 
@@ -125,7 +127,7 @@ class AppendOnlyPersistentMap<K, V, E, out EK>(
      * WARNING!! The method is not thread safe.
      */
     fun clear() {
-        val session = DatabaseTransactionManager.current().session
+        val session = currentDBSession()
         val deleteQuery = session.criteriaBuilder.createCriteriaDelete(persistentEntityClass)
         deleteQuery.from(persistentEntityClass)
         session.createQuery(deleteQuery).executeUpdate()
diff --git a/node/src/main/kotlin/net/corda/node/utilities/DatabaseTransactionManager.kt b/node/src/main/kotlin/net/corda/node/utilities/DatabaseTransactionManager.kt
index 9016112f7b..6c810a7005 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/DatabaseTransactionManager.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/DatabaseTransactionManager.kt
@@ -62,6 +62,7 @@ class DatabaseTransaction(isolation: Int, val threadLocal: ThreadLocal<DatabaseT
     }
 }
 
+fun currentDBSession() = DatabaseTransactionManager.current().session
 class DatabaseTransactionManager(initDataSource: CordaPersistence) {
     companion object {
         private val threadLocalDb = ThreadLocal<CordaPersistence>()
diff --git a/node/src/main/kotlin/net/corda/node/utilities/PersistentMap.kt b/node/src/main/kotlin/net/corda/node/utilities/PersistentMap.kt
index c24ce3c229..11ace024ef 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/PersistentMap.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/PersistentMap.kt
@@ -28,7 +28,7 @@ class PersistentMap<K, V, E, out EK>(
             removalListener = ExplicitRemoval(toPersistentEntityKey, persistentEntityClass)
     ).apply {
         //preload to allow all() to take data only from the cache (cache is unbound)
-        val session = DatabaseTransactionManager.current().session
+        val session = currentDBSession()
         val criteriaQuery = session.criteriaBuilder.createQuery(persistentEntityClass)
         criteriaQuery.select(criteriaQuery.from(persistentEntityClass))
         getAll(session.createQuery(criteriaQuery).resultList.map { e -> fromPersistentEntity(e as E).first }.asIterable())
@@ -38,7 +38,7 @@ class PersistentMap<K, V, E, out EK>(
         override fun onRemoval(notification: RemovalNotification<K, V>?) {
             when (notification?.cause) {
                 RemovalCause.EXPLICIT -> {
-                    val session = DatabaseTransactionManager.current().session
+                    val session = currentDBSession()
                     val elem = session.find(persistentEntityClass, toPersistentEntityKey(notification.key))
                     if (elem != null) {
                         session.remove(elem)
@@ -101,7 +101,7 @@ class PersistentMap<K, V, E, out EK>(
             set(key, value,
                     logWarning = false,
                     store = { k: K, v: V ->
-                        DatabaseTransactionManager.current().session.save(toPersistentEntity(k, v))
+                        currentDBSession().save(toPersistentEntity(k, v))
                         null
                     },
                     replace = { _: K, _: V -> Unit }
@@ -115,9 +115,10 @@ class PersistentMap<K, V, E, out EK>(
     fun addWithDuplicatesAllowed(key: K, value: V) =
             set(key, value,
                     store = { k, v ->
-                        val existingEntry = DatabaseTransactionManager.current().session.find(persistentEntityClass, toPersistentEntityKey(k))
+                        val session = currentDBSession()
+                        val existingEntry = session.find(persistentEntityClass, toPersistentEntityKey(k))
                         if (existingEntry == null) {
-                            DatabaseTransactionManager.current().session.save(toPersistentEntity(k, v))
+                            session.save(toPersistentEntity(k, v))
                             null
                         } else {
                             fromPersistentEntity(existingEntry).second
@@ -145,18 +146,19 @@ class PersistentMap<K, V, E, out EK>(
     }
 
     private fun merge(key: K, value: V): V? {
-        val existingEntry = DatabaseTransactionManager.current().session.find(persistentEntityClass, toPersistentEntityKey(key))
+        val session = currentDBSession()
+        val existingEntry = session.find(persistentEntityClass, toPersistentEntityKey(key))
         return if (existingEntry != null) {
-            DatabaseTransactionManager.current().session.merge(toPersistentEntity(key, value))
+            session.merge(toPersistentEntity(key, value))
             fromPersistentEntity(existingEntry).second
         } else {
-            DatabaseTransactionManager.current().session.save(toPersistentEntity(key, value))
+            session.save(toPersistentEntity(key, value))
             null
         }
     }
 
     private fun loadValue(key: K): V? {
-        val result = DatabaseTransactionManager.current().session.find(persistentEntityClass, toPersistentEntityKey(key))
+        val result = currentDBSession().find(persistentEntityClass, toPersistentEntityKey(key))
         return result?.let(fromPersistentEntity)?.second
     }
 
@@ -256,7 +258,7 @@ class PersistentMap<K, V, E, out EK>(
     }
 
     fun load() {
-        val session = DatabaseTransactionManager.current().session
+        val session = currentDBSession()
         val criteriaQuery = session.criteriaBuilder.createQuery(persistentEntityClass)
         criteriaQuery.select(criteriaQuery.from(persistentEntityClass))
         cache.getAll(session.createQuery(criteriaQuery).resultList.map { e -> fromPersistentEntity(e as E).first }.asIterable())
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt
index 46e954ecde..d3ee944069 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt
@@ -11,7 +11,6 @@ import net.corda.core.internal.write
 import net.corda.core.internal.writeLines
 import net.corda.node.services.transactions.PersistentUniquenessProvider
 import net.corda.node.utilities.CordaPersistence
-import net.corda.node.utilities.DatabaseTransactionManager
 import net.corda.node.utilities.configureDatabase
 import net.corda.testing.LogHelper
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
@@ -98,19 +97,18 @@ class NodeAttachmentStorageTest {
     @Test
     fun `corrupt entry throws exception`() {
         val testJar = makeTestJar()
-        val id =
-                database.transaction {
-                    val storage = NodeAttachmentService(MetricRegistry())
-                    val id = testJar.read { storage.importAttachment(it) }
+        val id = database.transaction {
+            val storage = NodeAttachmentService(MetricRegistry())
+            val id = testJar.read { storage.importAttachment(it) }
 
-                    // Corrupt the file in the store.
-                    val bytes = testJar.readAll()
-                    val corruptBytes = "arggghhhh".toByteArray()
-                    System.arraycopy(corruptBytes, 0, bytes, 0, corruptBytes.size)
-                    val corruptAttachment = NodeAttachmentService.DBAttachment(attId = id.toString(), content = bytes)
-                    DatabaseTransactionManager.current().session.merge(corruptAttachment)
-                    id
-                }
+            // Corrupt the file in the store.
+            val bytes = testJar.readAll()
+            val corruptBytes = "arggghhhh".toByteArray()
+            System.arraycopy(corruptBytes, 0, bytes, 0, corruptBytes.size)
+            val corruptAttachment = NodeAttachmentService.DBAttachment(attId = id.toString(), content = bytes)
+            session.merge(corruptAttachment)
+            id
+        }
         database.transaction {
             val storage = NodeAttachmentService(MetricRegistry())
             val e = assertFailsWith<NodeAttachmentService.HashMismatchException> {

From 86ede6f92852ab841f80a57081c2dc58d3f3ab15 Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Fri, 13 Oct 2017 12:21:48 +0100
Subject: [PATCH 169/185] Upgraded to 2.0-SNAPSHOT since current changes are
 for 2.0 (#1880)

---
 build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index ca5904ba95..70abd216ca 100644
--- a/build.gradle
+++ b/build.gradle
@@ -4,7 +4,7 @@ buildscript {
     file("$projectDir/constants.properties").withInputStream { constants.load(it) }
 
     // Our version: bump this on release.
-    ext.corda_release_version = "1.1-SNAPSHOT"
+    ext.corda_release_version = "2.0-SNAPSHOT"
     // Increment this on any release that changes public APIs anywhere in the Corda platform
     // TODO This is going to be difficult until we have a clear separation throughout the code of what is public and what is internal
     ext.corda_platform_version = 1

From 635ad9ac9217853a61879c1d8b628a29ab0bf0af Mon Sep 17 00:00:00 2001
From: Chris Rankin <chris.rankin@r3.com>
Date: Fri, 13 Oct 2017 12:27:42 +0100
Subject: [PATCH 170/185] Ensure that the contents of OpaqueBytes cannot be
 modified. (#1871)

* Ensure that contents of OpaqueBytes cannot be modified.
* Update documentation and restore the signature verification check.
* Update the API definition.
* KDoc fixes.
* Update the changelog for v1.1.
---
 .ci/api-current.txt                           |  2 +-
 .../net/corda/core/crypto/SecureHash.kt       | 56 +++++++++++++++++--
 .../transactions/TransactionWithSignatures.kt |  2 -
 .../net/corda/core/utilities/ByteArrays.kt    | 31 +++++++++-
 .../TransactionSerializationTests.kt          |  8 ++-
 docs/source/changelog.rst                     |  3 +
 6 files changed, 90 insertions(+), 12 deletions(-)

diff --git a/.ci/api-current.txt b/.ci/api-current.txt
index 6892aeae53..6e8e8df371 100644
--- a/.ci/api-current.txt
+++ b/.ci/api-current.txt
@@ -2923,7 +2923,7 @@ public static final class net.corda.core.utilities.NonEmptySet$iterator$1 extend
 ##
 public class net.corda.core.utilities.OpaqueBytes extends net.corda.core.utilities.ByteSequence
   public <init>(byte[])
-  @org.jetbrains.annotations.NotNull public byte[] getBytes()
+  @org.jetbrains.annotations.NotNull public final byte[] getBytes()
   public int getOffset()
   public int getSize()
   public static final net.corda.core.utilities.OpaqueBytes$Companion Companion
diff --git a/core/src/main/kotlin/net/corda/core/crypto/SecureHash.kt b/core/src/main/kotlin/net/corda/core/crypto/SecureHash.kt
index 16bf533550..6555ac6af7 100644
--- a/core/src/main/kotlin/net/corda/core/crypto/SecureHash.kt
+++ b/core/src/main/kotlin/net/corda/core/crypto/SecureHash.kt
@@ -19,39 +19,87 @@ sealed class SecureHash(bytes: ByteArray) : OpaqueBytes(bytes) {
         }
     }
 
+    /**
+     * Convert the hash value to an uppercase hexadecimal [String].
+     */
     override fun toString(): String = bytes.toHexString()
 
+    /**
+     * Returns the first [prefixLen] hexadecimal digits of the [SecureHash] value.
+     * @param prefixLen The number of characters in the prefix.
+     */
     fun prefixChars(prefixLen: Int = 6) = toString().substring(0, prefixLen)
+
+    /**
+     * Append a second hash value to this hash value, and then compute the SHA-256 hash of the result.
+     * @param other The hash to append to this one.
+     */
     fun hashConcat(other: SecureHash) = (this.bytes + other.bytes).sha256()
 
     // Like static methods in Java, except the 'companion' is a singleton that can have state.
     companion object {
+        /**
+         * Converts a SHA-256 hash value represented as a hexadecimal [String] into a [SecureHash].
+         * @param str A sequence of 64 hexadecimal digits that represents a SHA-256 hash value.
+         * @throws IllegalArgumentException The input string does not contain 64 hexadecimal digits, or it contains incorrectly-encoded characters.
+         */
         @JvmStatic
-        fun parse(str: String) = str.toUpperCase().parseAsHex().let {
-            when (it.size) {
-                32 -> SHA256(it)
-                else -> throw IllegalArgumentException("Provided string is ${it.size} bytes not 32 bytes in hex: $str")
+        fun parse(str: String): SHA256 {
+            return str.toUpperCase().parseAsHex().let {
+                when (it.size) {
+                    32 -> SHA256(it)
+                    else -> throw IllegalArgumentException("Provided string is ${it.size} bytes not 32 bytes in hex: $str")
+                }
             }
         }
 
+        /**
+         * Computes the SHA-256 hash value of the [ByteArray].
+         * @param bytes The [ByteArray] to hash.
+         */
         @JvmStatic
         fun sha256(bytes: ByteArray) = SHA256(MessageDigest.getInstance("SHA-256").digest(bytes))
 
+        /**
+         * Computes the SHA-256 hash of the [ByteArray], and then computes the SHA-256 hash of the hash.
+         * @param bytes The [ByteArray] to hash.
+         */
         @JvmStatic
         fun sha256Twice(bytes: ByteArray) = sha256(sha256(bytes).bytes)
 
+        /**
+         * Computes the SHA-256 hash of the [String]'s UTF-8 byte contents.
+         * @param str [String] whose UTF-8 contents will be hashed.
+         */
         @JvmStatic
         fun sha256(str: String) = sha256(str.toByteArray())
 
+        /**
+         * Generates a random SHA-256 value.
+         */
         @JvmStatic
         fun randomSHA256() = sha256(newSecureRandom().generateSeed(32))
 
+        /**
+         * A SHA-256 hash value consisting of 32 0x00 bytes.
+         */
         val zeroHash = SecureHash.SHA256(ByteArray(32, { 0.toByte() }))
+
+        /**
+         * A SHA-256 hash value consisting of 32 0xFF bytes.
+         */
         val allOnesHash = SecureHash.SHA256(ByteArray(32, { 255.toByte() }))
     }
 
     // In future, maybe SHA3, truncated hashes etc.
 }
 
+/**
+ * Compute the SHA-256 hash for the contents of the [ByteArray].
+ */
 fun ByteArray.sha256(): SecureHash.SHA256 = SecureHash.sha256(this)
+
+/**
+ * Compute the SHA-256 hash for the contents of the [OpaqueBytes].
+ */
 fun OpaqueBytes.sha256(): SecureHash.SHA256 = SecureHash.sha256(this.bytes)
diff --git a/core/src/main/kotlin/net/corda/core/transactions/TransactionWithSignatures.kt b/core/src/main/kotlin/net/corda/core/transactions/TransactionWithSignatures.kt
index 1909168198..ab25d68064 100644
--- a/core/src/main/kotlin/net/corda/core/transactions/TransactionWithSignatures.kt
+++ b/core/src/main/kotlin/net/corda/core/transactions/TransactionWithSignatures.kt
@@ -1,8 +1,6 @@
 package net.corda.core.transactions
 
-import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.NamedByHash
-import net.corda.core.contracts.TransactionState
 import net.corda.core.crypto.TransactionSignature
 import net.corda.core.crypto.isFulfilledBy
 import net.corda.core.transactions.SignedTransaction.SignaturesMissingException
diff --git a/core/src/main/kotlin/net/corda/core/utilities/ByteArrays.kt b/core/src/main/kotlin/net/corda/core/utilities/ByteArrays.kt
index a2b74a11ff..cf8b1f915d 100644
--- a/core/src/main/kotlin/net/corda/core/utilities/ByteArrays.kt
+++ b/core/src/main/kotlin/net/corda/core/utilities/ByteArrays.kt
@@ -118,8 +118,11 @@ sealed class ByteSequence : Comparable<ByteSequence> {
  * In an ideal JVM this would be a value type and be completely overhead free. Project Valhalla is adding such
  * functionality to Java, but it won't arrive for a few years yet!
  */
-open class OpaqueBytes(override val bytes: ByteArray) : ByteSequence() {
+open class OpaqueBytes(bytes: ByteArray) : ByteSequence() {
     companion object {
+        /**
+         * Create [OpaqueBytes] from a sequence of [Byte] values.
+         */
         @JvmStatic
         fun of(vararg b: Byte) = OpaqueBytes(byteArrayOf(*b))
     }
@@ -128,13 +131,35 @@ open class OpaqueBytes(override val bytes: ByteArray) : ByteSequence() {
         require(bytes.isNotEmpty())
     }
 
-    override val size: Int get() = bytes.size
-    override val offset: Int get() = 0
+    /**
+     * The bytes are always cloned so that this object becomes immutable. This has been done
+     * to prevent tampering with entities such as [SecureHash] and [PrivacySalt], as well as
+     * preserve the integrity of our hash constants [zeroHash] and [allOnesHash].
+     *
+     * Cloning like this may become a performance issue, depending on whether or not the JIT
+     * compiler is ever able to optimise away the clone. In which case we may need to revisit
+     * this later.
+     */
+    override final val bytes: ByteArray = bytes
+        get() = field.clone()
+    override val size: Int = bytes.size
+    override val offset: Int = 0
 }
 
+/**
+ * Copy [size] bytes from this [ByteArray] starting from [offset] into a new [ByteArray].
+ */
 fun ByteArray.sequence(offset: Int = 0, size: Int = this.size) = ByteSequence.of(this, offset, size)
 
+/**
+ * Converts this [ByteArray] into a [String] of hexadecimal digits.
+ */
 fun ByteArray.toHexString(): String = DatatypeConverter.printHexBinary(this)
+
+/**
+ * Converts this [String] of hexadecimal digits into a [ByteArray].
+ * @throws IllegalArgumentException if the [String] contains incorrectly-encoded characters.
+ */
 fun String.parseAsHex(): ByteArray = DatatypeConverter.parseHexBinary(this)
 
 /**
diff --git a/core/src/test/kotlin/net/corda/core/serialization/TransactionSerializationTests.kt b/core/src/test/kotlin/net/corda/core/serialization/TransactionSerializationTests.kt
index 88ef89b662..6a3324e6dd 100644
--- a/core/src/test/kotlin/net/corda/core/serialization/TransactionSerializationTests.kt
+++ b/core/src/test/kotlin/net/corda/core/serialization/TransactionSerializationTests.kt
@@ -12,11 +12,12 @@ import org.junit.Before
 import org.junit.Test
 import java.security.SignatureException
 import java.util.*
+import kotlin.reflect.jvm.javaField
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class TransactionSerializationTests : TestDependencyInjectionBase() {
-    val TEST_CASH_PROGRAM_ID = "net.corda.core.serialization.TransactionSerializationTests\$TestCash"
+    private val TEST_CASH_PROGRAM_ID = "net.corda.core.serialization.TransactionSerializationTests\$TestCash"
 
     class TestCash : Contract {
         override fun verify(tx: LedgerTransaction) {
@@ -65,7 +66,10 @@ class TransactionSerializationTests : TestDependencyInjectionBase() {
         stx.verifyRequiredSignatures()
 
         // Corrupt the data and ensure the signature catches the problem.
-        stx.id.bytes[5] = stx.id.bytes[5].inc()
+        val bytesField = stx.id::bytes.javaField?.apply { setAccessible(true) }
+        val bytes = bytesField?.get(stx.id) as ByteArray
+        bytes[5] = bytes[5].inc()
+
         assertFailsWith(SignatureException::class) {
             stx.verifyRequiredSignatures()
         }
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index ddc74beb2a..0ff4e44495 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -6,6 +6,9 @@ from the previous milestone release.
 
 UNRELEASED
 ----------
+* ``OpaqueBytes.bytes`` now returns a clone of its underlying ``ByteArray``, and has been redeclared as ``final``.
+  This is a minor change to the public API, but is required to ensure that classes like ``SecureHash`` are immutable.
+
 * ``FlowLogic`` now exposes a series of function called ``receiveAll(...)`` allowing to join ``receive(...)`` instructions.
 
 * The ``Cordformation`` gradle plugin has been split into ``cordformation`` and ``cordapp``. The former builds and

From b8538d5eb786debffc67b44fc9241684b01e8705 Mon Sep 17 00:00:00 2001
From: Christian Sailer <sar@mailraum.de>
Date: Fri, 13 Oct 2017 14:43:33 +0100
Subject: [PATCH 171/185] Fix file resource for non-unix filesystems.

---
 .../net/corda/signing/configuration/ConfigurationTest.kt     | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/signing-server/src/test/kotlin/net/corda/signing/configuration/ConfigurationTest.kt b/signing-server/src/test/kotlin/net/corda/signing/configuration/ConfigurationTest.kt
index 57b9ee613b..514715037e 100644
--- a/signing-server/src/test/kotlin/net/corda/signing/configuration/ConfigurationTest.kt
+++ b/signing-server/src/test/kotlin/net/corda/signing/configuration/ConfigurationTest.kt
@@ -3,12 +3,13 @@ package net.corda.signing.configuration
 import com.typesafe.config.ConfigException
 import net.corda.signing.authentication.AuthMode
 import org.junit.Test
+import java.io.File
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class ConfigurationTest {
-    private val validConfigPath = javaClass.getResource("/signing_service.conf").path
-    private val invalidConfigPath = javaClass.getResource("/signing_service_fail.conf").path
+    private val validConfigPath = File(javaClass.getResource("/signing_service.conf").path).absolutePath
+    private val invalidConfigPath = File(javaClass.getResource("/signing_service_fail.conf").path).absolutePath
 
     @Test
     fun `authMode is parsed correctly`() {

From 26803616964b0ed9651957748685d6bd0f1cf7ef Mon Sep 17 00:00:00 2001
From: Clinton <clintonxa@gmail.com>
Date: Fri, 13 Oct 2017 15:01:24 +0100
Subject: [PATCH 172/185] Renamed "plugins" dir to "cordapps" (#1644)

* Renamed plugins dir to cordapps dir while maintaining backwards compatibility with the plugins dir.
Bumped gradle plugins to 2.0.4
---
 .../rpc/StandaloneCordaRPCJavaClientTest.java |  6 +-
 .../kotlin/rpc/StandaloneCordaRPClientTest.kt |  4 +-
 constants.properties                          |  2 +-
 docs/source/azure-vm.rst                      |  6 +-
 docs/source/changelog.rst                     |  2 +
 docs/source/cordapp-build-systems.rst         |  6 +-
 docs/source/demobench.rst                     |  8 +--
 docs/source/deploying-a-node.rst              |  2 +-
 docs/source/hello-world-introduction.rst      |  2 +-
 docs/source/hello-world-running.rst           |  2 +-
 .../key-concepts-contract-constraints.rst     |  2 +-
 docs/source/key-concepts-node.rst             | 10 +--
 docs/source/node-services.rst                 |  2 +-
 docs/source/running-a-node.rst                |  2 +-
 docs/source/tutorial-cordapp.rst              |  4 +-
 .../main/groovy/net/corda/plugins/Node.groovy | 16 ++---
 .../node/services/AttachmentLoadingTests.kt   |  2 +-
 node/src/main/java/CordaCaplet.java           | 23 +++----
 .../node/internal/cordapp/CordappLoader.kt    | 24 +++++---
 .../kotlin/net/corda/node/CordappSmokeTest.kt |  9 +--
 tools/demobench/build.gradle                  |  6 +-
 .../net/corda/demobench/explorer/Explorer.kt  |  9 +--
 .../model/{HasPlugins.kt => HasCordapps.kt}   |  4 +-
 .../corda/demobench/model/InstallFactory.kt   |  4 +-
 .../net/corda/demobench/model/NodeConfig.kt   |  9 +--
 .../corda/demobench/model/NodeController.kt   | 12 ++--
 .../demobench/plugin/CordappController.kt     | 61 +++++++++++++++++++
 .../demobench/plugin/PluginController.kt      | 58 ------------------
 .../demobench/profile/ProfileController.kt    | 37 ++++++-----
 .../corda/demobench/model/NodeConfigTest.kt   |  1 +
 .../src/main/java/ExplorerCaplet.java         |  2 +-
 31 files changed, 176 insertions(+), 161 deletions(-)
 rename tools/demobench/src/main/kotlin/net/corda/demobench/model/{HasPlugins.kt => HasCordapps.kt} (56%)
 create mode 100644 tools/demobench/src/main/kotlin/net/corda/demobench/plugin/CordappController.kt
 delete mode 100644 tools/demobench/src/main/kotlin/net/corda/demobench/plugin/PluginController.kt

diff --git a/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java b/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java
index 70ae26e1b6..31daccc9c2 100644
--- a/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java
+++ b/client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java
@@ -74,9 +74,9 @@ public class StandaloneCordaRPCJavaClientTest {
     }
 
     private void copyFinanceCordapp() {
-        Path pluginsDir = (factory.baseDirectory(notaryConfig).resolve("plugins"));
+        Path cordappsDir = (factory.baseDirectory(notaryConfig).resolve("cordapps"));
         try {
-            Files.createDirectories(pluginsDir);
+            Files.createDirectories(cordappsDir);
         } catch (IOException ex) {
             fail("Failed to create directories");
         }
@@ -84,7 +84,7 @@ public class StandaloneCordaRPCJavaClientTest {
             paths.forEach(file -> {
                 if (file.toString().contains("corda-finance")) {
                     try {
-                        Files.copy(file, pluginsDir.resolve(file.getFileName()));
+                        Files.copy(file, cordappsDir.resolve(file.getFileName()));
                     } catch (IOException ex) {
                         fail("Failed to copy finance jar");
                     }
diff --git a/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt b/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt
index 1d487f762b..d6d305f542 100644
--- a/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt
+++ b/client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt
@@ -89,12 +89,12 @@ class StandaloneCordaRPClientTest {
     }
 
     private fun copyFinanceCordapp() {
-        val pluginsDir = (factory.baseDirectory(notaryConfig) / "plugins").createDirectories()
+        val cordappsDir = (factory.baseDirectory(notaryConfig) / "cordapps").createDirectories()
         // Find the finance jar file for the smoke tests of this module
         val financeJar = Paths.get("build", "resources", "smokeTest").list {
             it.filter { "corda-finance" in it.toString() }.toList().single()
         }
-        financeJar.copyToDirectory(pluginsDir)
+        financeJar.copyToDirectory(cordappsDir)
     }
 
     @Test
diff --git a/constants.properties b/constants.properties
index deebebf5d5..48f942803c 100644
--- a/constants.properties
+++ b/constants.properties
@@ -1,4 +1,4 @@
-gradlePluginsVersion=2.0.3
+gradlePluginsVersion=2.0.4
 kotlinVersion=1.1.50
 guavaVersion=21.0
 bouncycastleVersion=1.57
diff --git a/docs/source/azure-vm.rst b/docs/source/azure-vm.rst
index bc5ae24fa4..7f94f0fdcb 100644
--- a/docs/source/azure-vm.rst
+++ b/docs/source/azure-vm.rst
@@ -97,7 +97,7 @@ Loading the Yo! CordDapp on your Corda nodes lets you send simple Yo! messages t
 
 * **Loading the Yo! CorDapp onto your nodes**
 
-The nodes you will use to send and receive Yo messages require the Yo! CorDapp jar file to be saved to their plugins directory.
+The nodes you will use to send and receive Yo messages require the Yo! CorDapp jar file to be saved to their cordapps directory.
 
 Connect to one of your Corda nodes (make sure this is not the Notary node) using an SSH client of your choice (e.g. Putty) and log into the virtual machine using the public IP address and your SSH key or username / password combination you defined in Step 1 of the Azure build process. Type the following command:
 
@@ -105,14 +105,14 @@ For Corda nodes running release M10
 
 .. sourcecode:: shell
 
-	cd /opt/corda/plugins
+	cd /opt/corda/cordapps
 	wget http://downloads.corda.net/cordapps/net/corda/yo/0.10.1/yo-0.10.1.jar
 
 For Corda nodes running release M11
 
 .. sourcecode:: shell
 
-	cd /opt/corda/plugins
+	cd /opt/corda/cordapps
 	wget http://downloads.corda.net/cordapps/net/corda/yo/0.11.0/yo-0.11.0.jar
 
 Now restart Corda and the Corda webserver using the following commands or restart your Corda VM from the Azure portal:
diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst
index 0ff4e44495..e3be980710 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -11,6 +11,8 @@ UNRELEASED
 
 * ``FlowLogic`` now exposes a series of function called ``receiveAll(...)`` allowing to join ``receive(...)`` instructions.
 
+* Renamed "plugins" directory on nodes to "cordapps"
+
 * The ``Cordformation`` gradle plugin has been split into ``cordformation`` and ``cordapp``. The former builds and
   deploys nodes for development and testing, the latter turns a project into a cordapp project that generates JARs in
   the standard CorDapp format.
diff --git a/docs/source/cordapp-build-systems.rst b/docs/source/cordapp-build-systems.rst
index 016d741bf2..e20065838f 100644
--- a/docs/source/cordapp-build-systems.rst
+++ b/docs/source/cordapp-build-systems.rst
@@ -78,11 +78,11 @@ For further information about managing dependencies, see
 Installing CorDapps
 -------------------
 
-At runtime, nodes will load any plugins present in their ``plugins`` folder. Therefore in order to install a cordapp to
-a node the cordapp JAR must be added to the ``<node_dir>/plugins/`` folder, where ``node_dir`` is the folder in which the
+At runtime, nodes will load any CorDapp JARs present in their ``cordapps`` folder. Therefore in order to install a CorDapp to
+a node the CorDapp JAR must be added to the ``<node_dir>/cordapps/`` folder, where ``node_dir`` is the folder in which the
 node's JAR and configuration files are stored).
 
-The ``deployNodes`` gradle task, if correctly configured, will automatically place your cordapp JAR as well as any
+The ``deployNodes`` gradle task, if correctly configured, will automatically place your CorDapp JAR as well as any
 dependent cordapp JARs specified into the directory automatically.
 
 Example
diff --git a/docs/source/demobench.rst b/docs/source/demobench.rst
index 5382547301..374f12234a 100644
--- a/docs/source/demobench.rst
+++ b/docs/source/demobench.rst
@@ -37,13 +37,13 @@ Profiles
 
     notary/
         node.conf
-        plugins/
+        cordapps/
     banka/
         node.conf
-        plugins/
+        cordapps/
     bankb/
         node.conf
-        plugins/
+        cordapps/
             example-cordapp.jar
     ...
 
@@ -133,7 +133,7 @@ current working directory of the JVM):
         corda-webserver.jar
     explorer/
         node-explorer.jar
-    plugins/
+    cordapps/
         bank-of-corda.jar
 
 ..
diff --git a/docs/source/deploying-a-node.rst b/docs/source/deploying-a-node.rst
index 4125947fd8..74f8bdac65 100644
--- a/docs/source/deploying-a-node.rst
+++ b/docs/source/deploying-a-node.rst
@@ -84,7 +84,7 @@ run all the nodes at once. Each node in the ``nodes`` folder has the following s
     . nodeName
     ├── corda.jar               // The Corda runtime
     ├── node.conf               // The node's configuration
-    ├── plugins                 // Any installed CorDapps
+    ├── cordapps                // Any installed CorDapps
     └── additional-node-infos   // Directory containing all the addresses and certificates of the other nodes.
 
 .. note:: During the build process each node generates a NodeInfo file which is written in its own root directory,
diff --git a/docs/source/hello-world-introduction.rst b/docs/source/hello-world-introduction.rst
index 9760d91a6d..25bb4e189d 100644
--- a/docs/source/hello-world-introduction.rst
+++ b/docs/source/hello-world-introduction.rst
@@ -5,7 +5,7 @@ By this point, :doc:`your dev environment should be set up <getting-set-up>`, yo
 :doc:`your first CorDapp <tutorial-cordapp>`, and you're familiar with Corda's :doc:`key concepts <key-concepts>`. What
 comes next?
 
-If you're a developer, the next step is to write your own CorDapp. Each CorDapp takes the form of a plugin that is
+If you're a developer, the next step is to write your own CorDapp. Each CorDapp takes the form of a JAR that is
 installed on one or more Corda nodes, and gives them the ability to conduct some new process - anything from
 issuing a debt instrument to making a restaurant booking.
 
diff --git a/docs/source/hello-world-running.rst b/docs/source/hello-world-running.rst
index b5bf916e18..72c573b789 100644
--- a/docs/source/hello-world-running.rst
+++ b/docs/source/hello-world-running.rst
@@ -82,7 +82,7 @@ the three node folders. Each node folder has the following structure:
         |____dependencies
         |____node.conf                     // The node's configuration file
         |____additional-node-infos/        // Directory containing all the other nodes' addresses and identities
-        |____plugins
+        |____cordapps
           |____java/kotlin-source-0.1.jar  // Our IOU CorDapp
 
 Let's start the nodes by running the following commands from the root of the project:
diff --git a/docs/source/key-concepts-contract-constraints.rst b/docs/source/key-concepts-contract-constraints.rst
index 39840924fd..edd4c6694d 100644
--- a/docs/source/key-concepts-contract-constraints.rst
+++ b/docs/source/key-concepts-contract-constraints.rst
@@ -146,4 +146,4 @@ The driver takes a parameter called ``extraCordappPackagesToScan`` which is a li
 Full Nodes
 **********
 
-When testing against full nodes simply place your CorDapp into the plugins directory of the node.
+When testing against full nodes simply place your CorDapp into the cordapps directory of the node.
diff --git a/docs/source/key-concepts-node.rst b/docs/source/key-concepts-node.rst
index 537d0aebc4..624f5308af 100644
--- a/docs/source/key-concepts-node.rst
+++ b/docs/source/key-concepts-node.rst
@@ -36,7 +36,7 @@ The core elements of the architecture are:
 * A network interface for interacting with other nodes
 * An RPC interface for interacting with the node's owner
 * A service hub for allowing the node's flows to call upon the node's other services
-* A plugin registry for extending the node by installing CorDapps
+* A cordapp interface and provider for extending the node by installing CorDapps
 
 Persistence layer
 -----------------
@@ -68,11 +68,11 @@ updates. The key services provided are:
 * Information about the node itself
 * The current time, as tracked by the node
 
-The plugin registry
--------------------
-The plugin registry is where new CorDapps are installed to extend the behavior of the node.
+The CorDapp provider
+--------------------
+The CorDapp provider is where new CorDapps are installed to extend the behavior of the node.
 
-The node also has several plugins installed by default to handle common tasks such as:
+The node also has several CorDapps installed by default to handle common tasks such as:
 
 * Retrieving transactions and attachments from counterparties
 * Upgrading contracts
diff --git a/docs/source/node-services.rst b/docs/source/node-services.rst
index 3ab92255b6..d62edd2548 100644
--- a/docs/source/node-services.rst
+++ b/docs/source/node-services.rst
@@ -320,7 +320,7 @@ does this by tracking update notifications from the
 ``TransactionStorage`` service and processing relevant updates to delete 
 consumed states and insert new states. The resulting update is then 
 persisted to the database. The ``VaultService`` then exposes query and 
-event notification APIs to flows and CorDapp plugins to allow them 
+event notification APIs to flows and CorDapp services to allow them
 to respond to updates, or query for states meeting various conditions to 
 begin the formation of new transactions consuming them. The equivalent 
 services are also forwarded to RPC clients, so that they may show 
diff --git a/docs/source/running-a-node.rst b/docs/source/running-a-node.rst
index b87378bd29..4373e93a3e 100644
--- a/docs/source/running-a-node.rst
+++ b/docs/source/running-a-node.rst
@@ -10,7 +10,7 @@ already installed. You run each node by navigating to ``<node_dir>`` in a termin
 
    java -jar corda.jar
 
-.. warning:: If your working directory is not ``<node_dir>`` your plugins and configuration will not be used.
+.. warning:: If your working directory is not ``<node_dir>`` your cordapps and configuration will not be used.
 
 The configuration file and workspace paths can be overridden on the command line. For example:
 
diff --git a/docs/source/tutorial-cordapp.rst b/docs/source/tutorial-cordapp.rst
index c61e20f4be..7073a67af3 100644
--- a/docs/source/tutorial-cordapp.rst
+++ b/docs/source/tutorial-cordapp.rst
@@ -210,9 +210,9 @@ Building the example CorDapp
         . nodeName
         ├── corda.jar
         ├── node.conf
-        └── plugins
+        └── cordapps
 
-    ``corda.jar`` is the Corda runtime, ``plugins`` contains our node's CorDapps, and the node's configuration is
+    ``corda.jar`` is the Corda runtime, ``cordapps`` contains our node's CorDapps, and the node's configuration is
     given by ``node.conf``
 
 Running the example CorDapp
diff --git a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
index f6963541d4..8f6dcea295 100644
--- a/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
+++ b/gradle-plugins/cordformation/src/main/groovy/net/corda/plugins/Node.groovy
@@ -17,7 +17,7 @@ class Node extends CordformNode {
     static final String WEBJAR_NAME = 'corda-webserver.jar'
 
     /**
-     * Set the list of CorDapps to install to the plugins directory. Each cordapp is a fully qualified Maven
+     * Set the list of CorDapps to install to the cordapps directory. Each cordapp is a fully qualified Maven
      * dependency name, eg: com.example:product-name:0.1
      *
      * @note Your app will be installed by default and does not need to be included here.
@@ -104,7 +104,7 @@ class Node extends CordformNode {
         if (config.hasPath("webAddress")) {
             installWebserverJar()
         }
-        installBuiltPlugin()
+        installBuiltCordapp()
         installCordapps()
         installConfig()
         appendOptionalConfig()
@@ -157,23 +157,23 @@ class Node extends CordformNode {
     /**
      * Installs this project's cordapp to this directory.
      */
-    private void installBuiltPlugin() {
-        def pluginsDir = new File(nodeDir, "plugins")
+    private void installBuiltCordapp() {
+        def cordappsDir = new File(nodeDir, "cordapps")
         project.copy {
             from project.jar
-            into pluginsDir
+            into cordappsDir
         }
     }
 
     /**
-     * Installs other cordapps to this node's plugins directory.
+     * Installs other cordapps to this node's cordapps directory.
      */
     private void installCordapps() {
-        def pluginsDir = new File(nodeDir, "plugins")
+        def cordappsDir = new File(nodeDir, "cordapps")
         def cordapps = getCordappList()
         project.copy {
             from cordapps
-            into pluginsDir
+            into cordappsDir
         }
     }
 
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
index 3c15d0aec5..3ea5527202 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@@ -69,7 +69,7 @@ class AttachmentLoadingTests : TestDependencyInjectionBase() {
 
         private fun DriverDSLExposedInterface.installIsolatedCordappTo(nodeName: CordaX500Name) {
             // Copy the app jar to the first node. The second won't have it.
-            val path = (baseDirectory(nodeName.toString()) / "plugins").createDirectories() / "isolated.jar"
+            val path = (baseDirectory(nodeName.toString()) / "cordapps").createDirectories() / "isolated.jar"
             logger.info("Installing isolated jar to $path")
             isolatedJAR.openStream().buffered().use { input ->
                 Files.newOutputStream(path).buffered().use { output ->
diff --git a/node/src/main/java/CordaCaplet.java b/node/src/main/java/CordaCaplet.java
index 83e76ae2ba..fa39580fa7 100644
--- a/node/src/main/java/CordaCaplet.java
+++ b/node/src/main/java/CordaCaplet.java
@@ -24,26 +24,27 @@ public class CordaCaplet extends Capsule {
         // defined as public static final fields on the Capsule class, therefore referential equality is safe.
         if (ATTR_APP_CLASS_PATH == attr) {
             T cp = super.attribute(attr);
-            return (T) augmentClasspath((List<Path>) cp, "plugins");
+
+            (new File("cordapps")).mkdir();
+            augmentClasspath((List<Path>) cp, "cordapps");
+            augmentClasspath((List<Path>) cp, "plugins");
+            return cp;
         }
         return super.attribute(attr);
     }
 
     // TODO: Make directory configurable via the capsule manifest.
     // TODO: Add working directory variable to capsules string replacement variables.
-    private List<Path> augmentClasspath(List<Path> classpath, String dirName) {
+    private void augmentClasspath(List<Path> classpath, String dirName) {
         File dir = new File(dirName);
-        if (!dir.exists()) {
-            dir.mkdir();
-        }
-
-        File[] files = dir.listFiles();
-        for (File file : files) {
-            if (file.isFile() && isJAR(file)) {
-                classpath.add(file.toPath().toAbsolutePath());
+        if (dir.exists()) {
+            File[] files = dir.listFiles();
+            for (File file : files) {
+                if (file.isFile() && isJAR(file)) {
+                    classpath.add(file.toPath().toAbsolutePath());
+                }
             }
         }
-        return classpath;
     }
 
     @Override
diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
index 7cdba9ca71..c481bfcc36 100644
--- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
@@ -54,22 +54,30 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
     companion object {
         private val logger = loggerFor<CordappLoader>()
 
+        /**
+         * Default cordapp dir name
+         */
+        val CORDAPPS_DIR_NAME = "cordapps"
+
         /**
          * Creates a default CordappLoader intended to be used in non-dev or non-test environments.
          *
-         * @param baseDir The directory that this node is running in. Will use this to resolve the plugins directory
+         * @param baseDir The directory that this node is running in. Will use this to resolve the cordapps directory
          *                  for classpath scanning.
          */
-        fun createDefault(baseDir: Path) = CordappLoader(getCordappsInDirectory(getPluginsPath(baseDir)))
+        fun createDefault(baseDir: Path) = CordappLoader(getCordappsInDirectory(getCordappsPath(baseDir)))
 
         /**
          * Create a dev mode CordappLoader for test environments that creates and loads cordapps from the classpath
-         * and plugins directory. This is intended mostly for use by the driver.
+         * and cordapps directory. This is intended mostly for use by the driver.
+         *
+         * @param baseDir See [createDefault.baseDir]
+         * @param testPackages See [createWithTestPackages.testPackages]
          */
         @VisibleForTesting
         fun createDefaultWithTestPackages(configuration: NodeConfiguration, testPackages: List<String>): CordappLoader {
             check(configuration.devMode) { "Package scanning can only occur in dev mode" }
-            return CordappLoader(getCordappsInDirectory(getPluginsPath(configuration.baseDirectory)) + testPackages.flatMap(this::createScanPackage))
+            return CordappLoader(getCordappsInDirectory(getCordappsPath(configuration.baseDirectory)) + testPackages.flatMap(this::createScanPackage))
         }
 
         /**
@@ -91,7 +99,7 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
         @VisibleForTesting
         fun createDevMode(scanJars: List<URL>) = CordappLoader(scanJars)
 
-        private fun getPluginsPath(baseDir: Path): Path = baseDir / "plugins"
+        private fun getCordappsPath(baseDir: Path): Path = baseDir / CORDAPPS_DIR_NAME
 
         private fun createScanPackage(scanPackage: String): List<URL> {
             val resource = scanPackage.replace('.', '/')
@@ -135,11 +143,11 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
             return generatedCordapps[path]!!
         }
 
-        private fun getCordappsInDirectory(pluginsDir: Path): List<URL> {
-            return if (!pluginsDir.exists()) {
+        private fun getCordappsInDirectory(cordappsDir: Path): List<URL> {
+            return if (!cordappsDir.exists()) {
                 emptyList<URL>()
             } else {
-                pluginsDir.list {
+                cordappsDir.list {
                     it.filter { it.isRegularFile() && it.toString().endsWith(".jar") }.map { it.toUri().toURL() }.toList()
                 }
             }
diff --git a/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt b/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt
index dbb62d3bac..82c48bf82e 100644
--- a/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt
+++ b/node/src/smoke-test/kotlin/net/corda/node/CordappSmokeTest.kt
@@ -11,6 +11,7 @@ import net.corda.core.internal.list
 import net.corda.core.messaging.startFlow
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.unwrap
+import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.nodeapi.User
 import net.corda.smoketesting.NodeConfig
 import net.corda.smoketesting.NodeProcess
@@ -39,12 +40,12 @@ class CordappSmokeTest {
 
     @Test
     fun `FlowContent appName returns the filename of the CorDapp jar`() {
-        val pluginsDir = (factory.baseDirectory(aliceConfig) / "plugins").createDirectories()
+        val cordappsDir = (factory.baseDirectory(aliceConfig) / CordappLoader.CORDAPPS_DIR_NAME).createDirectories()
         // Find the jar file for the smoke tests of this module
         val selfCordapp = Paths.get("build", "libs").list {
             it.filter { "-smokeTests" in it.toString() }.toList().single()
         }
-        selfCordapp.copyToDirectory(pluginsDir)
+        selfCordapp.copyToDirectory(cordappsDir)
 
         factory.create(aliceConfig).use { alice ->
             alice.connect().use { connectionToAlice ->
@@ -59,8 +60,8 @@ class CordappSmokeTest {
     }
 
     @Test
-    fun `empty plugins directory`() {
-        (factory.baseDirectory(aliceConfig) / "plugins").createDirectories()
+    fun `empty cordapps directory`() {
+        (factory.baseDirectory(aliceConfig) / CordappLoader.CORDAPPS_DIR_NAME).createDirectories()
         factory.create(aliceConfig).close()
     }
 
diff --git a/tools/demobench/build.gradle b/tools/demobench/build.gradle
index c2d1142cc7..c3626bd72f 100644
--- a/tools/demobench/build.gradle
+++ b/tools/demobench/build.gradle
@@ -122,12 +122,12 @@ distributions {
             }
             from(project(':finance').tasks.jar) {
                 rename 'corda-finance-(.*)', 'corda-finance.jar'
-                into 'plugins'
+                into 'cordapps'
                 fileMode = 0444
             }
             from(project(':samples:bank-of-corda-demo').jar) {
                 rename 'bank-of-corda-demo-(.*)', 'bank-of-corda.jar'
-                into 'plugins'
+                into 'cordapps'
                 fileMode = 0444
             }
         }
@@ -201,7 +201,7 @@ task javapackage(dependsOn: distZip) {
 
                 fileset(dir: dist_source, type: 'data') {
                     include(name: 'corda/*.jar')
-                    include(name: 'plugins/*.jar')
+                    include(name: 'cordapps/*.jar')
                     include(name: 'explorer/*.jar')
                 }
 
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt
index 165388b2b0..286ad1e4c6 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/explorer/Explorer.kt
@@ -5,6 +5,7 @@ import net.corda.core.internal.div
 import net.corda.core.internal.list
 import net.corda.core.utilities.loggerFor
 import net.corda.demobench.model.JVMConfig
+import net.corda.demobench.model.NodeConfig
 import net.corda.demobench.model.NodeConfigWrapper
 import net.corda.demobench.readErrorLines
 import tornadofx.*
@@ -82,11 +83,11 @@ class Explorer internal constructor(private val explorerController: ExplorerCont
         // Note: does not copy dependencies because we should soon be making all apps fat jars and dependencies implicit.
         //
         // TODO: Remove this code when serialisation has been upgraded.
-        val pluginsDir = config.explorerDir / "plugins"
-        pluginsDir.createDirectories()
-        config.pluginDir.list {
+        val cordappsDir = config.explorerDir / NodeConfig.cordappDirName
+        cordappsDir.createDirectories()
+        config.cordappsDir.list {
             it.forEachOrdered { path ->
-                val destPath = pluginsDir / path.fileName.toString()
+                val destPath = cordappsDir / path.fileName.toString()
                 try {
                     // Try making a symlink to make things faster and use less disk space.
                     Files.createSymbolicLink(destPath, path)
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/HasPlugins.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/HasCordapps.kt
similarity index 56%
rename from tools/demobench/src/main/kotlin/net/corda/demobench/model/HasPlugins.kt
rename to tools/demobench/src/main/kotlin/net/corda/demobench/model/HasCordapps.kt
index 52a388b7a7..de0a2607b5 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/HasPlugins.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/HasCordapps.kt
@@ -2,6 +2,6 @@ package net.corda.demobench.model
 
 import java.nio.file.Path
 
-interface HasPlugins {
-    val pluginDir: Path
+interface HasCordapps {
+    val cordappsDir: Path
 }
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
index f34ebfef6d..d2dba4a687 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/InstallFactory.kt
@@ -37,9 +37,9 @@ class InstallFactory : Controller() {
  * Wraps the configuration information for a Node
  * which isn't ready to be instantiated yet.
  */
-class InstallConfig internal constructor(val baseDir: Path, private val config: NodeConfigWrapper) : HasPlugins {
+class InstallConfig internal constructor(val baseDir: Path, private val config: NodeConfigWrapper) : HasCordapps {
     val key = config.key
-    override val pluginDir: Path = baseDir / "plugins"
+    override val cordappsDir: Path = baseDir / "cordapps"
 
     fun deleteBaseDir(): Boolean = baseDir.toFile().deleteRecursively()
     fun installTo(installDir: Path) = config.copy(baseDir = installDir)
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
index e536b3bfb4..504fdfab79 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeConfig.kt
@@ -31,6 +31,7 @@ data class NodeConfig(
     companion object {
         val renderOptions: ConfigRenderOptions = ConfigRenderOptions.defaults().setOriginComments(false)
         val defaultUser = user("guest")
+        val cordappDirName = "cordapps"
     }
 
     @Suppress("unused")
@@ -56,18 +57,18 @@ data class NotaryService(val validating: Boolean) : ExtraService {
 }
 
 // TODO Think of a better name
-data class NodeConfigWrapper(val baseDir: Path, val nodeConfig: NodeConfig) : HasPlugins {
+data class NodeConfigWrapper(val baseDir: Path, val nodeConfig: NodeConfig) : HasCordapps {
     val key: String = nodeConfig.myLegalName.organisation.toKey()
     val nodeDir: Path = baseDir / key
     val explorerDir: Path = baseDir / "$key-explorer"
-    override val pluginDir: Path = nodeDir / "plugins"
+    override val cordappsDir: Path = nodeDir / NodeConfig.cordappDirName
     var state: NodeState = NodeState.STARTING
 
     fun install(cordapps: Collection<Path>) {
         if (cordapps.isEmpty()) return
-        pluginDir.createDirectories()
+        cordappsDir.createDirectories()
         for (cordapp in cordapps) {
-            cordapp.copyToDirectory(pluginDir, StandardCopyOption.REPLACE_EXISTING)
+            cordapp.copyToDirectory(cordappsDir, StandardCopyOption.REPLACE_EXISTING)
         }
     }
 }
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
index 4e7b6a6cc7..e13f23d3bb 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
@@ -7,7 +7,7 @@ import net.corda.core.internal.createDirectories
 import net.corda.core.internal.div
 import net.corda.core.internal.noneOrSingle
 import net.corda.core.utilities.NetworkHostAndPort
-import net.corda.demobench.plugin.PluginController
+import net.corda.demobench.plugin.CordappController
 import net.corda.demobench.pty.R3Pty
 import tornadofx.*
 import java.io.IOException
@@ -27,7 +27,7 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
     }
 
     private val jvm by inject<JVMConfig>()
-    private val pluginController by inject<PluginController>()
+    private val cordappController by inject<CordappController>()
 
     private var baseDir: Path = baseDirFor(ManagementFactory.getRuntimeMXBean().startTime)
     private val cordaPath: Path = jvm.applicationDir.resolve("corda").resolve("corda.jar")
@@ -112,7 +112,7 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
             config.nodeDir.createDirectories()
 
             // Install any built-in plugins into the working directory.
-            pluginController.populate(config)
+            cordappController.populate(config)
 
             // Write this node's configuration file into its working directory.
             val confFile = config.nodeDir / "node.conf"
@@ -164,9 +164,9 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
     fun install(config: InstallConfig): NodeConfigWrapper {
         val installed = config.installTo(baseDir)
 
-        pluginController.userPluginsFor(config).forEach {
-            installed.pluginDir.createDirectories()
-            val plugin = it.copyToDirectory(installed.pluginDir)
+        cordappController.useCordappsFor(config).forEach {
+            installed.cordappsDir.createDirectories()
+            val plugin = it.copyToDirectory(installed.cordappsDir)
             log.info("Installed: $plugin")
         }
 
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/plugin/CordappController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/plugin/CordappController.kt
new file mode 100644
index 0000000000..765824f4e8
--- /dev/null
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/plugin/CordappController.kt
@@ -0,0 +1,61 @@
+package net.corda.demobench.plugin
+
+import net.corda.core.internal.copyToDirectory
+import net.corda.core.internal.createDirectories
+import net.corda.core.internal.exists
+import net.corda.demobench.model.HasCordapps
+import net.corda.demobench.model.JVMConfig
+import net.corda.demobench.model.NodeConfig
+import net.corda.demobench.model.NodeConfigWrapper
+import tornadofx.*
+import java.io.IOException
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.StandardCopyOption
+import java.util.stream.Stream
+
+class CordappController : Controller() {
+
+    private val jvm by inject<JVMConfig>()
+    private val cordappDir: Path = jvm.applicationDir.resolve(NodeConfig.cordappDirName)
+    private val bankOfCorda: Path = cordappDir.resolve("bank-of-corda.jar")
+    private val finance: Path = cordappDir.resolve("corda-finance.jar")
+
+    /**
+     * Install any built-in cordapps that this node requires.
+     */
+    @Throws(IOException::class)
+    fun populate(config: NodeConfigWrapper) {
+        if (!config.cordappsDir.exists()) {
+            config.cordappsDir.createDirectories()
+        }
+        if (finance.exists()) {
+            finance.copyToDirectory(config.cordappsDir, StandardCopyOption.REPLACE_EXISTING)
+            log.info("Installed 'Finance' cordapp")
+        }
+        // Nodes cannot issue cash unless they contain the "Bank of Corda" cordapp.
+        if (config.nodeConfig.issuableCurrencies.isNotEmpty() && bankOfCorda.exists()) {
+            bankOfCorda.copyToDirectory(config.cordappsDir, StandardCopyOption.REPLACE_EXISTING)
+            log.info("Installed 'Bank of Corda' cordapp")
+        }
+    }
+
+    /**
+     * Generates a stream of a node's non-built-in cordapps.
+     */
+    @Throws(IOException::class)
+    fun useCordappsFor(config: HasCordapps): Stream<Path> = walkCordapps(config.cordappsDir)
+            .filter { !bankOfCorda.endsWith(it.fileName) }
+            .filter { !finance.endsWith(it.fileName) }
+
+    private fun walkCordapps(cordappsDir: Path): Stream<Path> {
+        return if (Files.isDirectory(cordappsDir))
+            Files.walk(cordappsDir, 1).filter(Path::isCordapp)
+        else
+            Stream.empty()
+    }
+
+}
+
+fun Path.isCordapp(): Boolean = Files.isReadable(this) && this.fileName.toString().endsWith(".jar")
+fun Path.inCordappsDir(): Boolean = (this.parent != null) && this.parent.endsWith("cordapps/")
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/plugin/PluginController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/plugin/PluginController.kt
deleted file mode 100644
index ac25d72c55..0000000000
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/plugin/PluginController.kt
+++ /dev/null
@@ -1,58 +0,0 @@
-package net.corda.demobench.plugin
-
-import net.corda.core.internal.copyToDirectory
-import net.corda.core.internal.createDirectories
-import net.corda.core.internal.exists
-import net.corda.demobench.model.HasPlugins
-import net.corda.demobench.model.JVMConfig
-import net.corda.demobench.model.NodeConfigWrapper
-import tornadofx.*
-import java.io.IOException
-import java.nio.file.Files
-import java.nio.file.Path
-import java.nio.file.StandardCopyOption
-import java.util.stream.Stream
-
-class PluginController : Controller() {
-
-    private val jvm by inject<JVMConfig>()
-    private val pluginDir: Path = jvm.applicationDir.resolve("plugins")
-    private val bankOfCorda: Path = pluginDir.resolve("bank-of-corda.jar")
-    private val finance: Path = pluginDir.resolve("corda-finance.jar")
-
-    /**
-     * Install any built-in plugins that this node requires.
-     */
-    @Throws(IOException::class)
-    fun populate(config: NodeConfigWrapper) {
-        config.pluginDir.createDirectories()
-        if (finance.exists()) {
-            finance.copyToDirectory(config.pluginDir, StandardCopyOption.REPLACE_EXISTING)
-            log.info("Installed 'Finance' plugin")
-        }
-        // Nodes cannot issue cash unless they contain the "Bank of Corda" plugin.
-        if (config.nodeConfig.issuableCurrencies.isNotEmpty() && bankOfCorda.exists()) {
-            bankOfCorda.copyToDirectory(config.pluginDir, StandardCopyOption.REPLACE_EXISTING)
-            log.info("Installed 'Bank of Corda' plugin")
-        }
-    }
-
-    /**
-     * Generates a stream of a node's non-built-in plugins.
-     */
-    @Throws(IOException::class)
-    fun userPluginsFor(config: HasPlugins): Stream<Path> = walkPlugins(config.pluginDir)
-            .filter { !bankOfCorda.endsWith(it.fileName) }
-            .filter { !finance.endsWith(it.fileName) }
-
-    private fun walkPlugins(pluginDir: Path): Stream<Path> {
-        return if (Files.isDirectory(pluginDir))
-            Files.walk(pluginDir, 1).filter(Path::isPlugin)
-        else
-            Stream.empty()
-    }
-
-}
-
-fun Path.isPlugin(): Boolean = Files.isReadable(this) && this.fileName.toString().endsWith(".jar")
-fun Path.inPluginsDir(): Boolean = (this.parent != null) && this.parent.endsWith("plugins/")
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/profile/ProfileController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/profile/ProfileController.kt
index c963a1c9ae..9f8a380b38 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/profile/ProfileController.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/profile/ProfileController.kt
@@ -6,13 +6,10 @@ import javafx.stage.FileChooser
 import javafx.stage.FileChooser.ExtensionFilter
 import net.corda.core.internal.createDirectories
 import net.corda.core.internal.div
-import net.corda.demobench.model.InstallConfig
-import net.corda.demobench.model.InstallFactory
-import net.corda.demobench.model.JVMConfig
-import net.corda.demobench.model.NodeController
-import net.corda.demobench.plugin.PluginController
-import net.corda.demobench.plugin.inPluginsDir
-import net.corda.demobench.plugin.isPlugin
+import net.corda.demobench.model.*
+import net.corda.demobench.plugin.CordappController
+import net.corda.demobench.plugin.inCordappsDir
+import net.corda.demobench.plugin.isCordapp
 import tornadofx.*
 import java.io.File
 import java.io.IOException
@@ -31,7 +28,7 @@ class ProfileController : Controller() {
     private val jvm by inject<JVMConfig>()
     private val baseDir: Path = jvm.dataHome
     private val nodeController by inject<NodeController>()
-    private val pluginController by inject<PluginController>()
+    private val cordappController by inject<CordappController>()
     private val installFactory by inject<InstallFactory>()
     private val chooser = FileChooser()
 
@@ -64,11 +61,11 @@ class ProfileController : Controller() {
                     val file = Files.write(nodeDir / "node.conf", config.nodeConfig.toText().toByteArray(UTF_8))
                     log.info("Wrote: $file")
 
-                    // Write all of the non-built-in plugins.
-                    val pluginDir = Files.createDirectory(nodeDir.resolve("plugins"))
-                    pluginController.userPluginsFor(config).forEach {
-                        val plugin = Files.copy(it, pluginDir.resolve(it.fileName.toString()))
-                        log.info("Wrote: $plugin")
+                    // Write all of the non-built-in cordapps.
+                    val cordappDir = Files.createDirectory(nodeDir.resolve(NodeConfig.cordappDirName))
+                    cordappController.useCordappsFor(config).forEach {
+                        val cordapp = Files.copy(it, cordappDir.resolve(it.fileName.toString()))
+                        log.info("Wrote: $cordapp")
                     }
                 }
             }
@@ -120,16 +117,16 @@ class ProfileController : Controller() {
             // Now extract all of the plugins from the ZIP file,
             // and copy them to a temporary location.
             StreamSupport.stream(fs.rootDirectories.spliterator(), false)
-                    .flatMap { Files.find(it, 3, BiPredicate { p, attr -> p.inPluginsDir() && p.isPlugin() && attr.isRegularFile }) }
-                    .forEach { plugin ->
-                        val config = nodeIndex[plugin.getName(0).toString()] ?: return@forEach
+                    .flatMap { Files.find(it, 3, BiPredicate { p, attr -> p.inCordappsDir() && p.isCordapp() && attr.isRegularFile }) }
+                    .forEach { cordapp ->
+                        val config = nodeIndex[cordapp.getName(0).toString()] ?: return@forEach
 
                         try {
-                            val pluginDir = Files.createDirectories(config.pluginDir)
-                            Files.copy(plugin, pluginDir.resolve(plugin.fileName.toString()))
-                            log.info("Loaded: $plugin")
+                            val cordappDir = Files.createDirectories(config.cordappsDir)
+                            Files.copy(cordapp, cordappDir.resolve(cordapp.fileName.toString()))
+                            log.info("Loaded: $cordapp")
                         } catch (e: Exception) {
-                            log.log(Level.SEVERE, "Failed to extract '$plugin': ${e.message}", e)
+                            log.log(Level.SEVERE, "Failed to extract '$cordapp': ${e.message}", e)
                             configs.forEach { c -> c.deleteBaseDir() }
                             throw e
                         }
diff --git a/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeConfigTest.kt b/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeConfigTest.kt
index e8fb14dff4..0bf02c1ca8 100644
--- a/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeConfigTest.kt
+++ b/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeConfigTest.kt
@@ -5,6 +5,7 @@ import com.typesafe.config.ConfigValueFactory
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.node.internal.NetworkMapInfo
+import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.services.config.FullNodeConfiguration
 import net.corda.nodeapi.User
 import net.corda.nodeapi.config.parseAs
diff --git a/tools/explorer/src/main/java/ExplorerCaplet.java b/tools/explorer/src/main/java/ExplorerCaplet.java
index 7ab25d09b5..fdeb2821fb 100644
--- a/tools/explorer/src/main/java/ExplorerCaplet.java
+++ b/tools/explorer/src/main/java/ExplorerCaplet.java
@@ -19,7 +19,7 @@ public class ExplorerCaplet extends Capsule {
         // defined as public static final fields on the Capsule class, therefore referential equality is safe.
         if (ATTR_APP_CLASS_PATH == attr) {
             T cp = super.attribute(attr);
-            List<Path> classpath = augmentClasspath((List<Path>) cp, "plugins");
+            List<Path> classpath = augmentClasspath((List<Path>) cp, "cordapps");
             return (T) augmentClasspath(classpath, "dependencies");
         }
         return super.attribute(attr);

From be235673e1f6274093c47157803a9b01388fdf7a Mon Sep 17 00:00:00 2001
From: josecoll <jose.coll@r3cev.com>
Date: Fri, 13 Oct 2017 16:26:55 +0100
Subject: [PATCH 173/185] H2 coin selection uses Prepared Statement to protect
 against SQL injection (#1872)

* Updated H2 coin selection code to use Prepared Statement to protect against SQL Injection attacks.

* Clean-up deprecations and warnings.

* Revert correct indentation.

* Revert logging back to debug for SQL display.

* Fix broken tests.
---
 .../cash/selection/CashSelectionH2Impl.kt     | 64 +++++++++++--------
 .../finance/contracts/asset/CashTests.kt      | 51 ++++++++-------
 2 files changed, 62 insertions(+), 53 deletions(-)

diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
index 8be96121c8..82bc6ad763 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
@@ -61,20 +61,10 @@ class CashSelectionH2Impl : CashSelection {
                                                  lockId: UUID,
                                                  withIssuerRefs: Set<OpaqueBytes>): List<StateAndRef<Cash.State>> {
 
-        val issuerKeysStr = onlyFromIssuerParties.fold("") { left, right -> left + "('${right.owningKey.toBase58String()}')," }.dropLast(1)
-        val issuerRefsStr = withIssuerRefs.fold("") { left, right -> left + "('${right.bytes.toHexString()}')," }.dropLast(1)
-
         val stateAndRefs = mutableListOf<StateAndRef<Cash.State>>()
 
-        //       We are using an H2 specific means of selecting a minimum set of rows that match a request amount of coins:
-        //       1) There is no standard SQL mechanism of calculating a cumulative total on a field and restricting row selection on the
-        //          running total of such an accumulator
-        //       2) H2 uses session variables to perform this accumulator function:
-        //          http://www.h2database.com/html/functions.html#set
-        //       3) H2 does not support JOIN's in FOR UPDATE (hence we are forced to execute 2 queries)
-
         for (retryCount in 1..MAX_RETRIES) {
-            if (!attemptSpend(services, amount, lockId, notary, onlyFromIssuerParties, issuerKeysStr, withIssuerRefs, issuerRefsStr, stateAndRefs)) {
+            if (!attemptSpend(services, amount, lockId, notary, onlyFromIssuerParties, withIssuerRefs, stateAndRefs)) {
                 log.warn("Coin selection failed on attempt $retryCount")
                 // TODO: revisit the back off strategy for contended spending.
                 if (retryCount != MAX_RETRIES) {
@@ -91,32 +81,52 @@ class CashSelectionH2Impl : CashSelection {
         return stateAndRefs
     }
 
-    private fun attemptSpend(services: ServiceHub, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, issuerKeysStr: String, withIssuerRefs: Set<OpaqueBytes>, issuerRefsStr: String, stateAndRefs: MutableList<StateAndRef<Cash.State>>): Boolean {
+    //       We are using an H2 specific means of selecting a minimum set of rows that match a request amount of coins:
+    //       1) There is no standard SQL mechanism of calculating a cumulative total on a field and restricting row selection on the
+    //          running total of such an accumulator
+    //       2) H2 uses session variables to perform this accumulator function:
+    //          http://www.h2database.com/html/functions.html#set
+    //       3) H2 does not support JOIN's in FOR UPDATE (hence we are forced to execute 2 queries)
+
+    private fun attemptSpend(services: ServiceHub, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, stateAndRefs: MutableList<StateAndRef<Cash.State>>): Boolean {
+        val connection = services.jdbcSession()
         spendLock.withLock {
-            val statement = services.jdbcSession().createStatement()
+            val statement = connection.createStatement()
             try {
                 statement.execute("CALL SET(@t, CAST(0 AS BIGINT));")
 
-                // we select spendable states irrespective of lock but prioritised by unlocked ones (Eg. null)
-                // the softLockReserve update will detect whether we try to lock states locked by others
                 val selectJoin = """
-                        SELECT vs.transaction_id, vs.output_index, vs.contract_state, ccs.pennies, SET(@t, ifnull(@t,0)+ccs.pennies) total_pennies, vs.lock_id
-                        FROM vault_states AS vs, contract_cash_states AS ccs
-                        WHERE vs.transaction_id = ccs.transaction_id AND vs.output_index = ccs.output_index
-                        AND vs.state_status = 0
-                        AND ccs.ccy_code = '${amount.token}' and @t < ${amount.quantity}
-                        AND (vs.lock_id = '$lockId' OR vs.lock_id is null)
-                        """ +
+                    SELECT vs.transaction_id, vs.output_index, vs.contract_state, ccs.pennies, SET(@t, ifnull(@t,0)+ccs.pennies) total_pennies, vs.lock_id
+                    FROM vault_states AS vs, contract_cash_states AS ccs
+                    WHERE vs.transaction_id = ccs.transaction_id AND vs.output_index = ccs.output_index
+                    AND vs.state_status = 0
+                    AND ccs.ccy_code = ? and @t < ?
+                    AND (vs.lock_id = ? OR vs.lock_id is null)
+                    """ +
                         (if (notary != null)
-                            " AND vs.notary_name = '${notary.name}'" else "") +
+                            " AND vs.notary_name = ?" else "") +
                         (if (onlyFromIssuerParties.isNotEmpty())
-                            " AND ccs.issuer_key IN ($issuerKeysStr)" else "") +
+                            " AND ccs.issuer_key IN (?)" else "") +
                         (if (withIssuerRefs.isNotEmpty())
-                            " AND ccs.issuer_ref IN ($issuerRefsStr)" else "")
+                            " AND ccs.issuer_ref IN (?)" else "")
+
+                // Use prepared statement for protection against SQL Injection (http://www.h2database.com/html/advanced.html#sql_injection)
+                val psSelectJoin = connection.prepareStatement(selectJoin)
+                var pIndex = 0
+                psSelectJoin.setString(++pIndex, amount.token.currencyCode)
+                psSelectJoin.setLong(++pIndex, amount.quantity)
+                psSelectJoin.setString(++pIndex, lockId.toString())
+                if (notary != null)
+                    psSelectJoin.setString(++pIndex, notary.name.toString())
+                if (onlyFromIssuerParties.isNotEmpty())
+                    psSelectJoin.setObject(++pIndex, onlyFromIssuerParties.map { it.owningKey.toBase58String() as Any}.toTypedArray() )
+                if (withIssuerRefs.isNotEmpty())
+                    psSelectJoin.setObject(++pIndex, withIssuerRefs.map { it.bytes.toHexString() as Any }.toTypedArray())
+                log.debug { psSelectJoin.toString() }
 
                 // Retrieve spendable state refs
-                val rs = statement.executeQuery(selectJoin)
-                log.debug(selectJoin)
+                val rs = psSelectJoin.executeQuery()
+                stateAndRefs.clear()
                 var totalPennies = 0L
                 while (rs.next()) {
                     val txHash = SecureHash.parse(rs.getString(1))
diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
index 537f347bd6..df14ca6843 100644
--- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
+++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt
@@ -3,9 +3,7 @@ package net.corda.finance.contracts.asset
 import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.generateKeyPair
-import net.corda.core.identity.AbstractParty
-import net.corda.core.identity.AnonymousParty
-import net.corda.core.identity.Party
+import net.corda.core.identity.*
 import net.corda.core.node.ServiceHub
 import net.corda.core.node.services.VaultService
 import net.corda.core.node.services.queryBy
@@ -32,25 +30,25 @@ import java.util.*
 import kotlin.test.*
 
 class CashTests : TestDependencyInjectionBase() {
-    val defaultRef = OpaqueBytes(ByteArray(1, { 1 }))
-    val defaultIssuer = MEGA_CORP.ref(defaultRef)
-    val inState = Cash.State(
+    private val defaultRef = OpaqueBytes(ByteArray(1, { 1 }))
+    private val defaultIssuer = MEGA_CORP.ref(defaultRef)
+    private val inState = Cash.State(
             amount = 1000.DOLLARS `issued by` defaultIssuer,
             owner = AnonymousParty(ALICE_PUBKEY)
     )
     // Input state held by the issuer
-    val issuerInState = inState.copy(owner = defaultIssuer.party)
-    val outState = issuerInState.copy(owner = AnonymousParty(BOB_PUBKEY))
+    private val issuerInState = inState.copy(owner = defaultIssuer.party)
+    private val outState = issuerInState.copy(owner = AnonymousParty(BOB_PUBKEY))
 
-    fun Cash.State.editDepositRef(ref: Byte) = copy(
+    private fun Cash.State.editDepositRef(ref: Byte) = copy(
             amount = Amount(amount.quantity, token = amount.token.copy(amount.token.issuer.copy(reference = OpaqueBytes.of(ref))))
     )
 
-    lateinit var miniCorpServices: MockServices
-    lateinit var megaCorpServices: MockServices
+    private lateinit var miniCorpServices: MockServices
+    private lateinit var megaCorpServices: MockServices
     val vault: VaultService get() = miniCorpServices.vaultService
     lateinit var database: CordaPersistence
-    lateinit var vaultStatesUnconsumed: List<StateAndRef<Cash.State>>
+    private lateinit var vaultStatesUnconsumed: List<StateAndRef<Cash.State>>
 
     @Before
     fun setUp() {
@@ -475,19 +473,20 @@ class CashTests : TestDependencyInjectionBase() {
     //
     // Spend tx generation
 
-    val OUR_KEY: KeyPair by lazy { generateKeyPair() }
-    val OUR_IDENTITY_1: AbstractParty get() = AnonymousParty(OUR_KEY.public)
+    private val OUR_KEY: KeyPair by lazy { generateKeyPair() }
+    private val OUR_IDENTITY_1: AbstractParty get() = AnonymousParty(OUR_KEY.public)
+    private val OUR_IDENTITY_AND_CERT = getTestPartyAndCertificate(CordaX500Name(organisation = "Me", locality = "London", country = "GB"), OUR_KEY.public)
 
-    val THEIR_IDENTITY_1 = AnonymousParty(MINI_CORP_PUBKEY)
-    val THEIR_IDENTITY_2 = AnonymousParty(CHARLIE_PUBKEY)
+    private val THEIR_IDENTITY_1 = AnonymousParty(MINI_CORP_PUBKEY)
+    private val THEIR_IDENTITY_2 = AnonymousParty(CHARLIE_PUBKEY)
 
-    fun makeCash(amount: Amount<Currency>, issuer: AbstractParty, depositRef: Byte = 1) =
+    private fun makeCash(amount: Amount<Currency>, issuer: AbstractParty, depositRef: Byte = 1) =
             StateAndRef(
-                    TransactionState<Cash.State>(Cash.State(amount `issued by` issuer.ref(depositRef), OUR_IDENTITY_1), Cash.PROGRAM_ID, DUMMY_NOTARY),
+                    TransactionState(Cash.State(amount `issued by` issuer.ref(depositRef), OUR_IDENTITY_1), Cash.PROGRAM_ID, DUMMY_NOTARY),
                     StateRef(SecureHash.randomSHA256(), Random().nextInt(32))
             )
 
-    val WALLET = listOf(
+    private val WALLET = listOf(
             makeCash(100.DOLLARS, MEGA_CORP),
             makeCash(400.DOLLARS, MEGA_CORP),
             makeCash(80.DOLLARS, MINI_CORP),
@@ -507,7 +506,7 @@ class CashTests : TestDependencyInjectionBase() {
     private fun makeSpend(amount: Amount<Currency>, dest: AbstractParty): WireTransaction {
         val tx = TransactionBuilder(DUMMY_NOTARY)
         database.transaction {
-            Cash.generateSpend(miniCorpServices, tx, amount, dest)
+            Cash.generateSpend(miniCorpServices, tx, amount, OUR_IDENTITY_AND_CERT, dest)
         }
         return tx.toWireTransaction(miniCorpServices)
     }
@@ -541,7 +540,7 @@ class CashTests : TestDependencyInjectionBase() {
         assertEquals(1, expectedInputs.size)
         val inputState = expectedInputs.single()
         val actualChange = wtx.outputs.single().data as Cash.State
-        val expectedChangeAmount = (inputState.state.data as Cash.State).amount.quantity - 50.DOLLARS.quantity
+        val expectedChangeAmount = inputState.state.data.amount.quantity - 50.DOLLARS.quantity
         val expectedChange = WALLET[0].state.data.copy(amount = WALLET[0].state.data.amount.copy(quantity = expectedChangeAmount), owner = actualChange.owner)
         assertEquals(expectedChange, wtx.getOutput(0))
     }
@@ -588,9 +587,9 @@ class CashTests : TestDependencyInjectionBase() {
     @Test
     fun generateExitWithEmptyVault() {
         initialiseTestSerialization()
-        assertFailsWith<InsufficientBalanceException> {
+        assertFailsWith<IllegalArgumentException> {
             val tx = TransactionBuilder(DUMMY_NOTARY)
-            Cash().generateExit(tx, Amount(100, Issued(CHARLIE.ref(1), GBP)), emptyList())
+            Cash().generateExit(tx, Amount(100, Issued(CHARLIE.ref(1), GBP)), emptyList(), OUR_IDENTITY_1)
         }
     }
 
@@ -615,7 +614,7 @@ class CashTests : TestDependencyInjectionBase() {
         database.transaction {
 
             val tx = TransactionBuilder(DUMMY_NOTARY)
-            Cash.generateSpend(miniCorpServices, tx, 80.DOLLARS, ALICE, setOf(MINI_CORP))
+            Cash.generateSpend(miniCorpServices, tx, 80.DOLLARS, OUR_IDENTITY_AND_CERT, ALICE, setOf(MINI_CORP))
 
             assertEquals(vaultStatesUnconsumed.elementAt(2).ref, tx.inputStates()[0])
         }
@@ -631,13 +630,13 @@ class CashTests : TestDependencyInjectionBase() {
         database.transaction {
             val vaultState = vaultStatesUnconsumed.elementAt(0)
             val changeAmount = 90.DOLLARS `issued by` defaultIssuer
-            val likelyChangeState = wtx.outputs.map(TransactionState<*>::data).filter { state ->
+            val likelyChangeState = wtx.outputs.map(TransactionState<*>::data).single { state ->
                 if (state is Cash.State) {
                     state.amount == changeAmount
                 } else {
                     false
                 }
-            }.single()
+            }
             val changeOwner = (likelyChangeState as Cash.State).owner
             assertEquals(1, miniCorpServices.keyManagementService.filterMyKeys(setOf(changeOwner.owningKey)).toList().size)
             assertEquals(vaultState.ref, wtx.inputs[0])

From 8549a77a7624bb4a35acc34b5ec39fdac293b311 Mon Sep 17 00:00:00 2001
From: Christian Sailer <sar@mailraum.de>
Date: Fri, 13 Oct 2017 16:31:44 +0100
Subject: [PATCH 174/185] Use system tmp dir instead of hardcoding unix path

---
 .../src/test/kotlin/com/r3/enclaves/txverify/EnclaveletTest.kt  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/verify-enclave/src/test/kotlin/com/r3/enclaves/txverify/EnclaveletTest.kt b/verify-enclave/src/test/kotlin/com/r3/enclaves/txverify/EnclaveletTest.kt
index 329eb22b8e..0aa04f5c29 100644
--- a/verify-enclave/src/test/kotlin/com/r3/enclaves/txverify/EnclaveletTest.kt
+++ b/verify-enclave/src/test/kotlin/com/r3/enclaves/txverify/EnclaveletTest.kt
@@ -44,7 +44,7 @@ class EnclaveletTest {
             val cashContract = MockContractAttachment(interpreter.services.cordappProvider.getContractAttachmentID(Cash.PROGRAM_ID)!!, Cash.PROGRAM_ID)
             val req = TransactionVerificationRequest(wtx3.serialize(), arrayOf(wtx1.serialize(), wtx2.serialize()), arrayOf(cashContract.serialize().bytes))
             val serialized = req.serialize()
-            Files.write(Paths.get("/tmp/req"), serialized.bytes)
+            Files.write(Paths.get(System.getProperty("java.io.tmpdir"), "req"), serialized.bytes)
             verifyInEnclave(serialized.bytes)
         }
     }

From 99b509cb689be3a961ca181c4035da6ef4851b81 Mon Sep 17 00:00:00 2001
From: Viktor Kolomeyko <viktor.kolomeyko@r3.com>
Date: Mon, 16 Oct 2017 09:16:40 +0100
Subject: [PATCH 175/185] Attempting to make VerifierTests more stable (#1883)

* Attempting to make VerifierTests more stable

Main point: Alice node will always be faster to locate Alice by name than NotaryNode. Especially given that it may take some time
for Alice node to get reflected on the Notary's NetworkMap.

Also additional logging which might be helpful during debug and IntelliJ changed project structure reflection.

* Introduce a way for nodes to reliably learn about each other existence in the NetworkMap

Plus minor refactoring of the Driver code.
---
 .idea/compiler.xml                            |  2 ++
 .../kotlin/net/corda/testing/driver/Driver.kt | 36 +++++++++++++------
 .../net/corda/verifier/VerifierTests.kt       | 12 ++++---
 3 files changed, 34 insertions(+), 16 deletions(-)

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index 5df761b918..0c996385a3 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -60,6 +60,8 @@
       <module name="jfx_integrationTest" target="1.8" />
       <module name="jfx_main" target="1.8" />
       <module name="jfx_test" target="1.8" />
+      <module name="kryo-hook_main" target="1.8" />
+      <module name="kryo-hook_test" target="1.8" />
       <module name="loadtest_main" target="1.8" />
       <module name="loadtest_test" target="1.8" />
       <module name="mock_main" target="1.8" />
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
index 0a8cf4ecbe..ed9ca09e6d 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt
@@ -67,6 +67,10 @@ import kotlin.concurrent.thread
 
 private val log: Logger = loggerFor<DriverDSL>()
 
+private val DEFAULT_POLL_INTERVAL = 500.millis
+
+private const val DEFAULT_WARN_COUNT = 120
+
 /**
  * This is the interface that's exposed to DSL users.
  */
@@ -102,13 +106,12 @@ interface DriverDSLExposedInterface : CordformContext {
                         validating: Boolean = true): CordaFuture<NodeHandle>
 
     /**
-     * Helper function for starting a [node] with custom parameters from Java.
+     * Helper function for starting a [Node] with custom parameters from Java.
      *
-     * @param defaultParameters The default parameters for the driver.
-     * @param dsl The dsl itself.
+     * @param parameters The default parameters for the driver.
      * @return The value returned in the [dsl] closure.
      */
-    fun <A> startNode(parameters: NodeParameters): CordaFuture<NodeHandle> {
+    fun startNode(parameters: NodeParameters): CordaFuture<NodeHandle> {
         return startNode(defaultParameters = parameters)
     }
 
@@ -165,16 +168,25 @@ interface DriverDSLExposedInterface : CordformContext {
      * @param check The function being polled.
      * @return A future that completes with the non-null value [check] has returned.
      */
-    fun <A> pollUntilNonNull(pollName: String, pollInterval: Duration = 500.millis, warnCount: Int = 120, check: () -> A?): CordaFuture<A>
+    fun <A> pollUntilNonNull(pollName: String, pollInterval: Duration = DEFAULT_POLL_INTERVAL, warnCount: Int = DEFAULT_WARN_COUNT, check: () -> A?): CordaFuture<A>
 
     /**
      * Polls the given function until it returns true.
      * @see pollUntilNonNull
      */
-    fun pollUntilTrue(pollName: String, pollInterval: Duration = 500.millis, warnCount: Int = 120, check: () -> Boolean): CordaFuture<Unit> {
+    fun pollUntilTrue(pollName: String, pollInterval: Duration = DEFAULT_POLL_INTERVAL, warnCount: Int = DEFAULT_WARN_COUNT, check: () -> Boolean): CordaFuture<Unit> {
         return pollUntilNonNull(pollName, pollInterval, warnCount) { if (check()) Unit else null }
     }
 
+    /**
+     * Polls until a given node knows about presence of another node via its own NetworkMap
+     */
+    fun NodeHandle.pollUntilKnowsAbout(another: NodeHandle, pollInterval: Duration = DEFAULT_POLL_INTERVAL, warnCount: Int = DEFAULT_WARN_COUNT): CordaFuture<Unit> {
+        return pollUntilTrue("${nodeInfo.legalIdentities} knows about ${another.nodeInfo.legalIdentities}", pollInterval, warnCount) {
+            another.nodeInfo in rpc.networkMapSnapshot()
+        }
+    }
+
     val shutdownManager: ShutdownManager
 }
 
@@ -345,7 +357,7 @@ fun <A> driver(
 /**
  * Helper function for starting a [driver] with custom parameters from Java.
  *
- * @param defaultParameters The default parameters for the driver.
+ * @param parameters The default parameters for the driver.
  * @param dsl The dsl itself.
  * @return The value returned in the [dsl] closure.
  */
@@ -706,7 +718,7 @@ class DriverDSL(
                         "webAddress" to webAddress.toString(),
                         "networkMapService" to networkMapServiceConfigLookup(name),
                         "useTestClock" to useTestClock,
-                        "rpcUsers" to if (rpcUsers.isEmpty()) defaultRpcUserList else rpcUsers.map { it.toMap() },
+                        "rpcUsers" to if (rpcUsers.isEmpty()) defaultRpcUserList else rpcUsers.map { it.toConfig().root().unwrapped() },
                         "verifierType" to verifierType.name
                 ) + customOverrides
         )
@@ -883,14 +895,16 @@ class DriverDSL(
                 }
                 establishRpc(nodeConfiguration, processDeathFuture).flatMap { rpc ->
                     // Call waitUntilNetworkReady in background in case RPC is failing over:
-                    val networkMapFuture = executorService.fork {
+                    val forked = executorService.fork {
                         rpc.waitUntilNetworkReady()
-                    }.flatMap { it }
+                    }
+                    val networkMapFuture = forked.flatMap { it }
                     firstOf(processDeathFuture, networkMapFuture) {
                         if (it == processDeathFuture) {
                             throw ListenProcessDeathException(nodeConfiguration.p2pAddress, process)
                         }
                         processDeathFuture.cancel(false)
+                        log.info("Node handle is ready. NodeInfo: ${rpc.nodeInfo()}, WebAddress: ${webAddress}")
                         NodeHandle.OutOfProcess(rpc.nodeInfo(), rpc, nodeConfiguration, webAddress, debugPort, process)
                     }
                 }
@@ -905,7 +919,7 @@ class DriverDSL(
     }
 
     companion object {
-        private val defaultRpcUserList = listOf(User("default", "default", setOf("ALL")).toMap())
+        private val defaultRpcUserList = listOf(User("default", "default", setOf("ALL")).toConfig().root().unwrapped())
 
         private val names = arrayOf(
                 ALICE.name,
diff --git a/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt b/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
index 7bdbecaf17..05bfc06673 100644
--- a/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
+++ b/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
@@ -6,20 +6,19 @@ import net.corda.core.messaging.startFlow
 import net.corda.core.transactions.LedgerTransaction
 import net.corda.core.transactions.WireTransaction
 import net.corda.core.utilities.OpaqueBytes
+import net.corda.core.utilities.getOrThrow
 import net.corda.finance.DOLLARS
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.services.config.VerifierType
 import net.corda.testing.ALICE
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.chooseIdentity
-import net.corda.node.services.transactions.ValidatingNotaryService
-import net.corda.nodeapi.internal.ServiceInfo
 import net.corda.testing.*
 import net.corda.testing.driver.NetworkMapStartStrategy
 import org.junit.Test
 import java.util.*
 import java.util.concurrent.atomic.AtomicInteger
+import kotlin.test.assertNotNull
 
 class VerifierTests {
     private fun generateTransactions(number: Int): List<LedgerTransaction> {
@@ -121,13 +120,16 @@ class VerifierTests {
             val notaryFuture = startNotaryNode(DUMMY_NOTARY.name, verifierType = VerifierType.OutOfProcess)
             val aliceNode = aliceFuture.get()
             val notaryNode = notaryFuture.get()
-            val alice = notaryNode.rpc.wellKnownPartyFromX500Name(ALICE_NAME)!!
+            val alice = aliceNode.rpc.wellKnownPartyFromX500Name(ALICE_NAME)!!
             val notary = notaryNode.rpc.notaryPartyFromX500Name(DUMMY_NOTARY_SERVICE_NAME)!!
             startVerifier(notaryNode)
+            notaryNode.pollUntilKnowsAbout(aliceNode).getOrThrow()
+            aliceNode.pollUntilKnowsAbout(notaryNode).getOrThrow()
             aliceNode.rpc.startFlow(::CashIssueFlow, 10.DOLLARS, OpaqueBytes.of(0), notary).returnValue.get()
             notaryNode.waitUntilNumberOfVerifiers(1)
             for (i in 1..10) {
-                aliceNode.rpc.startFlow(::CashPaymentFlow, 10.DOLLARS, alice).returnValue.get()
+                val cashFlowResult = aliceNode.rpc.startFlow(::CashPaymentFlow, 10.DOLLARS, alice).returnValue.get()
+                assertNotNull(cashFlowResult)
             }
         }
     }

From d3d87c2497d51386b0e7634b338157db6b5cb464 Mon Sep 17 00:00:00 2001
From: Alberto Arri <30873160+al-r3@users.noreply.github.com>
Date: Mon, 16 Oct 2017 09:42:13 +0100
Subject: [PATCH 176/185] [CORDA-442] DemoBench copies around the NodeInfos for
 running nodes. (#1796)

[CORDA-442] DemoBench copies around the NodeInfos for running nodes.
---
 tools/demobench/build.gradle                  |   2 +
 .../corda/demobench/model/NodeController.kt   |   7 +
 .../demobench/model/NodeInfoFilesCopier.kt    | 133 +++++++++++++++
 .../model/NodeInfoFilesCopierTest.kt          | 156 ++++++++++++++++++
 4 files changed, 298 insertions(+)
 create mode 100644 tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeInfoFilesCopier.kt
 create mode 100644 tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeInfoFilesCopierTest.kt

diff --git a/tools/demobench/build.gradle b/tools/demobench/build.gradle
index c3626bd72f..c0f21ad796 100644
--- a/tools/demobench/build.gradle
+++ b/tools/demobench/build.gradle
@@ -46,6 +46,8 @@ dependencies {
     // Controls FX: more java FX components http://fxexperience.com/controlsfx/
     compile "org.controlsfx:controlsfx:$controlsfx_version"
 
+    compile "net.corda.plugins:cordform-common:$gradle_plugins_version"
+
     compile project(':client:rpc')
     compile project(':finance')
 
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
index e13f23d3bb..ddd8010bb4 100644
--- a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeController.kt
@@ -28,6 +28,7 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
 
     private val jvm by inject<JVMConfig>()
     private val cordappController by inject<CordappController>()
+    private val nodeInfoFilesCopier by inject<NodeInfoFilesCopier>()
 
     private var baseDir: Path = baseDirFor(ManagementFactory.getRuntimeMXBean().startTime)
     private val cordaPath: Path = jvm.applicationDir.resolve("corda").resolve("corda.jar")
@@ -86,12 +87,16 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
             log.info("Network map provided by: ${nodeConfig.myLegalName}")
         }
 
+        nodeInfoFilesCopier.addConfig(wrapper)
+
         return wrapper
     }
 
     fun dispose(config: NodeConfigWrapper) {
         config.state = NodeState.DEAD
 
+        nodeInfoFilesCopier.removeConfig(config)
+
         if (config.nodeConfig.isNetworkMap) {
             log.warning("Network map service (Node '${config.nodeConfig.myLegalName}') has exited.")
         }
@@ -138,6 +143,7 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
         // Wipe out any knowledge of previous nodes.
         networkMapConfig = null
         nodes.clear()
+        nodeInfoFilesCopier.reset()
     }
 
     /**
@@ -147,6 +153,7 @@ class NodeController(check: atRuntime = ::checkExists) : Controller() {
         if (nodes.putIfAbsent(config.key, config) != null) {
             return false
         }
+        nodeInfoFilesCopier.addConfig(config)
 
         updatePort(config.nodeConfig)
 
diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeInfoFilesCopier.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeInfoFilesCopier.kt
new file mode 100644
index 0000000000..ed69e38b93
--- /dev/null
+++ b/tools/demobench/src/main/kotlin/net/corda/demobench/model/NodeInfoFilesCopier.kt
@@ -0,0 +1,133 @@
+package net.corda.demobench.model
+
+import net.corda.cordform.CordformNode
+import net.corda.core.internal.createDirectories
+import net.corda.core.internal.isRegularFile
+import net.corda.core.internal.list
+import rx.Observable
+import rx.Scheduler
+import rx.schedulers.Schedulers
+import tornadofx.*
+import java.io.IOException
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.StandardCopyOption.COPY_ATTRIBUTES
+import java.nio.file.StandardCopyOption.REPLACE_EXISTING
+import java.nio.file.attribute.BasicFileAttributes
+import java.nio.file.attribute.FileTime
+import java.util.concurrent.TimeUnit
+import java.util.logging.Level
+
+/**
+ * Utility class which copies nodeInfo files across a set of running nodes.
+ *
+ * This class will create paths that it needs to poll and to where it needs to copy files in case those
+ * don't exist yet.
+ */
+class NodeInfoFilesCopier(scheduler: Scheduler = Schedulers.io()): Controller() {
+
+    private val nodeDataMap = mutableMapOf<Path, NodeData>()
+
+    init {
+        Observable.interval(5, TimeUnit.SECONDS, scheduler)
+                .subscribe { poll() }
+    }
+
+    /**
+     * @param nodeConfig the configuration to be added.
+     * Add a [NodeConfig] for a node which is about to be started.
+     * Its nodeInfo file will be copied to other nodes' additional-node-infos directory, and conversely,
+     * other nodes' nodeInfo files will be copied to this node additional-node-infos directory.
+     */
+    @Synchronized
+    fun addConfig(nodeConfig: NodeConfigWrapper) {
+        val newNodeFile = NodeData(nodeConfig.nodeDir)
+        nodeDataMap[nodeConfig.nodeDir] = newNodeFile
+
+        for (previouslySeenFile in allPreviouslySeenFiles()) {
+            copy(previouslySeenFile, newNodeFile.destination.resolve(previouslySeenFile.fileName))
+        }
+        log.info("Now watching: ${nodeConfig.nodeDir}")
+    }
+
+    /**
+     * @param nodeConfig the configuration to be removed.
+     * Remove the configuration of a node which is about to be stopped or already stopped.
+     * No files written by that node will be copied to other nodes, nor files from other nodes will be copied to this
+     * one.
+     */
+    @Synchronized
+    fun removeConfig(nodeConfig: NodeConfigWrapper) {
+        nodeDataMap.remove(nodeConfig.nodeDir) ?: return
+        log.info("Stopped watching: ${nodeConfig.nodeDir}")
+    }
+
+    @Synchronized
+    fun reset() {
+        nodeDataMap.clear()
+    }
+
+    private fun allPreviouslySeenFiles() = nodeDataMap.values.map { it.previouslySeenFiles.keys }.flatten()
+
+    @Synchronized
+    private fun poll() {
+        for (nodeData in nodeDataMap.values) {
+            nodeData.nodeDir.list { paths ->
+                paths.filter { it.isRegularFile() }
+                        .filter { it.fileName.toString().startsWith("nodeInfo-") }
+                        .forEach { path -> processPath(nodeData, path) }
+            }
+        }
+    }
+
+    // Takes a path under nodeData config dir and decides whether the file represented by that path needs to
+    // be copied.
+    private fun processPath(nodeData: NodeData, path: Path) {
+        val newTimestamp = Files.readAttributes(path, BasicFileAttributes::class.java).lastModifiedTime()
+        val previousTimestamp = nodeData.previouslySeenFiles.put(path, newTimestamp) ?: FileTime.fromMillis(-1)
+        if (newTimestamp > previousTimestamp) {
+            for (destination in nodeDataMap.values.filter { it.nodeDir != nodeData.nodeDir }.map { it.destination }) {
+                val fullDestinationPath = destination.resolve(path.fileName)
+                copy(path, fullDestinationPath)
+            }
+        }
+    }
+
+    private fun copy(source: Path, destination: Path) {
+        val tempDestination = try {
+            Files.createTempFile(destination.parent, ".", null)
+        } catch (exception: IOException) {
+            log.log(Level.WARNING, "Couldn't create a temporary file to copy $source", exception)
+            throw exception
+        }
+        try {
+            // First copy the file to a temporary file within the appropriate directory.
+            Files.copy(source, tempDestination, COPY_ATTRIBUTES, REPLACE_EXISTING)
+        } catch (exception: IOException) {
+            log.log(Level.WARNING, "Couldn't copy $source to $tempDestination.", exception)
+            Files.delete(tempDestination)
+            throw exception
+        }
+        try {
+            // Then rename it to the desired name. This way the file 'appears' on the filesystem as an atomic operation.
+            Files.move(tempDestination, destination, REPLACE_EXISTING)
+        } catch (exception: IOException) {
+            log.log(Level.WARNING, "Couldn't move $tempDestination to $destination.", exception)
+            Files.delete(tempDestination)
+            throw exception
+        }
+    }
+
+    /**
+     * Convenience holder for all the paths and files relative to a single node.
+     */
+    private class NodeData(val nodeDir: Path) {
+        val destination: Path = nodeDir.resolve(CordformNode.NODE_INFO_DIRECTORY)
+        // Map from Path to its lastModifiedTime.
+        val previouslySeenFiles = mutableMapOf<Path, FileTime>()
+
+        init {
+            destination.createDirectories()
+        }
+    }
+}
diff --git a/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeInfoFilesCopierTest.kt b/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeInfoFilesCopierTest.kt
new file mode 100644
index 0000000000..557bd7095b
--- /dev/null
+++ b/tools/demobench/src/test/kotlin/net/corda/demobench/model/NodeInfoFilesCopierTest.kt
@@ -0,0 +1,156 @@
+package net.corda.demobench.model
+
+import net.corda.cordform.CordformNode
+import net.corda.core.identity.CordaX500Name
+import net.corda.core.utilities.NetworkHostAndPort
+import net.corda.testing.eventually
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import rx.schedulers.TestScheduler
+import java.nio.file.Files
+import java.nio.file.Path
+import java.time.Duration
+import java.util.concurrent.TimeUnit
+import kotlin.streams.toList
+import kotlin.test.assertEquals
+
+/**
+ * tests for [NodeInfoFilesCopier]
+ */
+class NodeInfoFilesCopierTest {
+
+    @Rule @JvmField var folder = TemporaryFolder()
+    private val rootPath get() = folder.root.toPath()
+    private val scheduler = TestScheduler()
+    companion object {
+        private const val ORGANIZATION = "Organization"
+        private const val NODE_1_PATH = "node1"
+        private const val NODE_2_PATH = "node2"
+
+        private val content = "blah".toByteArray(Charsets.UTF_8)
+        private val GOOD_NODE_INFO_NAME = "nodeInfo-test"
+        private val GOOD_NODE_INFO_NAME_2 = "nodeInfo-anotherNode"
+        private val BAD_NODE_INFO_NAME = "something"
+        private val legalName = CordaX500Name(organisation = ORGANIZATION, locality = "Nowhere", country = "GB")
+        private val hostAndPort = NetworkHostAndPort("localhost", 1)
+    }
+
+    private fun nodeDir(nodeBaseDir : String) = rootPath.resolve(nodeBaseDir).resolve(ORGANIZATION.toLowerCase())
+
+    private val node1Config by lazy { createConfig(NODE_1_PATH) }
+    private val node2Config by lazy { createConfig(NODE_2_PATH) }
+    private val node1RootPath by lazy { nodeDir(NODE_1_PATH) }
+    private val node2RootPath by lazy { nodeDir(NODE_2_PATH) }
+    private val node1AdditionalNodeInfoPath by lazy { node1RootPath.resolve(CordformNode.NODE_INFO_DIRECTORY) }
+    private val node2AdditionalNodeInfoPath by lazy { node2RootPath.resolve(CordformNode.NODE_INFO_DIRECTORY) }
+
+    lateinit var nodeInfoFilesCopier: NodeInfoFilesCopier
+
+    @Before
+    fun setUp() {
+        nodeInfoFilesCopier = NodeInfoFilesCopier(scheduler)
+    }
+
+    @Test
+    fun `files created before a node is started are copied to that node`() {
+        // Configure the first node.
+        nodeInfoFilesCopier.addConfig(node1Config)
+        // Ensure directories are created.
+        advanceTime()
+
+        // Create 2 files, a nodeInfo and another file in node1 folder.
+        Files.write(node1RootPath.resolve(GOOD_NODE_INFO_NAME), content)
+        Files.write(node1RootPath.resolve(BAD_NODE_INFO_NAME), content)
+
+        // Configure the second node.
+        nodeInfoFilesCopier.addConfig(node2Config)
+        advanceTime()
+
+        eventually<AssertionError, Unit>(Duration.ofMinutes(1)) {
+            // Check only one file is copied.
+            checkDirectoryContainsSingleFile(node2AdditionalNodeInfoPath, GOOD_NODE_INFO_NAME)
+        }
+    }
+
+    @Test
+    fun `polling of running nodes`() {
+        // Configure 2 nodes.
+        nodeInfoFilesCopier.addConfig(node1Config)
+        nodeInfoFilesCopier.addConfig(node2Config)
+        advanceTime()
+
+        // Create 2 files, one of which to be copied, in a node root path.
+        Files.write(node2RootPath.resolve(GOOD_NODE_INFO_NAME), content)
+        Files.write(node2RootPath.resolve(BAD_NODE_INFO_NAME), content)
+        advanceTime()
+
+        eventually<AssertionError, Unit>(Duration.ofMinutes(1)) {
+            // Check only one file is copied to the other node.
+            checkDirectoryContainsSingleFile(node1AdditionalNodeInfoPath, GOOD_NODE_INFO_NAME)
+        }
+    }
+
+    @Test
+    fun `remove nodes`() {
+        // Configure 2 nodes.
+        nodeInfoFilesCopier.addConfig(node1Config)
+        nodeInfoFilesCopier.addConfig(node2Config)
+        advanceTime()
+
+        // Create a file, in node 2 root path.
+        Files.write(node2RootPath.resolve(GOOD_NODE_INFO_NAME), content)
+        advanceTime()
+
+        // Remove node 2
+        nodeInfoFilesCopier.removeConfig(node2Config)
+
+        // Create another file in node 2 directory.
+        Files.write(node2RootPath.resolve(GOOD_NODE_INFO_NAME_2), content)
+        advanceTime()
+
+        eventually<AssertionError, Unit>(Duration.ofMinutes(1)) {
+            // Check only one file is copied to the other node.
+            checkDirectoryContainsSingleFile(node1AdditionalNodeInfoPath, GOOD_NODE_INFO_NAME)
+        }
+    }
+
+    @Test
+    fun `clear`() {
+        // Configure 2 nodes.
+        nodeInfoFilesCopier.addConfig(node1Config)
+        nodeInfoFilesCopier.addConfig(node2Config)
+        advanceTime()
+
+        nodeInfoFilesCopier.reset()
+
+        advanceTime()
+        Files.write(node2RootPath.resolve(GOOD_NODE_INFO_NAME_2), content)
+
+        // Give some time to the filesystem to report the change.
+        Thread.sleep(100)
+        assertEquals(0, Files.list(node1AdditionalNodeInfoPath).toList().size)
+    }
+
+    private fun advanceTime() {
+        scheduler.advanceTimeBy(1, TimeUnit.HOURS)
+    }
+
+    private fun checkDirectoryContainsSingleFile(path: Path, filename: String) {
+        assertEquals(1, Files.list(path).toList().size)
+        val onlyFileName = Files.list(path).toList().first().fileName.toString()
+        assertEquals(filename, onlyFileName)
+    }
+
+    private fun createConfig(relativePath: String) =
+            NodeConfigWrapper(rootPath.resolve(relativePath),
+                    NodeConfig(myLegalName = legalName,
+                            p2pAddress = hostAndPort,
+                            rpcAddress = hostAndPort,
+                            webAddress = hostAndPort,
+                            h2port = -1,
+                            notary = null,
+                            networkMapService = null,
+                            rpcUsers = listOf()))
+}
\ No newline at end of file

From 38cf4a489eb21edf3a1800cb3924b57f46f9e89a Mon Sep 17 00:00:00 2001
From: Andrzej Cichocki <andrzej.cichocki@r3.com>
Date: Mon, 16 Oct 2017 11:35:29 +0100
Subject: [PATCH 177/185] CORDA-676 Eager cordapp schemas (#1839)

* Retire customSchemas.
* Key cordapp-to-hash map by url as native equality too strict.
---
 .../client/rpc/CordaRPCJavaClientTest.java    |  3 +-
 .../corda/client/rpc/CordaRPCClientTest.kt    |  4 +-
 .../net/corda/core/internal/InternalUtils.kt  |  3 +
 .../corda/core/internal/InternalUtilsTest.kt  |  1 +
 .../net/corda/docs/CustomVaultQueryTest.kt    |  6 +-
 .../docs/FxTransactionBuildTutorialTest.kt    |  5 +-
 .../internal/AttachmentsClassLoaderTests.kt   |  3 +-
 .../node/services/AttachmentLoadingTests.kt   |  2 +-
 .../net/corda/node/internal/AbstractNode.kt   | 40 ++++-----
 .../kotlin/net/corda/node/internal/Node.kt    |  3 +-
 .../net/corda/node/internal/NodeStartup.kt    |  2 +-
 .../node/internal/cordapp/CordappLoader.kt    | 82 +++++++++++--------
 .../internal/cordapp/CordappProviderImpl.kt   | 26 ++----
 .../cordapp/CordappProviderInternal.kt        |  8 ++
 .../corda/node/services/api/SchemaService.kt  |  6 --
 .../node/services/api/ServiceHubInternal.kt   |  3 +-
 .../persistence/HibernateConfiguration.kt     | 22 ++---
 .../node/services/schema/HibernateObserver.kt |  2 +-
 .../node/services/schema/NodeSchemaService.kt | 20 ++---
 .../node/services/vault/NodeVaultService.kt   | 12 +--
 .../corda/node/utilities/CordaPersistence.kt  | 11 +--
 .../services/vault/VaultQueryJavaTests.java   |  6 +-
 .../net/corda/node/InteractiveShellTest.kt    |  2 +-
 .../cordapp/CordappProviderImplTests.kt       | 16 ++--
 .../events/NodeSchedulerServiceTest.kt        |  4 +-
 .../messaging/ArtemisMessagingTests.kt        |  2 +-
 .../persistence/DBCheckpointStorageTests.kt   |  2 +-
 .../persistence/DBTransactionStorageTests.kt  |  2 +-
 .../persistence/HibernateConfigurationTest.kt | 25 +++---
 .../persistence/NodeAttachmentStorageTest.kt  |  2 +-
 .../services/schema/HibernateObserverTests.kt |  4 +-
 .../services/schema/NodeSchemaServiceTest.kt  | 17 +++-
 .../DistributedImmutableMapTests.kt           |  2 +-
 .../PersistentUniquenessProviderTests.kt      |  2 +-
 .../services/vault/NodeVaultServiceTest.kt    |  4 +-
 .../node/services/vault/VaultQueryTests.kt    | 15 ++--
 .../node/services/vault/VaultWithCashTest.kt  |  4 +-
 .../corda/node/utilities/ObservablesTests.kt  |  2 +-
 .../corda/irs/api/NodeInterestRatesTest.kt    |  2 +-
 .../net/corda/netmap/simulation/Simulation.kt |  7 --
 .../net/corda/traderdemo/TraderDemoTest.kt    |  8 +-
 .../node/testing/MockServiceHubInternal.kt    |  9 +-
 .../net/corda/testing/node/MockServices.kt    | 22 +++--
 .../net/corda/testing/node/SimpleNode.kt      |  2 +-
 .../kotlin/net/corda/testing/LogHelper.kt     |  5 +-
 .../corda/testing/node/MockCordappProvider.kt |  3 +-
 46 files changed, 197 insertions(+), 236 deletions(-)
 create mode 100644 node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderInternal.kt

diff --git a/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java b/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
index 714b0d4316..4c0245462d 100644
--- a/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
+++ b/client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java
@@ -32,7 +32,7 @@ import static net.corda.testing.TestConstants.getALICE;
 
 public class CordaRPCJavaClientTest extends NodeBasedTest {
     public CordaRPCJavaClientTest() {
-        super(Collections.singletonList("net.corda.finance.contracts"));
+        super(Arrays.asList("net.corda.finance.contracts", CashSchemaV1.class.getPackage().getName()));
     }
 
     private List<String> perms = Arrays.asList(startFlowPermission(CashPaymentFlow.class), startFlowPermission(CashIssueFlow.class));
@@ -53,7 +53,6 @@ public class CordaRPCJavaClientTest extends NodeBasedTest {
     public void setUp() throws ExecutionException, InterruptedException {
         CordaFuture<StartedNode<Node>> nodeFuture = startNotaryNode(getALICE().getName(), singletonList(rpcUser), true);
         node = nodeFuture.get();
-        node.getInternals().registerCustomSchemas(Collections.singleton(CashSchemaV1.INSTANCE));
         client = new CordaRPCClient(requireNonNull(node.getInternals().getConfiguration().getRpcAddress()));
     }
 
diff --git a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
index be6f05715a..277769354c 100644
--- a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
+++ b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt
@@ -2,6 +2,7 @@ package net.corda.client.rpc
 
 import net.corda.core.crypto.random63BitValue
 import net.corda.core.flows.FlowInitiator
+import net.corda.core.internal.packageName
 import net.corda.core.messaging.FlowProgressHandle
 import net.corda.core.messaging.StateMachineUpdate
 import net.corda.core.messaging.startFlow
@@ -32,7 +33,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 
-class CordaRPCClientTest : NodeBasedTest(listOf("net.corda.finance.contracts")) {
+class CordaRPCClientTest : NodeBasedTest(listOf("net.corda.finance.contracts", CashSchemaV1::class.packageName)) {
     private val rpcUser = User("user1", "test", permissions = setOf(
             startFlowPermission<CashIssueFlow>(),
             startFlowPermission<CashPaymentFlow>()
@@ -48,7 +49,6 @@ class CordaRPCClientTest : NodeBasedTest(listOf("net.corda.finance.contracts"))
     @Before
     fun setUp() {
         node = startNotaryNode(ALICE.name, rpcUsers = listOf(rpcUser)).getOrThrow()
-        node.internals.registerCustomSchemas(setOf(CashSchemaV1))
         client = CordaRPCClient(node.internals.configuration.rpcAddress!!)
     }
 
diff --git a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
index 5f26ef2e48..2f101b869f 100644
--- a/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
+++ b/core/src/main/kotlin/net/corda/core/internal/InternalUtils.kt
@@ -300,3 +300,6 @@ fun TransactionBuilder.toWireTransaction(services: ServicesForResolution, serial
  * @suppress
  */
 fun TransactionBuilder.toLedgerTransaction(services: ServiceHub, serializationContext: SerializationContext) = toLedgerTransactionWithContext(services, serializationContext)
+
+/** Convenience method to get the package name of a class literal. */
+val KClass<*>.packageName get() = java.`package`.name
diff --git a/core/src/test/kotlin/net/corda/core/internal/InternalUtilsTest.kt b/core/src/test/kotlin/net/corda/core/internal/InternalUtilsTest.kt
index b2f31384db..0a2fb69f26 100644
--- a/core/src/test/kotlin/net/corda/core/internal/InternalUtilsTest.kt
+++ b/core/src/test/kotlin/net/corda/core/internal/InternalUtilsTest.kt
@@ -61,6 +61,7 @@ class InternalUtilsTest {
         assertArrayEquals(intArrayOf(1, 2, 3, 4), (1 until 5).stream().toArray())
         assertArrayEquals(intArrayOf(1, 3), (1..4 step 2).stream().toArray())
         assertArrayEquals(intArrayOf(1, 3), (1..3 step 2).stream().toArray())
+        @Suppress("EmptyRange") // It's supposed to be empty.
         assertArrayEquals(intArrayOf(), (1..0).stream().toArray())
         assertArrayEquals(intArrayOf(1, 0), (1 downTo 0).stream().toArray())
         assertArrayEquals(intArrayOf(3, 1), (3 downTo 0 step 2).stream().toArray())
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
index 847675db13..1ec43e7271 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt
@@ -2,6 +2,7 @@ package net.corda.docs
 
 import net.corda.core.contracts.Amount
 import net.corda.core.identity.Party
+import net.corda.core.internal.packageName
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.getOrThrow
 import net.corda.finance.*
@@ -26,15 +27,12 @@ class CustomVaultQueryTest {
 
     @Before
     fun setup() {
-        mockNet = MockNetwork(threadPerNode = true, cordappPackages = listOf("net.corda.finance.contracts.asset"))
+        mockNet = MockNetwork(threadPerNode = true, cordappPackages = listOf("net.corda.finance.contracts.asset", CashSchemaV1::class.packageName))
         mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         nodeA = mockNet.createPartyNode()
         nodeB = mockNet.createPartyNode()
-
         nodeA.internals.registerInitiatedFlow(TopupIssuerFlow.TopupIssuer::class.java)
         nodeA.internals.installCordaService(CustomVaultQuery.Service::class.java)
-        nodeA.internals.registerCustomSchemas(setOf(CashSchemaV1))
-        nodeB.internals.registerCustomSchemas(setOf(CashSchemaV1))
         notary = nodeA.services.getDefaultNotary()
     }
 
diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
index 97ddbc598c..7a5193c0b0 100644
--- a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
+++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt
@@ -1,6 +1,7 @@
 package net.corda.docs
 
 import net.corda.core.identity.Party
+import net.corda.core.internal.packageName
 import net.corda.core.toFuture
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.getOrThrow
@@ -24,12 +25,10 @@ class FxTransactionBuildTutorialTest {
 
     @Before
     fun setup() {
-        mockNet = MockNetwork(threadPerNode = true, cordappPackages = listOf("net.corda.finance.contracts.asset"))
+        mockNet = MockNetwork(threadPerNode = true, cordappPackages = listOf("net.corda.finance.contracts.asset", CashSchemaV1::class.packageName))
         mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
         nodeA = mockNet.createPartyNode()
         nodeB = mockNet.createPartyNode()
-        nodeA.internals.registerCustomSchemas(setOf(CashSchemaV1))
-        nodeB.internals.registerCustomSchemas(setOf(CashSchemaV1))
         nodeB.internals.registerInitiatedFlow(ForeignExchangeRemoteFlow::class.java)
         notary = nodeA.services.getDefaultNotary()
     }
diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
index bf4138379d..5fd6b46f21 100644
--- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
+++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt
@@ -55,8 +55,7 @@ class AttachmentsClassLoaderTests : TestDependencyInjectionBase() {
 
     class DummyServiceHub : MockServices() {
         override val cordappProvider: CordappProviderImpl
-                = CordappProviderImpl(CordappLoader.createDevMode(listOf(ISOLATED_CONTRACTS_JAR_PATH))).start(attachments)
-
+                = CordappProviderImpl(CordappLoader.createDevMode(listOf(ISOLATED_CONTRACTS_JAR_PATH)), attachments)
         private val cordapp get() = cordappProvider.cordapps.first()
         val attachmentId get() = cordappProvider.getCordappAttachmentId(cordapp)!!
         val appContext get() = cordappProvider.getAppContext(cordapp)
diff --git a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
index 3ea5527202..9d4abec634 100644
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@@ -37,7 +37,7 @@ import kotlin.test.assertFailsWith
 
 class AttachmentLoadingTests : TestDependencyInjectionBase() {
     private class Services : MockServices() {
-        private val provider = CordappProviderImpl(CordappLoader.createDevMode(listOf(isolatedJAR))).start(attachments)
+        private val provider = CordappProviderImpl(CordappLoader.createDevMode(listOf(isolatedJAR)), attachments)
         private val cordapp get() = provider.cordapps.first()
         val attachmentId get() = provider.getCordappAttachmentId(cordapp)!!
         val appContext get() = provider.getAppContext(cordapp)
diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
index 9a7e5cbbeb..16829873aa 100644
--- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
@@ -7,7 +7,6 @@ import net.corda.confidential.SwapIdentitiesFlow
 import net.corda.confidential.SwapIdentitiesHandler
 import net.corda.core.CordaException
 import net.corda.core.concurrent.CordaFuture
-import net.corda.core.cordapp.CordappProvider
 import net.corda.core.flows.*
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
@@ -26,7 +25,6 @@ import net.corda.core.node.ServiceHub
 import net.corda.core.node.StateLoader
 import net.corda.core.node.services.*
 import net.corda.core.node.services.NetworkMapCache.MapChange
-import net.corda.core.schemas.MappedSchema
 import net.corda.core.serialization.SerializationWhitelist
 import net.corda.core.serialization.SerializeAsToken
 import net.corda.core.serialization.SingletonSerializeAsToken
@@ -37,6 +35,7 @@ import net.corda.node.VersionInfo
 import net.corda.node.internal.classloading.requireAnnotation
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
+import net.corda.node.internal.cordapp.CordappProviderInternal
 import net.corda.node.services.ContractUpgradeHandler
 import net.corda.node.services.FinalityHandler
 import net.corda.node.services.NotaryChangeHandler
@@ -148,7 +147,6 @@ abstract class AbstractNode(config: NodeConfiguration,
     protected lateinit var network: MessagingService
     protected val runOnStop = ArrayList<() -> Any?>()
     protected lateinit var database: CordaPersistence
-    lateinit var cordappProvider: CordappProviderImpl
     protected val _nodeReadyFuture = openFuture<Unit>()
     /** Completes once the node has successfully registered with the network map service
      * or has loaded network map data from local database */
@@ -161,7 +159,7 @@ abstract class AbstractNode(config: NodeConfiguration,
     }
 
     open val serializationWhitelists: List<SerializationWhitelist> by lazy {
-        cordappProvider.cordapps.flatMap { it.serializationWhitelists }
+        cordappLoader.cordapps.flatMap { it.serializationWhitelists }
     }
 
     /** Set to non-null once [start] has been successfully called. */
@@ -185,11 +183,12 @@ abstract class AbstractNode(config: NodeConfiguration,
         validateKeystore()
     }
 
+    private fun makeSchemaService() = NodeSchemaService(cordappLoader)
     open fun generateNodeInfo() {
         check(started == null) { "Node has already been started" }
         initCertificate()
         log.info("Generating nodeInfo ...")
-        val schemaService = NodeSchemaService()
+        val schemaService = makeSchemaService()
         initialiseDatabasePersistence(schemaService) {
             makeServices(schemaService)
             saveOwnNodeInfo()
@@ -200,7 +199,7 @@ abstract class AbstractNode(config: NodeConfiguration,
         check(started == null) { "Node has already been started" }
         initCertificate()
         log.info("Node starting up ...")
-        val schemaService = NodeSchemaService()
+        val schemaService = makeSchemaService()
         // Do all of this in a database transaction so anything that might need a connection has one.
         val startedImpl = initialiseDatabasePersistence(schemaService) {
             val tokenizableServices = makeServices(schemaService)
@@ -231,8 +230,7 @@ abstract class AbstractNode(config: NodeConfiguration,
 
             installCordaServices()
             registerCordappFlows()
-            _services.rpcFlows += cordappProvider.cordapps.flatMap { it.rpcFlows }
-            registerCustomSchemas(cordappProvider.cordapps.flatMap { it.customSchemas }.toSet())
+            _services.rpcFlows += cordappLoader.cordapps.flatMap { it.rpcFlows }
             FlowLogicRefFactoryImpl.classloader = cordappLoader.appClassLoader
 
             runOnStop += network::stop
@@ -254,7 +252,7 @@ abstract class AbstractNode(config: NodeConfiguration,
     private class ServiceInstantiationException(cause: Throwable?) : CordaException("Service Instantiation Error", cause)
 
     private fun installCordaServices() {
-        val loadedServices = cordappProvider.cordapps.flatMap { it.services }
+        val loadedServices = cordappLoader.cordapps.flatMap { it.services }
         filterServicesToInstall(loadedServices).forEach {
             try {
                 installCordaService(it)
@@ -374,7 +372,7 @@ abstract class AbstractNode(config: NodeConfiguration,
     }
 
     private fun registerCordappFlows() {
-        cordappProvider.cordapps.flatMap { it.initiatedFlows }
+        cordappLoader.cordapps.flatMap { it.initiatedFlows }
                 .forEach {
                     try {
                         registerInitiatedFlowInternal(it, track = false)
@@ -471,11 +469,11 @@ abstract class AbstractNode(config: NodeConfiguration,
      */
     private fun makeServices(schemaService: SchemaService): MutableList<Any> {
         checkpointStorage = DBCheckpointStorage()
-        cordappProvider = CordappProviderImpl(cordappLoader)
         val transactionStorage = makeTransactionStorage()
-        _services = ServiceHubInternalImpl(schemaService, transactionStorage, StateLoaderImpl(transactionStorage))
-        attachments = NodeAttachmentService(services.monitoringService.metrics)
-        cordappProvider.start(attachments)
+        val metrics = MetricRegistry()
+        attachments = NodeAttachmentService(metrics)
+        val cordappProvider = CordappProviderImpl(cordappLoader, attachments)
+        _services = ServiceHubInternalImpl(schemaService, transactionStorage, StateLoaderImpl(transactionStorage), MonitoringService(metrics), cordappProvider)
         legalIdentity = obtainIdentity(notaryConfig = null)
         network = makeMessagingService(legalIdentity)
         info = makeInfo(legalIdentity)
@@ -541,7 +539,7 @@ abstract class AbstractNode(config: NodeConfiguration,
     protected open fun <T> initialiseDatabasePersistence(schemaService: SchemaService, insideTransaction: () -> T): T {
         val props = configuration.dataSourceProperties
         if (props.isNotEmpty()) {
-            this.database = configureDatabase(props, configuration.database, schemaService, { _services.identityService })
+            this.database = configureDatabase(props, configuration.database, { _services.identityService }, schemaService)
             // Now log the vendor string as this will also cause a connection to be tested eagerly.
             database.transaction {
                 log.info("Connected to ${database.dataSource.connection.metaData.databaseProductName} database.")
@@ -764,12 +762,13 @@ abstract class AbstractNode(config: NodeConfiguration,
     private inner class ServiceHubInternalImpl(
             override val schemaService: SchemaService,
             override val validatedTransactions: WritableTransactionStorage,
-            private val stateLoader: StateLoader
+            private val stateLoader: StateLoader,
+            override val monitoringService: MonitoringService,
+            override val cordappProvider: CordappProviderInternal
     ) : SingletonSerializeAsToken(), ServiceHubInternal, StateLoader by stateLoader {
         override val rpcFlows = ArrayList<Class<out FlowLogic<*>>>()
         override val stateMachineRecordedTransactionMapping = DBTransactionMappingStorage()
         override val auditService = DummyAuditService()
-        override val monitoringService = MonitoringService(MetricRegistry())
         override val transactionVerifierService by lazy { makeTransactionVerifierService() }
         override val networkMapCache by lazy { PersistentNetworkMapCache(this) }
         override val vaultService by lazy { NodeVaultService(platformClock, keyManagementService, stateLoader, this@AbstractNode.database.hibernateConfig) }
@@ -794,8 +793,6 @@ abstract class AbstractNode(config: NodeConfiguration,
         override val myInfo: NodeInfo get() = info
         override val database: CordaPersistence get() = this@AbstractNode.database
         override val configuration: NodeConfiguration get() = this@AbstractNode.configuration
-        override val cordappProvider: CordappProvider = this@AbstractNode.cordappProvider
-
         override fun <T : SerializeAsToken> cordaService(type: Class<T>): T {
             require(type.isAnnotationPresent(CordaService::class.java)) { "${type.name} is not a Corda service" }
             return cordappServices.getInstance(type) ?: throw IllegalArgumentException("Corda service ${type.name} does not exist")
@@ -817,9 +814,4 @@ abstract class AbstractNode(config: NodeConfiguration,
 
         override fun jdbcSession(): Connection = database.createSession()
     }
-
-    fun registerCustomSchemas(schemas: Set<MappedSchema>) {
-        database.hibernateConfig.schemaService.registerCustomSchemas(schemas)
-    }
-
 }
diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt
index 7257eea773..e76f226adc 100644
--- a/node/src/main/kotlin/net/corda/node/internal/Node.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt
@@ -62,7 +62,7 @@ import kotlin.system.exitProcess
  *
  * @param configuration This is typically loaded from a TypeSafe HOCON configuration file.
  */
-open class Node(override val configuration: FullNodeConfiguration,
+open class Node(configuration: FullNodeConfiguration,
                 versionInfo: VersionInfo,
                 val initialiseSerialization: Boolean = true,
                 cordappLoader: CordappLoader = makeCordappLoader(configuration)
@@ -99,6 +99,7 @@ open class Node(override val configuration: FullNodeConfiguration,
     }
 
     override val log: Logger get() = logger
+    override val configuration get() = super.configuration as FullNodeConfiguration // Necessary to avoid init order NPE.
     override val networkMapAddress: NetworkMapAddress? get() = configuration.networkMapService?.address?.let(::NetworkMapAddress)
     override fun makeTransactionVerifierService() = (network as NodeMessagingClient).verifierService
 
diff --git a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
index 67a06aa2e9..1776b64271 100644
--- a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt
@@ -95,7 +95,7 @@ open class NodeStartup(val args: Array<String>) {
             return
         }
         val startedNode = node.start()
-        Node.printBasicNodeInfo("Loaded CorDapps", startedNode.internals.cordappProvider.cordapps.joinToString { it.name })
+        Node.printBasicNodeInfo("Loaded CorDapps", startedNode.services.cordappProvider.cordapps.joinToString { it.name })
         startedNode.internals.nodeReadyFuture.thenMatch({
             val elapsed = (System.currentTimeMillis() - startTime) / 10 / 100.0
             val name = startedNode.info.legalIdentitiesAndCerts.first().name.organisation
diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
index c481bfcc36..5154c592b1 100644
--- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt
@@ -38,10 +38,10 @@ import kotlin.streams.toList
  *
  * @property cordappJarPaths The classpath of cordapp JARs
  */
-class CordappLoader private constructor(private val cordappJarPaths: List<URL>) {
+class CordappLoader private constructor(private val cordappJarPaths: List<RestrictedURL>) {
     val cordapps: List<Cordapp> by lazy { loadCordapps() + coreCordapp }
 
-    internal val appClassLoader: ClassLoader = URLClassLoader(cordappJarPaths.toTypedArray(), javaClass.classLoader)
+    internal val appClassLoader: ClassLoader = URLClassLoader(cordappJarPaths.stream().map { it.url }.toTypedArray(), javaClass.classLoader)
 
     init {
         if (cordappJarPaths.isEmpty()) {
@@ -97,20 +97,22 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
          * @param scanJars Uses the JAR URLs provided for classpath scanning and Cordapp detection
          */
         @VisibleForTesting
-        fun createDevMode(scanJars: List<URL>) = CordappLoader(scanJars)
+        fun createDevMode(scanJars: List<URL>) = CordappLoader(scanJars.map { RestrictedURL(it, null) })
 
         private fun getCordappsPath(baseDir: Path): Path = baseDir / CORDAPPS_DIR_NAME
 
-        private fun createScanPackage(scanPackage: String): List<URL> {
+        private fun createScanPackage(scanPackage: String): List<RestrictedURL> {
             val resource = scanPackage.replace('.', '/')
             return this::class.java.classLoader.getResources(resource)
                     .asSequence()
                     .map { path ->
                         if (path.protocol == "jar") {
-                            (path.openConnection() as JarURLConnection).jarFileURL.toURI()
+                            // When running tests from gradle this may be a corda module jar, so restrict to scanPackage:
+                            RestrictedURL((path.openConnection() as JarURLConnection).jarFileURL, scanPackage)
                         } else {
-                            createDevCordappJar(scanPackage, path, resource)
-                        }.toURL()
+                            // No need to restrict as createDevCordappJar has already done that:
+                            RestrictedURL(createDevCordappJar(scanPackage, path, resource).toURL(), null)
+                        }
                     }
                     .toList()
         }
@@ -143,12 +145,12 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
             return generatedCordapps[path]!!
         }
 
-        private fun getCordappsInDirectory(cordappsDir: Path): List<URL> {
+        private fun getCordappsInDirectory(cordappsDir: Path): List<RestrictedURL> {
             return if (!cordappsDir.exists()) {
-                emptyList<URL>()
+                emptyList()
             } else {
                 cordappsDir.list {
-                    it.filter { it.isRegularFile() && it.toString().endsWith(".jar") }.map { it.toUri().toURL() }.toList()
+                    it.filter { it.isRegularFile() && it.toString().endsWith(".jar") }.map { RestrictedURL(it.toUri().toURL(), null) }.toList()
                 }
             }
         }
@@ -187,15 +189,15 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
                     findServices(scanResult),
                     findPlugins(it),
                     findCustomSchemas(scanResult),
-                    it)
+                    it.url)
         }
     }
 
-    private fun findServices(scanResult: ScanResult): List<Class<out SerializeAsToken>> {
+    private fun findServices(scanResult: RestrictedScanResult): List<Class<out SerializeAsToken>> {
         return scanResult.getClassesWithAnnotation(SerializeAsToken::class, CordaService::class)
     }
 
-    private fun findInitiatedFlows(scanResult: ScanResult): List<Class<out FlowLogic<*>>> {
+    private fun findInitiatedFlows(scanResult: RestrictedScanResult): List<Class<out FlowLogic<*>>> {
         return scanResult.getClassesWithAnnotation(FlowLogic::class, InitiatedBy::class)
                 // First group by the initiating flow class in case there are multiple mappings
                 .groupBy { it.requireAnnotation<InitiatedBy>().value.java }
@@ -214,35 +216,35 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
         return Modifier.isPublic(modifiers) && !isLocalClass && !isAnonymousClass && (!isMemberClass || Modifier.isStatic(modifiers))
     }
 
-    private fun findRPCFlows(scanResult: ScanResult): List<Class<out FlowLogic<*>>> {
+    private fun findRPCFlows(scanResult: RestrictedScanResult): List<Class<out FlowLogic<*>>> {
         return scanResult.getClassesWithAnnotation(FlowLogic::class, StartableByRPC::class).filter { it.isUserInvokable() }
     }
 
-    private fun findServiceFlows(scanResult: ScanResult): List<Class<out FlowLogic<*>>> {
+    private fun findServiceFlows(scanResult: RestrictedScanResult): List<Class<out FlowLogic<*>>> {
         return scanResult.getClassesWithAnnotation(FlowLogic::class, StartableByService::class)
     }
 
-    private fun findSchedulableFlows(scanResult: ScanResult): List<Class<out FlowLogic<*>>> {
+    private fun findSchedulableFlows(scanResult: RestrictedScanResult): List<Class<out FlowLogic<*>>> {
         return scanResult.getClassesWithAnnotation(FlowLogic::class, SchedulableFlow::class)
     }
 
-    private fun findContractClassNames(scanResult: ScanResult): List<String> {
-        return (scanResult.getNamesOfClassesImplementing(Contract::class.java) + scanResult.getNamesOfClassesImplementing(UpgradedContract::class.java)).distinct()
+    private fun findContractClassNames(scanResult: RestrictedScanResult): List<String> {
+        return (scanResult.getNamesOfClassesImplementing(Contract::class) + scanResult.getNamesOfClassesImplementing(UpgradedContract::class)).distinct()
     }
 
-    private fun findPlugins(cordappJarPath: URL): List<SerializationWhitelist> {
-        return ServiceLoader.load(SerializationWhitelist::class.java, URLClassLoader(arrayOf(cordappJarPath), appClassLoader)).toList().filter {
-            cordappJarPath == it.javaClass.protectionDomain.codeSource.location
+    private fun findPlugins(cordappJarPath: RestrictedURL): List<SerializationWhitelist> {
+        return ServiceLoader.load(SerializationWhitelist::class.java, URLClassLoader(arrayOf(cordappJarPath.url), appClassLoader)).toList().filter {
+            it.javaClass.protectionDomain.codeSource.location == cordappJarPath.url && it.javaClass.name.startsWith(cordappJarPath.qualifiedNamePrefix)
         } + DefaultWhitelist // Always add the DefaultWhitelist to the whitelist for an app.
     }
 
-    private fun findCustomSchemas(scanResult: ScanResult): Set<MappedSchema> {
+    private fun findCustomSchemas(scanResult: RestrictedScanResult): Set<MappedSchema> {
         return scanResult.getClassesWithSuperclass(MappedSchema::class).toSet()
     }
 
-    private fun scanCordapp(cordappJarPath: URL): ScanResult {
+    private fun scanCordapp(cordappJarPath: RestrictedURL): RestrictedScanResult {
         logger.info("Scanning CorDapp in $cordappJarPath")
-        return FastClasspathScanner().addClassLoader(appClassLoader).overrideClasspath(cordappJarPath).scan()
+        return RestrictedScanResult(FastClasspathScanner().addClassLoader(appClassLoader).overrideClasspath(cordappJarPath.url).scan(), cordappJarPath.qualifiedNamePrefix)
     }
 
     private class FlowTypeHierarchyComparator(val initiatingFlow: Class<out FlowLogic<*>>) : Comparator<Class<out FlowLogic<*>>> {
@@ -269,16 +271,30 @@ class CordappLoader private constructor(private val cordappJarPaths: List<URL>)
         }
     }
 
-    private fun <T : Any> ScanResult.getClassesWithSuperclass(type: KClass<T>): List<T> {
-        return getNamesOfSubclassesOf(type.java)
-                .mapNotNull { loadClass(it, type) }
-                .filterNot { Modifier.isAbstract(it.modifiers) }
-                .map { it.kotlin.objectOrNewInstance() }
+    /** @param rootPackageName only this package and subpackages may be extracted from [url], or null to allow all packages. */
+    private class RestrictedURL(val url: URL, rootPackageName: String?) {
+        val qualifiedNamePrefix = rootPackageName?.let { it + '.' } ?: ""
     }
 
-    private fun <T : Any> ScanResult.getClassesWithAnnotation(type: KClass<T>, annotation: KClass<out Annotation>): List<Class<out T>> {
-        return getNamesOfClassesWithAnnotation(annotation.java)
-                .mapNotNull { loadClass(it, type) }
-                .filterNot { Modifier.isAbstract(it.modifiers) }
+    private inner class RestrictedScanResult(private val scanResult: ScanResult, private val qualifiedNamePrefix: String) {
+        fun getNamesOfClassesImplementing(type: KClass<*>): List<String> {
+            return scanResult.getNamesOfClassesImplementing(type.java)
+                    .filter { it.startsWith(qualifiedNamePrefix) }
+        }
+
+        fun <T : Any> getClassesWithSuperclass(type: KClass<T>): List<T> {
+            return scanResult.getNamesOfSubclassesOf(type.java)
+                    .filter { it.startsWith(qualifiedNamePrefix) }
+                    .mapNotNull { loadClass(it, type) }
+                    .filterNot { Modifier.isAbstract(it.modifiers) }
+                    .map { it.kotlin.objectOrNewInstance() }
+        }
+
+        fun <T : Any> getClassesWithAnnotation(type: KClass<T>, annotation: KClass<out Annotation>): List<Class<out T>> {
+            return scanResult.getNamesOfClassesWithAnnotation(annotation.java)
+                    .filter { it.startsWith(qualifiedNamePrefix) }
+                    .mapNotNull { loadClass(it, type) }
+                    .filterNot { Modifier.isAbstract(it.modifiers) }
+        }
     }
 }
diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt
index 967c332fd3..ba305283f2 100644
--- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt
@@ -6,15 +6,14 @@ import net.corda.core.crypto.SecureHash
 import net.corda.core.node.services.AttachmentStorage
 import net.corda.core.cordapp.Cordapp
 import net.corda.core.cordapp.CordappContext
-import net.corda.core.cordapp.CordappProvider
 import net.corda.core.node.services.AttachmentId
 import net.corda.core.serialization.SingletonSerializeAsToken
-import java.net.URLClassLoader
+import java.net.URL
 
 /**
  * Cordapp provider and store. For querying CorDapps for their attachment and vice versa.
  */
-open class CordappProviderImpl(private val cordappLoader: CordappLoader) : SingletonSerializeAsToken(), CordappProvider {
+open class CordappProviderImpl(private val cordappLoader: CordappLoader, attachmentStorage: AttachmentStorage) : SingletonSerializeAsToken(), CordappProviderInternal {
     override fun getAppContext(): CordappContext {
         // TODO: Use better supported APIs in Java 9
         Exception().stackTrace.forEach { stackFrame ->
@@ -34,28 +33,19 @@ open class CordappProviderImpl(private val cordappLoader: CordappLoader) : Singl
     /**
      * Current known CorDapps loaded on this node
      */
-    val cordapps get() = cordappLoader.cordapps
-    private lateinit var cordappAttachments: HashBiMap<SecureHash, Cordapp>
-
-    /**
-     * Should only be called once from the initialisation routine of the node or tests
-     */
-    fun start(attachmentStorage: AttachmentStorage): CordappProviderImpl {
-        cordappAttachments = HashBiMap.create(loadContractsIntoAttachmentStore(attachmentStorage))
-        return this
-    }
-
+    override val cordapps get() = cordappLoader.cordapps
+    private val cordappAttachments = HashBiMap.create(loadContractsIntoAttachmentStore(attachmentStorage))
     /**
      * Gets the attachment ID of this CorDapp. Only CorDapps with contracts have an attachment ID
      *
      * @param cordapp The cordapp to get the attachment ID
      * @return An attachment ID if it exists, otherwise nothing
      */
-    fun getCordappAttachmentId(cordapp: Cordapp): SecureHash? = cordappAttachments.inverse().get(cordapp)
+    fun getCordappAttachmentId(cordapp: Cordapp): SecureHash? = cordappAttachments.inverse().get(cordapp.jarPath)
 
-    private fun loadContractsIntoAttachmentStore(attachmentStorage: AttachmentStorage): Map<SecureHash, Cordapp> {
-        val cordappsWithAttachments = cordapps.filter { !it.contractClassNames.isEmpty() }
-        val attachmentIds = cordappsWithAttachments.map { it.jarPath.openStream().use { attachmentStorage.importAttachment(it) } }
+    private fun loadContractsIntoAttachmentStore(attachmentStorage: AttachmentStorage): Map<SecureHash, URL> {
+        val cordappsWithAttachments = cordapps.filter { !it.contractClassNames.isEmpty() }.map { it.jarPath }
+        val attachmentIds = cordappsWithAttachments.map { it.openStream().use { attachmentStorage.importAttachment(it) } }
         return attachmentIds.zip(cordappsWithAttachments).toMap()
     }
 
diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderInternal.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderInternal.kt
new file mode 100644
index 0000000000..a29d8bab25
--- /dev/null
+++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderInternal.kt
@@ -0,0 +1,8 @@
+package net.corda.node.internal.cordapp
+
+import net.corda.core.cordapp.Cordapp
+import net.corda.core.cordapp.CordappProvider
+
+interface CordappProviderInternal : CordappProvider {
+    val cordapps: List<Cordapp>
+}
diff --git a/node/src/main/kotlin/net/corda/node/services/api/SchemaService.kt b/node/src/main/kotlin/net/corda/node/services/api/SchemaService.kt
index 7428a2e90a..4a4d815708 100644
--- a/node/src/main/kotlin/net/corda/node/services/api/SchemaService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/api/SchemaService.kt
@@ -30,11 +30,5 @@ interface SchemaService {
      * or via custom logic in this service.
      */
     fun generateMappedObject(state: ContractState, schema: MappedSchema): PersistentState
-
-    /**
-     * Registration mechanism to add custom contract schemas that extend the [MappedSchema] class.
-     */
-    fun registerCustomSchemas(customSchemas: Set<MappedSchema>)
-
 }
 //DOCEND SchemaService
diff --git a/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt b/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
index 65bd38d843..5fdb7993a0 100644
--- a/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
+++ b/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt
@@ -21,6 +21,7 @@ import net.corda.core.serialization.CordaSerializable
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.utilities.loggerFor
 import net.corda.node.internal.InitiatedFlowFactory
+import net.corda.node.internal.cordapp.CordappProviderInternal
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.messaging.MessagingService
 import net.corda.node.services.statemachine.FlowLogicRefFactoryImpl
@@ -89,7 +90,7 @@ interface ServiceHubInternal : ServiceHub {
     val networkService: MessagingService
     val database: CordaPersistence
     val configuration: NodeConfiguration
-
+    override val cordappProvider: CordappProviderInternal
     override fun recordTransactions(notifyVault: Boolean, txs: Iterable<SignedTransaction>) {
         require(txs.any()) { "No transactions passed in for recording" }
         val recordedTransactions = txs.filter { validatedTransactions.addTransaction(it) }
diff --git a/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt
index bf6efb6c8c..8fb0023b3d 100644
--- a/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt
+++ b/node/src/main/kotlin/net/corda/node/services/persistence/HibernateConfiguration.kt
@@ -33,25 +33,13 @@ class HibernateConfiguration(val schemaService: SchemaService, private val datab
     private val sessionFactories = ConcurrentHashMap<Set<MappedSchema>, SessionFactory>()
 
     private val transactionIsolationLevel = parserTransactionIsolationLevel(databaseProperties.getProperty("transactionIsolationLevel") ?: "")
-
-    init {
-        logger.info("Init HibernateConfiguration for schemas: ${schemaService.schemaOptions.keys}")
-        sessionFactoryForRegisteredSchemas()
+    val sessionFactoryForRegisteredSchemas = schemaService.schemaOptions.keys.let {
+        logger.info("Init HibernateConfiguration for schemas: $it")
+        sessionFactoryForSchemas(it)
     }
 
-    fun sessionFactoryForRegisteredSchemas(): SessionFactory {
-        return sessionFactoryForSchemas(*schemaService.schemaOptions.keys.toTypedArray())
-    }
-
-    fun sessionFactoryForSchema(schema: MappedSchema): SessionFactory {
-        return sessionFactoryForSchemas(schema)
-    }
-
-    //vararg to set conversions left to preserve method signature for now
-    fun sessionFactoryForSchemas(vararg schemas: MappedSchema): SessionFactory {
-        val schemaSet: Set<MappedSchema> = schemas.toSet()
-        return sessionFactories.computeIfAbsent(schemaSet, { makeSessionFactoryForSchemas(schemaSet) })
-    }
+    /** @param key must be immutable, not just read-only. */
+    fun sessionFactoryForSchemas(key: Set<MappedSchema>) = sessionFactories.computeIfAbsent(key, { makeSessionFactoryForSchemas(key) })
 
     private fun makeSessionFactoryForSchemas(schemas: Set<MappedSchema>): SessionFactory {
         logger.info("Creating session factory for schemas: $schemas")
diff --git a/node/src/main/kotlin/net/corda/node/services/schema/HibernateObserver.kt b/node/src/main/kotlin/net/corda/node/services/schema/HibernateObserver.kt
index 9afc740949..45a3334ef1 100644
--- a/node/src/main/kotlin/net/corda/node/services/schema/HibernateObserver.kt
+++ b/node/src/main/kotlin/net/corda/node/services/schema/HibernateObserver.kt
@@ -38,7 +38,7 @@ class HibernateObserver(vaultUpdates: Observable<Vault.Update<ContractState>>, v
     }
 
     fun persistStateWithSchema(state: ContractState, stateRef: StateRef, schema: MappedSchema) {
-        val sessionFactory = config.sessionFactoryForSchema(schema)
+        val sessionFactory = config.sessionFactoryForSchemas(setOf(schema))
         val session = sessionFactory.withOptions().
                 connection(DatabaseTransactionManager.current().connection).
                 flushMode(FlushMode.MANUAL).
diff --git a/node/src/main/kotlin/net/corda/node/services/schema/NodeSchemaService.kt b/node/src/main/kotlin/net/corda/node/services/schema/NodeSchemaService.kt
index 0599616644..8436f9459b 100644
--- a/node/src/main/kotlin/net/corda/node/services/schema/NodeSchemaService.kt
+++ b/node/src/main/kotlin/net/corda/node/services/schema/NodeSchemaService.kt
@@ -9,6 +9,7 @@ import net.corda.core.schemas.NodeInfoSchemaV1
 import net.corda.core.schemas.PersistentState
 import net.corda.core.schemas.QueryableState
 import net.corda.core.serialization.SingletonSerializeAsToken
+import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.services.api.SchemaService
 import net.corda.node.services.events.NodeSchedulerService
 import net.corda.node.services.identity.PersistentIdentityService
@@ -27,13 +28,13 @@ import net.corda.node.services.vault.VaultSchemaV1
 
 /**
  * Most basic implementation of [SchemaService].
- *
+ * @param cordappLoader if not null, custom schemas will be extracted from its cordapps.
  * TODO: support loading schema options from node configuration.
  * TODO: support configuring what schemas are to be selected for persistence.
  * TODO: support plugins for schema version upgrading or custom mapping not supported by original [QueryableState].
  * TODO: create whitelisted tables when a CorDapp is first installed
  */
-class NodeSchemaService(customSchemas: Set<MappedSchema> = emptySet()) : SchemaService, SingletonSerializeAsToken() {
+class NodeSchemaService(cordappLoader: CordappLoader?) : SchemaService, SingletonSerializeAsToken() {
 
     // Entities for compulsory services
     object NodeServices
@@ -67,9 +68,12 @@ class NodeSchemaService(customSchemas: Set<MappedSchema> = emptySet()) : SchemaS
                     Pair(NodeInfoSchemaV1, SchemaService.SchemaOptions()),
                     Pair(NodeServicesV1, SchemaService.SchemaOptions()))
 
-    override var schemaOptions: Map<MappedSchema, SchemaService.SchemaOptions> = requiredSchemas.plus(customSchemas.map { mappedSchema ->
-        Pair(mappedSchema, SchemaService.SchemaOptions())
-    })
+    override val schemaOptions: Map<MappedSchema, SchemaService.SchemaOptions> = if (cordappLoader == null) {
+        requiredSchemas
+    } else {
+        val customSchemas = cordappLoader.cordapps.flatMap { it.customSchemas }.toSet()
+        requiredSchemas.plus(customSchemas.map { mappedSchema -> Pair(mappedSchema, SchemaService.SchemaOptions()) })
+    }
 
     // Currently returns all schemas supported by the state, with no filtering or enrichment.
     override fun selectSchemas(state: ContractState): Iterable<MappedSchema> {
@@ -92,10 +96,4 @@ class NodeSchemaService(customSchemas: Set<MappedSchema> = emptySet()) : SchemaS
             return VaultSchemaV1.VaultFungibleStates(state.owner, state.amount.quantity, state.amount.token.issuer.party, state.amount.token.issuer.reference, state.participants)
         return (state as QueryableState).generateMappedObject(schema)
     }
-
-    override fun registerCustomSchemas(_customSchemas: Set<MappedSchema>) {
-        schemaOptions = schemaOptions.plus(_customSchemas.map { mappedSchema ->
-            Pair(mappedSchema, SchemaService.SchemaOptions())
-        })
-    }
 }
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 864da2bd50..d5a189b0ee 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
@@ -59,7 +59,7 @@ private fun CriteriaBuilder.executeUpdate(session: Session, configure: Root<*>.(
  * TODO: keep an audit trail with time stamps of previously unconsumed states "as of" a particular point in time.
  * TODO: have transaction storage do some caching.
  */
-class NodeVaultService(private val clock: Clock, private val keyManagementService: KeyManagementService, private val stateLoader: StateLoader, private val hibernateConfig: HibernateConfiguration) : SingletonSerializeAsToken(), VaultServiceInternal {
+class NodeVaultService(private val clock: Clock, private val keyManagementService: KeyManagementService, private val stateLoader: StateLoader, hibernateConfig: HibernateConfiguration) : SingletonSerializeAsToken(), VaultServiceInternal {
 
     private companion object {
         val log = loggerFor<NodeVaultService>()
@@ -377,9 +377,8 @@ class NodeVaultService(private val clock: Clock, private val keyManagementServic
         return keysToCheck.any { it in myKeys }
     }
 
-    private var sessionFactory = hibernateConfig.sessionFactoryForRegisteredSchemas()
-    private var criteriaBuilder = sessionFactory.criteriaBuilder
-
+    private val sessionFactory = hibernateConfig.sessionFactoryForRegisteredSchemas
+    private val criteriaBuilder = sessionFactory.criteriaBuilder
     /**
      * Maintain a list of contract state interfaces to concrete types stored in the vault
      * for usage in generic queries of type queryBy<LinearState> or queryBy<FungibleState<*>>
@@ -406,11 +405,6 @@ class NodeVaultService(private val clock: Clock, private val keyManagementServic
     @Throws(VaultQueryException::class)
     override fun <T : ContractState> _queryBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): Vault.Page<T> {
         log.info("Vault Query for contract type: $contractStateType, criteria: $criteria, pagination: $paging, sorting: $sorting")
-
-        // refresh to include any schemas registered after initial VQ service initialisation
-        sessionFactory = hibernateConfig.sessionFactoryForRegisteredSchemas()
-        criteriaBuilder = sessionFactory.criteriaBuilder
-
         // calculate total results where a page specification has been defined
         var totalStates = -1L
         if (!paging.isDefault) {
diff --git a/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt b/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
index 0bf9885945..b8fc4f333d 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
@@ -6,8 +6,6 @@ import net.corda.core.node.services.IdentityService
 import net.corda.node.services.api.SchemaService
 import net.corda.node.services.persistence.HibernateConfiguration
 import net.corda.node.services.schema.NodeSchemaService
-import org.hibernate.SessionFactory
-
 import rx.Observable
 import rx.Subscriber
 import rx.subjects.UnicastSubject
@@ -32,12 +30,7 @@ class CordaPersistence(var dataSource: HikariDataSource, private val schemaServi
             HibernateConfiguration(schemaService, databaseProperties, createIdentityService)
         }
     }
-
-    val entityManagerFactory: SessionFactory by lazy {
-        transaction {
-            hibernateConfig.sessionFactoryForRegisteredSchemas()
-        }
-    }
+    val entityManagerFactory get() = hibernateConfig.sessionFactoryForRegisteredSchemas
 
     companion object {
         fun connect(dataSource: HikariDataSource, schemaService: SchemaService, createIdentityService: () -> IdentityService, databaseProperties: Properties): CordaPersistence {
@@ -103,7 +96,7 @@ class CordaPersistence(var dataSource: HikariDataSource, private val schemaServi
     }
 }
 
-fun configureDatabase(dataSourceProperties: Properties, databaseProperties: Properties?, schemaService: SchemaService = NodeSchemaService(), createIdentityService: () -> IdentityService): CordaPersistence {
+fun configureDatabase(dataSourceProperties: Properties, databaseProperties: Properties?, createIdentityService: () -> IdentityService, schemaService: SchemaService = NodeSchemaService(null)): CordaPersistence {
     val config = HikariConfig(dataSourceProperties)
     val dataSource = HikariDataSource(config)
     val persistence = CordaPersistence.connect(dataSource, schemaService, createIdentityService, databaseProperties ?: Properties())
diff --git a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
index 0568b45a3e..2ad7697d20 100644
--- a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
+++ b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
@@ -8,7 +8,6 @@ import net.corda.core.messaging.*;
 import net.corda.core.node.services.*;
 import net.corda.core.node.services.vault.*;
 import net.corda.core.node.services.vault.QueryCriteria.*;
-import net.corda.core.schemas.*;
 import net.corda.core.utilities.*;
 import net.corda.finance.contracts.*;
 import net.corda.finance.contracts.asset.*;
@@ -43,14 +42,13 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
 
     @Before
     public void setUp() {
-        List<String> cordappPackages = Arrays.asList("net.corda.testing.contracts", "net.corda.finance.contracts.asset");
+        List<String> cordappPackages = Arrays.asList("net.corda.testing.contracts", "net.corda.finance.contracts.asset", CashSchemaV1.class.getPackage().getName());
         ArrayList<KeyPair> keys = new ArrayList<>();
         keys.add(getMEGA_CORP_KEY());
         keys.add(getDUMMY_NOTARY_KEY());
-        Set<MappedSchema> requiredSchemas = Collections.singleton(CashSchemaV1.INSTANCE);
         IdentityService identitySvc = makeTestIdentityService();
         @SuppressWarnings("unchecked")
-        Pair<CordaPersistence, MockServices> databaseAndServices = makeTestDatabaseAndMockServices(requiredSchemas, keys, () -> identitySvc, cordappPackages);
+        Pair<CordaPersistence, MockServices> databaseAndServices = makeTestDatabaseAndMockServices(keys, () -> identitySvc, cordappPackages);
         issuerServices = new MockServices(cordappPackages, getDUMMY_CASH_ISSUER_KEY(), getBOC_KEY());
         database = databaseAndServices.getFirst();
         services = databaseAndServices.getSecond();
diff --git a/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt b/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt
index 3d4005d6fc..54117732cf 100644
--- a/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt
+++ b/node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt
@@ -26,7 +26,7 @@ import kotlin.test.assertEquals
 class InteractiveShellTest {
     @Before
     fun setup() {
-        InteractiveShell.database = configureDatabase(MockServices.makeTestDataSourceProperties(), MockServices.makeTestDatabaseProperties(), createIdentityService = ::makeTestIdentityService)
+        InteractiveShell.database = configureDatabase(MockServices.makeTestDataSourceProperties(), MockServices.makeTestDatabaseProperties(), ::makeTestIdentityService)
     }
 
     @After
diff --git a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt
index 877037c387..9f7833f928 100644
--- a/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt
+++ b/node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt
@@ -1,5 +1,6 @@
 package net.corda.node.internal.cordapp
 
+import com.nhaarman.mockito_kotlin.mock
 import net.corda.core.node.services.AttachmentStorage
 import net.corda.testing.node.MockAttachmentStorage
 import org.junit.Assert
@@ -22,9 +23,7 @@ class CordappProviderImplTests {
     @Test
     fun `isolated jar is loaded into the attachment store`() {
         val loader = CordappLoader.createDevMode(listOf(isolatedJAR))
-        val provider = CordappProviderImpl(loader)
-
-        provider.start(attachmentStore)
+        val provider = CordappProviderImpl(loader, attachmentStore)
         val maybeAttachmentId = provider.getCordappAttachmentId(provider.cordapps.first())
 
         Assert.assertNotNull(maybeAttachmentId)
@@ -34,17 +33,14 @@ class CordappProviderImplTests {
     @Test
     fun `empty jar is not loaded into the attachment store`() {
         val loader = CordappLoader.createDevMode(listOf(emptyJAR))
-        val provider = CordappProviderImpl(loader)
-
-        provider.start(attachmentStore)
-
+        val provider = CordappProviderImpl(loader, attachmentStore)
         Assert.assertNull(provider.getCordappAttachmentId(provider.cordapps.first()))
     }
 
     @Test
     fun `test that we find a cordapp class that is loaded into the store`() {
         val loader = CordappLoader.createDevMode(listOf(isolatedJAR))
-        val provider = CordappProviderImpl(loader)
+        val provider = CordappProviderImpl(loader, mock())
         val className = "net.corda.finance.contracts.isolated.AnotherDummyContract"
 
         val expected = provider.cordapps.first()
@@ -57,10 +53,8 @@ class CordappProviderImplTests {
     @Test
     fun `test that we find an attachment for a cordapp contrat class`() {
         val loader = CordappLoader.createDevMode(listOf(isolatedJAR))
-        val provider = CordappProviderImpl(loader)
+        val provider = CordappProviderImpl(loader, attachmentStore)
         val className = "net.corda.finance.contracts.isolated.AnotherDummyContract"
-
-        provider.start(attachmentStore)
         val expected = provider.getAppContext(provider.cordapps.first()).attachmentId
         val actual = provider.getContractAttachmentID(className)
 
diff --git a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
index d5c966d31c..d54bfa8754 100644
--- a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt
@@ -78,7 +78,7 @@ class NodeSchedulerServiceTest : SingletonSerializeAsToken() {
         calls = 0
         val dataSourceProps = makeTestDataSourceProperties()
         val databaseProperties = makeTestDatabaseProperties()
-        database = configureDatabase(dataSourceProps, databaseProperties, createIdentityService = ::makeTestIdentityService)
+        database = configureDatabase(dataSourceProps, databaseProperties, ::makeTestIdentityService)
         val identityService = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
         val kms = MockKeyManagementService(identityService, ALICE_KEY)
 
@@ -97,7 +97,7 @@ class NodeSchedulerServiceTest : SingletonSerializeAsToken() {
                     network = mockMessagingService), TestReference {
                 override val vaultService: VaultServiceInternal = NodeVaultService(testClock, kms, stateLoader, database.hibernateConfig)
                 override val testReference = this@NodeSchedulerServiceTest
-                override val cordappProvider = CordappProviderImpl(CordappLoader.createWithTestPackages(listOf("net.corda.testing.contracts"))).start(attachments)
+                override val cordappProvider = CordappProviderImpl(CordappLoader.createWithTestPackages(listOf("net.corda.testing.contracts")), attachments)
             }
             smmExecutor = AffinityExecutor.ServiceAffinityExecutor("test", 1)
             scheduler = NodeSchedulerService(services, schedulerGatedExecutor, serverThread = smmExecutor)
diff --git a/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTests.kt b/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTests.kt
index 6a1adee86a..418322b589 100644
--- a/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTests.kt
@@ -71,7 +71,7 @@ class ArtemisMessagingTests : TestDependencyInjectionBase() {
                 baseDirectory = baseDirectory,
                 myLegalName = ALICE.name)
         LogHelper.setLevel(PersistentUniquenessProvider::class)
-        database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), createIdentityService = ::makeTestIdentityService)
+        database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), ::makeTestIdentityService)
         networkMapRegistrationFuture = doneFuture(Unit)
         networkMapCache = PersistentNetworkMapCache(serviceHub = object : MockServiceHubInternal(database, config) {})
     }
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/DBCheckpointStorageTests.kt b/node/src/test/kotlin/net/corda/node/services/persistence/DBCheckpointStorageTests.kt
index aaa8e49db1..f71f266388 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/DBCheckpointStorageTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/DBCheckpointStorageTests.kt
@@ -33,7 +33,7 @@ class DBCheckpointStorageTests : TestDependencyInjectionBase() {
     @Before
     fun setUp() {
         LogHelper.setLevel(PersistentUniquenessProvider::class)
-        database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), createIdentityService = ::makeTestIdentityService)
+        database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), ::makeTestIdentityService)
         newCheckpointStorage()
     }
 
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
index 3a3148c0db..2b9ff96f1c 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt
@@ -38,7 +38,7 @@ class DBTransactionStorageTests : TestDependencyInjectionBase() {
     fun setUp() {
         LogHelper.setLevel(PersistentUniquenessProvider::class)
         val dataSourceProps = makeTestDataSourceProperties()
-        database = configureDatabase(dataSourceProps, makeTestDatabaseProperties(), NodeSchemaService(), ::makeTestIdentityService)
+        database = configureDatabase(dataSourceProps, makeTestDatabaseProperties(), ::makeTestIdentityService)
         database.transaction {
 
             services = object : MockServices(BOB_KEY) {
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
index f0a381c411..0e1cdc1047 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt
@@ -9,6 +9,7 @@ import net.corda.core.utilities.toBase58String
 import net.corda.core.node.services.Vault
 import net.corda.core.node.services.VaultService
 import net.corda.core.schemas.CommonSchemaV1
+import net.corda.core.schemas.MappedSchema
 import net.corda.core.schemas.PersistentStateRef
 import net.corda.core.serialization.SerializationDefaults
 import net.corda.core.serialization.deserialize
@@ -25,7 +26,6 @@ import net.corda.finance.schemas.SampleCashSchemaV2
 import net.corda.finance.schemas.SampleCashSchemaV3
 import net.corda.finance.utils.sumCash
 import net.corda.node.services.schema.HibernateObserver
-import net.corda.node.services.schema.NodeSchemaService
 import net.corda.node.services.vault.VaultSchemaV1
 import net.corda.node.utilities.CordaPersistence
 import net.corda.node.utilities.configureDatabase
@@ -77,7 +77,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
         issuerServices = MockServices(cordappPackages, DUMMY_CASH_ISSUER_KEY, BOB_KEY, BOC_KEY)
         val dataSourceProps = makeTestDataSourceProperties()
         val defaultDatabaseProperties = makeTestDatabaseProperties()
-        database = configureDatabase(dataSourceProps, defaultDatabaseProperties, NodeSchemaService(), ::makeTestIdentityService)
+        database = configureDatabase(dataSourceProps, defaultDatabaseProperties, ::makeTestIdentityService)
         database.transaction {
             hibernateConfig = database.hibernateConfig
             services = object : MockServices(cordappPackages, BOB_KEY, BOC_KEY, DUMMY_NOTARY_KEY) {
@@ -95,13 +95,13 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
             hibernatePersister = services.hibernatePersister
         }
         setUpDb()
-
-        val customSchemas = setOf(VaultSchemaV1, CashSchemaV1, SampleCashSchemaV2, SampleCashSchemaV3)
-        sessionFactory = hibernateConfig.sessionFactoryForSchemas(*customSchemas.toTypedArray())
+        sessionFactory = sessionFactoryForSchemas(VaultSchemaV1, CashSchemaV1, SampleCashSchemaV2, SampleCashSchemaV3)
         entityManager = sessionFactory.createEntityManager()
         criteriaBuilder = sessionFactory.criteriaBuilder
     }
 
+    private fun sessionFactoryForSchemas(vararg schemas: MappedSchema) = hibernateConfig.sessionFactoryForSchemas(schemas.toSet())
+
     @After
     fun cleanUp() {
         database.close()
@@ -536,8 +536,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestDeals(listOf("123", "456", "789"))
             services.fillWithSomeTestLinearStates(2)
         }
-
-        val sessionFactory = hibernateConfig.sessionFactoryForSchemas(VaultSchemaV1, DummyLinearStateSchemaV1)
+        val sessionFactory = sessionFactoryForSchemas(VaultSchemaV1, DummyLinearStateSchemaV1)
         val criteriaBuilder = sessionFactory.criteriaBuilder
         val entityManager = sessionFactory.createEntityManager()
 
@@ -568,8 +567,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestDeals(listOf("123", "456", "789"))
             services.fillWithSomeTestLinearStates(2)
         }
-
-        val sessionFactory = hibernateConfig.sessionFactoryForSchemas(VaultSchemaV1, DummyLinearStateSchemaV2)
+        val sessionFactory = sessionFactoryForSchemas(VaultSchemaV1, DummyLinearStateSchemaV2)
         val criteriaBuilder = sessionFactory.criteriaBuilder
         val entityManager = sessionFactory.createEntityManager()
 
@@ -635,8 +633,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
                 hibernatePersister.persistStateWithSchema(dummyFungibleState, it.ref, SampleCashSchemaV3)
             }
         }
-
-        val sessionFactory = hibernateConfig.sessionFactoryForSchemas(VaultSchemaV1, CommonSchemaV1, SampleCashSchemaV3)
+        val sessionFactory = sessionFactoryForSchemas(VaultSchemaV1, CommonSchemaV1, SampleCashSchemaV3)
         val criteriaBuilder = sessionFactory.criteriaBuilder
         val entityManager = sessionFactory.createEntityManager()
 
@@ -764,8 +761,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestLinearStates(2, externalId = "222")
             services.fillWithSomeTestLinearStates(3, externalId = "333")
         }
-
-        val sessionFactory = hibernateConfig.sessionFactoryForSchemas(VaultSchemaV1, DummyLinearStateSchemaV2)
+        val sessionFactory = sessionFactoryForSchemas(VaultSchemaV1, DummyLinearStateSchemaV2)
         val criteriaBuilder = sessionFactory.criteriaBuilder
         val entityManager = sessionFactory.createEntityManager()
 
@@ -817,8 +813,7 @@ class HibernateConfigurationTest : TestDependencyInjectionBase() {
             services.fillWithSomeTestLinearStates(2, externalId = "222")
             services.fillWithSomeTestLinearStates(3, externalId = "333")
         }
-
-        val sessionFactory = hibernateConfig.sessionFactoryForSchemas(VaultSchemaV1, DummyLinearStateSchemaV1)
+        val sessionFactory = sessionFactoryForSchemas(VaultSchemaV1, DummyLinearStateSchemaV1)
         val criteriaBuilder = sessionFactory.criteriaBuilder
         val entityManager = sessionFactory.createEntityManager()
 
diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt
index d3ee944069..a8a352cbf1 100644
--- a/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt
@@ -40,7 +40,7 @@ class NodeAttachmentStorageTest {
         LogHelper.setLevel(PersistentUniquenessProvider::class)
 
         val dataSourceProperties = makeTestDataSourceProperties()
-        database = configureDatabase(dataSourceProperties, makeTestDatabaseProperties(), createIdentityService = ::makeTestIdentityService)
+        database = configureDatabase(dataSourceProperties, makeTestDatabaseProperties(), ::makeTestIdentityService)
         fs = Jimfs.newFileSystem(Configuration.unix())
     }
 
diff --git a/node/src/test/kotlin/net/corda/node/services/schema/HibernateObserverTests.kt b/node/src/test/kotlin/net/corda/node/services/schema/HibernateObserverTests.kt
index 44fc3cb47b..33e8bcdad4 100644
--- a/node/src/test/kotlin/net/corda/node/services/schema/HibernateObserverTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/schema/HibernateObserverTests.kt
@@ -57,8 +57,6 @@ class HibernateObserverTests {
         val testSchema = TestSchema
         val rawUpdatesPublisher = PublishSubject.create<Vault.Update<ContractState>>()
         val schemaService = object : SchemaService {
-            override fun registerCustomSchemas(customSchemas: Set<MappedSchema>) {}
-
             override val schemaOptions: Map<MappedSchema, SchemaService.SchemaOptions> = emptyMap()
 
             override fun selectSchemas(state: ContractState): Iterable<MappedSchema> = setOf(testSchema)
@@ -70,7 +68,7 @@ class HibernateObserverTests {
                 return parent
             }
         }
-        val database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), schemaService, createIdentityService = ::makeTestIdentityService)
+        val database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), ::makeTestIdentityService, schemaService)
         @Suppress("UNUSED_VARIABLE")
         val observer = HibernateObserver(rawUpdatesPublisher, database.hibernateConfig)
         database.transaction {
diff --git a/node/src/test/kotlin/net/corda/node/services/schema/NodeSchemaServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/schema/NodeSchemaServiceTest.kt
index 73bb252af5..be168e8b98 100644
--- a/node/src/test/kotlin/net/corda/node/services/schema/NodeSchemaServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/schema/NodeSchemaServiceTest.kt
@@ -3,11 +3,13 @@ package net.corda.node.services.schema
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.StartableByRPC
+import net.corda.core.internal.packageName
 import net.corda.core.messaging.startFlow
 import net.corda.core.schemas.MappedSchema
 import net.corda.core.schemas.PersistentState
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.services.api.ServiceHubInternal
+import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.driver
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.schemas.DummyLinearStateSchemaV1
@@ -15,6 +17,7 @@ import org.hibernate.annotations.Cascade
 import org.hibernate.annotations.CascadeType
 import org.junit.Test
 import javax.persistence.*
+import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 class NodeSchemaServiceTest {
@@ -23,11 +26,9 @@ class NodeSchemaServiceTest {
      */
     @Test
     fun `registering custom schemas for testing with MockNode`() {
-        val mockNet = MockNetwork()
+        val mockNet = MockNetwork(cordappPackages = listOf(DummyLinearStateSchemaV1::class.packageName))
         val mockNode = mockNet.createNode()
         mockNet.runNetwork()
-
-        mockNode.internals.registerCustomSchemas(setOf(DummyLinearStateSchemaV1))
         val schemaService = mockNode.services.schemaService
         assertTrue(schemaService.schemaOptions.containsKey(DummyLinearStateSchemaV1))
 
@@ -50,6 +51,16 @@ class NodeSchemaServiceTest {
         }
     }
 
+    @Test
+    fun `custom schemas are loaded eagerly`() {
+        val expected = setOf("PARENTS", "CHILDREN")
+        assertEquals<Set<*>>(expected, driver {
+            (startNode(startInSameProcess = true).getOrThrow() as NodeHandle.InProcess).node.database.transaction {
+                session.createNativeQuery("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES").list()
+            }
+        }.toMutableSet().apply { retainAll(expected) })
+    }
+
     @StartableByRPC
     class MappedSchemasFlow : FlowLogic<List<String>>() {
         @Suspendable
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/DistributedImmutableMapTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/DistributedImmutableMapTests.kt
index bd4c3358f3..ce79064a79 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/DistributedImmutableMapTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/DistributedImmutableMapTests.kt
@@ -86,7 +86,7 @@ class DistributedImmutableMapTests : TestDependencyInjectionBase() {
     private fun createReplica(myAddress: NetworkHostAndPort, clusterAddress: NetworkHostAndPort? = null): CompletableFuture<Member> {
         val storage = Storage.builder().withStorageLevel(StorageLevel.MEMORY).build()
         val address = Address(myAddress.host, myAddress.port)
-        val database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties("serverNameTablePrefix", "PORT_${myAddress.port}_"), createIdentityService = ::makeTestIdentityService)
+        val database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties("serverNameTablePrefix", "PORT_${myAddress.port}_"), ::makeTestIdentityService)
         databases.add(database)
         val stateMachineFactory = { DistributedImmutableMap(database, RaftUniquenessProvider.Companion::createMap) }
 
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/PersistentUniquenessProviderTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/PersistentUniquenessProviderTests.kt
index 491931ab2a..088a14e18f 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/PersistentUniquenessProviderTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/PersistentUniquenessProviderTests.kt
@@ -23,7 +23,7 @@ class PersistentUniquenessProviderTests : TestDependencyInjectionBase() {
     @Before
     fun setUp() {
         LogHelper.setLevel(PersistentUniquenessProvider::class)
-        database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), createIdentityService = ::makeTestIdentityService)
+        database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), ::makeTestIdentityService)
     }
 
     @After
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
index 4740ac776d..46802e8a7f 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt
@@ -9,6 +9,7 @@ import net.corda.core.crypto.generateKeyPair
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.AnonymousParty
 import net.corda.core.identity.Party
+import net.corda.core.internal.packageName
 import net.corda.core.node.services.*
 import net.corda.core.node.services.vault.QueryCriteria
 import net.corda.core.node.services.vault.QueryCriteria.*
@@ -46,7 +47,7 @@ import kotlin.test.assertTrue
 
 class NodeVaultServiceTest : TestDependencyInjectionBase() {
     companion object {
-        private val cordappPackages = listOf("net.corda.finance.contracts.asset")
+        private val cordappPackages = listOf("net.corda.finance.contracts.asset", CashSchemaV1::class.packageName)
     }
 
     lateinit var services: MockServices
@@ -58,7 +59,6 @@ class NodeVaultServiceTest : TestDependencyInjectionBase() {
     fun setUp() {
         LogHelper.setLevel(NodeVaultService::class)
         val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(BOC_KEY, DUMMY_CASH_ISSUER_KEY),
-                customSchemas = setOf(CashSchemaV1),
                 cordappPackages = cordappPackages)
         database = databaseAndServices.first
         services = databaseAndServices.second
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
index 56d6e90992..8d34babb97 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
@@ -6,6 +6,7 @@ import net.corda.core.crypto.entropyToKeyPair
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.identity.PartyAndCertificate
+import net.corda.core.internal.packageName
 import net.corda.core.node.services.*
 import net.corda.core.node.services.vault.*
 import net.corda.core.node.services.vault.QueryCriteria.*
@@ -45,10 +46,9 @@ import java.time.temporal.ChronoUnit
 import java.util.*
 
 class VaultQueryTests : TestDependencyInjectionBase() {
-    companion object {
-        private val cordappPackages = listOf("net.corda.testing.contracts", "net.corda.finance.contracts")
-    }
-
+    private val cordappPackages = setOf(
+            "net.corda.testing.contracts", "net.corda.finance.contracts",
+            CashSchemaV1::class.packageName, CommercialPaperSchemaV1::class.packageName, DummyLinearStateSchemaV1::class.packageName).toMutableList()
     private lateinit var services: MockServices
     private lateinit var notaryServices: MockServices
     private val vaultService: VaultService get() = services.vaultService
@@ -67,7 +67,6 @@ class VaultQueryTests : TestDependencyInjectionBase() {
         identitySvc.verifyAndRegisterIdentity(BOC_IDENTITY)
         val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(MEGA_CORP_KEY, DUMMY_NOTARY_KEY),
                 createIdentityService = { identitySvc },
-                customSchemas = setOf(CashSchemaV1, CommercialPaperSchemaV1, DummyLinearStateSchemaV1),
                 cordappPackages = cordappPackages)
         database = databaseAndServices.first
         services = databaseAndServices.second
@@ -85,8 +84,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
     @Ignore
     @Test
     fun createPersistentTestDb() {
-        val database = configureDatabase(makePersistentDataSourceProperties(), makeTestDatabaseProperties(), createIdentityService = { identitySvc })
-
+        val database = configureDatabase(makePersistentDataSourceProperties(), makeTestDatabaseProperties(), { identitySvc })
         setUpDb(database, 5000)
 
         database.close()
@@ -1753,6 +1751,9 @@ class VaultQueryTests : TestDependencyInjectionBase() {
 
     @Test
     fun `query attempting to use unregistered schema`() {
+        tearDown()
+        cordappPackages -= SampleCashSchemaV3::class.packageName
+        setUp()
         database.transaction {
             services.fillWithSomeTestCash(100.DOLLARS, notaryServices, DUMMY_NOTARY, 1, 1, Random(0L))
             services.fillWithSomeTestCash(100.POUNDS, notaryServices, DUMMY_NOTARY, 1, 1, Random(0L))
diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
index a42e13d55c..feb6530062 100644
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
+++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
@@ -4,6 +4,7 @@ import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.LinearState
 import net.corda.core.contracts.UniqueIdentifier
 import net.corda.core.identity.AnonymousParty
+import net.corda.core.internal.packageName
 import net.corda.core.node.services.Vault
 import net.corda.core.node.services.VaultService
 import net.corda.core.node.services.queryBy
@@ -35,7 +36,7 @@ import kotlin.test.assertEquals
 
 class VaultWithCashTest : TestDependencyInjectionBase() {
     companion object {
-        private val cordappPackages = listOf("net.corda.testing.contracts", "net.corda.finance.contracts.asset")
+        private val cordappPackages = listOf("net.corda.testing.contracts", "net.corda.finance.contracts.asset", CashSchemaV1::class.packageName)
     }
 
     lateinit var services: MockServices
@@ -48,7 +49,6 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
     fun setUp() {
         LogHelper.setLevel(VaultWithCashTest::class)
         val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(DUMMY_CASH_ISSUER_KEY, DUMMY_NOTARY_KEY),
-                customSchemas = setOf(CashSchemaV1),
                 cordappPackages = cordappPackages)
         database = databaseAndServices.first
         services = databaseAndServices.second
diff --git a/node/src/test/kotlin/net/corda/node/utilities/ObservablesTests.kt b/node/src/test/kotlin/net/corda/node/utilities/ObservablesTests.kt
index ffac359f49..e7b9ca1623 100644
--- a/node/src/test/kotlin/net/corda/node/utilities/ObservablesTests.kt
+++ b/node/src/test/kotlin/net/corda/node/utilities/ObservablesTests.kt
@@ -21,7 +21,7 @@ class ObservablesTests {
     val toBeClosed = mutableListOf<Closeable>()
 
     fun createDatabase(): CordaPersistence {
-        val database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), createIdentityService = ::makeTestIdentityService)
+        val database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), ::makeTestIdentityService)
         toBeClosed += database
         return database
     }
diff --git a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
index 4e9d129c26..d43192cdf8 100644
--- a/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
+++ b/samples/irs-demo/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt
@@ -62,7 +62,7 @@ class NodeInterestRatesTest : TestDependencyInjectionBase() {
 
     @Before
     fun setUp() {
-        database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), createIdentityService = ::makeTestIdentityService)
+        database = configureDatabase(makeTestDataSourceProperties(), makeTestDatabaseProperties(), ::makeTestIdentityService)
         database.transaction {
             oracle = createMockCordaService(services, NodeInterestRates::Oracle)
             oracle.knownFixes = TEST_DATA
diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
index 90a3ca2d8b..b9abcd6538 100644
--- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
+++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/Simulation.kt
@@ -12,7 +12,6 @@ import net.corda.node.internal.StartedNode
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.statemachine.StateMachineManager
 import net.corda.nodeapi.internal.ServiceInfo
-import net.corda.nodeapi.internal.ServiceType
 import net.corda.testing.*
 import net.corda.testing.node.InMemoryMessagingNetwork
 import net.corda.testing.node.MockNetwork
@@ -270,9 +269,3 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean,
         mockNet.stopNodes()
     }
 }
-
-/**
- * Helper function for verifying that a service info contains the given type of advertised service. For non-simulation cases
- * this is a configuration matter rather than implementation.
- */
-fun Iterable<ServiceInfo>.containsType(type: ServiceType) = any { it.type == type }
\ No newline at end of file
diff --git a/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt b/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
index 6fb3556c25..61580c8632 100644
--- a/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
+++ b/samples/trader-demo/src/integration-test/kotlin/net/corda/traderdemo/TraderDemoTest.kt
@@ -1,6 +1,7 @@
 package net.corda.traderdemo
 
 import net.corda.client.rpc.CordaRPCClient
+import net.corda.core.internal.packageName
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.millis
 import net.corda.finance.DOLLARS
@@ -20,7 +21,9 @@ import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
 import java.util.concurrent.Executors
 
-class TraderDemoTest : NodeBasedTest(listOf("net.corda.finance.contracts.asset", "net.corda.finance.contracts")) {
+class TraderDemoTest : NodeBasedTest(listOf(
+        "net.corda.finance.contracts.asset", "net.corda.finance.contracts",
+        CashSchemaV1::class.packageName, CommercialPaperSchemaV1::class.packageName)) {
     @Test
     fun `runs trader demo`() {
         val demoUser = User("demo", "demo", setOf(startFlowPermission<SellerFlow>()))
@@ -35,9 +38,6 @@ class TraderDemoTest : NodeBasedTest(listOf("net.corda.finance.contracts.asset",
         val (nodeA, nodeB, bankNode) = listOf(nodeAFuture, nodeBFuture, bankNodeFuture, notaryFuture).map { it.getOrThrow() }
 
         nodeA.internals.registerInitiatedFlow(BuyerFlow::class.java)
-        nodeA.internals.registerCustomSchemas(setOf(CashSchemaV1))
-        nodeB.internals.registerCustomSchemas(setOf(CashSchemaV1, CommercialPaperSchemaV1))
-
         val (nodeARpc, nodeBRpc) = listOf(nodeA, nodeB).map {
             val client = CordaRPCClient(it.internals.configuration.rpcAddress!!)
             client.start(demoUser.username, demoUser.password).proxy
diff --git a/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt b/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt
index c4ca2077cf..1188e1571e 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/node/testing/MockServiceHubInternal.kt
@@ -1,7 +1,6 @@
 package net.corda.node.testing
 
 import com.codahale.metrics.MetricRegistry
-import net.corda.core.cordapp.CordappProvider
 import net.corda.core.flows.FlowInitiator
 import net.corda.core.flows.FlowLogic
 import net.corda.core.identity.Party
@@ -13,11 +12,11 @@ import net.corda.node.internal.InitiatedFlowFactory
 import net.corda.node.internal.StateLoaderImpl
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
+import net.corda.node.internal.cordapp.CordappProviderInternal
 import net.corda.node.serialization.NodeClock
 import net.corda.node.services.api.*
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.messaging.MessagingService
-import net.corda.node.services.schema.NodeSchemaService
 import net.corda.node.services.statemachine.FlowStateMachineImpl
 import net.corda.node.services.statemachine.StateMachineManager
 import net.corda.node.services.transactions.InMemoryTransactionVerifierService
@@ -46,10 +45,9 @@ open class MockServiceHubInternal(
         val mapCache: NetworkMapCacheInternal? = null,
         val scheduler: SchedulerService? = null,
         val overrideClock: Clock? = NodeClock(),
-        val schemas: SchemaService? = NodeSchemaService(),
         val customContractUpgradeService: ContractUpgradeService? = null,
         val customTransactionVerifierService: TransactionVerifierService? = InMemoryTransactionVerifierService(2),
-        override val cordappProvider: CordappProvider = CordappProviderImpl(CordappLoader.createDefault(Paths.get("."))).start(attachments),
+        override val cordappProvider: CordappProviderInternal = CordappProviderImpl(CordappLoader.createDefault(Paths.get(".")), attachments),
         protected val stateLoader: StateLoaderImpl = StateLoaderImpl(validatedTransactions)
 ) : ServiceHubInternal, StateLoader by stateLoader {
     override val transactionVerifierService: TransactionVerifierService
@@ -75,8 +73,7 @@ open class MockServiceHubInternal(
     override val monitoringService: MonitoringService = MonitoringService(MetricRegistry())
     override val rpcFlows: List<Class<out FlowLogic<*>>>
         get() = throw UnsupportedOperationException()
-    override val schemaService: SchemaService
-        get() = schemas ?: throw UnsupportedOperationException()
+    override val schemaService get() = throw UnsupportedOperationException()
     override val auditService: AuditService = DummyAuditService()
 
     lateinit var smm: StateMachineManager
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
index 47fd8589a3..fcd5689800 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
@@ -14,7 +14,6 @@ import net.corda.core.node.NodeInfo
 import net.corda.core.node.ServiceHub
 import net.corda.core.node.StateLoader
 import net.corda.core.node.services.*
-import net.corda.core.schemas.MappedSchema
 import net.corda.core.serialization.SerializeAsToken
 import net.corda.core.serialization.SingletonSerializeAsToken
 import net.corda.core.transactions.SignedTransaction
@@ -51,7 +50,7 @@ import java.util.*
  * building chains of transactions and verifying them. It isn't sufficient for testing flows however.
  */
 open class MockServices(
-        cordappPackages: List<String>,
+        cordappLoader: CordappLoader,
         override val validatedTransactions: WritableTransactionStorage,
         protected val stateLoader: StateLoaderImpl = StateLoaderImpl(validatedTransactions),
         vararg val keys: KeyPair
@@ -101,24 +100,22 @@ open class MockServices(
 
         /**
          * Makes database and mock services appropriate for unit tests.
-         *
-         * @param customSchemas a set of schemas being used by [NodeSchemaService]
-         * @param keys a lis of [KeyPair] instances to be used by [MockServices]. Defualts to [MEGA_CORP_KEY]
+         * @param keys a list of [KeyPair] instances to be used by [MockServices]. Defualts to [MEGA_CORP_KEY]
          * @param createIdentityService a lambda function returning an instance of [IdentityService]. Defauts to [InMemoryIdentityService].
          *
          * @return a pair where the first element is the instance of [CordaPersistence] and the second is [MockServices].
          */
         @JvmStatic
-        fun makeTestDatabaseAndMockServices(customSchemas: Set<MappedSchema> = emptySet(),
-                                            keys: List<KeyPair> = listOf(MEGA_CORP_KEY),
+        fun makeTestDatabaseAndMockServices(keys: List<KeyPair> = listOf(MEGA_CORP_KEY),
                                             createIdentityService: () -> IdentityService = { makeTestIdentityService() },
                                             cordappPackages: List<String> = emptyList()): Pair<CordaPersistence, MockServices> {
+            val cordappLoader = CordappLoader.createWithTestPackages(cordappPackages)
             val dataSourceProps = makeTestDataSourceProperties()
             val databaseProperties = makeTestDatabaseProperties()
             val identityServiceRef: IdentityService by lazy { createIdentityService() }
-            val database = configureDatabase(dataSourceProps, databaseProperties, NodeSchemaService(customSchemas), { identityServiceRef })
+            val database = configureDatabase(dataSourceProps, databaseProperties, { identityServiceRef }, NodeSchemaService(cordappLoader))
             val mockService = database.transaction {
-                object : MockServices(cordappPackages, *(keys.toTypedArray())) {
+                object : MockServices(cordappLoader, *(keys.toTypedArray())) {
                     override val identityService: IdentityService = database.transaction { identityServiceRef }
                     override val vaultService = makeVaultService(database.hibernateConfig)
 
@@ -137,7 +134,8 @@ open class MockServices(
         }
     }
 
-    constructor(cordappPackages: List<String>, vararg keys: KeyPair) : this(cordappPackages, MockTransactionStorage(), keys = *keys)
+    private constructor(cordappLoader: CordappLoader, vararg keys: KeyPair) : this(cordappLoader, MockTransactionStorage(), keys = *keys)
+    constructor(cordappPackages: List<String>, vararg keys: KeyPair) : this(CordappLoader.createWithTestPackages(cordappPackages), keys = *keys)
     constructor(vararg keys: KeyPair) : this(emptyList(), *keys)
     constructor() : this(generateKeyPair())
 
@@ -167,11 +165,11 @@ open class MockServices(
             return NodeInfo(emptyList(), listOf(identity), 1, serial = 1L)
         }
     override val transactionVerifierService: TransactionVerifierService get() = InMemoryTransactionVerifierService(2)
-    val mockCordappProvider = MockCordappProvider(CordappLoader.createWithTestPackages(cordappPackages)).start(attachments) as MockCordappProvider
+    val mockCordappProvider = MockCordappProvider(cordappLoader, attachments)
     override val cordappProvider: CordappProvider get() = mockCordappProvider
     lateinit var hibernatePersister: HibernateObserver
 
-    fun makeVaultService(hibernateConfig: HibernateConfiguration = HibernateConfiguration(NodeSchemaService(), makeTestDatabaseProperties(), { identityService })): VaultServiceInternal {
+    fun makeVaultService(hibernateConfig: HibernateConfiguration): VaultServiceInternal {
         val vaultService = NodeVaultService(Clock.systemUTC(), keyManagementService, stateLoader, hibernateConfig)
         hibernatePersister = HibernateObserver(vaultService.rawUpdates, hibernateConfig)
         return vaultService
diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/SimpleNode.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/SimpleNode.kt
index cfb1e3a29d..3b7bf9130e 100644
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/SimpleNode.kt
+++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/SimpleNode.kt
@@ -37,7 +37,7 @@ class SimpleNode(val config: NodeConfiguration, val address: NetworkHostAndPort
     val monitoringService = MonitoringService(MetricRegistry())
     val identity: KeyPair = generateKeyPair()
     val identityService: IdentityService = InMemoryIdentityService(trustRoot = trustRoot)
-    val database: CordaPersistence = configureDatabase(config.dataSourceProperties, config.database, NodeSchemaService(), { InMemoryIdentityService(trustRoot = trustRoot) })
+    val database: CordaPersistence = configureDatabase(config.dataSourceProperties, config.database, { InMemoryIdentityService(trustRoot = trustRoot) })
     val keyService: KeyManagementService = E2ETestKeyManagementService(identityService, setOf(identity))
     val executor = ServiceAffinityExecutor(config.myLegalName.organisation, 1)
     // TODO: We should have a dummy service hub rather than change behaviour in tests
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/LogHelper.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/LogHelper.kt
index ad2e488e91..1fab8508fc 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/LogHelper.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/LogHelper.kt
@@ -1,5 +1,6 @@
 package net.corda.testing
 
+import net.corda.core.internal.packageName
 import org.apache.logging.log4j.Level
 import org.apache.logging.log4j.LogManager
 import org.apache.logging.log4j.core.LoggerContext
@@ -25,7 +26,7 @@ object LogHelper {
         }
     }
 
-    fun setLevel(vararg classes: KClass<*>) = setLevel(*classes.map { "+" + it.java.`package`.name }.toTypedArray())
+    fun setLevel(vararg classes: KClass<*>) = setLevel(*classes.map { "+" + it.packageName }.toTypedArray())
 
     /** Removes custom configuration for the specified logger names */
     fun reset(vararg names: String) {
@@ -35,7 +36,7 @@ object LogHelper {
         loggerContext.updateLoggers(config)
     }
 
-    fun reset(vararg classes: KClass<*>) = reset(*classes.map { it.java.`package`.name }.toTypedArray())
+    fun reset(vararg classes: KClass<*>) = reset(*classes.map { it.packageName }.toTypedArray())
 
     /** Updates logging level for the specified Log4j logger name */
     private fun setLevel(name: String, level: Level) {
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
index dae72192a6..5c8736335e 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/node/MockCordappProvider.kt
@@ -4,12 +4,13 @@ import net.corda.core.contracts.ContractClassName
 import net.corda.core.cordapp.Cordapp
 import net.corda.core.internal.cordapp.CordappImpl
 import net.corda.core.node.services.AttachmentId
+import net.corda.core.node.services.AttachmentStorage
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
 import java.nio.file.Paths
 import java.util.*
 
-class MockCordappProvider(cordappLoader: CordappLoader) : CordappProviderImpl(cordappLoader) {
+class MockCordappProvider(cordappLoader: CordappLoader, attachmentStorage: AttachmentStorage) : CordappProviderImpl(cordappLoader, attachmentStorage) {
     val cordappRegistry = mutableListOf<Pair<Cordapp, AttachmentId>>()
 
     fun addMockCordapp(contractClassName: ContractClassName, attachments: MockAttachmentStorage) {

From 2a68e23e6930293f2a4cf5d18ef585fe5b47b549 Mon Sep 17 00:00:00 2001
From: josecoll <jose.coll@r3cev.com>
Date: Mon, 16 Oct 2017 13:47:35 +0100
Subject: [PATCH 178/185] Improved Cash Selection interface (#1858)

* Cash selection refactoring such that 3d party DB providers are only required to implement Coin Selection SQL logic.

* Re-added debug logging statement.

* Updated to include PR review feedback from VK

* Refactoring following rebase from master.

* Fix broken JUnits following rebase.

* Use JDBC ResultSet getBlob() and added custom serializer to address concern raised by tomtau in PR.

* Fix failing JUnits.
---
 .../core/serialization/SerializationAPI.kt    |   6 +
 .../net/corda/finance/contracts/asset/Cash.kt |  62 +------
 .../cash/selection/AbstractCashSelection.kt   | 168 ++++++++++++++++++
 .../cash/selection/CashSelectionH2Impl.kt     | 156 +++-------------
 .../cash/selection/CashSelectionMySQLImpl.kt  |  17 +-
 .../net/corda/finance/flows/CashExitFlow.kt   |   4 +-
 ...sset.cash.selection.AbstractCashSelection} |   0
 7 files changed, 212 insertions(+), 201 deletions(-)
 create mode 100644 finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/AbstractCashSelection.kt
 rename finance/src/main/resources/META-INF/services/{net.corda.finance.contracts.asset.CashSelection => net.corda.finance.contracts.asset.cash.selection.AbstractCashSelection} (100%)

diff --git a/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt b/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
index f77e3ae122..a91636ddc7 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/SerializationAPI.kt
@@ -6,6 +6,7 @@ import net.corda.core.internal.WriteOnceProperty
 import net.corda.core.utilities.ByteSequence
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.sequence
+import java.sql.Blob
 
 /**
  * An abstraction for serializing and deserializing objects, with support for versioning of the wire format via
@@ -185,6 +186,11 @@ inline fun <reified T : Any> SerializedBytes<T>.deserialize(serializationFactory
  */
 inline fun <reified T : Any> ByteArray.deserialize(serializationFactory: SerializationFactory = SerializationFactory.defaultFactory, context: SerializationContext = serializationFactory.defaultContext): T = this.sequence().deserialize(serializationFactory, context)
 
+/**
+ * Convenience extension method for deserializing a JDBC Blob, utilising the defaults.
+ */
+inline fun <reified T : Any> Blob.deserialize(serializationFactory: SerializationFactory = SerializationFactory.defaultFactory, context: SerializationContext = serializationFactory.defaultContext): T = this.getBytes(1, this.length().toInt()).deserialize(serializationFactory, context)
+
 /**
  * Convenience extension method for serializing an object of type T, utilising the defaults.
  */
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt
index 55dffe1d36..d8ead23d9d 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt
@@ -19,79 +19,21 @@ 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.utilities.OpaqueBytes
 import net.corda.core.utilities.toBase58String
-import net.corda.finance.contracts.asset.cash.selection.CashSelectionH2Impl
+import net.corda.finance.contracts.asset.cash.selection.AbstractCashSelection
 import net.corda.finance.schemas.CashSchemaV1
 import net.corda.finance.utils.sumCash
 import net.corda.finance.utils.sumCashOrNull
 import net.corda.finance.utils.sumCashOrZero
 import java.math.BigInteger
 import java.security.PublicKey
-import java.sql.DatabaseMetaData
 import java.util.*
-import java.util.concurrent.atomic.AtomicReference
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
 // Cash
 //
 
-/**
- * Pluggable interface to allow for different cash selection provider implementations
- * Default implementation [CashSelectionH2Impl] uses H2 database and a custom function within H2 to perform aggregation.
- * Custom implementations must implement this interface and declare their implementation in
- * META-INF/services/net.corda.contracts.asset.CashSelection
- */
-interface CashSelection {
-    companion object {
-        val instance = AtomicReference<CashSelection>()
-
-        fun getInstance(metadata: () -> java.sql.DatabaseMetaData): CashSelection {
-            return instance.get() ?: {
-                val _metadata = metadata()
-                val cashSelectionAlgos = ServiceLoader.load(CashSelection::class.java).toList()
-                val cashSelectionAlgo = cashSelectionAlgos.firstOrNull { it.isCompatible(_metadata) }
-                cashSelectionAlgo?.let {
-                    instance.set(cashSelectionAlgo)
-                    cashSelectionAlgo
-                } ?: throw ClassNotFoundException("\nUnable to load compatible cash selection algorithm implementation for JDBC driver ($_metadata)." +
-                        "\nPlease specify an implementation in META-INF/services/net.corda.finance.contracts.asset.CashSelection")
-            }.invoke()
-        }
-    }
-
-    /**
-     * Upon dynamically loading configured Cash Selection algorithms declared in META-INF/services
-     * this method determines whether the loaded implementation is compatible and usable with the currently
-     * loaded JDBC driver.
-     * Note: the first loaded implementation to pass this check will be used at run-time.
-     */
-    fun isCompatible(metadata: DatabaseMetaData): Boolean
-
-    /**
-     * Query to gather Cash states that are available
-     * @param services The service hub to allow access to the database session
-     * @param amount The amount of currency desired (ignoring issues, but specifying the currency)
-     * @param onlyFromIssuerParties If empty the operation ignores the specifics of the issuer,
-     * otherwise the set of eligible states wil be filtered to only include those from these issuers.
-     * @param notary If null the notary source is ignored, if specified then only states marked
-     * with this notary are included.
-     * @param lockId The FlowLogic.runId.uuid of the flow, which is used to soft reserve the states.
-     * Also, previous outputs of the flow will be eligible as they are implicitly locked with this id until the flow completes.
-     * @param withIssuerRefs If not empty the specific set of issuer references to match against.
-     * @return The matching states that were found. If sufficient funds were found these will be locked,
-     * otherwise what is available is returned unlocked for informational purposes.
-     */
-    @Suspendable
-    fun unconsumedCashStatesForSpending(services: ServiceHub,
-                                        amount: Amount<Currency>,
-                                        onlyFromIssuerParties: Set<AbstractParty> = emptySet(),
-                                        notary: Party? = null,
-                                        lockId: UUID,
-                                        withIssuerRefs: Set<OpaqueBytes> = emptySet()): List<StateAndRef<Cash.State>>
-}
-
 /**
  * A cash transaction may split and merge money represented by a set of (issuer, depositRef) pairs, across multiple
  * input and output states. Imagine a Bitcoin transaction but in which all UTXOs had a colour
@@ -384,7 +326,7 @@ class Cash : OnLedgerAsset<Currency, Cash.Commands, Cash.State>() {
 
             // Retrieve unspent and unlocked cash states that meet our spending criteria.
             val totalAmount = payments.map { it.amount }.sumOrThrow()
-            val cashSelection = CashSelection.getInstance({ services.jdbcSession().metaData })
+            val cashSelection = AbstractCashSelection.getInstance({ services.jdbcSession().metaData })
             val acceptableCoins = cashSelection.unconsumedCashStatesForSpending(services, totalAmount, onlyFromParties, tx.notary, tx.lockId)
             val revocationEnabled = false // Revocation is currently unsupported
             // Generate a new identity that change will be sent to for confidentiality purposes. This means that a
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/AbstractCashSelection.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/AbstractCashSelection.kt
new file mode 100644
index 0000000000..fdc3d0d5a7
--- /dev/null
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/AbstractCashSelection.kt
@@ -0,0 +1,168 @@
+package net.corda.finance.contracts.asset.cash.selection
+
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.contracts.Amount
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.contracts.StateRef
+import net.corda.core.contracts.TransactionState
+import net.corda.core.crypto.SecureHash
+import net.corda.core.flows.FlowLogic
+import net.corda.core.identity.AbstractParty
+import net.corda.core.identity.Party
+import net.corda.core.node.ServiceHub
+import net.corda.core.node.services.StatesNotAvailableException
+import net.corda.core.serialization.SerializationDefaults
+import net.corda.core.serialization.deserialize
+import net.corda.core.utilities.*
+import net.corda.finance.contracts.asset.Cash
+import java.sql.*
+import java.util.*
+import java.util.concurrent.atomic.AtomicReference
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+/**
+ * Pluggable interface to allow for different cash selection provider implementations
+ * Default implementation [CashSelectionH2Impl] uses H2 database and a custom function within H2 to perform aggregation.
+ * Custom implementations must implement this interface and declare their implementation in
+ * META-INF/services/net.corda.contracts.asset.CashSelection
+ */
+abstract class AbstractCashSelection {
+    companion object {
+        val instance = AtomicReference<AbstractCashSelection>()
+
+        fun getInstance(metadata: () -> java.sql.DatabaseMetaData): AbstractCashSelection {
+            return instance.get() ?: {
+                val _metadata = metadata()
+                val cashSelectionAlgos = ServiceLoader.load(AbstractCashSelection::class.java).toList()
+                val cashSelectionAlgo = cashSelectionAlgos.firstOrNull { it.isCompatible(_metadata) }
+                cashSelectionAlgo?.let {
+                    instance.set(cashSelectionAlgo)
+                    cashSelectionAlgo
+                } ?: throw ClassNotFoundException("\nUnable to load compatible cash selection algorithm implementation for JDBC driver ($_metadata)." +
+                        "\nPlease specify an implementation in META-INF/services/${AbstractCashSelection::class.java}")
+            }.invoke()
+        }
+
+        val log = loggerFor<AbstractCashSelection>()
+    }
+
+    // coin selection retry loop counter, sleep (msecs) and lock for selecting states
+    // TODO: make parameters configurable when we get CorDapp configuration.
+    private val MAX_RETRIES = 8
+    private val RETRY_SLEEP = 100
+    private val RETRY_CAP = 2000
+    private val spendLock: ReentrantLock = ReentrantLock()
+
+    /**
+     * Upon dynamically loading configured Cash Selection algorithms declared in META-INF/services
+     * this method determines whether the loaded implementation is compatible and usable with the currently
+     * loaded JDBC driver.
+     * Note: the first loaded implementation to pass this check will be used at run-time.
+     */
+    abstract fun isCompatible(metadata: DatabaseMetaData): Boolean
+
+    /**
+     * A vendor specific query(ies) to gather Cash states that are available.
+     * @param statement The service hub to allow access to the database session
+     * @param amount The amount of currency desired (ignoring issues, but specifying the currency)
+     * @param lockId The FlowLogic.runId.uuid of the flow, which is used to soft reserve the states.
+     * Also, previous outputs of the flow will be eligible as they are implicitly locked with this id until the flow completes.
+     * @param notary If null the notary source is ignored, if specified then only states marked
+     * with this notary are included.
+     * @param onlyFromIssuerParties Optional issuer parties to match against.
+     * @param withIssuerRefs Optional issuer references to match against.
+     * @return JDBC ResultSet with the matching states that were found. If sufficient funds were found these will be locked,
+     * otherwise what is available is returned unlocked for informational purposes.
+     */
+    abstract fun executeQuery(connection: Connection, amount: Amount<Currency>, lockId: UUID, notary: Party?,
+                              onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>) : ResultSet
+
+    override abstract fun toString() : String
+
+    /**
+     * Query to gather Cash states that are available and retry if they are temporarily unavailable.
+     * @param services The service hub to allow access to the database session
+     * @param amount The amount of currency desired (ignoring issues, but specifying the currency)
+     * @param onlyFromIssuerParties If empty the operation ignores the specifics of the issuer,
+     * otherwise the set of eligible states wil be filtered to only include those from these issuers.
+     * @param notary If null the notary source is ignored, if specified then only states marked
+     * with this notary are included.
+     * @param lockId The FlowLogic.runId.uuid of the flow, which is used to soft reserve the states.
+     * Also, previous outputs of the flow will be eligible as they are implicitly locked with this id until the flow completes.
+     * @param withIssuerRefs If not empty the specific set of issuer references to match against.
+     * @return The matching states that were found. If sufficient funds were found these will be locked,
+     * otherwise what is available is returned unlocked for informational purposes.
+     */
+    @Suspendable
+    fun unconsumedCashStatesForSpending(services: ServiceHub,
+                                        amount: Amount<Currency>,
+                                        onlyFromIssuerParties: Set<AbstractParty> = emptySet(),
+                                        notary: Party? = null,
+                                        lockId: UUID,
+                                        withIssuerRefs: Set<OpaqueBytes> = emptySet()): List<StateAndRef<Cash.State>> {
+        val stateAndRefs = mutableListOf<StateAndRef<Cash.State>>()
+
+        for (retryCount in 1..MAX_RETRIES) {
+            if (!attemptSpend(services, amount, lockId, notary, onlyFromIssuerParties, withIssuerRefs, stateAndRefs)) {
+                log.warn("Coin selection failed on attempt $retryCount")
+                // TODO: revisit the back off strategy for contended spending.
+                if (retryCount != MAX_RETRIES) {
+                    stateAndRefs.clear()
+                    val durationMillis = (minOf(RETRY_SLEEP.shl(retryCount), RETRY_CAP / 2) * (1.0 + Math.random())).toInt()
+                    FlowLogic.sleep(durationMillis.millis)
+                } else {
+                    log.warn("Insufficient spendable states identified for $amount")
+                }
+            } else {
+                break
+            }
+        }
+        return stateAndRefs
+    }
+
+    private fun attemptSpend(services: ServiceHub, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, stateAndRefs: MutableList<StateAndRef<Cash.State>>): Boolean {
+        spendLock.withLock {
+            val connection = services.jdbcSession()
+            try {
+                // we select spendable states irrespective of lock but prioritised by unlocked ones (Eg. null)
+                // the softLockReserve update will detect whether we try to lock states locked by others
+                val rs = executeQuery(connection, amount, lockId, notary, onlyFromIssuerParties, withIssuerRefs)
+                stateAndRefs.clear()
+
+                var totalPennies = 0L
+                while (rs.next()) {
+                    val txHash = SecureHash.parse(rs.getString(1))
+                    val index = rs.getInt(2)
+                    val stateRef = StateRef(txHash, index)
+                    val state = rs.getBlob(3).deserialize<TransactionState<Cash.State>>(context = SerializationDefaults.STORAGE_CONTEXT)
+                    val pennies = rs.getLong(4)
+                    totalPennies = rs.getLong(5)
+                    val rowLockId = rs.getString(6)
+                    stateAndRefs.add(StateAndRef(state, stateRef))
+                    log.trace { "ROW: $rowLockId ($lockId): $stateRef : $pennies ($totalPennies)" }
+                }
+
+                if (stateAndRefs.isNotEmpty() && totalPennies >= amount.quantity) {
+                    // we should have a minimum number of states to satisfy our selection `amount` criteria
+                    log.trace("Coin selection for $amount retrieved ${stateAndRefs.count()} states totalling $totalPennies pennies: $stateAndRefs")
+
+                    // With the current single threaded state machine available states are guaranteed to lock.
+                    // TODO However, we will have to revisit these methods in the future multi-threaded.
+                    services.vaultService.softLockReserve(lockId, (stateAndRefs.map { it.ref }).toNonEmptySet())
+                    return true
+                }
+                log.trace("Coin selection requested $amount but retrieved $totalPennies pennies with state refs: ${stateAndRefs.map { it.ref }}")
+                // retry as more states may become available
+            } catch (e: SQLException) {
+                log.error("""Failed retrieving unconsumed states for: amount [$amount], onlyFromIssuerParties [$onlyFromIssuerParties], notary [$notary], lockId [$lockId]
+                            $e.
+                        """)
+            } catch (e: StatesNotAvailableException) { // Should never happen with single threaded state machine
+                log.warn(e.message)
+                // retry only if there are locked states that may become available again (or consumed with change)
+            }
+        }
+        return false
+    }
+}
\ No newline at end of file
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
index 82bc6ad763..5894eff73f 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2Impl.kt
@@ -1,28 +1,15 @@
 package net.corda.finance.contracts.asset.cash.selection
 
-import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.contracts.Amount
-import net.corda.core.contracts.StateAndRef
-import net.corda.core.contracts.StateRef
-import net.corda.core.contracts.TransactionState
-import net.corda.core.crypto.SecureHash
-import net.corda.core.flows.FlowLogic
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.Party
-import net.corda.core.node.ServiceHub
-import net.corda.core.node.services.StatesNotAvailableException
-import net.corda.core.serialization.SerializationDefaults
-import net.corda.core.serialization.deserialize
 import net.corda.core.utilities.*
-import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.CashSelection
+import java.sql.Connection
 import java.sql.DatabaseMetaData
-import java.sql.SQLException
+import java.sql.ResultSet
 import java.util.*
-import java.util.concurrent.locks.ReentrantLock
-import kotlin.concurrent.withLock
 
-class CashSelectionH2Impl : CashSelection {
+class CashSelectionH2Impl : AbstractCashSelection() {
 
     companion object {
         const val JDBC_DRIVER_NAME = "H2 JDBC Driver"
@@ -33,53 +20,8 @@ class CashSelectionH2Impl : CashSelection {
         return metadata.driverName == JDBC_DRIVER_NAME
     }
 
-    // coin selection retry loop counter, sleep (msecs) and lock for selecting states
-    private val MAX_RETRIES = 8
-    private val RETRY_SLEEP = 100
-    private val RETRY_CAP = 2000
-    private val spendLock: ReentrantLock = ReentrantLock()
+    override fun toString() = "${this::class.java} for $JDBC_DRIVER_NAME"
 
-    /**
-     * An optimised query to gather Cash states that are available and retry if they are temporarily unavailable.
-     * @param services The service hub to allow access to the database session
-     * @param amount The amount of currency desired (ignoring issues, but specifying the currency)
-     * @param onlyFromIssuerParties If empty the operation ignores the specifics of the issuer,
-     * otherwise the set of eligible states wil be filtered to only include those from these issuers.
-     * @param notary If null the notary source is ignored, if specified then only states marked
-     * with this notary are included.
-     * @param lockId The FlowLogic.runId.uuid of the flow, which is used to soft reserve the states.
-     * Also, previous outputs of the flow will be eligible as they are implicitly locked with this id until the flow completes.
-     * @param withIssuerRefs If not empty the specific set of issuer references to match against.
-     * @return The matching states that were found. If sufficient funds were found these will be locked,
-     * otherwise what is available is returned unlocked for informational purposes.
-     */
-    @Suspendable
-    override fun unconsumedCashStatesForSpending(services: ServiceHub,
-                                                 amount: Amount<Currency>,
-                                                 onlyFromIssuerParties: Set<AbstractParty>,
-                                                 notary: Party?,
-                                                 lockId: UUID,
-                                                 withIssuerRefs: Set<OpaqueBytes>): List<StateAndRef<Cash.State>> {
-
-        val stateAndRefs = mutableListOf<StateAndRef<Cash.State>>()
-
-        for (retryCount in 1..MAX_RETRIES) {
-            if (!attemptSpend(services, amount, lockId, notary, onlyFromIssuerParties, withIssuerRefs, stateAndRefs)) {
-                log.warn("Coin selection failed on attempt $retryCount")
-                // TODO: revisit the back off strategy for contended spending.
-                if (retryCount != MAX_RETRIES) {
-                    stateAndRefs.clear()
-                    val durationMillis = (minOf(RETRY_SLEEP.shl(retryCount), RETRY_CAP / 2) * (1.0 + Math.random())).toInt()
-                    FlowLogic.sleep(durationMillis.millis)
-                } else {
-                    log.warn("Insufficient spendable states identified for $amount")
-                }
-            } else {
-                break
-            }
-        }
-        return stateAndRefs
-    }
 
     //       We are using an H2 specific means of selecting a minimum set of rows that match a request amount of coins:
     //       1) There is no standard SQL mechanism of calculating a cumulative total on a field and restricting row selection on the
@@ -87,15 +29,11 @@ class CashSelectionH2Impl : CashSelection {
     //       2) H2 uses session variables to perform this accumulator function:
     //          http://www.h2database.com/html/functions.html#set
     //       3) H2 does not support JOIN's in FOR UPDATE (hence we are forced to execute 2 queries)
+    override fun executeQuery(connection: Connection, amount: Amount<Currency>, lockId: UUID, notary: Party?,
+                              onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>) : ResultSet {
+        connection.createStatement().execute("CALL SET(@t, 0);")
 
-    private fun attemptSpend(services: ServiceHub, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, stateAndRefs: MutableList<StateAndRef<Cash.State>>): Boolean {
-        val connection = services.jdbcSession()
-        spendLock.withLock {
-            val statement = connection.createStatement()
-            try {
-                statement.execute("CALL SET(@t, CAST(0 AS BIGINT));")
-
-                val selectJoin = """
+        val selectJoin = """
                     SELECT vs.transaction_id, vs.output_index, vs.contract_state, ccs.pennies, SET(@t, ifnull(@t,0)+ccs.pennies) total_pennies, vs.lock_id
                     FROM vault_states AS vs, contract_cash_states AS ccs
                     WHERE vs.transaction_id = ccs.transaction_id AND vs.output_index = ccs.output_index
@@ -103,65 +41,27 @@ class CashSelectionH2Impl : CashSelection {
                     AND ccs.ccy_code = ? and @t < ?
                     AND (vs.lock_id = ? OR vs.lock_id is null)
                     """ +
-                        (if (notary != null)
-                            " AND vs.notary_name = ?" else "") +
-                        (if (onlyFromIssuerParties.isNotEmpty())
-                            " AND ccs.issuer_key IN (?)" else "") +
-                        (if (withIssuerRefs.isNotEmpty())
-                            " AND ccs.issuer_ref IN (?)" else "")
+                (if (notary != null)
+                    " AND vs.notary_name = ?" else "") +
+                (if (onlyFromIssuerParties.isNotEmpty())
+                    " AND ccs.issuer_key IN (?)" else "") +
+                (if (withIssuerRefs.isNotEmpty())
+                    " AND ccs.issuer_ref IN (?)" else "")
 
-                // Use prepared statement for protection against SQL Injection (http://www.h2database.com/html/advanced.html#sql_injection)
-                val psSelectJoin = connection.prepareStatement(selectJoin)
-                var pIndex = 0
-                psSelectJoin.setString(++pIndex, amount.token.currencyCode)
-                psSelectJoin.setLong(++pIndex, amount.quantity)
-                psSelectJoin.setString(++pIndex, lockId.toString())
-                if (notary != null)
-                    psSelectJoin.setString(++pIndex, notary.name.toString())
-                if (onlyFromIssuerParties.isNotEmpty())
-                    psSelectJoin.setObject(++pIndex, onlyFromIssuerParties.map { it.owningKey.toBase58String() as Any}.toTypedArray() )
-                if (withIssuerRefs.isNotEmpty())
-                    psSelectJoin.setObject(++pIndex, withIssuerRefs.map { it.bytes.toHexString() as Any }.toTypedArray())
-                log.debug { psSelectJoin.toString() }
+        // Use prepared statement for protection against SQL Injection (http://www.h2database.com/html/advanced.html#sql_injection)
+        val psSelectJoin = connection.prepareStatement(selectJoin)
+        var pIndex = 0
+        psSelectJoin.setString(++pIndex, amount.token.currencyCode)
+        psSelectJoin.setLong(++pIndex, amount.quantity)
+        psSelectJoin.setString(++pIndex, lockId.toString())
+        if (notary != null)
+            psSelectJoin.setString(++pIndex, notary.name.toString())
+        if (onlyFromIssuerParties.isNotEmpty())
+            psSelectJoin.setObject(++pIndex, onlyFromIssuerParties.map { it.owningKey.toBase58String() as Any}.toTypedArray() )
+        if (withIssuerRefs.isNotEmpty())
+            psSelectJoin.setObject(++pIndex, withIssuerRefs.map { it.bytes.toHexString() as Any }.toTypedArray())
+        log.debug { psSelectJoin.toString() }
 
-                // Retrieve spendable state refs
-                val rs = psSelectJoin.executeQuery()
-                stateAndRefs.clear()
-                var totalPennies = 0L
-                while (rs.next()) {
-                    val txHash = SecureHash.parse(rs.getString(1))
-                    val index = rs.getInt(2)
-                    val stateRef = StateRef(txHash, index)
-                    val state = rs.getBytes(3).deserialize<TransactionState<Cash.State>>(context = SerializationDefaults.STORAGE_CONTEXT)
-                    val pennies = rs.getLong(4)
-                    totalPennies = rs.getLong(5)
-                    val rowLockId = rs.getString(6)
-                    stateAndRefs.add(StateAndRef(state, stateRef))
-                    log.trace { "ROW: $rowLockId ($lockId): $stateRef : $pennies ($totalPennies)" }
-                }
-
-                if (stateAndRefs.isNotEmpty() && totalPennies >= amount.quantity) {
-                    // we should have a minimum number of states to satisfy our selection `amount` criteria
-                    log.trace("Coin selection for $amount retrieved ${stateAndRefs.count()} states totalling $totalPennies pennies: $stateAndRefs")
-
-                    // With the current single threaded state machine available states are guaranteed to lock.
-                    // TODO However, we will have to revisit these methods in the future multi-threaded.
-                    services.vaultService.softLockReserve(lockId, (stateAndRefs.map { it.ref }).toNonEmptySet())
-                    return true
-                }
-                log.trace("Coin selection requested $amount but retrieved $totalPennies pennies with state refs: ${stateAndRefs.map { it.ref }}")
-                // retry as more states may become available
-            } catch (e: SQLException) {
-                log.error("""Failed retrieving unconsumed states for: amount [$amount], onlyFromIssuerParties [$onlyFromIssuerParties], notary [$notary], lockId [$lockId]
-                            $e.
-                        """)
-            } catch (e: StatesNotAvailableException) { // Should never happen with single threaded state machine
-                log.warn(e.message)
-                // retry only if there are locked states that may become available again (or consumed with change)
-            } finally {
-                statement.close()
-            }
-        }
-        return false
+        return psSelectJoin.executeQuery()
     }
 }
\ No newline at end of file
diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionMySQLImpl.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionMySQLImpl.kt
index 1a0eac0169..853ba23d07 100644
--- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionMySQLImpl.kt
+++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionMySQLImpl.kt
@@ -1,17 +1,15 @@
 package net.corda.finance.contracts.asset.cash.selection
 
 import net.corda.core.contracts.Amount
-import net.corda.core.contracts.StateAndRef
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.Party
-import net.corda.core.node.ServiceHub
 import net.corda.core.utilities.OpaqueBytes
-import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.CashSelection
+import java.sql.Connection
 import java.sql.DatabaseMetaData
+import java.sql.ResultSet
 import java.util.*
 
-class CashSelectionMySQLImpl : CashSelection {
+class CashSelectionMySQLImpl : AbstractCashSelection() {
 
     companion object {
         const val JDBC_DRIVER_NAME = "MySQL JDBC Driver"
@@ -21,12 +19,9 @@ class CashSelectionMySQLImpl : CashSelection {
         return metadata.driverName == JDBC_DRIVER_NAME
     }
 
-    override fun unconsumedCashStatesForSpending(services: ServiceHub,
-                                                 amount: Amount<Currency>,
-                                                 onlyFromIssuerParties: Set<AbstractParty>,
-                                                 notary: Party?,
-                                                 lockId: UUID,
-                                                 withIssuerRefs: Set<OpaqueBytes>): List<StateAndRef<Cash.State>> {
+    override fun executeQuery(statement: Connection, amount: Amount<Currency>, lockId: UUID, notary: Party?, issuerKeysStr: Set<AbstractParty>, issuerRefsStr: Set<OpaqueBytes>): ResultSet {
         TODO("MySQL cash selection not implemented")
     }
+
+    override fun toString() = "${this::class.java} for ${CashSelectionH2Impl.JDBC_DRIVER_NAME}"
 }
\ No newline at end of file
diff --git a/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt b/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt
index c978ded6f0..23b05a1e8f 100644
--- a/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt
+++ b/finance/src/main/kotlin/net/corda/finance/flows/CashExitFlow.kt
@@ -14,7 +14,7 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.ProgressTracker
 import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.CashSelection
+import net.corda.finance.contracts.asset.cash.selection.AbstractCashSelection
 import net.corda.finance.issuedBy
 import java.util.*
 
@@ -46,7 +46,7 @@ class CashExitFlow(private val amount: Amount<Currency>,
         progressTracker.currentStep = GENERATING_TX
         val builder = TransactionBuilder(notary = null)
         val issuer = ourIdentity.ref(issuerRef)
-        val exitStates = CashSelection
+        val exitStates = AbstractCashSelection
                 .getInstance { serviceHub.jdbcSession().metaData }
                 .unconsumedCashStatesForSpending(serviceHub, amount, setOf(issuer.party), builder.notary, builder.lockId, setOf(issuer.reference))
         val signers = try {
diff --git a/finance/src/main/resources/META-INF/services/net.corda.finance.contracts.asset.CashSelection b/finance/src/main/resources/META-INF/services/net.corda.finance.contracts.asset.cash.selection.AbstractCashSelection
similarity index 100%
rename from finance/src/main/resources/META-INF/services/net.corda.finance.contracts.asset.CashSelection
rename to finance/src/main/resources/META-INF/services/net.corda.finance.contracts.asset.cash.selection.AbstractCashSelection

From 83b908050241776a25ebc814e1e63c5dd342b3b6 Mon Sep 17 00:00:00 2001
From: mkit <michal.kit@evrythng.com>
Date: Mon, 16 Oct 2017 14:03:51 +0100
Subject: [PATCH 179/185] Adding an option to override the default isolation
 level on per transaction basis (#1886)

---
 .../corda/node/utilities/CordaPersistence.kt  | 32 ++++++++++++++++---
 1 file changed, 28 insertions(+), 4 deletions(-)

diff --git a/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt b/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
index b8fc4f333d..77055c6073 100644
--- a/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
+++ b/node/src/main/kotlin/net/corda/node/utilities/CordaPersistence.kt
@@ -40,10 +40,21 @@ class CordaPersistence(var dataSource: HikariDataSource, private val schemaServi
         }
     }
 
-    fun createTransaction(): DatabaseTransaction {
+    /**
+     * Creates an instance of [DatabaseTransaction], with the given isolation level.
+     * @param isolationLevel isolation level for the transaction. If not specified the default (i.e. provided at the creation time) is used.
+     */
+    fun createTransaction(isolationLevel: Int): DatabaseTransaction {
         // We need to set the database for the current [Thread] or [Fiber] here as some tests share threads across databases.
         DatabaseTransactionManager.dataSource = this
-        return DatabaseTransactionManager.currentOrNew(transactionIsolationLevel)
+        return DatabaseTransactionManager.currentOrNew(isolationLevel)
+    }
+
+    /**
+     * Creates an instance of [DatabaseTransaction], with the transaction isolation level specified at the creation time.
+     */
+    fun createTransaction(): DatabaseTransaction {
+        return createTransaction(transactionIsolationLevel)
     }
 
     fun createSession(): Connection {
@@ -53,9 +64,22 @@ class CordaPersistence(var dataSource: HikariDataSource, private val schemaServi
         return ctx?.connection ?: throw IllegalStateException("Was expecting to find database transaction: must wrap calling code within a transaction.")
     }
 
-    fun <T> transaction(statement: DatabaseTransaction.() -> T): T {
+    /**
+     * Executes given statement in the scope of transaction, with the given isolation level.
+     * @param isolationLevel isolation level for the transaction.
+     * @param statement to be executed in the scope of this transaction.
+     */
+    fun <T> transaction(isolationLevel: Int, statement: DatabaseTransaction.() -> T): T {
         DatabaseTransactionManager.dataSource = this
-        return transaction(transactionIsolationLevel, 3, statement)
+        return transaction(isolationLevel, 3, statement)
+    }
+
+    /**
+     * Executes given statement in the scope of transaction with the transaction level specified at the creation time.
+     * @param statement to be executed in the scope of this transaction.
+     */
+    fun <T> transaction(statement: DatabaseTransaction.() -> T): T {
+        return transaction(transactionIsolationLevel, statement)
     }
 
     private fun <T> transaction(transactionIsolation: Int, repetitionAttempts: Int, statement: DatabaseTransaction.() -> T): T {

From ead805fb218b766035f4c05c84ec2954ad5ca857 Mon Sep 17 00:00:00 2001
From: Christian Sailer <christian.sailer@r3.com>
Date: Mon, 16 Oct 2017 14:32:16 +0100
Subject: [PATCH 180/185] Make it handle whitespace in paths correctly (needs
 to be URL decoded)

---
 .../com/r3/corda/signing/configuration/ConfigurationTest.kt   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/signing-server/src/test/kotlin/com/r3/corda/signing/configuration/ConfigurationTest.kt b/signing-server/src/test/kotlin/com/r3/corda/signing/configuration/ConfigurationTest.kt
index 979033a086..385049b23b 100644
--- a/signing-server/src/test/kotlin/com/r3/corda/signing/configuration/ConfigurationTest.kt
+++ b/signing-server/src/test/kotlin/com/r3/corda/signing/configuration/ConfigurationTest.kt
@@ -8,8 +8,8 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class ConfigurationTest {
-    private val validConfigPath = File(javaClass.getResource("/signing_service.conf").path).absolutePath
-    private val invalidConfigPath = File(javaClass.getResource("/signing_service_fail.conf").path).absolutePath
+    private val validConfigPath = File(java.net.URLDecoder.decode(javaClass.getResource("/signing_service.conf").path, "UTF-8")).absolutePath
+    private val invalidConfigPath = File(java.net.URLDecoder.decode(javaClass.getResource("/signing_service_fail.conf").path, "UTF-8")).absolutePath
 
     @Test
     fun `authMode is parsed correctly`() {

From d8462ad6628410b832c72e638bf3a0c29fec4bda Mon Sep 17 00:00:00 2001
From: Christian Sailer <christian.sailer@r3.com>
Date: Mon, 16 Oct 2017 14:36:43 +0100
Subject: [PATCH 181/185] Make it handle whitespace in paths correctly - even
 better by using toURI()

---
 .idea/compiler.xml                                            | 3 +++
 .../com/r3/corda/signing/configuration/ConfigurationTest.kt   | 4 ++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index 25abc91c93..1d5e5c9c1f 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -99,6 +99,9 @@
       <module name="sgx-jvm_test" target="1.8" />
       <module name="sgx-signtool_main" target="1.8" />
       <module name="sgx-signtool_test" target="1.8" />
+      <module name="signing-server_integrationTest" target="1.8" />
+      <module name="signing-server_main" target="1.8" />
+      <module name="signing-server_test" target="1.8" />
       <module name="simm-valuation-demo_integrationTest" target="1.8" />
       <module name="simm-valuation-demo_main" target="1.8" />
       <module name="simm-valuation-demo_test" target="1.8" />
diff --git a/signing-server/src/test/kotlin/com/r3/corda/signing/configuration/ConfigurationTest.kt b/signing-server/src/test/kotlin/com/r3/corda/signing/configuration/ConfigurationTest.kt
index 385049b23b..7883e13ba7 100644
--- a/signing-server/src/test/kotlin/com/r3/corda/signing/configuration/ConfigurationTest.kt
+++ b/signing-server/src/test/kotlin/com/r3/corda/signing/configuration/ConfigurationTest.kt
@@ -8,8 +8,8 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class ConfigurationTest {
-    private val validConfigPath = File(java.net.URLDecoder.decode(javaClass.getResource("/signing_service.conf").path, "UTF-8")).absolutePath
-    private val invalidConfigPath = File(java.net.URLDecoder.decode(javaClass.getResource("/signing_service_fail.conf").path, "UTF-8")).absolutePath
+    private val validConfigPath = File(javaClass.getResource("/signing_service.conf").toURI()).absolutePath
+    private val invalidConfigPath = File(javaClass.getResource("/signing_service_fail.conf").toURI()).absolutePath
 
     @Test
     fun `authMode is parsed correctly`() {

From d3e8df1644d84f9505452e65a219c0c67eb12b48 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Mon, 16 Oct 2017 14:39:28 +0100
Subject: [PATCH 182/185] Separates out the tutorial code into separate docs to
 ensure it compiles.

---
 .../java/tutorial/helloworld/IOUContract.java |  46 +++++
 .../java/tutorial/helloworld/IOUFlow.java     |  68 ++++++++
 .../java/tutorial/helloworld/IOUState.java    |  39 +++++
 .../java/tutorial/twoparty/IOUContract.java   |  50 ++++++
 .../docs/java/tutorial/twoparty/IOUFlow.java  |  82 +++++++++
 .../tutorial/twoparty/IOUFlowResponder.java   |  47 +++++
 .../docs/java/tutorial/twoparty/IOUState.java |  37 ++++
 .../docs/tutorial/helloworld/contract.kt      |  33 ++++
 .../corda/docs/tutorial/helloworld/flow.kt    |  52 ++++++
 .../corda/docs/tutorial/helloworld/state.kt   |  12 ++
 .../corda/docs/tutorial/twoparty/contract.kt  |  36 ++++
 .../net/corda/docs/tutorial/twoparty/flow.kt  |  57 ++++++
 .../docs/tutorial/twoparty/flowResponder.kt   |  30 ++++
 .../net/corda/docs/tutorial/twoparty/state.kt |  10 ++
 docs/source/hello-world-contract.rst          |  81 +--------
 docs/source/hello-world-flow.rst              | 128 ++------------
 docs/source/hello-world-running.rst           |  74 ++++----
 docs/source/hello-world-state.rst             |  54 +-----
 docs/source/hello-world-template.rst          |  11 +-
 docs/source/tut-two-party-contract.rst        |  40 +++--
 docs/source/tut-two-party-flow.rst            | 165 +++---------------
 docs/source/tut-two-party-introduction.rst    |   2 +-
 22 files changed, 720 insertions(+), 434 deletions(-)
 create mode 100644 docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUContract.java
 create mode 100644 docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUFlow.java
 create mode 100644 docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUState.java
 create mode 100644 docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUContract.java
 create mode 100644 docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUFlow.java
 create mode 100644 docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUFlowResponder.java
 create mode 100644 docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUState.java
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/contract.kt
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/flow.kt
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/state.kt
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/contract.kt
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/flow.kt
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/flowResponder.kt
 create mode 100644 docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/state.kt

diff --git a/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUContract.java b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUContract.java
new file mode 100644
index 0000000000..3023396e81
--- /dev/null
+++ b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUContract.java
@@ -0,0 +1,46 @@
+package net.corda.docs.java.tutorial.helloworld;
+
+// DOCSTART 01
+import net.corda.core.contracts.CommandData;
+import net.corda.core.contracts.CommandWithParties;
+import net.corda.core.contracts.Contract;
+import net.corda.core.identity.Party;
+import net.corda.core.transactions.LedgerTransaction;
+
+import java.security.PublicKey;
+import java.util.List;
+
+import static net.corda.core.contracts.ContractsDSL.requireSingleCommand;
+import static net.corda.core.contracts.ContractsDSL.requireThat;
+
+public class IOUContract implements Contract {
+    // Our Create command.
+    public static class Create implements CommandData {
+    }
+
+    @Override
+    public void verify(LedgerTransaction tx) {
+        final CommandWithParties<Create> command = requireSingleCommand(tx.getCommands(), Create.class);
+
+        requireThat(check -> {
+            // Constraints on the shape of the transaction.
+            check.using("No inputs should be consumed when issuing an IOU.", tx.getInputs().isEmpty());
+            check.using("There should be one output state of type IOUState.", tx.getOutputs().size() == 1);
+
+            // IOU-specific constraints.
+            final IOUState out = tx.outputsOfType(IOUState.class).get(0);
+            final Party lender = out.getLender();
+            final Party borrower = out.getBorrower();
+            check.using("The IOU's value must be non-negative.", out.getValue() > 0);
+            check.using("The lender and the borrower cannot be the same entity.", lender != borrower);
+
+            // Constraints on the signers.
+            final List<PublicKey> signers = command.getSigners();
+            check.using("There must only be one signer.", signers.size() == 1);
+            check.using("The signer must be the lender.", signers.contains(lender.getOwningKey()));
+
+            return null;
+        });
+    }
+}
+// DOCEND 01
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUFlow.java b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUFlow.java
new file mode 100644
index 0000000000..5b2d5d47f4
--- /dev/null
+++ b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUFlow.java
@@ -0,0 +1,68 @@
+package net.corda.docs.java.tutorial.helloworld;
+
+// DOCSTART 01
+import co.paralleluniverse.fibers.Suspendable;
+import net.corda.core.contracts.Command;
+import net.corda.core.contracts.StateAndContract;
+import net.corda.core.flows.*;
+import net.corda.core.identity.Party;
+import net.corda.core.transactions.SignedTransaction;
+import net.corda.core.transactions.TransactionBuilder;
+import net.corda.core.utilities.ProgressTracker;
+
+@InitiatingFlow
+@StartableByRPC
+public class IOUFlow extends FlowLogic<Void> {
+    private final Integer iouValue;
+    private final Party otherParty;
+
+    /**
+     * The progress tracker provides checkpoints indicating the progress of the flow to observers.
+     */
+    private final ProgressTracker progressTracker = new ProgressTracker();
+
+    public IOUFlow(Integer iouValue, Party otherParty) {
+        this.iouValue = iouValue;
+        this.otherParty = otherParty;
+    }
+
+    @Override
+    public ProgressTracker getProgressTracker() {
+        return progressTracker;
+    }
+
+    /**
+     * The flow logic is encapsulated within the call() method.
+     */
+    @Suspendable
+    @Override
+    public Void call() throws FlowException {
+        // We retrieve the notary identity from the network map.
+        final Party notary = getServiceHub().getNetworkMapCache().getNotaryIdentities().get(0);
+
+        // We create a transaction builder.
+        final TransactionBuilder txBuilder = new TransactionBuilder();
+        txBuilder.setNotary(notary);
+
+        // We create the transaction components.
+        IOUState outputState = new IOUState(iouValue, getOurIdentity(), otherParty);
+        String outputContract = IOUContract.class.getName();
+        StateAndContract outputContractAndState = new StateAndContract(outputState, outputContract);
+        Command cmd = new Command<>(new IOUContract.Create(), getOurIdentity().getOwningKey());
+
+        // We add the items to the builder.
+        txBuilder.withItems(outputContractAndState, cmd);
+
+        // Verifying the transaction.
+        txBuilder.verify(getServiceHub());
+
+        // Signing the transaction.
+        final SignedTransaction signedTx = getServiceHub().signInitialTransaction(txBuilder);
+
+        // Finalising the transaction.
+        subFlow(new FinalityFlow(signedTx));
+
+        return null;
+    }
+}
+// DOCEND 01
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUState.java b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUState.java
new file mode 100644
index 0000000000..977457fd29
--- /dev/null
+++ b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUState.java
@@ -0,0 +1,39 @@
+package net.corda.docs.java.tutorial.helloworld;
+
+// DOCSTART 01
+import com.google.common.collect.ImmutableList;
+import net.corda.core.contracts.ContractState;
+import net.corda.core.identity.AbstractParty;
+import net.corda.core.identity.Party;
+
+import java.util.List;
+
+public class IOUState implements ContractState {
+    private final int value;
+    private final Party lender;
+    private final Party borrower;
+
+    public IOUState(int value, Party lender, Party borrower) {
+        this.value = value;
+        this.lender = lender;
+        this.borrower = borrower;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public Party getLender() {
+        return lender;
+    }
+
+    public Party getBorrower() {
+        return borrower;
+    }
+
+    @Override
+    public List<AbstractParty> getParticipants() {
+        return ImmutableList.of(lender, borrower);
+    }
+}
+// DOCEND 01
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUContract.java b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUContract.java
new file mode 100644
index 0000000000..bcf8dded07
--- /dev/null
+++ b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUContract.java
@@ -0,0 +1,50 @@
+package net.corda.docs.java.tutorial.twoparty;
+
+// DOCSTART 01
+import com.google.common.collect.ImmutableList;
+import net.corda.core.contracts.CommandData;
+import net.corda.core.contracts.CommandWithParties;
+import net.corda.core.contracts.Contract;
+import net.corda.core.identity.Party;
+import net.corda.core.transactions.LedgerTransaction;
+
+import java.security.PublicKey;
+import java.util.List;
+
+import static net.corda.core.contracts.ContractsDSL.requireSingleCommand;
+import static net.corda.core.contracts.ContractsDSL.requireThat;
+// DOCEND 01
+
+public class IOUContract implements Contract {
+    // Our Create command.
+    public static class Create implements CommandData {
+    }
+
+    @Override
+    public void verify(LedgerTransaction tx) {
+        final CommandWithParties<net.corda.docs.java.tutorial.helloworld.IOUContract.Create> command = requireSingleCommand(tx.getCommands(), net.corda.docs.java.tutorial.helloworld.IOUContract.Create.class);
+
+        requireThat(check -> {
+            // Constraints on the shape of the transaction.
+            check.using("No inputs should be consumed when issuing an IOU.", tx.getInputs().isEmpty());
+            check.using("There should be one output state of type IOUState.", tx.getOutputs().size() == 1);
+
+            // IOU-specific constraints.
+            final IOUState out = tx.outputsOfType(IOUState.class).get(0);
+            final Party lender = out.getLender();
+            final Party borrower = out.getBorrower();
+            check.using("The IOU's value must be non-negative.", out.getValue() > 0);
+            check.using("The lender and the borrower cannot be the same entity.", lender != borrower);
+
+            // DOCSTART 02
+            // Constraints on the signers.
+            final List<PublicKey> signers = command.getSigners();
+            check.using("There must be two signers.", signers.size() == 2);
+            check.using("The borrower and lender must be signers.", signers.containsAll(
+                    ImmutableList.of(borrower.getOwningKey(), lender.getOwningKey())));
+            // DOCEND 02
+
+            return null;
+        });
+    }
+}
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUFlow.java b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUFlow.java
new file mode 100644
index 0000000000..4e0533d323
--- /dev/null
+++ b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUFlow.java
@@ -0,0 +1,82 @@
+package net.corda.docs.java.tutorial.twoparty;
+
+// DOCSTART 01
+import co.paralleluniverse.fibers.Suspendable;
+import com.google.common.collect.ImmutableList;
+import net.corda.core.contracts.Command;
+import net.corda.core.contracts.StateAndContract;
+import net.corda.core.flows.*;
+import net.corda.core.identity.Party;
+import net.corda.core.transactions.SignedTransaction;
+import net.corda.core.transactions.TransactionBuilder;
+import net.corda.core.utilities.ProgressTracker;
+
+import java.security.PublicKey;
+import java.util.List;
+// DOCEND 01
+
+@InitiatingFlow
+@StartableByRPC
+public class IOUFlow extends FlowLogic<Void> {
+    private final Integer iouValue;
+    private final Party otherParty;
+
+    /**
+     * The progress tracker provides checkpoints indicating the progress of the flow to observers.
+     */
+    private final ProgressTracker progressTracker = new ProgressTracker();
+
+    public IOUFlow(Integer iouValue, Party otherParty) {
+        this.iouValue = iouValue;
+        this.otherParty = otherParty;
+    }
+
+    @Override
+    public ProgressTracker getProgressTracker() {
+        return progressTracker;
+    }
+
+    /**
+     * The flow logic is encapsulated within the call() method.
+     */
+    @Suspendable
+    @Override
+    public Void call() throws FlowException {
+        // We retrieve the notary identity from the network map.
+        final Party notary = getServiceHub().getNetworkMapCache().getNotaryIdentities().get(0);
+
+        // We create a transaction builder.
+        final TransactionBuilder txBuilder = new TransactionBuilder();
+        txBuilder.setNotary(notary);
+
+        // DOCSTART 02
+        // We create the transaction components.
+        IOUState outputState = new IOUState(iouValue, getOurIdentity(), otherParty);
+        String outputContract = IOUContract.class.getName();
+        StateAndContract outputContractAndState = new StateAndContract(outputState, outputContract);
+        List<PublicKey> requiredSigners = ImmutableList.of(getOurIdentity().getOwningKey(), otherParty.getOwningKey());
+        Command cmd = new Command<>(new IOUContract.Create(), requiredSigners);
+
+        // We add the items to the builder.
+        txBuilder.withItems(outputContractAndState, cmd);
+
+        // Verifying the transaction.
+        txBuilder.verify(getServiceHub());
+
+        // Signing the transaction.
+        final SignedTransaction signedTx = getServiceHub().signInitialTransaction(txBuilder);
+
+        // Creating a session with the other party.
+        FlowSession otherpartySession = initiateFlow(otherParty);
+
+        // Obtaining the counterparty's signature.
+        SignedTransaction fullySignedTx = subFlow(new CollectSignaturesFlow(
+                signedTx, ImmutableList.of(otherpartySession), CollectSignaturesFlow.tracker()));
+
+        // Finalising the transaction.
+        subFlow(new FinalityFlow(fullySignedTx));
+
+        return null;
+        // DOCEND 02
+    }
+}
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUFlowResponder.java b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUFlowResponder.java
new file mode 100644
index 0000000000..ac1f312ab6
--- /dev/null
+++ b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUFlowResponder.java
@@ -0,0 +1,47 @@
+package net.corda.docs.java.tutorial.twoparty;
+
+// DOCSTART 01
+import co.paralleluniverse.fibers.Suspendable;
+import net.corda.core.contracts.ContractState;
+import net.corda.core.flows.*;
+import net.corda.core.transactions.SignedTransaction;
+import net.corda.core.utilities.ProgressTracker;
+import net.corda.docs.java.tutorial.helloworld.IOUFlow;
+import net.corda.docs.java.tutorial.helloworld.IOUState;
+
+import static net.corda.core.contracts.ContractsDSL.requireThat;
+
+@InitiatedBy(IOUFlow.class)
+public class IOUFlowResponder extends FlowLogic<Void> {
+    private final FlowSession otherPartySession;
+
+    public IOUFlowResponder(FlowSession otherPartySession) {
+        this.otherPartySession = otherPartySession;
+    }
+
+    @Suspendable
+    @Override
+    public Void call() throws FlowException {
+        class SignTxFlow extends SignTransactionFlow {
+            private SignTxFlow(FlowSession otherPartySession, ProgressTracker progressTracker) {
+                super(otherPartySession, progressTracker);
+            }
+
+            @Override
+            protected void checkTransaction(SignedTransaction stx) {
+                requireThat(require -> {
+                    ContractState output = stx.getTx().getOutputs().get(0).getData();
+                    require.using("This must be an IOU transaction.", output instanceof IOUState);
+                    IOUState iou = (IOUState) output;
+                    require.using("The IOU's value can't be too high.", iou.getValue() < 100);
+                    return null;
+                });
+            }
+        }
+
+        subFlow(new SignTxFlow(otherPartySession, SignTransactionFlow.Companion.tracker()));
+
+        return null;
+    }
+}
+// DOCEND 01
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUState.java b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUState.java
new file mode 100644
index 0000000000..4cc6f9f76c
--- /dev/null
+++ b/docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUState.java
@@ -0,0 +1,37 @@
+package net.corda.docs.java.tutorial.twoparty;
+
+import com.google.common.collect.ImmutableList;
+import net.corda.core.contracts.ContractState;
+import net.corda.core.identity.AbstractParty;
+import net.corda.core.identity.Party;
+
+import java.util.List;
+
+public class IOUState implements ContractState {
+    private final int value;
+    private final Party lender;
+    private final Party borrower;
+
+    public IOUState(int value, Party lender, Party borrower) {
+        this.value = value;
+        this.lender = lender;
+        this.borrower = borrower;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public Party getLender() {
+        return lender;
+    }
+
+    public Party getBorrower() {
+        return borrower;
+    }
+
+    @Override
+    public List<AbstractParty> getParticipants() {
+        return ImmutableList.of(lender, borrower);
+    }
+}
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/contract.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/contract.kt
new file mode 100644
index 0000000000..39f00d60ea
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/contract.kt
@@ -0,0 +1,33 @@
+package net.corda.docs.tutorial.helloworld
+
+// DOCSTART 01
+import net.corda.core.contracts.CommandData
+import net.corda.core.contracts.Contract
+import net.corda.core.contracts.requireSingleCommand
+import net.corda.core.contracts.requireThat
+import net.corda.core.transactions.LedgerTransaction
+
+class IOUContract : Contract {
+    // Our Create command.
+    class Create : CommandData
+
+    override fun verify(tx: LedgerTransaction) {
+        val command = tx.commands.requireSingleCommand<Create>()
+
+        requireThat {
+            // Constraints on the shape of the transaction.
+            "No inputs should be consumed when issuing an IOU." using (tx.inputs.isEmpty())
+            "There should be one output state of type IOUState." using (tx.outputs.size == 1)
+
+            // IOU-specific constraints.
+            val out = tx.outputsOfType<IOUState>().single()
+            "The IOU's value must be non-negative." using (out.value > 0)
+            "The lender and the borrower cannot be the same entity." using (out.lender != out.borrower)
+
+            // Constraints on the signers.
+            "There must only be one signer." using (command.signers.toSet().size == 1)
+            "The signer must be the lender." using (command.signers.contains(out.lender.owningKey))
+        }
+    }
+}
+// DOCEND 01
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/flow.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/flow.kt
new file mode 100644
index 0000000000..7bb068cba5
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/flow.kt
@@ -0,0 +1,52 @@
+package net.corda.docs.tutorial.helloworld
+
+// DOCSTART 01
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.contracts.Command
+import net.corda.core.contracts.StateAndContract
+import net.corda.core.flows.FinalityFlow
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.InitiatingFlow
+import net.corda.core.flows.StartableByRPC
+import net.corda.core.identity.Party
+import net.corda.core.transactions.TransactionBuilder
+import net.corda.core.utilities.ProgressTracker
+import kotlin.reflect.jvm.jvmName
+
+@InitiatingFlow
+@StartableByRPC
+class IOUFlow(val iouValue: Int,
+              val otherParty: Party) : FlowLogic<Unit>() {
+
+    /** The progress tracker provides checkpoints indicating the progress of the flow to observers. */
+    override val progressTracker = ProgressTracker()
+
+    /** The flow logic is encapsulated within the call() method. */
+    @Suspendable
+    override fun call() {
+        // We retrieve the notary identity from the network map.
+        val notary = serviceHub.networkMapCache.notaryIdentities[0]
+
+        // We create a transaction builder
+        val txBuilder = TransactionBuilder(notary = notary)
+
+        // We create the transaction components.
+        val outputState = IOUState(iouValue, ourIdentity, otherParty)
+        val outputContract = IOUContract::class.jvmName
+        val outputContractAndState = StateAndContract(outputState, outputContract)
+        val cmd = Command(IOUContract.Create(), ourIdentity.owningKey)
+
+        // We add the items to the builder.
+        txBuilder.withItems(outputContractAndState, cmd)
+
+        // Verifying the transaction.
+        txBuilder.verify(serviceHub)
+
+        // Signing the transaction.
+        val signedTx = serviceHub.signInitialTransaction(txBuilder)
+
+        // Finalising the transaction.
+        subFlow(FinalityFlow(signedTx))
+    }
+}
+// DOCEND 01
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/state.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/state.kt
new file mode 100644
index 0000000000..447265a2ae
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/state.kt
@@ -0,0 +1,12 @@
+package net.corda.docs.tutorial.helloworld
+
+// DOCSTART 01
+import net.corda.core.contracts.ContractState
+import net.corda.core.identity.Party
+
+class IOUState(val value: Int,
+               val lender: Party,
+               val borrower: Party) : ContractState {
+    override val participants get() = listOf(lender, borrower)
+}
+// DOCEND 01
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/contract.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/contract.kt
new file mode 100644
index 0000000000..25b5b3f6a1
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/contract.kt
@@ -0,0 +1,36 @@
+package net.corda.docs.tutorial.twoparty
+
+// DOCSTART 01
+import net.corda.core.contracts.CommandData
+import net.corda.core.contracts.Contract
+import net.corda.core.contracts.requireSingleCommand
+import net.corda.core.contracts.requireThat
+import net.corda.core.transactions.LedgerTransaction
+// DOCEND 01
+
+class IOUContract : Contract {
+    // Our Create command.
+    class Create : CommandData
+
+    override fun verify(tx: LedgerTransaction) {
+        val command = tx.commands.requireSingleCommand<Create>()
+
+        requireThat {
+            // Constraints on the shape of the transaction.
+            "No inputs should be consumed when issuing an IOU." using (tx.inputs.isEmpty())
+            "There should be one output state of type IOUState." using (tx.outputs.size == 1)
+
+            // IOU-specific constraints.
+            val out = tx.outputsOfType<net.corda.docs.tutorial.helloworld.IOUState>().single()
+            "The IOU's value must be non-negative." using (out.value > 0)
+            "The lender and the borrower cannot be the same entity." using (out.lender != out.borrower)
+
+            // DOCSTART 02
+            // Constraints on the signers.
+            "There must be two signers." using (command.signers.toSet().size == 2)
+            "The borrower and lender must be signers." using (command.signers.containsAll(listOf(
+                    out.borrower.owningKey, out.lender.owningKey)))
+            // DOCEND 02
+        }
+    }
+}
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/flow.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/flow.kt
new file mode 100644
index 0000000000..0d8ac221ad
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/flow.kt
@@ -0,0 +1,57 @@
+package net.corda.docs.tutorial.twoparty
+
+// DOCSTART 01
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.contracts.Command
+import net.corda.core.contracts.StateAndContract
+import net.corda.core.flows.*
+import net.corda.core.identity.Party
+import net.corda.core.transactions.TransactionBuilder
+import net.corda.core.utilities.ProgressTracker
+import kotlin.reflect.jvm.jvmName
+// DOCEND 01
+
+@InitiatingFlow
+@StartableByRPC
+class IOUFlow(val iouValue: Int,
+              val otherParty: Party) : FlowLogic<Unit>() {
+
+    /** The progress tracker provides checkpoints indicating the progress of the flow to observers. */
+    override val progressTracker = ProgressTracker()
+
+    /** The flow logic is encapsulated within the call() method. */
+    @Suspendable
+    override fun call() {
+        // We retrieve the notary identity from the network map.
+        val notary = serviceHub.networkMapCache.notaryIdentities[0]
+
+        // We create a transaction builder
+        val txBuilder = TransactionBuilder(notary = notary)
+
+        // DOCSTART 02
+        // We create the transaction components.
+        val outputState = IOUState(iouValue, ourIdentity, otherParty)
+        val outputContract = IOUContract::class.jvmName
+        val outputContractAndState = StateAndContract(outputState, outputContract)
+        val cmd = Command(IOUContract.Create(), listOf(ourIdentity.owningKey, otherParty.owningKey))
+
+        // We add the items to the builder.
+        txBuilder.withItems(outputContractAndState, cmd)
+
+        // Verifying the transaction.
+        txBuilder.verify(serviceHub)
+
+        // Signing the transaction.
+        val signedTx = serviceHub.signInitialTransaction(txBuilder)
+
+        // Creating a session with the other party.
+        val otherpartySession = initiateFlow(otherParty)
+
+        // Obtaining the counterparty's signature.
+        val fullySignedTx = subFlow(CollectSignaturesFlow(signedTx, listOf(otherpartySession), CollectSignaturesFlow.tracker()))
+
+        // Finalising the transaction.
+        subFlow(FinalityFlow(fullySignedTx))
+        // DOCEND 02
+    }
+}
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/flowResponder.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/flowResponder.kt
new file mode 100644
index 0000000000..b8007cc2ec
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/flowResponder.kt
@@ -0,0 +1,30 @@
+package net.corda.docs.tutorial.twoparty
+
+// DOCSTART 01
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.contracts.requireThat
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.FlowSession
+import net.corda.core.flows.InitiatedBy
+import net.corda.core.flows.SignTransactionFlow
+import net.corda.core.transactions.SignedTransaction
+import net.corda.docs.tutorial.helloworld.IOUFlow
+import net.corda.docs.tutorial.helloworld.IOUState
+
+@InitiatedBy(IOUFlow::class)
+class IOUFlowResponder(val otherPartySession: FlowSession) : FlowLogic<Unit>() {
+    @Suspendable
+    override fun call() {
+        val signTransactionFlow = object : SignTransactionFlow(otherPartySession, SignTransactionFlow.tracker()) {
+            override fun checkTransaction(stx: SignedTransaction) = requireThat {
+                val output = stx.tx.outputs.single().data
+                "This must be an IOU transaction." using (output is IOUState)
+                val iou = output as IOUState
+                "The IOU's value can't be too high." using (iou.value < 100)
+            }
+        }
+
+        subFlow(signTransactionFlow)
+    }
+}
+// DOCEND 01
\ No newline at end of file
diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/state.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/state.kt
new file mode 100644
index 0000000000..a690625d65
--- /dev/null
+++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/state.kt
@@ -0,0 +1,10 @@
+package net.corda.docs.tutorial.twoparty
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.identity.Party
+
+class IOUState(val value: Int,
+               val lender: Party,
+               val borrower: Party) : ContractState {
+    override val participants get() = listOf(lender, borrower)
+}
\ No newline at end of file
diff --git a/docs/source/hello-world-contract.rst b/docs/source/hello-world-contract.rst
index 7e367ff7eb..05ceaace01 100644
--- a/docs/source/hello-world-contract.rst
+++ b/docs/source/hello-world-contract.rst
@@ -78,80 +78,15 @@ Let's write a contract that enforces these constraints. We'll do this by modifyi
 
 .. container:: codeset
 
-    .. code-block:: kotlin
+    .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/contract.kt
+        :language: kotlin
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
-        ...
-
-        import net.corda.core.contracts.*
-
-        ...
-
-        class IOUContract : Contract {
-            // Our Create command.
-            class Create : CommandData
-
-            override fun verify(tx: LedgerTransaction) {
-                val command = tx.commands.requireSingleCommand<Create>()
-
-                requireThat {
-                    // Constraints on the shape of the transaction.
-                    "No inputs should be consumed when issuing an IOU." using (tx.inputs.isEmpty())
-                    "There should be one output state of type IOUState." using (tx.outputs.size == 1)
-
-                    // IOU-specific constraints.
-                    val out = tx.outputs.single().data as IOUState
-                    "The IOU's value must be non-negative." using (out.value > 0)
-                    "The lender and the borrower cannot be the same entity." using (out.lender != out.borrower)
-
-                    // Constraints on the signers.
-                    "There must only be one signer." using (command.signers.toSet().size == 1)
-                    "The signer must be the lender." using (command.signers.contains(out.lender.owningKey))
-                }
-            }
-        }
-
-    .. code-block:: java
-
-        package com.template.contract;
-
-        import com.template.state.IOUState;
-        import net.corda.core.contracts.CommandWithParties;
-        import net.corda.core.contracts.CommandData;
-        import net.corda.core.contracts.Contract;
-        import net.corda.core.transactions.LedgerTransaction;
-        import net.corda.core.identity.Party;
-
-        import static net.corda.core.contracts.ContractsDSL.requireSingleCommand;
-        import static net.corda.core.contracts.ContractsDSL.requireThat;
-
-        public class IOUContract implements Contract {
-            // Our Create command.
-            public static class Create implements CommandData {}
-
-            @Override
-            public void verify(LedgerTransaction tx) {
-                final CommandWithParties<Create> command = requireSingleCommand(tx.getCommands(), Create.class);
-
-                requireThat(check -> {
-                    // Constraints on the shape of the transaction.
-                    check.using("No inputs should be consumed when issuing an IOU.", tx.getInputs().isEmpty());
-                    check.using("There should be one output state of type IOUState.", tx.getOutputs().size() == 1);
-
-                    // IOU-specific constraints.
-                    final IOUState out = (IOUState) tx.getOutputs().get(0).getData();
-                    final Party lender = out.getLender();
-                    final Party borrower = out.getBorrower();
-                    check.using("The IOU's value must be non-negative.",out.getValue() > 0);
-                    check.using("The lender and the borrower cannot be the same entity.", lender != borrower);
-
-                    // Constraints on the signers.
-                    check.using("There must only be one signer.", command.getSigners().size() == 1);
-                    check.using("The signer must be the lender.", command.getSigners().contains(lender.getOwningKey()));
-
-                    return null;
-                });
-            }
-        }
+    .. literalinclude:: example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUContract.java
+        :language: java
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
 If you're following along in Java, you'll also need to rename ``TemplateContract.java`` to ``IOUContract.java``.
 
diff --git a/docs/source/hello-world-flow.rst b/docs/source/hello-world-flow.rst
index 351888fd0a..bedcf6842a 100644
--- a/docs/source/hello-world-flow.rst
+++ b/docs/source/hello-world-flow.rst
@@ -33,128 +33,20 @@ FlowLogic
 Flows are implemented as ``FlowLogic`` subclasses. You define the steps taken by the flow by overriding
 ``FlowLogic.call``.
 
-We'll write our flow in either ``TemplateFlow.java`` or ``App.kt``. Overwrite both the existing flows in the template
-with the following:
+We'll write our flow in either ``TemplateFlow.java`` or ``App.kt``. Delete both the existing flows in the template, and
+replace them with the following:
 
 .. container:: codeset
 
-    .. code-block:: kotlin
+    .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/flow.kt
+        :language: kotlin
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
-        ...
-
-        import net.corda.core.utilities.ProgressTracker
-        import net.corda.core.transactions.TransactionBuilder
-        import net.corda.core.flows.*
-
-        ...
-
-        @InitiatingFlow
-        @StartableByRPC
-        class IOUFlow(val iouValue: Int,
-                      val otherParty: Party) : FlowLogic<Unit>() {
-
-            /** The progress tracker provides checkpoints indicating the progress of the flow to observers. */
-            override val progressTracker = ProgressTracker()
-
-            /** The flow logic is encapsulated within the call() method. */
-            @Suspendable
-            override fun call() {
-                // We retrieve the notary identity from the network map.
-                val notary = serviceHub.networkMapCache.notaryIdentities[0]
-
-                // We create a transaction builder
-                val txBuilder = TransactionBuilder(notary = notary)
-
-                // We create the transaction components.
-                val outputState = IOUState(iouValue, ourIdentity, otherParty)
-                val outputContract = IOUContract::class.jvmName
-                val outputContractAndState = StateAndContract(outputState, outputContract)
-                val cmd = Command(IOUContract.Create(), ourIdentity.owningKey)
-
-                // We add the items to the builder.
-                txBuilder.withItems(outputContractAndState, cmd)
-
-                // Verifying the transaction.
-                txBuilder.verify(serviceHub)
-
-                // Signing the transaction.
-                val signedTx = serviceHub.signInitialTransaction(txBuilder)
-
-                // Finalising the transaction.
-                subFlow(FinalityFlow(signedTx))
-            }
-        }
-
-    .. code-block:: java
-
-        package com.template.flow;
-
-        import co.paralleluniverse.fibers.Suspendable;
-        import com.template.contract.IOUContract;
-        import com.template.state.IOUState;
-        import net.corda.core.contracts.Command;
-        import net.corda.core.contracts.StateAndContract;
-        import net.corda.core.flows.*;
-        import net.corda.core.identity.Party;
-        import net.corda.core.transactions.SignedTransaction;
-        import net.corda.core.transactions.TransactionBuilder;
-        import net.corda.core.utilities.ProgressTracker;
-
-        @InitiatingFlow
-        @StartableByRPC
-        public class IOUFlow extends FlowLogic<Void> {
-            private final Integer iouValue;
-            private final Party otherParty;
-
-            /**
-             * The progress tracker provides checkpoints indicating the progress of the flow to observers.
-             */
-            private final ProgressTracker progressTracker = new ProgressTracker();
-
-            public IOUFlow(Integer iouValue, Party otherParty) {
-                this.iouValue = iouValue;
-                this.otherParty = otherParty;
-            }
-
-            @Override
-            public ProgressTracker getProgressTracker() {
-                return progressTracker;
-            }
-
-            /**
-             * The flow logic is encapsulated within the call() method.
-             */
-            @Suspendable
-            @Override
-            public Void call() throws FlowException {
-                // We retrieve the notary identity from the network map.
-                final Party notary = getServiceHub().getNetworkMapCache().getNotaryIdentities().get(0);
-
-                // We create a transaction builder.
-                final TransactionBuilder txBuilder = new TransactionBuilder();
-                txBuilder.setNotary(notary);
-
-                // We create the transaction components.
-                IOUState outputState = new IOUState(iouValue, getOurIdentity(), otherParty);
-                String outputContract = IOUContract.class.getName();
-                StateAndContract outputContractAndState = new StateAndContract(outputState, outputContract);
-                Command cmd = new Command<>(new IOUContract.Create(), getOurIdentity().getOwningKey());
-
-                // We add the items to the builder.
-                txBuilder.withItems(outputContractAndState, cmd);
-
-                // Verifying the transaction.
-                txBuilder.verify(getServiceHub());
-
-                // Signing the transaction.
-                final SignedTransaction signedTx = getServiceHub().signInitialTransaction(txBuilder);
-
-                // Finalising the transaction.
-                subFlow(new FinalityFlow(signedTx));
-
-                return null;
-            }
-        }
+    .. literalinclude:: example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUFlow.java
+        :language: java
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
 If you're following along in Java, you'll also need to rename ``TemplateFlow.java`` to ``IOUFlow.java``.
 
diff --git a/docs/source/hello-world-running.rst b/docs/source/hello-world-running.rst
index 72c573b789..377fd90e05 100644
--- a/docs/source/hello-world-running.rst
+++ b/docs/source/hello-world-running.rst
@@ -17,38 +17,36 @@ Kotlin) file. We won't be using it, and it will cause build errors unless we rem
 Deploying our CorDapp
 ---------------------
 Let's take a look at the nodes we're going to deploy. Open the project's ``build.gradle`` file and scroll down to the
-``task deployNodes`` section. This section defines three nodes - the Controller, NodeA, and NodeB:
+``task deployNodes`` section. This section defines three nodes - the Controller, PartyA, and PartyB:
 
-.. container:: codeset
+.. code:: bash
 
-    .. code-block:: kotlin
-
-        task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
-            directory "./build/nodes"
-            node {
-                name "O=Controller,L=London,C=GB"
-                notary = [validating : true]
-                p2pPort 10002
-                rpcPort 10003
-                cordapps = ["net.corda:corda-finance:$corda_release_version"]
-            }
-            node {
-                name "O=PartyA,L=London,C=GB"
-                p2pPort 10005
-                rpcPort 10006
-                webPort 10007
-                cordapps = ["net.corda:corda-finance:$corda_release_version"]
-                rpcUsers = [[ user: "user1", "password": "test", "permissions": []]]
-            }
-            node {
-                name "O=PartyB,L=New York,C=US"
-                p2pPort 10008
-                rpcPort 10009
-                webPort 10010
-                cordapps = ["net.corda:corda-finance:$corda_release_version"]
-                rpcUsers = [[ user: "user1", "password": "test", "permissions": []]]
-            }
+    task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
+        directory "./build/nodes"
+        node {
+            name "O=Controller,L=London,C=GB"
+            advertisedServices = ["corda.notary.validating"]
+            p2pPort 10002
+            rpcPort 10003
+            cordapps = ["net.corda:corda-finance:$corda_release_version"]
         }
+        node {
+            name "O=PartyA,L=London,C=GB"
+            p2pPort 10005
+            rpcPort 10006
+            webPort 10007
+            cordapps = ["net.corda:corda-finance:$corda_release_version"]
+            rpcUsers = [[ user: "user1", "password": "test", "permissions": []]]
+        }
+        node {
+            name "O=PartyB,L=New York,C=US"
+            p2pPort 10008
+            rpcPort 10009
+            webPort 10010
+            cordapps = ["net.corda:corda-finance:$corda_release_version"]
+            rpcUsers = [[ user: "user1", "password": "test", "permissions": []]]
+        }
+    }
 
 We have three standard nodes, plus a special Controller node that is running the network map service, and is also
 advertising a validating notary service. Feel free to add additional node definitions here to expand the size of the
@@ -61,7 +59,7 @@ We can run this ``deployNodes`` task using Gradle. For each node definition, Gra
 
 We can do that now by running the following commands from the root of the project:
 
-.. code:: python
+.. code:: bash
 
     // On Windows
     gradlew clean deployNodes
@@ -74,20 +72,18 @@ Running the nodes
 Running ``deployNodes`` will build the nodes under ``build/nodes``. If we navigate to one of these folders, we'll see
 the three node folders. Each node folder has the following structure:
 
-    .. code:: python
+    .. code:: bash
 
         .
         |____corda.jar                     // The runnable node
         |____corda-webserver.jar           // The node's webserver
-        |____dependencies
         |____node.conf                     // The node's configuration file
-        |____additional-node-infos/        // Directory containing all the other nodes' addresses and identities
         |____cordapps
-          |____java/kotlin-source-0.1.jar  // Our IOU CorDapp
+        |____java/kotlin-source-0.1.jar  // Our IOU CorDapp
 
 Let's start the nodes by running the following commands from the root of the project:
 
-.. code:: python
+.. code:: bash
 
     // On Windows
     build/nodes/runnodes.bat
@@ -136,7 +132,7 @@ will display a list of the available commands. We can examine the contents of a
 
 The vaults of PartyA and PartyB should both display the following output:
 
-.. code:: python
+.. code:: bash
 
     states:
     - state:
@@ -192,11 +188,9 @@ There are a number of improvements we could make to this CorDapp:
 * We could add an API, to make it easier to interact with the CorDapp
 
 We will explore some of these improvements in future tutorials. But you should now be ready to develop your own
-CorDapps. There's `a more fleshed-out version of the IOU CorDapp <https://github.com/corda/cordapp-example>`_ with an
-API and web front-end, and a set of example CorDapps in `the main Corda repo <https://github.com/corda/corda>`_, under
-``samples``. An explanation of how to run these samples :doc:`here <running-the-demos>`.
+CorDapps. You can find a list of sample CorDapps `here <https://www.corda.net/samples/>`_.
 
-As you write CorDapps, you can learn more about the API available :doc:`here <api>`.
+As you write CorDapps, you can learn more about the Corda API :doc:`here <corda-api>`.
 
 If you get stuck at any point, please reach out on `Slack <https://slack.corda.net/>`_,
 `Discourse <https://discourse.corda.net/>`_, or `Stack Overflow <https://stackoverflow.com/questions/tagged/corda>`_.
diff --git a/docs/source/hello-world-state.rst b/docs/source/hello-world-state.rst
index dbcbe7c4b7..a933cc920b 100644
--- a/docs/source/hello-world-state.rst
+++ b/docs/source/hello-world-state.rst
@@ -63,53 +63,15 @@ define an ``IOUState``:
 
 .. container:: codeset
 
-    .. code-block:: kotlin
+    .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/tutorial/helloworld/state.kt
+        :language: kotlin
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
-        class IOUState(val value: Int,
-                       val lender: Party,
-                       val borrower: Party) : ContractState {
-            override val participants get() = listOf(lender, borrower)
-        }
-
-    .. code-block:: java
-
-        package com.template.state;
-
-        import com.google.common.collect.ImmutableList;
-        import net.corda.core.contracts.ContractState;
-        import net.corda.core.identity.AbstractParty;
-        import net.corda.core.identity.Party;
-
-        import java.util.List;
-
-        public class IOUState implements ContractState {
-            private final int value;
-            private final Party lender;
-            private final Party borrower;
-
-            public IOUState(int value, Party lender, Party borrower) {
-                this.value = value;
-                this.lender = lender;
-                this.borrower = borrower;
-            }
-
-            public int getValue() {
-                return value;
-            }
-
-            public Party getLender() {
-                return lender;
-            }
-
-            public Party getBorrower() {
-                return borrower;
-            }
-
-            @Override
-            public List<AbstractParty> getParticipants() {
-                return ImmutableList.of(lender, borrower);
-            }
-        }
+    .. literalinclude:: example-code/src/main/java/net/corda/docs/java/tutorial/helloworld/IOUState.java
+        :language: java
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
 If you're following along in Java, you'll also need to rename ``TemplateState.java`` to ``IOUState.java``.
 
diff --git a/docs/source/hello-world-template.rst b/docs/source/hello-world-template.rst
index 5a6e3920a1..d9358d60eb 100644
--- a/docs/source/hello-world-template.rst
+++ b/docs/source/hello-world-template.rst
@@ -42,18 +42,23 @@ implement our IOU CorDapp in Java, we'll need to modify three files. For Kotlin,
     .. code-block:: java
 
         // 1. The state
-        src/main/java/com/template/state/TemplateState.java
+        src/main/java/com/template/TemplateState.java
 
         // 2. The contract
-        src/main/java/com/template/contract/TemplateContract.java
+        src/main/java/com/template/TemplateContract.java
 
         // 3. The flow
-        src/main/java/com/template/flow/TemplateFlow.java
+        src/main/java/com/template/TemplateFlow.java
 
     .. code-block:: kotlin
 
         src/main/kotlin/com/template/App.kt
 
+To prevent build errors later on, you should delete the following file:
+
+* Java: ``src/test/java/com/template/FlowTests.java``
+* Kotlin: ``src/test/kotlin/com/template/FlowTests.kt``
+
 Progress so far
 ---------------
 We now have a template that we can build upon to define our IOU CorDapp.
diff --git a/docs/source/tut-two-party-contract.rst b/docs/source/tut-two-party-contract.rst
index 077133b378..2e59e2f0ef 100644
--- a/docs/source/tut-two-party-contract.rst
+++ b/docs/source/tut-two-party-contract.rst
@@ -11,31 +11,37 @@ Remember that each state references a contract. The contract imposes constraints
 If the transaction does not obey the constraints of all the contracts of all its states, it cannot become a valid
 ledger update.
 
-We need to modify our contract so that the borrower's signature is required in any IOU creation transaction. This will
-only require changing a single line of code. In ``IOUContract.java``/``IOUContract.kt``, update the final two lines of
-the ``requireThat`` block as follows:
+We need to modify our contract so that the borrower's signature is required in any IOU creation transaction.
+
+In ``IOUContract.java``/``IOUContract.kt``, change the imports block to the following:
 
 .. container:: codeset
 
-    .. code-block:: kotlin
+    .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/contract.kt
+        :language: kotlin
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
-        // Constraints on the signers.
-        "There must be two signers." using (command.signers.toSet().size == 2)
-        "The borrower and lender must be signers." using (command.signers.containsAll(listOf(
-            out.borrower.owningKey, out.lender.owningKey)))
+    .. literalinclude:: example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUContract.java
+        :language: java
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
-    .. code-block:: java
+And update the final block of constraints in the ``requireThat`` block as follows:
 
-        ...
+.. container:: codeset
 
-        import com.google.common.collect.ImmutableList;
+    .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/contract.kt
+        :language: kotlin
+        :start-after: DOCSTART 02
+        :end-before: DOCEND 02
+        :dedent: 12
 
-        ...
-
-        // Constraints on the signers.
-        check.using("There must be two signers.", command.getSigners().size() == 2);
-        check.using("The borrower and lender must be signers.", command.getSigners().containsAll(
-            ImmutableList.of(borrower.getOwningKey(), lender.getOwningKey())));
+    .. literalinclude:: example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUContract.java
+        :language: java
+        :start-after: DOCSTART 02
+        :end-before: DOCEND 02
+        :dedent: 12
 
 Progress so far
 ---------------
diff --git a/docs/source/tut-two-party-flow.rst b/docs/source/tut-two-party-flow.rst
index b19630eb32..4d5866b2c8 100644
--- a/docs/source/tut-two-party-flow.rst
+++ b/docs/source/tut-two-party-flow.rst
@@ -21,76 +21,35 @@ by invoking a built-in flow called ``FinalityFlow`` as a subflow. We're going to
 We also need to add the borrower's public key to the transaction's command, making the borrower one of the required
 signers on the transaction.
 
-In ``IOUFlow.java``/``IOUFlow.kt``, update ``IOUFlow.call`` as follows:
+In ``IOUFlow.java``/``IOUFlow.kt``, change the imports block to the following:
 
 .. container:: codeset
 
-    .. code-block:: kotlin
+    .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/flow.kt
+        :language: kotlin
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
-        ...
+    .. literalinclude:: example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUFlow.java
+        :language: java
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
-        // We create the transaction components.
-        val outputState = IOUState(iouValue, ourIdentity, otherParty)
-        val outputContract = IOUContract::class.jvmName
-        val outputContractAndState = StateAndContract(outputState, outputContract)
-        val cmd = Command(IOUContract.Create(), listOf(ourIdentity.owningKey, otherParty.owningKey))
+And update ``IOUFlow.call`` by changing the code following the creation of the ``TransactionBuilder`` as follows:
 
-        // We add the items to the builder.
-        txBuilder.withItems(outputContractAndState, cmd)
+.. container:: codeset
 
-        // Verifying the transaction.
-        txBuilder.verify(serviceHub)
+    .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/flow.kt
+        :language: kotlin
+        :start-after: DOCSTART 02
+        :end-before: DOCEND 02
+        :dedent: 8
 
-        // Signing the transaction.
-        val signedTx = serviceHub.signInitialTransaction(txBuilder)
-
-        // Creating a session with the other party.
-        val otherpartySession = initiateFlow(otherParty)
-
-        // Obtaining the counterparty's signature.
-        val fullySignedTx = subFlow(CollectSignaturesFlow(signedTx, listOf(otherpartySession), CollectSignaturesFlow.tracker()))
-
-        // Finalising the transaction.
-        subFlow(FinalityFlow(fullySignedTx))
-
-    .. code-block:: java
-
-        ...
-
-        import com.google.common.collect.ImmutableList;
-        import java.security.PublicKey;
-        import java.util.Collections;
-        import java.util.List;
-
-        ...
-
-        // We create the transaction components.
-        IOUState outputState = new IOUState(iouValue, getOurIdentity(), otherParty);
-        String outputContract = IOUContract.class.getName();
-        StateAndContract outputContractAndState = new StateAndContract(outputState, outputContract);
-        List<PublicKey> requiredSigners = ImmutableList.of(getOurIdentity().getOwningKey(), otherParty.getOwningKey());
-        Command cmd = new Command<>(new IOUContract.Create(), requiredSigners);
-
-        // We add the items to the builder.
-        txBuilder.withItems(outputContractAndState, cmd);
-
-        // Verifying the transaction.
-        txBuilder.verify(getServiceHub());
-
-        // Signing the transaction.
-        final SignedTransaction signedTx = getServiceHub().signInitialTransaction(txBuilder);
-
-        // Creating a session with the other party.
-        FlowSession otherpartySession = initiateFlow(otherParty);
-
-        // Obtaining the counterparty's signature.
-        SignedTransaction fullySignedTx = subFlow(new CollectSignaturesFlow(
-                signedTx, ImmutableList.of(otherpartySession), CollectSignaturesFlow.tracker()));
-
-        // Finalising the transaction.
-        subFlow(new FinalityFlow(signedTx));
-
-        return null;
+    .. literalinclude:: example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUFlow.java
+        :language: java
+        :start-after: DOCSTART 02
+        :end-before: DOCEND 02
+        :dedent: 8
 
 To make the borrower a required signer, we simply add the borrower's public key to the list of signers on the command.
 
@@ -116,81 +75,15 @@ In a new ``IOUFlowResponder.java`` file in Java, or within the ``App.kt`` file i
 
 .. container:: codeset
 
-    .. code-block:: kotlin
+    .. literalinclude:: example-code/src/main/kotlin/net/corda/docs/tutorial/twoparty/flowResponder.kt
+        :language: kotlin
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
-        ...
-
-        import net.corda.core.transactions.SignedTransaction
-
-        ...
-
-        @InitiatedBy(IOUFlow::class)
-        class IOUFlowResponder(val otherPartySession: FlowSession) : FlowLogic<Unit>() {
-            @Suspendable
-            override fun call() {
-                val signTransactionFlow = object : SignTransactionFlow(otherPartySession, SignTransactionFlow.tracker()) {
-                    override fun checkTransaction(stx: SignedTransaction) = requireThat {
-                        val output = stx.tx.outputs.single().data
-                        "This must be an IOU transaction." using (output is IOUState)
-                        val iou = output as IOUState
-                        "The IOU's value can't be too high." using (iou.value < 100)
-                    }
-                }
-
-                subFlow(signTransactionFlow)
-            }
-        }
-
-    .. code-block:: java
-
-        package com.template.flow;
-
-        import co.paralleluniverse.fibers.Suspendable;
-        import com.template.state.IOUState;
-        import net.corda.core.contracts.ContractState;
-        import net.corda.core.flows.FlowException;
-        import net.corda.core.flows.FlowLogic;
-        import net.corda.core.flows.FlowSession;
-        import net.corda.core.flows.InitiatedBy;
-        import net.corda.core.flows.SignTransactionFlow;
-        import net.corda.core.transactions.SignedTransaction;
-        import net.corda.core.utilities.ProgressTracker;
-
-        import static net.corda.core.contracts.ContractsDSL.requireThat;
-
-        @InitiatedBy(IOUFlow.class)
-        public class IOUFlowResponder extends FlowLogic<Void> {
-            private final FlowSession otherPartySession;
-
-            public IOUFlowResponder(FlowSession otherPartySession) {
-                this.otherPartySession = otherPartySession;
-            }
-
-            @Suspendable
-            @Override
-            public Void call() throws FlowException {
-                class SignTxFlow extends SignTransactionFlow {
-                    private signTxFlow(FlowSession otherPartySession, ProgressTracker progressTracker) {
-                        super(otherPartySession, progressTracker);
-                    }
-
-                    @Override
-                    protected void checkTransaction(SignedTransaction stx) {
-                        requireThat(require -> {
-                            ContractState output = stx.getTx().getOutputs().get(0).getData();
-                            require.using("This must be an IOU transaction.", output instanceof IOUState);
-                            IOUState iou = (IOUState) output;
-                            require.using("The IOU's value can't be too high.", iou.getValue() < 100);
-                            return null;
-                        });
-                    }
-                }
-
-                subFlow(new SignTxFlow(otherPartySession, SignTransactionFlow.Companion.tracker()));
-
-                return null;
-            }
-        }
+    .. literalinclude:: example-code/src/main/java/net/corda/docs/java/tutorial/twoparty/IOUFlowResponder.java
+        :language: java
+        :start-after: DOCSTART 01
+        :end-before: DOCEND 01
 
 As with the ``IOUFlow``, our ``IOUFlowResponder`` flow is a ``FlowLogic`` subclass where we've overridden
 ``FlowLogic.call``.
diff --git a/docs/source/tut-two-party-introduction.rst b/docs/source/tut-two-party-introduction.rst
index 95ad302e2c..66f4f14acc 100644
--- a/docs/source/tut-two-party-introduction.rst
+++ b/docs/source/tut-two-party-introduction.rst
@@ -20,4 +20,4 @@ IOU onto the ledger. We'll need to make two changes:
   signature (as well as the lender's) to become valid ledger updates
 * The ``IOUFlow`` will need to be updated to allow for the gathering of the borrower's signature
 
-We'll start by updating the contract.
+We'll start by updating the contract.
\ No newline at end of file

From d8b81f755a89f663b90c2aaef0ab832138129a56 Mon Sep 17 00:00:00 2001
From: Joel Dudley <joeldudleyr3@users.noreply.github.com>
Date: Mon, 16 Oct 2017 15:15:02 +0100
Subject: [PATCH 183/185] Makes docs fixes flagged by various internals.

---
 docs/source/node-services.rst               |   6 ++----
 docs/source/resources/node-architecture.png | Bin 371367 -> 289224 bytes
 docs/source/upgrade-notes.rst               |   2 ++
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/source/node-services.rst b/docs/source/node-services.rst
index d62edd2548..b63dbfc942 100644
--- a/docs/source/node-services.rst
+++ b/docs/source/node-services.rst
@@ -209,10 +209,8 @@ NodeAttachmentService
 The ``NodeAttachmentService`` provides an implementation of the 
 ``AttachmentStorage`` interface exposed on the ``ServiceHub`` allowing 
 transactions to add documents, copies of the contract code and binary 
-data to transactions. The data is persisted to the local file system 
-inside the attachments subfolder of the node workspace. The service is 
-also interfaced to by the web server, which allows files to be uploaded 
-via an HTTP post request. 
+data to transactions. The service is also interfaced to by the web server,
+which allows files to be uploaded via an HTTP post request.
 
 Flow framework and event scheduling services
 --------------------------------------------
diff --git a/docs/source/resources/node-architecture.png b/docs/source/resources/node-architecture.png
index cfc8b22cf7716e73509815af419d96dab7e67fa1..7004cda149e3924fa4831db8366d201a022eabbb 100644
GIT binary patch
literal 289224
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
aqCmi((=XGU!>$4UBt&Fi6#e<~_5T8Lwa*;@

literal 371367
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%0A3GHxoQ=B)fuD{Rv7j!
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%0Ai8(Q
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

diff --git a/docs/source/upgrade-notes.rst b/docs/source/upgrade-notes.rst
index 3f6444d497..0040c48e05 100644
--- a/docs/source/upgrade-notes.rst
+++ b/docs/source/upgrade-notes.rst
@@ -220,6 +220,8 @@ Miscellaneous
   apps would not typically select random, unknown counterparties from the network map based on self-declared capabilities.
   We will introduce a replacement for this functionality, business networks, in a future release.
 
+  For now, your should retrieve the service by legal name using ``NetworkMapCache.getNodeByLegalName``.
+
 Gotchas
 ^^^^^^^
 

From 63b7eb3f70c5eced987aa5fae6fd4e6620758c10 Mon Sep 17 00:00:00 2001
From: Ross Nicoll <ross.nicoll@r3.com>
Date: Mon, 16 Oct 2017 15:51:26 +0100
Subject: [PATCH 184/185] CORDA-654: Move from chooseIdentity() to
 singleIdentity() (#1819)

Move from `chooseIdentity()` to `singleIdentity()` where tests use a single identity, or to fetching by name where multiple identities are present, so we stop using the first identity as special.
---
 .../confidential/IdentitySyncFlowTests.kt     |  24 +-
 .../confidential/SwapIdentitiesFlowTests.kt   |   8 +-
 .../net/corda/core/flows/AttachmentTests.kt   |   5 +-
 .../core/flows/CollectSignaturesFlowTests.kt  |   8 +-
 .../net/corda/core/flows/FinalityFlowTests.kt |   6 +-
 .../corda/node/services/vault/VaultSchema.kt  |   5 +-
 .../node/messaging/TwoPartyTradeFlowTests.kt  | 105 ++---
 .../statemachine/FlowFrameworkTests.kt        | 380 +++++++++---------
 .../transactions/NotaryServiceTests.kt        |  72 ++--
 .../ValidatingNotaryServiceTests.kt           |   4 +-
 .../kotlin/net/corda/testing/CoreTestUtils.kt |  13 +-
 11 files changed, 329 insertions(+), 301 deletions(-)

diff --git a/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt b/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
index ef276ef07e..b760817afe 100644
--- a/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
+++ b/confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt
@@ -40,12 +40,12 @@ class IdentitySyncFlowTests {
     @Test
     fun `sync confidential identities`() {
         // Set up values we'll need
-        mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
-        val bobNode = mockNet.createPartyNode(BOB.name)
-        val alice: Party = aliceNode.services.myInfo.chooseIdentity()
-        val bob: Party = bobNode.services.myInfo.chooseIdentity()
-        val notary = aliceNode.services.getDefaultNotary()
+        val notaryNode = mockNet.createNotaryNode()
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
+        val alice: Party = aliceNode.info.singleIdentity()
+        val bob: Party = bobNode.info.singleIdentity()
+        val notary = notaryNode.services.getDefaultNotary()
         bobNode.internals.registerInitiatedFlow(Receive::class.java)
 
         // Alice issues then pays some cash to a new confidential identity that Bob doesn't know about
@@ -71,12 +71,12 @@ class IdentitySyncFlowTests {
     fun `don't offer other's identities confidential identities`() {
         // Set up values we'll need
         val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
-        val bobNode = mockNet.createPartyNode(BOB.name)
-        val charlieNode = mockNet.createPartyNode(CHARLIE.name)
-        val alice: Party = aliceNode.services.myInfo.chooseIdentity()
-        val bob: Party = bobNode.services.myInfo.chooseIdentity()
-        val charlie: Party = charlieNode.services.myInfo.chooseIdentity()
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
+        val charlieNode = mockNet.createPartyNode(CHARLIE_NAME)
+        val alice: Party = aliceNode.info.singleIdentity()
+        val bob: Party = bobNode.info.singleIdentity()
+        val charlie: Party = charlieNode.info.singleIdentity()
         val notary = notaryNode.services.getDefaultNotary()
         bobNode.internals.registerInitiatedFlow(Receive::class.java)
 
diff --git a/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt b/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
index 3a0e6602fe..8030469fe5 100644
--- a/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
+++ b/confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt
@@ -19,8 +19,8 @@ class SwapIdentitiesFlowTests {
         val notaryNode = mockNet.createNotaryNode()
         val aliceNode = mockNet.createPartyNode(ALICE.name)
         val bobNode = mockNet.createPartyNode(BOB.name)
-        val alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
-        val bob = bobNode.services.myInfo.identityFromX500Name(BOB_NAME)
+        val alice = aliceNode.info.singleIdentity()
+        val bob = bobNode.services.myInfo.singleIdentity()
 
         // Run the flows
         val requesterFlow = aliceNode.services.startFlow(SwapIdentitiesFlow(bob))
@@ -59,7 +59,7 @@ class SwapIdentitiesFlowTests {
         val notaryNode = mockNet.createNotaryNode(DUMMY_NOTARY.name)
         val aliceNode = mockNet.createPartyNode(ALICE.name)
         val bobNode = mockNet.createPartyNode(BOB.name)
-        val bob: Party = bobNode.services.myInfo.chooseIdentity()
+        val bob: Party = bobNode.services.myInfo.singleIdentity()
         val notBob = notaryNode.database.transaction {
             notaryNode.services.keyManagementService.freshKeyAndCert(notaryNode.services.myInfo.chooseIdentityAndCert(), false)
         }
@@ -84,7 +84,7 @@ class SwapIdentitiesFlowTests {
         val notaryNode = mockNet.createNotaryNode(DUMMY_NOTARY.name)
         val aliceNode = mockNet.createPartyNode(ALICE.name)
         val bobNode = mockNet.createPartyNode(BOB.name)
-        val bob: Party = bobNode.services.myInfo.chooseIdentity()
+        val bob: Party = bobNode.services.myInfo.singleIdentity()
         // Check that the wrong signature is rejected
         notaryNode.database.transaction {
             notaryNode.services.keyManagementService.freshKeyAndCert(notaryNode.services.myInfo.chooseIdentityAndCert(), false)
diff --git a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
index c9974d5dc3..aae7f6fc0d 100644
--- a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt
@@ -17,6 +17,7 @@ import net.corda.testing.ALICE
 import net.corda.testing.ALICE_NAME
 import net.corda.testing.BOB
 import net.corda.testing.node.MockNetwork
+import net.corda.testing.singleIdentity
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -60,7 +61,7 @@ class AttachmentTests {
         // Ensure that registration was successful before progressing any further
         mockNet.runNetwork()
         aliceNode.internals.ensureRegistered()
-        val alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
+        val alice = aliceNode.info.singleIdentity()
 
         aliceNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
         bobNode.internals.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
@@ -105,7 +106,7 @@ class AttachmentTests {
         // Get node one to fetch a non-existent attachment.
         val hash = SecureHash.randomSHA256()
         mockNet.runNetwork()
-        val alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
+        val alice = aliceNode.info.singleIdentity()
         val bobFlow = bobNode.startAttachmentFlow(setOf(hash), alice)
         mockNet.runNetwork()
         val e = assertFailsWith<FetchDataFlow.HashNotFound> { bobFlow.resultFuture.getOrThrow() }
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 d2c2a846ac..a0b2c0020c 100644
--- a/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
@@ -45,10 +45,10 @@ class CollectSignaturesFlowTests {
         charlieNode = mockNet.createPartyNode(CHARLIE.name)
         mockNet.runNetwork()
         aliceNode.internals.ensureRegistered()
-        alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
-        bob = bobNode.services.myInfo.identityFromX500Name(BOB_NAME)
-        charlie = charlieNode.services.myInfo.identityFromX500Name(CHARLIE_NAME)
-        notary = notaryNode.services.networkMapCache.getNotary(DUMMY_NOTARY_SERVICE_NAME)!!
+        alice = aliceNode.info.singleIdentity()
+        bob = bobNode.info.singleIdentity()
+        charlie = charlieNode.info.singleIdentity()
+        notary = notaryNode.services.getDefaultNotary()
     }
 
     @After
diff --git a/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt b/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
index a68d4542c8..bdc76e1d83 100644
--- a/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
@@ -33,9 +33,9 @@ class FinalityFlowTests {
         aliceNode.internals.ensureRegistered()
         aliceServices = aliceNode.services
         bobServices = bobNode.services
-        alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
-        bob = bobNode.services.myInfo.identityFromX500Name(BOB_NAME)
-        notary = notaryNode.services.networkMapCache.getNotary(DUMMY_NOTARY_SERVICE_NAME)!!
+        alice = aliceNode.info.singleIdentity()
+        bob = bobNode.info.singleIdentity()
+        notary = notaryNode.services.getDefaultNotary()
     }
 
     @After
diff --git a/node/src/main/kotlin/net/corda/node/services/vault/VaultSchema.kt b/node/src/main/kotlin/net/corda/node/services/vault/VaultSchema.kt
index 0c8ba52a4e..909d35925c 100644
--- a/node/src/main/kotlin/net/corda/node/services/vault/VaultSchema.kt
+++ b/node/src/main/kotlin/net/corda/node/services/vault/VaultSchema.kt
@@ -3,13 +3,12 @@ package net.corda.node.services.vault
 import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.UniqueIdentifier
 import net.corda.core.identity.AbstractParty
+import net.corda.core.identity.Party
 import net.corda.core.node.services.Vault
 import net.corda.core.schemas.MappedSchema
 import net.corda.core.schemas.PersistentState
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.utilities.OpaqueBytes
-import org.hibernate.annotations.Generated
-import org.hibernate.annotations.GenerationTime
 import java.io.Serializable
 import java.time.Instant
 import java.util.*
@@ -32,7 +31,7 @@ object VaultSchemaV1 : MappedSchema(schemaFamily = VaultSchema.javaClass, versio
     class VaultStates(
             /** refers to the X500Name of the notary a state is attached to */
             @Column(name = "notary_name")
-            var notary: AbstractParty,
+            var notary: Party,
 
             /** references a concrete ContractState that is [QueryableState] and has a [MappedSchema] */
             @Column(name = "contract_state_class_name")
diff --git a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
index 9677213a16..93edb33b92 100644
--- a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
+++ b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
@@ -31,7 +31,6 @@ import net.corda.finance.`issued by`
 import net.corda.finance.contracts.CommercialPaper
 import net.corda.finance.contracts.asset.CASH
 import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.ownedBy
 import net.corda.finance.flows.TwoPartyTradeFlow.Buyer
 import net.corda.finance.flows.TwoPartyTradeFlow.Seller
 import net.corda.node.internal.StartedNode
@@ -103,12 +102,14 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
         mockNet = MockNetwork(false, true, cordappPackages = cordappPackages)
         ledger(MockServices(cordappPackages), initialiseSerialization = false) {
             val notaryNode = mockNet.createNotaryNode()
-            val aliceNode = mockNet.createPartyNode(ALICE.name)
-            val bobNode = mockNet.createPartyNode(BOB.name)
-            val bankNode = mockNet.createPartyNode(BOC.name)
+            val aliceNode = mockNet.createPartyNode(ALICE_NAME)
+            val bobNode = mockNet.createPartyNode(BOB_NAME)
+            val bankNode = mockNet.createPartyNode(BOC_NAME)
+            val alice = aliceNode.info.singleIdentity()
+            val bank = bankNode.info.singleIdentity()
             val notary = notaryNode.services.getDefaultNotary()
-            val cashIssuer = bankNode.info.chooseIdentity().ref(1)
-            val cpIssuer = bankNode.info.chooseIdentity().ref(1, 2, 3)
+            val cashIssuer = bank.ref(1)
+            val cpIssuer = bank.ref(1, 2, 3)
 
             aliceNode.internals.disableDBCloseOnStop()
             bobNode.internals.disableDBCloseOnStop()
@@ -119,8 +120,8 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
             }
 
             val alicesFakePaper = aliceNode.database.transaction {
-                fillUpForSeller(false, cpIssuer, aliceNode.info.chooseIdentity(),
-                        1200.DOLLARS `issued by` bankNode.info.chooseIdentity().ref(0), null, notary).second
+                fillUpForSeller(false, cpIssuer, alice,
+                        1200.DOLLARS `issued by` bank.ref(0), null, notary).second
             }
 
             insertFakeTransactions(alicesFakePaper, aliceNode, notaryNode, bankNode)
@@ -151,10 +152,12 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
         mockNet = MockNetwork(false, true, cordappPackages = cordappPackages)
         ledger(MockServices(cordappPackages), initialiseSerialization = false) {
             val notaryNode = mockNet.createNotaryNode()
-            val aliceNode = mockNet.createPartyNode(ALICE.name)
-            val bobNode = mockNet.createPartyNode(BOB.name)
-            val bankNode = mockNet.createPartyNode(BOC.name)
-            val issuer = bankNode.info.chooseIdentity().ref(1)
+            val aliceNode = mockNet.createPartyNode(ALICE_NAME)
+            val bobNode = mockNet.createPartyNode(BOB_NAME)
+            val bankNode = mockNet.createPartyNode(BOC_NAME)
+            val alice = aliceNode.info.singleIdentity()
+            val bank = bankNode.info.singleIdentity()
+            val issuer = bank.ref(1)
             val notary = aliceNode.services.getDefaultNotary()
 
             aliceNode.internals.disableDBCloseOnStop()
@@ -166,8 +169,8 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
             }
 
             val alicesFakePaper = aliceNode.database.transaction {
-                fillUpForSeller(false, issuer, aliceNode.info.chooseIdentity(),
-                        1200.DOLLARS `issued by` bankNode.info.chooseIdentity().ref(0), null, notary).second
+                fillUpForSeller(false, issuer, alice,
+                        1200.DOLLARS `issued by` bank.ref(0), null, notary).second
             }
 
             insertFakeTransactions(alicesFakePaper, aliceNode, notaryNode, bankNode)
@@ -205,31 +208,27 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
         mockNet = MockNetwork(false, cordappPackages = cordappPackages)
         ledger(MockServices(cordappPackages), initialiseSerialization = false) {
             val notaryNode = mockNet.createNotaryNode()
-            val aliceNode = mockNet.createPartyNode(ALICE.name)
-            var bobNode = mockNet.createPartyNode(BOB.name)
-            val bankNode = mockNet.createPartyNode(BOC.name)
-            val issuer = bankNode.info.chooseIdentity().ref(1, 2, 3)
-
-            aliceNode.database.transaction {
-                aliceNode.services.identityService.verifyAndRegisterIdentity(bobNode.info.chooseIdentityAndCert())
-            }
-            bobNode.database.transaction {
-                bobNode.services.identityService.verifyAndRegisterIdentity(aliceNode.info.chooseIdentityAndCert())
-            }
+            val aliceNode = mockNet.createPartyNode(ALICE_NAME)
+            var bobNode = mockNet.createPartyNode(BOB_NAME)
+            val bankNode = mockNet.createPartyNode(BOC_NAME)
             aliceNode.internals.disableDBCloseOnStop()
             bobNode.internals.disableDBCloseOnStop()
 
             val bobAddr = bobNode.network.myAddress as InMemoryMessagingNetwork.PeerHandle
             mockNet.runNetwork() // Clear network map registration messages
-            val notary = aliceNode.services.getDefaultNotary()
+
+            val notary = notaryNode.services.getDefaultNotary()
+            val alice = aliceNode.info.singleIdentity()
+            val bank = bankNode.info.singleIdentity()
+            val issuer = bank.ref(1, 2, 3)
 
             bobNode.database.transaction {
                 bobNode.services.fillWithSomeTestCash(2000.DOLLARS, bankNode.services, outputNotary = notary,
                         issuedBy = issuer)
             }
             val alicesFakePaper = aliceNode.database.transaction {
-                fillUpForSeller(false, issuer, aliceNode.info.chooseIdentity(),
-                        1200.DOLLARS `issued by` bankNode.info.chooseIdentity().ref(0), null, notary).second
+                fillUpForSeller(false, issuer, alice,
+                        1200.DOLLARS `issued by` bank.ref(0), null, notary).second
             }
             insertFakeTransactions(alicesFakePaper, aliceNode, notaryNode, bankNode)
             val aliceFuture = runBuyerAndSeller(notary, aliceNode, bobNode, "alice's paper".outputStateAndRef()).sellerResult
@@ -274,7 +273,7 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
                                     id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): MockNetwork.MockNode {
                     return MockNetwork.MockNode(config, network, networkMapAddr, bobAddr.id, notaryIdentity, entropyRoot)
                 }
-            }, BOB.name)
+            }, BOB_NAME)
 
             // Find the future representing the result of this state machine again.
             val bobFuture = bobNode.smm.findStateMachines(BuyerAcceptor::class.java).single().second
@@ -329,13 +328,16 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
     fun `check dependencies of sale asset are resolved`() {
         mockNet = MockNetwork(false, cordappPackages = cordappPackages)
         val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = makeNodeWithTracking(ALICE.name)
-        val bobNode = makeNodeWithTracking(BOB.name)
-        val bankNode = makeNodeWithTracking(BOC.name)
-        val issuer = bankNode.info.chooseIdentity().ref(1, 2, 3)
+        val aliceNode = makeNodeWithTracking(ALICE_NAME)
+        val bobNode = makeNodeWithTracking(BOB_NAME)
+        val bankNode = makeNodeWithTracking(BOC_NAME)
         mockNet.runNetwork()
         notaryNode.internals.ensureRegistered()
         val notary = aliceNode.services.getDefaultNotary()
+        val alice = aliceNode.info.singleIdentity()
+        val bob = bobNode.info.singleIdentity()
+        val bank = bankNode.info.singleIdentity()
+        val issuer = bank.ref(1, 2, 3)
 
         ledger(aliceNode.services, initialiseSerialization = false) {
 
@@ -351,12 +353,12 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
             }
 
             val bobsFakeCash = bobNode.database.transaction {
-                fillUpForBuyer(false, issuer, AnonymousParty(bobNode.info.chooseIdentity().owningKey), notary)
+                fillUpForBuyer(false, issuer, AnonymousParty(bob.owningKey), notary)
             }.second
             val bobsSignedTxns = insertFakeTransactions(bobsFakeCash, bobNode, notaryNode, bankNode)
             val alicesFakePaper = aliceNode.database.transaction {
-                fillUpForSeller(false, issuer, aliceNode.info.chooseIdentity(),
-                        1200.DOLLARS `issued by` bankNode.info.chooseIdentity().ref(0), attachmentID, notary).second
+                fillUpForSeller(false, issuer, alice,
+                        1200.DOLLARS `issued by` bank.ref(0), attachmentID, notary).second
             }
             val alicesSignedTxns = insertFakeTransactions(alicesFakePaper, aliceNode, notaryNode, bankNode)
 
@@ -433,14 +435,16 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
     fun `track works`() {
         mockNet = MockNetwork(false, cordappPackages = cordappPackages)
         val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = makeNodeWithTracking(ALICE.name)
-        val bobNode = makeNodeWithTracking(BOB.name)
-        val bankNode = makeNodeWithTracking(BOC.name)
-        val issuer = bankNode.info.chooseIdentity().ref(1, 2, 3)
+        val aliceNode = makeNodeWithTracking(ALICE_NAME)
+        val bobNode = makeNodeWithTracking(BOB_NAME)
+        val bankNode = makeNodeWithTracking(BOC_NAME)
 
         mockNet.runNetwork()
         notaryNode.internals.ensureRegistered()
         val notary = aliceNode.services.getDefaultNotary()
+        val alice: Party = aliceNode.info.singleIdentity()
+        val bank: Party = bankNode.info.singleIdentity()
+        val issuer = bank.ref(1, 2, 3)
 
         ledger(aliceNode.services, initialiseSerialization = false) {
             // Insert a prospectus type attachment into the commercial paper transaction.
@@ -461,8 +465,8 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
             insertFakeTransactions(bobsFakeCash, bobNode, notaryNode, bankNode)
 
             val alicesFakePaper = aliceNode.database.transaction {
-                fillUpForSeller(false, issuer, aliceNode.info.chooseIdentity(),
-                        1200.DOLLARS `issued by` bankNode.info.chooseIdentity().ref(0), attachmentID, notary).second
+                fillUpForSeller(false, issuer, alice,
+                        1200.DOLLARS `issued by` bank.ref(0), attachmentID, notary).second
             }
 
             insertFakeTransactions(alicesFakePaper, aliceNode, notaryNode, bankNode)
@@ -587,22 +591,23 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
             expectedMessageSubstring: String
     ) {
         val notaryNode = mockNet.createNotaryNode()
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
-        val bobNode = mockNet.createPartyNode(BOB.name)
-        val bankNode = mockNet.createPartyNode(BOC.name)
-        val issuer = bankNode.info.chooseIdentity().ref(1, 2, 3)
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
+        val bankNode = mockNet.createPartyNode(BOC_NAME)
 
         mockNet.runNetwork()
         notaryNode.internals.ensureRegistered()
         val notary = aliceNode.services.getDefaultNotary()
+        val alice = aliceNode.info.singleIdentity()
+        val bob = bobNode.info.singleIdentity()
+        val bank = bankNode.info.singleIdentity()
+        val issuer = bank.ref(1, 2, 3)
 
         val bobsBadCash = bobNode.database.transaction {
-            fillUpForBuyer(bobError, issuer, bobNode.info.chooseIdentity(),
-                    notary).second
+            fillUpForBuyer(bobError, issuer, bob, notary).second
         }
         val alicesFakePaper = aliceNode.database.transaction {
-            fillUpForSeller(aliceError, issuer, aliceNode.info.chooseIdentity(),
-                    1200.DOLLARS `issued by` issuer, null, notary).second
+            fillUpForSeller(aliceError, issuer, alice,1200.DOLLARS `issued by` issuer, null, notary).second
         }
 
         insertFakeTransactions(bobsBadCash, bobNode, notaryNode, bankNode)
diff --git a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
index 418ffb5142..e65592f70b 100644
--- a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
@@ -58,28 +58,33 @@ class FlowFrameworkTests {
 
     private lateinit var mockNet: MockNetwork
     private val receivedSessionMessages = ArrayList<SessionTransfer>()
-    private lateinit var node1: StartedNode<MockNode>
-    private lateinit var node2: StartedNode<MockNode>
-    private lateinit var notary: StartedNode<MockNode>
+    private lateinit var aliceNode: StartedNode<MockNode>
+    private lateinit var bobNode: StartedNode<MockNode>
     private lateinit var notaryIdentity: Party
+    private lateinit var alice: Party
+    private lateinit var bob: Party
 
     @Before
     fun start() {
         mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin(), cordappPackages = listOf("net.corda.finance.contracts", "net.corda.testing.contracts"))
-        node1 = mockNet.createNode()
-        node2 = mockNet.createNode()
+        aliceNode = mockNet.createNode(legalName = ALICE_NAME)
+        bobNode = mockNet.createNode(legalName = BOB_NAME)
 
         mockNet.runNetwork()
-        node1.internals.ensureRegistered()
+        aliceNode.internals.ensureRegistered()
 
         // We intentionally create our own notary and ignore the one provided by the network
         // Note that these notaries don't operate correctly as they don't share their state. They are only used for testing
         // service addressing.
-        notary = mockNet.createNotaryNode()
+        val notary = mockNet.createNotaryNode()
 
         receivedSessionMessagesObservable().forEach { receivedSessionMessages += it }
         mockNet.runNetwork()
-        notaryIdentity = notary.services.myInfo.legalIdentities[1]
+
+        // Extract identities
+        alice = aliceNode.info.singleIdentity()
+        bob = bobNode.info.singleIdentity()
+        notaryIdentity = notary.services.getDefaultNotary()
     }
 
     @After
@@ -90,24 +95,24 @@ class FlowFrameworkTests {
 
     @Test
     fun `newly added flow is preserved on restart`() {
-        node1.services.startFlow(NoOpFlow(nonTerminating = true))
-        node1.internals.acceptableLiveFiberCountOnStop = 1
-        val restoredFlow = node1.restartAndGetRestoredFlow<NoOpFlow>()
+        aliceNode.services.startFlow(NoOpFlow(nonTerminating = true))
+        aliceNode.internals.acceptableLiveFiberCountOnStop = 1
+        val restoredFlow = aliceNode.restartAndGetRestoredFlow<NoOpFlow>()
         assertThat(restoredFlow.flowStarted).isTrue()
     }
 
     @Test
     fun `flow can lazily use the serviceHub in its constructor`() {
         val flow = LazyServiceHubAccessFlow()
-        node1.services.startFlow(flow)
+        aliceNode.services.startFlow(flow)
         assertThat(flow.lazyTime).isNotNull()
     }
 
     @Test
     fun `exception while fiber suspended`() {
-        node2.registerFlowFactory(ReceiveFlow::class) { InitiatedSendFlow("Hello", it) }
-        val flow = ReceiveFlow(node2.info.chooseIdentity())
-        val fiber = node1.services.startFlow(flow) as FlowStateMachineImpl
+        bobNode.registerFlowFactory(ReceiveFlow::class) { InitiatedSendFlow("Hello", it) }
+        val flow = ReceiveFlow(bob)
+        val fiber = aliceNode.services.startFlow(flow) as FlowStateMachineImpl
         // Before the flow runs change the suspend action to throw an exception
         val exceptionDuringSuspend = Exception("Thrown during suspend")
         fiber.actionOnSuspend = {
@@ -117,31 +122,31 @@ class FlowFrameworkTests {
         assertThatThrownBy {
             fiber.resultFuture.getOrThrow()
         }.isSameAs(exceptionDuringSuspend)
-        assertThat(node1.smm.allStateMachines).isEmpty()
+        assertThat(aliceNode.smm.allStateMachines).isEmpty()
         // Make sure the fiber does actually terminate
         assertThat(fiber.isTerminated).isTrue()
     }
 
     @Test
     fun `flow restarted just after receiving payload`() {
-        node2.registerFlowFactory(SendFlow::class) { InitiatedReceiveFlow(it).nonTerminating() }
-        node1.services.startFlow(SendFlow("Hello", node2.info.chooseIdentity()))
+        bobNode.registerFlowFactory(SendFlow::class) { InitiatedReceiveFlow(it).nonTerminating() }
+        aliceNode.services.startFlow(SendFlow("Hello", bob))
 
         // We push through just enough messages to get only the payload sent
-        node2.pumpReceive()
-        node2.internals.disableDBCloseOnStop()
-        node2.internals.acceptableLiveFiberCountOnStop = 1
-        node2.dispose()
+        bobNode.pumpReceive()
+        bobNode.internals.disableDBCloseOnStop()
+        bobNode.internals.acceptableLiveFiberCountOnStop = 1
+        bobNode.dispose()
         mockNet.runNetwork()
-        val restoredFlow = node2.restartAndGetRestoredFlow<InitiatedReceiveFlow>()
+        val restoredFlow = bobNode.restartAndGetRestoredFlow<InitiatedReceiveFlow>()
         assertThat(restoredFlow.receivedPayloads[0]).isEqualTo("Hello")
     }
 
     @Test
     fun `flow added before network map does run after init`() {
-        val node3 = mockNet.createNode() //create vanilla node
+        val charlieNode = mockNet.createNode() //create vanilla node
         val flow = NoOpFlow()
-        node3.services.startFlow(flow)
+        charlieNode.services.startFlow(flow)
         assertEquals(false, flow.flowStarted) // Not started yet as no network activity has been allowed yet
         mockNet.runNetwork() // Allow network map messages to flow
         assertEquals(true, flow.flowStarted) // Now we should have run the flow
@@ -149,40 +154,40 @@ class FlowFrameworkTests {
 
     @Test
     fun `flow added before network map will be init checkpointed`() {
-        var node3 = mockNet.createNode() //create vanilla node
+        var charlieNode = mockNet.createNode() //create vanilla node
         val flow = NoOpFlow()
-        node3.services.startFlow(flow)
+        charlieNode.services.startFlow(flow)
         assertEquals(false, flow.flowStarted) // Not started yet as no network activity has been allowed yet
-        node3.internals.disableDBCloseOnStop()
-        node3.services.networkMapCache.clearNetworkMapCache() // zap persisted NetworkMapCache to force use of network.
-        node3.dispose()
+        charlieNode.internals.disableDBCloseOnStop()
+        charlieNode.services.networkMapCache.clearNetworkMapCache() // zap persisted NetworkMapCache to force use of network.
+        charlieNode.dispose()
 
-        node3 = mockNet.createNode(node3.internals.id)
-        val restoredFlow = node3.getSingleFlow<NoOpFlow>().first
+        charlieNode = mockNet.createNode(charlieNode.internals.id)
+        val restoredFlow = charlieNode.getSingleFlow<NoOpFlow>().first
         assertEquals(false, restoredFlow.flowStarted) // Not started yet as no network activity has been allowed yet
         mockNet.runNetwork() // Allow network map messages to flow
-        node3.smm.executor.flush()
+        charlieNode.smm.executor.flush()
         assertEquals(true, restoredFlow.flowStarted) // Now we should have run the flow and hopefully cleared the init checkpoint
-        node3.internals.disableDBCloseOnStop()
-        node3.services.networkMapCache.clearNetworkMapCache() // zap persisted NetworkMapCache to force use of network.
-        node3.dispose()
+        charlieNode.internals.disableDBCloseOnStop()
+        charlieNode.services.networkMapCache.clearNetworkMapCache() // zap persisted NetworkMapCache to force use of network.
+        charlieNode.dispose()
 
         // Now it is completed the flow should leave no Checkpoint.
-        node3 = mockNet.createNode(node3.internals.id)
+        charlieNode = mockNet.createNode(charlieNode.internals.id)
         mockNet.runNetwork() // Allow network map messages to flow
-        node3.smm.executor.flush()
-        assertTrue(node3.smm.findStateMachines(NoOpFlow::class.java).isEmpty())
+        charlieNode.smm.executor.flush()
+        assertTrue(charlieNode.smm.findStateMachines(NoOpFlow::class.java).isEmpty())
     }
 
     @Test
     fun `flow loaded from checkpoint will respond to messages from before start`() {
-        node1.registerFlowFactory(ReceiveFlow::class) { InitiatedSendFlow("Hello", it) }
-        node2.services.startFlow(ReceiveFlow(node1.info.chooseIdentity()).nonTerminating()) // Prepare checkpointed receive flow
+        aliceNode.registerFlowFactory(ReceiveFlow::class) { InitiatedSendFlow("Hello", it) }
+        bobNode.services.startFlow(ReceiveFlow(alice).nonTerminating()) // Prepare checkpointed receive flow
         // Make sure the add() has finished initial processing.
-        node2.smm.executor.flush()
-        node2.internals.disableDBCloseOnStop()
-        node2.dispose() // kill receiver
-        val restoredFlow = node2.restartAndGetRestoredFlow<ReceiveFlow>()
+        bobNode.smm.executor.flush()
+        bobNode.internals.disableDBCloseOnStop()
+        bobNode.dispose() // kill receiver
+        val restoredFlow = bobNode.restartAndGetRestoredFlow<ReceiveFlow>()
         assertThat(restoredFlow.receivedPayloads[0]).isEqualTo("Hello")
     }
 
@@ -194,26 +199,27 @@ class FlowFrameworkTests {
         var sentCount = 0
         mockNet.messagingNetwork.sentMessages.toSessionTransfers().filter { it.isPayloadTransfer }.forEach { sentCount++ }
 
-        val node3 = mockNet.createNode()
-        val secondFlow = node3.registerFlowFactory(PingPongFlow::class) { PingPongFlow(it, payload2) }
+        val charlieNode = mockNet.createNode(legalName = CHARLIE_NAME)
+        val secondFlow = charlieNode.registerFlowFactory(PingPongFlow::class) { PingPongFlow(it, payload2) }
         mockNet.runNetwork()
+        val charlie = charlieNode.info.singleIdentity()
 
         // Kick off first send and receive
-        node2.services.startFlow(PingPongFlow(node3.info.chooseIdentity(), payload))
-        node2.database.transaction {
-            assertEquals(1, node2.checkpointStorage.checkpoints().size)
+        bobNode.services.startFlow(PingPongFlow(charlie, payload))
+        bobNode.database.transaction {
+            assertEquals(1, bobNode.checkpointStorage.checkpoints().size)
         }
         // Make sure the add() has finished initial processing.
-        node2.smm.executor.flush()
-        node2.internals.disableDBCloseOnStop()
+        bobNode.smm.executor.flush()
+        bobNode.internals.disableDBCloseOnStop()
         // Restart node and thus reload the checkpoint and resend the message with same UUID
-        node2.dispose()
-        node2.database.transaction {
-            assertEquals(1, node2.checkpointStorage.checkpoints().size) // confirm checkpoint
-            node2.services.networkMapCache.clearNetworkMapCache()
+        bobNode.dispose()
+        bobNode.database.transaction {
+            assertEquals(1, bobNode.checkpointStorage.checkpoints().size) // confirm checkpoint
+            bobNode.services.networkMapCache.clearNetworkMapCache()
         }
-        val node2b = mockNet.createNode(node2.internals.id)
-        node2.internals.manuallyCloseDB()
+        val node2b = mockNet.createNode(bobNode.internals.id)
+        bobNode.internals.manuallyCloseDB()
         val (firstAgain, fut1) = node2b.getSingleFlow<PingPongFlow>()
         // Run the network which will also fire up the second flow. First message should get deduped. So message data stays in sync.
         mockNet.runNetwork()
@@ -228,8 +234,8 @@ class FlowFrameworkTests {
         node2b.database.transaction {
             assertEquals(0, node2b.checkpointStorage.checkpoints().size, "Checkpoints left after restored flow should have ended")
         }
-        node3.database.transaction {
-            assertEquals(0, node3.checkpointStorage.checkpoints().size, "Checkpoints left after restored flow should have ended")
+        charlieNode.database.transaction {
+            assertEquals(0, charlieNode.checkpointStorage.checkpoints().size, "Checkpoints left after restored flow should have ended")
         }
         assertEquals(payload2, firstAgain.receivedPayload, "Received payload does not match the first value on Node 3")
         assertEquals(payload2 + 1, firstAgain.receivedPayload2, "Received payload does not match the expected second value on Node 3")
@@ -239,87 +245,89 @@ class FlowFrameworkTests {
 
     @Test
     fun `sending to multiple parties`() {
-        val node3 = mockNet.createNode()
+        val charlieNode = mockNet.createNode(legalName = CHARLIE_NAME)
         mockNet.runNetwork()
-        node2.registerFlowFactory(SendFlow::class) { InitiatedReceiveFlow(it).nonTerminating() }
-        node3.registerFlowFactory(SendFlow::class) { InitiatedReceiveFlow(it).nonTerminating() }
+        val charlie = charlieNode.info.singleIdentity()
+        bobNode.registerFlowFactory(SendFlow::class) { InitiatedReceiveFlow(it).nonTerminating() }
+        charlieNode.registerFlowFactory(SendFlow::class) { InitiatedReceiveFlow(it).nonTerminating() }
         val payload = "Hello World"
-        node1.services.startFlow(SendFlow(payload, node2.info.chooseIdentity(), node3.info.chooseIdentity()))
+        aliceNode.services.startFlow(SendFlow(payload, bob, charlie))
         mockNet.runNetwork()
-        val node2Flow = node2.getSingleFlow<InitiatedReceiveFlow>().first
-        val node3Flow = node3.getSingleFlow<InitiatedReceiveFlow>().first
-        assertThat(node2Flow.receivedPayloads[0]).isEqualTo(payload)
-        assertThat(node3Flow.receivedPayloads[0]).isEqualTo(payload)
+        val bobFlow = bobNode.getSingleFlow<InitiatedReceiveFlow>().first
+        val charlieFlow = charlieNode.getSingleFlow<InitiatedReceiveFlow>().first
+        assertThat(bobFlow.receivedPayloads[0]).isEqualTo(payload)
+        assertThat(charlieFlow.receivedPayloads[0]).isEqualTo(payload)
 
-        assertSessionTransfers(node2,
-                node1 sent sessionInit(SendFlow::class, payload = payload) to node2,
-                node2 sent sessionConfirm() to node1,
-                node1 sent normalEnd to node2
+        assertSessionTransfers(bobNode,
+                aliceNode sent sessionInit(SendFlow::class, payload = payload) to bobNode,
+                bobNode sent sessionConfirm() to aliceNode,
+                aliceNode sent normalEnd to bobNode
                 //There's no session end from the other flows as they're manually suspended
         )
 
-        assertSessionTransfers(node3,
-                node1 sent sessionInit(SendFlow::class, payload = payload) to node3,
-                node3 sent sessionConfirm() to node1,
-                node1 sent normalEnd to node3
+        assertSessionTransfers(charlieNode,
+                aliceNode sent sessionInit(SendFlow::class, payload = payload) to charlieNode,
+                charlieNode sent sessionConfirm() to aliceNode,
+                aliceNode sent normalEnd to charlieNode
                 //There's no session end from the other flows as they're manually suspended
         )
 
-        node2.internals.acceptableLiveFiberCountOnStop = 1
-        node3.internals.acceptableLiveFiberCountOnStop = 1
+        bobNode.internals.acceptableLiveFiberCountOnStop = 1
+        charlieNode.internals.acceptableLiveFiberCountOnStop = 1
     }
 
     @Test
     fun `receiving from multiple parties`() {
-        val node3 = mockNet.createNode()
+        val charlieNode = mockNet.createNode(legalName = CHARLIE_NAME)
         mockNet.runNetwork()
-        val node2Payload = "Test 1"
-        val node3Payload = "Test 2"
-        node2.registerFlowFactory(ReceiveFlow::class) { InitiatedSendFlow(node2Payload, it) }
-        node3.registerFlowFactory(ReceiveFlow::class) { InitiatedSendFlow(node3Payload, it) }
-        val multiReceiveFlow = ReceiveFlow(node2.info.chooseIdentity(), node3.info.chooseIdentity()).nonTerminating()
-        node1.services.startFlow(multiReceiveFlow)
-        node1.internals.acceptableLiveFiberCountOnStop = 1
+        val charlie = charlieNode.info.singleIdentity()
+        val bobPayload = "Test 1"
+        val charliePayload = "Test 2"
+        bobNode.registerFlowFactory(ReceiveFlow::class) { InitiatedSendFlow(bobPayload, it) }
+        charlieNode.registerFlowFactory(ReceiveFlow::class) { InitiatedSendFlow(charliePayload, it) }
+        val multiReceiveFlow = ReceiveFlow(bob, charlie).nonTerminating()
+        aliceNode.services.startFlow(multiReceiveFlow)
+        aliceNode.internals.acceptableLiveFiberCountOnStop = 1
         mockNet.runNetwork()
-        assertThat(multiReceiveFlow.receivedPayloads[0]).isEqualTo(node2Payload)
-        assertThat(multiReceiveFlow.receivedPayloads[1]).isEqualTo(node3Payload)
+        assertThat(multiReceiveFlow.receivedPayloads[0]).isEqualTo(bobPayload)
+        assertThat(multiReceiveFlow.receivedPayloads[1]).isEqualTo(charliePayload)
 
-        assertSessionTransfers(node2,
-                node1 sent sessionInit(ReceiveFlow::class) to node2,
-                node2 sent sessionConfirm() to node1,
-                node2 sent sessionData(node2Payload) to node1,
-                node2 sent normalEnd to node1
+        assertSessionTransfers(bobNode,
+                aliceNode sent sessionInit(ReceiveFlow::class) to bobNode,
+                bobNode sent sessionConfirm() to aliceNode,
+                bobNode sent sessionData(bobPayload) to aliceNode,
+                bobNode sent normalEnd to aliceNode
         )
 
-        assertSessionTransfers(node3,
-                node1 sent sessionInit(ReceiveFlow::class) to node3,
-                node3 sent sessionConfirm() to node1,
-                node3 sent sessionData(node3Payload) to node1,
-                node3 sent normalEnd to node1
+        assertSessionTransfers(charlieNode,
+                aliceNode sent sessionInit(ReceiveFlow::class) to charlieNode,
+                charlieNode sent sessionConfirm() to aliceNode,
+                charlieNode sent sessionData(charliePayload) to aliceNode,
+                charlieNode sent normalEnd to aliceNode
         )
     }
 
     @Test
     fun `both sides do a send as their first IO request`() {
-        node2.registerFlowFactory(PingPongFlow::class) { PingPongFlow(it, 20L) }
-        node1.services.startFlow(PingPongFlow(node2.info.chooseIdentity(), 10L))
+        bobNode.registerFlowFactory(PingPongFlow::class) { PingPongFlow(it, 20L) }
+        aliceNode.services.startFlow(PingPongFlow(bob, 10L))
         mockNet.runNetwork()
 
         assertSessionTransfers(
-                node1 sent sessionInit(PingPongFlow::class, payload = 10L) to node2,
-                node2 sent sessionConfirm() to node1,
-                node2 sent sessionData(20L) to node1,
-                node1 sent sessionData(11L) to node2,
-                node2 sent sessionData(21L) to node1,
-                node1 sent normalEnd to node2,
-                node2 sent normalEnd to node1
+                aliceNode sent sessionInit(PingPongFlow::class, payload = 10L) to bobNode,
+                bobNode sent sessionConfirm() to aliceNode,
+                bobNode sent sessionData(20L) to aliceNode,
+                aliceNode sent sessionData(11L) to bobNode,
+                bobNode sent sessionData(21L) to aliceNode,
+                aliceNode sent normalEnd to bobNode,
+                bobNode sent normalEnd to aliceNode
         )
     }
 
     @Test
     fun `other side ends before doing expected send`() {
-        node2.registerFlowFactory(ReceiveFlow::class) { NoOpFlow() }
-        val resultFuture = node1.services.startFlow(ReceiveFlow(node2.info.chooseIdentity())).resultFuture
+        bobNode.registerFlowFactory(ReceiveFlow::class) { NoOpFlow() }
+        val resultFuture = aliceNode.services.startFlow(ReceiveFlow(bob)).resultFuture
         mockNet.runNetwork()
         assertThatExceptionOfType(UnexpectedFlowEndException::class.java).isThrownBy {
             resultFuture.getOrThrow()
@@ -328,11 +336,11 @@ class FlowFrameworkTests {
 
     @Test
     fun `receiving unexpected session end before entering sendAndReceive`() {
-        node2.registerFlowFactory(WaitForOtherSideEndBeforeSendAndReceive::class) { NoOpFlow() }
+        bobNode.registerFlowFactory(WaitForOtherSideEndBeforeSendAndReceive::class) { NoOpFlow() }
         val sessionEndReceived = Semaphore(0)
         receivedSessionMessagesObservable().filter { it.message is SessionEnd }.subscribe { sessionEndReceived.release() }
-        val resultFuture = node1.services.startFlow(
-                WaitForOtherSideEndBeforeSendAndReceive(node2.info.chooseIdentity(), sessionEndReceived)).resultFuture
+        val resultFuture = aliceNode.services.startFlow(
+                WaitForOtherSideEndBeforeSendAndReceive(bob, sessionEndReceived)).resultFuture
         mockNet.runNetwork()
         assertThatExceptionOfType(UnexpectedFlowEndException::class.java).isThrownBy {
             resultFuture.getOrThrow()
@@ -355,14 +363,14 @@ class FlowFrameworkTests {
 
     @Test
     fun `non-FlowException thrown on other side`() {
-        val erroringFlowFuture = node2.registerFlowFactory(ReceiveFlow::class) {
+        val erroringFlowFuture = bobNode.registerFlowFactory(ReceiveFlow::class) {
             ExceptionFlow { Exception("evil bug!") }
         }
         val erroringFlowSteps = erroringFlowFuture.flatMap { it.progressSteps }
 
-        val receiveFlow = ReceiveFlow(node2.info.chooseIdentity())
+        val receiveFlow = ReceiveFlow(bob)
         val receiveFlowSteps = receiveFlow.progressSteps
-        val receiveFlowResult = node1.services.startFlow(receiveFlow).resultFuture
+        val receiveFlowResult = aliceNode.services.startFlow(receiveFlow).resultFuture
 
         mockNet.runNetwork()
 
@@ -381,20 +389,20 @@ class FlowFrameworkTests {
         )
 
         assertSessionTransfers(
-                node1 sent sessionInit(ReceiveFlow::class) to node2,
-                node2 sent sessionConfirm() to node1,
-                node2 sent erroredEnd() to node1
+                aliceNode sent sessionInit(ReceiveFlow::class) to bobNode,
+                bobNode sent sessionConfirm() to aliceNode,
+                bobNode sent erroredEnd() to aliceNode
         )
     }
 
     @Test
     fun `FlowException thrown on other side`() {
-        val erroringFlow = node2.registerFlowFactory(ReceiveFlow::class) {
+        val erroringFlow = bobNode.registerFlowFactory(ReceiveFlow::class) {
             ExceptionFlow { MyFlowException("Nothing useful") }
         }
         val erroringFlowSteps = erroringFlow.flatMap { it.progressSteps }
 
-        val receivingFiber = node1.services.startFlow(ReceiveFlow(node2.info.chooseIdentity())) as FlowStateMachineImpl
+        val receivingFiber = aliceNode.services.startFlow(ReceiveFlow(bob)) as FlowStateMachineImpl
 
         mockNet.runNetwork()
 
@@ -402,8 +410,8 @@ class FlowFrameworkTests {
                 .isThrownBy { receivingFiber.resultFuture.getOrThrow() }
                 .withMessage("Nothing useful")
                 .withStackTraceContaining(ReceiveFlow::class.java.name)  // Make sure the stack trace is that of the receiving flow
-        node2.database.transaction {
-            assertThat(node2.checkpointStorage.checkpoints()).isEmpty()
+        bobNode.database.transaction {
+            assertThat(bobNode.checkpointStorage.checkpoints()).isEmpty()
         }
 
         assertThat(receivingFiber.isTerminated).isTrue()
@@ -414,9 +422,9 @@ class FlowFrameworkTests {
         )
 
         assertSessionTransfers(
-                node1 sent sessionInit(ReceiveFlow::class) to node2,
-                node2 sent sessionConfirm() to node1,
-                node2 sent erroredEnd(erroringFlow.get().exceptionThrown) to node1
+                aliceNode sent sessionInit(ReceiveFlow::class) to bobNode,
+                bobNode sent sessionConfirm() to aliceNode,
+                bobNode sent erroredEnd(erroringFlow.get().exceptionThrown) to aliceNode
         )
         // Make sure the original stack trace isn't sent down the wire
         assertThat((receivedSessionMessages.last().message as ErrorSessionEnd).errorResponse!!.stackTrace).isEmpty()
@@ -424,12 +432,13 @@ class FlowFrameworkTests {
 
     @Test
     fun `FlowException propagated in invocation chain`() {
-        val node3 = mockNet.createNode()
+        val charlieNode = mockNet.createNode(legalName = CHARLIE_NAME)
         mockNet.runNetwork()
+        val charlie = charlieNode.info.singleIdentity()
 
-        node3.registerFlowFactory(ReceiveFlow::class) { ExceptionFlow { MyFlowException("Chain") } }
-        node2.registerFlowFactory(ReceiveFlow::class) { ReceiveFlow(node3.info.chooseIdentity()) }
-        val receivingFiber = node1.services.startFlow(ReceiveFlow(node2.info.chooseIdentity()))
+        charlieNode.registerFlowFactory(ReceiveFlow::class) { ExceptionFlow { MyFlowException("Chain") } }
+        bobNode.registerFlowFactory(ReceiveFlow::class) { ReceiveFlow(charlie) }
+        val receivingFiber = aliceNode.services.startFlow(ReceiveFlow(bob))
         mockNet.runNetwork()
         assertThatExceptionOfType(MyFlowException::class.java)
                 .isThrownBy { receivingFiber.resultFuture.getOrThrow() }
@@ -438,34 +447,35 @@ class FlowFrameworkTests {
 
     @Test
     fun `FlowException thrown and there is a 3rd unrelated party flow`() {
-        val node3 = mockNet.createNode()
+        val charlieNode = mockNet.createNode(legalName = CHARLIE_NAME)
         mockNet.runNetwork()
+        val charlie = charlieNode.info.singleIdentity()
 
-        // Node 2 will send its payload and then block waiting for the receive from node 1. Meanwhile node 1 will move
-        // onto node 3 which will throw the exception
-        val node2Fiber = node2
+        // Bob will send its payload and then block waiting for the receive from Alice. Meanwhile Alice will move
+        // onto Charlie which will throw the exception
+        val node2Fiber = bobNode
                 .registerFlowFactory(ReceiveFlow::class) { SendAndReceiveFlow(it, "Hello") }
                 .map { it.stateMachine }
-        node3.registerFlowFactory(ReceiveFlow::class) { ExceptionFlow { MyFlowException("Nothing useful") } }
+        charlieNode.registerFlowFactory(ReceiveFlow::class) { ExceptionFlow { MyFlowException("Nothing useful") } }
 
-        val node1Fiber = node1.services.startFlow(ReceiveFlow(node2.info.chooseIdentity(), node3.info.chooseIdentity())) as FlowStateMachineImpl
+        val aliceFiber = aliceNode.services.startFlow(ReceiveFlow(bob, charlie)) as FlowStateMachineImpl
         mockNet.runNetwork()
 
-        // Node 1 will terminate with the error it received from node 3 but it won't propagate that to node 2 (as it's
+        // Alice will terminate with the error it received from Charlie but it won't propagate that to Bob (as it's
         // not relevant to it) but it will end its session with it
         assertThatExceptionOfType(MyFlowException::class.java).isThrownBy {
-            node1Fiber.resultFuture.getOrThrow()
+            aliceFiber.resultFuture.getOrThrow()
         }
-        val node2ResultFuture = node2Fiber.getOrThrow().resultFuture
+        val bobResultFuture = node2Fiber.getOrThrow().resultFuture
         assertThatExceptionOfType(UnexpectedFlowEndException::class.java).isThrownBy {
-            node2ResultFuture.getOrThrow()
+            bobResultFuture.getOrThrow()
         }
 
-        assertSessionTransfers(node2,
-                node1 sent sessionInit(ReceiveFlow::class) to node2,
-                node2 sent sessionConfirm() to node1,
-                node2 sent sessionData("Hello") to node1,
-                node1 sent erroredEnd() to node2
+        assertSessionTransfers(bobNode,
+                aliceNode sent sessionInit(ReceiveFlow::class) to bobNode,
+                bobNode sent sessionConfirm() to aliceNode,
+                bobNode sent sessionData("Hello") to aliceNode,
+                aliceNode sent erroredEnd() to bobNode
         )
     }
 
@@ -499,16 +509,16 @@ class FlowFrameworkTests {
             }
         }
 
-        node2.registerFlowFactory(AskForExceptionFlow::class) { ConditionalExceptionFlow(it, "Hello") }
-        val resultFuture = node1.services.startFlow(RetryOnExceptionFlow(node2.info.chooseIdentity())).resultFuture
+        bobNode.registerFlowFactory(AskForExceptionFlow::class) { ConditionalExceptionFlow(it, "Hello") }
+        val resultFuture = aliceNode.services.startFlow(RetryOnExceptionFlow(bob)).resultFuture
         mockNet.runNetwork()
         assertThat(resultFuture.getOrThrow()).isEqualTo("Hello")
     }
 
     @Test
     fun `serialisation issue in counterparty`() {
-        node2.registerFlowFactory(ReceiveFlow::class) { InitiatedSendFlow(NonSerialisableData(1), it) }
-        val result = node1.services.startFlow(ReceiveFlow(node2.info.chooseIdentity())).resultFuture
+        bobNode.registerFlowFactory(ReceiveFlow::class) { InitiatedSendFlow(NonSerialisableData(1), it) }
+        val result = aliceNode.services.startFlow(ReceiveFlow(bob)).resultFuture
         mockNet.runNetwork()
         assertThatExceptionOfType(UnexpectedFlowEndException::class.java).isThrownBy {
             result.getOrThrow()
@@ -517,10 +527,10 @@ class FlowFrameworkTests {
 
     @Test
     fun `FlowException has non-serialisable object`() {
-        node2.registerFlowFactory(ReceiveFlow::class) {
+        bobNode.registerFlowFactory(ReceiveFlow::class) {
             ExceptionFlow { NonSerialisableFlowException(NonSerialisableData(1)) }
         }
-        val result = node1.services.startFlow(ReceiveFlow(node2.info.chooseIdentity())).resultFuture
+        val result = aliceNode.services.startFlow(ReceiveFlow(bob)).resultFuture
         mockNet.runNetwork()
         assertThatExceptionOfType(FlowException::class.java).isThrownBy {
             result.getOrThrow()
@@ -531,13 +541,13 @@ class FlowFrameworkTests {
     fun `wait for transaction`() {
         val ptx = TransactionBuilder(notary = notaryIdentity)
                 .addOutputState(DummyState(), DummyContract.PROGRAM_ID)
-                .addCommand(dummyCommand(node1.info.chooseIdentity().owningKey))
-        val stx = node1.services.signInitialTransaction(ptx)
+                .addCommand(dummyCommand(alice.owningKey))
+        val stx = aliceNode.services.signInitialTransaction(ptx)
 
-        val committerFiber = node1.registerFlowFactory(WaitingFlows.Waiter::class) {
+        val committerFiber = aliceNode.registerFlowFactory(WaitingFlows.Waiter::class) {
             WaitingFlows.Committer(it)
         }.map { it.stateMachine }
-        val waiterStx = node2.services.startFlow(WaitingFlows.Waiter(stx, node1.info.chooseIdentity())).resultFuture
+        val waiterStx = bobNode.services.startFlow(WaitingFlows.Waiter(stx, alice)).resultFuture
         mockNet.runNetwork()
         assertThat(waiterStx.getOrThrow()).isEqualTo(committerFiber.getOrThrow().resultFuture.getOrThrow())
     }
@@ -547,12 +557,12 @@ class FlowFrameworkTests {
         val ptx = TransactionBuilder(notary = notaryIdentity)
                 .addOutputState(DummyState(), DummyContract.PROGRAM_ID)
                 .addCommand(dummyCommand())
-        val stx = node1.services.signInitialTransaction(ptx)
+        val stx = aliceNode.services.signInitialTransaction(ptx)
 
-        node1.registerFlowFactory(WaitingFlows.Waiter::class) {
+        aliceNode.registerFlowFactory(WaitingFlows.Waiter::class) {
             WaitingFlows.Committer(it) { throw Exception("Error") }
         }
-        val waiter = node2.services.startFlow(WaitingFlows.Waiter(stx, node1.info.chooseIdentity())).resultFuture
+        val waiter = bobNode.services.startFlow(WaitingFlows.Waiter(stx, alice)).resultFuture
         mockNet.runNetwork()
         assertThatExceptionOfType(UnexpectedFlowEndException::class.java).isThrownBy {
             waiter.getOrThrow()
@@ -563,13 +573,13 @@ class FlowFrameworkTests {
     fun `verify vault query service is tokenizable by force checkpointing within a flow`() {
         val ptx = TransactionBuilder(notary = notaryIdentity)
                 .addOutputState(DummyState(), DummyContract.PROGRAM_ID)
-                .addCommand(dummyCommand(node1.info.chooseIdentity().owningKey))
-        val stx = node1.services.signInitialTransaction(ptx)
+                .addCommand(dummyCommand(alice.owningKey))
+        val stx = aliceNode.services.signInitialTransaction(ptx)
 
-        node1.registerFlowFactory(VaultQueryFlow::class) {
+        aliceNode.registerFlowFactory(VaultQueryFlow::class) {
             WaitingFlows.Committer(it)
         }
-        val result = node2.services.startFlow(VaultQueryFlow(stx, node1.info.chooseIdentity())).resultFuture
+        val result = bobNode.services.startFlow(VaultQueryFlow(stx, alice)).resultFuture
 
         mockNet.runNetwork()
         assertThat(result.getOrThrow()).isEmpty()
@@ -577,15 +587,15 @@ class FlowFrameworkTests {
 
     @Test
     fun `customised client flow`() {
-        val receiveFlowFuture = node2.registerFlowFactory(SendFlow::class) { InitiatedReceiveFlow(it) }
-        node1.services.startFlow(CustomSendFlow("Hello", node2.info.chooseIdentity())).resultFuture
+        val receiveFlowFuture = bobNode.registerFlowFactory(SendFlow::class) { InitiatedReceiveFlow(it) }
+        aliceNode.services.startFlow(CustomSendFlow("Hello", bob)).resultFuture
         mockNet.runNetwork()
         assertThat(receiveFlowFuture.getOrThrow().receivedPayloads).containsOnly("Hello")
     }
 
     @Test
     fun `customised client flow which has annotated @InitiatingFlow again`() {
-        val result = node1.services.startFlow(IncorrectCustomSendFlow("Hello", node2.info.chooseIdentity())).resultFuture
+        val result = aliceNode.services.startFlow(IncorrectCustomSendFlow("Hello", bob)).resultFuture
         mockNet.runNetwork()
         assertThatExceptionOfType(IllegalArgumentException::class.java).isThrownBy {
             result.getOrThrow()
@@ -594,12 +604,12 @@ class FlowFrameworkTests {
 
     @Test
     fun `upgraded initiating flow`() {
-        node2.registerFlowFactory(UpgradedFlow::class, initiatedFlowVersion = 1) { InitiatedSendFlow("Old initiated", it) }
-        val result = node1.services.startFlow(UpgradedFlow(node2.info.chooseIdentity())).resultFuture
+        bobNode.registerFlowFactory(UpgradedFlow::class, initiatedFlowVersion = 1) { InitiatedSendFlow("Old initiated", it) }
+        val result = aliceNode.services.startFlow(UpgradedFlow(bob)).resultFuture
         mockNet.runNetwork()
         assertThat(receivedSessionMessages).startsWith(
-                node1 sent sessionInit(UpgradedFlow::class, flowVersion = 2) to node2,
-                node2 sent sessionConfirm(flowVersion = 1) to node1
+                aliceNode sent sessionInit(UpgradedFlow::class, flowVersion = 2) to bobNode,
+                bobNode sent sessionConfirm(flowVersion = 1) to aliceNode
         )
         val (receivedPayload, node2FlowVersion) = result.getOrThrow()
         assertThat(receivedPayload).isEqualTo("Old initiated")
@@ -608,20 +618,20 @@ class FlowFrameworkTests {
 
     @Test
     fun `upgraded initiated flow`() {
-        node2.registerFlowFactory(SendFlow::class, initiatedFlowVersion = 2) { UpgradedFlow(it) }
-        val initiatingFlow = SendFlow("Old initiating", node2.info.chooseIdentity())
-        val flowInfo = node1.services.startFlow(initiatingFlow).resultFuture
+        bobNode.registerFlowFactory(SendFlow::class, initiatedFlowVersion = 2) { UpgradedFlow(it) }
+        val initiatingFlow = SendFlow("Old initiating", bob)
+        val flowInfo = aliceNode.services.startFlow(initiatingFlow).resultFuture
         mockNet.runNetwork()
         assertThat(receivedSessionMessages).startsWith(
-                node1 sent sessionInit(SendFlow::class, flowVersion = 1, payload = "Old initiating") to node2,
-                node2 sent sessionConfirm(flowVersion = 2) to node1
+                aliceNode sent sessionInit(SendFlow::class, flowVersion = 1, payload = "Old initiating") to bobNode,
+                bobNode sent sessionConfirm(flowVersion = 2) to aliceNode
         )
         assertThat(flowInfo.get().flowVersion).isEqualTo(2)
     }
 
     @Test
     fun `unregistered flow`() {
-        val future = node1.services.startFlow(SendFlow("Hello", node2.info.chooseIdentity())).resultFuture
+        val future = aliceNode.services.startFlow(SendFlow("Hello", bob)).resultFuture
         mockNet.runNetwork()
         assertThatExceptionOfType(UnexpectedFlowEndException::class.java)
                 .isThrownBy { future.getOrThrow() }
@@ -630,7 +640,7 @@ class FlowFrameworkTests {
 
     @Test
     fun `unknown class in session init`() {
-        node1.sendSessionMessage(SessionInit(random63BitValue(), "not.a.real.Class", 1, "version", null), node2)
+        aliceNode.sendSessionMessage(SessionInit(random63BitValue(), "not.a.real.Class", 1, "version", null), bob)
         mockNet.runNetwork()
         assertThat(receivedSessionMessages).hasSize(2) // Only the session-init and session-reject are expected
         val reject = receivedSessionMessages.last().message as SessionReject
@@ -639,7 +649,7 @@ class FlowFrameworkTests {
 
     @Test
     fun `non-flow class in session init`() {
-        node1.sendSessionMessage(SessionInit(random63BitValue(), String::class.java.name, 1, "version", null), node2)
+        aliceNode.sendSessionMessage(SessionInit(random63BitValue(), String::class.java.name, 1, "version", null), bob)
         mockNet.runNetwork()
         assertThat(receivedSessionMessages).hasSize(2) // Only the session-init and session-reject are expected
         val reject = receivedSessionMessages.last().message as SessionReject
@@ -648,23 +658,23 @@ class FlowFrameworkTests {
 
     @Test
     fun `single inlined sub-flow`() {
-        node2.registerFlowFactory(SendAndReceiveFlow::class) { SingleInlinedSubFlow(it) }
-        val result = node1.services.startFlow(SendAndReceiveFlow(node2.info.chooseIdentity(), "Hello")).resultFuture
+        bobNode.registerFlowFactory(SendAndReceiveFlow::class) { SingleInlinedSubFlow(it) }
+        val result = aliceNode.services.startFlow(SendAndReceiveFlow(bob, "Hello")).resultFuture
         mockNet.runNetwork()
         assertThat(result.getOrThrow()).isEqualTo("HelloHello")
     }
 
     @Test
     fun `double inlined sub-flow`() {
-        node2.registerFlowFactory(SendAndReceiveFlow::class) { DoubleInlinedSubFlow(it) }
-        val result = node1.services.startFlow(SendAndReceiveFlow(node2.info.chooseIdentity(), "Hello")).resultFuture
+        bobNode.registerFlowFactory(SendAndReceiveFlow::class) { DoubleInlinedSubFlow(it) }
+        val result = aliceNode.services.startFlow(SendAndReceiveFlow(bob, "Hello")).resultFuture
         mockNet.runNetwork()
         assertThat(result.getOrThrow()).isEqualTo("HelloHello")
     }
 
     @Test
     fun `double initiateFlow throws`() {
-        val future = node1.services.startFlow(DoubleInitiatingFlow()).resultFuture
+        val future = aliceNode.services.startFlow(DoubleInitiatingFlow()).resultFuture
         mockNet.runNetwork()
         assertThatExceptionOfType(IllegalStateException::class.java)
                 .isThrownBy { future.getOrThrow() }
@@ -675,8 +685,8 @@ class FlowFrameworkTests {
     private class DoubleInitiatingFlow : FlowLogic<Unit>() {
         @Suspendable
         override fun call() {
-            initiateFlow(serviceHub.myInfo.chooseIdentity())
-            initiateFlow(serviceHub.myInfo.chooseIdentity())
+            initiateFlow(ourIdentity)
+            initiateFlow(ourIdentity)
         }
     }
 
@@ -718,9 +728,9 @@ class FlowFrameworkTests {
     private val normalEnd = NormalSessionEnd(0)
     private fun erroredEnd(errorResponse: FlowException? = null) = ErrorSessionEnd(0, errorResponse)
 
-    private fun StartedNode<*>.sendSessionMessage(message: SessionMessage, destination: StartedNode<*>) {
+    private fun StartedNode<*>.sendSessionMessage(message: SessionMessage, destination: Party) {
         services.networkService.apply {
-            val address = getAddressOfParty(PartyInfo.SingleNode(destination.info.chooseIdentity(), emptyList()))
+            val address = getAddressOfParty(PartyInfo.SingleNode(destination, emptyList()))
             send(createMessage(StateMachineManager.sessionTopic, message.serialize().bytes), address)
         }
     }
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
index f30063aac8..ec8155a18e 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
@@ -8,11 +8,12 @@ import net.corda.core.flows.NotaryError
 import net.corda.core.flows.NotaryException
 import net.corda.core.flows.NotaryFlow
 import net.corda.core.identity.Party
+import net.corda.core.node.ServiceHub
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.seconds
-import net.corda.node.internal.StartedNode
+import net.corda.node.services.api.ServiceHubInternal
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
@@ -27,18 +28,21 @@ import kotlin.test.assertFailsWith
 
 class NotaryServiceTests {
     lateinit var mockNet: MockNetwork
-    lateinit var notaryNode: StartedNode<MockNetwork.MockNode>
-    lateinit var clientNode: StartedNode<MockNetwork.MockNode>
+    lateinit var notaryServices: ServiceHubInternal
+    lateinit var aliceServices: ServiceHubInternal
     lateinit var notary: Party
+    lateinit var alice: Party
 
     @Before
     fun setup() {
         mockNet = MockNetwork(cordappPackages = listOf("net.corda.testing.contracts"))
-        notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name, validating = false)
-        clientNode = mockNet.createNode()
+        val notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name, validating = false)
+        aliceServices = mockNet.createNode(legalName = ALICE_NAME).services
         mockNet.runNetwork() // Clear network map registration messages
         notaryNode.internals.ensureRegistered()
-        notary = clientNode.services.getDefaultNotary()
+        notaryServices = notaryNode.services
+        notary = notaryServices.getDefaultNotary()
+        alice = aliceServices.myInfo.singleIdentity()
     }
 
     @After
@@ -49,12 +53,12 @@ class NotaryServiceTests {
     @Test
     fun `should sign a unique transaction with a valid time-window`() {
         val stx = run {
-            val inputState = issueState(clientNode)
+            val inputState = issueState(aliceServices, alice)
             val tx = TransactionBuilder(notary)
                     .addInputState(inputState)
-                    .addCommand(dummyCommand(clientNode.info.chooseIdentity().owningKey))
+                    .addCommand(dummyCommand(alice.owningKey))
                     .setTimeWindow(Instant.now(), 30.seconds)
-            clientNode.services.signInitialTransaction(tx)
+            aliceServices.signInitialTransaction(tx)
         }
 
         val future = runNotaryClient(stx)
@@ -65,11 +69,11 @@ class NotaryServiceTests {
     @Test
     fun `should sign a unique transaction without a time-window`() {
         val stx = run {
-            val inputState = issueState(clientNode)
+            val inputState = issueState(aliceServices, alice)
             val tx = TransactionBuilder(notary)
                     .addInputState(inputState)
-                    .addCommand(dummyCommand(clientNode.info.chooseIdentity().owningKey))
-            clientNode.services.signInitialTransaction(tx)
+                    .addCommand(dummyCommand(alice.owningKey))
+            aliceServices.signInitialTransaction(tx)
         }
 
         val future = runNotaryClient(stx)
@@ -80,12 +84,12 @@ class NotaryServiceTests {
     @Test
     fun `should report error for transaction with an invalid time-window`() {
         val stx = run {
-            val inputState = issueState(clientNode)
+            val inputState = issueState(aliceServices, alice)
             val tx = TransactionBuilder(notary)
                     .addInputState(inputState)
-                    .addCommand(dummyCommand(clientNode.info.chooseIdentity().owningKey))
+                    .addCommand(dummyCommand(alice.owningKey))
                     .setTimeWindow(Instant.now().plusSeconds(3600), 30.seconds)
-            clientNode.services.signInitialTransaction(tx)
+            aliceServices.signInitialTransaction(tx)
         }
 
         val future = runNotaryClient(stx)
@@ -97,17 +101,17 @@ class NotaryServiceTests {
     @Test
     fun `should sign identical transaction multiple times (signing is idempotent)`() {
         val stx = run {
-            val inputState = issueState(clientNode)
+            val inputState = issueState(aliceServices, alice)
             val tx = TransactionBuilder(notary)
                     .addInputState(inputState)
-                    .addCommand(dummyCommand(clientNode.info.chooseIdentity().owningKey))
-            clientNode.services.signInitialTransaction(tx)
+                    .addCommand(dummyCommand(alice.owningKey))
+            aliceServices.signInitialTransaction(tx)
         }
 
         val firstAttempt = NotaryFlow.Client(stx)
         val secondAttempt = NotaryFlow.Client(stx)
-        val f1 = clientNode.services.startFlow(firstAttempt)
-        val f2 = clientNode.services.startFlow(secondAttempt)
+        val f1 = aliceServices.startFlow(firstAttempt)
+        val f2 = aliceServices.startFlow(secondAttempt)
 
         mockNet.runNetwork()
 
@@ -116,25 +120,25 @@ class NotaryServiceTests {
 
     @Test
     fun `should report conflict when inputs are reused across transactions`() {
-        val inputState = issueState(clientNode)
+        val inputState = issueState(aliceServices, alice)
         val stx = run {
             val tx = TransactionBuilder(notary)
                     .addInputState(inputState)
-                    .addCommand(dummyCommand(clientNode.info.chooseIdentity().owningKey))
-            clientNode.services.signInitialTransaction(tx)
+                    .addCommand(dummyCommand(alice.owningKey))
+            aliceServices.signInitialTransaction(tx)
         }
         val stx2 = run {
             val tx = TransactionBuilder(notary)
                     .addInputState(inputState)
-                    .addInputState(issueState(clientNode))
-                    .addCommand(dummyCommand(clientNode.info.chooseIdentity().owningKey))
-            clientNode.services.signInitialTransaction(tx)
+                    .addInputState(issueState(aliceServices, alice))
+                    .addCommand(dummyCommand(alice.owningKey))
+            aliceServices.signInitialTransaction(tx)
         }
 
         val firstSpend = NotaryFlow.Client(stx)
         val secondSpend = NotaryFlow.Client(stx2) // Double spend the inputState in a second transaction.
-        clientNode.services.startFlow(firstSpend)
-        val future = clientNode.services.startFlow(secondSpend)
+        aliceServices.startFlow(firstSpend)
+        val future = aliceServices.startFlow(secondSpend)
 
         mockNet.runNetwork()
 
@@ -146,16 +150,16 @@ class NotaryServiceTests {
 
     private fun runNotaryClient(stx: SignedTransaction): CordaFuture<List<TransactionSignature>> {
         val flow = NotaryFlow.Client(stx)
-        val future = clientNode.services.startFlow(flow).resultFuture
+        val future = aliceServices.startFlow(flow).resultFuture
         mockNet.runNetwork()
         return future
     }
 
-    fun issueState(node: StartedNode<*>): StateAndRef<*> {
-        val tx = DummyContract.generateInitial(Random().nextInt(), notary, node.info.chooseIdentity().ref(0))
-        val signedByNode = node.services.signInitialTransaction(tx)
-        val stx = notaryNode.services.addSignature(signedByNode, notary.owningKey)
-        node.services.recordTransactions(stx)
+    fun issueState(services: ServiceHub, identity: Party): StateAndRef<*> {
+        val tx = DummyContract.generateInitial(Random().nextInt(), notary, identity.ref(0))
+        val signedByNode = services.signInitialTransaction(tx)
+        val stx = notaryServices.addSignature(signedByNode, notary.owningKey)
+        services.recordTransactions(stx)
         return StateAndRef(tx.outputStates().first(), StateRef(stx.id, 0))
     }
 }
diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
index a137cc41e9..3700848e47 100644
--- a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
@@ -42,8 +42,8 @@ class ValidatingNotaryServiceTests {
         notaryNode.internals.ensureRegistered()
         notaryServices = notaryNode.services
         aliceServices = aliceNode.services
-        notary = notaryServices.networkMapCache.getNotary(DUMMY_NOTARY_SERVICE_NAME)!!
-        alice = aliceServices.myInfo.identityFromX500Name(ALICE_NAME)
+        notary = notaryServices.getDefaultNotary()
+        alice = aliceNode.info.singleIdentity()
     }
 
     @After
diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
index 385b195e04..71be78c0bd 100644
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/CoreTestUtils.kt
@@ -69,11 +69,11 @@ val MEGA_CORP: Party get() = MEGA_CORP_IDENTITY.party
 val MINI_CORP_IDENTITY: PartyAndCertificate get() = getTestPartyAndCertificate(CordaX500Name(organisation = "MiniCorp", locality = "London", country = "GB"), MINI_CORP_PUBKEY)
 val MINI_CORP: Party get() = MINI_CORP_IDENTITY.party
 
+val BOC_NAME: CordaX500Name = CordaX500Name(organisation = "BankOfCorda", locality = "London", country = "GB")
 val BOC_KEY: KeyPair by lazy { generateKeyPair() }
 val BOC_PUBKEY: PublicKey get() = BOC_KEY.public
-val BOC_IDENTITY: PartyAndCertificate get() = getTestPartyAndCertificate(CordaX500Name(organisation = "BankOfCorda", locality = "London", country = "GB"), BOC_PUBKEY)
+val BOC_IDENTITY: PartyAndCertificate get() = getTestPartyAndCertificate(BOC_NAME, BOC_PUBKEY)
 val BOC: Party get() = BOC_IDENTITY.party
-val BOC_PARTY_REF = BOC.ref(OpaqueBytes.of(1)).reference
 
 val BIG_CORP_KEY: KeyPair by lazy { generateKeyPair() }
 val BIG_CORP_PUBKEY: PublicKey get() = BIG_CORP_KEY.public
@@ -166,5 +166,14 @@ inline fun <reified T : Any> T.amqpSpecific(reason: String, function: () -> Unit
 fun NodeInfo.chooseIdentityAndCert(): PartyAndCertificate = legalIdentitiesAndCerts.first()
 
 fun NodeInfo.chooseIdentity(): Party = chooseIdentityAndCert().party
+/**
+ * Extract a single identity from the node info. Throws an error if the node has multiple identities.
+ */
+fun NodeInfo.singleIdentityAndCert(): PartyAndCertificate = legalIdentitiesAndCerts.single()
+
+/**
+ * Extract a single identity from the node info. Throws an error if the node has multiple identities.
+ */
+fun NodeInfo.singleIdentity(): Party = singleIdentityAndCert().party
 /** Returns the identity of the first notary found on the network */
 fun ServiceHub.getDefaultNotary(): Party = networkMapCache.notaryIdentities.first()

From c4369844622ba4df3c85aa7494aa445388ccc521 Mon Sep 17 00:00:00 2001
From: szymonsztuka <szymon.sztuka@yahoo.com>
Date: Mon, 16 Oct 2017 19:08:51 +0100
Subject: [PATCH 185/185] Merge from Corda master - fix compilation errors

---
 .idea/compiler.xml                                          | 3 +++
 README.md                                                   | 2 +-
 .../kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt | 1 +
 .../main/kotlin/net/corda/node/internal/EnterpriseNode.kt   | 6 +++---
 .../net/corda/explorer/formatters/FlowInitiatorFormatter.kt | 3 ++-
 5 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index 4ecdc4bfee..bfeff657cb 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -108,6 +108,9 @@
       <module name="sgx-jvm_test" target="1.8" />
       <module name="sgx-signtool_main" target="1.8" />
       <module name="sgx-signtool_test" target="1.8" />
+      <module name="signing-server_integrationTest" target="1.8" />
+      <module name="signing-server_main" target="1.8" />
+      <module name="signing-server_test" target="1.8" />
       <module name="simm-valuation-demo_integrationTest" target="1.8" />
       <module name="simm-valuation-demo_main" target="1.8" />
       <module name="simm-valuation-demo_test" target="1.8" />
diff --git a/README.md b/README.md
index 3408574289..46b03d5320 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 ![Corda](https://www.corda.net/wp-content/uploads/2016/11/fg005_corda_b.png)
 
-<a href="https://ci-master.corda.r3cev.com/viewType.html?buildTypeId=CordaEnterprise_CordaBuild&tab=buildTypeStatusDiv"><img src="https://ci.corda.r3cev.com/app/rest/builds/buildType:Corda_CordaBuild/statusIcon"/></a>
+<a href="https://ci-master.corda.r3cev.com/viewType.html?buildTypeId=CordaEnterprise_Build&tab=buildTypeStatusDiv"><img src="https://ci.corda.r3cev.com/app/rest/builds/buildType:Corda_CordaBuild/statusIcon"/></a>
 
 # Corda Enterprise
 
diff --git a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
index 9e3192859f..4a82fe8d85 100644
--- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
+++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/Kryo.kt
@@ -25,6 +25,7 @@ import net.corda.core.transactions.CoreTransaction
 import net.corda.core.transactions.NotaryChangeWireTransaction
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.WireTransaction
+import net.corda.core.utilities.SgxSupport
 import org.bouncycastle.asn1.ASN1InputStream
 import org.bouncycastle.asn1.x500.X500Name
 import org.bouncycastle.cert.X509CertificateHolder
diff --git a/node/src/main/kotlin/net/corda/node/internal/EnterpriseNode.kt b/node/src/main/kotlin/net/corda/node/internal/EnterpriseNode.kt
index f883c21f9c..8b28ed9667 100644
--- a/node/src/main/kotlin/net/corda/node/internal/EnterpriseNode.kt
+++ b/node/src/main/kotlin/net/corda/node/internal/EnterpriseNode.kt
@@ -12,8 +12,8 @@ import org.fusesource.jansi.Ansi
 import org.fusesource.jansi.AnsiConsole
 import java.io.IOException
 
-class EnterpriseNode(configuration: FullNodeConfiguration, advertisedServices: Set<ServiceInfo>,
-                     versionInfo: VersionInfo) : Node(configuration, advertisedServices, versionInfo) {
+class EnterpriseNode(configuration: FullNodeConfiguration,
+                     versionInfo: VersionInfo) : Node(configuration, versionInfo) {
     companion object {
         private val logger by lazy { loggerFor<EnterpriseNode>() }
     }
@@ -66,7 +66,7 @@ D""".trimStart()
             return tips[(Math.random() * tips.size).toInt()]
         }
 
-        override fun createNode(conf: FullNodeConfiguration, versionInfo: VersionInfo, services: Set<ServiceInfo>) = EnterpriseNode(conf, services, versionInfo)
+        override fun createNode(conf: FullNodeConfiguration, versionInfo: VersionInfo) = EnterpriseNode(conf, versionInfo)
 
         private fun connectToRelay(config: RelayConfiguration, localBrokerPort: Int) {
             with(config) {
diff --git a/tools/explorer/src/main/kotlin/net/corda/explorer/formatters/FlowInitiatorFormatter.kt b/tools/explorer/src/main/kotlin/net/corda/explorer/formatters/FlowInitiatorFormatter.kt
index b42c7ae72a..31639d9291 100644
--- a/tools/explorer/src/main/kotlin/net/corda/explorer/formatters/FlowInitiatorFormatter.kt
+++ b/tools/explorer/src/main/kotlin/net/corda/explorer/formatters/FlowInitiatorFormatter.kt
@@ -10,6 +10,7 @@ object FlowInitiatorFormatter : Formatter<FlowInitiator> {
             is FlowInitiator.Shell -> "Shell" // TODO We don't have much information about that user.
             is FlowInitiator.Peer -> PartyNameFormatter.short.format(value.party.name)
             is FlowInitiator.RPC -> value.username
+            is FlowInitiator.Service -> value.name
         }
     }
 
@@ -20,7 +21,7 @@ object FlowInitiatorFormatter : Formatter<FlowInitiator> {
             is FlowInitiator.Shell -> Pair(FontAwesomeIcon.TERMINAL, text)
             is FlowInitiator.Peer -> Pair(FontAwesomeIcon.GROUP, text)
             is FlowInitiator.RPC -> Pair(FontAwesomeIcon.SHARE, text)
-
+            is FlowInitiator.Service -> Pair(FontAwesomeIcon.SERVER, text)
         }
     }
 }