Regen docsite

docs/build/html/_sources/consensus.txt

@@ -0,0 +1,118 @@
+Consensus Model
+===============
+
+The fundamental unit of consensus in Corda is the **state**. The concept of consensus can be divided into two parts:
+
+1. Consensus over state **validity** -- parties can reach certainty that a transaction defining output states is accepted by the contracts pointed to by the states and has all the required signatures. This is achieved by parties independently running the same contract code and validation logic (as described in :doc:`data model <data-model>`)
+
+2. Consensus over state **uniqueness** -- parties can reach certainty the the output states created in a transaction are the unique successors to the input states consumed by that transaction (in other words -- a state has not been used as an input by more than one transaction)
+
+This article presents an initial model for addressing the **uniqueness** problem.
+
+.. note:: The current model is still a **work in progress** and everything described in this article can and is likely to change
+
+Notary
+------
+
+We introduce the concept of a **Notary**, which is an authority responsible for attesting that for a given transaction, it had not signed another transaction consuming any of its input states.
+The data model is extended so that every **state** has an appointed Notary:
+
+.. sourcecode:: kotlin
+
+    interface ContractState {
+        /** Contract by which the state belongs */
+        val contract: Contract
+
+        /** Identity of the notary that ensures this state is not used as an input to a transaction more than once */
+        val notary: Party
+    }
+
+All transactions have to be signed by their input state Notary for the output states to be **valid** (apart from *issue* transactions, containing no input states).
+
+.. note:: The Notary is a logical concept and can itself be a distributed entity, potentially a cluster maintained by mutually distrusting parties
+
+When the Notary is requested to sign a transaction, it either signs over it, attesting that the outputs are the **unique** successors of the inputs,
+or provides conflict information for any input state that had been consumed by another transaction it had signed before.
+In doing so, the Notary provides the point of finality in the system. Until the Notary signature is obtained, parties cannot be sure that an equally valid, but conflicting transaction,
+will not be regarded as confirmed. After the signature is obtained, the parties know that the inputs to this transaction have been uniquely consumed by this transaction.
+Hence it is the point at which we can say finality has occurred.
+
+Validation
+----------
+
+The Notary *does not validate* transaction integrity (i.e. does not run contracts or check signatures) to minimise the exposed data.
+Validation would require the caller to reveal the whole transaction history chain, resulting in a privacy leak.
+
+However, this makes it open to "denial of state" attacks, where a party could submit any invalid transaction to the Notary and thus "block" someone else's states.
+That is partially alleviated by requiring the calling party to authenticate and storing its identity for the request.
+The conflict information returned by the Notary specifies the consuming transaction id along with the identity of the party that had requested the commit.
+If the conflicting transaction is valid, the current one gets aborted; if not – a dispute can be raised and the input states of the conflicting invalid transaction are "un-committed" (to be covered by legal process).
+
+.. note:: At present the Notary can see the entire transaction, but we have a separate piece of work to replace the parts of the transaction it does not require knowing about with hashes (only input references, timestamp information, overall transaction ID and the necessary digests of the rest of the transaction to prove that the referenced inputs/timestamps really do form part of the stated transaction ID should be visible).
+
+Multiple Notaries
+-----------------
+
+More than one Notary can exist in the network. This gives the following benefits:
+
+* **Custom behaviour**. We can have both validating and privacy preserving Notaries -- parties can make a choice based on their specific requirements
+* **Load balancing**. Spreading the transaction load over multiple Notaries will allow higher transaction throughput in the platform overall
+* **Low latency**. Latency could be minimised by choosing a Notary physically closer the transacting parties
+
+A transaction should only be signed by a Notary if all of its input states point to it.
+In cases where a transaction involves states controlled by multiple Notaries, the states first have to be repointed to the same notary.
+This is achieved by using a special type of transaction that doesn't modify anything but the Notary pointer of the state.
+Ensuring that all input states point to the same Notary is the responsibility of each involved party
+(it is another condition for an output state of the transaction to be **valid**)
+
+Timestamping
+------------
+
+In this model the Notary also acts as a **Timestamping Authority**, verifying the transaction timestamp command.
+
+For a timestamp to be meaningful, its implications must be binding on the party requesting it.
+A party can obtain a timestamp signature in order to prove that some event happened before/on/or after a particular point in time.
+However, if the party is not also compelled to commit to the associated transaction, it has a choice of whether or not to reveal this fact until some point in the future.
+As a result, we need to ensure that the Notary either has to also sign the transaction within some time tolerance,
+or perform timestamping *and* notarisation at the same time, which is the chosen behaviour for this model.
+
+Implementation & Usage
+----------------------
+
+At present we have single basic implementation of a Notary that uses a :code:`UniquenessProvider` storing committed input states in memory:
+
+.. sourcecode:: kotlin
+
+    class InMemoryUniquenessProvider() : UniquenessProvider {
+        /** For each input state store the consuming transaction information */
+        private val committedStates = HashMap<StateRef, ConsumingTx>()
+
+        override fun commit(tx: WireTransaction, callerIdentity: Party) {
+            ...
+        }
+    }
+    ...
+    /**
+     * Specifies the transaction id, the position of the consumed state in the inputs, and
+     * the caller identity requesting the commit
+     */
+    data class ConsumingTx(val id: SecureHash, val inputIndex: Int, val requestingParty: Party)
+
+To obtain a signature from a Notary use :code:`NotaryProtocol`, passing in a :code:`WireTransaction`.
+The protocol will work out which Notary needs to be called based on the input states and the timestamp command.
+For example, the following snippet can be used when writing a custom protocol:
+
+.. sourcecode:: kotlin
+
+    private fun getNotarySignature(wtx: WireTransaction): DigitalSignature.LegallyIdentifiable {
+        return subProtocol(NotaryProtocol(wtx))
+    }
+
+On conflict the :code:`NotaryProtocol` with throw a :code:`NotaryException` containing the conflict details:
+
+.. sourcecode:: kotlin
+
+    /** Specifies the consuming transaction for the conflicting input state */
+    data class Conflict(val stateHistory: Map<StateRef, ConsumingTx>)
+
+Conflict handling and resolution is currently the responsibility of the protocol author.

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

@@ -1,23 +1,33 @@
 Getting set up
 ==============
 
-Install the Oracle JDK 8u45 or higher. OpenJDK will probably also work but I'm not testing with that.
+Ensure that you have access to R3 git repository.
 
-Then install IntelliJ version 15 community edition:
+    https://bitbucket.org/R3-CEV/r3prototyping.git
 
-   https://www.jetbrains.com/idea/download/
+If you cannot access the page please contact the R3 admin team.
 
-Upgrade the Kotlin plugin to the latest version (1.0-beta-4584) by clicking "Configure > Plugins" in the opening screen,
+Install the Oracle JDK 8u45 or higher. OpenJDK will probably also work, but it hasn't been tested.
+
+Then install IntelliJ. The Community Edition is good enough:
+
+    https://www.jetbrains.com/idea/download/
+
+Upgrade the Kotlin plugin to the latest version by clicking "Configure > Plugins" in the opening screen,
 then clicking "Install JetBrains plugin", then searching for Kotlin, then hitting "Upgrade" and then "Restart".
+You can confirm what is the latest version of Kotlin plugin on this page:
 
-Choose "Check out from version control" and use this git URL
+    https://plugins.jetbrains.com/plugin/6954
 
-     https://your_username@bitbucket.org/R3-CEV/r3repository.git
+Choose "Check out from version control" and use this git URL. Please remember to replace your_username with your
+actual bitbucket user name.
 
-Agree to the defaults for importing a Gradle project. Wait for it to think and download the dependencies.
+    https://your_username@bitbucket.org/R3-CEV/r3prototyping.git
 
-Right click on the tests directory, click "Run -> All Tests" (note: NOT the first item in the submenu that has the
-gradle logo next to it).
+After code is cloned open the project. Please ensure that Gradle project is imported.
+You should have the "Unliked Gradle project?" pop-up window in the IntelliJ top right corner. Please click on "Import Gradle Project". Wait for it to think and download the dependencies. After that you might have another popup titled "Unindexed remote maven repositories found." This is general IntelliJ question and doesn't affect Corda, therefore you can decided to index them or not.
+
+Next click on "green arrow" next to "All tests" pop-up on the top toolbar.
 
 The code should build, the unit tests should show as all green.
 
@@ -26,7 +36,7 @@ You can catch up with the latest code by selecting "VCS -> Update Project" in th
 If IntelliJ complains about lack of an SDK
 ------------------------------------------
 
-If on attempting to open the project, IntelliJ refuses because SDK was not selected, do the following:
+If on attempting to open the project (including importing Gradle project), IntelliJ refuses because SDK was not selected, do the following:
 
    Configure -> Project Defaults -> Project Structure
 
@@ -45,6 +55,7 @@ Doing it without IntelliJ
 -------------------------
 
 If you don't want to explore or modify the code in a local IDE, you can also just use the command line and a text editor:
-
-* Run ``./gradlew test`` to run the unit tests.
-* Run ``git pull`` to upgrade
+* First run ``git clone https://your_username@bitbucket.org/R3-CEV/r3prototyping.git`` to download Corda source code. Please remember to replace your_username with your actual bitbucket user name.
+* Next ensure that you are in r3repository ``cd r3repository``
+* Then you can run ``./gradlew test`` to run the unit tests.
+* Finally remeber to run ``git pull`` to upgrade the source code.

docs/build/html/_sources/index.txt

@@ -1,26 +1,24 @@
-Welcome to the R3 prototyping repository!
-=========================================
+Welcome to the Corda repository!
+================================
 
-This documentation describes the first prototype of a possible future R3 shared ledger platform.
+This documentation describes the prototype of a proposed architecture for distributed ledgers.
 
-The goal of this prototype is to explore fundamentally better designs for transactions, states and smart contract APIs
-than what presently exists on the market, tailor made for the needs of the financial industry. We are attempting to
-prove or disprove the following hypothesis:
+The goal of this prototype is to explore fundamentally better designs for distributed ledgers than what presently exists
+on the market, tailor made for the needs of the financial industry. We are attempting to prove or disprove the
+following hypothesis:
 
-*The combination of*
-
-* *An upgraded state transition model*
-* *Industry standard, production quality virtual machines and languages*
-* *Limited data propagation*
-* *Conflict resolution without proof of work or blocks*
-
-*is sufficiently powerful to justify the creation of a new platform implementation.*
+The combination of
 
+* An upgraded state transition model
+* Industry standard, production quality virtual machines and languages
+* An advanced orchestration framework
+* Limited data propagation
+* Conflict resolution without proof of work or blocks
 
+is sufficiently powerful to justify the creation of a new platform implementation.
 
 Read on to learn:
 
-
 .. toctree::
    :maxdepth: 2
    :caption: Overview
@@ -28,6 +26,7 @@ Read on to learn:
    inthebox
    getting-set-up
    data-model
+   consensus
    messaging
    running-the-demos
    node-administration
@@ -37,7 +36,7 @@ Read on to learn:
    :maxdepth: 2
    :caption: Tutorials
 
-   tutorial_contract
+   tutorial-contract
    protocol-state-machines
    oracles
 
@@ -45,6 +44,7 @@ Read on to learn:
    :maxdepth: 2
    :caption: Appendix
 
+   release-process
    visualiser
    codestyle
    building-the-docs

docs/build/html/_sources/node-administration.txt

@@ -8,7 +8,7 @@ Monitoring your node
 --------------------
 
 Like most Java servers, the node exports various useful metrics and management operations via the industry-standard
-`JMX infrastructure <https://en.wikipedia.org/wiki/Java_Management_Extensions>`_. JMX is a standard _in-process_ API
+`JMX infrastructure <https://en.wikipedia.org/wiki/Java_Management_Extensions>`_. JMX is a standard API
 for registering so-called _MBeans_ ... objects whose properties and methods are intended for server management. It does
 not require any particular network protocol for export. So this data can be exported from the node in various ways:
 some monitoring systems provide a "Java Agent", which is essentially a JVM plugin that finds all the MBeans and sends

docs/build/html/_sources/oracles.txt

@@ -176,11 +176,11 @@ Implementation involves the following steps:
 2. Defining a lower level service class, that binds network messages to the API.
 3. Defining a protocol using the :doc:`protocol-state-machines` framework to make it easy for a client to interact
    with the oracle.
+4. Constructing it (when advertised) in ``AbstractNode``.
 
 An example of how to do this can be found in the ``NodeInterestRates.Oracle``, ``NodeInterestRates.Service`` and
-``RateFixProtocol`` classes. The exact details of how this code works will change in future, so for now consulting
-the protocols tutorial and the code for the server-side oracles implementation will have to suffice. There will be more
-detail added once the platform APIs have settled down.
+``RateFixProtocol`` classes.
 
-Currently, there's no network map service, so the location and identity keys of an oracle must be distributed out of
-band.
+The exact details of how this code works will change in future, so for now consulting the protocols tutorial and the
+code for the server-side oracles implementation will have to suffice. There will be more detail added once the
+platform APIs have settled down.

docs/build/html/_sources/release-process.txt

@@ -0,0 +1,23 @@
+Release process
+===============
+
+Corda is under heavy development. The current release process is therefore geared towards rapid iteration.
+
+Each Corda development release is called a *milestone* and has its own branch in the git repository. Milestones are
+temporarily stabilised snapshots of the Corda code which are suitable for developers to experiment with. They may
+receive backported bugfixes but once announced a milestone will not have any API or backwards compatibility breaks.
+
+Between milestones backwards compatibility is expected to break. Every new milestone comes with a short announcement
+detailing:
+
+* What major improvements have been made.
+* How to forward port your code to the new milestone.
+* What new documentation has become available.
+* Important known issues.
+
+Eventually, Corda will stabilise and release version 1. At that point backwards compatibility will be guaranteed
+forever and the software will be considered production ready. Until then, expect it to be a building site and wear your
+hard hat.
+
+Our goal is to cut a new milestone roughly once a month. There are no fixed dates. If need be, a milestone may slip by
+a few days to ensure the code is sufficiently usable.

docs/build/html/_sources/running-the-demos.txt

@@ -14,29 +14,27 @@ The demos have only been tested on MacOS X and Ubuntu Linux. If you have success
 The demos create node data directories in the root of the project. If something goes wrong with them, blow away the
 directories and try again.
 
-For Windows users, the contents of the shell scripts are very trivial and can easily be done by hand from a command
-window. Essentially, it just runs Gradle to create the startup scripts, and then starts the node with one set of
-flags or another. Alternatively you could play with the new Linux syscall support in Windows 10!
-
 Trader demo
 -----------
 
 Open two terminals, and in the first run:::
 
-    ./scripts/trader-demo.sh buyer
+    gradle installDist && ./build/install/r3prototyping/bin/trader-demo.sh --role=BUYER
 
-It will compile things, if necessary, then create a directory named "buyer" with a bunch of files inside and start
-the node. You should see it waiting for a trade to begin.
+It will compile things, if necessary, then create a directory named trader-demo/buyer with a bunch of files inside and
+start the node. You should see it waiting for a trade to begin.
 
 In the second terminal, run::
 
-    ./scripts/trader-demo.sh seller
+    ./build/install/r3prototyping/bin/trader-demo.sh --role=SELLER
 
 You should see some log lines scroll past, and within a few seconds the messages "Purchase complete - we are a
 happy customer!" and "Sale completed - we have a happy customer!" should be printed.
 
 If it doesn't work, jump on the mailing list and let us know.
 
+On Windows, use the same commands, but run the batch file instead of the shell file.
+
 
 IRS demo
 --------

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

