Rebuilds docs.

docs/build/html/.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: f31fa13a644d2330bb46729777cbb8f7
+config: 1768caf6e5e802b716b72241d5bd1c76
 tags: 645f666f9bcd5a90fca523b33c5a78b7

docs/build/html/CLI-vs-IDE.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Overview" href="key-concepts.html"/>
         <link rel="prev" title="Running the demos" href="running-the-demos.html"/> 
@@ -129,7 +132,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/_sources/creating-a-cordapp.txt

@@ -201,7 +201,7 @@ deployment.
 
 To use this gradle plugin you must add a new task that is of the type ``net.corda.plugins.Cordform`` to your
 build.gradle and then configure the nodes you wish to deploy with the Node and nodes configuration DSL.
-This DSL is specified in the `JavaDoc <api/index.html>`_. An example of this is in the template-cordapp and below
+This DSL is specified in the `JavaDoc <api/index.html>`_. An example of this is in the CorDapp template and below
 is a three node example;
 
 .. code-block:: text

docs/build/html/_sources/flow-state-machines.txt

@@ -89,7 +89,9 @@ Our flow has two parties (B and S for buyer and seller) and will proceed as foll
 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.
-3. S signs it and hands the now finalised ``SignedTransaction`` back to B.
+3. S signs it and *finalises* the transaction. This means sending it to the notary, which checks the transaction for
+   validity, recording the transaction in the local vault, and then sending it back to B who also checks it and commits
+   the transaction to their local vault.
 
 You can find the implementation of this flow in the file ``finance/src/main/kotlin/net/corda/flows/TwoPartyTradeFlow.kt``.
 
@@ -98,8 +100,7 @@ represents an atomic asset swap.
 
 Note that it's the *seller* who initiates contact with the buyer, not vice-versa as you might imagine.
 
-We start by defining a wrapper that namespaces the flow code, two functions to start either the buy or sell side
-of the flow, and two classes that will contain the flow definition. We also pick what data will be used by
+We start by defining two classes that will contain the flow definition. We also pick what data will be used by
 each side.
 
 .. note:: The code samples in this tutorial are only available in Kotlin, but you can use any JVM language to
@@ -110,7 +111,6 @@ each side.
    .. 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"
@@ -188,8 +188,6 @@ and try again.
 
 .. note:: Java 9 is likely to remove this pre-marking requirement completely.
 
-.. note:: Accessing the vault from inside an @Suspendable function (e.g. via ``serviceHub.vaultService``) can cause a serialisation error when the fiber suspends. Instead, vault access should be performed from a helper non-suspendable function, which you then call from the @Suspendable function. We are working to fix this.
-
 Starting your flow
 ------------------
 
@@ -248,12 +246,11 @@ Let's implement the ``Seller.call`` method. This will be run when the flow is in
             :dedent: 4
 
 Here we see the outline of the procedure. We receive a proposed trade transaction from the buyer and check that it's
-valid. The buyer has already attached their signature before sending it. Then we calculate and attach our own signature so that the transaction is
-now signed by both the buyer and the seller. We then send this request to a notary to assert with another signature that the
-timestamp in the transaction (if any) is valid and there are no double spends, and send back both
-our signature and the notaries signature. Note we should not send to the notary until all other required signatures have been appended
-as the notary may validate the signatures as well as verifying for itself the transactional integrity.
-Finally, we hand back to the code that invoked the flow the finished transaction.
+valid. The buyer has already attached their signature before sending it. Then we calculate and attach our own signature
+so that the transaction is now signed by both the buyer and the seller. We then *finalise* this transaction by sending
+it to a notary to assert (with another signature) that the timestamp in the transaction (if any) is valid and there are no
+double spends. Finally, after the finalisation process is complete, we retrieve the now fully signed transaction from
+local storage. It will have the same ID as the one we started with but more signatures.
 
 Let's fill out the ``receiveAndCheckProposedTransaction()`` method.
 
@@ -327,24 +324,39 @@ Throwing a ``FlowException`` enables a flow to reject a piece of data it has rec
 done in the ``unwrap`` method of the received ``UntrustworthyData``. In the above example the seller checks the price
 and throws ``FlowException`` if it's invalid. It's then up to the buyer to either try again with a better price or give up.
 
-Sub-flows
----------
+Sub-flows and finalisation
+--------------------------
 
 Flows can be composed via nesting. Invoking a sub-flow looks similar to an ordinary function call:
 
 .. container:: codeset
 
-    .. literalinclude:: ../../finance/src/main/kotlin/net/corda/flows/TwoPartyTradeFlow.kt
-            :language: kotlin
-            :start-after: DOCSTART 6
-            :end-before: DOCEND 6
-            :dedent: 4
+   .. sourcecode:: kotlin
+
+      @Suspendable
+      fun call() {
+          val unnotarisedTransaction = ...
+          subFlow(FinalityFlow(unnotarisedTransaction))
+      }
+
+   .. sourcecode:: java
+
+      @Suspendable
+      public void call() throws FlowException {
+          SignedTransaction unnotarisedTransaction = ...
+          subFlow(new FinalityFlow(unnotarisedTransaction))
+      }
+
+In this code snippet we are using the ``FinalityFlow`` to finish off the transaction. It will:
+
+* Send the transaction to the chosen notary and, if necessary, satisfy the notary that the transaction is valid.
+* Record the transaction in the local vault, if it is relevant (i.e. involves the owner of the node).
+* Send the fully signed transaction to the other participants for recording as well.
 
-In this code snippet we are using the ``NotaryFlow.Client`` to request notarisation of the transaction.
 We simply create the flow object via its constructor, and then pass it to the ``subFlow`` method which
 returns the result of the flow's execution directly. Behind the scenes all this is doing is wiring up progress
-tracking (discussed more below) and then running the objects ``call`` method. Because this little helper method can
-be on the stack when network IO takes place, we mark it as ``@Suspendable``.
+tracking (discussed more below) and then running the objects ``call`` method. Because the sub-flow might suspend,
+we must mark the method that invokes it as suspendable.
 
 Going back to the previous code snippet, we use a sub-flow called ``ResolveTransactionsFlow``. This is
 responsible for downloading and checking all the dependencies of a transaction, which in Corda are always retrievable
@@ -360,32 +372,11 @@ objects, but we don't need them here so we just ignore the return value.
 After the dependencies, we check the proposed trading transaction for validity by running the contracts for that as
 well (but having handled the fact that some signatures are missing ourselves).
 
-Here's the rest of the code:
-
-.. container:: codeset
-
-    .. literalinclude:: ../../finance/src/main/kotlin/net/corda/flows/TwoPartyTradeFlow.kt
-            :language: kotlin
-            :start-after: DOCSTART 7
-            :end-before: DOCEND 7
-            :dedent: 4
-
-It's all pretty straightforward from now on. Here ``id`` is the secure hash representing the serialised
-transaction, and we just use our private key to calculate a signature over it. As a reminder, in Corda signatures do
-not cover other signatures: just the core of the transaction data.
-
-In ``sendSignatures``, we take the two signatures we obtained and add them to the partial transaction we were sent.
-There is an overload for the + operator so signatures can be added to a SignedTransaction easily. Finally, we wrap the
-two signatures in a simple wrapper message class and send it back. The send won't block waiting for an acknowledgement,
-but the underlying message queue software will retry delivery if the other side has gone away temporarily.
-
-You can also see that every flow instance has a logger (using the SLF4J API) which you can use to log progress
-messages.
-
-.. warning:: This sample code is **not secure**. Other than not checking for all possible invalid constructions, if the
-   seller stops before sending the finalised transaction to the buyer, the seller is left with a valid transaction
-   but the buyer isn't, so they can't spend the asset they just purchased! This sort of thing will be fixed in a
-   future version of the code.
+.. warning:: If the seller stops before sending the finalised transaction to the buyer, the seller is left with a
+   valid transaction but the buyer isn't, so they can't spend the asset they just purchased! This sort of thing is not
+   always a risk (as the seller may not gain anything from that sort of behaviour except a lawsuit), but if it is, a future
+   version of the platform will allow you to ask the notary to send you the transaction as well, in case your counterparty
+   does not. This is not the default because it reveals more private info to the notary.
 
 Implementing the buyer
 ----------------------
@@ -403,12 +394,11 @@ OK, let's do the same for the buyer side:
 This code is longer but no more complicated. Here are some things to pay attention to:
 
 1. We do some sanity checking on the received message to ensure we're being offered what we expected to be offered.
-2. We create a cash spend in the normal way, by using ``VaultService.generateSpend``. See the vault documentation if this
-   part isn't clear.
+2. We create a cash spend using ``VaultService.generateSpend``. You can read the vault documentation to learn more about this.
 3. We access the *service hub* when we need it to access things that are transient and may change or be recreated
    whilst a flow is suspended, things like the wallet or the network map.
-4. Finally, we send the unfinished, invalid transaction to the seller so they can sign it. They are expected to send
-   back to us a ``SignaturesFromSeller``, which once we verify it, should be the final outcome of the trade.
+4. We send the unfinished, invalid transaction to the seller so they can sign it and finalise it.
+5. Finally, we wait for the finished transaction to arrive in our local storage and vault.
 
 As you can see, the flow logic is straightforward and does not contain any callbacks or network glue code, despite
 the fact that it takes minimal resources and can survive node restarts.
@@ -435,7 +425,7 @@ A flow might declare some steps with code inside the flow class like this:
     .. literalinclude:: ../../finance/src/main/kotlin/net/corda/flows/TwoPartyTradeFlow.kt
             :language: kotlin
             :start-after: DOCSTART 2
-            :end-before: DOCSTART 1
+            :end-before: DOCEND 2
             :dedent: 4
 
     .. sourcecode:: java

docs/build/html/_sources/getting-set-up-fault-finding.txt

@@ -4,9 +4,9 @@ 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 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 stable branch instead, by running ``git checkout release-M7``.
+When developing on Corda, you should always check out the latest milestone (i.e. stable) branch instead. For example, to check out milestone 7, you'd run ``git checkout release-M7``.
 
 Java issues
 -----------
@@ -19,7 +19,9 @@ Many users have faced issues when running versions of Java that are either outda
 "Unresolved reference: javafx"
 ******************************
 
-JavaFX is not bundled with OpenJDK. If you are using OpenJDK and get an 'Unresolved reference: javafx' error, this means that you need to install OpenJFX. Do this by running ``sudo apt install openjfx``, and possibly ``sudo apt install libopenjfx-jav``.
+JavaFX is not bundled with OpenJDK. If you are using OpenJDK and get an 'Unresolved reference: javafx' error, this means that you need to install OpenJFX.
+
+If you have APT installed and OpenJFX is part of your Unix distribution's package list, you can do this by running ``sudo apt install openjfx``, and possibly ``sudo apt install libopenjfx-jav``. Other users will want to refer to the guide `here <https://wiki.openjdk.java.net/display/OpenJFX/Building+OpenJFX>`_, or to the list of Community Builds `here <https://wiki.openjdk.java.net/display/OpenJFX/Community+Builds>`_.
 
 IDEA issues
 ---------------

docs/build/html/_sources/getting-set-up.txt

@@ -69,13 +69,17 @@ The Corda platform source code is available here:
 
     https://github.com/corda/corda.git
 
-and a basic CorDapp that you can use as the basis for your own CorDapps is available here:
+A CorDapp template that you can use as the basis for your own CorDapps is available here:
 
     https://github.com/corda/cordapp-template.git
 
-You can clone both of these repos to your local machine by running the command ``git clone [repo URL]``.
+And a simple example CorDapp for you to explore basic concepts is available here:
 
-By default, both repos will be on the ``master`` branch. However, this is an unstable development branch. You should check 
+	https://github.com/corda/cordapp-tutorial.git
+
+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 ``master`` branch. However, this is an unstable development branch. You should check 
 out the latest milestone release (currently Milestone 7) instead by running ``git checkout release-M7``.
 
 Opening Corda/CorDapps in IDEA

docs/build/html/_sources/index.txt

@@ -19,10 +19,8 @@ Corda is designed so that developers can easily extend its functionality by writ
 sure you follow the instructions in :doc:`getting-set-up`, then go to
 :doc:`running-the-demos`.
 
-If, after running the demos, you're interested in writing your own CorDapps, a template CorDapp is available on
-`Github <https://github.com/corda/cordapp-template>`_. To get it running, follow the instructions in the
-`readme <https://github.com/corda/cordapp-template/blob/master/README.md>`_, or watch the
-`Corda Developers Tutorial <https://vimeo.com/192797322/aab499b152>`_.
+If, after running the demos, you're interested in writing your own CorDapps, you can use the 
+`CorDapp template <https://github.com/corda/cordapp-template>`_ as a base. A simple example CorDapp built upon the template is available `here <https://github.com/corda/cordapp-tutorial>`_, and a video primer on basic CorDapp structure is available `here <https://vimeo.com/192797322/aab499b152>`_.
 
 From there, you'll be in a position to start extending the example CorDapp yourself (e.g. by writing new states, contracts,
 and/or flows). For this, you'll want to refer to this docsite, and to the `tutorials <https://docs.corda.net/tutorial-contract.html>`_

docs/build/html/_sources/merkle-trees.txt

@@ -15,17 +15,17 @@ You can read more on the concept `here <https://en.wikipedia.org/wiki/Merkle_tre
 Merkle trees in Corda
 ---------------------
 
-Transactions are split into leaves, each of them contains either input, output, command or attachment. Other fields like
-timestamp or signers are not used in the calculation.
-Next, the Merkle tree is built in the normal way by hashing the concatenation
-of nodes’ hashes below the current one together. It’s visible on the example image below, where ``H`` denotes sha256 function,
-"+" - concatenation.
+Transactions are split into leaves, each of them contains either input, output, command or attachment. Additionally, in
+transaction id calculation we use other fields of ``WireTransaction`` like timestamp, notary, type and signers.
+Next, the Merkle tree is built in the normal way by hashing the concatenation of nodes’ hashes below the current one together.
+It’s visible on the example image below, where ``H`` denotes sha256 function, "+" - concatenation.
 
 .. image:: resources/merkleTree.png
 
-The transaction has one input state, one output and three commands. If a tree is not a full binary tree, the rightmost nodes are
-duplicated in hash calculation (dotted lines).
-
+The transaction has two input states, one of output, attachment and command each and timestamp. For brevity we didn't
+include all leaves on the diagram (type, notary and signers are presented as one leaf labelled Rest - in reality
+they are separate leaves). Notice that if a tree is not a full binary tree, leaves are padded to the nearest power
+of 2 with zero hash (since finding a pre-image of sha256(x) == 0 is hard computational task) - marked light green above.
 Finally, the hash of the root is the identifier of the transaction, it's also used for signing and verification of data integrity.
 Every change in transaction on a leaf level will change its identifier.
 
@@ -39,9 +39,11 @@ to that particular transaction.
 
 .. image:: resources/partialMerkle.png
 
-In the example above, the red node is the one holding data for signing Oracle service. Blue nodes' hashes form the Partial Merkle
-Tree, dotted ones are not included. Having the command that should be in a red node place and branch we are able to calculate
-root of this tree and compare it with original transaction identifier - we have a proof that this command belongs to this transaction.
+In the example above, the node ``H(f)`` is the one holding command data for signing by Oracle service. Blue leaf ``H(g)`` is also
+included since it's holding timestamp information. Nodes labelled ``Provided`` form the Partial Merkle Tree, black ones
+are omitted. Having timestamp with the command that should be in a violet node place and branch we are able to calculate
+root of this tree and compare it with original transaction identifier - we have a proof that this command and timestamp
+belong to this transaction.
 
 Example of usage
 ----------------
@@ -50,36 +52,34 @@ Let’s focus on a code example. We want to construct a transaction with command
 :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 functions for inputs, outputs, attachments and commands separately. If a function is not provided by default none
-of the elements from this group will be included in a Partial Merkle Tree.
+filtering function over fields of ``WireTransaction`` of type ``(Any) -> Boolean``.
 
 .. container:: codeset
 
    .. sourcecode:: kotlin
 
-        val partialTx  = ...
+        val partialTx = ...
         val oracle: Party = ...
-        fun filterCommands(c: Command) = oracle.owningKey in c.signers && c.value is Fix
-        val filterFuns = FilterFuns(filterCommands = ::filterCommands)
+        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 pass filtering function over commands - ``filterCommands`` to ``FilterFuns``. It filters only
-commands of type ``Fix`` as in IRSDemo example. Then we can construct ``FilteredTransaction``:
+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``:
 
 .. container:: codeset
 
    .. sourcecode:: kotlin
 
         val wtx: WireTransaction = partialTx.toWireTransaction()
-        val ftx = FilteredTransaction.buildMerkleTransaction(wtx, filterFuns)
+        val ftx: FilteredTransaction = wtx.buildFilteredTransaction(filtering)
 
-In the Oracle example this step takes place in ``RatesFixFlow``:
+In the Oracle example this step takes place in ``RatesFixFlow`` by overriding ``filtering`` function, see: :ref:`filtering_ref`
 
-.. container:: codeset
-
-   .. sourcecode:: kotlin
-
-        val flow = RatesFixFlow(partialTx, filterFuns, oracle, fixOf, "0.675".bd, "0.1".bd)
 
 ``FilteredTransaction`` holds ``filteredLeaves`` (data that we wanted to reveal) and Merkle branch for them.
 
@@ -87,14 +87,21 @@ In the Oracle example this step takes place in ``RatesFixFlow``:
 
    .. sourcecode:: kotlin
 
-        // Getting included commands, inputs, outputs, attachments.
+        // Direct accsess to included commands, inputs, outputs, attachments etc.
         val cmds: List<Command> = ftx.filteredLeaves.commands
         val ins: List<StateRef> = ftx.filteredLeaves.inputs
-        val outs: List<TransactionState<ContractState>> = ftx.filteredLeaves.outputs
-        val attchs: List<SecureHash> = ftx.filteredLeaves.attachments
+        val timestamp: Timestamp? = ftx.filteredLeaves.timestamp
+        ...
 
+.. literalinclude:: ../../samples/irs-demo/src/main/kotlin/net/corda/irs/api/NodeInterestRates.kt
+    :language: kotlin
+    :start-after: DOCSTART 1
+    :end-before: DOCEND 1
 
-If you want to verify obtained ``FilteredTransaction`` all you need is the root hash of the full transaction:
+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
+of the full transaction:
 
 .. container:: codeset
 
@@ -104,6 +111,13 @@ If you want to verify obtained ``FilteredTransaction`` all you need is the root
                 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)
 
 .. 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.

docs/build/html/_sources/oracles.txt

@@ -239,8 +239,11 @@ those for ``NodeInterestRates.Oracle``.
    :start-after: DOCSTART 1
    :end-before: DOCEND 1
 
-You'll note that the ``FixSignFlow`` requires a ``FilterFuns`` instance with the appropriate filter to include only
-the ``Fix`` commands.  You can find a further explanation of this in :doc:`merkle-trees`.
+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.
+
+.. _filtering_ref:
 
 Using an oracle
 ---------------
@@ -260,8 +263,9 @@ As you can see, this:
 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. Requests the signature from the oracle using the client sub-flow for signing from above.
-6. Adds the signature returned 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.
 
 Here's an example of it in action from ``FixingFlow.Fixer``.
 
@@ -269,3 +273,8 @@ Here's an example of it in action from ``FixingFlow.Fixer``.
    :language: kotlin
    :start-after: DOCSTART 1
    :end-before: DOCEND 1
+
+.. note::
+    When overriding be careful when making the sub-class an anonymous or inner class (object declarations in Kotlin),
+    because that kind of classes can access variables from the enclosing scope and cause serialization problems when
+    checkpointed.

docs/build/html/_sources/tutorial-cordapp.txt

@@ -4,14 +4,18 @@
    <script type="text/javascript" src="_static/jquery.js"></script>
    <script type="text/javascript" src="_static/codesets.js"></script>
 
-The CorDapp template
-====================
+The example CorDapp
+===================
 
-This guide covers how to get started with the `cordapp-template`. Please note there are two Corda repositories:
+.. note:: The example CorDapp was previously hosted in the `cordapp-template <https://github.com/corda/cordapp-template>`_ repository. It has now been 
+   moved into a new `cordapp-tutorial <https://github.com/corda/cordapp-tutorial>`_ repository. Going forward, the cordapp-template repo will contain an 
+   actual CorDapp template, which should be used as the basis for your CorDapps going forward.
 
-* ``corda`` which contains the core platform code and sample CorDapps.
-* ``cordapp-template`` which contains a template CorDapp you can use to bootstrap your own CorDapps. It is the subject
-  of this tutorial and should help you understand the basics of building a CorDapp.
+This guide covers how to get started with the example CorDapp. Please note there are several Corda repositories:
+
+* `corda <https://github.com/corda/corda>`_ which contains the core platform code and sample CorDapps.
+* `cordapp-tutorial <https://github.com/corda/cordapp-tutorial>`_ which contains an example CorDapp you can use to bootstrap your own CorDapps. It is the subject of this tutorial and should help you understand the basics of building a CorDapp.
+* `cordapp-template <https://github.com/corda/cordapp-template>`_ which contains a bare-bones template on which to build your own CorDapps.
 
 We recommend you read the non-technical white paper and technical white paper before you get started with Corda:
 
@@ -25,30 +29,29 @@ We recommend you read the non-technical white paper and technical white paper be
 Background
 ----------
 
-The Example CorDapp implements a basic scenario where a buyer wishes to submit purchase orders to a seller. The scenario
+The Example CorDapp implements a basic scenario where one party wishes to send an IOU to another party. The scenario
 defines four nodes:
 
-* **Controller** which hosts the network map service and validating notary service.
-* **NodeA** who is the buyer.
-* **NodeB** who is the seller.
-* **NodeC** an unrelated third party.
+* **Controller**, which hosts the network map service and validating notary service
+* **NodeA**
+* **NodeB**
+* **NodeC**
 
-NodeA can generate purchase orders for lists and quantities of items and associated metadata such as delivery address
-and delivery date. The flows used to facilitate the agreement process always results in an agreement with the seller as
-long as the purchase order meets the contract constraints which are defined in ``PurchaseOrderContract.kt``.
+The nodes can generate IOUs and send them to other nodes. The flows used to facilitate the agreement process always results in 
+an agreement with the recipient as long as the IOU meets the contract constraints which are defined in ``IOUContract.kt``.
 
-All agreed purchase orders between NodeA and NodeB become "shared facts" between NodeA and NodeB. But note that NodeC
-won't see any of these transactions or have copies of any of the resulting ``PurchaseOrderState`` objects. This is
+All agreed IOUs between NodeA and NodeB become "shared facts" between NodeA and NodeB. But note that NodeC
+won't see any of these transactions or have copies of any of the resulting ``IOUState`` objects. This is
 because data is only propagated on a need-to-know basis.
 
 Getting started
 ---------------
 
-There are two ways to get started with the CorDapp template. You can either work from a milestone release of Corda or a
+There are two ways to get started with the example CorDapp. You can either work from a milestone release of Corda or a
 SNAPSHOT release of Corda.
 
 **Using a monthly Corda milestone release.** If you wish to develop your CorDapp using the most recent milestone release
-then you can get started simply by cloning the ``cordapp-template`` repository. Gradle will grab all the required dependencies
+then you can get started simply by cloning the ``cordapp-tutorial`` repository. Gradle will grab all the required dependencies
 for you from our `public Maven repository <https://bintray.com/r3/corda>`_.
 
 **Using a Corda SNAPSHOT build.** Alternatively, if you wish to work from the master branch of the Corda repo which contains
@@ -69,21 +72,21 @@ The process for developing your CorDapp from a milestone release is the most sim
 approach.
 
 We publish all our milestone releases to a public Maven repository on a monthly basis. As such, Gradle will automatically