@@ -0,0 +1,838 @@
+.. highlight:: kotlin
+.. raw:: html
+
+   <script type="text/javascript" src="_static/jquery.js"></script>
+   <script type="text/javascript" src="_static/codesets.js"></script>
+
+Writing a contract
+==================
+
+This tutorial will take you through how the commercial paper contract works.
+
+The code in this tutorial is available in both Kotlin and Java. You can quickly switch between them to get a feeling
+for how Kotlin syntax works.
+
+Starting the commercial paper class
+-----------------------------------
+
+A smart contract is a class that implements the ``Contract`` interface. For now, they have to be a part of the main
+codebase, as dynamic loading of contract code is not yet implemented. Therefore, we start by creating a file named
+either ``CommercialPaper.kt`` or ``CommercialPaper.java`` in the src/contracts directory with the following contents:
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      class CommercialPaper : Contract {
+          override val legalContractReference: SecureHash = SecureHash.sha256("https://en.wikipedia.org/wiki/Commercial_paper");
+
+          override fun verify(tx: TransactionForVerification) {
+              TODO()
+          }
+      }
+
+   .. sourcecode:: java
+
+      public class Cash implements Contract {
+          @Override
+          public SecureHash getLegalContractReference() {
+              return SecureHash.Companion.sha256("https://en.wikipedia.org/wiki/Commercial_paper");
+          }
+
+          @Override
+          public void verify(TransactionForVerification tx) {
+              throw new UnsupportedOperationException();
+          }
+      }
+
+Every contract must have at least a ``getLegalContractReference()`` and a ``verify()`` method. In Kotlin we express
+a getter without a setter as an immutable property (val). The *legal contract reference* is supposed to be a hash
+of a document that describes the legal contract and may take precedence over the code, in case of a dispute.
+
+The verify method returns nothing. This is intentional: the function either completes correctly, or throws an exception,
+in which case the transaction is rejected.
+
+We also need to define a constant hash that would, in a real system, be the hash of the program bytecode. For now
+we just set it to a dummy value as dynamic loading and sandboxing of bytecode is not implemented. This constant
+isn't shown in the code snippet but is called ``CP_PROGRAM_ID``.
+
+So far, so simple. Now we need to define the commercial paper *state*, which represents the fact of ownership of a
+piece of issued paper.
+
+States
+------
+
+A state is a class that stores data that is checked by the contract.
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      data class State(
+        val issuance: InstitutionReference,
+        val owner: PublicKey,
+        val faceValue: Amount,
+        val maturityDate: Instant
+      ) : ContractState {
+        override val programRef = CP_PROGRAM_ID
+
+        fun withoutOwner() = copy(owner = NullPublicKey)
+      }
+
+   .. sourcecode:: java
+
+      public static class State implements ContractState, SerializeableWithKryo {
+        private InstitutionReference issuance;
+        private PublicKey owner;
+        private Amount faceValue;
+        private Instant maturityDate;
+
+        public State() {}  // For serialization
+
+        public State(InstitutionReference issuance, PublicKey owner, Amount faceValue, Instant maturityDate) {
+            this.issuance = issuance;
+            this.owner = owner;
+            this.faceValue = faceValue;
+            this.maturityDate = maturityDate;
+        }
+
+        public InstitutionReference getIssuance() {
+            return issuance;
+        }
+
+        public PublicKey getOwner() {
+            return owner;
+        }
+
+        public Amount getFaceValue() {
+            return faceValue;
+        }
+
+        public Instant getMaturityDate() {
+            return maturityDate;
+        }
+
+        @NotNull
+        @Override
+        public SecureHash getProgramRef() {
+            return SecureHash.Companion.sha256("java commercial paper (this should be a bytecode hash)");
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            State state = (State) o;
+
+            if (issuance != null ? !issuance.equals(state.issuance) : state.issuance != null) return false;
+            if (owner != null ? !owner.equals(state.owner) : state.owner != null) return false;
+            if (faceValue != null ? !faceValue.equals(state.faceValue) : state.faceValue != null) return false;
+            return !(maturityDate != null ? !maturityDate.equals(state.maturityDate) : state.maturityDate != null);
+
+        }
+
+        @Override
+        public int hashCode() {
+            int result = issuance != null ? issuance.hashCode() : 0;
+            result = 31 * result + (owner != null ? owner.hashCode() : 0);
+            result = 31 * result + (faceValue != null ? faceValue.hashCode() : 0);
+            result = 31 * result + (maturityDate != null ? maturityDate.hashCode() : 0);
+            return result;
+        }
+
+        public State withoutOwner() {
+            return new State(issuance, NullPublicKey.INSTANCE, faceValue, maturityDate);
+        }
+      }
+
+We define a class that implements the ``ContractState`` and ``SerializableWithKryo`` interfaces. The
+latter is an artifact of how the prototype implements serialization and can be ignored for now: it wouldn't work
+like this in any final product.
+
+The ``ContractState`` interface requires us to provide a ``getProgramRef`` method that is supposed to return a hash of
+the bytecode of the contract itself. For now this is a dummy value and isn't used: later on, this mechanism will change.
+Beyond that it's a freeform object into which we can put anything which can be serialized.
+
+We have four fields in our state:
+
+* ``issuance``: a reference to a specific piece of commercial paper at a party
+* ``owner``: the public key of the current owner. This is the same concept as seen in Bitcoin: the public key has no
+  attached identity and is expected to be one-time-use for privacy reasons. However, unlike in Bitcoin, we model
+  ownership at the level of individual contracts rather than as a platform-level concept as we envisage many
+  (possibly most) contracts on the platform will not represent "owner/issuer" relationships, but "party/party"
+  relationships such as a derivative contract.
+* ``faceValue``: an ``Amount``, which wraps an integer number of pennies and a currency.
+* ``maturityDate``: an `Instant <https://docs.oracle.com/javase/8/docs/api/java/time/Instant.html>`_, which is a type
+  from the Java 8 standard time library. It defines a point on the timeline.
+
+States are immutable, and thus the class is defined as immutable as well. The ``data`` modifier in the Kotlin version
+causes the compiler to generate the equals/hashCode/toString methods automatically, along with a copy method that can
+be used to create variants of the original object. Data classes are similar to case classes in Scala, if you are
+familiar with that language. The ``withoutOwner`` method uses the auto-generated copy method to return a version of
+the state with the owner public key blanked out: this will prove useful later.
+
+The Java code compiles to the same bytecode as the Kotlin version, but as you can see, is much more verbose.
+
+Commands
+--------
+
+The logic for a contract may vary depending on what stage of a lifecycle it is automating. So it can be useful to
+pass additional data into the contract code that isn't represented by the states which exist permanently in the ledger.
+
+For this purpose we have commands. Often, they don't need to contain any data at all, they just need to exist. A command
+is a piece of data associated with some *signatures*. By the time the contract runs the signatures have already been
+checked, so from the contract code's perspective, a command is simply a data structure with a list of attached
+public keys. Each key had a signature proving that the corresponding private key was used to sign.
+
+Let's define a few commands now:
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      interface Commands : Command {
+          object Move : Commands
+          object Redeem : Commands
+          object Issue : Commands
+      }
+
+
+   .. sourcecode:: java
+
+      public static class Commands implements core.contract.Command {
+          public static class Move extends Commands {
+              @Override
+              public boolean equals(Object obj) {
+                  return obj instanceof Move;
+              }
+          }
+
+          public static class Redeem extends Commands {
+              @Override
+              public boolean equals(Object obj) {
+                  return obj instanceof Redeem;
+              }
+          }
+
+          public static class Issue extends Commands {
+              @Override
+              public boolean equals(Object obj) {
+                  return obj instanceof Issue;
+              }
+          }
+      }
+
+The ``object`` keyword in Kotlin just defines a singleton object. As the commands don't need any additional data in our
+case, they can be empty and we just use their type as the important information. Java has no syntax for declaring
+singletons, so we just define a class that considers any other instance to be equal and that's good enough.
+
+The verify function
+-------------------
+
+The heart of a smart contract is the code that verifies a set of state transitions (a *transaction*). The function is
+simple: it's given a class representing the transaction, and if the function returns then the transaction is considered
+acceptable. If it throws an exception, the transaction is rejected.
+
+Each transaction can have multiple input and output states of different types. The set of contracts to run is decided
+by taking the code references inside each state. Each contract is run only once. As an example, a contract that includes
+2 cash states and 1 commercial paper state as input, and has as output 1 cash state and 1 commercial paper state, will
+run two contracts one time each: Cash and CommercialPaper.
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      override fun verify(tx: TransactionForVerification) {
+          // Group by everything except owner: any modification to the CP at all is considered changing it fundamentally.
+          val groups = tx.groupStates() { it: State -> it.withoutOwner() }
+          val command = tx.commands.requireSingleCommand<CommercialPaper.Commands>()
+
+   .. sourcecode:: java
+
+      @Override
+      public void verify(@NotNull TransactionForVerification tx) {
+          List<InOutGroup<State, State>> groups = tx.groupStates(State.class, State::withoutOwner);
+          AuthenticatedObject<Command> cmd = requireSingleCommand(tx.getCommands(), Commands.class);
+
+We start by using the ``groupStates`` method, which takes a type and a function. State grouping is a way of ensuring
+your contract can handle multiple unrelated states of the same type in the same transaction, which is needed for
+splitting/merging of assets, atomic swaps and so on. The second line does what the code suggests: it searches for
+a command object that inherits from the ``CommercialPaper.Commands`` supertype, and either returns it, or throws an
+exception if there's zero or more than one such command.
+
+Using state groups
+------------------
+
+The simplest way to write a smart contract would be to say that each transaction can have a single input state and a
+single output state of the kind govered by that contract. This would be easy for the developer, but would prevent many
+important use cases.
+
+The next easiest way to write a contract would be to iterate over each input state and expect it to have an output
+state. Now you can build a single transaction that, for instance, moves two different cash states in different currencies
+simultaneously. But it gets complicated when you want to issue or exit one state at the same time as moving another.
+
+Things get harder still once you want to split and merge states. We say states are *fungible* if they are
+treated identically to each other by the recipient, despite the fact that they aren't quite identical. Dollar bills are
+fungible because even though one may be worn/a bit dirty and another may be crisp and new, they are still both worth
+exactly $1. Likewise, ten $1 bills are almost exactly equivalent to one $10 bill. On the other hand, $10 and £10 are not
+fungible: if you tried to pay for something that cost £20 with $10+£10 notes your trade would not be accepted.
+
+To make all this easier the contract API provides a notion of groups. A group is a set of input states and output states
+that should be checked for validity together.
+
+Consider the following simplified currency trade transaction:
+
+* **Input**:  $12,000 owned by Alice   (A)
+* **Input**:   $3,000 owned by Alice   (A)
+* **Input**:  £10,000 owned by Bob     (B)
+* **Output**: £10,000 owned by Alice   (B)
+* **Output**: $15,000 owned by Bob     (A)
+
+In this transaction Alice and Bob are trading $15,000 for £10,000. Alice has her money in the form of two different
+inputs e.g. because she received the dollars in two payments. The input and output amounts do balance correctly, but
+the cash smart contract must consider the pounds and the dollars separately because they are not fungible: they cannot
+be merged together. So we have two groups: A and B.
+
+The ``TransactionForVerification.groupStates`` method handles this logic for us: firstly, it selects only states of the
+given type (as the transaction may include other types of state, such as states representing bond ownership, or a
+multi-sig state) and then it takes a function that maps a state to a grouping key. All states that share the same key are
+grouped together. In the case of the cash example above, the grouping key would be the currency.
+
+In other kinds of contract, we don't want CP to be fungible: merging and splitting is (in our example) not allowed.
+So we just use a copy of the state minus the owner field as the grouping key.
+
+Here are some code examples:
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      // Type of groups is List<InOutGroup<State, Pair<PartyReference, Currency>>>
+      val groups = tx.groupStates() { it: Cash.State -> Pair(it.deposit, it.amount.currency) }
+      for ((inputs, outputs, key) in groups) {
+          // Either inputs or outputs could be empty.
+          val (deposit, currency) = key
+
+          ...
+      }
+
+   .. sourcecode:: java
+
+      List<InOutGroup<State, Pair<PartyReference, Currency>>> groups = tx.groupStates(Cash.State.class, s -> Pair(s.deposit, s.amount.currency))
+      for (InOutGroup<State, Pair<PartyReference, Currency>> group : groups) {
+          List<State> inputs = group.getInputs();
+          List<State> outputs = group.getOutputs();
+          Pair<PartyReference, Currency> key = group.getKey();
+
+          ...
+      }
+
+The ``groupStates`` call uses the provided function to calculate a "grouping key". All states that have the same
+grouping key are placed in the same group. A grouping key can be anything that implements equals/hashCode, but it's
+always an aggregate of the fields that shouldn't change between input and output. In the above example we picked the
+fields we wanted and packed them into a ``Pair``. It returns a list of ``InOutGroup``, which is just a holder for the
+inputs, outputs and the key that was used to define the group. In the Kotlin version we unpack these using destructuring
+to get convenient access to the inputs, the outputs, the deposit data and the currency. The Java version is more
+verbose, but equivalent.
+
+The rules can then be applied to the inputs and outputs as if it were a single transaction. A group may have zero
+inputs or zero outputs: this can occur when issuing assets onto the ledger, or removing them.
+
+In this example, we do it differently and use the state class itself as the aggregator. We just
+blank out fields that are allowed to change, making the grouping key be "everything that isn't that":
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      val groups = tx.groupStates() { it: State -> it.withoutOwner() }
+
+   .. sourcecode:: java
+
+      List<InOutGroup<State, State>> groups = tx.groupStates(State.class, State::withoutOwner);
+
+For large states with many fields that must remain constant and only one or two that are really mutable, it's often
+easier to do things this way than to specifically name each field that must stay the same. The ``withoutOwner`` function
+here simply returns a copy of the object but with the ``owner`` field set to ``NullPublicKey``, which is just a public key
+of all zeros. It's invalid and useless, but that's OK, because all we're doing is preventing the field from mattering
+in equals and hashCode.
+
+
+Checking the requirements
+-------------------------
+
+After extracting the command and the groups, we then iterate over each group and verify it meets the required business
+logic.
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      val time = tx.time
+      for (group in groups) {
+          when (command.value) {
+              is Commands.Move -> {
+                  val input = group.inputs.single()
+                  requireThat {
+                      "the transaction is signed by the owner of the CP" by (command.signers.contains(input.owner))
+                      "the state is propagated" by (group.outputs.size == 1)
+                  }
+              }
+
+              is Commands.Redeem -> {
+                  val input = group.inputs.single()
+                  val received = tx.outStates.sumCashBy(input.owner)
+                  if (time == null) throw IllegalArgumentException("Redemption transactions must be timestamped")
+                  requireThat {
+                      "the paper must have matured" by (time > input.maturityDate)
+                      "the received amount equals the face value" by (received == input.faceValue)
+                      "the paper must be destroyed" by group.outputs.isEmpty()
+                      "the transaction is signed by the owner of the CP" by (command.signers.contains(input.owner))
+                  }
+              }
+
+              is Commands.Issue -> {
+                  val output = group.outputs.single()
+                  if (time == null) throw IllegalArgumentException("Issuance transactions must be timestamped")
+                  requireThat {
+                      // Don't allow people to issue commercial paper under other entities identities.
+                      "the issuance is signed by the claimed issuer of the paper" by
+                              (command.signers.contains(output.issuance.party.owningKey))
+                      "the face value is not zero" by (output.faceValue.pennies > 0)
+                      "the maturity date is not in the past" by (time < output.maturityDate )
+                      // Don't allow an existing CP state to be replaced by this issuance.
+                      "there is no input state" by group.inputs.isEmpty()
+                  }
+              }
+
+              // TODO: Think about how to evolve contracts over time with new commands.
+              else -> throw IllegalArgumentException("Unrecognised command")
+          }
+      }
+
+   .. sourcecode:: java
+
+      Instant time = tx.getTime();   // Can be null/missing.
+      for (InOutGroup<State> group : groups) {
+          List<State> inputs = group.getInputs();
+          List<State> outputs = group.getOutputs();
+
+          // For now do not allow multiple pieces of CP to trade in a single transaction. Study this more!
+          State input = single(filterIsInstance(inputs, State.class));
+
+          if (!cmd.getSigners().contains(input.getOwner()))
+              throw new IllegalStateException("Failed requirement: the transaction is signed by the owner of the CP");
+
+          if (cmd.getValue() instanceof JavaCommercialPaper.Commands.Move) {
+              // Check the output CP state is the same as the input state, ignoring the owner field.
+              State output = single(outputs);
+
+              if (!output.getFaceValue().equals(input.getFaceValue()) ||
+                      !output.getIssuance().equals(input.getIssuance()) ||
+                      !output.getMaturityDate().equals(input.getMaturityDate()))
+                  throw new IllegalStateException("Failed requirement: the output state is the same as the input state except for owner");
+          } else if (cmd.getValue() instanceof JavaCommercialPaper.Commands.Redeem) {
+              Amount received = CashKt.sumCashOrNull(inputs);
+              if (time == null)
+                  throw new IllegalArgumentException("Redemption transactions must be timestamped");
+              if (received == null)
+                  throw new IllegalStateException("Failed requirement: no cash being redeemed");
+              if (input.getMaturityDate().isAfter(time))
+                  throw new IllegalStateException("Failed requirement: the paper must have matured");
+              if (!input.getFaceValue().equals(received))
+                  throw new IllegalStateException("Failed requirement: the received amount equals the face value");
+              if (!outputs.isEmpty())
+                  throw new IllegalStateException("Failed requirement: the paper must be destroyed");
+          } else if (cmd.getValue() instanceof JavaCommercialPaper.Commands.Issue) {
+              // .. etc .. (see Kotlin for full definition)
+          }
+      }
+
+This loop is the core logic of the contract.
+
+The first line simply gets the timestamp out of the transaction. Timestamping of transactions is optional, so a time
+may be missing here. We check for it being null later.
+
+.. note:: In the Kotlin version, as long as we write a comparison with the transaction time first, the compiler will
+   verify we didn't forget to check if it's missing. Unfortunately due to the need for smooth Java interop, this
+   check won't happen if we write e.g. ``someDate > time``, it has to be ``time < someDate``. So it's good practice to
+   always write the transaction timestamp first.
+
+The first line (first three lines in Java) impose a requirement that there be a single piece of commercial paper in
+this group. We do not allow multiple units of CP to be split or merged even if they are owned by the same owner. The
+``single()`` method is a static *extension method* defined by the Kotlin standard library: given a list, it throws an
+exception if the list size is not 1, otherwise it returns the single item in that list. In Java, this appears as a
+regular static method of the type familiar from many FooUtils type singleton classes. In Kotlin, it appears as a
+method that can be called on any JDK list. The syntax is slightly different but behind the scenes, the code compiles
+to the same bytecodes.
+
+Next, we check that the transaction was signed by the public key that's marked as the current owner of the commercial
+paper. Because the platform has already verified all the digital signatures before the contract begins execution,
+all we have to do is verify that the owner's public key was one of the keys that signed the transaction. The Java code
+is straightforward. The Kotlin version looks a little odd: we have a *requireThat* construct that looks like it's
+built into the language. In fact *requireThat* is an ordinary function provided by the platform's contract API. Kotlin
+supports the creation of *domain specific languages* through the intersection of several features of the language, and
+we use it here to support the natural listing of requirements. To see what it compiles down to, look at the Java version.
+Each ``"string" by (expression)`` statement inside a ``requireThat`` turns into an assertion that the given expression is
+true, with an exception being thrown that contains the string if not. It's just another way to write out a regular
+assertion, but with the English-language requirement being put front and center.
+
+Next, we take one of two paths, depending on what the type of the command object is.
+
+If the command is a ``Move`` command, then we simply verify that the output state is actually present: a move is not
+allowed to delete the CP from the ledger. The grouping logic already ensured that the details are identical and haven't
+been changed, save for the public key of the owner.
+
+If the command is a ``Redeem`` command, then the requirements are more complex:
+
+1. We want to see that the face value of the CP is being moved as a cash claim against some party, that is, the
+   issuer of the CP is really paying back the face value.
+2. The transaction must be happening after the maturity date.
+3. The commercial paper must *not* be propagated by this transaction: it must be deleted, by the group having no
+   output state. This prevents the same CP being considered redeemable multiple times.
+
+To calculate how much cash is moving, we use the ``sumCashOrNull`` utility method. Again, this is an extension method,
+so in Kotlin code it appears as if it was a method on the ``List<Cash.State>`` type even though JDK provides no such
+method. In Java we see its true nature: it is actually a static method named ``CashKt.sumCashOrNull``. This method simply
+returns an ``Amount`` object containing the sum of all the cash states in the transaction output, or null if there were
+no such states *or* if there were different currencies represented in the outputs! So we can see that this contract
+imposes a limitation on the structure of a redemption transaction: you are not allowed to move currencies in the same
+transaction that the CP does not involve. This limitation could be addressed with better APIs, if it were to be a
+real limitation.
+
+Finally, we support an ``Issue`` command, to create new instances of commercial paper on the ledger. It likewise
+enforces various invariants upon the issuance.
+
+This contract is extremely simple and does not implement all the business logic a real commercial paper lifecycle
+management program would. For instance, there is no logic requiring a signature from the issuer for redemption:
+it is assumed that any transfer of money that takes place at the same time as redemption is good enough. Perhaps
+that is something that should be tightened. Likewise, there is no logic handling what happens if the issuer has gone
+bankrupt, if there is a dispute, and so on.
+
+As the prototype evolves, these requirements will be explored and this tutorial updated to reflect improvements in the
+contracts API.
+
+How to test your contract
+-------------------------
+
+Of course, it is essential to unit test your new nugget of business logic to ensure that it behaves as you expect.
+Although you can write traditional unit tests in Java, the platform also provides a *domain specific language*
+(DSL) for writing contract unit tests that automates many of the common patterns. This DSL builds on top of JUnit yet
+is a Kotlin DSL, and therefore this section will not show Java equivalent code (for Java unit tests you would not
+benefit from the DSL and would write them by hand).
+
+We start by defining a new test class, with a basic CP state:
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      class CommercialPaperTests {
+          val PAPER_1 = CommercialPaper.State(
+                  issuance = InstitutionReference(MEGA_CORP, OpaqueBytes.of(123)),
+                  owner = MEGA_CORP_KEY,
+                  faceValue = 1000.DOLLARS,
+                  maturityDate = TEST_TX_TIME + 7.days
+          )
+
+          @Test
+          fun key_mismatch_at_issue() {
+              transactionGroup {
+                  transaction {
+                      output { PAPER_1 }
+                      arg(DUMMY_PUBKEY_1) { CommercialPaper.Commands.Issue() }
+                  }
+
+                  expectFailureOfTx(1, "signed by the claimed issuer")
+              }
+          }
+      }
+
+We start by defining a commercial paper state. It will be owned by a pre-defined unit test party, affectionately
+called ``MEGA_CORP`` (this constant, along with many others, is defined in ``TestUtils.kt``). Due to Kotin's extensive
+type inference, many types are not written out explicitly in this code and it has the feel of a scripting language.
+But the types are there, and you can ask IntelliJ to reveal them by pressing Alt-Enter on a "val" or "var" and selecting
+"Specify type explicitly".
+
+There are a few things that are unusual here:
+
+* We can specify quantities of money by writing 1000.DOLLARS or 1000.POUNDS
+* We can specify quantities of time by writing 7.days
+* We can add quantities of time to the TEST_TX_TIME constant, which merely defines an arbitrary java.time.Instant
+
+If you examine the code in the actual repository, you will also notice that it makes use of method names with spaces
+in them by surrounding the name with backticks, rather than using underscores. We don't show this here as it breaks the
+doc website's syntax highlighting engine.
+
+The ``1000.DOLLARS`` construct is quite simple: Kotlin allows you to define extension functions on primitive types like
+Int or Double. So by writing 7.days, for instance, the compiler will emit a call to a static method that takes an int
+and returns a ``java.time.Duration``.
+
+As this is JUnit, we must remember to annotate each test method with @Test. Let's examine the contents of the first test.
+We are trying to check that it's not possible for just anyone to issue commercial paper in MegaCorp's name. That would
+be bad!
+
+The ``transactionGroup`` function works the same way as the ``requireThat`` construct above.
+
+.. note:: This DSL is an example of what Kotlin calls a type safe builder, which you can read about in `the
+   documentation for builders <https://kotlinlang.org/docs/reference/type-safe-builders.html>`_. You can mix and match
+   ordinary code inside such DSLs so please read the linked page to make sure you fully understand what they are capable
+   of.
+
+The code block that follows it is run in the scope of a freshly created ``TransactionGroupForTest`` object, which assists
+you with building little transaction graphs and verifying them as a whole. Here, our "group" only actually has a
+single transaction in it, with a single output, no inputs, and an Issue command signed by ``DUMMY_PUBKEY_1`` which is just
+an arbitrary public key. As the paper claims to be issued by ``MEGA_CORP``, this doesn't match and should cause a
+failure. The ``expectFailureOfTx`` method takes a 1-based index (in this case we expect the first transaction to fail)
+and a string that should appear in the exception message. Then it runs the ``TransactionGroup.verify()`` method to
+invoke all the involved contracts.
+
+It's worth bearing in mind that even though this code may look like a totally different language to normal Kotlin or
+Java, it's actually not, and so you can embed arbitrary code anywhere inside any of these blocks.
+
+Let's set up a full trade and ensure it works:
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      // Generate a trade lifecycle with various parameters.
+      private fun trade(redemptionTime: Instant = TEST_TX_TIME + 8.days,
+                        aliceGetsBack: Amount = 1000.DOLLARS,
+                        destroyPaperAtRedemption: Boolean = true): TransactionGroupForTest {
+        val someProfits = 1200.DOLLARS
+        return transactionGroup {
+            roots {
+                transaction(900.DOLLARS.CASH owned_by ALICE label "alice's $900")
+                transaction(someProfits.CASH owned_by MEGA_CORP_KEY label "some profits")
+            }
+
+            // Some CP is issued onto the ledger by MegaCorp.
+            transaction {
+                output("paper") { PAPER_1 }
+                arg(MEGA_CORP_KEY) { CommercialPaper.Commands.Issue() }
+            }
+
+            // The CP is sold to alice for her $900, $100 less than the face value. At 10% interest after only 7 days,
+            // that sounds a bit too good to be true!
+            transaction {
+                input("paper")
+                input("alice's $900")
+                output { 900.DOLLARS.CASH owned_by MEGA_CORP_KEY }
+                output("alice's paper") { PAPER_1 owned_by ALICE }
+                arg(ALICE) { Cash.Commands.Move }
+                arg(MEGA_CORP_KEY) { CommercialPaper.Commands.Move }
+            }
+
+            // Time passes, and Alice redeem's her CP for $1000, netting a $100 profit. MegaCorp has received $1200
+            // as a single payment from somewhere and uses it to pay Alice off, keeping the remaining $200 as change.
+            transaction(time = redemptionTime) {
+                input("alice's paper")
+                input("some profits")
+
+                output { aliceGetsBack.CASH owned_by ALICE }
+                output { (someProfits - aliceGetsBack).CASH owned_by MEGA_CORP_KEY }
+                if (!destroyPaperAtRedemption)
+                    output { PAPER_1 owned_by ALICE }
+
+                arg(MEGA_CORP_KEY) { Cash.Commands.Move }
+                arg(ALICE) { CommercialPaper.Commands.Redeem }
+            }
+        }
+    }
+
+In this example we see some new features of the DSL:
+
+* The ``roots`` construct. Sometimes you don't want to write transactions that laboriously issue everything you need
+  in a formally correct way. Inside ``roots`` you can create a bunch of states without any contract checking what you're
+  doing. As states may not exist outside of transactions, each line inside defines a fake/invalid transaction with the
+  given output states, which may be *labelled* with a short string. Those labels can be used later to join transactions
+  together.
+* The ``.CASH`` suffix. This is a part of the unit test DSL specific to the cash contract. It takes a monetary amount
+  like 1000.DOLLARS and then wraps it in a cash ledger state, with some fake data.
+* The owned_by `infix function <https://kotlinlang.org/docs/reference/functions.html#infix-notation>`_. This is just
+  a normal function that we're allowed to write in a slightly different way, which returns a copy of the cash state
+  with the owner field altered to be the given public key. ``ALICE`` is a constant defined by the test utilities that
+  is, like ``DUMMY_PUBKEY_1``, just an arbitrary keypair.
+* We are now defining several transactions that chain together. We can optionally label any output we create. Obviously
+  then, the ``input`` method requires us to give the label of some other output that it connects to.
+* The ``transaction`` function can also be given a time, to override the default timestamp on a transaction.
+
+The ``trade`` function is not itself a unit test. Instead it builds up a trade/transaction group, with some slight
+differences depending on the parameters provided (Kotlin allows parameters to have default values). Then it returns
+it, unexecuted.
+
+We use it like this:
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      @Test
+      fun ok() {
+          trade().verify()
+      }
+
+      @Test
+      fun not_matured_at_redemption() {
+          trade(redemptionTime = TEST_TX_TIME + 2.days).expectFailureOfTx(3, "must have matured")
+      }
+
+That's pretty simple: we just call ``verify`` in order to check all the transactions in the group. If any are invalid,
+an exception will be thrown indicating which transaction failed and why. In the second case, we call ``expectFailureOfTx``
+again to ensure the third transaction fails with a message that contains "must have matured" (it doesn't have to be
+the exact message).
+
+
+Adding a generation API to your contract
+----------------------------------------
+
+Contract classes **must** provide a verify function, but they may optionally also provide helper functions to simplify
+their usage. A simple class of functions most contracts provide are *generation functions*, which either create or
+modify a transaction to perform certain actions (an action is normally mappable 1:1 to a command, but doesn't have to
+be so).
+
+Generation may involve complex logic. For example, the cash contract has a ``generateSpend`` method that is given a set of
+cash states and chooses a way to combine them together to satisfy the amount of money that is being sent. In the
+immutable-state model that we are using ledger entries (states) can only be created and deleted, but never modified.
+Therefore to send $1200 when we have only $900 and $500 requires combining both states together, and then creating
+two new output states of $1200 and $200 back to ourselves. This latter state is called the *change* and is a concept
+that should be familiar to anyone who has worked with Bitcoin.
+
+As another example, we can imagine code that implements a netting algorithm may generate complex transactions that must
+be signed by many people. Whilst such code might be too big for a single utility method (it'd probably be sized more
+like a module), the basic concept is the same: preparation of a transaction using complex logic.
+
+For our commercial paper contract however, the things that can be done with it are quite simple. Let's start with
+a method to wrap up the issuance process:
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      fun generateIssue(issuance: InstitutionReference, faceValue: Amount, maturityDate: Instant): TransactionBuilder {
+          val state = State(issuance, issuance.party.owningKey, faceValue, maturityDate)
+          return TransactionBuilder(state, WireCommand(Commands.Issue, issuance.party.owningKey))
+      }
+
+We take a reference that points to the issuing party (i.e. the caller) and which can contain any internal
+bookkeeping/reference numbers that we may require. Then the face value of the paper, and the maturity date. It
+returns a ``TransactionBuilder``. A ``TransactionBuilder`` is one of the few mutable classes the platform provides.
+It allows you to add inputs, outputs and commands to it and is designed to be passed around, potentially between
+multiple contracts.
+
+.. note:: Generation methods should ideally be written to compose with each other, that is, they should take a
+   ``TransactionBuilder`` as an argument instead of returning one, unless you are sure it doesn't make sense to
+   combine this type of transaction with others. In this case, issuing CP at the same time as doing other things
+   would just introduce complexity that isn't likely to be worth it, so we return a fresh object each time: instead,
+   an issuer should issue the CP (starting out owned by themselves), and then sell it in a separate transaction.
+
+The function we define creates a ``CommercialPaper.State`` object that mostly just uses the arguments we were given,
+but it fills out the owner field of the state to be the same public key as the issuing party. If the caller wants
+to issue CP onto the ledger that's immediately owned by someone else, they'll have to create the state themselves.
+
+The returned partial transaction has a ``WireCommand`` object as a parameter. This is a container for any object
+that implements the ``Command`` interface, along with a key that is expected to sign this transaction. In this case,
+issuance requires that the issuing party sign, so we put the key of the party there.
+
+The ``TransactionBuilder`` constructor we used above takes a variable argument list for convenience. You can pass in
+any ``ContractStateRef`` (input), ``ContractState`` (output) or ``Command`` objects and it'll build up the transaction
+for you.
+
+What about moving the paper, i.e. reassigning ownership to someone else?
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      fun generateMove(tx: TransactionBuilder, paper: StateAndRef<State>, newOwner: PublicKey) {
+          tx.addInputState(paper.ref)
+          tx.addOutputState(paper.state.copy(owner = newOwner))
+          tx.addArg(WireCommand(Commands.Move, paper.state.owner))
+      }
+
+Here, the method takes a pre-existing ``TransactionBuilder`` and adds to it. This is correct because typically
+you will want to combine a sale of CP atomically with the movement of some other asset, such as cash. So both
+generate methods should operate on the same transaction. You can see an example of this being done in the unit tests
+for the commercial paper contract.
+
+The paper is given to us as a ``StateAndRef<CommercialPaper.State>`` object. This is exactly what it sounds like:
+a small object that has a (copy of) a state object, and also the (txhash, index) that indicates the location of this
+state on the ledger.
+
+Finally, we can do redemption.
+
+.. container:: codeset
+
+   .. sourcecode:: kotlin
+
+      @Throws(InsufficientBalanceException::class)
+      fun generateRedeem(tx: TransactionBuilder, paper: StateAndRef<State>, wallet: List<StateAndRef<Cash.State>>) {
+          // Add the cash movement using the states in our wallet.
+          Cash().generateSpend(tx, paper.state.faceValue, paper.state.owner, wallet)
+          tx.addInputState(paper.ref)
+          tx.addArg(WireCommand(CommercialPaper.Commands.Redeem, paper.state.owner))
+      }
+
+Here we can see an example of composing contracts together. When an owner wishes to redeem the commercial paper, the
+issuer (i.e. the caller) must gather cash from its wallet and send the face value to the owner of the paper.
+
+.. note:: **Exercise for the reader**: In this early, simplified model of CP there is no built in support
+   for rollover. Extend the contract code to support rollover as well as redemption (reissuance of the paper with a
+   higher face value without any transfer of cash)
+
+The *wallet* is a concept that may be familiar from Bitcoin and Ethereum. It is simply a set of cash states that are
+owned by the caller. Here, we use the wallet to update the partial transaction we are handed with a movement of cash
+from the issuer of the commercial paper to the current owner. If we don't have enough quantity of cash in our wallet,
+an exception is thrown. And then we add the paper itself as an input, but, not an output (as we wish to delete it
+from the ledger permanently). Finally, we add a Redeem command that should be signed by the owner of the commercial
+paper.
+
+A ``TransactionBuilder`` is not by itself ready to be used anywhere, so first, we must convert it to something that
+is recognised by the network. The most important next step is for the participating entities to sign it using the
+``signWith()`` method. This takes a keypair, serialises the transaction, signs the serialised form and then stores the
+signature inside the ``TransactionBuilder``. Once all parties have signed, you can call ``TransactionBuilder.toSignedTransaction()``
+to get a ``SignedTransaction`` object. This is an immutable form of the transaction that's ready for *timestamping*,
+which can be done using a ``TimestamperClient``. To learn more about that, please refer to the
+:doc:`protocol-state-machines` document.
+
+You can see how transactions flow through the different stages of construction by examining the commercial paper
+unit tests.
+
+Non-asset-oriented based smart contracts
+----------------------------------------
+
+It is important to distinguish between the idea of a legal contract vs a code contract. In this document we use the
+term *contract* as a shorthand for code contract: a small module of widely shared, simultaneously executed business
+logic that uses standardised APIs and runs in a sandbox.
+
+Although this tutorial covers how to implement an owned asset, there is no requirement that states and code contracts
+*must* be concerned with ownership of an asset. It is better to think of states as representing useful facts about the
+world, and (code) contracts as imposing logical relations on how facts combine to produce new facts.
+
+For example, in the case that the transfer of an asset cannot be performed entirely on-ledger, one possible usage of
+the model is to implement a delivery-vs-payment lifecycle in which there is a state representing an intention to trade
+and two other states that can be interpreted by off-ledger platforms as firm instructions to move the respective asset
+or cash - and a final state in which the exchange is marked as complete. The key point here is that the two off-platform
+instructions form pa rt of the same Transaction and so either both are signed (and can be processed by the off-ledger
+systems) or neither are.
+
+As another example, consider multi-signature transactions, a feature which is commonly used in Bitcoin to implement
+various kinds of useful protocols. This technique allows you to lock an asset to ownership of a group, in which a
+threshold of signers (e.g. 3 out of 4) must all sign simultaneously to enable the asset to move. It is initially
+tempting to simply add this as another feature to each existing contract which someone might want to treat in this way.
+But that could lead to unnecessary duplication of work.
+
+A better approach is to model the fact of joint ownership as a new contract with its own state. In this approach, to
+lock up your commercial paper under multi-signature ownership you would make a transaction that looks like this:
+
+* **Input**: the CP state
+* **Output**: a multi-sig state that contains the list of keys and the signing threshold desired (e.g. 3 of 4). The state has a hash of H.
+* **Output**: the same CP state, with a marker that says a state with hash H must exist in any transaction that spends it.
+
+The CP contract then needs to be extended only to verify that a state with the required hash is present as an input.
+The logic that implements measurement of the threshold, different signing combinations that may be allowed etc can then
+be implemented once in a separate contract, with the controlling data being held in the named state.
+
+Future versions of the prototype will explore these concepts in more depth.

docs/build/html/api/api/-a-p-i-server-impl/-init-.html

@@ -1,14 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.<init> - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">APIServerImpl</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$<init>(node.internal.AbstractNode)/node">node</span><span class="symbol">:</span>&nbsp;<a href="../../core.node/-abstract-node/index.html"><span class="identifier">AbstractNode</span></a><span class="symbol">)</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/build-transaction.html

@@ -1,19 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.buildTransaction - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">buildTransaction</a><br/>
-<br/>
-<h1>buildTransaction</h1>
-<a name="node.internal.APIServerImpl$buildTransaction(node.api.ContractDefRef, kotlin.collections.List((node.api.TransactionBuildStep)))"></a>
-<code><span class="keyword">fun </span><span class="identifier">buildTransaction</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$buildTransaction(node.api.ContractDefRef, kotlin.collections.List((node.api.TransactionBuildStep)))/type">type</span><span class="symbol">:</span>&nbsp;<a href="../-contract-def-ref.html"><span class="identifier">ContractDefRef</span></a><span class="symbol">, </span><span class="identifier" id="node.internal.APIServerImpl$buildTransaction(node.api.ContractDefRef, kotlin.collections.List((node.api.TransactionBuildStep)))/steps">steps</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../-transaction-build-step/index.html"><span class="identifier">TransactionBuildStep</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span></code><br/>
-Overrides <a href="../-a-p-i-server/build-transaction.html">APIServer.buildTransaction</a><br/>
-<p>TransactionBuildSteps would be invocations of contract.generateXXX() methods that all share a common TransactionBuilder
-and a common contract type (e.g. Cash or CommercialPaper)
-which would automatically be passed as the first argument (wed need that to be a criteria/pattern of the generateXXX methods).</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/commit-transaction.html

@@ -1,18 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.commitTransaction - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">commitTransaction</a><br/>
-<br/>
-<h1>commitTransaction</h1>
-<a name="node.internal.APIServerImpl$commitTransaction(core.serialization.SerializedBytes((core.contracts.WireTransaction)), kotlin.collections.List((core.crypto.DigitalSignature.WithKey)))"></a>
-<code><span class="keyword">fun </span><span class="identifier">commitTransaction</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$commitTransaction(core.serialization.SerializedBytes((core.contracts.WireTransaction)), kotlin.collections.List((core.crypto.DigitalSignature.WithKey)))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="node.internal.APIServerImpl$commitTransaction(core.serialization.SerializedBytes((core.contracts.WireTransaction)), kotlin.collections.List((core.crypto.DigitalSignature.WithKey)))/signatures">signatures</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core.crypto/-digital-signature/-with-key/index.html"><span class="identifier">WithKey</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code><br/>
-Overrides <a href="../-a-p-i-server/commit-transaction.html">APIServer.commitTransaction</a><br/>
-<p>Attempt to commit transaction (returned from build transaction) with the necessary signatures for that to be
-successful, otherwise exception is thrown.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/fetch-protocols-requiring-attention.html

@@ -1,17 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.fetchProtocolsRequiringAttention - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">fetchProtocolsRequiringAttention</a><br/>
-<br/>
-<h1>fetchProtocolsRequiringAttention</h1>
-<a name="node.internal.APIServerImpl$fetchProtocolsRequiringAttention(node.api.StatesQuery)"></a>
-<code><span class="keyword">fun </span><span class="identifier">fetchProtocolsRequiringAttention</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$fetchProtocolsRequiringAttention(node.api.StatesQuery)/query">query</span><span class="symbol">:</span>&nbsp;<a href="../-states-query/index.html"><span class="identifier">StatesQuery</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">,</span>&nbsp;<a href="../-protocol-requiring-attention/index.html"><span class="identifier">ProtocolRequiringAttention</span></a><span class="symbol">&gt;</span></code><br/>
-Overrides <a href="../-a-p-i-server/fetch-protocols-requiring-attention.html">APIServer.fetchProtocolsRequiringAttention</a><br/>
-<p>Fetch protocols that require a response to some prompt/question by a human (on the "bank" side).</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/fetch-states.html

@@ -1,16 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.fetchStates - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">fetchStates</a><br/>
-<br/>
-<h1>fetchStates</h1>
-<a name="node.internal.APIServerImpl$fetchStates(kotlin.collections.List((core.contracts.StateRef)))"></a>
-<code><span class="keyword">fun </span><span class="identifier">fetchStates</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$fetchStates(kotlin.collections.List((core.contracts.StateRef)))/states">states</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">,</span>&nbsp;<a href="../../core/-contract-state/index.html"><span class="identifier">ContractState</span></a><span class="symbol">?</span><span class="symbol">&gt;</span></code><br/>
-Overrides <a href="../-a-p-i-server/fetch-states.html">APIServer.fetchStates</a><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/fetch-transactions.html

@@ -1,22 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.fetchTransactions - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">fetchTransactions</a><br/>
-<br/>
-<h1>fetchTransactions</h1>
-<a name="node.internal.APIServerImpl$fetchTransactions(kotlin.collections.List((core.crypto.SecureHash)))"></a>
-<code><span class="keyword">fun </span><span class="identifier">fetchTransactions</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$fetchTransactions(kotlin.collections.List((core.crypto.SecureHash)))/txs">txs</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">,</span>&nbsp;<a href="../../core/-signed-transaction/index.html"><span class="identifier">SignedTransaction</span></a><span class="symbol">?</span><span class="symbol">&gt;</span></code><br/>
-Overrides <a href="../-a-p-i-server/fetch-transactions.html">APIServer.fetchTransactions</a><br/>
-<p>Query for immutable transactions (results can be cached indefinitely by their id/hash).</p>
-<h3>Parameters</h3>
-<a name="txs"></a>
-<code>txs</code> - The hashes (from <a href="../../core/-state-ref/txhash.html">StateRef.txhash</a> returned from <a href="query-states.html">queryStates</a>) you would like full transactions for.<br/>
-<p><strong>Return</strong><br/>
-null values indicate missing transactions from the requested list.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/generate-transaction-signature.html

@@ -1,17 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.generateTransactionSignature - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">generateTransactionSignature</a><br/>
-<br/>
-<h1>generateTransactionSignature</h1>
-<a name="node.internal.APIServerImpl$generateTransactionSignature(core.serialization.SerializedBytes((core.contracts.WireTransaction)))"></a>
-<code><span class="keyword">fun </span><span class="identifier">generateTransactionSignature</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$generateTransactionSignature(core.serialization.SerializedBytes((core.contracts.WireTransaction)))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.crypto/-digital-signature/-with-key/index.html"><span class="identifier">WithKey</span></a></code><br/>
-Overrides <a href="../-a-p-i-server/generate-transaction-signature.html">APIServer.generateTransactionSignature</a><br/>
-<p>Generate a signature for this transaction signed by us.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/index.html

@@ -1,115 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">APIServerImpl</a><br/>
-<br/>
-<h1>APIServerImpl</h1>
-<code><span class="keyword">class </span><span class="identifier">APIServerImpl</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-a-p-i-server/index.html"><span class="identifier">APIServer</span></a></code><br/>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">APIServerImpl</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$<init>(node.internal.AbstractNode)/node">node</span><span class="symbol">:</span>&nbsp;<a href="../../core.node/-abstract-node/index.html"><span class="identifier">AbstractNode</span></a><span class="symbol">)</span></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Properties</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="node.html">node</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">node</span><span class="symbol">: </span><a href="../../core.node/-abstract-node/index.html"><span class="identifier">AbstractNode</span></a></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Functions</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="build-transaction.html">buildTransaction</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">buildTransaction</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$buildTransaction(node.api.ContractDefRef, kotlin.collections.List((node.api.TransactionBuildStep)))/type">type</span><span class="symbol">:</span>&nbsp;<a href="../-contract-def-ref.html"><span class="identifier">ContractDefRef</span></a><span class="symbol">, </span><span class="identifier" id="node.internal.APIServerImpl$buildTransaction(node.api.ContractDefRef, kotlin.collections.List((node.api.TransactionBuildStep)))/steps">steps</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../-transaction-build-step/index.html"><span class="identifier">TransactionBuildStep</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span></code><p>TransactionBuildSteps would be invocations of contract.generateXXX() methods that all share a common TransactionBuilder
-and a common contract type (e.g. Cash or CommercialPaper)
-which would automatically be passed as the first argument (wed need that to be a criteria/pattern of the generateXXX methods).</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="commit-transaction.html">commitTransaction</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">commitTransaction</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$commitTransaction(core.serialization.SerializedBytes((core.contracts.WireTransaction)), kotlin.collections.List((core.crypto.DigitalSignature.WithKey)))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="node.internal.APIServerImpl$commitTransaction(core.serialization.SerializedBytes((core.contracts.WireTransaction)), kotlin.collections.List((core.crypto.DigitalSignature.WithKey)))/signatures">signatures</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core.crypto/-digital-signature/-with-key/index.html"><span class="identifier">WithKey</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code><p>Attempt to commit transaction (returned from build transaction) with the necessary signatures for that to be
-successful, otherwise exception is thrown.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="fetch-protocols-requiring-attention.html">fetchProtocolsRequiringAttention</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">fetchProtocolsRequiringAttention</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$fetchProtocolsRequiringAttention(node.api.StatesQuery)/query">query</span><span class="symbol">:</span>&nbsp;<a href="../-states-query/index.html"><span class="identifier">StatesQuery</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">,</span>&nbsp;<a href="../-protocol-requiring-attention/index.html"><span class="identifier">ProtocolRequiringAttention</span></a><span class="symbol">&gt;</span></code><p>Fetch protocols that require a response to some prompt/question by a human (on the "bank" side).</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="fetch-states.html">fetchStates</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">fetchStates</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$fetchStates(kotlin.collections.List((core.contracts.StateRef)))/states">states</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">,</span>&nbsp;<a href="../../core/-contract-state/index.html"><span class="identifier">ContractState</span></a><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="fetch-transactions.html">fetchTransactions</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">fetchTransactions</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$fetchTransactions(kotlin.collections.List((core.crypto.SecureHash)))/txs">txs</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">,</span>&nbsp;<a href="../../core/-signed-transaction/index.html"><span class="identifier">SignedTransaction</span></a><span class="symbol">?</span><span class="symbol">&gt;</span></code><p>Query for immutable transactions (results can be cached indefinitely by their id/hash).</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="generate-transaction-signature.html">generateTransactionSignature</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">generateTransactionSignature</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$generateTransactionSignature(core.serialization.SerializedBytes((core.contracts.WireTransaction)))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.crypto/-digital-signature/-with-key/index.html"><span class="identifier">WithKey</span></a></code><p>Generate a signature for this transaction signed by us.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="invoke-protocol-sync.html">invokeProtocolSync</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">invokeProtocolSync</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$invokeProtocolSync(node.api.ProtocolRef, kotlin.collections.Map((kotlin.String, kotlin.Any)))/type">type</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-ref.html"><span class="identifier">ProtocolRef</span></a><span class="symbol">, </span><span class="identifier" id="node.internal.APIServerImpl$invokeProtocolSync(node.api.ProtocolRef, kotlin.collections.Map((kotlin.String, kotlin.Any)))/args">args</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Any</span><span class="symbol">?</span></code><p>This method would not return until the protocol is finished (hence the "Sync").</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="provide-protocol-response.html">provideProtocolResponse</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">provideProtocolResponse</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/protocol">protocol</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-instance-ref/index.html"><span class="identifier">ProtocolInstanceRef</span></a><span class="symbol">, </span><span class="identifier" id="node.internal.APIServerImpl$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/choice">choice</span><span class="symbol">:</span>&nbsp;<a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">, </span><span class="identifier" id="node.internal.APIServerImpl$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/args">args</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><p>Provide the response that a protocol is waiting for.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="query-states.html">queryStates</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">queryStates</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$queryStates(node.api.StatesQuery)/query">query</span><span class="symbol">:</span>&nbsp;<a href="../-states-query/index.html"><span class="identifier">StatesQuery</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">&gt;</span></code><p>Query your "local" states (containing only outputs involving you) and return the hashes &amp; indexes associated with them
-to probably be later inflated by fetchLedgerTransactions() or fetchStates() although because immutable you can cache them
-to avoid calling fetchLedgerTransactions() many times.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="server-time.html">serverTime</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">serverTime</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/time/LocalDateTime.html"><span class="identifier">LocalDateTime</span></a></code><p>Report current UTC time as understood by the platform.</p>
-</td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/invoke-protocol-sync.html

@@ -1,22 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.invokeProtocolSync - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">invokeProtocolSync</a><br/>
-<br/>
-<h1>invokeProtocolSync</h1>
-<a name="node.internal.APIServerImpl$invokeProtocolSync(node.api.ProtocolRef, kotlin.collections.Map((kotlin.String, kotlin.Any)))"></a>
-<code><span class="keyword">fun </span><span class="identifier">invokeProtocolSync</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$invokeProtocolSync(node.api.ProtocolRef, kotlin.collections.Map((kotlin.String, kotlin.Any)))/type">type</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-ref.html"><span class="identifier">ProtocolRef</span></a><span class="symbol">, </span><span class="identifier" id="node.internal.APIServerImpl$invokeProtocolSync(node.api.ProtocolRef, kotlin.collections.Map((kotlin.String, kotlin.Any)))/args">args</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Any</span><span class="symbol">?</span></code><br/>
-Overrides <a href="../-a-p-i-server/invoke-protocol-sync.html">APIServer.invokeProtocolSync</a><br/>
-<p>This method would not return until the protocol is finished (hence the "Sync").</p>
-<p>Longer term wed add an Async version that returns some kind of ProtocolInvocationRef that could be queried and
-would appear on some kind of event message that is broadcast informing of progress.</p>
-<p>Will throw exception if protocol fails.</p>
-<br/>
-<br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/node.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.node - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">node</a><br/>
-<br/>
-<h1>node</h1>
-<a name="node.internal.APIServerImpl$node"></a>
-<code><span class="keyword">val </span><span class="identifier">node</span><span class="symbol">: </span><a href="../../core.node/-abstract-node/index.html"><span class="identifier">AbstractNode</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/provide-protocol-response.html

@@ -1,29 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.provideProtocolResponse - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">provideProtocolResponse</a><br/>
-<br/>
-<h1>provideProtocolResponse</h1>
-<a name="node.internal.APIServerImpl$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))"></a>
-<code><span class="keyword">fun </span><span class="identifier">provideProtocolResponse</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/protocol">protocol</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-instance-ref/index.html"><span class="identifier">ProtocolInstanceRef</span></a><span class="symbol">, </span><span class="identifier" id="node.internal.APIServerImpl$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/choice">choice</span><span class="symbol">:</span>&nbsp;<a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">, </span><span class="identifier" id="node.internal.APIServerImpl$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/args">args</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
-Overrides <a href="../-a-p-i-server/provide-protocol-response.html">APIServer.provideProtocolResponse</a><br/>
-<p>Provide the response that a protocol is waiting for.</p>
-<h3>Parameters</h3>
-<a name="protocol"></a>
-<code>protocol</code> - Should refer to a previously supplied ProtocolRequiringAttention.<br/>
-<br/>
-<a name="stepId"></a>
-<code>stepId</code> - Which step of the protocol are we referring too.<br/>
-<br/>
-<a name="choice"></a>
-<code>choice</code> - Should be one of the choices presented in the ProtocolRequiringAttention.<br/>
-<br/>
-<a name="args"></a>
-<code>args</code> - Any arguments required.<br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/query-states.html

@@ -1,24 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.queryStates - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">queryStates</a><br/>
-<br/>
-<h1>queryStates</h1>
-<a name="node.internal.APIServerImpl$queryStates(node.api.StatesQuery)"></a>
-<code><span class="keyword">fun </span><span class="identifier">queryStates</span><span class="symbol">(</span><span class="identifier" id="node.internal.APIServerImpl$queryStates(node.api.StatesQuery)/query">query</span><span class="symbol">:</span>&nbsp;<a href="../-states-query/index.html"><span class="identifier">StatesQuery</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">&gt;</span></code><br/>
-Overrides <a href="../-a-p-i-server/query-states.html">APIServer.queryStates</a><br/>
-<p>Query your "local" states (containing only outputs involving you) and return the hashes &amp; indexes associated with them
-to probably be later inflated by fetchLedgerTransactions() or fetchStates() although because immutable you can cache them
-to avoid calling fetchLedgerTransactions() many times.</p>
-<h3>Parameters</h3>
-<a name="query"></a>
-<code>query</code> - Some "where clause" like expression.<br/>
-<p><strong>Return</strong><br/>
-Zero or more matching States.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server-impl/server-time.html

@@ -1,17 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServerImpl.serverTime - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServerImpl</a>&nbsp;/&nbsp;<a href=".">serverTime</a><br/>
-<br/>
-<h1>serverTime</h1>
-<a name="node.internal.APIServerImpl$serverTime()"></a>
-<code><span class="keyword">fun </span><span class="identifier">serverTime</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/time/LocalDateTime.html"><span class="identifier">LocalDateTime</span></a></code><br/>
-Overrides <a href="../-a-p-i-server/server-time.html">APIServer.serverTime</a><br/>
-<p>Report current UTC time as understood by the platform.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server/build-transaction.html

@@ -1,18 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServer.buildTransaction - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServer</a>&nbsp;/&nbsp;<a href=".">buildTransaction</a><br/>
-<br/>
-<h1>buildTransaction</h1>
-<a name="node.api.APIServer$buildTransaction(node.api.ContractDefRef, kotlin.collections.List((node.api.TransactionBuildStep)))"></a>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">buildTransaction</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$buildTransaction(node.api.ContractDefRef, kotlin.collections.List((node.api.TransactionBuildStep)))/type">type</span><span class="symbol">:</span>&nbsp;<a href="../-contract-def-ref.html"><span class="identifier">ContractDefRef</span></a><span class="symbol">, </span><span class="identifier" id="node.api.APIServer$buildTransaction(node.api.ContractDefRef, kotlin.collections.List((node.api.TransactionBuildStep)))/steps">steps</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../-transaction-build-step/index.html"><span class="identifier">TransactionBuildStep</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span></code><br/>
-<p>TransactionBuildSteps would be invocations of contract.generateXXX() methods that all share a common TransactionBuilder
-and a common contract type (e.g. Cash or CommercialPaper)
-which would automatically be passed as the first argument (wed need that to be a criteria/pattern of the generateXXX methods).</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server/commit-transaction.html

@@ -1,17 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServer.commitTransaction - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServer</a>&nbsp;/&nbsp;<a href=".">commitTransaction</a><br/>
-<br/>
-<h1>commitTransaction</h1>
-<a name="node.api.APIServer$commitTransaction(core.serialization.SerializedBytes((core.contracts.WireTransaction)), kotlin.collections.List((core.crypto.DigitalSignature.WithKey)))"></a>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">commitTransaction</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$commitTransaction(core.serialization.SerializedBytes((core.contracts.WireTransaction)), kotlin.collections.List((core.crypto.DigitalSignature.WithKey)))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="node.api.APIServer$commitTransaction(core.serialization.SerializedBytes((core.contracts.WireTransaction)), kotlin.collections.List((core.crypto.DigitalSignature.WithKey)))/signatures">signatures</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core.crypto/-digital-signature/-with-key/index.html"><span class="identifier">WithKey</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code><br/>
-<p>Attempt to commit transaction (returned from build transaction) with the necessary signatures for that to be
-successful, otherwise exception is thrown.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server/fetch-protocols-requiring-attention.html

@@ -1,16 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServer.fetchProtocolsRequiringAttention - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServer</a>&nbsp;/&nbsp;<a href=".">fetchProtocolsRequiringAttention</a><br/>
-<br/>
-<h1>fetchProtocolsRequiringAttention</h1>
-<a name="node.api.APIServer$fetchProtocolsRequiringAttention(node.api.StatesQuery)"></a>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">fetchProtocolsRequiringAttention</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$fetchProtocolsRequiringAttention(node.api.StatesQuery)/query">query</span><span class="symbol">:</span>&nbsp;<a href="../-states-query/index.html"><span class="identifier">StatesQuery</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">,</span>&nbsp;<a href="../-protocol-requiring-attention/index.html"><span class="identifier">ProtocolRequiringAttention</span></a><span class="symbol">&gt;</span></code><br/>
-<p>Fetch protocols that require a response to some prompt/question by a human (on the "bank" side).</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server/fetch-states.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServer.fetchStates - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServer</a>&nbsp;/&nbsp;<a href=".">fetchStates</a><br/>
-<br/>
-<h1>fetchStates</h1>
-<a name="node.api.APIServer$fetchStates(kotlin.collections.List((core.contracts.StateRef)))"></a>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">fetchStates</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$fetchStates(kotlin.collections.List((core.contracts.StateRef)))/states">states</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">,</span>&nbsp;<a href="../../core/-contract-state/index.html"><span class="identifier">ContractState</span></a><span class="symbol">?</span><span class="symbol">&gt;</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server/fetch-transactions.html

@@ -1,21 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServer.fetchTransactions - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServer</a>&nbsp;/&nbsp;<a href=".">fetchTransactions</a><br/>
-<br/>
-<h1>fetchTransactions</h1>
-<a name="node.api.APIServer$fetchTransactions(kotlin.collections.List((core.crypto.SecureHash)))"></a>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">fetchTransactions</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$fetchTransactions(kotlin.collections.List((core.crypto.SecureHash)))/txs">txs</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">,</span>&nbsp;<a href="../../core/-signed-transaction/index.html"><span class="identifier">SignedTransaction</span></a><span class="symbol">?</span><span class="symbol">&gt;</span></code><br/>
-<p>Query for immutable transactions (results can be cached indefinitely by their id/hash).</p>
-<h3>Parameters</h3>
-<a name="txs"></a>
-<code>txs</code> - The hashes (from <a href="../../core/-state-ref/txhash.html">StateRef.txhash</a> returned from <a href="query-states.html">queryStates</a>) you would like full transactions for.<br/>
-<p><strong>Return</strong><br/>
-null values indicate missing transactions from the requested list.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server/generate-transaction-signature.html

@@ -1,16 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServer.generateTransactionSignature - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServer</a>&nbsp;/&nbsp;<a href=".">generateTransactionSignature</a><br/>
-<br/>
-<h1>generateTransactionSignature</h1>
-<a name="node.api.APIServer$generateTransactionSignature(core.serialization.SerializedBytes((core.contracts.WireTransaction)))"></a>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">generateTransactionSignature</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$generateTransactionSignature(core.serialization.SerializedBytes((core.contracts.WireTransaction)))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.crypto/-digital-signature/-with-key/index.html"><span class="identifier">WithKey</span></a></code><br/>
-<p>Generate a signature for this transaction signed by us.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server/index.html

@@ -1,109 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServer - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">APIServer</a><br/>
-<br/>
-<h1>APIServer</h1>
-<code><span class="keyword">interface </span><span class="identifier">APIServer</span></code><br/>
-<p>Top level interface to external interaction with the distributed ledger.</p>
-<p>Wherever a list is returned by a fetchXXX method that corresponds with an input list, that output list will have optional elements
-where a null indicates "missing" and the elements returned will be in the order corresponding with the input list.</p>
-<br/>
-<br/>
-<br/>
-<br/>
-<h3>Functions</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="build-transaction.html">buildTransaction</a></td>
-<td>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">buildTransaction</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$buildTransaction(node.api.ContractDefRef, kotlin.collections.List((node.api.TransactionBuildStep)))/type">type</span><span class="symbol">:</span>&nbsp;<a href="../-contract-def-ref.html"><span class="identifier">ContractDefRef</span></a><span class="symbol">, </span><span class="identifier" id="node.api.APIServer$buildTransaction(node.api.ContractDefRef, kotlin.collections.List((node.api.TransactionBuildStep)))/steps">steps</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../-transaction-build-step/index.html"><span class="identifier">TransactionBuildStep</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span></code><p>TransactionBuildSteps would be invocations of contract.generateXXX() methods that all share a common TransactionBuilder
-and a common contract type (e.g. Cash or CommercialPaper)
-which would automatically be passed as the first argument (wed need that to be a criteria/pattern of the generateXXX methods).</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="commit-transaction.html">commitTransaction</a></td>
-<td>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">commitTransaction</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$commitTransaction(core.serialization.SerializedBytes((core.contracts.WireTransaction)), kotlin.collections.List((core.crypto.DigitalSignature.WithKey)))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="node.api.APIServer$commitTransaction(core.serialization.SerializedBytes((core.contracts.WireTransaction)), kotlin.collections.List((core.crypto.DigitalSignature.WithKey)))/signatures">signatures</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core.crypto/-digital-signature/-with-key/index.html"><span class="identifier">WithKey</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code><p>Attempt to commit transaction (returned from build transaction) with the necessary signatures for that to be
-successful, otherwise exception is thrown.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="fetch-protocols-requiring-attention.html">fetchProtocolsRequiringAttention</a></td>
-<td>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">fetchProtocolsRequiringAttention</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$fetchProtocolsRequiringAttention(node.api.StatesQuery)/query">query</span><span class="symbol">:</span>&nbsp;<a href="../-states-query/index.html"><span class="identifier">StatesQuery</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">,</span>&nbsp;<a href="../-protocol-requiring-attention/index.html"><span class="identifier">ProtocolRequiringAttention</span></a><span class="symbol">&gt;</span></code><p>Fetch protocols that require a response to some prompt/question by a human (on the "bank" side).</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="fetch-states.html">fetchStates</a></td>
-<td>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">fetchStates</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$fetchStates(kotlin.collections.List((core.contracts.StateRef)))/states">states</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">,</span>&nbsp;<a href="../../core/-contract-state/index.html"><span class="identifier">ContractState</span></a><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="fetch-transactions.html">fetchTransactions</a></td>
-<td>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">fetchTransactions</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$fetchTransactions(kotlin.collections.List((core.crypto.SecureHash)))/txs">txs</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">,</span>&nbsp;<a href="../../core/-signed-transaction/index.html"><span class="identifier">SignedTransaction</span></a><span class="symbol">?</span><span class="symbol">&gt;</span></code><p>Query for immutable transactions (results can be cached indefinitely by their id/hash).</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="generate-transaction-signature.html">generateTransactionSignature</a></td>
-<td>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">generateTransactionSignature</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$generateTransactionSignature(core.serialization.SerializedBytes((core.contracts.WireTransaction)))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../core.serialization/-serialized-bytes/index.html"><span class="identifier">SerializedBytes</span></a><span class="symbol">&lt;</span><a href="../../core/-wire-transaction/index.html"><span class="identifier">WireTransaction</span></a><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../core.crypto/-digital-signature/-with-key/index.html"><span class="identifier">WithKey</span></a></code><p>Generate a signature for this transaction signed by us.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="invoke-protocol-sync.html">invokeProtocolSync</a></td>
-<td>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">invokeProtocolSync</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$invokeProtocolSync(node.api.ProtocolRef, kotlin.collections.Map((kotlin.String, kotlin.Any)))/type">type</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-ref.html"><span class="identifier">ProtocolRef</span></a><span class="symbol">, </span><span class="identifier" id="node.api.APIServer$invokeProtocolSync(node.api.ProtocolRef, kotlin.collections.Map((kotlin.String, kotlin.Any)))/args">args</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Any</span><span class="symbol">?</span></code><p>This method would not return until the protocol is finished (hence the "Sync").</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="provide-protocol-response.html">provideProtocolResponse</a></td>
-<td>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">provideProtocolResponse</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/protocol">protocol</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-instance-ref/index.html"><span class="identifier">ProtocolInstanceRef</span></a><span class="symbol">, </span><span class="identifier" id="node.api.APIServer$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/choice">choice</span><span class="symbol">:</span>&nbsp;<a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">, </span><span class="identifier" id="node.api.APIServer$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/args">args</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><p>Provide the response that a protocol is waiting for.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="query-states.html">queryStates</a></td>
-<td>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">queryStates</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$queryStates(node.api.StatesQuery)/query">query</span><span class="symbol">:</span>&nbsp;<a href="../-states-query/index.html"><span class="identifier">StatesQuery</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">&gt;</span></code><p>Query your "local" states (containing only outputs involving you) and return the hashes &amp; indexes associated with them
-to probably be later inflated by fetchLedgerTransactions() or fetchStates() although because immutable you can cache them
-to avoid calling fetchLedgerTransactions() many times.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="server-time.html">serverTime</a></td>
-<td>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">serverTime</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/time/LocalDateTime.html"><span class="identifier">LocalDateTime</span></a></code><p>Report current UTC time as understood by the platform.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<h3>Inheritors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="../-a-p-i-server-impl/index.html">APIServerImpl</a></td>
-<td>
-<code><span class="keyword">class </span><span class="identifier">APIServerImpl</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">APIServer</span></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server/invoke-protocol-sync.html

@@ -1,21 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServer.invokeProtocolSync - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServer</a>&nbsp;/&nbsp;<a href=".">invokeProtocolSync</a><br/>
-<br/>
-<h1>invokeProtocolSync</h1>
-<a name="node.api.APIServer$invokeProtocolSync(node.api.ProtocolRef, kotlin.collections.Map((kotlin.String, kotlin.Any)))"></a>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">invokeProtocolSync</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$invokeProtocolSync(node.api.ProtocolRef, kotlin.collections.Map((kotlin.String, kotlin.Any)))/type">type</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-ref.html"><span class="identifier">ProtocolRef</span></a><span class="symbol">, </span><span class="identifier" id="node.api.APIServer$invokeProtocolSync(node.api.ProtocolRef, kotlin.collections.Map((kotlin.String, kotlin.Any)))/args">args</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Any</span><span class="symbol">?</span></code><br/>
-<p>This method would not return until the protocol is finished (hence the "Sync").</p>
-<p>Longer term wed add an Async version that returns some kind of ProtocolInvocationRef that could be queried and
-would appear on some kind of event message that is broadcast informing of progress.</p>
-<p>Will throw exception if protocol fails.</p>
-<br/>
-<br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server/provide-protocol-response.html

@@ -1,28 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServer.provideProtocolResponse - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServer</a>&nbsp;/&nbsp;<a href=".">provideProtocolResponse</a><br/>
-<br/>
-<h1>provideProtocolResponse</h1>
-<a name="node.api.APIServer$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))"></a>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">provideProtocolResponse</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/protocol">protocol</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-instance-ref/index.html"><span class="identifier">ProtocolInstanceRef</span></a><span class="symbol">, </span><span class="identifier" id="node.api.APIServer$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/choice">choice</span><span class="symbol">:</span>&nbsp;<a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">, </span><span class="identifier" id="node.api.APIServer$provideProtocolResponse(node.api.ProtocolInstanceRef, core.crypto.SecureHash, kotlin.collections.Map((kotlin.String, kotlin.Any)))/args">args</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
-<p>Provide the response that a protocol is waiting for.</p>
-<h3>Parameters</h3>
-<a name="protocol"></a>
-<code>protocol</code> - Should refer to a previously supplied ProtocolRequiringAttention.<br/>
-<br/>
-<a name="stepId"></a>
-<code>stepId</code> - Which step of the protocol are we referring too.<br/>
-<br/>
-<a name="choice"></a>
-<code>choice</code> - Should be one of the choices presented in the ProtocolRequiringAttention.<br/>
-<br/>
-<a name="args"></a>
-<code>args</code> - Any arguments required.<br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server/query-states.html

@@ -1,23 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServer.queryStates - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServer</a>&nbsp;/&nbsp;<a href=".">queryStates</a><br/>
-<br/>
-<h1>queryStates</h1>
-<a name="node.api.APIServer$queryStates(node.api.StatesQuery)"></a>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">queryStates</span><span class="symbol">(</span><span class="identifier" id="node.api.APIServer$queryStates(node.api.StatesQuery)/query">query</span><span class="symbol">:</span>&nbsp;<a href="../-states-query/index.html"><span class="identifier">StatesQuery</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../core/-state-ref/index.html"><span class="identifier">StateRef</span></a><span class="symbol">&gt;</span></code><br/>
-<p>Query your "local" states (containing only outputs involving you) and return the hashes &amp; indexes associated with them
-to probably be later inflated by fetchLedgerTransactions() or fetchStates() although because immutable you can cache them
-to avoid calling fetchLedgerTransactions() many times.</p>
-<h3>Parameters</h3>
-<a name="query"></a>
-<code>query</code> - Some "where clause" like expression.<br/>
-<p><strong>Return</strong><br/>
-Zero or more matching States.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-a-p-i-server/server-time.html

@@ -1,16 +0,0 @@
-<HTML>
-<HEAD>
-<title>APIServer.serverTime - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">APIServer</a>&nbsp;/&nbsp;<a href=".">serverTime</a><br/>
-<br/>
-<h1>serverTime</h1>
-<a name="node.api.APIServer$serverTime()"></a>
-<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">serverTime</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/time/LocalDateTime.html"><span class="identifier">LocalDateTime</span></a></code><br/>
-<p>Report current UTC time as understood by the platform.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-config/-init-.html

@@ -1,16 +0,0 @@
-<HTML>
-<HEAD>
-<title>Config.<init> - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">Config</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">Config</span><span class="symbol">(</span><span class="identifier" id="node.servlets.Config$<init>(core.node.ServiceHub)/services">services</span><span class="symbol">:</span>&nbsp;<a href="../../core.node/-service-hub/index.html"><span class="identifier">ServiceHub</span></a><span class="symbol">)</span></code><br/>
-<p>Primary purpose is to install Kotlin extensions for Jackson ObjectMapper so data classes work
-and to organise serializers / deserializers for java.time.* classes as necessary</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-config/default-object-mapper.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>Config.defaultObjectMapper - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">Config</a>&nbsp;/&nbsp;<a href=".">defaultObjectMapper</a><br/>
-<br/>
-<h1>defaultObjectMapper</h1>
-<a name="node.servlets.Config$defaultObjectMapper"></a>
-<code><span class="keyword">val </span><span class="identifier">defaultObjectMapper</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-config/get-context.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>Config.getContext - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">Config</a>&nbsp;/&nbsp;<a href=".">getContext</a><br/>
-<br/>
-<h1>getContext</h1>
-<a name="node.servlets.Config$getContext(java.lang.Class((kotlin.Any)))"></a>
-<code><span class="keyword">fun </span><span class="identifier">getContext</span><span class="symbol">(</span><span class="identifier" id="node.servlets.Config$getContext(java.lang.Class((kotlin.Any)))/type">type</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Class.html"><span class="identifier">Class</span></a><span class="symbol">&lt;</span><span class="identifier">*</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-config/index.html

@@ -1,57 +0,0 @@
-<HTML>
-<HEAD>
-<title>Config - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">Config</a><br/>
-<br/>
-<h1>Config</h1>
-<code><span class="keyword">class </span><span class="identifier">Config</span></code><br/>
-<p>Primary purpose is to install Kotlin extensions for Jackson ObjectMapper so data classes work
-and to organise serializers / deserializers for java.time.* classes as necessary</p>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">Config</span><span class="symbol">(</span><span class="identifier" id="node.servlets.Config$<init>(core.node.ServiceHub)/services">services</span><span class="symbol">:</span>&nbsp;<a href="../../core.node/-service-hub/index.html"><span class="identifier">ServiceHub</span></a><span class="symbol">)</span></code><p>Primary purpose is to install Kotlin extensions for Jackson ObjectMapper so data classes work
-and to organise serializers / deserializers for java.time.* classes as necessary</p>
-</td>
-</tr>
-</tbody>
-</table>
-<h3>Properties</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="default-object-mapper.html">defaultObjectMapper</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">defaultObjectMapper</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="services.html">services</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">services</span><span class="symbol">: </span><a href="../../core.node/-service-hub/index.html"><span class="identifier">ServiceHub</span></a></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Functions</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="get-context.html">getContext</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">getContext</span><span class="symbol">(</span><span class="identifier" id="node.servlets.Config$getContext(java.lang.Class((kotlin.Any)))/type">type</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Class.html"><span class="identifier">Class</span></a><span class="symbol">&lt;</span><span class="identifier">*</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-config/services.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>Config.services - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">Config</a>&nbsp;/&nbsp;<a href=".">services</a><br/>
-<br/>
-<h1>services</h1>
-<a name="node.servlets.Config$services"></a>
-<code><span class="keyword">val </span><span class="identifier">services</span><span class="symbol">: </span><a href="../../core.node/-service-hub/index.html"><span class="identifier">ServiceHub</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-contract-class-ref/-init-.html

@@ -1,14 +0,0 @@
-<HTML>
-<HEAD>
-<title>ContractClassRef.<init> - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ContractClassRef</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">ContractClassRef</span><span class="symbol">(</span><span class="identifier" id="node.api.ContractClassRef$<init>(kotlin.String)/className">className</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-contract-class-ref/class-name.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ContractClassRef.className - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ContractClassRef</a>&nbsp;/&nbsp;<a href=".">className</a><br/>
-<br/>
-<h1>className</h1>
-<a name="node.api.ContractClassRef$className"></a>
-<code><span class="keyword">val </span><span class="identifier">className</span><span class="symbol">: </span><span class="identifier">String</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-contract-class-ref/index.html

@@ -1,36 +0,0 @@
-<HTML>
-<HEAD>
-<title>ContractClassRef - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">ContractClassRef</a><br/>
-<br/>
-<h1>ContractClassRef</h1>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">ContractClassRef</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-contract-def-ref.html"><span class="identifier">ContractDefRef</span></a></code><br/>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">ContractClassRef</span><span class="symbol">(</span><span class="identifier" id="node.api.ContractClassRef$<init>(kotlin.String)/className">className</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Properties</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="class-name.html">className</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">className</span><span class="symbol">: </span><span class="identifier">String</span></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-contract-ledger-ref/-init-.html

@@ -1,14 +0,0 @@
-<HTML>
-<HEAD>
-<title>ContractLedgerRef.<init> - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ContractLedgerRef</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">ContractLedgerRef</span><span class="symbol">(</span><span class="identifier" id="node.api.ContractLedgerRef$<init>(core.crypto.SecureHash)/hash">hash</span><span class="symbol">:</span>&nbsp;<a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">)</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-contract-ledger-ref/hash.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ContractLedgerRef.hash - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ContractLedgerRef</a>&nbsp;/&nbsp;<a href=".">hash</a><br/>
-<br/>
-<h1>hash</h1>
-<a name="node.api.ContractLedgerRef$hash"></a>
-<code><span class="keyword">val </span><span class="identifier">hash</span><span class="symbol">: </span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-contract-ledger-ref/index.html

@@ -1,36 +0,0 @@
-<HTML>
-<HEAD>
-<title>ContractLedgerRef - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">ContractLedgerRef</a><br/>
-<br/>
-<h1>ContractLedgerRef</h1>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">ContractLedgerRef</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-contract-def-ref.html"><span class="identifier">ContractDefRef</span></a></code><br/>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">ContractLedgerRef</span><span class="symbol">(</span><span class="identifier" id="node.api.ContractLedgerRef$<init>(core.crypto.SecureHash)/hash">hash</span><span class="symbol">:</span>&nbsp;<a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">)</span></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Properties</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="hash.html">hash</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">hash</span><span class="symbol">: </span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-interest-rate-swap-a-p-i/-init-.html

@@ -1,28 +0,0 @@
-<HTML>
-<HEAD>
-<title>InterestRateSwapAPI.<init> - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">InterestRateSwapAPI</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">InterestRateSwapAPI</span><span class="symbol">(</span><span class="identifier" id="api.InterestRateSwapAPI$<init>(node.api.APIServer)/api">api</span><span class="symbol">:</span>&nbsp;<a href="../-a-p-i-server/index.html"><span class="identifier">APIServer</span></a><span class="symbol">)</span></code><br/>
-<p>This provides a simplified API, currently for demonstration use only.</p>
-<p>It provides several JSON REST calls as follows:</p>
-<p>GET /api/irs/deals - returns an array of all deals tracked by the wallet of this node.
-GET /api/irs/deals/{ref} - return the deal referenced by the externally provided refence that was previously uploaded.
-POST /api/irs/deals - Payload is a JSON formatted <a href="../../contracts/-interest-rate-swap/-state/index.html">InterestRateSwap.State</a> create a new deal (includes an externally provided reference for use above).</p>
-<p>TODO: where we currently refer to singular external deal reference, of course this could easily be multiple identifiers e.g. CUSIP, ISIN.</p>
-<p>GET /api/irs/demodate - return the current date as viewed by the system in YYYY-MM-DD format.
-PUT /api/irs/demodate - put date in format YYYY-MM-DD to advance the current date as viewed by the system and
-simulate any associated business processing (currently fixing).</p>
-<p>TODO: replace simulated date advancement with business event based implementation</p>
-<p>PUT /api/irs/restart - (empty payload) cause the node to restart for API user emergency use in case any servers become unresponsive,
-or if the demodate or population of deals should be reset (will only work while persistence is disabled).</p>
-<br/>
-<br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-interest-rate-swap-a-p-i/api.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>InterestRateSwapAPI.api - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">InterestRateSwapAPI</a>&nbsp;/&nbsp;<a href=".">api</a><br/>
-<br/>
-<h1>api</h1>
-<a name="api.InterestRateSwapAPI$api"></a>
-<code><span class="keyword">val </span><span class="identifier">api</span><span class="symbol">: </span><a href="../-a-p-i-server/index.html"><span class="identifier">APIServer</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-interest-rate-swap-a-p-i/exit-server.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>InterestRateSwapAPI.exitServer - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">InterestRateSwapAPI</a>&nbsp;/&nbsp;<a href=".">exitServer</a><br/>
-<br/>
-<h1>exitServer</h1>
-<a name="api.InterestRateSwapAPI$exitServer()"></a>
-<code><span class="keyword">fun </span><span class="identifier">exitServer</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-interest-rate-swap-a-p-i/fetch-deal.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>InterestRateSwapAPI.fetchDeal - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">InterestRateSwapAPI</a>&nbsp;/&nbsp;<a href=".">fetchDeal</a><br/>
-<br/>
-<h1>fetchDeal</h1>
-<a name="api.InterestRateSwapAPI$fetchDeal(kotlin.String)"></a>
-<code><span class="keyword">fun </span><span class="identifier">fetchDeal</span><span class="symbol">(</span><span class="identifier" id="api.InterestRateSwapAPI$fetchDeal(kotlin.String)/ref">ref</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-interest-rate-swap-a-p-i/fetch-deals.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>InterestRateSwapAPI.fetchDeals - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">InterestRateSwapAPI</a>&nbsp;/&nbsp;<a href=".">fetchDeals</a><br/>
-<br/>
-<h1>fetchDeals</h1>
-<a name="api.InterestRateSwapAPI$fetchDeals()"></a>
-<code><span class="keyword">fun </span><span class="identifier">fetchDeals</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Array</span><span class="symbol">&lt;</span><a href="../../contracts/-interest-rate-swap/-state/index.html"><span class="identifier">State</span></a><span class="symbol">&gt;</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-interest-rate-swap-a-p-i/fetch-demo-date.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>InterestRateSwapAPI.fetchDemoDate - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">InterestRateSwapAPI</a>&nbsp;/&nbsp;<a href=".">fetchDemoDate</a><br/>
-<br/>
-<h1>fetchDemoDate</h1>
-<a name="api.InterestRateSwapAPI$fetchDemoDate()"></a>
-<code><span class="keyword">fun </span><span class="identifier">fetchDemoDate</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/time/LocalDate.html"><span class="identifier">LocalDate</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-interest-rate-swap-a-p-i/index.html

@@ -1,92 +0,0 @@
-<HTML>
-<HEAD>
-<title>InterestRateSwapAPI - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">InterestRateSwapAPI</a><br/>
-<br/>
-<h1>InterestRateSwapAPI</h1>
-<code><span class="keyword">class </span><span class="identifier">InterestRateSwapAPI</span></code><br/>
-<p>This provides a simplified API, currently for demonstration use only.</p>
-<p>It provides several JSON REST calls as follows:</p>
-<p>GET /api/irs/deals - returns an array of all deals tracked by the wallet of this node.
-GET /api/irs/deals/{ref} - return the deal referenced by the externally provided refence that was previously uploaded.
-POST /api/irs/deals - Payload is a JSON formatted <a href="../../contracts/-interest-rate-swap/-state/index.html">InterestRateSwap.State</a> create a new deal (includes an externally provided reference for use above).</p>
-<p>TODO: where we currently refer to singular external deal reference, of course this could easily be multiple identifiers e.g. CUSIP, ISIN.</p>
-<p>GET /api/irs/demodate - return the current date as viewed by the system in YYYY-MM-DD format.
-PUT /api/irs/demodate - put date in format YYYY-MM-DD to advance the current date as viewed by the system and
-simulate any associated business processing (currently fixing).</p>
-<p>TODO: replace simulated date advancement with business event based implementation</p>
-<p>PUT /api/irs/restart - (empty payload) cause the node to restart for API user emergency use in case any servers become unresponsive,
-or if the demodate or population of deals should be reset (will only work while persistence is disabled).</p>
-<br/>
-<br/>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">InterestRateSwapAPI</span><span class="symbol">(</span><span class="identifier" id="api.InterestRateSwapAPI$<init>(node.api.APIServer)/api">api</span><span class="symbol">:</span>&nbsp;<a href="../-a-p-i-server/index.html"><span class="identifier">APIServer</span></a><span class="symbol">)</span></code><p>This provides a simplified API, currently for demonstration use only.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<h3>Properties</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="api.html">api</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">api</span><span class="symbol">: </span><a href="../-a-p-i-server/index.html"><span class="identifier">APIServer</span></a></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Functions</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="exit-server.html">exitServer</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">exitServer</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="fetch-deal.html">fetchDeal</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">fetchDeal</span><span class="symbol">(</span><span class="identifier" id="api.InterestRateSwapAPI$fetchDeal(kotlin.String)/ref">ref</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="fetch-deals.html">fetchDeals</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">fetchDeals</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Array</span><span class="symbol">&lt;</span><a href="../../contracts/-interest-rate-swap/-state/index.html"><span class="identifier">State</span></a><span class="symbol">&gt;</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="fetch-demo-date.html">fetchDemoDate</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">fetchDemoDate</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/time/LocalDate.html"><span class="identifier">LocalDate</span></a></code></td>
-</tr>
-<tr>
-<td>
-<a href="store-deal.html">storeDeal</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">storeDeal</span><span class="symbol">(</span><span class="identifier" id="api.InterestRateSwapAPI$storeDeal(contracts.InterestRateSwap.State)/newDeal">newDeal</span><span class="symbol">:</span>&nbsp;<a href="../../contracts/-interest-rate-swap/-state/index.html"><span class="identifier">State</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="store-demo-date.html">storeDemoDate</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">storeDemoDate</span><span class="symbol">(</span><span class="identifier" id="api.InterestRateSwapAPI$storeDemoDate(java.time.LocalDate)/newDemoDate">newDemoDate</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/time/LocalDate.html"><span class="identifier">LocalDate</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-interest-rate-swap-a-p-i/store-deal.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>InterestRateSwapAPI.storeDeal - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">InterestRateSwapAPI</a>&nbsp;/&nbsp;<a href=".">storeDeal</a><br/>
-<br/>
-<h1>storeDeal</h1>
-<a name="api.InterestRateSwapAPI$storeDeal(contracts.InterestRateSwap.State)"></a>
-<code><span class="keyword">fun </span><span class="identifier">storeDeal</span><span class="symbol">(</span><span class="identifier" id="api.InterestRateSwapAPI$storeDeal(contracts.InterestRateSwap.State)/newDeal">newDeal</span><span class="symbol">:</span>&nbsp;<a href="../../contracts/-interest-rate-swap/-state/index.html"><span class="identifier">State</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-interest-rate-swap-a-p-i/store-demo-date.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>InterestRateSwapAPI.storeDemoDate - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">InterestRateSwapAPI</a>&nbsp;/&nbsp;<a href=".">storeDemoDate</a><br/>
-<br/>
-<h1>storeDemoDate</h1>
-<a name="api.InterestRateSwapAPI$storeDemoDate(java.time.LocalDate)"></a>
-<code><span class="keyword">fun </span><span class="identifier">storeDemoDate</span><span class="symbol">(</span><span class="identifier" id="api.InterestRateSwapAPI$storeDemoDate(java.time.LocalDate)/newDemoDate">newDemoDate</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/time/LocalDate.html"><span class="identifier">LocalDate</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-class-ref/-init-.html

@@ -1,14 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolClassRef.<init> - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ProtocolClassRef</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">ProtocolClassRef</span><span class="symbol">(</span><span class="identifier" id="node.api.ProtocolClassRef$<init>(kotlin.String)/className">className</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-class-ref/class-name.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolClassRef.className - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ProtocolClassRef</a>&nbsp;/&nbsp;<a href=".">className</a><br/>
-<br/>
-<h1>className</h1>
-<a name="node.api.ProtocolClassRef$className"></a>
-<code><span class="keyword">val </span><span class="identifier">className</span><span class="symbol">: </span><span class="identifier">String</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-class-ref/index.html

@@ -1,36 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolClassRef - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">ProtocolClassRef</a><br/>
-<br/>
-<h1>ProtocolClassRef</h1>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">ProtocolClassRef</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-protocol-ref.html"><span class="identifier">ProtocolRef</span></a></code><br/>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">ProtocolClassRef</span><span class="symbol">(</span><span class="identifier" id="node.api.ProtocolClassRef$<init>(kotlin.String)/className">className</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Properties</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="class-name.html">className</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">className</span><span class="symbol">: </span><span class="identifier">String</span></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-instance-ref/-init-.html

@@ -1,14 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolInstanceRef.<init> - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ProtocolInstanceRef</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">ProtocolInstanceRef</span><span class="symbol">(</span><span class="identifier" id="node.api.ProtocolInstanceRef$<init>(core.crypto.SecureHash, node.api.ProtocolClassRef, kotlin.String)/protocolInstance">protocolInstance</span><span class="symbol">:</span>&nbsp;<a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">, </span><span class="identifier" id="node.api.ProtocolInstanceRef$<init>(core.crypto.SecureHash, node.api.ProtocolClassRef, kotlin.String)/protocolClass">protocolClass</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-class-ref/index.html"><span class="identifier">ProtocolClassRef</span></a><span class="symbol">, </span><span class="identifier" id="node.api.ProtocolInstanceRef$<init>(core.crypto.SecureHash, node.api.ProtocolClassRef, kotlin.String)/protocolStepId">protocolStepId</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-instance-ref/index.html

@@ -1,48 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolInstanceRef - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">ProtocolInstanceRef</a><br/>
-<br/>
-<h1>ProtocolInstanceRef</h1>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">ProtocolInstanceRef</span></code><br/>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">ProtocolInstanceRef</span><span class="symbol">(</span><span class="identifier" id="node.api.ProtocolInstanceRef$<init>(core.crypto.SecureHash, node.api.ProtocolClassRef, kotlin.String)/protocolInstance">protocolInstance</span><span class="symbol">:</span>&nbsp;<a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">, </span><span class="identifier" id="node.api.ProtocolInstanceRef$<init>(core.crypto.SecureHash, node.api.ProtocolClassRef, kotlin.String)/protocolClass">protocolClass</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-class-ref/index.html"><span class="identifier">ProtocolClassRef</span></a><span class="symbol">, </span><span class="identifier" id="node.api.ProtocolInstanceRef$<init>(core.crypto.SecureHash, node.api.ProtocolClassRef, kotlin.String)/protocolStepId">protocolStepId</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Properties</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="protocol-class.html">protocolClass</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">protocolClass</span><span class="symbol">: </span><a href="../-protocol-class-ref/index.html"><span class="identifier">ProtocolClassRef</span></a></code></td>
-</tr>
-<tr>
-<td>
-<a href="protocol-instance.html">protocolInstance</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">protocolInstance</span><span class="symbol">: </span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code></td>
-</tr>
-<tr>
-<td>
-<a href="protocol-step-id.html">protocolStepId</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">protocolStepId</span><span class="symbol">: </span><span class="identifier">String</span></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-instance-ref/protocol-class.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolInstanceRef.protocolClass - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ProtocolInstanceRef</a>&nbsp;/&nbsp;<a href=".">protocolClass</a><br/>
-<br/>
-<h1>protocolClass</h1>
-<a name="node.api.ProtocolInstanceRef$protocolClass"></a>
-<code><span class="keyword">val </span><span class="identifier">protocolClass</span><span class="symbol">: </span><a href="../-protocol-class-ref/index.html"><span class="identifier">ProtocolClassRef</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-instance-ref/protocol-instance.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolInstanceRef.protocolInstance - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ProtocolInstanceRef</a>&nbsp;/&nbsp;<a href=".">protocolInstance</a><br/>
-<br/>
-<h1>protocolInstance</h1>
-<a name="node.api.ProtocolInstanceRef$protocolInstance"></a>
-<code><span class="keyword">val </span><span class="identifier">protocolInstance</span><span class="symbol">: </span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-instance-ref/protocol-step-id.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolInstanceRef.protocolStepId - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ProtocolInstanceRef</a>&nbsp;/&nbsp;<a href=".">protocolStepId</a><br/>
-<br/>
-<h1>protocolStepId</h1>
-<a name="node.api.ProtocolInstanceRef$protocolStepId"></a>
-<code><span class="keyword">val </span><span class="identifier">protocolStepId</span><span class="symbol">: </span><span class="identifier">String</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-requiring-attention/-init-.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolRequiringAttention.<init> - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ProtocolRequiringAttention</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">ProtocolRequiringAttention</span><span class="symbol">(</span><span class="identifier" id="node.api.ProtocolRequiringAttention$<init>(node.api.ProtocolInstanceRef, kotlin.String, kotlin.collections.Map((core.crypto.SecureHash, kotlin.String)), java.time.Instant)/ref">ref</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-instance-ref/index.html"><span class="identifier">ProtocolInstanceRef</span></a><span class="symbol">, </span><span class="identifier" id="node.api.ProtocolRequiringAttention$<init>(node.api.ProtocolInstanceRef, kotlin.String, kotlin.collections.Map((core.crypto.SecureHash, kotlin.String)), java.time.Instant)/prompt">prompt</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">, </span><span class="identifier" id="node.api.ProtocolRequiringAttention$<init>(node.api.ProtocolInstanceRef, kotlin.String, kotlin.collections.Map((core.crypto.SecureHash, kotlin.String)), java.time.Instant)/choiceIdsToMessages">choiceIdsToMessages</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">,</span>&nbsp;<span class="identifier">String</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="node.api.ProtocolRequiringAttention$<init>(node.api.ProtocolInstanceRef, kotlin.String, kotlin.collections.Map((core.crypto.SecureHash, kotlin.String)), java.time.Instant)/dueBy">dueBy</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/time/Instant.html"><span class="identifier">Instant</span></a><span class="symbol">)</span></code><br/>
-<p>Thinking that Instant is OK for short lived protocol deadlines.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-requiring-attention/choice-ids-to-messages.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolRequiringAttention.choiceIdsToMessages - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ProtocolRequiringAttention</a>&nbsp;/&nbsp;<a href=".">choiceIdsToMessages</a><br/>
-<br/>
-<h1>choiceIdsToMessages</h1>
-<a name="node.api.ProtocolRequiringAttention$choiceIdsToMessages"></a>
-<code><span class="keyword">val </span><span class="identifier">choiceIdsToMessages</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">,</span>&nbsp;<span class="identifier">String</span><span class="symbol">&gt;</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-requiring-attention/due-by.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolRequiringAttention.dueBy - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ProtocolRequiringAttention</a>&nbsp;/&nbsp;<a href=".">dueBy</a><br/>
-<br/>
-<h1>dueBy</h1>
-<a name="node.api.ProtocolRequiringAttention$dueBy"></a>
-<code><span class="keyword">val </span><span class="identifier">dueBy</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/time/Instant.html"><span class="identifier">Instant</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-requiring-attention/index.html

@@ -1,56 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolRequiringAttention - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">ProtocolRequiringAttention</a><br/>
-<br/>
-<h1>ProtocolRequiringAttention</h1>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">ProtocolRequiringAttention</span></code><br/>
-<p>Thinking that Instant is OK for short lived protocol deadlines.</p>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">ProtocolRequiringAttention</span><span class="symbol">(</span><span class="identifier" id="node.api.ProtocolRequiringAttention$<init>(node.api.ProtocolInstanceRef, kotlin.String, kotlin.collections.Map((core.crypto.SecureHash, kotlin.String)), java.time.Instant)/ref">ref</span><span class="symbol">:</span>&nbsp;<a href="../-protocol-instance-ref/index.html"><span class="identifier">ProtocolInstanceRef</span></a><span class="symbol">, </span><span class="identifier" id="node.api.ProtocolRequiringAttention$<init>(node.api.ProtocolInstanceRef, kotlin.String, kotlin.collections.Map((core.crypto.SecureHash, kotlin.String)), java.time.Instant)/prompt">prompt</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">, </span><span class="identifier" id="node.api.ProtocolRequiringAttention$<init>(node.api.ProtocolInstanceRef, kotlin.String, kotlin.collections.Map((core.crypto.SecureHash, kotlin.String)), java.time.Instant)/choiceIdsToMessages">choiceIdsToMessages</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">,</span>&nbsp;<span class="identifier">String</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="node.api.ProtocolRequiringAttention$<init>(node.api.ProtocolInstanceRef, kotlin.String, kotlin.collections.Map((core.crypto.SecureHash, kotlin.String)), java.time.Instant)/dueBy">dueBy</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/time/Instant.html"><span class="identifier">Instant</span></a><span class="symbol">)</span></code><p>Thinking that Instant is OK for short lived protocol deadlines.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<h3>Properties</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="choice-ids-to-messages.html">choiceIdsToMessages</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">choiceIdsToMessages</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../../core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">,</span>&nbsp;<span class="identifier">String</span><span class="symbol">&gt;</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="due-by.html">dueBy</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">dueBy</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/time/Instant.html"><span class="identifier">Instant</span></a></code></td>
-</tr>
-<tr>
-<td>
-<a href="prompt.html">prompt</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">prompt</span><span class="symbol">: </span><span class="identifier">String</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="ref.html">ref</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">ref</span><span class="symbol">: </span><a href="../-protocol-instance-ref/index.html"><span class="identifier">ProtocolInstanceRef</span></a></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-requiring-attention/prompt.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolRequiringAttention.prompt - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ProtocolRequiringAttention</a>&nbsp;/&nbsp;<a href=".">prompt</a><br/>
-<br/>
-<h1>prompt</h1>
-<a name="node.api.ProtocolRequiringAttention$prompt"></a>
-<code><span class="keyword">val </span><span class="identifier">prompt</span><span class="symbol">: </span><span class="identifier">String</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-protocol-requiring-attention/ref.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ProtocolRequiringAttention.ref - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ProtocolRequiringAttention</a>&nbsp;/&nbsp;<a href=".">ref</a><br/>
-<br/>
-<h1>ref</h1>
-<a name="node.api.ProtocolRequiringAttention$ref"></a>
-<code><span class="keyword">val </span><span class="identifier">ref</span><span class="symbol">: </span><a href="../-protocol-instance-ref/index.html"><span class="identifier">ProtocolInstanceRef</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-response-filter/-init-.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ResponseFilter.<init> - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ResponseFilter</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">ResponseFilter</span><span class="symbol">(</span><span class="symbol">)</span></code><br/>
-<p>This adds headers needed for cross site scripting on API clients</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-response-filter/filter.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>ResponseFilter.filter - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">ResponseFilter</a>&nbsp;/&nbsp;<a href=".">filter</a><br/>
-<br/>
-<h1>filter</h1>
-<a name="node.servlets.ResponseFilter$filter(, )"></a>
-<code><span class="keyword">fun </span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="node.servlets.ResponseFilter$filter(, )/requestContext">requestContext</span><span class="symbol">:</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">, </span><span class="identifier" id="node.servlets.ResponseFilter$filter(, )/responseContext">responseContext</span><span class="symbol">:</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-response-filter/index.html

@@ -1,38 +0,0 @@
-<HTML>
-<HEAD>
-<title>ResponseFilter - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">ResponseFilter</a><br/>
-<br/>
-<h1>ResponseFilter</h1>
-<code><span class="keyword">class </span><span class="identifier">ResponseFilter</span></code><br/>
-<p>This adds headers needed for cross site scripting on API clients</p>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">ResponseFilter</span><span class="symbol">(</span><span class="symbol">)</span></code><p>This adds headers needed for cross site scripting on API clients</p>
-</td>
-</tr>
-</tbody>
-</table>
-<h3>Functions</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="filter.html">filter</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">filter</span><span class="symbol">(</span><span class="identifier" id="node.servlets.ResponseFilter$filter(, )/requestContext">requestContext</span><span class="symbol">:</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">, </span><span class="identifier" id="node.servlets.ResponseFilter$filter(, )/responseContext">responseContext</span><span class="symbol">:</span>&nbsp;<span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/-criteria/-all-deals.html

@@ -1,14 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery.Criteria.AllDeals - </title>
-<link rel="stylesheet" href="../../../style.css">
-</HEAD>
-<BODY>
-<a href="../../index.html">api</a>&nbsp;/&nbsp;<a href="../index.html">StatesQuery</a>&nbsp;/&nbsp;<a href="index.html">Criteria</a>&nbsp;/&nbsp;<a href=".">AllDeals</a><br/>
-<br/>
-<h1>AllDeals</h1>
-<code><span class="keyword">object </span><span class="identifier">AllDeals</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="index.html"><span class="identifier">Criteria</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/-criteria/-deal/-init-.html

@@ -1,14 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery.Criteria.Deal.<init> - </title>
-<link rel="stylesheet" href="../../../../style.css">
-</HEAD>
-<BODY>
-<a href="../../../index.html">api</a>&nbsp;/&nbsp;<a href="../../index.html">StatesQuery</a>&nbsp;/&nbsp;<a href="../index.html">Criteria</a>&nbsp;/&nbsp;<a href="index.html">Deal</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">Deal</span><span class="symbol">(</span><span class="identifier" id="node.api.StatesQuery.Criteria.Deal$<init>(kotlin.String)/ref">ref</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/-criteria/-deal/index.html

@@ -1,36 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery.Criteria.Deal - </title>
-<link rel="stylesheet" href="../../../../style.css">
-</HEAD>
-<BODY>
-<a href="../../../index.html">api</a>&nbsp;/&nbsp;<a href="../../index.html">StatesQuery</a>&nbsp;/&nbsp;<a href="../index.html">Criteria</a>&nbsp;/&nbsp;<a href=".">Deal</a><br/>
-<br/>
-<h1>Deal</h1>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Deal</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../index.html"><span class="identifier">Criteria</span></a></code><br/>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">Deal</span><span class="symbol">(</span><span class="identifier" id="node.api.StatesQuery.Criteria.Deal$<init>(kotlin.String)/ref">ref</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Properties</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="ref.html">ref</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">ref</span><span class="symbol">: </span><span class="identifier">String</span></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/-criteria/-deal/ref.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery.Criteria.Deal.ref - </title>
-<link rel="stylesheet" href="../../../../style.css">
-</HEAD>
-<BODY>
-<a href="../../../index.html">api</a>&nbsp;/&nbsp;<a href="../../index.html">StatesQuery</a>&nbsp;/&nbsp;<a href="../index.html">Criteria</a>&nbsp;/&nbsp;<a href="index.html">Deal</a>&nbsp;/&nbsp;<a href=".">ref</a><br/>
-<br/>
-<h1>ref</h1>
-<a name="node.api.StatesQuery.Criteria.Deal$ref"></a>
-<code><span class="keyword">val </span><span class="identifier">ref</span><span class="symbol">: </span><span class="identifier">String</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/-criteria/index.html

@@ -1,48 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery.Criteria - </title>
-<link rel="stylesheet" href="../../../style.css">
-</HEAD>
-<BODY>
-<a href="../../index.html">api</a>&nbsp;/&nbsp;<a href="../index.html">StatesQuery</a>&nbsp;/&nbsp;<a href=".">Criteria</a><br/>
-<br/>
-<h1>Criteria</h1>
-<code><span class="keyword">interface </span><span class="identifier">Criteria</span></code><br/>
-<br/>
-<br/>
-<h3>Types</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-all-deals.html">AllDeals</a></td>
-<td>
-<code><span class="keyword">object </span><span class="identifier">AllDeals</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Criteria</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="-deal/index.html">Deal</a></td>
-<td>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Deal</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Criteria</span></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Inheritors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-all-deals.html">AllDeals</a></td>
-<td>
-<code><span class="keyword">object </span><span class="identifier">AllDeals</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Criteria</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="-deal/index.html">Deal</a></td>
-<td>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Deal</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Criteria</span></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/-selection/-init-.html

@@ -1,14 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery.Selection.<init> - </title>
-<link rel="stylesheet" href="../../../style.css">
-</HEAD>
-<BODY>
-<a href="../../index.html">api</a>&nbsp;/&nbsp;<a href="../index.html">StatesQuery</a>&nbsp;/&nbsp;<a href="index.html">Selection</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">Selection</span><span class="symbol">(</span><span class="identifier" id="node.api.StatesQuery.Selection$<init>(node.api.StatesQuery.Criteria)/criteria">criteria</span><span class="symbol">:</span>&nbsp;<a href="../-criteria/index.html"><span class="identifier">Criteria</span></a><span class="symbol">)</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/-selection/criteria.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery.Selection.criteria - </title>
-<link rel="stylesheet" href="../../../style.css">
-</HEAD>
-<BODY>
-<a href="../../index.html">api</a>&nbsp;/&nbsp;<a href="../index.html">StatesQuery</a>&nbsp;/&nbsp;<a href="index.html">Selection</a>&nbsp;/&nbsp;<a href=".">criteria</a><br/>
-<br/>
-<h1>criteria</h1>
-<a name="node.api.StatesQuery.Selection$criteria"></a>
-<code><span class="keyword">val </span><span class="identifier">criteria</span><span class="symbol">: </span><a href="../-criteria/index.html"><span class="identifier">Criteria</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/-selection/index.html

@@ -1,36 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery.Selection - </title>
-<link rel="stylesheet" href="../../../style.css">
-</HEAD>
-<BODY>
-<a href="../../index.html">api</a>&nbsp;/&nbsp;<a href="../index.html">StatesQuery</a>&nbsp;/&nbsp;<a href=".">Selection</a><br/>
-<br/>
-<h1>Selection</h1>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Selection</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../index.html"><span class="identifier">StatesQuery</span></a></code><br/>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">Selection</span><span class="symbol">(</span><span class="identifier" id="node.api.StatesQuery.Selection$<init>(node.api.StatesQuery.Criteria)/criteria">criteria</span><span class="symbol">:</span>&nbsp;<a href="../-criteria/index.html"><span class="identifier">Criteria</span></a><span class="symbol">)</span></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Properties</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="criteria.html">criteria</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">criteria</span><span class="symbol">: </span><a href="../-criteria/index.html"><span class="identifier">Criteria</span></a></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/index.html

@@ -1,66 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">StatesQuery</a><br/>
-<br/>
-<h1>StatesQuery</h1>
-<code><span class="keyword">interface </span><span class="identifier">StatesQuery</span></code><br/>
-<p>Extremely rudimentary query language which should most likely be replaced with a product</p>
-<br/>
-<br/>
-<h3>Types</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-criteria/index.html">Criteria</a></td>
-<td>
-<code><span class="keyword">interface </span><span class="identifier">Criteria</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="-selection/index.html">Selection</a></td>
-<td>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Selection</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">StatesQuery</span></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Companion Object Functions</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="select.html">select</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">select</span><span class="symbol">(</span><span class="identifier" id="node.api.StatesQuery.Companion$select(node.api.StatesQuery.Criteria)/criteria">criteria</span><span class="symbol">:</span>&nbsp;<a href="-criteria/index.html"><span class="identifier">Criteria</span></a><span class="symbol">)</span><span class="symbol">: </span><a href="-selection/index.html"><span class="identifier">Selection</span></a></code></td>
-</tr>
-<tr>
-<td>
-<a href="select-all-deals.html">selectAllDeals</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">selectAllDeals</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><a href="-selection/index.html"><span class="identifier">Selection</span></a></code></td>
-</tr>
-<tr>
-<td>
-<a href="select-deal.html">selectDeal</a></td>
-<td>
-<code><span class="keyword">fun </span><span class="identifier">selectDeal</span><span class="symbol">(</span><span class="identifier" id="node.api.StatesQuery.Companion$selectDeal(kotlin.String)/ref">ref</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span><span class="symbol">: </span><a href="-selection/index.html"><span class="identifier">Selection</span></a></code></td>
-</tr>
-</tbody>
-</table>
-<h3>Inheritors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-selection/index.html">Selection</a></td>
-<td>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Selection</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">StatesQuery</span></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/select-all-deals.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery.selectAllDeals - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">StatesQuery</a>&nbsp;/&nbsp;<a href=".">selectAllDeals</a><br/>
-<br/>
-<h1>selectAllDeals</h1>
-<a name="node.api.StatesQuery.Companion$selectAllDeals()"></a>
-<code><span class="keyword">fun </span><span class="identifier">selectAllDeals</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><a href="-selection/index.html"><span class="identifier">Selection</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/select-deal.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery.selectDeal - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">StatesQuery</a>&nbsp;/&nbsp;<a href=".">selectDeal</a><br/>
-<br/>
-<h1>selectDeal</h1>
-<a name="node.api.StatesQuery.Companion$selectDeal(kotlin.String)"></a>
-<code><span class="keyword">fun </span><span class="identifier">selectDeal</span><span class="symbol">(</span><span class="identifier" id="node.api.StatesQuery.Companion$selectDeal(kotlin.String)/ref">ref</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span><span class="symbol">: </span><a href="-selection/index.html"><span class="identifier">Selection</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-states-query/select.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>StatesQuery.select - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">StatesQuery</a>&nbsp;/&nbsp;<a href=".">select</a><br/>
-<br/>
-<h1>select</h1>
-<a name="node.api.StatesQuery.Companion$select(node.api.StatesQuery.Criteria)"></a>
-<code><span class="keyword">fun </span><span class="identifier">select</span><span class="symbol">(</span><span class="identifier" id="node.api.StatesQuery.Companion$select(node.api.StatesQuery.Criteria)/criteria">criteria</span><span class="symbol">:</span>&nbsp;<a href="-criteria/index.html"><span class="identifier">Criteria</span></a><span class="symbol">)</span><span class="symbol">: </span><a href="-selection/index.html"><span class="identifier">Selection</span></a></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-transaction-build-step/-init-.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>TransactionBuildStep.<init> - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">TransactionBuildStep</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
-<br/>
-<h1>&lt;init&gt;</h1>
-<code><span class="identifier">TransactionBuildStep</span><span class="symbol">(</span><span class="identifier" id="node.api.TransactionBuildStep$<init>(kotlin.String, kotlin.collections.Map((kotlin.String, kotlin.Any)))/generateMethodName">generateMethodName</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">, </span><span class="identifier" id="node.api.TransactionBuildStep$<init>(kotlin.String, kotlin.collections.Map((kotlin.String, kotlin.Any)))/args">args</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><br/>
-<p>Encapsulate a generateXXX method call on a contract.</p>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-transaction-build-step/args.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>TransactionBuildStep.args - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">TransactionBuildStep</a>&nbsp;/&nbsp;<a href=".">args</a><br/>
-<br/>
-<h1>args</h1>
-<a name="node.api.TransactionBuildStep$args"></a>
-<code><span class="keyword">val </span><span class="identifier">args</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-transaction-build-step/generate-method-name.html

@@ -1,15 +0,0 @@
-<HTML>
-<HEAD>
-<title>TransactionBuildStep.generateMethodName - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href="index.html">TransactionBuildStep</a>&nbsp;/&nbsp;<a href=".">generateMethodName</a><br/>
-<br/>
-<h1>generateMethodName</h1>
-<a name="node.api.TransactionBuildStep$generateMethodName"></a>
-<code><span class="keyword">val </span><span class="identifier">generateMethodName</span><span class="symbol">: </span><span class="identifier">String</span></code><br/>
-<br/>
-<br/>
-</BODY>
-</HTML>

docs/build/html/api/api/-transaction-build-step/index.html

@@ -1,44 +0,0 @@
-<HTML>
-<HEAD>
-<title>TransactionBuildStep - </title>
-<link rel="stylesheet" href="../../style.css">
-</HEAD>
-<BODY>
-<a href="../index.html">api</a>&nbsp;/&nbsp;<a href=".">TransactionBuildStep</a><br/>
-<br/>
-<h1>TransactionBuildStep</h1>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">TransactionBuildStep</span></code><br/>
-<p>Encapsulate a generateXXX method call on a contract.</p>
-<br/>
-<br/>
-<h3>Constructors</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-init-.html">&lt;init&gt;</a></td>
-<td>
-<code><span class="identifier">TransactionBuildStep</span><span class="symbol">(</span><span class="identifier" id="node.api.TransactionBuildStep$<init>(kotlin.String, kotlin.collections.Map((kotlin.String, kotlin.Any)))/generateMethodName">generateMethodName</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">, </span><span class="identifier" id="node.api.TransactionBuildStep$<init>(kotlin.String, kotlin.collections.Map((kotlin.String, kotlin.Any)))/args">args</span><span class="symbol">:</span>&nbsp;<span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><p>Encapsulate a generateXXX method call on a contract.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<h3>Properties</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="args.html">args</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">args</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><span class="identifier">String</span><span class="symbol">,</span>&nbsp;<span class="identifier">Any</span><span class="symbol">?</span><span class="symbol">&gt;</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="generate-method-name.html">generateMethodName</a></td>
-<td>
-<code><span class="keyword">val </span><span class="identifier">generateMethodName</span><span class="symbol">: </span><span class="identifier">String</span></code></td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/api/index.html

@@ -1,110 +0,0 @@
-<HTML>
-<HEAD>
-<title>api - </title>
-<link rel="stylesheet" href="../style.css">
-</HEAD>
-<BODY>
-<a href=".">api</a><br/>
-<br/>
-<h2>Package api</h2>
-<h3>Types</h3>
-<table>
-<tbody>
-<tr>
-<td>
-<a href="-a-p-i-server/index.html">APIServer</a></td>
-<td>
-<code><span class="keyword">interface </span><span class="identifier">APIServer</span></code><p>Top level interface to external interaction with the distributed ledger.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="-a-p-i-server-impl/index.html">APIServerImpl</a></td>
-<td>
-<code><span class="keyword">class </span><span class="identifier">APIServerImpl</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="-a-p-i-server/index.html"><span class="identifier">APIServer</span></a></code></td>
-</tr>
-<tr>
-<td>
-<a href="-config/index.html">Config</a></td>
-<td>
-<code><span class="keyword">class </span><span class="identifier">Config</span></code><p>Primary purpose is to install Kotlin extensions for Jackson ObjectMapper so data classes work
-and to organise serializers / deserializers for java.time.* classes as necessary</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="-contract-class-ref/index.html">ContractClassRef</a></td>
-<td>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">ContractClassRef</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="-contract-def-ref.html"><span class="identifier">ContractDefRef</span></a></code></td>
-</tr>
-<tr>
-<td>
-<a href="-contract-def-ref.html">ContractDefRef</a></td>
-<td>
-<code><span class="keyword">interface </span><span class="identifier">ContractDefRef</span></code><p>Encapsulates the contract type.  e.g. Cash or CommercialPaper etc.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="-contract-ledger-ref/index.html">ContractLedgerRef</a></td>
-<td>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">ContractLedgerRef</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="-contract-def-ref.html"><span class="identifier">ContractDefRef</span></a></code></td>
-</tr>
-<tr>
-<td>
-<a href="-interest-rate-swap-a-p-i/index.html">InterestRateSwapAPI</a></td>
-<td>
-<code><span class="keyword">class </span><span class="identifier">InterestRateSwapAPI</span></code><p>This provides a simplified API, currently for demonstration use only.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="-protocol-class-ref/index.html">ProtocolClassRef</a></td>
-<td>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">ProtocolClassRef</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="-protocol-ref.html"><span class="identifier">ProtocolRef</span></a></code></td>
-</tr>
-<tr>
-<td>
-<a href="-protocol-instance-ref/index.html">ProtocolInstanceRef</a></td>
-<td>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">ProtocolInstanceRef</span></code></td>
-</tr>
-<tr>
-<td>
-<a href="-protocol-ref.html">ProtocolRef</a></td>
-<td>
-<code><span class="keyword">interface </span><span class="identifier">ProtocolRef</span></code><p>Encapsulates the protocol to be instantiated.  e.g. TwoPartyTradeProtocol.Buyer.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="-protocol-requiring-attention/index.html">ProtocolRequiringAttention</a></td>
-<td>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">ProtocolRequiringAttention</span></code><p>Thinking that Instant is OK for short lived protocol deadlines.</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="-response-filter/index.html">ResponseFilter</a></td>
-<td>
-<code><span class="keyword">class </span><span class="identifier">ResponseFilter</span></code><p>This adds headers needed for cross site scripting on API clients</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="-states-query/index.html">StatesQuery</a></td>
-<td>
-<code><span class="keyword">interface </span><span class="identifier">StatesQuery</span></code><p>Extremely rudimentary query language which should most likely be replaced with a product</p>
-</td>
-</tr>
-<tr>
-<td>
-<a href="-transaction-build-step/index.html">TransactionBuildStep</a></td>
-<td>
-<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">TransactionBuildStep</span></code><p>Encapsulate a generateXXX method call on a contract.</p>
-</td>
-</tr>
-</tbody>
-</table>
-</BODY>
-</HTML>

docs/build/html/api/com.r3corda.contracts.cash/-cash-issuance-definition/currency.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>CashIssuanceDefinition.currency - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.contracts.cash</a>&nbsp;/&nbsp;<a href="index.html">CashIssuanceDefinition</a>&nbsp;/&nbsp;<a href=".">currency</a><br/>
+<br/>
+<h1>currency</h1>
+<a name="com.r3corda.contracts.cash.CashIssuanceDefinition$currency"></a>
+<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">currency</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.cash/-cash-issuance-definition/deposit.html

@@ -0,0 +1,16 @@
+<HTML>
+<HEAD>
+<title>CashIssuanceDefinition.deposit - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.contracts.cash</a>&nbsp;/&nbsp;<a href="index.html">CashIssuanceDefinition</a>&nbsp;/&nbsp;<a href=".">deposit</a><br/>
+<br/>
+<h1>deposit</h1>
+<a name="com.r3corda.contracts.cash.CashIssuanceDefinition$deposit"></a>
+<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">deposit</span><span class="symbol">: </span><a href="../../com.r3corda.core.contracts/-party-and-reference/index.html"><span class="identifier">PartyAndReference</span></a></code><br/>
+<p>Where the underlying currency backing this ledger entry can be found (propagated)</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.cash/-cash-issuance-definition/index.html

@@ -0,0 +1,45 @@
+<HTML>
+<HEAD>
+<title>CashIssuanceDefinition - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.contracts.cash</a>&nbsp;/&nbsp;<a href=".">CashIssuanceDefinition</a><br/>
+<br/>
+<h1>CashIssuanceDefinition</h1>
+<code><span class="keyword">interface </span><span class="identifier">CashIssuanceDefinition</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-issuance-definition.html"><span class="identifier">IssuanceDefinition</span></a></code><br/>
+<p>Subset of cash-like contract state, containing the issuance definition. If these definitions match for two
+contracts states, those states can be aggregated.</p>
+<br/>
+<br/>
+<h3>Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="currency.html">currency</a></td>
+<td>
+<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">currency</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a></code></td>
+</tr>
+<tr>
+<td>
+<a href="deposit.html">deposit</a></td>
+<td>
+<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">deposit</span><span class="symbol">: </span><a href="../../com.r3corda.core.contracts/-party-and-reference/index.html"><span class="identifier">PartyAndReference</span></a></code><p>Where the underlying currency backing this ledger entry can be found (propagated)</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3>Inheritors</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../../com.r3corda.contracts/-cash/-issuance-definition/index.html">IssuanceDefinition</a></td>
+<td>
+<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">IssuanceDefinition</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">CashIssuanceDefinition</span></code></td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.cash/-common-cash-state/amount.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>CommonCashState.amount - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.contracts.cash</a>&nbsp;/&nbsp;<a href="index.html">CommonCashState</a>&nbsp;/&nbsp;<a href=".">amount</a><br/>
+<br/>
+<h1>amount</h1>
+<a name="com.r3corda.contracts.cash.CommonCashState$amount"></a>
+<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">amount</span><span class="symbol">: </span><a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.cash/-common-cash-state/deposit.html

@@ -0,0 +1,16 @@
+<HTML>
+<HEAD>
+<title>CommonCashState.deposit - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.contracts.cash</a>&nbsp;/&nbsp;<a href="index.html">CommonCashState</a>&nbsp;/&nbsp;<a href=".">deposit</a><br/>
+<br/>
+<h1>deposit</h1>
+<a name="com.r3corda.contracts.cash.CommonCashState$deposit"></a>
+<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">deposit</span><span class="symbol">: </span><a href="../../com.r3corda.core.contracts/-party-and-reference/index.html"><span class="identifier">PartyAndReference</span></a></code><br/>
+<p>Where the underlying currency backing this ledger entry can be found (propagated)</p>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.cash/-common-cash-state/index.html

@@ -0,0 +1,93 @@
+<HTML>
+<HEAD>
+<title>CommonCashState - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.contracts.cash</a>&nbsp;/&nbsp;<a href=".">CommonCashState</a><br/>
+<br/>
+<h1>CommonCashState</h1>
+<code><span class="keyword">interface </span><span class="identifier">CommonCashState</span><span class="symbol">&lt;</span><span class="identifier">I</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-cash-issuance-definition/index.html"><span class="identifier">CashIssuanceDefinition</span></a><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-ownable-state/index.html"><span class="identifier">OwnableState</span></a></code><br/>
+<p>Common elements of cash contract states.</p>
+<br/>
+<br/>
+<h3>Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="amount.html">amount</a></td>
+<td>
+<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">amount</span><span class="symbol">: </span><a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a></code></td>
+</tr>
+<tr>
+<td>
+<a href="deposit.html">deposit</a></td>
+<td>
+<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">deposit</span><span class="symbol">: </span><a href="../../com.r3corda.core.contracts/-party-and-reference/index.html"><span class="identifier">PartyAndReference</span></a></code><p>Where the underlying currency backing this ledger entry can be found (propagated)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="issuance-def.html">issuanceDef</a></td>
+<td>
+<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">issuanceDef</span><span class="symbol">: </span><span class="identifier">I</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Inherited Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../../com.r3corda.core.contracts/-ownable-state/owner.html">owner</a></td>
+<td>
+<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">owner</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a></code><p>There must be a MoveCommand signed by this key to claim the amount</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3>Inherited Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../../com.r3corda.core.contracts/-ownable-state/with-new-owner.html">withNewOwner</a></td>
+<td>
+<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">withNewOwner</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core.contracts.OwnableState$withNewOwner(java.security.PublicKey)/newOwner">newOwner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><a href="../../com.r3corda.core.contracts/-command-data.html"><span class="identifier">CommandData</span></a><span class="symbol">,</span>&nbsp;<a href="../../com.r3corda.core.contracts/-ownable-state/index.html"><span class="identifier">OwnableState</span></a><span class="symbol">&gt;</span></code><p>Copies the underlying data structure, replacing the owner field with this new value and leaving the rest alone</p>
+</td>
+</tr>
+</tbody>
+</table>
+<h3>Extension Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../../com.r3corda.core.contracts/hash.html">hash</a></td>
+<td>
+<code><span class="keyword">fun </span><a href="../../com.r3corda.core.contracts/-contract-state/index.html"><span class="identifier">ContractState</span></a><span class="symbol">.</span><span class="identifier">hash</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code><p>Returns the SHA-256 hash of the serialised contents of this state (not cached)</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="../../com.r3corda.core.testing/label.html">label</a></td>
+<td>
+<code><span class="keyword">infix</span> <span class="keyword">fun </span><a href="../../com.r3corda.core.contracts/-contract-state/index.html"><span class="identifier">ContractState</span></a><span class="symbol">.</span><span class="identifier">label</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core.testing$label(com.r3corda.core.contracts.ContractState, kotlin.String)/label">label</span><span class="symbol">:</span>&nbsp;<span class="identifier">String</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../com.r3corda.core.testing/-labeled-output/index.html"><span class="identifier">LabeledOutput</span></a></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Inheritors</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="../../com.r3corda.contracts/-cash/-state/index.html">State</a></td>
+<td>
+<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">State</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">CommonCashState</span><span class="symbol">&lt;</span><a href="../../com.r3corda.contracts/-cash/-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&gt;</span></code><p>A state representing a cash claim against some party</p>
+</td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.cash/-common-cash-state/issuance-def.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>CommonCashState.issuanceDef - </title>
+<link rel="stylesheet" href="../../style.css">
+</HEAD>
+<BODY>
+<a href="../index.html">com.r3corda.contracts.cash</a>&nbsp;/&nbsp;<a href="index.html">CommonCashState</a>&nbsp;/&nbsp;<a href=".">issuanceDef</a><br/>
+<br/>
+<h1>issuanceDef</h1>
+<a name="com.r3corda.contracts.cash.CommonCashState$issuanceDef"></a>
+<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">issuanceDef</span><span class="symbol">: </span><span class="identifier">I</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.cash/index.html

@@ -0,0 +1,31 @@
+<HTML>
+<HEAD>
+<title>com.r3corda.contracts.cash - </title>
+<link rel="stylesheet" href="../style.css">
+</HEAD>
+<BODY>
+<a href=".">com.r3corda.contracts.cash</a><br/>
+<br/>
+<h2>Package com.r3corda.contracts.cash</h2>
+<h3>Types</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="-cash-issuance-definition/index.html">CashIssuanceDefinition</a></td>
+<td>
+<code><span class="keyword">interface </span><span class="identifier">CashIssuanceDefinition</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../com.r3corda.core.contracts/-issuance-definition.html"><span class="identifier">IssuanceDefinition</span></a></code><p>Subset of cash-like contract state, containing the issuance definition. If these definitions match for two
+contracts states, those states can be aggregated.</p>
+</td>
+</tr>
+<tr>
+<td>
+<a href="-common-cash-state/index.html">CommonCashState</a></td>
+<td>
+<code><span class="keyword">interface </span><span class="identifier">CommonCashState</span><span class="symbol">&lt;</span><span class="identifier">I</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="-cash-issuance-definition/index.html"><span class="identifier">CashIssuanceDefinition</span></a><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../com.r3corda.core.contracts/-ownable-state/index.html"><span class="identifier">OwnableState</span></a></code><p>Common elements of cash contract states.</p>
+</td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.testing/-c-a-s-h.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>CASH - </title>
+<link rel="stylesheet" href="../style.css">
+</HEAD>
+<BODY>
+<a href="index.html">com.r3corda.contracts.testing</a>&nbsp;/&nbsp;<a href=".">CASH</a><br/>
+<br/>
+<h1>CASH</h1>
+<a name="com.r3corda.contracts.testing$CASH#com.r3corda.core.contracts.Amount"></a>
+<code><span class="keyword">val </span><a href="../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">.</span><span class="identifier">CASH</span><span class="symbol">: </span><a href="../com.r3corda.contracts/-cash/-state/index.html"><span class="identifier">State</span></a></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.testing/-t-e-s-t_-p-r-o-g-r-a-m_-m-a-p.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>TEST_PROGRAM_MAP - </title>
+<link rel="stylesheet" href="../style.css">
+</HEAD>
+<BODY>
+<a href="index.html">com.r3corda.contracts.testing</a>&nbsp;/&nbsp;<a href=".">TEST_PROGRAM_MAP</a><br/>
+<br/>
+<h1>TEST_PROGRAM_MAP</h1>
+<a name="com.r3corda.contracts.testing$TEST_PROGRAM_MAP"></a>
+<code><span class="keyword">val </span><span class="identifier">TEST_PROGRAM_MAP</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../com.r3corda.core.contracts/-contract/index.html"><span class="identifier">Contract</span></a><span class="symbol">,</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Class.html"><span class="identifier">Class</span></a><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<a href="../com.r3corda.core.contracts/-contract/index.html"><span class="identifier">Contract</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.testing/generate-state.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>generateState - </title>
+<link rel="stylesheet" href="../style.css">
+</HEAD>
+<BODY>
+<a href="index.html">com.r3corda.contracts.testing</a>&nbsp;/&nbsp;<a href=".">generateState</a><br/>
+<br/>
+<h1>generateState</h1>
+<a name="com.r3corda.contracts.testing$generateState(com.r3corda.core.crypto.Party)"></a>
+<code><span class="keyword">fun </span><span class="identifier">generateState</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$generateState(com.r3corda.core.crypto.Party)/notary">notary</span><span class="symbol">:</span>&nbsp;<a href="../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a>&nbsp;<span class="symbol">=</span>&nbsp;DUMMY_NOTARY<span class="symbol">)</span><span class="symbol">: </span><a href="../com.r3corda.contracts/-dummy-contract/-state/index.html"><span class="identifier">State</span></a></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.testing/index.html

@@ -0,0 +1,53 @@
+<HTML>
+<HEAD>
+<title>com.r3corda.contracts.testing - </title>
+<link rel="stylesheet" href="../style.css">
+</HEAD>
+<BODY>
+<a href=".">com.r3corda.contracts.testing</a><br/>
+<br/>
+<h2>Package com.r3corda.contracts.testing</h2>
+<h3>Properties</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="-c-a-s-h.html">CASH</a></td>
+<td>
+<code><span class="keyword">val </span><a href="../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">.</span><span class="identifier">CASH</span><span class="symbol">: </span><a href="../com.r3corda.contracts/-cash/-state/index.html"><span class="identifier">State</span></a></code></td>
+</tr>
+<tr>
+<td>
+<a href="-t-e-s-t_-p-r-o-g-r-a-m_-m-a-p.html">TEST_PROGRAM_MAP</a></td>
+<td>
+<code><span class="keyword">val </span><span class="identifier">TEST_PROGRAM_MAP</span><span class="symbol">: </span><span class="identifier">Map</span><span class="symbol">&lt;</span><a href="../com.r3corda.core.contracts/-contract/index.html"><span class="identifier">Contract</span></a><span class="symbol">,</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Class.html"><span class="identifier">Class</span></a><span class="symbol">&lt;</span><span class="keyword">out</span>&nbsp;<a href="../com.r3corda.core.contracts/-contract/index.html"><span class="identifier">Contract</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code></td>
+</tr>
+</tbody>
+</table>
+<h3>Functions</h3>
+<table>
+<tbody>
+<tr>
+<td>
+<a href="generate-state.html">generateState</a></td>
+<td>
+<code><span class="keyword">fun </span><span class="identifier">generateState</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$generateState(com.r3corda.core.crypto.Party)/notary">notary</span><span class="symbol">:</span>&nbsp;<a href="../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a>&nbsp;<span class="symbol">=</span>&nbsp;DUMMY_NOTARY<span class="symbol">)</span><span class="symbol">: </span><a href="../com.r3corda.contracts/-dummy-contract/-state/index.html"><span class="identifier">State</span></a></code></td>
+</tr>
+<tr>
+<td>
+<a href="issued by.html">issued by</a></td>
+<td>
+<code><span class="keyword">infix</span> <span class="keyword">fun </span><a href="../com.r3corda.contracts/-cash/-state/index.html"><span class="identifier">State</span></a><span class="symbol">.</span><span class="identifier">issued by</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$issued by(com.r3corda.contracts.Cash.State, com.r3corda.core.crypto.Party)/party">party</span><span class="symbol">:</span>&nbsp;<a href="../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">)</span><span class="symbol">: </span><a href="../com.r3corda.contracts/-cash/-state/index.html"><span class="identifier">State</span></a></code></td>
+</tr>
+<tr>
+<td>
+<a href="owned by.html">owned by</a></td>
+<td>
+<code><span class="keyword">infix</span> <span class="keyword">fun </span><a href="../com.r3corda.contracts/-cash/-state/index.html"><span class="identifier">State</span></a><span class="symbol">.</span><span class="identifier">owned by</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$owned by(com.r3corda.contracts.Cash.State, java.security.PublicKey)/owner">owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><a href="../com.r3corda.contracts/-cash/-state/index.html"><span class="identifier">State</span></a></code><br/>
+<code><span class="keyword">infix</span> <span class="keyword">fun </span><a href="../com.r3corda.contracts/-commercial-paper/-state/index.html"><span class="identifier">State</span></a><span class="symbol">.</span><span class="identifier">owned by</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$owned by(com.r3corda.contracts.CommercialPaper.State, java.security.PublicKey)/owner">owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><a href="../com.r3corda.contracts/-commercial-paper/-state/index.html"><span class="identifier">State</span></a></code><br/>
+<code><span class="keyword">infix</span> <span class="keyword">fun </span><span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">.</span><span class="identifier">owned by</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$owned by(, java.security.PublicKey)/new_owner">new_owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code></td>
+</tr>
+</tbody>
+</table>
+</BODY>
+</HTML>

docs/build/html/api/com.r3corda.contracts.testing/issued by.html

@@ -0,0 +1,15 @@
+<HTML>
+<HEAD>
+<title>issued by - </title>
+<link rel="stylesheet" href="../style.css">
+</HEAD>
+<BODY>
+<a href="index.html">com.r3corda.contracts.testing</a>&nbsp;/&nbsp;<a href=".">issued by</a><br/>
+<br/>
+<h1>issued by</h1>
+<a name="com.r3corda.contracts.testing$issued by(com.r3corda.contracts.Cash.State, com.r3corda.core.crypto.Party)"></a>
+<code><span class="keyword">infix</span> <span class="keyword">fun </span><a href="../com.r3corda.contracts/-cash/-state/index.html"><span class="identifier">State</span></a><span class="symbol">.</span><span class="identifier">issued by</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$issued by(com.r3corda.contracts.Cash.State, com.r3corda.core.crypto.Party)/party">party</span><span class="symbol">:</span>&nbsp;<a href="../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">)</span><span class="symbol">: </span><a href="../com.r3corda.contracts/-cash/-state/index.html"><span class="identifier">State</span></a></code><br/>
+<br/>
+<br/>
+</BODY>
+</HTML>