-grab the appropriately versioned (specified in the ``cordapp-template``'s ``build.gradle`` file) dependencies for you from Maven.
-All you have to do is check out the release tag of the template version you wish to use.
+grab the appropriately versioned (specified in the ``cordapp-tutorial``'s ``build.gradle`` file) dependencies for you from Maven.
+All you have to do is check out the release tag of the tutorial version you wish to use.
 
-By default, the ``master`` branch of the ``cordapp-template`` points to a SNAPSHOT release of Corda, this is because it is
+By default, the ``master`` branch of the ``cordapp-tutorial`` points to a SNAPSHOT release of Corda, this is because it is
 being constantly updated to reflect the changes in the master branch of the `corda` repository.
 
 .. note:: If you wish to use a SNAPSHOT release then follow the instructions below: `Using a SNAPSHOT release`_.
 
-To clone the ``cordapp-template`` repository, use the following command:
+To clone the ``cordapp-tutorial`` repository, use the following command:
 
-``git clone https://github.com/corda/cordapp-template``
+``git clone https://github.com/corda/cordapp-tutorial``
 
 Now change directories to the freshly cloned repo:
 
-``cd cordapp-template``
+``cd cordapp-tutorial``
 
 To enumerate all the tagged releases. Use:
 
@@ -95,7 +98,7 @@ To checkout a specific tag, use:
 
 where ``local_branch_name`` is a name of your choice and ``tag_name`` is the name of the tag you wish to checkout.
 
-Gradle will handle all the dependencies for you. Now you are now ready to get started `building the CorDapp Template`_.
+Gradle will handle all the dependencies for you. Now you are now ready to get started `building the example CorDapp`_.
 
 Using a SNAPSHOT release
 ~~~~~~~~~~~~~~~~~~~~~~~~
@@ -145,7 +148,7 @@ where ``local_branch_name`` is a name of your choice and ``remote_branch_name``
 to checkout.
 
 .. note:: When working with ``master`` you will have access to the most up-to-date feature set. However you will be
-  potentially sacrificing stability. We will endeavour to keep the ``master`` branch of the ``cordapp-template`` repo in sync
+  potentially sacrificing stability. We will endeavour to keep the ``master`` branch of the ``cordapp-tutorial`` repo in sync
   with the ``master`` branch of ``corda`` repo. A milestone tagged release would be more stable for CorDapp development.
 
 The next step is to publish the Corda JARs to your local Maven repository. By default the Maven local repository can be
@@ -198,13 +201,13 @@ and to check out an open feature branch, use:
 Once you have published the Corda JARs to your local Maven repository, you are ready to get started building your
 CorDapp using the latest Corda features.
 
-Opening the CorDapp Template with IntelliJ
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Opening the example CorDapp with IntelliJ
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 For those familiar with IntelliJ, you can skip this section.
 
 As noted in the getting started guide, we recommend using the IntelliJ IDE. Assuming you have already downloaded and
-installed IntelliJ, lets now open the CorDapp Template with IntelliJ.
+installed IntelliJ, lets now open the example CorDapp with IntelliJ.
 
 **For those completely new to IntelliJ**
 
@@ -213,7 +216,7 @@ Firstly, load up IntelliJ. A dialogue will appear:
 .. image:: resources/intellij-welcome.png
   :width: 400
 
-Click open, then navigate to the folder where you cloned the ``cordapp-template`` and click OK.
+Click open, then navigate to the folder where you cloned the ``cordapp-tutorial`` and click OK.
 
 Next, IntelliJ will show a bunch of pop-up windows. One of which requires our attention:
 
@@ -227,14 +230,14 @@ dialogue, simply close and re-open IntelliJ again to see it again.
 **Alternative approach**
 
 Alternatively, one can instruct IntelliJ to create a new project through cloning a repository. From the IntelliJ welcome
-dialogue (shown above), opt to 'check out from version control', then select git and enter the git URL for the CorDapp template
-(https://github.com/corda/cordapp-template). You'll then need to import the Gradle project when prompted, as explained above.
+dialogue (shown above), opt to 'check out from version control', then select git and enter the git URL for the example CorDapp 
+(https://github.com/corda/cordapp-tutorial). You'll then need to import the Gradle project when prompted, as explained above.
 
 **If you already have IntelliJ open**
 
-From the ``File`` menu, navigate to ``Open ...`` and then navigate to the directory where you cloned the ``cordapp-template``.
+From the ``File`` menu, navigate to ``Open ...`` and then navigate to the directory where you cloned the ``cordapp-tutorial``.
 Alternatively, if you wish to clone from github directly then navigate to ``File > New > Project from existing sources ...``
-and enter the URL to the CorDapp Template (specified above). When instructed, be sure to import the Gradle project when prompted.
+and enter the URL to the example CorDapp (specified above). When instructed, be sure to import the Gradle project when prompted.
 
 **The Gradle plugin**
 
@@ -242,30 +245,30 @@ IntelliJ can be used to run Gradle tasks through the Gradle plugin which can be
 All the Gradle projects are listed in the window on the right hand side of the IDE. Click on a project, then 'tasks' to
 see all available Gradle tasks.
 
-* For the CorDapp Template repo there will only be one Gradle project listed.
+* For the example CorDapp repo there will only be one Gradle project listed.
 * For the Corda repo there will be many project listed, the root project ``corda`` and associated sub-projects: ``core``,
   ``finance``, ``node``, etc.
 
-.. note:: It's worth noting that when you change branch in the CorDapp template, the ``corda_version`` will change to
+.. note:: It's worth noting that when you change branch in the example CorDapp, the ``corda_version`` will change to
    reflect the version of the branch you are working from.
 
 To execute a task, double click it. The output will be shown in a console window.
 
-Building the CorDapp template
------------------------------
+Building the example CorDapp
+----------------------------
 
 **From the command line**
 
-Firstly, return to your terminal window used above and make sure you are in the ``cordapp-template`` directory.
+Firstly, return to your terminal window used above and make sure you are in the ``cordapp-tutorial`` directory.
 
-To build the CorDapp template use the following command:
+To build the example CorDapp use the following command:
 
 Unix/Mac OSX: ``./gradlew deployNodes``
 
 Windows: ``gradlew.bat deployNodes``
 
-This build process will build the example CorDapp defined in the CorDapp template source. CorDapps can be written in 
-any language targeting the JVM. In our case, we've provided the template source in both Kotlin (``/kotlin/src``) and 
+This build process will build the example CorDapp defined in the example CorDapp source. CorDapps can be written in 
+any language targeting the JVM. In our case, we've provided the example source in both Kotlin (``/kotlin/src``) and 
 Java (``/java/src``) Since both sets of source files are functionally identical, we will refer to the Kotlin build 
 throughout the documentation.
 
@@ -276,7 +279,7 @@ The ``deployNodes`` Gradle task allows you easily create a formation of Corda no
 we are creating ``four`` nodes.
 
 After the building process has finished to see the newly built nodes, you can navigate to the ``kotlin/build/nodes`` folder
-located in the ``cordapp-template`` root directory. You can ignore the other folders in ``/build`` for now. The ``nodes``
+located in the ``cordapp-tutorial`` root directory. You can ignore the other folders in ``/build`` for now. The ``nodes``
 folder has the following structure:
 
 .. sourcecode:: none
@@ -317,10 +320,10 @@ Open the Gradle window by selecting ``View > Tool windows > Gradle`` from the ma
 open on the right hand side of the IDE. Expand `tasks` and then expand `other`. Double click on `deployNodes`. Gradle will
 start the build process and output progress to a console window in the IDE.
 
-Running the CorDapp template
-----------------------------
+Running the example CorDapp
+---------------------------
 
-Running the CorDapp template from the command line
+Running the example CorDapp from the command line
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 To run the sample CorDapp navigate to the ``kotlin/build/nodes`` folder and execute the ``runnodes`` shell script with:
@@ -342,7 +345,7 @@ message and some pertinent config information, see below:
 
   --- DEVELOPER SNAPSHOT ------------------------------------------------------------
 
-  Logs can be found in                    : /Users/rogerwillis/Documents/Corda/cordapp-template/kotlin/build/nodes/nodea/logs
+  Logs can be found in                    : /Users/rogerwillis/Documents/Corda/cordapp-tutorial/kotlin/build/nodes/nodea/logs
   Database connection URL is              : jdbc:h2:tcp://10.18.0.196:50661/node
   Node listening on address               : localhost:10004
   Loaded plugins                          : com.example.plugin.ExamplePlugin
@@ -416,14 +419,14 @@ To stop the nodes, press the red "stop" button at the top right-hand side of the
 
 The node driver can also be used to as a basis for `debugging your CorDapp`_
 
-Interacting with the CorDapp template
--------------------------------------
+Interacting with the example CorDapp
+------------------------------------
 
 Via HTTP
 ~~~~~~~~
 
 The CorDapp defines a few HTTP API end-points and also serves some static web content. The end-points allow you to
-list purchase orders and add purchase orders.
+list IOUs and add IOUs.
 
 The nodes can be found using the following port numbers, defined in build.gradle and the respective node.conf file for
 each node found in `kotlin/build/nodes/NodeX`` etc:
@@ -440,32 +443,32 @@ served are as follows:
 
 * ``/api/example/me``
 * ``/api/example/peers``
-* ``/api/example/purchase-orders``
-* ``/api/example/{COUNTERPARTY}/create-purchase-order``
+* ``/api/example/ious``
+* ``/api/example/{COUNTERPARTY}/create-iou``
 
 The static web content is served from ``/web/example``.
 
-A purchase order can be created via accessing the ``api/example/create-purchase-order`` end-point directly or through the
+An IOU can be created via accessing the ``api/example/create-iou`` end-point directly or through the
 the web form hosted at ``/web/example``.
 
  .. warning:: **The content in ``web/example`` is only available for demonstration purposes and does not implement any
   anti-XSS, anti-XSRF or any other security techniques. Do not copy such code directly into products meant for production use.**
 
-**Submitting a purchase order via HTTP API:**
+**Submitting an IOU via HTTP API:**
 
-To create a purchase order from NodeA to NodeB, use:
+To create an IOU from NodeA to NodeB, use:
 
 .. sourcecode:: bash
 
-  echo '{"orderNumber": "1","deliveryDate": "2018-09-15","deliveryAddress": {"city": "London","country": "UK"},"items" : [{"name": "widget","amount": "3"},{"name": "thing","amount": "4"}]}' | cURL -T - -H 'Content-Type: application/json' http://localhost:10005/api/example/NodeB/create-purchase-order
+  echo '{"value": "1"}' | cURL -T - -H 'Content-Type: application/json' http://localhost:10005/api/example/NodeB/create-iou
 
 Note the port number ``10005`` (NodeA) and NodeB referenced in the API end-point path. This command instructs NodeA to
-create and send a purchase order to NodeB. Upon verification and completion of the process, both nodes (but not NodeC) will
-have a signed, notarised copy of the purchase order.
+create and send an IOU to NodeB. Upon verification and completion of the process, both nodes (but not NodeC) will
+have a signed, notarised copy of the IOU.
 
-**Submitting a purchase order via web/example:**
+**Submitting an IOU via web/example:**
 
-Navigate to the "create purchase order" button at the top left of the page, enter in the purchase order details e.g.
+Navigate to the "create IOU" button at the top left of the page, and enter the IOU details - e.g.
 
 .. sourcecode:: none
 
@@ -478,20 +481,22 @@ Navigate to the "create purchase order" button at the top left of the page, ente
   Item amount:   5
 
 and click submit (note you can add additional item types and amounts). Upon pressing submit, the modal dialogue should close.
-To check what validation is performed over the purchase order data, have a look at the ``PurchaseOrderContract.Place`` class in
-``PurchaseOrderContract.kt`` which defines the following contract constraints (among others not included here):
+To check what validation is performed over the IOU data, have a look at the ``IOUContract.Create`` class in
+``IOUContract.kt`` which defines the following contract constraints (among others not included here):
 
 .. sourcecode:: kotlin
 
-  // Purchase order specific constraints.
-  "We only deliver to the UK." by (out.po.deliveryAddress.country == "UK")
-  "You must order at least one type of item." by (out.po.items.size > 0)
-  "You cannot order zero or negative amounts of an item." by (out.po.items.map(Item::amount).all { it > 0 })
-  "You can only order up to 10 items at a time." by (out.po.items.map(Item::amount).sum() <= 10)
-  val time = tx.timestamp?.midpoint
-  "The delivery date must be in the future." by (out.po.deliveryDate.toInstant() > time)
+  // Generic constraints around the IOU transaction.
+  "No inputs should be consumed when issuing an IOU." by (tx.inputs.isEmpty())
+  "Only one output state should be created." by (tx.outputs.size == 1)
+  val out = tx.outputs.single() as IOUState
+  "The sender and the recipient cannot be the same entity." by (out.sender != out.recipient)
+  "All of the participants must be signers." by (command.signers.containsAll(out.participants))
 
-**Once a purchase order has been submitted:**
+  // IOU-specific constraints.
+  "The IOU's value must be non-negative." by (out.iou.value > 0)
+
+**Once an IOU has been submitted:**
 
 Inspect the terminal windows for the nodes. Assume all of the above contract constraints are met, you should see some
 activity in the terminal windows for NodeA and NodeB (note: the green ticks are only visible on unix/mac):
@@ -500,29 +505,25 @@ activity in the terminal windows for NodeA and NodeB (note: the green ticks are
 
 .. sourcecode:: none
 
-  ✅  Constructing proposed purchase order.
-  ✅  Sending purchase order to seller for review.
-  ✅  Received partially signed transaction from seller.
-  ✅  Verifying signatures and contract constraints.
-  ✅  Signing transaction with our private key.
-  ✅  Obtaining notary signature.
-      ✅  Requesting signature by Notary service
-      ✅  Validating response from Notary service
-  ✅  Recording transaction in vault.
-  ✅  Sending fully signed transaction to seller.
-  ✅  Done
+✅  Generating transaction based on new IOU.
+✅  Verifying contract constraints.
+✅  Signing transaction with our private key.
+✅  Sending proposed transaction to recipient for review.
+✅  Done
 
 *NodeB:*
 
 .. sourcecode:: none
 
-  ✅  Receiving proposed purchase order from buyer.
-  ✅  Generating transaction based on proposed purchase order.
-  ✅  Signing proposed transaction with our private key.
-  ✅  Sending partially signed transaction to buyer and wait for a response.
-  ✅  Verifying signatures and contract constraints.
-  ✅  Recording transaction in vault.
-  ✅  Done
+✅  Receiving proposed transaction from sender.
+✅  Verifying signatures and contract constraints.
+✅  Signing proposed transaction with our private key.
+✅  Obtaining notary signature and recording transaction.
+    ✅  Requesting signature by notary service
+        ✅  Requesting signature by Notary service
+        ✅  Validating response from Notary service
+    ✅  Broadcasting transaction to participants
+✅  Done
 
 *NodeC:*
 
@@ -530,12 +531,12 @@ activity in the terminal windows for NodeA and NodeB (note: the green ticks are
 
   You shouldn't see any activity.
 
-Next you can view the newly created purchase order by accessing the vault of NodeA or NodeB:
+Next you can view the newly created IOU by accessing the vault of NodeA or NodeB:
 
 *Via the HTTP API:*
 
-For NodeA. navigate to http://localhost:10005/api/example/purchase-orders. For NodeB,
-navigate to http://localhost:10007/api/example/purchase-orders.
+For NodeA. navigate to http://localhost:10005/api/example/ious. For NodeB,
+navigate to http://localhost:10007/api/example/ious.
 
 *Via web/example:*
 
@@ -575,9 +576,9 @@ Using the Example RPC client
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The ``/src/main/kotlin/com/example/client/ExampleClientRPC.kt`` file is a simple utility which uses the client RPC library
-to connect to a node and log the 'placed' purchase orders. It will log any existing purchase orders and listen for any future
-purchase orders. If you haven't placed any purchase orders when you connect to one of the Nodes via RPC then the client will log
-and future purchase orders which are agreed.
+to connect to a node and log the created IOUs. It will log any existing IOUs and listen for any future
+IOUs. If you haven't created any IOUs when you connect to one of the Nodes via RPC then the client will log
+and future IOUs which are agreed.
 
 To build the client use the following gradle task:
 
@@ -600,17 +601,17 @@ application see:
 * :doc:`Client RPC documentation <clientrpc>`
 * :doc:`Client RPC tutorial <tutorial-clientrpc-api>`
 
-Extending the CorDapp template
-------------------------------
+Extending the example CorDapp
+-----------------------------
 
-CorDapp-template project structure
+cordapp-tutorial project structure
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The CorDapp template has the following directory structure:
+The example CorDapp has the following directory structure:
 
 .. sourcecode:: none
 
-    . cordapp-template
+    . cordapp-tutorial
     ├── README.md
     ├── LICENSE
     ├── build.gradle
@@ -624,7 +625,7 @@ The CorDapp template has the following directory structure:
     ├── lib
     │   ├── ...
     ├── settings.gradle
-    ├── kotlin
+    ├── kotlin-source
     │   └── src
     │       ├── main
     │       │   ├── kotlin
@@ -636,10 +637,10 @@ The CorDapp template has the following directory structure:
     │       │   │           ├── client
     │       │   │           │   └── ExampleClientRPC.kt
     │       │   │           ├── contract
-    │       │   │           │   ├── PurchaseOrderContract.kt
-    │       │   │           │   └── PurchaseOrderState.kt
+    │       │   │           │   ├── IOUContract.kt
+    │       │   │           │   └── IOUState.kt
     │       │   │           ├── model
-    │       │   │           │   └── PurchaseOrder.kt
+    │       │   │           │   └── IOU.kt
     │       │   │           ├── plugin
     │       │   │           │   └── ExamplePlugin.kt
     │       │   │           └── flow
@@ -666,7 +667,7 @@ The CorDapp template has the following directory structure:
     │           │       └── example
     │           │           └── ExampleTest.kt
     │           └── resources
-    └── java
+    └── java-source
         └── src
             ├── main
             │   ├── java
@@ -678,10 +679,10 @@ The CorDapp template has the following directory structure:
             │   │           ├── client
             │   │           │   └── ExampleClientRPC.java
             │   │           ├── contract
-            │   │           │   ├── PurchaseOrderContract.java
-            │   │           │   └── PurchaseOrderState.java
+            │   │           │   ├── IOUContract.java
+            │   │           │   └── IOUState.java
             │   │           ├── model
-            │   │           │   └── PurchaseOrder.java
+            │   │           │   └── IOU.java
             │   │           ├── plugin
             │   │           │   └── ExamplePlugin.java
             │   │           └── flow
@@ -740,8 +741,8 @@ things.
 
 If you are working from a Corda SNAPSHOT release which you have publish to Maven local then ensure that
 ``corda_version`` is the same as the version of the Corda core modules you published to Maven local. If not then change the
-``kotlin_version`` property. Also, if you are working from a previous milestone release, then be sure to ``git checkout``
-the correct version of the CorDapp template from the ``cordapp-template`` repo.
+``kotlin_version`` property. Also, if you are working from a previous cordapp-tutorial milestone release, then be sure to ``git checkout``
+the correct version of the example CorDapp from the ``cordapp-tutorial`` repo.
 
 .. sourcecode:: groovy
 
@@ -824,7 +825,7 @@ like to deploy for testing. See further details below:
 You can add any number of nodes, with any number of services / CorDapps by editing the templates in ``deployNodes``. The
 only requirement is that you must specify a node to run as the network map service and one as the notary service.
 
-.. note:: CorDapps in the current cordapp-template project are automatically registered with all nodes defined in
+.. note:: CorDapps in the current cordapp-tutorial project are automatically registered with all nodes defined in
   ``deployNodes``, although we expect this to change in the near future.
 
 .. warning:: Make sure that there are no port clashes!
@@ -834,7 +835,7 @@ When you are finished editing your *CordFormation* the changes will be reflected
 Service Provider Configuration File
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-If you are building a CorDapp from scratch or adding a new CorDapp to the CorDapp-template project then you must provide
+If you are building a CorDapp from scratch or adding a new CorDapp to the cordapp-tutorial project then you must provide
 a reference to your sub-class of ``CordaPluginRegistry`` in the provider-configuration file in located in the ``resources/META-INF/services`` directory.
 
 Re-Deploying Your Nodes Locally
@@ -881,8 +882,8 @@ controller node is running and to its legal name (e.g. `networkMapService.addres
 `networkMapService.legalName=controller`) (please note that the controller will not have the `networkMapService` config)
 
 Each machine should now run its nodes using `runnodes` or `runnodes.bat` 
-files. Once they are up and running, the nodes should be able to place 
-purchase orders among themselves in the same way as when they were running on 
+files. Once they are up and running, the nodes should be able to create 
+IOUs among themselves in the same way as when they were running on 
 the same machine.
 
 Debugging your CorDapp

docs/build/html/_static/basic.css

@@ -494,6 +494,13 @@ pre {
     overflow-y: hidden;  /* fixes display issues on Chrome browsers */
 }
 
+span.pre {
+    -moz-hyphens: none;
+    -ms-hyphens: none;
+    -webkit-hyphens: none;
+    hyphens: none;
+}
+
 td.linenos pre {
     padding: 5px 0px;
     border: 0;

docs/build/html/_static/searchtools.js

@@ -226,6 +226,106 @@ var Scorer = {
 };
 
 
+
+
+
+var splitChars = (function() {
+    var result = {};
+    var singles = [96, 180, 187, 191, 215, 247, 749, 885, 903, 907, 909, 930, 1014, 1648,
+         1748, 1809, 2416, 2473, 2481, 2526, 2601, 2609, 2612, 2615, 2653, 2702,
+         2706, 2729, 2737, 2740, 2857, 2865, 2868, 2910, 2928, 2948, 2961, 2971,
+         2973, 3085, 3089, 3113, 3124, 3213, 3217, 3241, 3252, 3295, 3341, 3345,
+         3369, 3506, 3516, 3633, 3715, 3721, 3736, 3744, 3748, 3750, 3756, 3761,
+         3781, 3912, 4239, 4347, 4681, 4695, 4697, 4745, 4785, 4799, 4801, 4823,
+         4881, 5760, 5901, 5997, 6313, 7405, 8024, 8026, 8028, 8030, 8117, 8125,
+         8133, 8181, 8468, 8485, 8487, 8489, 8494, 8527, 11311, 11359, 11687, 11695,
+         11703, 11711, 11719, 11727, 11735, 12448, 12539, 43010, 43014, 43019, 43587,
+         43696, 43713, 64286, 64297, 64311, 64317, 64319, 64322, 64325, 65141];
+    var i, j, start, end;
+    for (i = 0; i < singles.length; i++) {
+        result[singles[i]] = true;
+    }
+    var ranges = [[0, 47], [58, 64], [91, 94], [123, 169], [171, 177], [182, 184], [706, 709],
+         [722, 735], [741, 747], [751, 879], [888, 889], [894, 901], [1154, 1161],
+         [1318, 1328], [1367, 1368], [1370, 1376], [1416, 1487], [1515, 1519], [1523, 1568],
+         [1611, 1631], [1642, 1645], [1750, 1764], [1767, 1773], [1789, 1790], [1792, 1807],
+         [1840, 1868], [1958, 1968], [1970, 1983], [2027, 2035], [2038, 2041], [2043, 2047],
+         [2070, 2073], [2075, 2083], [2085, 2087], [2089, 2307], [2362, 2364], [2366, 2383],
+         [2385, 2391], [2402, 2405], [2419, 2424], [2432, 2436], [2445, 2446], [2449, 2450],
+         [2483, 2485], [2490, 2492], [2494, 2509], [2511, 2523], [2530, 2533], [2546, 2547],
+         [2554, 2564], [2571, 2574], [2577, 2578], [2618, 2648], [2655, 2661], [2672, 2673],
+         [2677, 2692], [2746, 2748], [2750, 2767], [2769, 2783], [2786, 2789], [2800, 2820],
+         [2829, 2830], [2833, 2834], [2874, 2876], [2878, 2907], [2914, 2917], [2930, 2946],
+         [2955, 2957], [2966, 2968], [2976, 2978], [2981, 2983], [2987, 2989], [3002, 3023],
+         [3025, 3045], [3059, 3076], [3130, 3132], [3134, 3159], [3162, 3167], [3170, 3173],
+         [3184, 3191], [3199, 3204], [3258, 3260], [3262, 3293], [3298, 3301], [3312, 3332],
+         [3386, 3388], [3390, 3423], [3426, 3429], [3446, 3449], [3456, 3460], [3479, 3481],
+         [3518, 3519], [3527, 3584], [3636, 3647], [3655, 3663], [3674, 3712], [3717, 3718],
+         [3723, 3724], [3726, 3731], [3752, 3753], [3764, 3772], [3774, 3775], [3783, 3791],
+         [3802, 3803], [3806, 3839], [3841, 3871], [3892, 3903], [3949, 3975], [3980, 4095],
+         [4139, 4158], [4170, 4175], [4182, 4185], [4190, 4192], [4194, 4196], [4199, 4205],
+         [4209, 4212], [4226, 4237], [4250, 4255], [4294, 4303], [4349, 4351], [4686, 4687],
+         [4702, 4703], [4750, 4751], [4790, 4791], [4806, 4807], [4886, 4887], [4955, 4968],
+         [4989, 4991], [5008, 5023], [5109, 5120], [5741, 5742], [5787, 5791], [5867, 5869],
+         [5873, 5887], [5906, 5919], [5938, 5951], [5970, 5983], [6001, 6015], [6068, 6102],
+         [6104, 6107], [6109, 6111], [6122, 6127], [6138, 6159], [6170, 6175], [6264, 6271],
+         [6315, 6319], [6390, 6399], [6429, 6469], [6510, 6511], [6517, 6527], [6572, 6592],
+         [6600, 6607], [6619, 6655], [6679, 6687], [6741, 6783], [6794, 6799], [6810, 6822],
+         [6824, 6916], [6964, 6980], [6988, 6991], [7002, 7042], [7073, 7085], [7098, 7167],
+         [7204, 7231], [7242, 7244], [7294, 7400], [7410, 7423], [7616, 7679], [7958, 7959],
+         [7966, 7967], [8006, 8007], [8014, 8015], [8062, 8063], [8127, 8129], [8141, 8143],
+         [8148, 8149], [8156, 8159], [8173, 8177], [8189, 8303], [8306, 8307], [8314, 8318],
+         [8330, 8335], [8341, 8449], [8451, 8454], [8456, 8457], [8470, 8472], [8478, 8483],
+         [8506, 8507], [8512, 8516], [8522, 8525], [8586, 9311], [9372, 9449], [9472, 10101],
+         [10132, 11263], [11493, 11498], [11503, 11516], [11518, 11519], [11558, 11567],
+         [11622, 11630], [11632, 11647], [11671, 11679], [11743, 11822], [11824, 12292],
+         [12296, 12320], [12330, 12336], [12342, 12343], [12349, 12352], [12439, 12444],
+         [12544, 12548], [12590, 12592], [12687, 12689], [12694, 12703], [12728, 12783],
+         [12800, 12831], [12842, 12880], [12896, 12927], [12938, 12976], [12992, 13311],
+         [19894, 19967], [40908, 40959], [42125, 42191], [42238, 42239], [42509, 42511],
+         [42540, 42559], [42592, 42593], [42607, 42622], [42648, 42655], [42736, 42774],
+         [42784, 42785], [42889, 42890], [42893, 43002], [43043, 43055], [43062, 43071],
+         [43124, 43137], [43188, 43215], [43226, 43249], [43256, 43258], [43260, 43263],
+         [43302, 43311], [43335, 43359], [43389, 43395], [43443, 43470], [43482, 43519],
+         [43561, 43583], [43596, 43599], [43610, 43615], [43639, 43641], [43643, 43647],
+         [43698, 43700], [43703, 43704], [43710, 43711], [43715, 43738], [43742, 43967],
+         [44003, 44015], [44026, 44031], [55204, 55215], [55239, 55242], [55292, 55295],
+         [57344, 63743], [64046, 64047], [64110, 64111], [64218, 64255], [64263, 64274],
+         [64280, 64284], [64434, 64466], [64830, 64847], [64912, 64913], [64968, 65007],
+         [65020, 65135], [65277, 65295], [65306, 65312], [65339, 65344], [65371, 65381],
+         [65471, 65473], [65480, 65481], [65488, 65489], [65496, 65497]];
+    for (i = 0; i < ranges.length; i++) {
+        start = ranges[i][0];
+        end = ranges[i][1];
+        for (j = start; j <= end; j++) {
+            result[j] = true;
+        }
+    }
+    return result;
+})();
+
+function splitQuery(query) {
+    var result = [];
+    var start = -1;
+    for (var i = 0; i < query.length; i++) {
+        if (splitChars[query.charCodeAt(i)]) {
+            if (start !== -1) {
+                result.push(query.slice(start, i));
+                start = -1;
+            }
+        } else if (start === -1) {
+            start = i;
+        }
+    }
+    if (start !== -1) {
+        result.push(query.slice(start));
+    }
+    return result;
+}
+
+
+
+
 /**
  * Search Module
  */
@@ -324,7 +424,7 @@ var Search = {
     var searchterms = [];
     var excluded = [];
     var hlterms = [];
-    var tmp = query.split(/\s+/);
+    var tmp = splitQuery(query);
     var objectterms = [];
     for (i = 0; i < tmp.length; i++) {
       if (tmp[i] !== "") {

docs/build/html/azure-vm.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Glossary" href="glossary.html"/>
         <link rel="prev" title="Publishing Corda" href="publishing-corda.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/building-the-docs.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Further notes on Kotlin" href="further-notes-on-kotlin.html"/>
         <link rel="prev" title="Code style guide" href="codestyle.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/clauses.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Transaction tear-offs" href="merkle-trees.html"/>
         <link rel="prev" title="Network Simulator" href="network-simulator.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/clientrpc.html

@@ -34,9 +34,12 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Networking and messaging" href="messaging.html"/>
-        <link rel="prev" title="The CorDapp template" href="tutorial-cordapp.html"/> 
+        <link rel="prev" title="The example CorDapp" href="tutorial-cordapp.html"/> 
 
   
   <script src="_static/js/modernizr.min.js"></script>
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul class="current">
@@ -333,7 +336,7 @@ customisation point will either go away completely or change.</p>
         <a href="messaging.html" class="btn btn-neutral float-right" title="Networking and messaging" accesskey="n">Next <span class="fa fa-arrow-circle-right"></span></a>
       
       
-        <a href="tutorial-cordapp.html" class="btn btn-neutral" title="The CorDapp template" accesskey="p"><span class="fa fa-arrow-circle-left"></span> Previous</a>
+        <a href="tutorial-cordapp.html" class="btn btn-neutral" title="The example CorDapp" accesskey="p"><span class="fa fa-arrow-circle-left"></span> Previous</a>
       
     </div>
   

docs/build/html/codestyle.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Building the documentation" href="building-the-docs.html"/>
         <link rel="prev" title="Release notes" href="release-notes.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/contract-catalogue.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Interest rate swaps" href="contract-irs.html"/>
         <link rel="prev" title="Transaction tear-offs" href="merkle-trees.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/contract-irs.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Load testing" href="loadtesting.html"/>
         <link rel="prev" title="Contract catalogue" href="contract-catalogue.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/corda-configuration-file.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="The Corda plugin framework" href="corda-plugins.html"/>
         <link rel="prev" title="Node administration" href="node-administration.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul class="current">

docs/build/html/corda-plugins.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Brief introduction to the node services" href="node-services.html"/>
         <link rel="prev" title="Node configuration" href="corda-configuration-file.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul class="current">

docs/build/html/creating-a-cordapp.html

@@ -34,8 +34,11 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
-        <link rel="next" title="The CorDapp template" href="tutorial-cordapp.html"/>
+        <link rel="next" title="The example CorDapp" href="tutorial-cordapp.html"/>
         <link rel="prev" title="Security model" href="key-concepts-security-model.html"/> 
 
   
@@ -134,7 +137,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 </li>
 </ul>
 </li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>
@@ -412,7 +415,7 @@ experimenting, debugging, and testing node configurations and setups but not int
 deployment.</p>
 <p>To use this gradle plugin you must add a new task that is of the type <code class="docutils literal"><span class="pre">net.corda.plugins.Cordform</span></code> to your
 build.gradle and then configure the nodes you wish to deploy with the Node and nodes configuration DSL.
-This DSL is specified in the <a class="reference external" href="api/index.html">JavaDoc</a>. An example of this is in the template-cordapp and below
+This DSL is specified in the <a class="reference external" href="api/index.html">JavaDoc</a>. An example of this is in the CorDapp template and below
 is a three node example;</p>
 <div class="highlight-text"><div class="highlight"><pre><span></span>task deployNodes(type: net.corda.plugins.Cordform, dependsOn: [&#39;build&#39;]) {
     directory &quot;./build/nodes&quot; // The output directory
@@ -463,7 +466,7 @@ one node per window.</p>
   
     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
       
-        <a href="tutorial-cordapp.html" class="btn btn-neutral float-right" title="The CorDapp template" accesskey="n">Next <span class="fa fa-arrow-circle-right"></span></a>
+        <a href="tutorial-cordapp.html" class="btn btn-neutral float-right" title="The example CorDapp" accesskey="n">Next <span class="fa fa-arrow-circle-right"></span></a>
       
       
         <a href="key-concepts-security-model.html" class="btn btn-neutral" title="Security model" accesskey="p"><span class="fa fa-arrow-circle-left"></span> Previous</a>

docs/build/html/event-scheduling.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Network Simulator" href="network-simulator.html"/>
         <link rel="prev" title="Using attachments" href="tutorial-attachments.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/flow-state-machines.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Writing flow tests" href="flow-testing.html"/>
         <link rel="prev" title="Building transactions" href="tutorial-building-transactions.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>
@@ -147,7 +150,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <li class="toctree-l2"><a class="reference internal" href="#starting-your-flow">Starting your flow</a></li>
 <li class="toctree-l2"><a class="reference internal" href="#implementing-the-seller">Implementing the seller</a></li>
 <li class="toctree-l2"><a class="reference internal" href="#exception-handling">Exception handling</a></li>
-<li class="toctree-l2"><a class="reference internal" href="#sub-flows">Sub-flows</a></li>
+<li class="toctree-l2"><a class="reference internal" href="#sub-flows-and-finalisation">Sub-flows and finalisation</a></li>
 <li class="toctree-l2"><a class="reference internal" href="#implementing-the-buyer">Implementing the buyer</a></li>
 <li class="toctree-l2"><a class="reference internal" href="#progress-tracking">Progress tracking</a></li>
 <li class="toctree-l2"><a class="reference internal" href="#versioning">Versioning</a></li>
@@ -307,14 +310,15 @@ B to pay.</li>
 <li>B sends to S a <code class="docutils literal"><span class="pre">SignedTransaction</span></code> that includes the state as input, B&#8217;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&#8217;t valid because
 it lacks a signature from S authorising movement of the asset.</li>
-<li>S signs it and hands the now finalised <code class="docutils literal"><span class="pre">SignedTransaction</span></code> back to B.</li>
+<li>S signs it and <em>finalises</em> the transaction. This means sending it to the notary, which checks the transaction for
+validity, recording the transaction in the local vault, and then sending it back to B who also checks it and commits
+the transaction to their local vault.</li>
 </ol>
 <p>You can find the implementation of this flow in the file <code class="docutils literal"><span class="pre">finance/src/main/kotlin/net/corda/flows/TwoPartyTradeFlow.kt</span></code>.</p>
 <p>Assuming no malicious termination, they both end the flow being in possession of a valid, signed transaction that
 represents an atomic asset swap.</p>
 <p>Note that it&#8217;s the <em>seller</em> who initiates contact with the buyer, not vice-versa as you might imagine.</p>
-<p>We start by defining a wrapper that namespaces the flow code, two functions to start either the buy or sell side
-of the flow, and two classes that will contain the flow definition. We also pick what data will be used by
+<p>We start by defining two classes that will contain the flow definition. We also pick what data will be used by
 each side.</p>
 <div class="admonition note">
 <p class="first admonition-title">Note</p>
@@ -323,7 +327,6 @@ write them and the approach is the same.</p>
 </div>
 <div class="codeset container">
 <div class="highlight-kotlin"><div class="highlight"><pre><span></span><span class="k">object</span> <span class="nc">TwoPartyTradeFlow</span> <span class="p">{</span>
-
     <span class="k">class</span> <span class="nc">UnacceptablePriceException</span><span class="p">(</span><span class="k">val</span> <span class="py">givenPrice</span><span class="p">:</span> <span class="n">Amount</span><span class="p">&lt;</span><span class="n">Currency</span><span class="p">&gt;)</span> <span class="p">:</span> <span class="n">FlowException</span><span class="p">(</span><span class="s">&quot;Unacceptable price: $givenPrice&quot;</span><span class="p">)</span>
     <span class="k">class</span> <span class="nc">AssetMismatchException</span><span class="p">(</span><span class="k">val</span> <span class="py">expectedTypeName</span><span class="p">:</span> <span class="n">String</span><span class="p">,</span> <span class="k">val</span> <span class="py">typeName</span><span class="p">:</span> <span class="n">String</span><span class="p">)</span> <span class="p">:</span> <span class="n">FlowException</span><span class="p">()</span> <span class="p">{</span>
         <span class="k">override</span> <span class="k">fun</span> <span class="nf">toString</span><span class="p">()</span> <span class="p">=</span> <span class="s">&quot;The submitted asset didn&#39;t match the expected type: $expectedTypeName vs $typeName&quot;</span>
@@ -401,10 +404,6 @@ and try again.</p>
 <p class="first admonition-title">Note</p>
 <p class="last">Java 9 is likely to remove this pre-marking requirement completely.</p>
 </div>
-<div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">Accessing the vault from inside an &#64;Suspendable function (e.g. via <code class="docutils literal"><span class="pre">serviceHub.vaultService</span></code>) can cause a serialisation error when the fiber suspends. Instead, vault access should be performed from a helper non-suspendable function, which you then call from the &#64;Suspendable function. We are working to fix this.</p>
-</div>
 </div>
 <div class="section" id="starting-your-flow">
 <h2>Starting your flow<a class="headerlink" href="#starting-your-flow" title="Permalink to this headline">¶</a></h2>
@@ -449,23 +448,21 @@ is a seller (<code class="docutils literal"><span class="pre">Seller::class</spa
 <div class="codeset container">
 <div class="highlight-kotlin"><div class="highlight"><pre><span></span>    <span class="n">@Suspendable</span>
     <span class="k">override</span> <span class="k">fun</span> <span class="nf">call</span><span class="p">():</span> <span class="n">SignedTransaction</span> <span class="p">{</span>
-        <span class="k">val</span> <span class="py">partialTX</span><span class="p">:</span> <span class="n">SignedTransaction</span> <span class="p">=</span> <span class="n">receiveAndCheckProposedTransaction</span><span class="p">()</span>
-        <span class="k">val</span> <span class="py">ourSignature</span><span class="p">:</span> <span class="n">DigitalSignature</span><span class="p">.</span><span class="n">WithKey</span> <span class="p">=</span> <span class="n">calculateOurSignature</span><span class="p">(</span><span class="n">partialTX</span><span class="p">)</span>
-        <span class="k">val</span> <span class="py">allPartySignedTx</span><span class="p">:</span> <span class="n">SignedTransaction</span> <span class="p">=</span> <span class="n">partialTX</span> <span class="p">+</span> <span class="n">ourSignature</span>
-        <span class="k">val</span> <span class="py">notarySignature</span><span class="p">:</span> <span class="n">DigitalSignature</span><span class="p">.</span><span class="n">WithKey</span> <span class="p">=</span> <span class="n">getNotarySignature</span><span class="p">(</span><span class="n">allPartySignedTx</span><span class="p">)</span>
-        <span class="k">val</span> <span class="py">result</span><span class="p">:</span> <span class="n">SignedTransaction</span> <span class="p">=</span> <span class="n">sendSignatures</span><span class="p">(</span><span class="n">allPartySignedTx</span><span class="p">,</span> <span class="n">ourSignature</span><span class="p">,</span> <span class="n">notarySignature</span><span class="p">)</span>
-        <span class="k">return</span> <span class="n">result</span>
+        <span class="k">val</span> <span class="py">partialSTX</span><span class="p">:</span> <span class="n">SignedTransaction</span> <span class="p">=</span> <span class="n">receiveAndCheckProposedTransaction</span><span class="p">()</span>
+        <span class="k">val</span> <span class="py">ourSignature</span> <span class="p">=</span> <span class="n">calculateOurSignature</span><span class="p">(</span><span class="n">partialSTX</span><span class="p">)</span>
+        <span class="k">val</span> <span class="py">unnotarisedSTX</span><span class="p">:</span> <span class="n">SignedTransaction</span> <span class="p">=</span> <span class="n">partialSTX</span> <span class="p">+</span> <span class="n">ourSignature</span>
+        <span class="k">val</span> <span class="py">finishedSTX</span> <span class="p">=</span> <span class="n">subFlow</span><span class="p">(</span><span class="n">FinalityFlow</span><span class="p">(</span><span class="n">unnotarisedSTX</span><span class="p">)).</span><span class="n">single</span><span class="p">()</span>
+        <span class="k">return</span> <span class="n">finishedSTX</span>
     <span class="p">}</span>
 </pre></div>
 </div>
 </div>
 <p>Here we see the outline of the procedure. We receive a proposed trade transaction from the buyer and check that it&#8217;s
-valid. The buyer has already attached their signature before sending it. Then we calculate and attach our own signature so that the transaction is
-now signed by both the buyer and the seller. We then send this request to a notary to assert with another signature that the
-timestamp in the transaction (if any) is valid and there are no double spends, and send back both
-our signature and the notaries signature. Note we should not send to the notary until all other required signatures have been appended
-as the notary may validate the signatures as well as verifying for itself the transactional integrity.
-Finally, we hand back to the code that invoked the flow the finished transaction.</p>
+valid. The buyer has already attached their signature before sending it. Then we calculate and attach our own signature
+so that the transaction is now signed by both the buyer and the seller. We then <em>finalise</em> this transaction by sending
+it to a notary to assert (with another signature) that the timestamp in the transaction (if any) is valid and there are no
+double spends. Finally, after the finalisation process is complete, we retrieve the now fully signed transaction from
+local storage. It will have the same ID as the one we started with but more signatures.</p>
 <p>Let&#8217;s fill out the <code class="docutils literal"><span class="pre">receiveAndCheckProposedTransaction()</span></code> method.</p>
 <div class="codeset container">
 <div class="highlight-kotlin"><div class="highlight"><pre><span></span>    <span class="n">@Suspendable</span>
@@ -475,14 +472,12 @@ Finally, we hand back to the code that invoked the flow the finished transaction
         <span class="k">val</span> <span class="py">myPublicKey</span> <span class="p">=</span> <span class="n">myKeyPair</span><span class="p">.</span><span class="k">public</span><span class="p">.</span><span class="n">composite</span>
         <span class="c1">// Make the first message we&#39;ll send to kick off the flow.</span>
         <span class="k">val</span> <span class="py">hello</span> <span class="p">=</span> <span class="n">SellerTradeInfo</span><span class="p">(</span><span class="n">assetToSell</span><span class="p">,</span> <span class="n">price</span><span class="p">,</span> <span class="n">myPublicKey</span><span class="p">)</span>
-
-        <span class="k">val</span> <span class="py">maybeSTX</span> <span class="p">=</span> <span class="n">sendAndReceive</span><span class="p">&lt;</span><span class="n">SignedTransaction</span><span class="p">&gt;(</span><span class="n">otherParty</span><span class="p">,</span> <span class="n">hello</span><span class="p">)</span>
+        <span class="c1">// What we get back from the other side is a transaction that *might* be valid and acceptable to us,</span>
+        <span class="c1">// but we must check it out thoroughly before we sign!</span>
+        <span class="k">val</span> <span class="py">untrustedSTX</span> <span class="p">=</span> <span class="n">sendAndReceive</span><span class="p">&lt;</span><span class="n">SignedTransaction</span><span class="p">&gt;(</span><span class="n">otherParty</span><span class="p">,</span> <span class="n">hello</span><span class="p">)</span>
 
         <span class="n">progressTracker</span><span class="p">.</span><span class="n">currentStep</span> <span class="p">=</span> <span class="n">VERIFYING</span>
-
-        <span class="n">maybeSTX</span><span class="p">.</span><span class="n">unwrap</span> <span class="p">{</span>
-            <span class="n">progressTracker</span><span class="p">.</span><span class="n">nextStep</span><span class="p">()</span>
-
+        <span class="k">return</span> <span class="n">untrustedSTX</span><span class="p">.</span><span class="n">unwrap</span> <span class="p">{</span>
             <span class="c1">// Check that the tx proposed by the buyer is valid.</span>
             <span class="k">val</span> <span class="py">wtx</span><span class="p">:</span> <span class="n">WireTransaction</span> <span class="p">=</span> <span class="n">it</span><span class="p">.</span><span class="n">verifySignatures</span><span class="p">(</span><span class="n">myPublicKey</span><span class="p">,</span> <span class="n">notaryNode</span><span class="p">.</span><span class="n">notaryIdentity</span><span class="p">.</span><span class="n">owningKey</span><span class="p">)</span>
             <span class="n">logger</span><span class="p">.</span><span class="n">trace</span> <span class="p">{</span> <span class="s">&quot;Received partially signed transaction: ${it.id}&quot;</span> <span class="p">}</span>
@@ -491,11 +486,10 @@ Finally, we hand back to the code that invoked the flow the finished transaction
             <span class="c1">// even though it is missing signatures.</span>
             <span class="n">subFlow</span><span class="p">(</span><span class="n">ResolveTransactionsFlow</span><span class="p">(</span><span class="n">wtx</span><span class="p">,</span> <span class="n">otherParty</span><span class="p">))</span>
 
-            <span class="k">if</span> <span class="p">(</span><span class="n">wtx</span><span class="p">.</span><span class="n">outputs</span><span class="p">.</span><span class="n">map</span> <span class="p">{</span> <span class="n">it</span><span class="p">.</span><span class="k">data</span> <span class="p">}.</span><span class="n">sumCashBy</span><span class="p">(</span><span class="n">myPublicKey</span><span class="p">).</span><span class="n">withoutIssuer</span><span class="p">()</span> <span class="p">!=</span> <span class="n">price</span><span class="p">)</span> <span class="p">{</span>
+            <span class="k">if</span> <span class="p">(</span><span class="n">wtx</span><span class="p">.</span><span class="n">outputs</span><span class="p">.</span><span class="n">map</span> <span class="p">{</span> <span class="n">it</span><span class="p">.</span><span class="k">data</span> <span class="p">}.</span><span class="n">sumCashBy</span><span class="p">(</span><span class="n">myPublicKey</span><span class="p">).</span><span class="n">withoutIssuer</span><span class="p">()</span> <span class="p">!=</span> <span class="n">price</span><span class="p">)</span>
                 <span class="k">throw</span> <span class="n">FlowException</span><span class="p">(</span><span class="s">&quot;Transaction is not sending us the right amount of cash&quot;</span><span class="p">)</span>
-            <span class="p">}</span>
 
-            <span class="k">return</span> <span class="n">it</span>
+            <span class="n">it</span>
         <span class="p">}</span>
     <span class="p">}</span>
 </pre></div>
@@ -560,23 +554,35 @@ flows.</p>
 done in the <code class="docutils literal"><span class="pre">unwrap</span></code> method of the received <code class="docutils literal"><span class="pre">UntrustworthyData</span></code>. In the above example the seller checks the price
 and throws <code class="docutils literal"><span class="pre">FlowException</span></code> if it&#8217;s invalid. It&#8217;s then up to the buyer to either try again with a better price or give up.</p>
 </div>
-<div class="section" id="sub-flows">
-<h2>Sub-flows<a class="headerlink" href="#sub-flows" title="Permalink to this headline">¶</a></h2>
+<div class="section" id="sub-flows-and-finalisation">
+<h2>Sub-flows and finalisation<a class="headerlink" href="#sub-flows-and-finalisation" title="Permalink to this headline">¶</a></h2>
 <p>Flows can be composed via nesting. Invoking a sub-flow looks similar to an ordinary function call:</p>
 <div class="codeset container">
-<div class="highlight-kotlin"><div class="highlight"><pre><span></span>    <span class="n">@Suspendable</span>
-    <span class="k">private</span> <span class="k">fun</span> <span class="nf">getNotarySignature</span><span class="p">(</span><span class="n">stx</span><span class="p">:</span> <span class="n">SignedTransaction</span><span class="p">):</span> <span class="n">DigitalSignature</span><span class="p">.</span><span class="n">WithKey</span> <span class="p">{</span>
-        <span class="n">progressTracker</span><span class="p">.</span><span class="n">currentStep</span> <span class="p">=</span> <span class="n">NOTARY</span>
-        <span class="k">return</span> <span class="n">subFlow</span><span class="p">(</span><span class="n">NotaryFlow</span><span class="p">.</span><span class="n">Client</span><span class="p">(</span><span class="n">stx</span><span class="p">))</span>
-    <span class="p">}</span>
+<div class="highlight-kotlin"><div class="highlight"><pre><span></span><span class="n">@Suspendable</span>
+<span class="k">fun</span> <span class="nf">call</span><span class="p">()</span> <span class="p">{</span>
+    <span class="k">val</span> <span class="py">unnotarisedTransaction</span> <span class="p">=</span> <span class="p">...</span>
+    <span class="n">subFlow</span><span class="p">(</span><span class="n">FinalityFlow</span><span class="p">(</span><span class="n">unnotarisedTransaction</span><span class="p">))</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<div class="highlight-java"><div class="highlight"><pre><span></span><span class="nd">@Suspendable</span>
+<span class="kd">public</span> <span class="kt">void</span> <span class="nf">call</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">FlowException</span> <span class="o">{</span>
+    <span class="n">SignedTransaction</span> <span class="n">unnotarisedTransaction</span> <span class="o">=</span> <span class="o">...</span>
+    <span class="n">subFlow</span><span class="o">(</span><span class="k">new</span> <span class="n">FinalityFlow</span><span class="o">(</span><span class="n">unnotarisedTransaction</span><span class="o">))</span>
+<span class="o">}</span>
 </pre></div>
 </div>
 </div>
-<p>In this code snippet we are using the <code class="docutils literal"><span class="pre">NotaryFlow.Client</span></code> to request notarisation of the transaction.
-We simply create the flow object via its constructor, and then pass it to the <code class="docutils literal"><span class="pre">subFlow</span></code> method which
+<p>In this code snippet we are using the <code class="docutils literal"><span class="pre">FinalityFlow</span></code> to finish off the transaction. It will:</p>
+<ul class="simple">
+<li>Send the transaction to the chosen notary and, if necessary, satisfy the notary that the transaction is valid.</li>
+<li>Record the transaction in the local vault, if it is relevant (i.e. involves the owner of the node).</li>
+<li>Send the fully signed transaction to the other participants for recording as well.</li>
+</ul>
+<p>We simply create the flow object via its constructor, and then pass it to the <code class="docutils literal"><span class="pre">subFlow</span></code> method which
 returns the result of the flow&#8217;s execution directly. Behind the scenes all this is doing is wiring up progress
-tracking (discussed more below) and then running the objects <code class="docutils literal"><span class="pre">call</span></code> method. Because this little helper method can
-be on the stack when network IO takes place, we mark it as <code class="docutils literal"><span class="pre">&#64;Suspendable</span></code>.</p>
+tracking (discussed more below) and then running the objects <code class="docutils literal"><span class="pre">call</span></code> method. Because the sub-flow might suspend,
+we must mark the method that invokes it as suspendable.</p>
 <p>Going back to the previous code snippet, we use a sub-flow called <code class="docutils literal"><span class="pre">ResolveTransactionsFlow</span></code>. This is
 responsible for downloading and checking all the dependencies of a transaction, which in Corda are always retrievable
 from the party that sent you a transaction that uses them. This flow returns a list of <code class="docutils literal"><span class="pre">LedgerTransaction</span></code>
@@ -591,43 +597,13 @@ leak will come later.</p>
 </div>
 <p>After the dependencies, we check the proposed trading transaction for validity by running the contracts for that as
 well (but having handled the fact that some signatures are missing ourselves).</p>
-<p>Here&#8217;s the rest of the code:</p>
-<div class="codeset container">
-<div class="highlight-kotlin"><div class="highlight"><pre><span></span>    <span class="k">open</span> <span class="k">fun</span> <span class="nf">calculateOurSignature</span><span class="p">(</span><span class="n">partialTX</span><span class="p">:</span> <span class="n">SignedTransaction</span><span class="p">):</span> <span class="n">DigitalSignature</span><span class="p">.</span><span class="n">WithKey</span> <span class="p">{</span>
-        <span class="n">progressTracker</span><span class="p">.</span><span class="n">currentStep</span> <span class="p">=</span> <span class="n">SIGNING</span>
-        <span class="k">return</span> <span class="n">myKeyPair</span><span class="p">.</span><span class="n">signWithECDSA</span><span class="p">(</span><span class="n">partialTX</span><span class="p">.</span><span class="n">id</span><span class="p">)</span>
-    <span class="p">}</span>
-
-    <span class="n">@Suspendable</span>
-    <span class="k">private</span> <span class="k">fun</span> <span class="nf">sendSignatures</span><span class="p">(</span><span class="n">allPartySignedTx</span><span class="p">:</span> <span class="n">SignedTransaction</span><span class="p">,</span>
-                               <span class="n">ourSignature</span><span class="p">:</span> <span class="n">DigitalSignature</span><span class="p">.</span><span class="n">WithKey</span><span class="p">,</span>
-                               <span class="n">notarySignature</span><span class="p">:</span> <span class="n">DigitalSignature</span><span class="p">.</span><span class="n">WithKey</span><span class="p">):</span> <span class="n">SignedTransaction</span> <span class="p">{</span>
-        <span class="n">progressTracker</span><span class="p">.</span><span class="n">currentStep</span> <span class="p">=</span> <span class="n">SENDING_SIGS</span>
-        <span class="k">val</span> <span class="py">fullySigned</span> <span class="p">=</span> <span class="n">allPartySignedTx</span> <span class="p">+</span> <span class="n">notarySignature</span>
-
-        <span class="n">logger</span><span class="p">.</span><span class="n">trace</span> <span class="p">{</span> <span class="s">&quot;Built finished transaction, sending back to secondary!&quot;</span> <span class="p">}</span>
-
-        <span class="n">send</span><span class="p">(</span><span class="n">otherParty</span><span class="p">,</span> <span class="n">SignaturesFromSeller</span><span class="p">(</span><span class="n">ourSignature</span><span class="p">,</span> <span class="n">notarySignature</span><span class="p">))</span>
-        <span class="k">return</span> <span class="n">fullySigned</span>
-    <span class="p">}</span>
-</pre></div>
-</div>
-</div>
-<p>It&#8217;s all pretty straightforward from now on. Here <code class="docutils literal"><span class="pre">id</span></code> is the secure hash representing the serialised
-transaction, and we just use our private key to calculate a signature over it. As a reminder, in Corda signatures do
-not cover other signatures: just the core of the transaction data.</p>
-<p>In <code class="docutils literal"><span class="pre">sendSignatures</span></code>, we take the two signatures we obtained and add them to the partial transaction we were sent.
-There is an overload for the + operator so signatures can be added to a SignedTransaction easily. Finally, we wrap the
-two signatures in a simple wrapper message class and send it back. The send won&#8217;t block waiting for an acknowledgement,
-but the underlying message queue software will retry delivery if the other side has gone away temporarily.</p>
-<p>You can also see that every flow instance has a logger (using the SLF4J API) which you can use to log progress
-messages.</p>
 <div class="admonition warning">
 <p class="first admonition-title">Warning</p>
-<p class="last">This sample code is <strong>not secure</strong>. Other than not checking for all possible invalid constructions, if the
-seller stops before sending the finalised transaction to the buyer, the seller is left with a valid transaction
-but the buyer isn&#8217;t, so they can&#8217;t spend the asset they just purchased! This sort of thing will be fixed in a
-future version of the code.</p>
+<p class="last">If the seller stops before sending the finalised transaction to the buyer, the seller is left with a
+valid transaction but the buyer isn&#8217;t, so they can&#8217;t spend the asset they just purchased! This sort of thing is not
+always a risk (as the seller may not gain anything from that sort of behaviour except a lawsuit), but if it is, a future
+version of the platform will allow you to ask the notary to send you the transaction as well, in case your counterparty
+does not. This is not the default because it reveals more private info to the notary.</p>
 </div>
 </div>
 <div class="section" id="implementing-the-buyer">
@@ -636,27 +612,27 @@ future version of the code.</p>
 <div class="codeset container">
 <div class="highlight-kotlin"><div class="highlight"><pre><span></span>    @Suspendable
     override fun call(): SignedTransaction {
+        // Wait for a trade request to come in from the other party.
+        progressTracker.currentStep = RECEIVING
         val tradeRequest = receiveAndValidateTradeRequest()
 
+        // Put together a proposed transaction that performs the trade, and sign it.
         progressTracker.currentStep = SIGNING
         val (ptx, cashSigningPubKeys) = assembleSharedTX(tradeRequest)
         val stx = signWithOurKeys(cashSigningPubKeys, ptx)
 
-        val signatures = swapSignaturesWithSeller(stx)
+        // Send the signed transaction to the seller, who must then sign it themselves and commit
+        // it to the ledger by sending it to the notary.
+        progressTracker.currentStep = SENDING_SIGNATURES
+        send(otherParty, stx)
 
-        logger.trace { &quot;Got signatures from seller, verifying ... &quot; }
-
-        val fullySigned = stx + signatures.sellerSig + signatures.notarySig
-        fullySigned.verifySignatures()
-
-        logger.trace { &quot;Signatures received are valid. Trade complete! :-)&quot; }
-        return fullySigned
+        // Wait for the finished, notarised transaction to arrive in our transaction store.
+        progressTracker.currentStep = WAITING_FOR_TX
+        return waitForLedgerCommit(stx.id)
     }
 
     @Suspendable
     private fun receiveAndValidateTradeRequest(): SellerTradeInfo {
-        progressTracker.currentStep = RECEIVING
-        // Wait for a trade request to come in from the other side
         val maybeTradeRequest = receive&lt;SellerTradeInfo&gt;(otherParty)
 
         progressTracker.currentStep = VERIFYING
@@ -671,24 +647,14 @@ future version of the code.</p>
             if (!typeToBuy.isInstance(asset))
                 throw AssetMismatchException(typeToBuy.name, assetTypeName)
 
-            // Check the transaction that contains the state which is being resolved.
-            // We only have a hash here, so if we don&#39;t know it already, we have to ask for it.
+            // Check that the state being sold to us is in a valid chain of transactions, i.e. that the
+            // seller has a valid chain of custody proving that they own the thing they&#39;re selling.
             subFlow(ResolveTransactionsFlow(setOf(it.assetForSale.ref.txhash), otherParty))
 
             return it
         }
     }
 
-    @Suspendable
-    private fun swapSignaturesWithSeller(stx: SignedTransaction): SignaturesFromSeller {
-        progressTracker.currentStep = SWAPPING_SIGNATURES
-        logger.trace { &quot;Sending partially signed transaction to seller&quot; }
-
-        // TODO: Protect against the seller terminating here and leaving us in the lurch without the final tx.
-
-        return sendAndReceive&lt;SignaturesFromSeller&gt;(otherParty, stx).unwrap { it }
-    }
-
     private fun signWithOurKeys(cashSigningPubKeys: List&lt;CompositeKey&gt;, ptx: TransactionBuilder): SignedTransaction {
         // Now sign the transaction with whatever keys we need to move the cash.
         for (publicKey in cashSigningPubKeys.keys) {
@@ -729,12 +695,11 @@ future version of the code.</p>
 <p>This code is longer but no more complicated. Here are some things to pay attention to:</p>
 <ol class="arabic simple">
 <li>We do some sanity checking on the received message to ensure we&#8217;re being offered what we expected to be offered.</li>
-<li>We create a cash spend in the normal way, by using <code class="docutils literal"><span class="pre">VaultService.generateSpend</span></code>. See the vault documentation if this
-part isn&#8217;t clear.</li>
+<li>We create a cash spend using <code class="docutils literal"><span class="pre">VaultService.generateSpend</span></code>. You can read the vault documentation to learn more about this.</li>
 <li>We access the <em>service hub</em> when we need it to access things that are transient and may change or be recreated
 whilst a flow is suspended, things like the wallet or the network map.</li>
-<li>Finally, we send the unfinished, invalid transaction to the seller so they can sign it. They are expected to send
-back to us a <code class="docutils literal"><span class="pre">SignaturesFromSeller</span></code>, which once we verify it, should be the final outcome of the trade.</li>
+<li>We send the unfinished, invalid transaction to the seller so they can sign it and finalise it.</li>
+<li>Finally, we wait for the finished transaction to arrive in our local storage and vault.</li>
 </ol>
 <p>As you can see, the flow logic is straightforward and does not contain any callbacks or network glue code, despite
 the fact that it takes minimal resources and can survive node restarts.</p>
@@ -755,17 +720,13 @@ in one line when using Kotlin. Typical steps might be &#8220;Waiting for respons
 approved&#8221;, &#8220;Downloading and verifying data&#8221; etc.</p>
 <p>A flow might declare some steps with code inside the flow class like this:</p>
 <div class="codeset container">
-<div class="highlight-kotlin"><div class="highlight"><pre><span></span><span class="k">open</span> <span class="k">class</span> <span class="nc">Buyer</span><span class="p">(</span><span class="k">val</span> <span class="py">otherParty</span><span class="p">:</span> <span class="n">Party</span><span class="p">,</span>
-                 <span class="k">val</span> <span class="py">notary</span><span class="p">:</span> <span class="n">Party</span><span class="p">,</span>
-                 <span class="k">val</span> <span class="py">acceptablePrice</span><span class="p">:</span> <span class="n">Amount</span><span class="p">&lt;</span><span class="n">Currency</span><span class="p">&gt;,</span>
-                 <span class="k">val</span> <span class="py">typeToBuy</span><span class="p">:</span> <span class="n">Class</span><span class="p">&lt;</span><span class="k">out</span> <span class="n">OwnableState</span><span class="p">&gt;)</span> <span class="p">:</span> <span class="n">FlowLogic</span><span class="p">&lt;</span><span class="n">SignedTransaction</span><span class="p">&gt;()</span> <span class="p">{</span>
-
-    <span class="k">object</span> <span class="nc">RECEIVING</span> <span class="p">:</span> <span class="n">ProgressTracker</span><span class="p">.</span><span class="n">Step</span><span class="p">(</span><span class="s">&quot;Waiting for seller trading info&quot;</span><span class="p">)</span>
+<div class="highlight-kotlin"><div class="highlight"><pre><span></span>    <span class="k">object</span> <span class="nc">RECEIVING</span> <span class="p">:</span> <span class="n">ProgressTracker</span><span class="p">.</span><span class="n">Step</span><span class="p">(</span><span class="s">&quot;Waiting for seller trading info&quot;</span><span class="p">)</span>
     <span class="k">object</span> <span class="nc">VERIFYING</span> <span class="p">:</span> <span class="n">ProgressTracker</span><span class="p">.</span><span class="n">Step</span><span class="p">(</span><span class="s">&quot;Verifying seller assets&quot;</span><span class="p">)</span>
     <span class="k">object</span> <span class="nc">SIGNING</span> <span class="p">:</span> <span class="n">ProgressTracker</span><span class="p">.</span><span class="n">Step</span><span class="p">(</span><span class="s">&quot;Generating and signing transaction proposal&quot;</span><span class="p">)</span>
-    <span class="k">object</span> <span class="nc">SWAPPING_SIGNATURES</span> <span class="p">:</span> <span class="n">ProgressTracker</span><span class="p">.</span><span class="n">Step</span><span class="p">(</span><span class="s">&quot;Swapping signatures with the seller&quot;</span><span class="p">)</span>
+    <span class="k">object</span> <span class="nc">SENDING_SIGNATURES</span> <span class="p">:</span> <span class="n">ProgressTracker</span><span class="p">.</span><span class="n">Step</span><span class="p">(</span><span class="s">&quot;Sending signatures to the seller&quot;</span><span class="p">)</span>
+    <span class="k">object</span> <span class="nc">WAITING_FOR_TX</span> <span class="p">:</span> <span class="n">ProgressTracker</span><span class="p">.</span><span class="n">Step</span><span class="p">(</span><span class="s">&quot;Waiting for the transaction to finalise.&quot;</span><span class="p">)</span>
 
-    <span class="k">override</span> <span class="k">val</span> <span class="py">progressTracker</span> <span class="p">=</span> <span class="n">ProgressTracker</span><span class="p">(</span><span class="n">RECEIVING</span><span class="p">,</span> <span class="n">VERIFYING</span><span class="p">,</span> <span class="n">SIGNING</span><span class="p">,</span> <span class="n">SWAPPING_SIGNATURES</span><span class="p">)</span>
+    <span class="k">override</span> <span class="k">val</span> <span class="py">progressTracker</span> <span class="p">=</span> <span class="n">ProgressTracker</span><span class="p">(</span><span class="n">RECEIVING</span><span class="p">,</span> <span class="n">VERIFYING</span><span class="p">,</span> <span class="n">SIGNING</span><span class="p">,</span> <span class="n">SENDING_SIGNATURES</span><span class="p">,</span> <span class="n">WAITING_FOR_TX</span><span class="p">)</span>
 </pre></div>
 </div>
 <div class="highlight-java"><div class="highlight"><pre><span></span><span class="kd">private</span> <span class="kd">final</span> <span class="n">ProgressTracker</span> <span class="n">progressTracker</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ProgressTracker</span><span class="o">(</span>
@@ -794,7 +755,7 @@ fully know ahead of time what steps will be required. If you <em>do</em> know wh
 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 <code class="docutils literal"><span class="pre">Step</span></code> class like this:</p>
 <div class="codeset container">
-<div class="highlight-kotlin"><div class="highlight"><pre><span></span>        <span class="k">object</span> <span class="nc">NOTARY</span> <span class="p">:</span> <span class="n">ProgressTracker</span><span class="p">.</span><span class="n">Step</span><span class="p">(</span><span class="s">&quot;Getting notary signature&quot;</span><span class="p">)</span> <span class="p">{</span>
+<div class="highlight-kotlin"><div class="highlight"><pre><span></span>        <span class="k">object</span> <span class="nc">COMMITTING</span> <span class="p">:</span> <span class="n">ProgressTracker</span><span class="p">.</span><span class="n">Step</span><span class="p">(</span><span class="s">&quot;Committing transaction to the ledger&quot;</span><span class="p">)</span> <span class="p">{</span>
             <span class="k">override</span> <span class="k">fun</span> <span class="nf">childProgressTracker</span><span class="p">()</span> <span class="p">=</span> <span class="n">FinalityFlow</span><span class="p">.</span><span class="n">tracker</span><span class="p">()</span>
         <span class="p">}</span>
 </pre></div>

docs/build/html/flow-testing.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Running a notary service" href="running-a-notary.html"/>
         <link rel="prev" title="Writing flows" href="flow-state-machines.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/further-notes-on-kotlin.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Publishing Corda" href="publishing-corda.html"/>
         <link rel="prev" title="Building the documentation" href="building-the-docs.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/genindex.html

@@ -35,6 +35,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="#"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/> 
 
   
@@ -116,7 +119,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/getting-set-up-fault-finding.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Running the demos" href="running-the-demos.html"/>
         <link rel="prev" title="Getting set up" href="getting-set-up.html"/> 
@@ -137,7 +140,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>
@@ -242,8 +245,8 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <h1>Troubleshooting<a class="headerlink" href="#troubleshooting" title="Permalink to this headline">¶</a></h1>
 <div class="section" id="milestone-releases">
 <h2>Milestone releases<a class="headerlink" href="#milestone-releases" title="Permalink to this headline">¶</a></h2>
-<p>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.</p>
-<p>When developing on Corda, you should always check out the latest stable branch instead, by running <code class="docutils literal"><span class="pre">git</span> <span class="pre">checkout</span> <span class="pre">release-M7</span></code>.</p>
+<p>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.</p>
+<p>When developing on Corda, you should always check out the latest milestone (i.e. stable) branch instead. For example, to check out milestone 7, you&#8217;d run <code class="docutils literal"><span class="pre">git</span> <span class="pre">checkout</span> <span class="pre">release-M7</span></code>.</p>
 </div>
 <div class="section" id="java-issues">
 <h2>Java issues<a class="headerlink" href="#java-issues" title="Permalink to this headline">¶</a></h2>
@@ -253,7 +256,8 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 </div>
 <div class="section" id="unresolved-reference-javafx">
 <h3>&#8220;Unresolved reference: javafx&#8221;<a class="headerlink" href="#unresolved-reference-javafx" title="Permalink to this headline">¶</a></h3>
-<p>JavaFX is not bundled with OpenJDK. If you are using OpenJDK and get an &#8216;Unresolved reference: javafx&#8217; error, this means that you need to install OpenJFX. Do this by running <code class="docutils literal"><span class="pre">sudo</span> <span class="pre">apt</span> <span class="pre">install</span> <span class="pre">openjfx</span></code>, and possibly <code class="docutils literal"><span class="pre">sudo</span> <span class="pre">apt</span> <span class="pre">install</span> <span class="pre">libopenjfx-jav</span></code>.</p>
+<p>JavaFX is not bundled with OpenJDK. If you are using OpenJDK and get an &#8216;Unresolved reference: javafx&#8217; error, this means that you need to install OpenJFX.</p>
+<p>If you have APT installed and OpenJFX is part of your Unix distribution&#8217;s package list, you can do this by running <code class="docutils literal"><span class="pre">sudo</span> <span class="pre">apt</span> <span class="pre">install</span> <span class="pre">openjfx</span></code>, and possibly <code class="docutils literal"><span class="pre">sudo</span> <span class="pre">apt</span> <span class="pre">install</span> <span class="pre">libopenjfx-jav</span></code>. Other users will want to refer to the guide <a class="reference external" href="https://wiki.openjdk.java.net/display/OpenJFX/Building+OpenJFX">here</a>, or to the list of Community Builds <a class="reference external" href="https://wiki.openjdk.java.net/display/OpenJFX/Community+Builds">here</a>.</p>
 </div>
 </div>
 <div class="section" id="idea-issues">

docs/build/html/getting-set-up.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Troubleshooting" href="getting-set-up-fault-finding.html"/>
         <link rel="prev" title="What’s included?" href="inthebox.html"/> 
@@ -132,7 +135,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>
@@ -287,11 +290,14 @@ for doing so can be found on the <a class="reference external" href="https://www
 <p>The Corda platform source code is available here:</p>
 <blockquote>
 <div><a class="reference external" href="https://github.com/corda/corda.git">https://github.com/corda/corda.git</a></div></blockquote>
-<p>and a basic CorDapp that you can use as the basis for your own CorDapps is available here:</p>
+<p>A CorDapp template that you can use as the basis for your own CorDapps is available here:</p>
 <blockquote>
 <div><a class="reference external" href="https://github.com/corda/cordapp-template.git">https://github.com/corda/cordapp-template.git</a></div></blockquote>
-<p>You can clone both of these repos to your local machine by running the command <code class="docutils literal"><span class="pre">git</span> <span class="pre">clone</span> <span class="pre">[repo</span> <span class="pre">URL]</span></code>.</p>
-<p>By default, both repos will be on the <code class="docutils literal"><span class="pre">master</span></code> branch. However, this is an unstable development branch. You should check
+<p>And a simple example CorDapp for you to explore basic concepts is available here:</p>
+<blockquote>
+<div><a class="reference external" href="https://github.com/corda/cordapp-tutorial.git">https://github.com/corda/cordapp-tutorial.git</a></div></blockquote>
+<p>You can clone these repos to your local machine by running the command <code class="docutils literal"><span class="pre">git</span> <span class="pre">clone</span> <span class="pre">[repo</span> <span class="pre">URL]</span></code>.</p>
+<p>By default, these repos will be on the <code class="docutils literal"><span class="pre">master</span></code> branch. However, this is an unstable development branch. You should check
 out the latest milestone release (currently Milestone 7) instead by running <code class="docutils literal"><span class="pre">git</span> <span class="pre">checkout</span> <span class="pre">release-M7</span></code>.</p>
 <div class="section" id="opening-corda-cordapps-in-idea">
 <h3>Opening Corda/CorDapps in IDEA<a class="headerlink" href="#opening-corda-cordapps-in-idea" title="Permalink to this headline">¶</a></h3>
@@ -308,7 +314,7 @@ and clicking &#8220;Refresh all Gradle projects&#8221;. Whenever prompted about
 <h2>Next steps<a class="headerlink" href="#next-steps" title="Permalink to this headline">¶</a></h2>
 <p>The best way to check that everything is working fine is by <a class="reference internal" href="running-the-demos.html"><span class="doc">Running the demos</span></a>.</p>
 <p>Once you have these demos running, you may be interested in writing your own CorDapps, in which case you should refer to
-<a class="reference internal" href="tutorial-cordapp.html"><span class="doc">The CorDapp template</span></a>.</p>
+<a class="reference internal" href="tutorial-cordapp.html"><span class="doc">The example CorDapp</span></a>.</p>
 <p>If you encounter any issues, please see the <a class="reference internal" href="getting-set-up-fault-finding.html"><span class="doc">Troubleshooting</span></a> page, or get in touch with us on the
 <a class="reference external" href="https://discourse.corda.net/">forums</a> or via <a class="reference external" href="http://slack.corda.net/">slack</a>.</p>
 </div>

docs/build/html/glossary.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="prev" title="Working with the Corda Demo on Azure Marketplace" href="azure-vm.html"/> 
 
@@ -116,7 +119,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/index.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="#"/>
         <link rel="next" title="What’s included?" href="inthebox.html"/> 
 
@@ -116,7 +119,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>
@@ -236,10 +239,8 @@ which describes the platform&#8217;s envisioned end-state.</p>
 <a class="reference external" href="https://github.com/corda/corda/tree/master/samples">samples</a> directory. To run these yourself, make
 sure you follow the instructions in <a class="reference internal" href="getting-set-up.html"><span class="doc">Getting set up</span></a>, then go to
 <a class="reference internal" href="running-the-demos.html"><span class="doc">Running the demos</span></a>.</p>
-<p>If, after running the demos, you&#8217;re interested in writing your own CorDapps, a template CorDapp is available on
-<a class="reference external" href="https://github.com/corda/cordapp-template">Github</a>. To get it running, follow the instructions in the
-<a class="reference external" href="https://github.com/corda/cordapp-template/blob/master/README.md">readme</a>, or watch the
-<a class="reference external" href="https://vimeo.com/192797322/aab499b152">Corda Developers Tutorial</a>.</p>
+<p>If, after running the demos, you&#8217;re interested in writing your own CorDapps, you can use the
+<a class="reference external" href="https://github.com/corda/cordapp-template">CorDapp template</a> as a base. A simple example CorDapp built upon the template is available <a class="reference external" href="https://github.com/corda/cordapp-tutorial">here</a>, and a video primer on basic CorDapp structure is available <a class="reference external" href="https://vimeo.com/192797322/aab499b152">here</a>.</p>
 <p>From there, you&#8217;ll be in a position to start extending the example CorDapp yourself (e.g. by writing new states, contracts,
 and/or flows). For this, you&#8217;ll want to refer to this docsite, and to the <a class="reference external" href="https://docs.corda.net/tutorial-contract.html">tutorials</a>
 in particular. If you get stuck, get in touch on <a class="reference external" href="https://slack.corda.net/">Slack</a> or the <a class="reference external" href="https://discourse.corda.net/">forum</a>.</p>
@@ -248,8 +249,8 @@ platform itself. Find out more about <a class="reference external" href="https:/
 </div>
 <div class="section" id="documentation-contents">
 <h1>Documentation Contents:<a class="headerlink" href="#documentation-contents" title="Permalink to this headline">¶</a></h1>
-<div class="toctree-wrapper compound" id="getting-started">
-<p class="caption"><span class="caption-text">Getting started</span><a class="headerlink" href="#getting-started" title="Permalink to this toctree">¶</a></p>
+<div class="toctree-wrapper compound">
+<p class="caption"><span class="caption-text">Getting started</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="inthebox.html">What&#8217;s included?</a></li>
 <li class="toctree-l1"><a class="reference internal" href="getting-set-up.html">Getting set up</a><ul>
@@ -282,8 +283,8 @@ platform itself. Find out more about <a class="reference external" href="https:/
 </li>
 </ul>
 </div>
-<div class="toctree-wrapper compound" id="key-concepts">
-<p class="caption"><span class="caption-text">Key concepts</span><a class="headerlink" href="#key-concepts" title="Permalink to this toctree">¶</a></p>
+<div class="toctree-wrapper compound">
+<p class="caption"><span class="caption-text">Key concepts</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="key-concepts.html">Overview</a></li>
 <li class="toctree-l1"><a class="reference internal" href="key-concepts-ecosystem.html">Corda ecosystem</a><ul>
@@ -324,8 +325,8 @@ platform itself. Find out more about <a class="reference external" href="https:/
 <li class="toctree-l1"><a class="reference internal" href="key-concepts-security-model.html">Security model</a></li>
 </ul>
 </div>
-<div class="toctree-wrapper compound" id="cordapps">
-<p class="caption"><span class="caption-text">CorDapps</span><a class="headerlink" href="#cordapps" title="Permalink to this toctree">¶</a></p>
+<div class="toctree-wrapper compound">
+<p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="creating-a-cordapp.html#app-plugins">App plugins</a></li>
@@ -339,19 +340,19 @@ platform itself. Find out more about <a class="reference external" href="https:/
 <li class="toctree-l2"><a class="reference internal" href="creating-a-cordapp.html#gradle-plugins-for-cordapps">Gradle plugins for CorDapps</a></li>
 </ul>
 </li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a><ul>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="tutorial-cordapp.html#background">Background</a></li>
 <li class="toctree-l2"><a class="reference internal" href="tutorial-cordapp.html#getting-started">Getting started</a></li>
-<li class="toctree-l2"><a class="reference internal" href="tutorial-cordapp.html#building-the-cordapp-template">Building the CorDapp template</a></li>
-<li class="toctree-l2"><a class="reference internal" href="tutorial-cordapp.html#running-the-cordapp-template">Running the CorDapp template</a></li>
-<li class="toctree-l2"><a class="reference internal" href="tutorial-cordapp.html#interacting-with-the-cordapp-template">Interacting with the CorDapp template</a></li>
-<li class="toctree-l2"><a class="reference internal" href="tutorial-cordapp.html#extending-the-cordapp-template">Extending the CorDapp template</a></li>
+<li class="toctree-l2"><a class="reference internal" href="tutorial-cordapp.html#building-the-example-cordapp">Building the example CorDapp</a></li>
+<li class="toctree-l2"><a class="reference internal" href="tutorial-cordapp.html#running-the-example-cordapp">Running the example CorDapp</a></li>
+<li class="toctree-l2"><a class="reference internal" href="tutorial-cordapp.html#interacting-with-the-example-cordapp">Interacting with the example CorDapp</a></li>
+<li class="toctree-l2"><a class="reference internal" href="tutorial-cordapp.html#extending-the-example-cordapp">Extending the example CorDapp</a></li>
 </ul>
 </li>
 </ul>
 </div>
-<div class="toctree-wrapper compound" id="the-corda-node">
-<p class="caption"><span class="caption-text">The Corda node</span><a class="headerlink" href="#the-corda-node" title="Permalink to this toctree">¶</a></p>
+<div class="toctree-wrapper compound">
+<p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="clientrpc.html">Client RPC</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="clientrpc.html#security">Security</a></li>
@@ -418,8 +419,8 @@ platform itself. Find out more about <a class="reference external" href="https:/
 </li>
 </ul>
 </div>
-<div class="toctree-wrapper compound" id="id4">
-<p class="caption"><span class="caption-text">Tutorials</span><a class="headerlink" href="#id4" title="Permalink to this toctree">¶</a></p>
+<div class="toctree-wrapper compound">
+<p class="caption"><span class="caption-text">Tutorials</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="tutorial-contract.html">Writing a contract</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="tutorial-contract.html#where-to-put-your-code">Where to put your code</a></li>
@@ -479,7 +480,7 @@ platform itself. Find out more about <a class="reference external" href="https:/
 <li class="toctree-l2"><a class="reference internal" href="flow-state-machines.html#starting-your-flow">Starting your flow</a></li>
 <li class="toctree-l2"><a class="reference internal" href="flow-state-machines.html#implementing-the-seller">Implementing the seller</a></li>
 <li class="toctree-l2"><a class="reference internal" href="flow-state-machines.html#exception-handling">Exception handling</a></li>
-<li class="toctree-l2"><a class="reference internal" href="flow-state-machines.html#sub-flows">Sub-flows</a></li>
+<li class="toctree-l2"><a class="reference internal" href="flow-state-machines.html#sub-flows-and-finalisation">Sub-flows and finalisation</a></li>
 <li class="toctree-l2"><a class="reference internal" href="flow-state-machines.html#implementing-the-buyer">Implementing the buyer</a></li>
 <li class="toctree-l2"><a class="reference internal" href="flow-state-machines.html#progress-tracking">Progress tracking</a></li>
 <li class="toctree-l2"><a class="reference internal" href="flow-state-machines.html#versioning">Versioning</a></li>
@@ -511,8 +512,8 @@ platform itself. Find out more about <a class="reference external" href="https:/
 </li>
 </ul>
 </div>
-<div class="toctree-wrapper compound" id="other">
-<p class="caption"><span class="caption-text">Other</span><a class="headerlink" href="#other" title="Permalink to this toctree">¶</a></p>
+<div class="toctree-wrapper compound">
+<p class="caption"><span class="caption-text">Other</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="network-simulator.html">Network Simulator</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="network-simulator.html#what-it-is-and-is-not">What it is and is not</a></li>
@@ -533,8 +534,8 @@ platform itself. Find out more about <a class="reference external" href="https:/
 </li>
 </ul>
 </div>
-<div class="toctree-wrapper compound" id="component-library">
-<p class="caption"><span class="caption-text">Component library</span><a class="headerlink" href="#component-library" title="Permalink to this toctree">¶</a></p>
+<div class="toctree-wrapper compound">
+<p class="caption"><span class="caption-text">Component library</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="contract-catalogue.html">Contract catalogue</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="contract-catalogue.html#cash">Cash</a></li>
@@ -551,8 +552,8 @@ platform itself. Find out more about <a class="reference external" href="https:/
 </li>
 </ul>
 </div>
-<div class="toctree-wrapper compound" id="appendix">
-<p class="caption"><span class="caption-text">Appendix</span><a class="headerlink" href="#appendix" title="Permalink to this toctree">¶</a></p>
+<div class="toctree-wrapper compound">
+<p class="caption"><span class="caption-text">Appendix</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="loadtesting.html">Load testing</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="loadtesting.html#configuration-of-the-load-testing-cluster">Configuration of the load testing cluster</a></li>
@@ -619,8 +620,8 @@ platform itself. Find out more about <a class="reference external" href="https:/
 </li>
 </ul>
 </div>
-<div class="toctree-wrapper compound" id="glossary">
-<p class="caption"><span class="caption-text">Glossary</span><a class="headerlink" href="#glossary" title="Permalink to this toctree">¶</a></p>
+<div class="toctree-wrapper compound">
+<p class="caption"><span class="caption-text">Glossary</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="glossary.html">Glossary</a></li>
 </ul>

docs/build/html/inthebox.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Getting set up" href="getting-set-up.html"/>
         <link rel="prev" title="Welcome to the Corda documentation!" href="index.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/key-concepts-consensus-notaries.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Vault" href="key-concepts-vault.html"/>
         <link rel="prev" title="Flow framework" href="key-concepts-flow-framework.html"/> 
@@ -127,7 +130,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/key-concepts-core-types.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Financial model" href="key-concepts-financial-model.html"/>
         <link rel="prev" title="Data model" href="key-concepts-data-model.html"/> 
@@ -130,7 +133,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/key-concepts-data-model.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Core types" href="key-concepts-core-types.html"/>
         <link rel="prev" title="Corda ecosystem" href="key-concepts-ecosystem.html"/> 
@@ -127,7 +130,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/key-concepts-ecosystem.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Data model" href="key-concepts-data-model.html"/>
         <link rel="prev" title="Overview" href="key-concepts.html"/> 
@@ -120,7 +123,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/key-concepts-financial-model.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Flow framework" href="key-concepts-flow-framework.html"/>
         <link rel="prev" title="Core types" href="key-concepts-core-types.html"/> 
@@ -121,7 +124,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/key-concepts-flow-framework.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Consensus and notaries" href="key-concepts-consensus-notaries.html"/>
         <link rel="prev" title="Financial model" href="key-concepts-financial-model.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/key-concepts-security-model.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="CorDapp basics" href="creating-a-cordapp.html"/>
         <link rel="prev" title="Vault" href="key-concepts-vault.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/key-concepts-vault.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Security model" href="key-concepts-security-model.html"/>
         <link rel="prev" title="Consensus and notaries" href="key-concepts-consensus-notaries.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/key-concepts.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="Corda ecosystem" href="key-concepts-ecosystem.html"/>
         <link rel="prev" title="CLI vs IDE" href="CLI-vs-IDE.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>

docs/build/html/loadtesting.html

@@ -34,6 +34,9 @@
   
 
   
+        <link rel="index" title="Index"
+              href="genindex.html"/>
+        <link rel="search" title="Search" href="search.html"/>
     <link rel="top" title="R3 Corda latest documentation" href="index.html"/>
         <link rel="next" title="What is a corda network?" href="setting-up-a-corda-network.html"/>
         <link rel="prev" title="Interest rate swaps" href="contract-irs.html"/> 
@@ -117,7 +120,7 @@ API reference: <a href="api/kotlin/corda/index.html">Kotlin</a>/ <a href="api/ja
 <p class="caption"><span class="caption-text">CorDapps</span></p>
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="creating-a-cordapp.html">CorDapp basics</a></li>
-<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The CorDapp template</a></li>
+<li class="toctree-l1"><a class="reference internal" href="tutorial-cordapp.html">The example CorDapp</a></li>
 </ul>
 <p class="caption"><span class="caption-text">The Corda node</span></p>
 <ul>