diff --git a/.idea/runConfigurations/Run_Contract_Tests.xml b/.idea/runConfigurations/Run_Contract_Tests.xml
index 4ec7b4a..85ba4f8 100644
--- a/.idea/runConfigurations/Run_Contract_Tests.xml
+++ b/.idea/runConfigurations/Run_Contract_Tests.xml
@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Run Contract Tests" type="JUnit" factoryName="JUnit">
-    <module name="onixlabs-corda-core.onixlabs-corda-core-contract.test" />
-    <option name="PACKAGE_NAME" value="io.onixlabs.corda.core.contract" />
+    <module name="onixlabs-corda-core.onixlabs-corda-test-contract.test" />
+    <option name="PACKAGE_NAME" value="io.onixlabs.corda.test" />
     <option name="MAIN_CLASS_NAME" value="" />
     <option name="METHOD_NAME" value="" />
     <option name="TEST_OBJECT" value="package" />
diff --git a/.idea/runConfigurations/Run_Workflow_Tests.xml b/.idea/runConfigurations/Run_Workflow_Tests.xml
index 37e4863..5c3a34e 100644
--- a/.idea/runConfigurations/Run_Workflow_Tests.xml
+++ b/.idea/runConfigurations/Run_Workflow_Tests.xml
@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Run Workflow Tests" type="JUnit" factoryName="JUnit">
-    <module name="onixlabs-corda-core.onixlabs-corda-core-workflow.test" />
-    <option name="PACKAGE_NAME" value="io.onixlabs.corda.core.workflow" />
+    <module name="onixlabs-corda-core.onixlabs-corda-test-workflow.test" />
+    <option name="PACKAGE_NAME" value="io.onixlabs.corda.test.workflow" />
     <option name="MAIN_CLASS_NAME" value="" />
     <option name="METHOD_NAME" value="" />
     <option name="TEST_OBJECT" value="package" />
diff --git a/CHANGELOG.md b/CHANGELOG.md
deleted file mode 100644
index 89bcba4..0000000
--- a/CHANGELOG.md
+++ /dev/null
@@ -1,142 +0,0 @@
-![ONIX Labs](https://raw.githubusercontent.com/onix-labs/onix-labs.github.io/master/content/logo/master_full_md.png)
-
-# Change Log
-
-This document serves as the change log for the ONIXLabs Corda Core API.
-
-## Version 1.1.0
-
-### Contract
-
-#### Extensions
-
--   Moved to new extension file naming convention for maintainability.
--   Added extensions to obtain single inputs, reference inputs and outputs from a `LedgerTransaction`.
--   Added extension to cast `Iterable<StateAndRef<*>>` to `List<StateAndRef<T>>`.
--   Added `ContractID` interface which automatically binds a contract ID to a contract class.
--   Added `SignedCommandData` interface which defines a contract command that must include a signature.
--   Added `VerifiedCommandData` interface which verifies a ledger transaction.
--   Added `SignatureData` class, which represents a digital signature, and it's unsigned counterpart.
-
-### Workflow
-
-#### Extensions
-
--   Moved to new extension naming convention for maintainability.
--   Added extensions to filter a set of sessions to include or exclude certain counter-parties, or state participants.
-
-## Version 1.0.0
-
-### Contract
-
-#### ChainState (interface)
-
-Defines a Corda chain state. 
-
->   A chain state is similar to a `LinearState`, in that it represents a set of state transitions. Chain states adopt a concept similar to blockchain, where each new state transition references the previous one by it's `StateRef`, or null if it's the first state in the chain.
-
-#### Hashable (interface)
-
-Defines an object that can produce a unique hash. 
-
->   This is useful if you require some level of state uniqueness.
-
-#### Resolvable (interface)
-
-Defines an object which resolves a `ContractState`. 
-
->   This is the fundamental principle on which state pointers are implemented in Corda; their ability to maintain and resolve a reference back to another known state in the vault. The implementation here is flexible and open, allowing developers to model resolvable as a design pattern, rather than as a strict implementation detail.
-
-#### TransactionResolution (enum)
-
-Defines how to resolve states from a transaction, and is used by the `Resolvable` interface.
-
-#### Extensions
-
--   Added extension to obtain a set of owning keys from a collection of `AbstractParty`.
--   Added extension to obtain a participant hash to determine state uniqueness by participation.
--   Added extensions to determine whether a chain state instance is pointing to a specified `StateRef`.
--   Added extension to cast an unknown `StateAndRef<*>` to a typed `StateAndRef<T>`.
-
-### Workflow
-
-#### FindStateFlow (abstract class)
-
-Represents the base class for implementing a query that finds a single state.
-
-#### FindStatesFlow (abstract class)
-
-Represents the base class for implementing a query that finds multiple states.
-
->   This design pattern enables developers to be more consistent in their approach to performing vault queries, regardless of whether they're being performed from within the node (using `ServiceHub`) or from an RPC client (using `CordaRPCOps`).
-
-#### Message (open class)
-
-Represents an open, transient message.
-
-#### MessageAcknowledgement (open class)
-
-Represents an open acknowledgement to a message.
-
-#### SendMessageFlow (class)
-
-Sends a message to other nodes on the Corda network.
-
-#### ReceiveMessageFlow (class)
-
-Receives a message from another node on the Corda network.
-
-#### SendMessageAcknowledgementFlow (class)
-
-Sends a message acknowledgement to other nodes on the Corda network.
-
-#### ReceiveMessageAcknowledgementFlow (class)
-
-Receives a message acknowledgement from another node on the Corda network.
-
-#### TransactionNote (class)
-
-Represents a wrapper around a transaction note and the transaction that the note belongs to.
-
-#### SendTransactionNoteFlow (class)
-
-Sends a transaction note to other nodes on the Corda network for persistence.
-
-#### ReceiveTransactionNoteFlow (class)
-
-Receives a transaction note from another node on the Corda network, and optionally persists it.
-
->   All messaging APIs are part of the ONIXLabs Corda Code messaging protocol, which allows Corda nodes to send and receive transient messages and messages acknowledgements, which are not bound to the ledger.
-
-#### Extensions
-
--   Added extensions to obtain the first notary from the network map cache.
--   Added extensions to obtain a random notary from the network map cache.
--   Added extensions to obtain the preferred notary from the CorDapp config file.
--   Added extensions to set, and optionally log progress tracker steps.
--   Added extensions to initiate flow sessions for a collection of parties and/or state participants.
--   Added extensions to check that sufficient flow sessions have been passed for the specified states.
--   Added extensions to find transactions by transaction ID or `StateRef`.
--   Added constants for default sorting and default, or maximum size page specification.
--   Added extensions to  build complex query expressions.
-
-### Integration
-
-#### RPCService (abstract class)
-
-Represents the base class for implementing services that utilize `CordaRPCOps`.
-
-#### MessageService (class)
-
-Represents an RPC service for sending and subscribing to transient messages.
-
-#### MessageAcknowledgementService (class)
-
-Represents an RPC service for sending and subscribing to transience message acknowledgements.
-
-#### TransactionNoteService (class)
-
-Represents an RPC service for adding, sending and persisting transaction notes.
-
-
-
diff --git a/HEADER b/HEADER
index 27084fa..173b988 100644
--- a/HEADER
+++ b/HEADER
@@ -1,15 +1,13 @@
-/**
- * Copyright 2020 Matthew Layton
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
\ No newline at end of file
+Copyright 2020-2021 ONIXLabs
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
\ No newline at end of file
diff --git a/README.md b/README.md
index 048e6b7..700ffef 100644
--- a/README.md
+++ b/README.md
@@ -2,11 +2,57 @@
 
 # ONIXLabs Corda Core
 
-ONIXLabs Corda Core provides Corda developers with a suite of APIs to empower development of CorDapps, and also serves as the foundation for all of the ONIXLabs Corda Frameworks and APIs.
+The ONIXLabs Corda Core API provides Corda developers with a suite of APIs to empower development of Corda contracts, workflows and integration. These APIs are not intended to be used as CorDapps, since they do not contain any states or contracts, however they are partitioned into contract, workflow and integration modules containing features to improve and simplify CorDapp design and development.
 
-Whilst the ONIXLabs Corda Core API isn't intended to be used as a CorDapp (it doesn't have any of it's own states and/or contracts), it's partitioned into contract, workflow and integration layers for simplicty, and is signed with the ONIXLabs key.
+## CorDapp Signing
 
+As of version 2.0.0 of the ONIXLabs Corda Core API, this repository ships with the ONIXLabs developer signing key so that this repository can be checked out and built locally. Official releases of this API are signed with the ONIXLabs production signing key.
 
+## Integration Guide
 
+Follow these steps to integrate the ONIXLabs Corda Core API into your application
 
+1.  Add the following to your project's top level **build.gradle** file.
 
+    ```
+    buildscript {
+        ext {
+            onixlabs_group = 'io.onixlabs'
+            onixlabs_corda_core_release_version = '2.0.0'
+        }
+    }
+    ```
+
+2.  Implement the ONIXLabs Corda Core contract module into your contract.
+
+    ```
+    dependencies {
+        cordapp "$onixlabs_group:onixlabs-corda-core-contract:$onixlabs_corda_core_release_version"
+    }
+    ```
+
+3.  Implement the ONIXLabs Corda Core workflow module into your workflow.
+
+    ```
+    dependencies {
+        cordapp "$onixlabs_group:onixlabs-corda-core-workflow:$onixlabs_corda_core_release_version"
+    }
+    ```
+
+4.  Implement the ONIXLabs Corda Core integration module into your integration.
+
+    ```
+    dependencies {
+        implementation "$onixlabs_group:onixlabs-corda-core-integration:$onixlabs_corda_core_release_version"
+    }
+    ```
+
+## Package Versioning
+
+The ONIXLabs Corda Core API uses semantic versioning for every published release of the API. Version numbers apply the following format, **_major_._minor_._patch_**; for example 1.2.34
+
+-   **Major** - The API contains breaking changes which are not backwards compatible.
+-   **Minor** - The API contains new features which are backwards compatible.
+-   **Patch** - The API contains bug fixes which are backwards compatible.
+
+Release Candidate versions are considered unstable and likely to change quickly. Release Candidate version numbers apply the following format, **_major_._minor_._patch_-rc#**; for example 1.2.0-rc3
diff --git a/build.gradle b/build.gradle
index 26cb2f5..99cdc29 100644
--- a/build.gradle
+++ b/build.gradle
@@ -23,8 +23,8 @@ buildscript {
         cordapp_signing_enabled = true
         cordapp_signing_alias = 'cordapp-signer'
         cordapp_signing_storetype = 'PKCS12'
-        cordapp_signing_keystore = getProperty('jar.sign.keystore')
-        cordapp_signing_password = getProperty('jar.sign.password')
+        cordapp_signing_keystore = findProperty('onixlabs.production.jarsign.keystore') ?: getProperty('onixlabs.development.jarsign.keystore')
+        cordapp_signing_password = findProperty('onixlabs.production.jarsign.password') ?: getProperty('onixlabs.development.jarsign.password')
     }
 
     repositories {
@@ -42,7 +42,7 @@ buildscript {
 }
 
 group 'io.onixlabs'
-version '1.2.0'
+version '2.0.0'
 
 subprojects {
     repositories {
diff --git a/docs/CHANGELOG-1.0.0.md b/docs/CHANGELOG-1.0.0.md
new file mode 100644
index 0000000..46beb41
--- /dev/null
+++ b/docs/CHANGELOG-1.0.0.md
@@ -0,0 +1,746 @@
+![ONIX Labs](https://raw.githubusercontent.com/onix-labs/onix-labs.github.io/master/content/logo/master_full_md.png)
+
+# Change Log - Version 1.0.0
+
+This document serves as the change log for the ONIXLabs Corda Core API.
+
+## Release Notes
+
+This is the initial release of the ONIXLabs Corda Core API and contains features for Corda contract, workflow and integration design.
+
+---
+
+### ChainState *Interface*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Defines a Corda chain state.
+
+```kotlin
+interface ChainState
+```
+
+#### Remarks
+
+A chain state is similar to a `LinearState` in that it represents a set of state transitions. Chain states adopt a concept similar to a blockchain, where each new state transition references the previous one by its `StateRef`, or `null` if it's the first state in the chain.
+
+---
+
+### Hashable *Interface*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Defines an object that can produce a unique hash.
+
+```kotlin
+interface Hashable
+```
+
+#### Remarks
+
+When used in conjunction with the `ChainState` interface, this can be useful for modelling states that always produce a unique hash for every state transition.
+
+---
+
+### Resolvable *Interface*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Defines an object which resolves a `ContractState`.
+
+```kotlin
+interface Resolvable<T> where T : ContractState
+```
+
+#### Remarks
+
+This is the fundamental principle on which state pointers are implemented in Corda; their ability to maintain and resolve a reference back to another known state in the vault. The implementation here is flexible and open, allowing developers to model resolvable as a design pattern, rather than as a strict implementation detail.
+
+---
+
+### TransactionResolution *Enum Class*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Defines how to resolve states from a transaction, and is used by the `Resolvable` interface.
+
+```kotlin
+enum class TransactionResolution
+```
+
+#### Entries
+
+| Name          | Description                                                  |
+| ------------- | ------------------------------------------------------------ |
+| **INPUT**     | Defines that a resolvable should resolve from a transaction input state. |
+| **OUTPUT**    | Defines that a resolvable should resolve from a transaction output state. |
+| **REFERENCE** | Defines that a resolvable should resolve from a transaction reference input state. |
+
+---
+
+### owningKeys *Extension Property*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Gets the owning keys from an `Iterable` of `AbstractParty`.
+
+```kotlin
+val Iterable<AbstractParty>.owningKeys: Set<PublicKey> 
+```
+
+---
+
+### participantHash *Extension Property*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Gets a hash from an `Iterable` of `AbstractParty`.
+
+```kotlin
+val Iterable<AbstractParty>.participantHash: SecureHash
+```
+
+#### Remarks
+
+This extension property can be used to determine whether the participants of a state are unique, regardless of the ordering of those participants.
+
+---
+
+### isPointingTo *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Determines whether the current state is pointing to the specified `StateRef`, or `StateAndRef`.
+
+```kotlin
+fun <T> §T.isPointingTo(stateAndRef: StateAndRef<T>): Boolean where T : ChainState
+```
+
+---
+
+### cast *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Casts a `StateAndRef` of an unknown `ContractState` to a `StateAndRef` of type `T`.
+
+```kotlin
+inline fun <reified T> StateAndRef<*>.cast(): StateAndRef<T> where T : ContractState
+```
+
+---
+
+### FindStateFlow *Abstract Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents the base class for implementing a query that finds a single state.
+
+```kotlin
+abstract class FindStateFlow<T> : FlowLogic<StateAndRef<T>?>() where T : ContractState
+```
+
+#### Remarks
+
+This design pattern enables developers to be more consistent in their approach to performing vault queries, regardless of whether they're being performed from within the node (using `ServiceHub`) or from an RPC client (using `CordaRPCOps`).
+
+---
+
+### FindStatesFlow *Abstract Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents the base class for implementing a query that finds multiple states.
+
+```kotlin
+abstract class FindStatesFlow<T> : FlowLogic<List<StateAndRef<T>>>() where T : ContractState
+```
+
+#### Remarks
+
+This design pattern enables developers to be more consistent in their approach to performing vault queries, regardless of whether they're being performed from within the node (using `ServiceHub`) or from an RPC client (using `CordaRPCOps`).
+
+---
+
+### Message *Open Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a transient message.
+
+```kotlin
+open class Message<T>(val data: T, val id: UUID = UUID.randomUUID()) where T : Any
+```
+
+---
+
+### MessageAcknowledgement *Open Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents an acknowledgement to a transient message.
+
+```kotlin
+open class MessageAcknowledgement(val id: UUID)
+```
+
+---
+
+### SendMessageFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that sends a message to the specified counter-parties.
+
+```kotlin
+class SendMessageFlow<T>(
+    private val message: T,
+    private val sessions: Set<FlowSession>,
+    private val requestAcknowledgement: Boolean = false,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Map<Party, MessageAcknowledgement>>() where T : Message<*>
+```
+
+#### Remarks
+
+Use the built-in `SendMessageFlow.Initiator` class in order to use this class as an initiating flow.
+
+```kotlin
+@StartableByRPC
+@StartableByService
+@InitiatingFlow
+class Initiator<T>(
+    private val message: T,
+    private val counterparties: Collection<Party>
+) : FlowLogic<Map<Party, MessageAcknowledgement>>() where T : Message<*>
+```
+
+---
+
+### ReceiveMessageFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that receives a message from the specified counter-parties.
+
+```kotlin
+class ReceiveMessageFlow<T>(
+    private val session: FlowSession,
+    private val requestAcknowledgement: Boolean = false,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Pair<Party, T>>() where T : Message<*>
+```
+
+#### Remarks
+
+Use the built-in `ReceiveMessageFlow.Receiver` class in order to register it as an initiated-by flow, and listen for message results.
+
+```kotlin
+@InitiatedBy(SendMessageFlow.Initiator::class)
+class Receiver<T>(private val session: FlowSession) : FlowLogic<Pair<Party, T>>() where T : Message<*>
+```
+
+---
+
+### SendMessageAcknowledgementFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that sends a message acknowledgement to the specified counter-party.
+
+```kotlin
+class SendMessageAcknowledgementFlow<T>(
+    private val acknowledgement: T,
+    private val session: FlowSession,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Unit>() where T : MessageAcknowledgement
+```
+
+#### Remarks
+
+Use the built-in `SendMessageAcknowledgementFlow.Initiator` class in order to use this class as an initiating flow.
+
+```kotlin
+@StartableByRPC
+@StartableByService
+@InitiatingFlow
+class Initiator<T>(
+    private val acknowledgement: T,
+    private val counterparty: Party
+) : FlowLogic<Unit>() where T : MessageAcknowledgement
+```
+
+---
+
+### ReceiveMessageAcknowledgementFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that receives a message acknowledgement from the specified counter-party.
+
+```kotlin
+class ReceiveMessageAcknowledgementFlow<T>(
+    private val session: FlowSession,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Pair<Party, T>>()
+```
+
+#### Remarks
+
+Use the built-in `ReceiveMessageAcknowledgementFlow.Receiver` class in order to register it as an initiated-by flow, and listen for message acknowledgement results.
+
+```kotlin
+@InitiatedBy(SendMessageAcknowledgementFlow.Initiator::class)
+class Receiver<T>(private val session: FlowSession) : FlowLogic<Pair<Party, T>>() where T : MessageAcknowledgement
+```
+
+---
+
+### TransactionNote *Data Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a transaction note.
+
+```kotlin
+data class TransactionNote(val transactionId: SecureHash, val text: String)
+```
+
+---
+
+### SendTransactionNoteFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that sends a transaction note to the specified counter-parties.
+
+```kotlin
+class SendTransactionNoteFlow(
+    private val transactionNote: TransactionNote,
+    private val sessions: Collection<FlowSession>,
+    private val addNoteToTransaction: Boolean = true,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Unit>()
+```
+
+#### Remarks
+
+Use the built-in `SendTransactionNoteFlow.Initiator` class in order to use this class as an initiating flow.
+
+```kotlin
+@StartableByRPC
+@StartableByService
+@InitiatingFlow
+class Initiator(
+    private val transactionNote: TransactionNote,
+    private val counterparties: Iterable<Party>,
+    private val addNoteToTransaction: Boolean = true
+) : FlowLogic<Unit>()
+```
+
+---
+
+### ReceiveTransactionNoteFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that receives a transaction note from the specified counter-party.
+
+```kotlin
+class ReceiveTransactionNoteFlow(
+    private val session: FlowSession,
+    private val persist: Boolean = true,
+    private val expectedTransactionId: SecureHash? = null,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Pair<Party, TransactionNote>>()
+```
+
+#### Remarks
+
+Use the built-in `ReceiveTransactionNoteFlow.Receiver` class in order to register it as an initiated-by flow, and listen for transaction note results.
+
+```kotlin
+@InitiatedBy(SendTransactionNoteFlow.Initiator::class)
+class Receiver(private val session: FlowSession) : FlowLogic<Pair<Party, TransactionNote>>()
+```
+
+---
+
+### firstNotary *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Gets the first available notary.
+
+```kotlin
+val FlowLogic<*>.firstNotary: Party
+```
+
+#### Remarks
+
+This extension property will throw a `NoSuchElementException` if there are no available notaries.
+
+---
+
+### randomNotary *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Gets a randomly available notary.
+
+```kotlin
+val FlowLogic<*>.randomNotary: Party
+```
+
+#### Remarks
+
+This extension property will throw a `NoSuchElementException` if there are no available notaries.
+
+---
+
+### getPreferredNotary *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Gets the preferred notary from the CorDapp config, or alternatively a default notary in the event that a preferred notary has not been specified in the CorDapp config.
+
+```kotlin
+@Suspendable
+fun FlowLogic<*>.getPreferredNotary(
+    serviceHub: ServiceHub = this.serviceHub,
+    defaultSelector: (ServiceHub) -> Party = { firstNotary }
+): Party
+```
+
+#### Remarks
+
+This extension property will throw an `IllegalArgumentException` if the preferred notary cannot be found in the network map cache.
+
+---
+
+### currentStep *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Sets the current progress tracker step.
+
+```kotlin
+@Suspendable
+fun FlowLogic<*>.currentStep(step: Step, log: Boolean = true, additionalLogInfo: String? = null)
+```
+
+---
+
+### initiateFlows *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Initiates flow sessions for the specified parties and/or states, except for identities that belong to the local node, since flow sessions are not required locally.
+
+```kotlin
+@Suspendable
+fun FlowLogic<*>.initiateFlows(vararg parties: AbstractParty): Set<FlowSession>
+
+@Suspendable
+fun FlowLogic<*>.initiateFlows(vararg states: ContractState): Set<FlowSession>
+
+@Suspendable
+fun FlowLogic<*>.initiateFlows(parties: Iterable<AbstractParty>, vararg states: ContractState): Set<FlowSession>
+```
+
+---
+
+### checkSufficientSessions *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Checks that sufficient flow sessions have been provided for the specified states, of from the input and output states of a transaction builder.
+
+```kotlin
+@Suspendable
+fun FlowLogic<*>.checkSufficientSessions(sessions: Iterable<FlowSession>, states: Iterable<ContractState>)
+
+@Suspendable
+fun FlowLogic<*>.checkSufficientSessions(sessions: Iterable<FlowSession>, vararg states: ContractState)
+
+@Suspendable
+fun FlowLogic<*>.checkSufficientSessions(sessions: Iterable<FlowSession>, transaction: TransactionBuilder)
+```
+
+#### Remarks
+
+Assuming that the specified states will be used as input or output states in a transaction, this function will extract a set of all state participants, excluding identities owned by the initiating node, and then check that a flow session exists for each participant.
+
+---
+
+### findTransaction *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Finds a recorded transaction in the vault for the specified transaction hash.
+
+```kotlin
+@Suspendable
+fun FlowLogic<*>.findTransaction(transactionHash: SecureHash): SignedTransaction
+
+@Suspendable
+fun FlowLogic<*>.findTransaction(stateRef: StateRef): SignedTransaction
+
+@Suspendable
+fun FlowLogic<*>.findTransaction(stateAndRef: StateAndRef<*>): SignedTransaction
+```
+
+---
+
+### DEFAULT_SORTING *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+The default sorting order.
+
+```kotlin
+val DEFAULT_SORTING: Sort
+```
+
+---
+
+### DEFAULT_PAGE_SPECIFICATION *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+The default page specification.
+
+```kotlin
+val DEFAULT_PAGE_SPECIFICATION: PageSpecification
+```
+
+---
+
+### MAXIMUM_PAGE_SPECIFICATION *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+The maximum page specification.
+
+```kotlin
+val MAXIMUM_PAGE_SPECIFICATION: PageSpecification
+```
+
+---
+
+### andWithExpressions *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Builds a custom query criteria. This combines all non-null query expressions using logical AND.
+
+```kotlin
+fun <T : StatePersistable> QueryCriteria.VaultQueryCriteria.andWithExpressions(
+    vararg expressions: CriteriaExpression<T, Boolean>?
+): QueryCriteria
+```
+
+---
+
+### orWithExpressions *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Builds a custom query criteria. This combines all non-null query expressions using logical OR.
+
+```kotlin
+fun <T : StatePersistable> QueryCriteria.VaultQueryCriteria.andWithExpressions(
+    vararg expressions: CriteriaExpression<T, Boolean>?
+): QueryCriteria
+```
+
+---
+
+### RPCService *Abstract Class*
+
+**Module:** onixlabs-corda-core-integration
+
+**Package:** io.onixlabs.corda.core.integration
+
+#### Description
+
+Represents the base class for implementing integration services over RPC.
+
+```kotlin
+abstract class RPCService(val rpc: CordaRPCOps)
+```
+
+---
+
+### MessageService *Class*
+
+**Module:** onixlabs-corda-core-integration
+
+**Package:** io.onixlabs.corda.core.integration
+
+#### Description
+
+Represents an RPC service for sending and subscribing to transient messages.
+
+```kotlin
+class MessageService(rpc: CordaRPCOps) : RPCService(rpc)
+```
+
+---
+
+### MessageAcknowledgementService *Class*
+
+**Module:** onixlabs-corda-core-integration
+
+**Package:** io.onixlabs.corda.core.integration
+
+#### Description
+
+Represents an RPC service for sending and subscribing to transience message acknowledgements.
+
+```kotlin
+class MessageAcknowledgementService(rpc: CordaRPCOps) : RPCService(rpc)
+```
+
+---
+
+### TransactionNoteService *Class*
+
+**Module:** onixlabs-corda-core-integration
+
+**Package:** io.onixlabs.corda.core.integration
+
+#### Description
+
+Represents an RPC service for adding, sending and persisting transaction notes.
+
+```kotlin
+class TransactionNoteService(rpc: CordaRPCOps) : RPCService(rpc)
+```
+
+---
+
diff --git a/docs/CHANGELOG-1.1.0.md b/docs/CHANGELOG-1.1.0.md
new file mode 100644
index 0000000..035b53f
--- /dev/null
+++ b/docs/CHANGELOG-1.1.0.md
@@ -0,0 +1,965 @@
+![ONIX Labs](https://raw.githubusercontent.com/onix-labs/onix-labs.github.io/master/content/logo/master_full_md.png)
+
+# Change Log - Version 1.1.0
+
+This document serves as the change log for the ONIXLabs Corda Core API.
+
+## Release Notes
+
+In addition to the new APIs in this release, all extension files have been renamed to use a better naming convention for maintainability.
+
+---
+
+### singleInputRefOfType *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Obtains a single input ref from a ledger transaction.
+
+```kotlin
+fun <T : ContractState> LedgerTransaction.singleInputRefOfType(contractStateClass: Class<T>): StateAndRef<T>
+
+inline fun <reified T : ContractState> LedgerTransaction.singleInputRefOfType(): StateAndRef<T>
+```
+
+---
+
+### singleInputOfType *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Obtains a single input from a ledger transaction.
+
+```kotlin
+fun <T : ContractState> LedgerTransaction.singleInputOfType(contractStateClass: Class<T>): T
+
+inline fun <reified T : ContractState> LedgerTransaction.singleInputOfType(): T
+```
+
+---
+
+### singleReferenceInputRefOfType *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Obtains a single reference input ref from a ledger transaction.
+
+```kotlin
+fun <T : ContractState> LedgerTransaction.singleReferenceInputRefOfType(contractStateClass: Class<T>): StateAndRef<T>
+
+inline fun <reified T : ContractState> LedgerTransaction.singleReferenceInputRefOfType(): StateAndRef<T>
+```
+
+---
+
+### singleReferenceInputOfType *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Obtains a single reference input from a ledger transaction.
+
+```kotlin
+fun <T : ContractState> LedgerTransaction.singleReferenceInputOfType(contractStateClass: Class<T>): T
+
+inline fun <reified T : ContractState> LedgerTransaction.singleReferenceInputOfType(): T
+```
+
+---
+
+### singleOutputRefOfType *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Obtains a single output ref from a ledger transaction.
+
+```kotlin
+fun <T : ContractState> LedgerTransaction.singleOutputRefOfType(contractStateClass: Class<T>): StateAndRef<T>
+
+inline fun <reified T : ContractState> LedgerTransaction.singleOutputRefOfType(): StateAndRef<T>
+```
+
+---
+
+### singleOutputOfType *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Obtains a single output from a ledger transaction.
+
+```kotlin
+fun <T : ContractState> LedgerTransaction.singleOutputOfType(contractStateClass: Class<T>): T
+
+inline fun <reified T : ContractState> LedgerTransaction.singleOutputOfType(): T
+```
+
+---
+
+### singleOutputOfType *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Obtains a single output from a ledger transaction.
+
+```kotlin
+fun <T : ContractState> LedgerTransaction.singleOutputOfType(contractStateClass: Class<T>): T
+
+inline fun <reified T : ContractState> LedgerTransaction.singleOutputOfType(): T
+```
+
+---
+
+### singleCommandOfType *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Obtains a single command from a ledger transaction.
+
+```kotlin
+fun <T : CommandData> LedgerTransaction.singleCommandOfType(commandClass: Class<T>): Command<T>
+
+inline fun <reified T : CommandData> LedgerTransaction.singleCommandOfType(): Command<T>
+```
+
+---
+
+### sessionsFor *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Obtains a collection of sessions for the specified parties, or state participants.
+
+```kotlin
+fun Iterable<FlowSession>.sessionsFor(parties: Iterable<AbstractParty>): Set<FlowSession>
+
+fun Iterable<FlowSession>.sessionsFor(vararg parties: AbstractParty): Set<FlowSession>
+
+fun Iterable<FlowSession>.sessionsFor(vararg states: ContractState): Set<FlowSession>
+```
+
+---
+
+### sessionFor *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Obtains a session for the specified party.
+
+```kotlin
+fun Iterable<FlowSession>.sessionFor(party: AbstractParty): FlowSession
+```
+
+---
+
+### sessionsExcluding *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Obtains a collection of sessions excluding those for the specified parties, or state participants.
+
+```kotlin
+fun Iterable<FlowSession>.sessionsExcluding(parties: Iterable<AbstractParty>): Set<FlowSession>
+
+fun Iterable<FlowSession>.sessionsExcluding(vararg parties: AbstractParty): Set<FlowSession>
+
+fun Iterable<FlowSession>.sessionsExcluding(vararg states: ContractState): Set<FlowSession>
+```
+
+---
+
+### cast *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Casts an iterable of `StateAndRef` of an unknown `ContractState` to a list of `StateAndRef` of type `T`.
+
+```kotlin
+inline fun <reified T> Iterable<StateAndRef<*>>.cast(): List<StateAndRef<T>> where T : ContractState
+```
+
+---
+
+## Version 1.0.0
+
+### ChainState *Interface*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Defines a Corda chain state.
+
+```kotlin
+interface ChainState
+```
+
+#### Remarks
+
+A chain state is similar to a `LinearState` in that it represents a set of state transitions. Chain states adopt a concept similar to a blockchain, where each new state transition references the previous one by its `StateRef`, or `null` if it's the first state in the chain.
+
+---
+
+### Hashable *Interface*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Defines an object that can produce a unique hash.
+
+```kotlin
+interface Hashable
+```
+
+#### Remarks
+
+When used in conjunction with the `ChainState` interface, this can be useful for modelling states that always produce a unique hash for every state transition.
+
+---
+
+### Resolvable *Interface*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Defines an object which resolves a `ContractState`.
+
+```kotlin
+interface Resolvable<T> where T : ContractState
+```
+
+#### Remarks
+
+This is the fundamental principle on which state pointers are implemented in Corda; their ability to maintain and resolve a reference back to another known state in the vault. The implementation here is flexible and open, allowing developers to model resolvable as a design pattern, rather than as a strict implementation detail.
+
+---
+
+### TransactionResolution *Enum Class*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Defines how to resolve states from a transaction, and is used by the `Resolvable` interface.
+
+```kotlin
+enum class TransactionResolution
+```
+
+#### Entries
+
+| Name          | Description                                                  |
+| ------------- | ------------------------------------------------------------ |
+| **INPUT**     | Defines that a resolvable should resolve from a transaction input state. |
+| **OUTPUT**    | Defines that a resolvable should resolve from a transaction output state. |
+| **REFERENCE** | Defines that a resolvable should resolve from a transaction reference input state. |
+
+---
+
+### owningKeys *Extension Property*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Gets the owning keys from an `Iterable` of `AbstractParty`.
+
+```kotlin
+val Iterable<AbstractParty>.owningKeys: Set<PublicKey> 
+```
+
+---
+
+### participantHash *Extension Property*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Gets a hash from an `Iterable` of `AbstractParty`.
+
+```kotlin
+val Iterable<AbstractParty>.participantHash: SecureHash
+```
+
+#### Remarks
+
+This extension property can be used to determine whether the participants of a state are unique, regardless of the ordering of those participants.
+
+---
+
+### isPointingTo *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Determines whether the current state is pointing to the specified `StateRef`, or `StateAndRef`.
+
+```kotlin
+fun <T> T.isPointingTo(stateRef: StateRef): Boolean where T : ChainState
+fun <T> T.isPointingTo(stateAndRef: StateAndRef<T>): Boolean where T : ChainState
+```
+
+---
+
+### cast *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Casts a `StateAndRef` of an unknown `ContractState` to a `StateAndRef` of type `T`.
+
+```kotlin
+inline fun <reified T> StateAndRef<*>.cast(): StateAndRef<T> where T : ContractState
+```
+
+---
+
+### FindStateFlow *Abstract Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents the base class for implementing a query that finds a single state.
+
+```kotlin
+abstract class FindStateFlow<T> : FlowLogic<StateAndRef<T>?>() where T : ContractState
+```
+
+#### Remarks
+
+This design pattern enables developers to be more consistent in their approach to performing vault queries, regardless of whether they're being performed from within the node (using `ServiceHub`) or from an RPC client (using `CordaRPCOps`).
+
+---
+
+### FindStatesFlow *Abstract Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents the base class for implementing a query that finds multiple states.
+
+```kotlin
+abstract class FindStatesFlow<T> : FlowLogic<List<StateAndRef<T>>>() where T : ContractState
+```
+
+#### Remarks
+
+This design pattern enables developers to be more consistent in their approach to performing vault queries, regardless of whether they're being performed from within the node (using `ServiceHub`) or from an RPC client (using `CordaRPCOps`).
+
+---
+
+### Message *Open Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a transient message.
+
+```kotlin
+open class Message<T>(val data: T, val id: UUID = UUID.randomUUID()) where T : Any
+```
+
+---
+
+### MessageAcknowledgement *Open Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents an acknowledgement to a transient message.
+
+```kotlin
+open class MessageAcknowledgement(val id: UUID)
+```
+
+---
+
+### SendMessageFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that sends a message to the specified counter-parties.
+
+```kotlin
+class SendMessageFlow<T>(
+    private val message: T,
+    private val sessions: Set<FlowSession>,
+    private val requestAcknowledgement: Boolean = false,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Map<Party, MessageAcknowledgement>>() where T : Message<*>
+```
+
+#### Remarks
+
+Use the built-in `SendMessageFlow.Initiator` class in order to use this class as an initiating flow.
+
+```kotlin
+@StartableByRPC
+@StartableByService
+@InitiatingFlow
+class Initiator<T>(
+    private val message: T,
+    private val counterparties: Collection<Party>
+) : FlowLogic<Map<Party, MessageAcknowledgement>>() where T : Message<*>
+```
+
+---
+
+### ReceiveMessageFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that receives a message from the specified counter-parties.
+
+```kotlin
+class ReceiveMessageFlow<T>(
+    private val session: FlowSession,
+    private val requestAcknowledgement: Boolean = false,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Pair<Party, T>>() where T : Message<*>
+```
+
+#### Remarks
+
+Use the built-in `ReceiveMessageFlow.Receiver` class in order to register it as an initiated-by flow, and listen for message results.
+
+```kotlin
+@InitiatedBy(SendMessageFlow.Initiator::class)
+class Receiver<T>(private val session: FlowSession) : FlowLogic<Pair<Party, T>>() where T : Message<*>
+```
+
+---
+
+### SendMessageAcknowledgementFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that sends a message acknowledgement to the specified counter-party.
+
+```kotlin
+class SendMessageAcknowledgementFlow<T>(
+    private val acknowledgement: T,
+    private val session: FlowSession,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Unit>() where T : MessageAcknowledgement
+```
+
+#### Remarks
+
+Use the built-in `SendMessageAcknowledgementFlow.Initiator` class in order to use this class as an initiating flow.
+
+```kotlin
+@StartableByRPC
+@StartableByService
+@InitiatingFlow
+class Initiator<T>(
+    private val acknowledgement: T,
+    private val counterparty: Party
+) : FlowLogic<Unit>() where T : MessageAcknowledgement
+```
+
+---
+
+### ReceiveMessageAcknowledgementFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that receives a message acknowledgement from the specified counter-party.
+
+```kotlin
+class ReceiveMessageAcknowledgementFlow<T>(
+    private val session: FlowSession,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Pair<Party, T>>()
+```
+
+#### Remarks
+
+Use the built-in `ReceiveMessageAcknowledgementFlow.Receiver` class in order to register it as an initiated-by flow, and listen for message acknowledgement results.
+
+```kotlin
+@InitiatedBy(SendMessageAcknowledgementFlow.Initiator::class)
+class Receiver<T>(private val session: FlowSession) : FlowLogic<Pair<Party, T>>() where T : MessageAcknowledgement
+```
+
+---
+
+### TransactionNote *Data Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a transaction note.
+
+```kotlin
+data class TransactionNote(val transactionId: SecureHash, val text: String)
+```
+
+---
+
+### SendTransactionNoteFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that sends a transaction note to the specified counter-parties.
+
+```kotlin
+class SendTransactionNoteFlow(
+    private val transactionNote: TransactionNote,
+    private val sessions: Collection<FlowSession>,
+    private val addNoteToTransaction: Boolean = true,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Unit>()
+```
+
+#### Remarks
+
+Use the built-in `SendTransactionNoteFlow.Initiator` class in order to use this class as an initiating flow.
+
+```kotlin
+@StartableByRPC
+@StartableByService
+@InitiatingFlow
+class Initiator(
+    private val transactionNote: TransactionNote,
+    private val counterparties: Iterable<Party>,
+    private val addNoteToTransaction: Boolean = true
+) : FlowLogic<Unit>()
+```
+
+---
+
+### ReceiveTransactionNoteFlow *Class*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Represents a sub-flow that receives a transaction note from the specified counter-party.
+
+```kotlin
+class ReceiveTransactionNoteFlow(
+    private val session: FlowSession,
+    private val persist: Boolean = true,
+    private val expectedTransactionId: SecureHash? = null,
+    override val progressTracker: ProgressTracker = tracker()
+) : FlowLogic<Pair<Party, TransactionNote>>()
+```
+
+#### Remarks
+
+Use the built-in `ReceiveTransactionNoteFlow.Receiver` class in order to register it as an initiated-by flow, and listen for transaction note results.
+
+```kotlin
+@InitiatedBy(SendTransactionNoteFlow.Initiator::class)
+class Receiver(private val session: FlowSession) : FlowLogic<Pair<Party, TransactionNote>>()
+```
+
+---
+
+### firstNotary *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Gets the first available notary.
+
+```kotlin
+val FlowLogic<*>.firstNotary: Party
+```
+
+#### Remarks
+
+This extension property will throw a `NoSuchElementException` if there are no available notaries.
+
+---
+
+### randomNotary *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Gets a randomly available notary.
+
+```kotlin
+val FlowLogic<*>.randomNotary: Party
+```
+
+#### Remarks
+
+This extension property will throw a `NoSuchElementException` if there are no available notaries.
+
+---
+
+### getPreferredNotary *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Gets the preferred notary from the CorDapp config, or alternatively a default notary in the event that a preferred notary has not been specified in the CorDapp config.
+
+```kotlin
+@Suspendable
+fun FlowLogic<*>.getPreferredNotary(
+    serviceHub: ServiceHub = this.serviceHub,
+    defaultSelector: (ServiceHub) -> Party = { firstNotary }
+): Party
+```
+
+#### Remarks
+
+This extension property will throw an `IllegalArgumentException` if the preferred notary cannot be found in the network map cache.
+
+---
+
+### currentStep *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Sets the current progress tracker step.
+
+```kotlin
+@Suspendable
+fun FlowLogic<*>.currentStep(step: Step, log: Boolean = true, additionalLogInfo: String? = null)
+```
+
+---
+
+### initiateFlows *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Initiates flow sessions for the specified parties and/or states, except for identities that belong to the local node, since flow sessions are not required locally.
+
+```kotlin
+@Suspendable
+fun FlowLogic<*>.initiateFlows(vararg parties: AbstractParty): Set<FlowSession>
+
+@Suspendable
+fun FlowLogic<*>.initiateFlows(vararg states: ContractState): Set<FlowSession>
+
+@Suspendable
+fun FlowLogic<*>.initiateFlows(parties: Iterable<AbstractParty>, vararg states: ContractState): Set<FlowSession>
+```
+
+---
+
+### checkSufficientSessions *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Checks that sufficient flow sessions have been provided for the specified states, of from the input and output states of a transaction builder.
+
+```kotlin
+@Suspendable
+fun FlowLogic<*>.checkSufficientSessions(sessions: Iterable<FlowSession>, states: Iterable<ContractState>)
+
+@Suspendable
+fun FlowLogic<*>.checkSufficientSessions(sessions: Iterable<FlowSession>, vararg states: ContractState)
+
+@Suspendable
+fun FlowLogic<*>.checkSufficientSessions(sessions: Iterable<FlowSession>, transaction: TransactionBuilder)
+```
+
+#### Remarks
+
+Assuming that the specified states will be used as input or output states in a transaction, this function will extract a set of all state participants, excluding identities owned by the initiating node, and then check that a flow session exists for each participant.
+
+---
+
+### findTransaction *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Finds a recorded transaction in the vault for the specified transaction hash.
+
+```kotlin
+@Suspendable
+fun FlowLogic<*>.findTransaction(transactionHash: SecureHash): SignedTransaction
+
+@Suspendable
+fun FlowLogic<*>.findTransaction(stateRef: StateRef): SignedTransaction
+
+@Suspendable
+fun FlowLogic<*>.findTransaction(stateAndRef: StateAndRef<*>): SignedTransaction
+```
+
+---
+
+### DEFAULT_SORTING *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+The default sorting order.
+
+```kotlin
+val DEFAULT_SORTING: Sort
+```
+
+---
+
+### DEFAULT_PAGE_SPECIFICATION *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+The default page specification.
+
+```kotlin
+val DEFAULT_PAGE_SPECIFICATION: PageSpecification
+```
+
+---
+
+### MAXIMUM_PAGE_SPECIFICATION *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+The maximum page specification.
+
+```kotlin
+val MAXIMUM_PAGE_SPECIFICATION: PageSpecification
+```
+
+---
+
+### andWithExpressions *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Builds a custom query criteria. This combines all non-null query expressions using logical AND.
+
+```kotlin
+fun <T : StatePersistable> QueryCriteria.VaultQueryCriteria.andWithExpressions(
+    vararg expressions: CriteriaExpression<T, Boolean>?
+): QueryCriteria
+```
+
+---
+
+### orWithExpressions *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+#### Description
+
+Builds a custom query criteria. This combines all non-null query expressions using logical OR.
+
+```kotlin
+fun <T : StatePersistable> QueryCriteria.VaultQueryCriteria.andWithExpressions(
+    vararg expressions: CriteriaExpression<T, Boolean>?
+): QueryCriteria
+```
+
+---
+
+### RPCService *Abstract Class*
+
+**Module:** onixlabs-corda-core-integration
+
+**Package:** io.onixlabs.corda.core.integration
+
+#### Description
+
+Represents the base class for implementing integration services over RPC.
+
+```kotlin
+abstract class RPCService(val rpc: CordaRPCOps)
+```
+
+---
+
+### MessageService *Class*
+
+**Module:** onixlabs-corda-core-integration
+
+**Package:** io.onixlabs.corda.core.integration
+
+#### Description
+
+Represents an RPC service for sending and subscribing to transient messages.
+
+```kotlin
+class MessageService(rpc: CordaRPCOps) : RPCService(rpc)
+```
+
+---
+
+### MessageAcknowledgementService *Class*
+
+**Module:** onixlabs-corda-core-integration
+
+**Package:** io.onixlabs.corda.core.integration
+
+#### Description
+
+Represents an RPC service for sending and subscribing to transience message acknowledgements.
+
+```kotlin
+class MessageAcknowledgementService(rpc: CordaRPCOps) : RPCService(rpc)
+```
+
+---
+
+### TransactionNoteService *Class*
+
+**Module:** onixlabs-corda-core-integration
+
+**Package:** io.onixlabs.corda.core.integration
+
+#### Description
+
+Represents an RPC service for adding, sending and persisting transaction notes.
+
+```kotlin
+class TransactionNoteService(rpc: CordaRPCOps) : RPCService(rpc)
+```
+
+---
+
diff --git a/docs/CHANGELOG-1.2.0.md b/docs/CHANGELOG-1.2.0.md
new file mode 100644
index 0000000..808fb33
--- /dev/null
+++ b/docs/CHANGELOG-1.2.0.md
@@ -0,0 +1,136 @@
+![ONIX Labs](https://raw.githubusercontent.com/onix-labs/onix-labs.github.io/master/content/logo/master_full_md.png)
+
+# Change Log - Version 1.2.0
+
+This document serves as the change log for the ONIXLabs Corda Core API.
+
+## Release Notes
+
+This release contains more APIs for contract design, specifically for verifiable and signed commands.
+
+---
+
+### ContractID *Interface*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Defines an interface which automatically binds a contract ID to a contract class.
+
+```kotlin
+interface ContractID
+```
+
+#### Remarks
+
+Rather than referencing the contract by a string or by its canonical name, implementing `ContractID` on a companion object adds the contract ID to the class for you automatically.
+
+---
+
+### SignatureData *Class*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Represents an array of unsigned bytes, and its signed equivalent.
+
+```kotlin
+@CordaSerializable
+data class SignatureData(
+    private val content: ByteArray, 
+    private val signature: DigitalSignature
+)
+```
+
+---
+
+### SignedCommandData *Interface*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Defines a contract command that must include a signature.
+
+```kotlin
+interface SignedCommandData : CommandData
+```
+
+#### Remarks
+
+This can be used within a contract to check that a particular contract participant signed over the command; usually the transaction initiator.
+
+---
+
+### VerifiedCommandData *Interface*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Defines a contract command that can verify a ledger transaction.
+
+```kotlin
+interface VerifiedCommandData : CommandData
+```
+
+#### Remarks
+
+Rather than commands simply being marker objects to determine which verification to execute, this leans towards the single responsibility principle, whereby each command is responsible for its verification.
+
+---
+
+### cast *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Casts a `StateAndRef` of an unknown `ContractState` to a `StateAndRef` of type `T`.
+
+```kotlin
+fun <T> StateAndRef<*>.cast(contractStateClass: Class<T>): StateAndRef<T> where T : ContractState
+
+inline fun <reified T> StateAndRef<*>.cast(): StateAndRef<T> where T : ContractState
+```
+
+>   🔵 **INFORMATION**
+>
+>   This API exists in version 1.0.0 but only using reified generics.
+
+---
+
+### cast *Extension Function*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Casts an iterable of `StateAndRef` of an unknown `ContractState` to a list of `StateAndRef` of type `T`.
+
+```kotlin
+fun <T> Iterable<StateAndRef<*>>.cast(contractStateClass: Class<T>): List<StateAndRef<T>> where T : ContractState
+
+inline fun <reified T> Iterable<StateAndRef<*>>.cast(): List<StateAndRef<T>> where T : ContractState
+```
+
+>   🔵 **INFORMATION**
+>
+>   This API exists in version 1.1.0 but only using reified generics.
+
+---
+
diff --git a/docs/CHANGELOG-2.0.0.md b/docs/CHANGELOG-2.0.0.md
new file mode 100644
index 0000000..30930d3
--- /dev/null
+++ b/docs/CHANGELOG-2.0.0.md
@@ -0,0 +1,922 @@
+![ONIX Labs](https://raw.githubusercontent.com/onix-labs/onix-labs.github.io/master/content/logo/master_full_md.png)
+
+# Change Log - Version 2.0.0
+
+This document serves as the change log for the ONIXLabs Corda Core API.
+
+## Release Notes
+
+#### 🔴 WARNING
+
+**This release contains breaking changes from version 1.2.0 and is not backwards compatible.**
+
+-   `FindStateFlow<T>` and `FindStatesFlow<T>` have been removed in favour of using the new vault query service and query DSL.
+-   `Resolvable<T>` has been refactored to allow state resolution of sungular (one-to-one) and plural (one-to-many) contract states (see below).
+
+#### 🔵 INFORMATION
+
+As of version 1.0.0, packaged releases of this API has been signed with the ONIXLabs production signing key. Historically, clones of this repository would have failed to build, since the ONIXLabs production signing key is a secret. Version 2.0.0 ships with the ONIXLabs developer key, allowing this repository to be cloned, built and tested locally.
+
+As of version 2.0.0 this project contains test CorDapp modules in order to thoroughly test and exercise the API surface, as opposed to limited tests per module.
+
+---
+
+### getArgumentsTypes _Extension Function_
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core
+
+Gets the argument types from a generic superclass.
+
+```kotlin
+fun Class<*>.getArgumentTypes(): List<Type>
+```
+
+---
+
+### getArgumentType _Extension Function_
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core
+
+Gets an argument type from a generic superclass.
+
+```kotlin
+fun Class<*>.getArgumentType(index: Int): Type
+```
+
+---
+
+### toClass _Extension Function_
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core
+
+Converts a type to a class.
+
+```kotlin
+fun Type.toClass(): Class<*>
+```
+
+---
+
+### toTypedClass _Extension Function_
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core
+
+Converts a type to a class.
+
+```kotlin
+fun <T> Type.toTypedClass(): Class<T>
+```
+
+---
+
+### AbstractPluralResolvable _Class_
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+Represents the base class for implementing plural (one-to-many) contract state resolvers.
+
+```kotlin
+abstract class AbstractPluralResolvable<T> : PluralResolvable<T> where T : ContractState
+```
+
+#### Remarks
+
+Corda states are persisted to a relational database, however due to the nature of the ledger and the way states are created, evolved and spent, it's hard to model relational data with states. This brings Corda one step closer, allowing Corda states to model one-to-many relationships with other Corda states. To model a one-to-one state relationship, see `SingularResolvable<T>` and `AbstractSingularResolvable<T>`.
+
+---
+
+### AbstractSingularResolvable _Class_
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+Represents the base class for implementing singular (one-to-one) contract state resolvers.
+
+```kotlin
+abstract class AbstractSingularResolvable<T> : SingularResolvable<T> where T : ContractState
+```
+
+#### Remarks
+
+Corda states are persisted to a relational database, however due to the nature of the ledger and the way states are created, evolved and spent, it's hard to model relational data with states. This brings Corda one step closer, allowing Corda states to model one-to-one relationships with other Corda states. To model a one-to-many state relationship, see `PluralResolvable<T>` and `AbstractPluralResolvable<T>`.
+
+---
+
+### PluralResolvable _Interface_
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+Defines an object which resolves a collection of `ContractState`.
+
+```kotlin
+interface PluralResolvable<T> where T : ContractState
+```
+
+#### Remarks
+
+An abstract implementation of this interface can be found in `AbstractPluralResolvable<T>`.
+
+---
+
+### SingularResolvable _Interface_
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+Defines an object which resolves a `ContractState`.
+
+```kotlin
+interface SingularResolvable<T> where T : ContractState
+```
+
+#### Remarks
+
+An abstract implementation of this interface can be found in `AbstractSingularResolvable<T>`.
+
+>   🔴 **WARNING**
+>
+>   **This API is not backwards compatible!**
+>
+>   This API exists in version 1.0.0 and was originally called `Resolvable<T>` however in version 2.0.0 the model has been extended to support one-to-one, and one-to-many relationships.
+
+---
+
+### SignatureData *Class*
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+#### Description
+
+Represents an array of unsigned bytes, and its signed equivalent.
+
+```kotlin
+@CordaSerializable
+data class SignatureData(
+    val content: ByteArray, 
+    val signature: DigitalSignature
+)
+```
+
+>   🔵  **INFORMATION**
+>
+>   This API exists in version 1.2.0 however in version 2.0.0 the `content` and `signature` properties are public, where they were originally private.
+
+---
+
+### allowCommands _Extension Function_
+
+**Module:** onixlabs-corda-core-contract
+
+**Package:** io.onixlabs.corda.core.contract
+
+Provides utility for `VerifiedCommandData` implementations, specifying which commands are allowed within a contract. This function will verify allowed commands, or throw an `IllegalArgumentException` exception if the command is not allowed.
+
+```kotlin
+fun <T : VerifiedCommandData> LedgerTransaction.allowCommands(commandClass: Class<T>, vararg allowed: Class<out T>)
+
+inline fun <reified T : VerifiedCommandData> LedgerTransaction.allowCommands(vararg allowed: Class<out T>
+```
+
+---
+
+### QueryDsl _Class_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.workflow
+
+Represents a DSL for building vault queries.
+
+```kotlin
+class QueryDsl<T : ContractState> internal constructor(
+    private var queryCriteria: QueryCriteria,
+    private var page: PageSpecification,
+    private var sort: Sort
+)
+```
+
+---
+
+### QueryDslContext _Annotation Class_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Specifies that a function is contextually party of the query DSL.
+
+```kotlin
+@DslMarker
+annotation class QueryDslMarker
+```
+
+---
+
+### VaultAdapter _Abstract Class_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Represents the base class for implementing vault adapters. This uses the adapter design pattern to unify the vault query API between `ServiceHub` and `CordaRPCOps` implementations.
+
+```kotlin
+internal abstract class VaultAdapter<T : ContractState>(
+  protected val contractStateType: Class<T>
+)
+```
+
+---
+
+### VaultAdapterCordaRPCOps _Class_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Represents a vault service adapter implementation for `CordaRPCOps`.
+
+```kotlin
+internal class VaultAdapterCordaRPCOps<T : ContractState>(
+    private val cordaRPCOps: CordaRPCOps,
+    contractStateType: Class<T>
+) : VaultAdapter<T>(contractStateType)
+```
+
+---
+
+### VaultServiceAdapterServiceHub _Class_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Represents a vault service adapter implementation for `ServiceHub`.
+
+```kotlin
+internal class VaultAdapterServiceHub<T : ContractState>(
+    private val serviceHub: ServiceHub,
+    contractStateType: Class<T>
+) : VaultAdapter<T>(contractStateType)
+```
+
+---
+
+### VaultObservable _Class_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Represents an observable vault state.
+
+```kotlin
+@CordaSerializable
+class VaultObservable<T : ContractState>(
+    val state: TransactionState<T>,
+    val ref: StateRef,
+    val status: Vault.StateStatus,
+    val flowId: UUID?
+)
+```
+
+---
+
+### VaultSequence _Class_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Represents a lazily evaluated sequence of vault query results.
+
+```kotlin
+class VaultSequence<T : ContractState> internal constructor(
+    private val service: VaultService<T>,
+    private val criteria: QueryCriteria,
+    private val paging: PageSpecification,
+    private val sorting: Sort
+) : Sequence<StateAndRef<T>>
+```
+
+---
+
+### VaultService _Class_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Represents a service for managing vault querying and tracking.
+
+```kotlin
+class VaultService<T : ContractState> private constructor(
+    private val adapter: VaultAdapter<T>,
+    internal val contractStateType: Class<T>
+)
+```
+
+---
+
+### vaultServiceFor _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Creates a vault service, bound to the specified `ContractState` type. This allows vault services to be created from either `CordaRPCOps` or `ServiceHub` instances.
+
+```kotlin
+inline fun <reified T : ContractState> CordaRPCOps.vaultServiceFor(): VaultService<T>
+
+inline fun <reified T : ContractState> ServiceHub.vaultServiceFor(): VaultService<T>
+```
+
+---
+
+### vaultQuery _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Creates a `QueryCriteria` using the Query DSL.
+
+```kotlin
+fun <T : ContractState> vaultQuery(
+    contractStateType: Class<T>,
+    action: QueryDsl<T>.() -> Unit
+): QueryCriteria
+
+inline fun <reified T : ContractState> vaultQuery(
+    noinline action: QueryDsl<T>.() -> Unit
+): QueryCriteria
+```
+
+---
+
+### any _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Determines whether the sequence contains any elements.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.any(
+  criteria: QueryCriteria,
+  paging: PageSpecification,
+  sorting: Sort
+): Boolean
+
+fun <T : ContractState> VaultService<T>.any(
+  action: QueryDsl<T>.() -> Unit
+): Boolean
+```
+
+---
+
+### count _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Counts the number of elements in a sequence.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.count(
+  criteria: QueryCriteria,
+  paging: PageSpecification,
+  sorting: Sort
+): Int
+
+fun <T : ContractState> VaultService<T>.count(
+  action: QueryDsl<T>.() -> Unit
+): Int
+```
+
+---
+
+### filter _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Filters a sequence of elements based on the specified query criteria.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.filter(
+    criteria: QueryCriteria,
+    paging: PageSpecification,
+    sorting: Sort
+): VaultSequence<T>
+
+fun <T : ContractState> VaultService<T>.filter(
+  action: QueryDsl<T>.() -> Unit
+): VaultSequence<T> 
+```
+
+---
+
+### first _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Obtains the first element of a sequence.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.first(
+    criteria: QueryCriteria,
+    paging: PageSpecification,
+    sorting: Sort
+): StateAndRef<T>
+
+fun <T : ContractState> VaultService<T>.first(
+  action: QueryDsl<T>.() -> Unit
+): StateAndRef<T>
+```
+
+---
+
+### firstOrNull _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Obtains the first element of a sequence, or null if no element is found.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.firstOrNull(
+    criteria: QueryCriteria,
+    paging: PageSpecification,
+    sorting: Sort
+): StateAndRef<T>
+
+fun <T : ContractState> VaultService<T>.firstOrNull(
+  action: QueryDsl<T>.() -> Unit
+): StateAndRef<T>
+```
+
+---
+
+### last _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Obtains the last element of a sequence.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.last(
+    criteria: QueryCriteria,
+    paging: PageSpecification,
+    sorting: Sort
+): StateAndRef<T>
+
+fun <T : ContractState> VaultService<T>.last(
+  action: QueryDsl<T>.() -> Unit
+): StateAndRef<T>
+```
+
+---
+
+### lastOrNull _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Obtains the last element of a sequence, or null if no element is found.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.lastOrNull(
+    criteria: QueryCriteria,
+    paging: PageSpecification,
+    sorting: Sort
+): StateAndRef<T>
+
+fun <T : ContractState> VaultService<T>.lastOrNull(
+  action: QueryDsl<T>.() -> Unit
+): StateAndRef<T>
+```
+
+---
+
+### single _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Obtains a single, specific element of a sequence.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.single(
+    criteria: QueryCriteria,
+    paging: PageSpecification,
+    sorting: Sort
+): StateAndRef<T>
+
+fun <T : ContractState> VaultService<T>.single(
+  action: QueryDsl<T>.() -> Unit
+): StateAndRef<T>
+```
+
+---
+
+### singleOrNull _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Obtains a single, specific element of a sequence, or null if no element is found.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.singleOrNull(
+    criteria: QueryCriteria,
+    paging: PageSpecification,
+    sorting: Sort
+): StateAndRef<T>
+
+fun <T : ContractState> VaultService<T>.singleOrNull(
+  action: QueryDsl<T>.() -> Unit
+): StateAndRef<T>
+```
+
+---
+
+### toList _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Obtains a sequence of elements as a `List`.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.toList(
+    criteria: QueryCriteria,
+    paging: PageSpecification,
+    sorting: Sort
+): List<StateAndRef<T>>
+```
+
+---
+
+### toSet _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Obtains a sequence of elements as a `Set`.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.toSet(
+    criteria: QueryCriteria,
+    paging: PageSpecification,
+    sorting: Sort
+): List<StateAndRef<T>>
+```
+
+---
+
+### subscribe _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Subscribes to vault tracking updates.
+
+```kotlin
+fun <T : ContractState> VaultService<T>.subscribe(
+    criteria: QueryCriteria = defaultTrackingCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING,
+    observer: (VaultObservable<T>) -> Unit
+)
+```
+
+---
+
+### isNull _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with null value.
+
+```kotlin
+fun <T : StatePersistable, P> KProperty1<T, P?>.isNull() : ColumnPredicateExpression<T, P>
+```
+
+---
+
+### isNotNull _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a non-null value.
+
+```kotlin
+fun <T : StatePersistable, P> KProperty1<T, P?>.isNotNull() : ColumnPredicateExpression<T, P>
+```
+
+---
+
+### equalTo _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a value equal to the specified value.
+
+```kotlin
+infix fun <T : StatePersistable, P> KProperty1<T, P?>.equalTo(value: P) : ColumnPredicateExpression<T, P>
+```
+
+---
+
+### notEqualTo _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a value not equal to the specified value.
+
+```kotlin
+infix fun <T : StatePersistable, P> KProperty1<T, P?>.notEqualTo(value: P) : ColumnPredicateExpression<T, P>
+```
+
+---
+
+### greaterThan _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a value greater than to the specified value.
+
+```kotlin
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.greaterThan(value: P) : ColumnPredicateExpression<T, P>
+```
+
+---
+
+### greaterThanOrEqualTo _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a value greater than or equal to to the specified value.
+
+```kotlin
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.greaterThanOrEqualTo(value: P) : ColumnPredicateExpression<T, P>
+```
+
+---
+
+### lessThan _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a value less than to the specified value.
+
+```kotlin
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.lessThan(value: P) : ColumnPredicateExpression<T, P>
+```
+
+---
+
+### lessThanOrEqualTo _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a value less than or equal to to the specified value.
+
+```kotlin
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.lessThanOrEqualTo(value: P) : ColumnPredicateExpression<T, P>
+```
+
+---
+
+### between _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a value between the specified minimum and maximum values.
+
+```kotlin
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.between(range: ClosedRange<P>) : ColumnPredicateExpression<T, P>
+```
+
+---
+
+### like _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a value like the specified value.
+
+```kotlin
+infix fun <T : StatePersistable> KProperty1<T, String?>.like(value: String) : ColumnPredicateExpression<T, String>
+```
+
+---
+
+### notLike _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a value not like the specified value.
+
+```kotlin
+infix fun <T : StatePersistable> KProperty1<T, String?>.notLike(value: String) : ColumnPredicateExpression<T, String>
+```
+
+---
+
+### within _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a value within the specified collection.
+
+```kotlin
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.within(value: Collection<P>) : ColumnPredicateExpression<T, P>
+```
+
+---
+
+### notWithin _Extension Function_
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+Builds a query criterion for a property with a value not within the specified collection.
+
+```kotlin
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.notWithin(value: Collection<P>) : ColumnPredicateExpression<T, P>
+```
+
+---
+
+### DEFAULT_SORTING *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+#### Description
+
+The default sorting order.
+
+```kotlin
+val DEFAULT_SORTING: Sort
+```
+
+>   🔴 **WARNING**
+>
+>   **This API is not backwards compatible!**
+>
+>   This API exists in version 1.0.0 however in version 2.0.0 it has moved from `io.onixlabs.corda.core.workflow` to `io.onixlabs.corda.core.services`.
+
+---
+
+### DEFAULT_PAGE_SPECIFICATION *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+#### Description
+
+The default page specification.
+
+```kotlin
+val DEFAULT_PAGE_SPECIFICATION: PageSpecification
+```
+
+>   🔴 **WARNING**
+>
+>   **This API is not backwards compatible!**
+>
+>   This API exists in version 1.0.0 however in version 2.0.0 it has moved from `io.onixlabs.corda.core.workflow` to `io.onixlabs.corda.core.services`.
+
+---
+
+### MAXIMUM_PAGE_SPECIFICATION *Extension Property*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+#### Description
+
+The maximum page specification.
+
+```kotlin
+val MAXIMUM_PAGE_SPECIFICATION: PageSpecification
+```
+
+>   🔴 **WARNING**
+>
+>   **This API is not backwards compatible!**
+>
+>   This API exists in version 1.0.0 however in version 2.0.0 it has moved from `io.onixlabs.corda.core.workflow` to `io.onixlabs.corda.core.services`.
+
+---
+
+### andWithExpressions *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+#### Description
+
+Builds a custom query criteria. This combines all non-null query expressions using logical AND.
+
+```kotlin
+fun <T : StatePersistable> QueryCriteria.VaultQueryCriteria.andWithExpressions(
+    vararg expressions: CriteriaExpression<T, Boolean>?
+): QueryCriteria
+```
+
+>   🔴 **WARNING**
+>
+>   **This API is not backwards compatible!**
+>
+>   This API exists in version 1.0.0 however in version 2.0.0 it has moved from `io.onixlabs.corda.core.workflow` to `io.onixlabs.corda.core.services`.
+
+---
+
+### orWithExpressions *Extension Function*
+
+**Module:** onixlabs-corda-core-workflow
+
+**Package:** io.onixlabs.corda.core.services
+
+#### Description
+
+Builds a custom query criteria. This combines all non-null query expressions using logical OR.
+
+```kotlin
+fun <T : StatePersistable> QueryCriteria.VaultQueryCriteria.andWithExpressions(
+    vararg expressions: CriteriaExpression<T, Boolean>?
+): QueryCriteria
+```
+
+>   🔴 **WARNING**
+>
+>   **This API is not backwards compatible!**
+>
+>   This API exists in version 1.0.0 however in version 2.0.0 it has moved from `io.onixlabs.corda.core.workflow` to `io.onixlabs.corda.core.services`.
+
+---
+
diff --git a/docs/CHANGELOG-TEMPLATE.md b/docs/CHANGELOG-TEMPLATE.md
new file mode 100644
index 0000000..08d8ca3
--- /dev/null
+++ b/docs/CHANGELOG-TEMPLATE.md
@@ -0,0 +1,30 @@
+![ONIX Labs](https://raw.githubusercontent.com/onix-labs/onix-labs.github.io/master/content/logo/master_full_md.png)
+
+# Change Log - Version 0.0.0
+
+This document serves as the change log for the ONIXLabs Corda Core API.
+
+## Release Notes
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+
+---
+
+### TypeName _Declaration_
+
+**Module:** onixlabs-corda-core-modulename
+
+**Package:** io.onixlabs.corda.core.packagename
+
+Description of the type or feature.
+
+```kotlin
+class TypeName
+```
+
+#### Remarks
+
+This extension property can be used to determine whether the participants of a state are unique, regardless of the ordering of those participants.
+
+---
+
diff --git a/gradle.properties b/gradle.properties
index 3a99098..8000e82 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,5 +1,9 @@
 name=onixlabs-corda-core
 group=io.onixlabs
 version=0.1
+
 kotlin.incremental=false
 kotlin.code.style=official
+
+onixlabs.development.jarsign.keystore=../lib/onixlabs.development.pkcs12
+onixlabs.development.jarsign.password=5891f47942424d2acbe108691fdb5ba258712fca7e4762be4327241ebf3dbfa3
\ No newline at end of file
diff --git a/lib/onixlabs.development.jks b/lib/onixlabs.development.jks
new file mode 100644
index 0000000..9d72c5a
Binary files /dev/null and b/lib/onixlabs.development.jks differ
diff --git a/lib/onixlabs.development.pkcs12 b/lib/onixlabs.development.pkcs12
new file mode 100644
index 0000000..9f9f764
Binary files /dev/null and b/lib/onixlabs.development.pkcs12 differ
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/Extensions.Class.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/Extensions.Class.kt
new file mode 100644
index 0000000..b01ecf4
--- /dev/null
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/Extensions.Class.kt
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core
+
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
+
+/**
+ * Gets the argument types from a generic superclass.
+ *
+ * @return Returns a list of generic argument types.
+ * @throws IllegalArgumentException if the superclass is not a [ParameterizedType].
+ */
+fun Class<*>.getArgumentTypes(): List<Type> {
+    val superClass = genericSuperclass
+    return (superClass as? ParameterizedType)?.actualTypeArguments?.toList()
+        ?: throw IllegalArgumentException("Cannot obtain generic argument types from a non-parameterized type.")
+}
+
+/**
+ * Gets an argument type from a generic superclass.
+ *
+ * @param index The index of the argument to get.
+ * @return Returns a list of generic argument types.
+ * @throws IllegalArgumentException if the superclass is not a [ParameterizedType].
+ */
+fun Class<*>.getArgumentType(index: Int): Type {
+    return getArgumentTypes()[index]
+}
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/Extensions.Type.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/Extensions.Type.kt
new file mode 100644
index 0000000..1cd77df
--- /dev/null
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/Extensions.Type.kt
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core
+
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
+import java.lang.reflect.WildcardType
+
+/**
+ * Converts a type to a class.
+ */
+fun Type.toClass(): Class<*> = when (this) {
+    is ParameterizedType -> rawType.toClass()
+    is WildcardType -> this.upperBounds[0].toClass()
+    is Class<*> -> this
+    else -> Class.forName(typeName)
+}
+
+/**
+ * Converts a type to a class.
+ */
+@Suppress("UNCHECKED_CAST")
+fun <T> Type.toTypedClass(): Class<T> {
+    return toClass() as Class<T>
+}
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/AbstractPluralResolvable.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/AbstractPluralResolvable.kt
new file mode 100644
index 0000000..2cae8e9
--- /dev/null
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/AbstractPluralResolvable.kt
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.contract
+
+import io.onixlabs.corda.core.getArgumentType
+import io.onixlabs.corda.core.toTypedClass
+import net.corda.core.contracts.ContractState
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.messaging.CordaRPCOps
+import net.corda.core.node.ServiceHub
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.transactions.LedgerTransaction
+
+/**
+ * Represents the base class for implementing plural (one-to-many) contract state resolvers.
+ *
+ * @param T The underlying [ContractState] type.
+ * @property contractStateType The contract state class to resolve.
+ */
+abstract class AbstractPluralResolvable<T> : PluralResolvable<T> where T : ContractState {
+
+    @Suppress
+    protected val contractStateType: Class<T> = javaClass.getArgumentType(0).toTypedClass()
+    protected abstract val criteria: QueryCriteria
+
+    /**
+     * Resolves a [ContractState] using a [CordaRPCOps] instance.
+     *
+     * @param cordaRPCOps The [CordaRPCOps] instance to use to resolve the state.
+     * @return Returns a list of resolved [ContractState] elements, or an empty list if no matching state is found.
+     */
+    override fun resolve(cordaRPCOps: CordaRPCOps): List<StateAndRef<T>> {
+        return cordaRPCOps.vaultQueryByCriteria(criteria, contractStateType).states
+    }
+
+    /**
+     * Resolves a [ContractState] using a [ServiceHub] instance.
+     *
+     * @param serviceHub The [ServiceHub] instance to use to resolve the state.
+     * @return Returns a list of resolved [ContractState] elements, or an empty list if no matching state is found.
+     */
+    override fun resolve(serviceHub: ServiceHub): List<StateAndRef<T>> {
+        return serviceHub.vaultService.queryBy(contractStateType, criteria).states
+    }
+
+    /**
+     * Resolves a [ContractState] using a [LedgerTransaction] instance.
+     *
+     * @param transaction The [LedgerTransaction] instance to use to resolve the state.
+     * @param resolution The transaction resolution method to use to resolve the [ContractState] instance.
+     * @return Returns a list of resolved [ContractState] elements, or an empty list if no matching state is found.
+     */
+    override fun resolve(transaction: LedgerTransaction, resolution: TransactionResolution): List<StateAndRef<T>> {
+        val states = when (resolution) {
+            TransactionResolution.INPUT -> transaction.inRefsOfType(contractStateType)
+            TransactionResolution.OUTPUT -> transaction.outRefsOfType(contractStateType)
+            TransactionResolution.REFERENCE -> transaction.referenceInputRefsOfType(contractStateType)
+        }
+
+        return states.filter { isPointingTo(it) }
+    }
+}
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/AbstractSingularResolvable.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/AbstractSingularResolvable.kt
new file mode 100644
index 0000000..07314c2
--- /dev/null
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/AbstractSingularResolvable.kt
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.contract
+
+import io.onixlabs.corda.core.getArgumentType
+import io.onixlabs.corda.core.toTypedClass
+import net.corda.core.contracts.ContractState
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.messaging.CordaRPCOps
+import net.corda.core.node.ServiceHub
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.transactions.LedgerTransaction
+
+/**
+ * Represents the base class for implementing singular (one-to-one) contract state resolvers.
+ *
+ * @param T The underlying [ContractState] type.
+ * @property contractStateType The contract state class to resolve.
+ */
+abstract class AbstractSingularResolvable<T> : SingularResolvable<T> where T : ContractState {
+
+    @Suppress
+    protected val contractStateType: Class<T> = javaClass.getArgumentType(0).toTypedClass()
+    protected abstract val criteria: QueryCriteria
+
+    /**
+     * Resolves a [ContractState] using a [CordaRPCOps] instance.
+     *
+     * @param cordaRPCOps The [CordaRPCOps] instance to use to resolve the state.
+     * @return Returns the resolved [ContractState], or null if no matching state is found.
+     */
+    override fun resolve(cordaRPCOps: CordaRPCOps): StateAndRef<T>? {
+        return cordaRPCOps.vaultQueryByCriteria(criteria, contractStateType).states.singleOrNull()
+    }
+
+    /**
+     * Resolves a [ContractState] using a [ServiceHub] instance.
+     *
+     * @param serviceHub The [ServiceHub] instance to use to resolve the state.
+     * @return Returns the resolved [ContractState], or null if no matching state is found.
+     */
+    override fun resolve(serviceHub: ServiceHub): StateAndRef<T>? {
+        return serviceHub.vaultService.queryBy(contractStateType, criteria).states.singleOrNull()
+    }
+
+    /**
+     * Resolves a [ContractState] using a [LedgerTransaction] instance.
+     *
+     * @param transaction The [LedgerTransaction] instance to use to resolve the state.
+     * @param resolution The transaction resolution method to use to resolve the [ContractState] instance.
+     * @return Returns the resolved [ContractState], or null if no matching state is found.
+     */
+    override fun resolve(transaction: LedgerTransaction, resolution: TransactionResolution): StateAndRef<T>? {
+        val states = when (resolution) {
+            TransactionResolution.INPUT -> transaction.inRefsOfType(contractStateType)
+            TransactionResolution.OUTPUT -> transaction.outRefsOfType(contractStateType)
+            TransactionResolution.REFERENCE -> transaction.referenceInputRefsOfType(contractStateType)
+        }
+
+        return states.singleOrNull { isPointingTo(it) }
+    }
+}
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/ChainState.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/ChainState.kt
index ee8ef6d..0a16073 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/ChainState.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/ChainState.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/ContractID.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/ContractID.kt
index 000ce97..6b2b9d3 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/ContractID.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/ContractID.kt
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.onixlabs.corda.core.contract
 
 import net.corda.core.contracts.ContractClassName
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/DummyContract.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/DummyContract.kt
index ac664ff..ea37b2f 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/DummyContract.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/DummyContract.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -16,53 +16,20 @@
 
 package io.onixlabs.corda.core.contract
 
-import net.corda.core.contracts.*
+import net.corda.core.contracts.BelongsToContract
+import net.corda.core.contracts.Contract
+import net.corda.core.contracts.ContractState
 import net.corda.core.identity.AbstractParty
 import net.corda.core.transactions.LedgerTransaction
-import java.security.PublicKey
 
 /**
  * Represents a dummy state and contract that will never be used.
- * This exists for two reasons:
- * 1. So that Corda will load the contract into attachment storage.
- * 2. To test contract interface implementations locally.
+ * It exists only so that Corda will load the contract into attachment storage.
  */
 @Suppress("UNUSED")
-internal class DummyContract : Contract {
-
-    companion object : ContractID
+private class DummyContract : Contract {
+    override fun verify(tx: LedgerTransaction) {}
 
     @BelongsToContract(DummyContract::class)
-    data class DummyState(
-        override val participants: List<AbstractParty> = emptyList(),
-        override val previousStateRef: StateRef? = null
-    ) : ChainState
-
-    override fun verify(tx: LedgerTransaction) {
-        val command = tx.commands.requireSingleCommand<DummyContractCommand>()
-        when (command.value) {
-            is DummyCommand -> command.value.verify(tx, command.signers.toSet())
-            else -> throw IllegalArgumentException("Unrecognised command: ${command.value}.")
-        }
-    }
-
-    interface DummyContractCommand : SignedCommandData, VerifiedCommandData
-
-    class DummyCommand(override val signature: SignatureData) : DummyContractCommand {
-
-        companion object {
-            internal const val CONTRACT_RULE_COMMAND_SIGNED =
-                "On dummy command, the command must be signed by the dummy state participant."
-        }
-
-        override fun verify(transaction: LedgerTransaction, signers: Set<PublicKey>) = requireThat {
-            val state = transaction.singleOutputOfType<DummyState>()
-            val command = transaction.singleCommandOfType<DummyCommand>()
-
-            val key = state.participants.single().owningKey
-            val signature = command.value.signature
-
-            CONTRACT_RULE_COMMAND_SIGNED using (signature.verify(key))
-        }
-    }
+    data class DummyState(override val participants: List<AbstractParty>) : ContractState
 }
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.AbstractParty.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.AbstractParty.kt
index 94b333c..8786f3f 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.AbstractParty.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.AbstractParty.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.ChainState.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.ChainState.kt
index 3e8bf73..10fbed6 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.ChainState.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.ChainState.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.LedgerTransaction.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.LedgerTransaction.kt
index f219b0f..ffdcb26 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.LedgerTransaction.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.LedgerTransaction.kt
@@ -1,9 +1,22 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.onixlabs.corda.core.contract
 
-import net.corda.core.contracts.Command
-import net.corda.core.contracts.CommandData
-import net.corda.core.contracts.ContractState
-import net.corda.core.contracts.StateAndRef
+import net.corda.core.contracts.*
 import net.corda.core.transactions.LedgerTransaction
 
 /**
@@ -152,3 +165,34 @@ fun <T : CommandData> LedgerTransaction.singleCommandOfType(commandClass: Class<
 inline fun <reified T : CommandData> LedgerTransaction.singleCommandOfType(): Command<T> {
     return singleCommandOfType(T::class.java)
 }
+
+/**
+ * Provides utility for [VerifiedCommandData] implementations, specifying which commands are allowed within a contract.
+ * This function will verify allowed commands, or throw an [IllegalArgumentException] exception if the command is not allowed.
+ *
+ * @param T The underlying [VerifiedCommandData] type.
+ * @param commandClass The class of the allowed commands.
+ * @param allowed the allowed commands.
+ * @throws [IllegalArgumentException] if the command is not allowed.
+ */
+fun <T : VerifiedCommandData> LedgerTransaction.allowCommands(commandClass: Class<T>, vararg allowed: Class<out T>) {
+    val command = commands.requireSingleCommand(commandClass)
+
+    if (command.value.javaClass !in allowed) {
+        throw IllegalArgumentException("Unrecognised command: ${command.value.javaClass.canonicalName}.")
+    }
+
+    command.value.verify(this, command.signers.toSet())
+}
+
+/**
+ * Provides utility for [VerifiedCommandData] implementations, specifying which commands are allowed within a contract.
+ * This function will verify allowed commands, or throw an [IllegalArgumentException] exception if the command is not allowed.
+ *
+ * @param T The underlying [VerifiedCommandData] type.
+ * @param allowed the allowed commands.
+ * @throws [IllegalArgumentException] if the command is not allowed.
+ */
+inline fun <reified T : VerifiedCommandData> LedgerTransaction.allowCommands(vararg allowed: Class<out T>) {
+    return allowCommands(T::class.java, *allowed)
+}
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.SingularResolvable.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.SingularResolvable.kt
new file mode 100644
index 0000000..87c0b06
--- /dev/null
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.SingularResolvable.kt
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.contract
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.messaging.CordaRPCOps
+import net.corda.core.node.ServiceHub
+import net.corda.core.transactions.LedgerTransaction
+
+private const val MESSAGE = "The expected state may have not been witnessed, or may have been exited by this node."
+
+/**
+ * Resolves a [ContractState] using a [CordaRPCOps] instance.
+ *
+ * @param cordaRPCOps The [CordaRPCOps] instance to use to resolve the state.
+ * @param message The exception message to throw if the state cannot be resolved.
+ * @return Returns the resolved [ContractState], or throws an exception if the state cannot be resolved.
+ */
+fun <T : ContractState> SingularResolvable<T>.resolveOrThrow(
+    cordaRPCOps: CordaRPCOps,
+    message: () -> String = { MESSAGE }
+): StateAndRef<T> = resolve(cordaRPCOps) ?: throw IllegalArgumentException(message())
+
+/**
+ * Resolves a [ContractState] using a [ServiceHub] instance.
+ *
+ * @param serviceHub The [ServiceHub] instance to use to resolve the state.
+ * @param message The exception message to throw if the state cannot be resolved.
+ * @return Returns the resolved [ContractState], or throws an exception if the state cannot be resolved.
+ */
+fun <T : ContractState> SingularResolvable<T>.resolveOrThrow(
+    serviceHub: ServiceHub,
+    message: () -> String = { MESSAGE }
+): StateAndRef<T> = resolve(serviceHub) ?: throw IllegalArgumentException(message())
+
+/**
+ * Resolves a [ContractState] using a [LedgerTransaction] instance.
+ *
+ * @param transaction The [LedgerTransaction] instance to use to resolve the state.
+ * @param resolution The transaction resolution method to use to resolve the [ContractState] instance.
+ * @param message The exception message to throw if the state cannot be resolved.
+ * @return Returns the resolved [ContractState], or throws an exception if the state cannot be resolved.
+ */
+fun <T : ContractState> SingularResolvable<T>.resolveOrThrow(
+    transaction: LedgerTransaction,
+    resolution: TransactionResolution,
+    message: () -> String = { MESSAGE }
+): StateAndRef<T> = resolve(transaction, resolution) ?: throw IllegalArgumentException(message())
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.StateAndRef.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.StateAndRef.kt
index 3b762c8..16e8f1f 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.StateAndRef.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.StateAndRef.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Hashable.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Hashable.kt
index 49a038a..9bc68bb 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Hashable.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Hashable.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/PluralResolvable.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/PluralResolvable.kt
new file mode 100644
index 0000000..6b3df6e
--- /dev/null
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/PluralResolvable.kt
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.contract
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.messaging.CordaRPCOps
+import net.corda.core.node.ServiceHub
+import net.corda.core.transactions.LedgerTransaction
+
+/**
+ * Defines an object which resolves a collection of [ContractState].
+ *
+ * @param T The underlying [ContractState] type to resolve.
+ */
+interface PluralResolvable<T> where T : ContractState {
+
+    /**
+     * Resolves a [ContractState] using a [CordaRPCOps] instance.
+     *
+     * @param cordaRPCOps The [CordaRPCOps] instance to use to resolve the state.
+     * @return Returns a list of resolved [ContractState] elements, or an empty list if no matching state is found.
+     */
+    fun resolve(cordaRPCOps: CordaRPCOps): List<StateAndRef<T>>
+
+    /**
+     * Resolves a [ContractState] using a [ServiceHub] instance.
+     *
+     * @param serviceHub The [ServiceHub] instance to use to resolve the state.
+     * @return Returns a list of resolved [ContractState] elements, or an empty list if no matching state is found.
+     */
+    fun resolve(serviceHub: ServiceHub): List<StateAndRef<T>>
+
+    /**
+     * Resolves a [ContractState] using a [LedgerTransaction] instance.
+     *
+     * @param transaction The [LedgerTransaction] instance to use to resolve the state.
+     * @param resolution The transaction resolution method to use to resolve the [ContractState] instance.
+     * @return Returns a list of resolved [ContractState] elements, or an empty list if no matching state is found.
+     */
+    fun resolve(transaction: LedgerTransaction, resolution: TransactionResolution): List<StateAndRef<T>>
+
+    /**
+     * Determines whether this [PluralResolvable] is pointing to the specified [StateAndRef] instance.
+     *
+     * @param stateAndRef The [StateAndRef] to determine being pointed to.
+     * @return Returns true if this [PluralResolvable] is pointing to the specified [StateAndRef]; otherwise, false.
+     */
+    fun isPointingTo(stateAndRef: StateAndRef<T>): Boolean
+}
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SignatureData.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SignatureData.kt
index b725c84..61705df 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SignatureData.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SignatureData.kt
@@ -1,13 +1,31 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.onixlabs.corda.core.contract
 
 import net.corda.core.crypto.Crypto
 import net.corda.core.crypto.DigitalSignature
 import net.corda.core.crypto.sign
 import net.corda.core.node.ServiceHub
+import net.corda.core.node.services.KeyManagementService
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.utilities.toBase64
 import java.security.PrivateKey
 import java.security.PublicKey
+import java.security.SignatureException
 import java.util.*
 
 /**
@@ -17,10 +35,13 @@ import java.util.*
  * @property signature The digital signature representing the signed content.
  */
 @CordaSerializable
-data class SignatureData(private val content: ByteArray, private val signature: DigitalSignature) {
+data class SignatureData(val content: ByteArray, val signature: DigitalSignature) {
 
     companion object {
 
+        private const val CANNOT_OBTAIN_PRIVATE_KEY_EXCEPTION =
+            "Failed to obtain a private key matching the specified public key from the key management service."
+
         /**
          * Creates a signature from the specified content and private key.
          *
@@ -33,6 +54,20 @@ data class SignatureData(private val content: ByteArray, private val signature:
             return SignatureData(content, signature)
         }
 
+        /**
+         * Creates a signature from the specified content by resolving the signing key from the service hub.
+         *
+         * @param content The content to sign.
+         * @param publicKey The public key to resolve from the service hub.
+         * @param service The key management service to resolve and sign the signature data.
+         * @return Returns a new signature containing the content and signed data.
+         */
+        fun create(content: ByteArray, publicKey: PublicKey, service: KeyManagementService): SignatureData = try {
+            SignatureData(content, service.sign(content, publicKey).withoutKey())
+        } catch (ex: NoSuchElementException) {
+            throw SignatureException(CANNOT_OBTAIN_PRIVATE_KEY_EXCEPTION, ex)
+        }
+
         /**
          * Creates a signature from the specified content by resolving the signing key from the service hub.
          *
@@ -42,8 +77,7 @@ data class SignatureData(private val content: ByteArray, private val signature:
          * @return Returns a new signature containing the content and signed data.
          */
         fun create(content: ByteArray, publicKey: PublicKey, serviceHub: ServiceHub): SignatureData {
-            val signature = serviceHub.keyManagementService.sign(content, publicKey)
-            return SignatureData(content, signature.withoutKey())
+            return create(content, publicKey, serviceHub.keyManagementService)
         }
     }
 
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SignedCommandData.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SignedCommandData.kt
index 4ef52b4..d777dd6 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SignedCommandData.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SignedCommandData.kt
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.onixlabs.corda.core.contract
 
 import net.corda.core.contracts.CommandData
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Resolvable.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SingularResolvable.kt
similarity index 85%
rename from onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Resolvable.kt
rename to onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SingularResolvable.kt
index 11b3abf..3897119 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Resolvable.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SingularResolvable.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -27,7 +27,7 @@ import net.corda.core.transactions.LedgerTransaction
  *
  * @param T The underlying [ContractState] type to resolve.
  */
-interface Resolvable<T> where T : ContractState {
+interface SingularResolvable<T> where T : ContractState {
 
     /**
      * Resolves a [ContractState] using a [CordaRPCOps] instance.
@@ -55,10 +55,10 @@ interface Resolvable<T> where T : ContractState {
     fun resolve(transaction: LedgerTransaction, resolution: TransactionResolution): StateAndRef<T>?
 
     /**
-     * Determines whether this [Resolvable] is pointing to the specified [StateAndRef] instance.
+     * Determines whether this [SingularResolvable] is pointing to the specified [StateAndRef] instance.
      *
      * @param stateAndRef The [StateAndRef] to determine being pointed to.
-     * @return Returns true if this [Resolvable] is pointing to the specified [StateAndRef]; otherwise, false.
+     * @return Returns true if this [SingularResolvable] is pointing to the specified [StateAndRef]; otherwise, false.
      */
     fun isPointingTo(stateAndRef: StateAndRef<T>): Boolean
 }
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/TransactionResolution.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/TransactionResolution.kt
index f407d87..cd8dd78 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/TransactionResolution.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/TransactionResolution.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/VerifiedCommandData.kt b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/VerifiedCommandData.kt
index 05aef5d..cbac326 100644
--- a/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/VerifiedCommandData.kt
+++ b/onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/VerifiedCommandData.kt
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.onixlabs.corda.core.contract
 
 import net.corda.core.contracts.CommandData
diff --git a/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/ContractTest.kt b/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/ContractTest.kt
deleted file mode 100644
index 5dc0b5d..0000000
--- a/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/ContractTest.kt
+++ /dev/null
@@ -1,30 +0,0 @@
-package io.onixlabs.corda.core.contract
-
-import net.corda.core.node.NotaryInfo
-import net.corda.testing.common.internal.testNetworkParameters
-import net.corda.testing.core.TestIdentity
-import net.corda.testing.node.MockServices
-import org.junit.jupiter.api.BeforeEach
-
-abstract class ContractTest {
-
-    protected companion object {
-        private val cordapps = listOf("io.onixlabs.corda.core.contract")
-        private val contracts = listOf(DummyContract.ID)
-
-        fun keysOf(vararg identities: TestIdentity) = identities.map { it.publicKey }
-    }
-
-    private lateinit var _services: MockServices
-    protected val services: MockServices get() = _services
-
-    @BeforeEach
-    private fun setup() {
-        val networkParameters = testNetworkParameters(
-            minimumPlatformVersion = 8,
-            notaries = listOf(NotaryInfo(NOTARY.party, true))
-        )
-        _services = MockServices(cordapps, IDENTITY_A, networkParameters, IDENTITY_B, IDENTITY_C)
-        contracts.forEach { _services.addMockCordapp(it) }
-    }
-}
diff --git a/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/DummyContractCommandTests.kt b/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/DummyContractCommandTests.kt
deleted file mode 100644
index ed066cc..0000000
--- a/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/DummyContractCommandTests.kt
+++ /dev/null
@@ -1,22 +0,0 @@
-package io.onixlabs.corda.core.contract
-
-import net.corda.core.crypto.SecureHash
-import net.corda.testing.node.ledger
-import org.junit.jupiter.api.Test
-
-class DummyContractCommandTests : ContractTest() {
-
-    @Test
-    fun `On dummy command, the dummy state must be signed by the state participant`() {
-        services.ledger {
-            transaction {
-                val state = DummyContract.DummyState(listOf(IDENTITY_A.party))
-                val content = SecureHash.randomSHA256().bytes
-                val signature = SignatureData.create(content, IDENTITY_B.keyPair.private)
-                output(DummyContract.ID, state)
-                command(keysOf(IDENTITY_A), DummyContract.DummyCommand(signature))
-                failsWith(DummyContract.DummyCommand.CONTRACT_RULE_COMMAND_SIGNED)
-            }
-        }
-    }
-}
diff --git a/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/DummyContractTests.kt b/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/DummyContractTests.kt
deleted file mode 100644
index b684590..0000000
--- a/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/DummyContractTests.kt
+++ /dev/null
@@ -1,20 +0,0 @@
-package io.onixlabs.corda.core.contract
-
-import org.junit.jupiter.api.Test
-import kotlin.test.assertEquals
-
-class DummyContractTests {
-
-    @Test
-    fun `DummyContract ID should be the canonical name of the DummyContract class`() {
-
-        // Arrange
-        val expected = "io.onixlabs.corda.core.contract.DummyContract"
-
-        // Act
-        val actual = DummyContract.ID
-
-        // Assert
-        assertEquals(expected, actual)
-    }
-}
diff --git a/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/MockData.kt b/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/MockData.kt
deleted file mode 100644
index 40f6598..0000000
--- a/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/MockData.kt
+++ /dev/null
@@ -1,10 +0,0 @@
-package io.onixlabs.corda.core.contract
-
-import net.corda.core.identity.CordaX500Name
-import net.corda.testing.core.DUMMY_NOTARY_NAME
-import net.corda.testing.core.TestIdentity
-
-val IDENTITY_A = TestIdentity(CordaX500Name("PartyA", "London", "GB"))
-val IDENTITY_B = TestIdentity(CordaX500Name("PartyB", "New York", "US"))
-val IDENTITY_C = TestIdentity(CordaX500Name("PartyC", "Paris", "FR"))
-val NOTARY = TestIdentity(DUMMY_NOTARY_NAME)
diff --git a/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/MessageAcknowledgementService.kt b/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/MessageAcknowledgementService.kt
index 60012b8..33680f7 100644
--- a/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/MessageAcknowledgementService.kt
+++ b/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/MessageAcknowledgementService.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/MessageService.kt b/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/MessageService.kt
index e25b878..42a59b9 100644
--- a/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/MessageService.kt
+++ b/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/MessageService.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/RPCService.kt b/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/RPCService.kt
index e4b3207..6eadf9b 100644
--- a/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/RPCService.kt
+++ b/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/RPCService.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/TransactionNoteService.kt b/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/TransactionNoteService.kt
index 452d533..82c5944 100644
--- a/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/TransactionNoteService.kt
+++ b/onixlabs-corda-core-integration/src/main/kotlin/io/onixlabs/corda/core/integration/TransactionNoteService.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Defaults.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Defaults.kt
new file mode 100644
index 0000000..1656993
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Defaults.kt
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.node.services.vault.*
+
+/**
+ * The default sorting order.
+ */
+val DEFAULT_SORTING: Sort get() = Sort(emptySet())
+
+/**
+ * The default page specification.
+ */
+val DEFAULT_PAGE_SPECIFICATION: PageSpecification get() = PageSpecification(DEFAULT_PAGE_NUM, DEFAULT_PAGE_SIZE)
+
+/**
+ * The maximum page specification.
+ */
+val MAXIMUM_PAGE_SPECIFICATION: PageSpecification get() = PageSpecification(DEFAULT_PAGE_NUM, MAX_PAGE_SIZE)
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.CordaRPCOps.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.CordaRPCOps.kt
new file mode 100644
index 0000000..287648f
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.CordaRPCOps.kt
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.messaging.CordaRPCOps
+
+/**
+ * Creates a vault service, bound to the specified [ContractState] type.
+ *
+ * @param T The underlying [ContractState] type to bind the vault service to.
+ * @param contractStateType The [Class] of the [ContractState] type to bind the vault service to.
+ * @return Returns a [VaultService] instance bound to the underlying [ContractState] type.
+ */
+fun <T : ContractState> CordaRPCOps.vaultServiceFor(contractStateType: Class<T>): VaultService<T> {
+    return VaultService.create(this, contractStateType)
+}
+
+/**
+ * Creates a vault service, bound to the specified [ContractState] type.
+ *
+ * @param T The underlying [ContractState] type to bind the vault service to.
+ * @return Returns a [VaultService] instance bound to the underlying [ContractState] type.
+ */
+inline fun <reified T : ContractState> CordaRPCOps.vaultServiceFor(): VaultService<T> {
+    return vaultServiceFor(T::class.java)
+}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.Query.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.QueryCriteria.kt
similarity index 78%
rename from onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.Query.kt
rename to onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.QueryCriteria.kt
index 9ed830b..ff0a15a 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.Query.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.QueryCriteria.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -14,26 +14,12 @@
  * limitations under the License.
  */
 
-package io.onixlabs.corda.core.workflow
+package io.onixlabs.corda.core.services
 
-import net.corda.core.node.services.vault.*
+import net.corda.core.node.services.vault.CriteriaExpression
+import net.corda.core.node.services.vault.QueryCriteria
 import net.corda.core.schemas.StatePersistable
 
-/**
- * The default sorting order.
- */
-val DEFAULT_SORTING: Sort = Sort(emptySet())
-
-/**
- * The default page specification.
- */
-val DEFAULT_PAGE_SPECIFICATION: PageSpecification get() = PageSpecification(DEFAULT_PAGE_NUM, DEFAULT_PAGE_SIZE)
-
-/**
- * The maximum page specification.
- */
-val MAXIMUM_PAGE_SPECIFICATION: PageSpecification get() = PageSpecification(DEFAULT_PAGE_NUM, MAX_PAGE_SIZE)
-
 /**
  * Builds a custom query criteria. This combines all non-null query expressions using logical AND.
  *
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.QueryDsl.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.QueryDsl.kt
new file mode 100644
index 0000000..32f4094
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.QueryDsl.kt
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.node.services.vault.QueryCriteria.VaultQueryCriteria
+
+/**
+ * Creates a [QueryCriteria] using the Query DSL.
+ *
+ * @param T The underlying [ContractState] which will be included in the query.
+ * @param contractStateType The [ContractState] class which will be included in the query.
+ * @return Returns the [QueryCriteria] that was created using the Query DSL.
+ */
+@QueryDslContext
+fun <T : ContractState> vaultQuery(contractStateType: Class<T>, action: QueryDsl<T>.() -> Unit): QueryCriteria {
+    val criteria = VaultQueryCriteria(contractStateTypes = setOf(contractStateType))
+    return vaultQuery(criteria, action)
+}
+
+/**
+ * Creates a [QueryCriteria] using the Query DSL.
+ *
+ * @param T The underlying [ContractState] which will be included in the query.
+ * @return Returns the [QueryCriteria] that was created using the Query DSL.
+ */
+@QueryDslContext
+inline fun <reified T : ContractState> vaultQuery(noinline action: QueryDsl<T>.() -> Unit): QueryCriteria {
+    return vaultQuery(T::class.java, action)
+}
+
+/**
+ * Creates a [QueryCriteria] using the Query DSL.
+ *
+ * @param T The underlying [ContractState] which will be included in the query.
+ * @param criteria The base criteria upon which the Query DSL will build.
+ * @return Returns the [QueryCriteria] that was created using the Query DSL.
+ */
+private fun <T : ContractState> vaultQuery(criteria: QueryCriteria, action: QueryDsl<T>.() -> Unit): QueryCriteria {
+    val queryDsl = QueryDsl<T>(criteria)
+    action(queryDsl)
+    return queryDsl.getQueryCriteria()
+}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.ServiceHub.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.ServiceHub.kt
new file mode 100644
index 0000000..0f381ef
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.ServiceHub.kt
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.node.ServiceHub
+
+/**
+ * Creates a vault service, bound to the specified [ContractState] type.
+ *
+ * @param T The underlying [ContractState] type to bind the vault service to.
+ * @param contractStateType The [Class] of the [ContractState] type to bind the vault service to.
+ * @return Returns a [VaultService] instance bound to the underlying [ContractState] type.
+ */
+fun <T : ContractState> ServiceHub.vaultServiceFor(contractStateType: Class<T>): VaultService<T> {
+    return VaultService.create(this, contractStateType)
+}
+
+/**
+ * Creates a vault service, bound to the specified [ContractState] type.
+ *
+ * @param T The underlying [ContractState] type to bind the vault service to.
+ * @return Returns a [VaultService] instance bound to the underlying [ContractState] type.
+ */
+inline fun <reified T : ContractState> ServiceHub.vaultServiceFor(): VaultService<T> {
+    return vaultServiceFor(T::class.java)
+}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.VaultService.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.VaultService.kt
new file mode 100644
index 0000000..360065f
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/Extensions.VaultService.kt
@@ -0,0 +1,340 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.node.services.Vault
+import net.corda.core.node.services.vault.PageSpecification
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.node.services.vault.Sort
+import java.util.*
+
+/**
+ * Determines whether the sequence contains any elements.
+ *
+ * @param T the underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the sequence.
+ * @return Returns true if the sequence contains any elements; otherwise, false.
+ */
+fun <T : ContractState> VaultService<T>.any(
+    criteria: QueryCriteria = defaultQueryCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING
+): Boolean = VaultSequence(this, criteria, paging, sorting).any()
+
+/**
+ * Determines whether the sequence contains any elements.
+ *
+ * @param T the underlying [ContractState] type.
+ * @param action Builds the query criteria that will be used to obtain the sequence.
+ * @return Returns true if the sequence contains any elements; otherwise, false.
+ */
+fun <T : ContractState> VaultService<T>.any(action: QueryDsl<T>.() -> Unit): Boolean {
+    val queryDsl = QueryDsl<T>(defaultQueryCriteria)
+    action(queryDsl)
+    return VaultSequence(this, queryDsl).any()
+}
+
+/**
+ * Counts the number of elements in a sequence.
+ *
+ * @param T the underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the sequence.
+ * @return Returns a count of the number of elements in a sequence.
+ */
+fun <T : ContractState> VaultService<T>.count(
+    criteria: QueryCriteria = defaultQueryCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING
+): Int = VaultSequence(this, criteria, paging, sorting).count()
+
+/**
+ * Counts the number of elements in a sequence.
+ *
+ * @param T the underlying [ContractState] type.
+ * @param action Builds the query criteria that will be used to obtain the sequence.
+ * @return Returns a count of the number of elements in a sequence.
+ */
+fun <T : ContractState> VaultService<T>.count(action: QueryDsl<T>.() -> Unit): Int {
+    val queryDsl = QueryDsl<T>(defaultQueryCriteria)
+    action(queryDsl)
+    return VaultSequence(this, queryDsl).count()
+}
+
+/**
+ * Filters a sequence of elements based on the specified query criteria.
+ *
+ * @param T the underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the sequence.
+ * @param paging The page specification that will be applied to the vault query.
+ * @param sorting The sort that will be applied to the vault query.
+ * @return Returns a filtered sequence of elements.
+ */
+fun <T : ContractState> VaultService<T>.filter(
+    criteria: QueryCriteria = defaultQueryCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING
+): VaultSequence<T> = VaultSequence(this, criteria, paging, sorting)
+
+/**
+ * Filters a sequence of values based on the specified query criteria.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param action Builds the query criteria that will be used to obtain the sequence.
+ * @return Returns a filtered sequence of elements.
+ */
+fun <T : ContractState> VaultService<T>.filter(action: QueryDsl<T>.() -> Unit): VaultSequence<T> {
+    val queryDsl = QueryDsl<T>(defaultQueryCriteria)
+    action(queryDsl)
+    return VaultSequence(this, queryDsl)
+}
+
+/**
+ * Obtains the first element of a sequence.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the sequence.
+ * @param paging The page specification that will be applied to the vault query.
+ * @param sorting The sort that will be applied to the vault query.
+ * @return Returns the first element in the sequence.
+ */
+fun <T : ContractState> VaultService<T>.first(
+    criteria: QueryCriteria = defaultQueryCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING
+): StateAndRef<T> = VaultSequence(this, criteria, paging, sorting).first()
+
+/**
+ * Obtains the first element of a sequence.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param action Builds the query criteria that will be used to obtain the sequence.
+ * @return Returns the first element in the sequence.
+ */
+fun <T : ContractState> VaultService<T>.first(action: QueryDsl<T>.() -> Unit): StateAndRef<T> {
+    val queryDsl = QueryDsl<T>(defaultQueryCriteria)
+    action(queryDsl)
+    return VaultSequence(this, queryDsl).first()
+}
+
+/**
+ * Obtains the first element of a sequence, or null if no element is found.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the sequence.
+ * @param paging The page specification that will be applied to the vault query.
+ * @param sorting The sort that will be applied to the vault query.
+ * @return Returns the first element in the sequence, or null if no element is found.
+ */
+fun <T : ContractState> VaultService<T>.firstOrNull(
+    criteria: QueryCriteria = defaultQueryCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING
+): StateAndRef<T>? = VaultSequence(this, criteria, paging, sorting).firstOrNull()
+
+/**
+ * Obtains the first element of a sequence, or null if no element is found.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param action Builds the query criteria that will be used to obtain the sequence.
+ * @return Returns the first element in the sequence, or null if no element is found.
+ */
+fun <T : ContractState> VaultService<T>.firstOrNull(action: QueryDsl<T>.() -> Unit): StateAndRef<T>? {
+    val queryDsl = QueryDsl<T>(defaultQueryCriteria)
+    action(queryDsl)
+    return VaultSequence(this, queryDsl).firstOrNull()
+}
+
+/**
+ * Obtains the last element of a sequence.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the sequence.
+ * @param paging The page specification that will be applied to the vault query.
+ * @param sorting The sort that will be applied to the vault query.
+ * @return Returns the last element in the sequence.
+ */
+fun <T : ContractState> VaultService<T>.last(
+    criteria: QueryCriteria = defaultQueryCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING
+): StateAndRef<T> = VaultSequence(this, criteria, paging, sorting).last()
+
+/**
+ * Obtains the last element of a sequence.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param action Builds the query criteria that will be used to obtain the sequence.
+ * @return Returns the last element in the sequence.
+ */
+fun <T : ContractState> VaultService<T>.last(action: QueryDsl<T>.() -> Unit): StateAndRef<T> {
+    val queryDsl = QueryDsl<T>(defaultQueryCriteria)
+    action(queryDsl)
+    return VaultSequence(this, queryDsl).last()
+}
+
+/**
+ * Obtains the last element of a sequence, or null if no element is found.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the sequence.
+ * @param paging The page specification that will be applied to the vault query.
+ * @param sorting The sort that will be applied to the vault query.
+ * @return Returns the last element in the sequence, or null if no element is found.
+ */
+fun <T : ContractState> VaultService<T>.lastOrNull(
+    criteria: QueryCriteria = defaultQueryCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING
+): StateAndRef<T>? = VaultSequence(this, criteria, paging, sorting).lastOrNull()
+
+/**
+ * Obtains the last element of a sequence, or null if no element is found.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param action Builds the query criteria that will be used to obtain the sequence.
+ * @return Returns the last element in the sequence, or null if no element is found.
+ */
+fun <T : ContractState> VaultService<T>.lastOrNull(action: QueryDsl<T>.() -> Unit): StateAndRef<T>? {
+    val queryDsl = QueryDsl<T>(defaultQueryCriteria)
+    action(queryDsl)
+    return VaultSequence(this, queryDsl).lastOrNull()
+}
+
+/**
+ * Obtains a single, specific element of a sequence.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the sequence.
+ * @param paging The page specification that will be applied to the vault query.
+ * @param sorting The sort that will be applied to the vault query.
+ * @return Returns the last element in the sequence.
+ */
+fun <T : ContractState> VaultService<T>.single(
+    criteria: QueryCriteria = defaultQueryCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING
+): StateAndRef<T> = VaultSequence(this, criteria, paging, sorting).single()
+
+/**
+ * Obtains a single, specific element of a sequence.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param action Builds the query criteria that will be used to obtain the sequence.
+ * @return Returns the last element in the sequence.
+ */
+fun <T : ContractState> VaultService<T>.single(action: QueryDsl<T>.() -> Unit): StateAndRef<T> {
+    val queryDsl = QueryDsl<T>(defaultQueryCriteria)
+    action(queryDsl)
+    return VaultSequence(this, queryDsl).single()
+}
+
+/**
+ * Obtains a single, specific element of a sequence, or null if no element is found.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the sequence.
+ * @param paging The page specification that will be applied to the vault query.
+ * @param sorting The sort that will be applied to the vault query.
+ * @return Returns the last element in the sequence, or null if no element is found.
+ */
+fun <T : ContractState> VaultService<T>.singleOrNull(
+    criteria: QueryCriteria = defaultQueryCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING
+): StateAndRef<T>? = VaultSequence(this, criteria, paging, sorting).singleOrNull()
+
+/**
+ * Obtains a single, specific element of a sequence, or null if no element is found.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param action Builds the query criteria that will be used to obtain the sequence.
+ * @return Returns the last element in the sequence, or null if no element is found.
+ */
+fun <T : ContractState> VaultService<T>.singleOrNull(action: QueryDsl<T>.() -> Unit): StateAndRef<T>? {
+    val queryDsl = QueryDsl<T>(defaultQueryCriteria)
+    action(queryDsl)
+    return VaultSequence(this, queryDsl).singleOrNull()
+}
+
+/**
+ * Obtains a sequence of elements as a [List].
+ *
+ * @param T The underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the sequence.
+ * @param paging The page specification that will be applied to the vault query.
+ * @param sorting The sort that will be applied to the vault query.
+ * @return Returns a sequence of elements as a [List].
+ */
+fun <T : ContractState> VaultService<T>.toList(
+    criteria: QueryCriteria = defaultQueryCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING
+): List<StateAndRef<T>> = VaultSequence(this, criteria, paging, sorting).toList()
+
+/**
+ * Obtains a sequence of elements as a [Set].
+ *
+ * @param T The underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the sequence.
+ * @param paging The page specification that will be applied to the vault query.
+ * @param sorting The sort that will be applied to the vault query.
+ * @return Returns a sequence of elements as a [Set].
+ */
+fun <T : ContractState> VaultService<T>.toSet(
+    criteria: QueryCriteria = defaultQueryCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING
+): Set<StateAndRef<T>> = VaultSequence(this, criteria, paging, sorting).toSet()
+
+/**
+ * Subscribes to vault tracking updates.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param criteria The query criteria that will be used to obtain the tracking updates.
+ * @param paging The page specification that will be applied to the vault tracking.
+ * @param sorting The sort that will be applied to the vault tracking.
+ * @param observer The function which will receive vault tracking updates as [VaultObservable] instances.
+ */
+fun <T : ContractState> VaultService<T>.subscribe(
+    criteria: QueryCriteria = defaultTrackingCriteria,
+    paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    sorting: Sort = DEFAULT_SORTING,
+    observer: (VaultObservable<T>) -> Unit
+) {
+    fun handle(stateAndRef: StateAndRef<T>, status: Vault.StateStatus, flowId: UUID?) {
+        if (stateAndRef.state.data.javaClass.isAssignableFrom(contractStateType)) {
+            observer(VaultObservable(stateAndRef.state, stateAndRef.ref, status, flowId))
+        }
+    }
+
+    val status = when (criteria) {
+        is QueryCriteria.VaultQueryCriteria -> criteria.status
+        else -> Vault.StateStatus.ALL
+    }
+
+    trackBy(criteria, paging, sorting).updates.subscribe {
+        if (status != Vault.StateStatus.UNCONSUMED) {
+            it.consumed.forEach { stateAndRef -> handle(stateAndRef, Vault.StateStatus.CONSUMED, it.flowId) }
+        }
+
+        if (status != Vault.StateStatus.CONSUMED) {
+            it.produced.forEach { stateAndRef -> handle(stateAndRef, Vault.StateStatus.UNCONSUMED, it.flowId) }
+        }
+    }
+}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/QueryDsl.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/QueryDsl.kt
new file mode 100644
index 0000000..561d527
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/QueryDsl.kt
@@ -0,0 +1,605 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import io.onixlabs.corda.core.toTypedClass
+import net.corda.core.contracts.*
+import net.corda.core.identity.AbstractParty
+import net.corda.core.node.services.Vault
+import net.corda.core.node.services.vault.*
+import net.corda.core.node.services.vault.CriteriaExpression.ColumnPredicateExpression
+import net.corda.core.node.services.vault.QueryCriteria.*
+import net.corda.core.schemas.StatePersistable
+import net.corda.core.utilities.OpaqueBytes
+import java.util.*
+import kotlin.reflect.KProperty1
+import kotlin.reflect.jvm.javaType
+
+/**
+ * Represents a DSL for building expressive Corda vault queries.
+ *
+ * @param T The underlying [ContractState] to determine which contract state types to include in the query.
+ * @property criteria The root query criteria upon which the query is constructed.
+ * @property paging The page specification which will be applied to the query.
+ * @property sorting The sorting which will be applied to the query.
+ */
+class QueryDsl<T : ContractState> internal constructor(
+    private var criteria: QueryCriteria,
+    private var paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    private var sorting: Sort = DEFAULT_SORTING
+) {
+
+    /**
+     * Defines the common query criteria which will be applied to each sub-node of the query expression.
+     *
+     * Values applied to this should be initialized up front, and will be copied to all sub-nodes of the
+     * criteria expression. If you want to include different common query criteria to sub-query expressions
+     * then wrap the expression into either and "and" or "or" block, which will give you a new [QueryDsl] instance
+     * and therefore a new set of common query criteria.
+     */
+    private val commonQueryCriteria = object : CommonQueryCriteria() {
+        override var constraintTypes: Set<Vault.ConstraintInfo.Type> = emptySet()
+        override var constraints: Set<Vault.ConstraintInfo> = emptySet()
+        override var contractStateTypes: Set<Class<out ContractState>>? = null
+        override var exactParticipants: List<AbstractParty>? = null
+        override var externalIds: List<UUID> = emptyList()
+        override var participants: List<AbstractParty>? = null
+        override var relevancyStatus: Vault.RelevancyStatus = Vault.RelevancyStatus.RELEVANT
+        override var status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED
+    }
+
+    init {
+
+        /**
+         * If the root query criteria derives from CommonQueryCriteria then these values are copied to
+         * the common query criteria on initialization.
+         */
+        if (criteria is CommonQueryCriteria) with(commonQueryCriteria) {
+            val criteriaToCopy = criteria as CommonQueryCriteria
+            constraintTypes = criteriaToCopy.constraintTypes
+            constraints = criteriaToCopy.constraints
+            contractStateTypes = criteriaToCopy.contractStateTypes
+            exactParticipants = criteriaToCopy.exactParticipants
+            externalIds = criteriaToCopy.externalIds
+            participants = criteriaToCopy.participants
+            relevancyStatus = criteriaToCopy.relevancyStatus
+            status = criteriaToCopy.status
+        }
+    }
+
+    /**
+     * Specifies the constraints to apply to the query criteria.
+     *
+     * @param values The [Vault.ConstraintInfo] to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun constraints(values: Iterable<Vault.ConstraintInfo>) {
+        commonQueryCriteria.constraints = values.toSet()
+        criteria = criteria.updateQueryCriteria()
+    }
+
+    /**
+     * Specifies the constraints to apply to the query criteria.
+     *
+     * @param values The [Vault.ConstraintInfo] to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun constraints(vararg values: Vault.ConstraintInfo) {
+        constraints(values.toSet())
+    }
+
+    /**
+     * Specifies the constraint types to apply to the query criteria.
+     *
+     * @param values The [Vault.ConstraintInfo.Type] to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun constraintTypes(values: Iterable<Vault.ConstraintInfo.Type>) {
+        commonQueryCriteria.constraintTypes = values.toSet()
+        criteria = criteria.updateQueryCriteria()
+    }
+
+    /**
+     * Specifies the constraint types to apply to the query criteria.
+     *
+     * @param values The [Vault.ConstraintInfo.Type] to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun constraintTypes(vararg values: Vault.ConstraintInfo.Type) {
+        constraintTypes(values.toSet())
+    }
+
+    /**
+     * Specifies the contract state types to apply to the query criteria.
+     *
+     * @param values The [ContractState] types to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun contractStateTypes(values: Iterable<Class<out T>>) {
+        commonQueryCriteria.contractStateTypes = values.toSet()
+        criteria = criteria.updateQueryCriteria()
+    }
+
+    /**
+     * Specifies the contract state types to apply to the query criteria.
+     *
+     * @param values The [ContractState] types to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun contractStateTypes(vararg values: Class<out T>) {
+        contractStateTypes(values.toSet())
+    }
+
+    /**
+     * Specifies the exact participants to apply to the query criteria.
+     *
+     * @param values The exact [AbstractParty] participants to apply to the query.
+     */
+    @QueryDslContext
+    fun exactParticipants(values: Iterable<AbstractParty>) {
+        commonQueryCriteria.exactParticipants = values.toList()
+        criteria = criteria.updateQueryCriteria()
+    }
+
+    /**
+     * Specifies the exact participants to apply to the query criteria.
+     *
+     * @param values The exact [AbstractParty] participants to apply to the query.
+     */
+    @QueryDslContext
+    fun exactParticipants(vararg values: AbstractParty) {
+        exactParticipants(values.toList())
+    }
+
+    /**
+     * Specifies the participants to apply to the query criteria.
+     *
+     * @param values The participant [AbstractParty] instances to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun participants(values: Iterable<AbstractParty>) {
+        commonQueryCriteria.participants = values.toList()
+        criteria = criteria.updateQueryCriteria()
+    }
+
+    /**
+     * Specifies the participants to apply to the query criteria.
+     *
+     * @param values The participant [AbstractParty] instances to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun participants(vararg values: AbstractParty) {
+        participants(values.toList())
+    }
+
+    /**
+     * Specifies the relevancy status of the query criteria.
+     *
+     * @param value The [Vault.RelevancyStatus] to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun relevancyStatus(value: Vault.RelevancyStatus) {
+        commonQueryCriteria.relevancyStatus = value
+        criteria = criteria.updateQueryCriteria()
+    }
+
+    /**
+     * Specifies the state status of the query criteria.
+     *
+     * @param value The [Vault.StateStatus] to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun stateStatus(value: Vault.StateStatus) {
+        commonQueryCriteria.status = value
+        criteria = criteria.updateQueryCriteria()
+    }
+
+    /**
+     * Specifies a custom query criteria expression to apply to the query criteria.
+     *
+     * @param value The custom query criteria expression to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun <T : StatePersistable, P> expression(value: ColumnPredicateExpression<T, P>) {
+        val criteriaToAdd = VaultCustomQueryCriteria(value)
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Specifies the external identifiers to apply to the query criteria.
+     *
+     * @param values The [String] instances to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun externalIds(values: Iterable<String?>) {
+        val criteriaToAdd = LinearStateQueryCriteria(externalId = values.filterNotNull())
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Specifies the external identifiers to apply to the query criteria.
+     *
+     * @param values The [String] instances to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun externalIds(vararg values: String?) {
+        externalIds(values.toList())
+    }
+
+    /**
+     * Specifies the unique identifiers to apply to the query criteria.
+     *
+     * @param values The [UniqueIdentifier] instances to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun linearIds(values: Iterable<UniqueIdentifier>) {
+        val criteriaToAdd = LinearStateQueryCriteria(linearId = values.toList())
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Specifies the unique identifiers to apply to the query criteria.
+     *
+     * @param values The [UniqueIdentifier] instances to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun linearIds(vararg values: UniqueIdentifier) {
+        linearIds(values.toList())
+    }
+
+    /**
+     * Specifies the issuers of [FungibleAsset] states to apply to the query criteria.
+     *
+     * @param values The [AbstractParty] issuers of [FungibleAsset] states to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun issuers(values: Iterable<AbstractParty>) {
+        val criteriaToAdd = FungibleAssetQueryCriteria(issuer = values.toList())
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Specifies the issuers of [FungibleAsset] states to apply to the query criteria.
+     *
+     * @param values The [AbstractParty] issuers of [FungibleAsset] states to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun issuers(vararg values: AbstractParty) {
+        issuers(values.toList())
+    }
+
+    /**
+     * Specifies the issuer refs of [FungibleAsset] states to apply to the query criteria.
+     *
+     * @param values The [AbstractParty] issuer refs of [FungibleAsset] states to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun issuerRefs(values: Iterable<OpaqueBytes>) {
+        val criteriaToAdd = FungibleAssetQueryCriteria(issuerRef = values.toList())
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Specifies the issuer refs of [FungibleAsset] states to apply to the query criteria.
+     *
+     * @param values The [AbstractParty] issuer refs of [FungibleAsset] states to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun issuerRefs(vararg values: OpaqueBytes) {
+        issuerRefs(values.toList())
+    }
+
+    /**
+     * Specifies the notaries to apply to the query criteria.
+     *
+     * @param values The notary [AbstractParty] instances to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun notaries(values: Iterable<AbstractParty>) {
+        val criteriaToAdd = VaultQueryCriteria(notary = values.toList())
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Specifies the notaries to apply to the query criteria.
+     *
+     * @param values The notary [AbstractParty] instances to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun notaries(vararg values: AbstractParty) {
+        notaries(values.toList())
+    }
+
+    /**
+     * Specifies the owners of [FungibleAsset] states to apply to the query criteria.
+     *
+     * @param values The [AbstractParty] owners of [FungibleAsset] states to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun owners(values: Iterable<AbstractParty>) {
+        val criteriaToAdd = FungibleAssetQueryCriteria(owner = values.toList())
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Specifies the owners of [FungibleAsset] states to apply to the query criteria.
+     *
+     * @param values The [AbstractParty] owners of [FungibleAsset] states to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun owners(vararg values: AbstractParty) {
+        owners(values.toList())
+    }
+
+    /**
+     * Specifies a column predicate that determines the quantity of a [FungibleAsset] to apply to the query criteria.
+     *
+     * @param value The [ColumnPredicate] that determines the quantity of a [FungibleAsset] to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun fungibleAssetQuantity(value: ColumnPredicate<Long>) {
+        val criteriaToAdd = FungibleAssetQueryCriteria(quantity = value)
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Specifies a column predicate that determines the quantity of a [FungibleState] to apply to the query criteria.
+     *
+     * @param value The [ColumnPredicate] that determines the quantity of a [FungibleState] to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun fungibleStateQuantity(value: ColumnPredicate<Long>) {
+        val criteriaToAdd = FungibleStateQueryCriteria(quantity = value)
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Specifies the soft locking condition of the query criteria.
+     *
+     * @param value The [SoftLockingCondition] to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun softLockingCondition(value: SoftLockingCondition) {
+        val criteriaToAdd = VaultQueryCriteria(softLockingCondition = value)
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Specifies the state references to apply to the query criteria.
+     *
+     * @param values The [StateRef] instances to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun stateRefs(values: Iterable<StateRef>) {
+        val criteriaToAdd = VaultQueryCriteria(stateRefs = values.toList())
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Specifies the state references to apply to the query criteria.
+     *
+     * @param values The [StateRef] instances to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun stateRefs(vararg values: StateRef) {
+        stateRefs(values.toList())
+    }
+
+    /**
+     * Specifies the time condition of the query criteria.
+     *
+     * @param value The [TimeCondition] to apply to the query criteria.
+     */
+    @QueryDslContext
+    fun timeCondition(value: TimeCondition) {
+        val criteriaToAdd = VaultQueryCriteria(timeCondition = value)
+        criteria = criteria.and(criteriaToAdd.updateQueryCriteria())
+    }
+
+    /**
+     * Applies a sub-query to the current query criteria using logical AND.
+     *
+     * @param action The [QueryDsl] action which will be used to build the sub-query.
+     */
+    @QueryDslContext
+    fun and(action: QueryDsl<T>.() -> Unit) {
+        val query = QueryDsl<T>(VaultQueryCriteria().updateQueryCriteria(), paging, sorting)
+        action(query)
+        criteria = criteria.and(query.criteria)
+    }
+
+    /**
+     * Applies a sub-query to the current query criteria using logical OR.
+     *
+     * @param action The [QueryDsl] action which will be used to build the sub-query.
+     */
+    @QueryDslContext
+    fun or(action: QueryDsl<T>.() -> Unit) {
+        val query = QueryDsl<T>(VaultQueryCriteria().updateQueryCriteria(), paging, sorting)
+        action(query)
+        criteria = criteria.or(query.criteria)
+    }
+
+    /**
+     * Specifies the page specification which will be applied to the query.
+     *
+     * @param value The [PageSpecification] to apply to the query.
+     */
+    @QueryDslContext
+    fun page(value: PageSpecification) {
+        paging = value
+    }
+
+    /**
+     * Specifies the page specification which will be applied to the query.
+     *
+     * @param pageNumber The page number of the page to obtain from the vault.
+     * @param pageSize The size of the page to obtain from the vault.
+     */
+    @QueryDslContext
+    fun page(pageNumber: Int, pageSize: Int) {
+        page(PageSpecification(pageNumber, pageSize))
+    }
+
+    /**
+     * Specifies the sorting which will be applied to the query.
+     *
+     * @param value The [Sort] to apply to the query.
+     */
+    @QueryDslContext
+    fun sort(value: Sort) {
+        sorting = value
+    }
+
+    /**
+     * Specifies that the query should be sorted by the specified property and by the specified order.
+     *
+     * @param property The property to sort the query by.
+     * @param direction The sort direction of the sorted data.
+     */
+    @QueryDslContext
+    fun sortBy(property: KProperty1<out StatePersistable, *>, direction: Sort.Direction) {
+        val receiver = property.parameters.first().type.javaType.toTypedClass<StatePersistable>()
+        val attribute = SortAttribute.Custom(receiver, property.name)
+        val column = Sort.SortColumn(attribute, direction)
+        sort(Sort(setOf(column)))
+    }
+
+    /**
+     * Specifies that the query should be sorted by the specified property in ascending order.
+     *
+     * @param property The property to sort the query by.
+     */
+    @QueryDslContext
+    fun sortByAscending(property: KProperty1<out StatePersistable, *>) {
+        sortBy(property, Sort.Direction.ASC)
+    }
+
+    /**
+     * Specifies that the query should be sorted by the specified property in descending order.
+     *
+     * @param property The property to sort the query by.
+     */
+    @QueryDslContext
+    fun sortByDescending(property: KProperty1<out StatePersistable, *>) {
+        sortBy(property, Sort.Direction.DESC)
+    }
+
+    /**
+     * Gets the fully built query criteria expression.
+     *
+     * @return Returns a [QueryCriteria] representing the vault query.
+     */
+    fun getQueryCriteria(): QueryCriteria {
+        return criteria
+    }
+
+    /**
+     * Gets the paging specification for this query.
+     *
+     * @return Returns a [PageSpecification] for this query.
+     */
+    fun getPaging(): PageSpecification {
+        return paging
+    }
+
+    /**
+     * Gets the sorting for this query.
+     *
+     * @return Returns a [Sort] for this query.
+     */
+    fun getSorting(): Sort {
+        return sorting
+    }
+
+    /**
+     * Updates the current [QueryCriteria] with the values maintained in the common query criteria object.
+     *
+     * @return Returns the updated query criteria.
+     */
+    private fun QueryCriteria.updateQueryCriteria(): QueryCriteria = when (this) {
+        is VaultQueryCriteria -> updateQueryCriteria()
+        is VaultCustomQueryCriteria<*> -> updateQueryCriteria()
+        is LinearStateQueryCriteria -> updateQueryCriteria()
+        is FungibleAssetQueryCriteria -> updateQueryCriteria()
+        is FungibleStateQueryCriteria -> updateQueryCriteria()
+        else -> this
+    }
+
+    /**
+     * Updates the current [VaultQueryCriteria] with the values maintained in the common query criteria object.
+     *
+     * @return Returns the updated query criteria.
+     */
+    private fun VaultQueryCriteria.updateQueryCriteria(): VaultQueryCriteria = copy(
+        constraintTypes = commonQueryCriteria.constraintTypes,
+        constraints = commonQueryCriteria.constraints,
+        contractStateTypes = commonQueryCriteria.contractStateTypes,
+        exactParticipants = commonQueryCriteria.exactParticipants,
+        externalIds = commonQueryCriteria.externalIds,
+        participants = commonQueryCriteria.participants,
+        relevancyStatus = commonQueryCriteria.relevancyStatus,
+        status = commonQueryCriteria.status
+    )
+
+    /**
+     * Updates the current [VaultCustomQueryCriteria] with the values maintained in the common query criteria object.
+     *
+     * @return Returns the updated query criteria.
+     */
+    private fun VaultCustomQueryCriteria<*>.updateQueryCriteria(): VaultCustomQueryCriteria<*> = copy(
+        contractStateTypes = commonQueryCriteria.contractStateTypes,
+        relevancyStatus = commonQueryCriteria.relevancyStatus,
+        status = commonQueryCriteria.status
+    )
+
+    /**
+     * Updates the current [LinearStateQueryCriteria] with the values maintained in the common query criteria object.
+     *
+     * @return Returns the updated query criteria.
+     */
+    private fun LinearStateQueryCriteria.updateQueryCriteria(): LinearStateQueryCriteria = copy(
+        contractStateTypes = commonQueryCriteria.contractStateTypes,
+        participants = commonQueryCriteria.participants,
+        relevancyStatus = commonQueryCriteria.relevancyStatus,
+        status = commonQueryCriteria.status
+    )
+
+    /**
+     * Updates the current [FungibleAssetQueryCriteria] with the values maintained in the common query criteria object.
+     *
+     * @return Returns the updated query criteria.
+     */
+    private fun FungibleAssetQueryCriteria.updateQueryCriteria(): FungibleAssetQueryCriteria = copy(
+        contractStateTypes = commonQueryCriteria.contractStateTypes,
+        participants = commonQueryCriteria.participants,
+        relevancyStatus = commonQueryCriteria.relevancyStatus,
+        status = commonQueryCriteria.status
+    )
+
+    /**
+     * Updates the current [FungibleStateQueryCriteria] with the values maintained in the common query criteria object.
+     *
+     * @return Returns the updated query criteria.
+     */
+    private fun FungibleStateQueryCriteria.updateQueryCriteria(): FungibleStateQueryCriteria = copy(
+        contractStateTypes = commonQueryCriteria.contractStateTypes,
+        participants = commonQueryCriteria.participants,
+        relevancyStatus = commonQueryCriteria.relevancyStatus,
+        status = commonQueryCriteria.status
+    )
+}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/QueryDslContext.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/QueryDslContext.kt
new file mode 100644
index 0000000..6f67c04
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/QueryDslContext.kt
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+/**
+ * Specifies that a function is contextually party of the query DSL.
+ */
+@DslMarker
+annotation class QueryDslContext
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultAdapter.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultAdapter.kt
new file mode 100644
index 0000000..322f498
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultAdapter.kt
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.messaging.DataFeed
+import net.corda.core.node.services.Vault
+import net.corda.core.node.services.vault.PageSpecification
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.node.services.vault.Sort
+
+/**
+ * Represents the base class for implementing vault adapters.
+ *
+ * @param contractStateType The contract state class used by the vault adapter.
+ */
+internal abstract class VaultAdapter<T : ContractState>(protected val contractStateType: Class<T>) {
+
+    /**
+     * Queries the vault.
+     *
+     * @param criteria The query criteria to use in the vault query.
+     * @param paging The paging specification to use in the vault query.
+     * @param sorting The sorting to use in the vault query.
+     * @return Returns a vault page of contract state items.
+     */
+    abstract fun queryBy(
+        criteria: QueryCriteria,
+        paging: PageSpecification,
+        sorting: Sort
+    ): Vault.Page<T>
+
+    /**
+     * Tracks the vault.
+     *
+     * @param criteria The query criteria to use in vault tracking.
+     * @param paging The paging specification to use in vault tracking.
+     * @param sorting The sorting to use in vault tracking.
+     * @return Returns a data feed of tracked items from the vault.
+     */
+    abstract fun trackBy(
+        criteria: QueryCriteria,
+        paging: PageSpecification,
+        sorting: Sort
+    ): DataFeed<Vault.Page<T>, Vault.Update<T>>
+}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultAdapterCordaRPCOps.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultAdapterCordaRPCOps.kt
new file mode 100644
index 0000000..209099c
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultAdapterCordaRPCOps.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.messaging.CordaRPCOps
+import net.corda.core.messaging.DataFeed
+import net.corda.core.node.services.Vault
+import net.corda.core.node.services.vault.PageSpecification
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.node.services.vault.Sort
+
+/**
+ * Represents a vault service adapter implementation for [CordaRPCOps].
+ *
+ * @param cordaRPCOps The [CordaRPCOps] instance which will be used to query or track the vault.
+ * @param contractStateType The type of contract state used by the vault service adapter.
+ */
+internal class VaultAdapterCordaRPCOps<T : ContractState>(
+    private val cordaRPCOps: CordaRPCOps,
+    contractStateType: Class<T>
+) : VaultAdapter<T>(contractStateType) {
+
+    /**
+     * Queries the vault.
+     *
+     * @param criteria The query criteria to use in the vault query.
+     * @param paging The paging specification to use in the vault query.
+     * @param sorting The sorting to use in the vault query.
+     * @return Returns a vault page of contract state items.
+     */
+    override fun queryBy(
+        criteria: QueryCriteria,
+        paging: PageSpecification,
+        sorting: Sort
+    ): Vault.Page<T> {
+        return cordaRPCOps.vaultQueryBy(criteria, paging, sorting, contractStateType)
+    }
+
+    /**
+     * Tracks the vault.
+     *
+     * @param criteria The query criteria to use in vault tracking.
+     * @param paging The paging specification to use in vault tracking.
+     * @param sorting The sorting to use in vault tracking.
+     * @return Returns a data feed of tracked items from the vault.
+     */
+    override fun trackBy(
+        criteria: QueryCriteria,
+        paging: PageSpecification,
+        sorting: Sort
+    ): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+        return cordaRPCOps.vaultTrackBy(criteria, paging, sorting, contractStateType)
+    }
+}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultAdapterServiceHub.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultAdapterServiceHub.kt
new file mode 100644
index 0000000..e9f3781
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultAdapterServiceHub.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.messaging.DataFeed
+import net.corda.core.node.ServiceHub
+import net.corda.core.node.services.Vault
+import net.corda.core.node.services.vault.PageSpecification
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.node.services.vault.Sort
+
+/**
+ * Represents a vault service adapter wrapping a [ServiceHub] instance.
+ *
+ * @param serviceHub The [ServiceHub] instance which will be used to query or track the vault.
+ * @param contractStateType The type of contract state used by the vault service adapter.
+ */
+internal class VaultAdapterServiceHub<T : ContractState>(
+    private val serviceHub: ServiceHub,
+    contractStateType: Class<T>
+) : VaultAdapter<T>(contractStateType) {
+
+    /**
+     * Queries the vault.
+     *
+     * @param criteria The query criteria to use in the vault query.
+     * @param paging The paging specification to use in the vault query.
+     * @param sorting The sorting to use in the vault query.
+     * @return Returns a vault page of contract state items.
+     */
+    override fun queryBy(
+        criteria: QueryCriteria,
+        paging: PageSpecification,
+        sorting: Sort
+    ): Vault.Page<T> {
+        return serviceHub.vaultService.queryBy(contractStateType, criteria, paging, sorting)
+    }
+
+    /**
+     * Tracks the vault.
+     *
+     * @param criteria The query criteria to use in vault tracking.
+     * @param paging The paging specification to use in vault tracking.
+     * @param sorting The sorting to use in vault tracking.
+     * @return Returns a data feed of tracked items from the vault.
+     */
+    override fun trackBy(
+        criteria: QueryCriteria,
+        paging: PageSpecification,
+        sorting: Sort
+    ): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+        return serviceHub.vaultService.trackBy(contractStateType, criteria, paging, sorting)
+    }
+}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultObservable.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultObservable.kt
new file mode 100644
index 0000000..77f49e0
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultObservable.kt
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.contracts.StateRef
+import net.corda.core.contracts.TransactionState
+import net.corda.core.node.services.Vault
+import net.corda.core.serialization.CordaSerializable
+import java.util.*
+
+/**
+ * Represents an observable vault state.
+ *
+ * @param T The underlying [ContractState] type.
+ * @property state The [TransactionState] of the observable.
+ * @property ref The [StateRef] of the observable.
+ * @property status The [Vault.StateStatus] of the observable.
+ * @property flowId The ID of the flow that was responsible for consuming or creating the state.
+ */
+@CordaSerializable
+class VaultObservable<T : ContractState>(
+    val state: TransactionState<T>,
+    val ref: StateRef,
+    val status: Vault.StateStatus,
+    val flowId: UUID?
+)
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultQueryOperators.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultQueryOperators.kt
new file mode 100644
index 0000000..b4eb41b
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultQueryOperators.kt
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.node.services.vault.Builder
+import net.corda.core.node.services.vault.Builder.predicate
+import net.corda.core.node.services.vault.CriteriaExpression.ColumnPredicateExpression
+import net.corda.core.schemas.StatePersistable
+import kotlin.reflect.KProperty1
+
+/**
+ * Builds a column query expression for a property with null value.
+ *
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+fun <T : StatePersistable, P> KProperty1<T, P?>.isNull()
+        : ColumnPredicateExpression<T, P> = predicate(Builder.isNull())
+
+/**
+ * Builds a column query expression for a property with a non-null value.
+ *
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+fun <T : StatePersistable, P> KProperty1<T, P?>.isNotNull()
+        : ColumnPredicateExpression<T, P> = predicate(Builder.isNotNull())
+
+/**
+ * Builds a column query expression for a property with a value equal to the specified value.
+ *
+ * @param value The value which will be used to build the query criterion.
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+infix fun <T : StatePersistable, P> KProperty1<T, P?>.equalTo(value: P)
+        : ColumnPredicateExpression<T, P> = predicate(Builder.equal(value))
+
+/**
+ * Builds a column query expression for a property with a value not equal to the specified value.
+ *
+ * @param value The value which will be used to build the query criterion.
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+infix fun <T : StatePersistable, P> KProperty1<T, P?>.notEqualTo(value: P)
+        : ColumnPredicateExpression<T, P> = predicate(Builder.notEqual(value))
+
+/**
+ * Builds a column query expression for a property with a value greater than to the specified value.
+ *
+ * @param value The value which will be used to build the query criterion.
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.greaterThan(value: P)
+        : ColumnPredicateExpression<T, P> = predicate(Builder.greaterThan(value))
+
+/**
+ * Builds a column query expression for a property with a value greater than or equal to to the specified value.
+ *
+ * @param value The value which will be used to build the query criterion.
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.greaterThanOrEqualTo(value: P)
+        : ColumnPredicateExpression<T, P> = predicate(Builder.greaterThanOrEqual(value))
+
+/**
+ * Builds a column query expression for a property with a value less than the specified value.
+ *
+ * @param value The value which will be used to build the query criterion.
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.lessThan(value: P)
+        : ColumnPredicateExpression<T, P> = predicate(Builder.lessThan(value))
+
+/**
+ * Builds a column query expression for a property with a value less than or equal to the specified value.
+ *
+ * @param value The value which will be used to build the query criterion.
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.lessThanOrEqualTo(value: P)
+        : ColumnPredicateExpression<T, P> = predicate(Builder.lessThanOrEqual(value))
+
+/**
+ * Builds a column query expression for a property with a value between the specified minimum and maximum values.
+ *
+ * @param range The range value which will be used to build the query criterion.
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.between(range: ClosedRange<P>)
+        : ColumnPredicateExpression<T, P> = predicate(Builder.between(range.start, range.endInclusive))
+
+/**
+ * Builds a column query expression for a property with a value like the specified value.
+ *
+ * @param value The value which will be used to build the query criterion.
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+infix fun <T : StatePersistable> KProperty1<T, String?>.like(value: String)
+        : ColumnPredicateExpression<T, String> = predicate(Builder.like(value))
+
+/**
+ * Builds a column query expression for a property with a value not like the specified value.
+ *
+ * @param value The value which will be used to build the query criterion.
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+infix fun <T : StatePersistable> KProperty1<T, String?>.notLike(value: String)
+        : ColumnPredicateExpression<T, String> = predicate(Builder.notLike(value))
+
+/**
+ * Builds a column query expression for a property with a value within the specified collection.
+ *
+ * @param value The value which will be used to build the query criterion.
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.within(value: Collection<P>)
+        : ColumnPredicateExpression<T, P> = predicate(Builder.`in`(value))
+
+/**
+ * Builds a column query expression for a property with a value not within the specified collection.
+ *
+ * @param value The value which will be used to build the query criterion.
+ * @return Returns a [ColumnPredicateExpression] representing the specified custom query criterion.
+ */
+infix fun <T : StatePersistable, P : Comparable<P>> KProperty1<T, P?>.notWithin(value: Collection<P>)
+        : ColumnPredicateExpression<T, P> = predicate(Builder.notIn(value))
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultSequence.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultSequence.kt
new file mode 100644
index 0000000..75f80a9
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultSequence.kt
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.node.services.vault.PageSpecification
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.node.services.vault.Sort
+
+/**
+ * Represents a lazily evaluated sequence of vault query results.
+ *
+ * @param T The underlying [ContractState] type bound to this sequence.
+ * @property service A reference to the vault service which will be used to perform vault queries.
+ * @property criteria The criteria that will be used to query the vault.
+ * @property paging The page specification consisting of the page number and page size to return from the vault.
+ * @property sorting The sort order for the resulting data.
+ */
+class VaultSequence<T : ContractState> internal constructor(
+    private val service: VaultService<T>,
+    private val criteria: QueryCriteria,
+    private val paging: PageSpecification = MAXIMUM_PAGE_SPECIFICATION,
+    private val sorting: Sort = DEFAULT_SORTING
+) : Sequence<StateAndRef<T>> {
+
+    internal constructor(service: VaultService<T>, queryDsl: QueryDsl<T>) : this(
+        service = service,
+        criteria = queryDsl.getQueryCriteria(),
+        paging = queryDsl.getPaging(),
+        sorting = queryDsl.getSorting()
+    )
+
+    /**
+     * Gets the iterator which will evaluate the vault query.
+     *
+     * @return Returns an iterator for the [StateAndRef] instances returned by the vault query.
+     */
+    override fun iterator(): Iterator<StateAndRef<T>> {
+        return service.queryBy(criteria, paging, sorting).states.iterator()
+    }
+}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultService.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultService.kt
new file mode 100644
index 0000000..fee255b
--- /dev/null
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/services/VaultService.kt
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.core.services
+
+import net.corda.core.contracts.ContractState
+import net.corda.core.messaging.CordaRPCOps
+import net.corda.core.messaging.DataFeed
+import net.corda.core.node.ServiceHub
+import net.corda.core.node.services.Vault
+import net.corda.core.node.services.vault.PageSpecification
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.node.services.vault.QueryCriteria.VaultQueryCriteria
+import net.corda.core.node.services.vault.Sort
+
+/**
+ * Represents a service for managing vault querying and tracking.
+ *
+ * @param T The underlying [ContractState] type.
+ * @param adapter The [VaultAdapter] which will be used for performing vault queries and tracking.
+ * @param contractStateType The [Class] of the contract state type to bind this vault service to.
+ */
+class VaultService<T : ContractState> private constructor(
+    private val adapter: VaultAdapter<T>,
+    internal val contractStateType: Class<T>
+) {
+
+    companion object {
+
+        /**
+         * Creates a vault service from a [CordaRPCOps] instance.
+         *
+         * @param cordaRPCOps The [CordaRPCOps] instance from which to create a [VaultService] instance.
+         * @param contractStateType The [Class] of the [ContractState] type to bind the vault service to.
+         */
+        fun <T : ContractState> create(cordaRPCOps: CordaRPCOps, contractStateType: Class<T>): VaultService<T> {
+            return VaultService(VaultAdapterCordaRPCOps(cordaRPCOps, contractStateType), contractStateType)
+        }
+
+        /**
+         * Creates a vault service from a [CordaRPCOps] instance.
+         *
+         * @param T The underlying [ContractState] type to bind the vault service to.
+         * @param cordaRPCOps The [CordaRPCOps] instance from which to create a [VaultService] instance.
+         */
+        inline fun <reified T : ContractState> create(cordaRPCOps: CordaRPCOps): VaultService<T> {
+            return create(cordaRPCOps, T::class.java)
+        }
+
+        /**
+         * Creates a vault service from a [ServiceHub] instance.
+         *
+         * @param serviceHub The [ServiceHub] instance from which to create a [VaultService] instance.
+         * @param contractStateType The [Class] of the [ContractState] type to bind the vault service to.
+         */
+        fun <T : ContractState> create(serviceHub: ServiceHub, contractStateType: Class<T>): VaultService<T> {
+            return VaultService(VaultAdapterServiceHub(serviceHub, contractStateType), contractStateType)
+        }
+
+        /**
+         * Creates a vault service from a [ServiceHub] instance.
+         *
+         * @param T The underlying [ContractState] type to bind the vault service to.
+         * @param serviceHub The [ServiceHub] instance from which to create a [VaultService] instance.
+         */
+        inline fun <reified T : ContractState> create(serviceHub: ServiceHub): VaultService<T> {
+            return create(serviceHub, T::class.java)
+        }
+    }
+
+    /**
+     * The default criteria for tracking the vault.
+     */
+    internal val defaultTrackingCriteria = VaultQueryCriteria(
+        contractStateTypes = setOf(contractStateType),
+        status = Vault.StateStatus.ALL
+    )
+
+    /**
+     * The default criteria for querying the vault.
+     */
+    internal val defaultQueryCriteria = VaultQueryCriteria(
+        contractStateTypes = setOf(contractStateType),
+        status = Vault.StateStatus.UNCONSUMED
+    )
+
+    /**
+     * Performs a vault query given the specified criteria, paging and sorting.
+     *
+     * @param criteria The query criteria to use in the vault query.
+     * @param paging The paging specification to use in the vault query.
+     * @param sorting The sorting to use in the vault query.
+     * @return Returns a vault page of contract state items.
+     */
+    fun queryBy(
+        criteria: QueryCriteria = defaultQueryCriteria,
+        paging: PageSpecification = DEFAULT_PAGE_SPECIFICATION,
+        sorting: Sort = DEFAULT_SORTING
+    ): Vault.Page<T> {
+        return adapter.queryBy(criteria, paging, sorting)
+    }
+
+    /**
+     * Tracks changes in the vault given the specified criteria, paging and sorting.
+     *
+     * @param criteria The query criteria to use in vault tracking.
+     * @param paging The paging specification to use in vault tracking.
+     * @param sorting The sorting to use in vault tracking.
+     * @return Returns a data feed of tracked items from the vault.
+     */
+    fun trackBy(
+        criteria: QueryCriteria = defaultTrackingCriteria,
+        paging: PageSpecification = DEFAULT_PAGE_SPECIFICATION,
+        sorting: Sort = DEFAULT_SORTING
+    ): DataFeed<Vault.Page<T>, Vault.Update<T>> {
+        return adapter.trackBy(criteria, paging, sorting)
+    }
+}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Notaries.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Notaries.kt
index 63c9cb3..4130ee2 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Notaries.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Notaries.kt
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.onixlabs.corda.core.workflow
 
 import co.paralleluniverse.fibers.Suspendable
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Sessions.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Sessions.kt
index 91406c1..3344698 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Sessions.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Sessions.kt
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.onixlabs.corda.core.workflow
 
 import co.paralleluniverse.fibers.Suspendable
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Transaction.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Transaction.kt
index 272d6e0..d2ea079 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Transaction.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowLogic.Transaction.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowSession.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowSession.kt
index b5e3441..0ef2f6d 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowSession.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Extensions.FlowSession.kt
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.onixlabs.corda.core.workflow
 
 import net.corda.core.contracts.ContractState
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/FindStateFlow.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/FindStateFlow.kt
deleted file mode 100644
index e0a2a98..0000000
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/FindStateFlow.kt
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * Copyright 2020 Matthew Layton
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.onixlabs.corda.core.workflow
-
-import co.paralleluniverse.fibers.Suspendable
-import net.corda.core.contracts.ContractState
-import net.corda.core.contracts.StateAndRef
-import net.corda.core.flows.FlowLogic
-import net.corda.core.flows.StartableByRPC
-import net.corda.core.flows.StartableByService
-import net.corda.core.node.services.vault.PageSpecification
-import net.corda.core.node.services.vault.QueryCriteria
-import kotlin.reflect.jvm.jvmErasure
-
-/**
- * Represents the base class for implementing flows to find individual states.
- *
- * @property criteria The vault query criteria expression.
- * @property pageSpecification The vault query page specification.
- * @property contractStateType The vault query contract state type.
- */
-@StartableByRPC
-@StartableByService
-abstract class FindStateFlow<T> : FlowLogic<StateAndRef<T>?>() where T : ContractState {
-    protected abstract val criteria: QueryCriteria
-    protected abstract val pageSpecification: PageSpecification
-
-    @Suppress("UNCHECKED_CAST")
-    protected val contractStateType: Class<T>
-        get() = javaClass.kotlin.supertypes[0].arguments[0].type?.jvmErasure?.javaObjectType as Class<T>
-
-    @Suspendable
-    override fun call(): StateAndRef<T>? {
-        return serviceHub.vaultService.queryBy(contractStateType, criteria, pageSpecification).states.singleOrNull()
-    }
-}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/FindStatesFlow.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/FindStatesFlow.kt
deleted file mode 100644
index 6fd5989..0000000
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/FindStatesFlow.kt
+++ /dev/null
@@ -1,52 +0,0 @@
-/**
- * Copyright 2020 Matthew Layton
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.onixlabs.corda.core.workflow
-
-import co.paralleluniverse.fibers.Suspendable
-import net.corda.core.contracts.ContractState
-import net.corda.core.contracts.StateAndRef
-import net.corda.core.flows.FlowLogic
-import net.corda.core.flows.StartableByRPC
-import net.corda.core.flows.StartableByService
-import net.corda.core.node.services.vault.PageSpecification
-import net.corda.core.node.services.vault.QueryCriteria
-import net.corda.core.node.services.vault.Sort
-import kotlin.reflect.jvm.jvmErasure
-
-/**
- * Represents the base class for implementing flows to find multiple states.
- *
- * @property criteria The vault query criteria expression.
- * @property pageSpecification The vault query page specification.
- * @property contractStateType The vault query contract state type.
- */
-@StartableByRPC
-@StartableByService
-abstract class FindStatesFlow<T : ContractState> : FlowLogic<List<StateAndRef<T>>>() {
-    protected abstract val criteria: QueryCriteria
-    protected abstract val pageSpecification: PageSpecification
-    protected abstract val sorting: Sort
-
-    @Suppress("UNCHECKED_CAST")
-    protected val contractStateType: Class<T>
-        get() = javaClass.kotlin.supertypes[0].arguments[0].type?.jvmErasure?.javaObjectType as Class<T>
-
-    @Suspendable
-    override fun call(): List<StateAndRef<T>> {
-        return serviceHub.vaultService.queryBy(contractStateType, criteria, pageSpecification, sorting).states
-    }
-}
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Message.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Message.kt
index b9c52c0..3ab94cd 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Message.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/Message.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/MessageAcknowledgement.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/MessageAcknowledgement.kt
index fc16267..3accb94 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/MessageAcknowledgement.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/MessageAcknowledgement.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveMessageAcknowledgementFlow.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveMessageAcknowledgementFlow.kt
index 2ceeab3..53e6491 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveMessageAcknowledgementFlow.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveMessageAcknowledgementFlow.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveMessageFlow.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveMessageFlow.kt
index a41bdc7..0f1166a 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveMessageFlow.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveMessageFlow.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveTransactionNoteFlow.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveTransactionNoteFlow.kt
index eb3168e..9b02ff2 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveTransactionNoteFlow.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/ReceiveTransactionNoteFlow.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendMessageAcknowledgementFlow.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendMessageAcknowledgementFlow.kt
index b2157ab..5e52277 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendMessageAcknowledgementFlow.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendMessageAcknowledgementFlow.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendMessageFlow.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendMessageFlow.kt
index b376562..8a48b5a 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendMessageFlow.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendMessageFlow.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendTransactionNoteFlow.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendTransactionNoteFlow.kt
index 812bfed..1a5b8e4 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendTransactionNoteFlow.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/SendTransactionNoteFlow.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/TransactionNote.kt b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/TransactionNote.kt
index 763e19c..ed8eeff 100644
--- a/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/TransactionNote.kt
+++ b/onixlabs-corda-core-workflow/src/main/kotlin/io/onixlabs/corda/core/workflow/TransactionNote.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
diff --git a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/MessageWithAcknowledgementFlowTests.kt b/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/MessageWithAcknowledgementFlowTests.kt
deleted file mode 100644
index b8ac352..0000000
--- a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/MessageWithAcknowledgementFlowTests.kt
+++ /dev/null
@@ -1,31 +0,0 @@
-package io.onixlabs.corda.core.workflow.messaging
-
-import io.onixlabs.corda.core.workflow.FlowTest
-import io.onixlabs.corda.core.workflow.Message
-import io.onixlabs.corda.core.workflow.MessageAcknowledgement
-import io.onixlabs.corda.core.workflow.Pipeline
-import io.onixlabs.corda.core.workflow.messaging.flows.SendFlow
-import net.corda.core.identity.Party
-import org.junit.jupiter.api.Test
-import kotlin.test.assertEquals
-
-class MessageWithAcknowledgementFlowTests : FlowTest() {
-
-    private val message = Message("Hello, World!")
-    private lateinit var result: Map<Party, MessageAcknowledgement>
-
-    override fun initialize() {
-
-        Pipeline
-            .create(network)
-            .run(nodeA) { SendFlow(message, setOf(partyB, partyC)) }
-            .finally { result = it }
-    }
-
-    @Test
-    @Suppress("UNCHECKED_CAST")
-    fun `Sender should receive expected message acknowledgement`() {
-        assertEquals(result.keys, setOf(partyB, partyC))
-        result.forEach { (_, acknowledgement) -> assertEquals(message.id, acknowledgement.id) }
-    }
-}
diff --git a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/flows/ReceiveFlow.kt b/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/flows/ReceiveFlow.kt
deleted file mode 100644
index 2101f8f..0000000
--- a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/flows/ReceiveFlow.kt
+++ /dev/null
@@ -1,20 +0,0 @@
-package io.onixlabs.corda.core.workflow.messaging.flows
-
-import co.paralleluniverse.fibers.Suspendable
-import io.onixlabs.corda.core.workflow.Message
-import io.onixlabs.corda.core.workflow.ReceiveMessageFlow
-import net.corda.core.flows.FlowLogic
-import net.corda.core.flows.FlowSession
-import net.corda.core.flows.InitiatedBy
-import net.corda.core.identity.Party
-
-@InitiatedBy(SendFlow::class)
-class ReceiveFlow<T>(
-    private val session: FlowSession
-) : FlowLogic<Pair<Party, T>>() where T : Message<*> {
-
-    @Suspendable
-    override fun call(): Pair<Party, T> {
-        return subFlow(ReceiveMessageFlow(session, true))
-    }
-}
diff --git a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/flows/SendFlow.kt b/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/flows/SendFlow.kt
deleted file mode 100644
index 96f66c5..0000000
--- a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/flows/SendFlow.kt
+++ /dev/null
@@ -1,23 +0,0 @@
-package io.onixlabs.corda.core.workflow.messaging.flows
-
-import co.paralleluniverse.fibers.Suspendable
-import io.onixlabs.corda.core.workflow.initiateFlows
-import io.onixlabs.corda.core.workflow.Message
-import io.onixlabs.corda.core.workflow.MessageAcknowledgement
-import io.onixlabs.corda.core.workflow.SendMessageFlow
-import net.corda.core.flows.FlowLogic
-import net.corda.core.flows.InitiatingFlow
-import net.corda.core.identity.Party
-
-@InitiatingFlow
-class SendFlow<T>(
-    private val message: T,
-    private val counterparties: Set<Party>
-) : FlowLogic<Map<Party, MessageAcknowledgement>>() where T : Message<*> {
-
-    @Suspendable
-    override fun call(): Map<Party, MessageAcknowledgement> {
-        val sessions = initiateFlows(counterparties)
-        return subFlow(SendMessageFlow(message, sessions, true))
-    }
-}
diff --git a/onixlabs-corda-test-contract/build.gradle b/onixlabs-corda-test-contract/build.gradle
new file mode 100644
index 0000000..9291cd7
--- /dev/null
+++ b/onixlabs-corda-test-contract/build.gradle
@@ -0,0 +1,36 @@
+cordapp {
+    targetPlatformVersion cordapp_platform_version
+    minimumPlatformVersion cordapp_platform_version
+    contract {
+        name 'ONIXLabs Corda Test Contract'
+        vendor cordapp_vendor_name
+        licence cordapp_license
+        versionId cordapp_version_id
+    }
+    signing {
+        enabled = cordapp_signing_enabled
+        options {
+            keystore cordapp_signing_keystore
+            alias cordapp_signing_alias
+            storepass cordapp_signing_password
+            keypass cordapp_signing_password
+            storetype cordapp_signing_storetype
+        }
+    }
+}
+
+dependencies {
+    // Kotlin Dependencies
+    implementation "$kotlin_group:kotlin-stdlib-jdk8:$kotlin_version"
+
+    // Corda Development Dependencies
+    cordaCompile "$corda_group:corda-core:$corda_release_version"
+    cordapp project(":onixlabs-corda-core-contract")
+    cordapp project(":onixlabs-corda-core-workflow")
+
+    // Test Dependencies
+    testRuntimeOnly "$junit_group:junit-jupiter-engine:$junit_version"
+    testImplementation "$junit_group:junit-jupiter-api:$junit_version"
+    testImplementation "$kotlin_group:kotlin-test:$kotlin_version"
+    testImplementation "$corda_group:corda-node-driver:$corda_release_version"
+}
diff --git a/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/Customer.kt b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/Customer.kt
new file mode 100644
index 0000000..6f50b23
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/Customer.kt
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import io.onixlabs.corda.core.contract.AbstractPluralResolvable
+import io.onixlabs.corda.core.contract.ChainState
+import io.onixlabs.corda.core.contract.Hashable
+import io.onixlabs.corda.core.contract.PluralResolvable
+import io.onixlabs.corda.core.services.equalTo
+import io.onixlabs.corda.core.services.vaultQuery
+import net.corda.core.contracts.*
+import net.corda.core.crypto.SecureHash
+import net.corda.core.identity.AbstractParty
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.schemas.MappedSchema
+import net.corda.core.schemas.PersistentState
+import net.corda.core.schemas.QueryableState
+import java.time.Instant
+
+@BelongsToContract(CustomerContract::class)
+data class Customer(
+    val owner: AbstractParty,
+    val firstName: String,
+    val lastName: String,
+    val birthday: Instant,
+    override val previousStateRef: StateRef? = null,
+    override val linearId: UniqueIdentifier = UniqueIdentifier()
+) : LinearState, QueryableState, ChainState, Hashable {
+
+    val rewards: PluralResolvable<Reward> get() = RewardResolver(this)
+
+    override val hash: SecureHash
+        get() = SecureHash.sha256("$firstName$lastName$birthday$previousStateRef")
+
+    override val participants: List<AbstractParty>
+        get() = listOf(owner)
+
+    override fun generateMappedObject(schema: MappedSchema): PersistentState = when (schema) {
+        is CustomerEntity.CustomerSchema.CustomerSchemaV1 -> CustomerEntity(
+            linearId = linearId.id,
+            externalId = linearId.externalId,
+            owner = owner,
+            firstName = firstName,
+            lastName = lastName,
+            birthday = birthday,
+            previousStateRef = previousStateRef?.toString(),
+            hash = hash.toString()
+        )
+        else -> throw IllegalArgumentException("Unrecognised schema: $schema.")
+    }
+
+    override fun supportedSchemas(): Iterable<MappedSchema> {
+        return listOf(CustomerEntity.CustomerSchema.CustomerSchemaV1)
+    }
+
+    private class RewardResolver(private val customer: Customer) : AbstractPluralResolvable<Reward>() {
+
+        override val criteria: QueryCriteria = vaultQuery<Reward> {
+            expression(RewardEntity::owner equalTo customer.owner)
+            expression(RewardEntity::customerLinearId equalTo customer.linearId.id)
+            expression(RewardEntity::customerExternalId equalTo  customer.linearId.externalId)
+        }
+
+        override fun isPointingTo(stateAndRef: StateAndRef<Reward>): Boolean = with(stateAndRef.state) {
+            data.customerLinearId == customer.linearId && data.owner == customer.owner
+        }
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/CustomerContract.kt b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/CustomerContract.kt
new file mode 100644
index 0000000..b4af914
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/CustomerContract.kt
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import io.onixlabs.corda.core.contract.ContractID
+import io.onixlabs.corda.core.contract.VerifiedCommandData
+import io.onixlabs.corda.core.contract.allowCommands
+import net.corda.core.contracts.Contract
+import net.corda.core.contracts.requireThat
+import net.corda.core.transactions.LedgerTransaction
+import java.security.PublicKey
+
+class CustomerContract : Contract {
+
+    companion object : ContractID
+
+    override fun verify(tx: LedgerTransaction) = tx.allowCommands(
+        Issue::class.java,
+        Amend::class.java,
+        Revoke::class.java
+    )
+
+    interface CustomerContractCommand : VerifiedCommandData
+
+    object Issue : CustomerContractCommand {
+
+        internal const val CONTRACT_RULE_INPUTS =
+            "On customer issuing, zero customer states must be consumed."
+
+        internal const val CONTRACT_RULE_OUTPUTS =
+            "On customer issuing, only one customer state must be created."
+
+        internal const val CONTRACT_RULE_FIRST_NAME =
+            "On customer issuing, the created customer's first name must not be blank."
+
+        internal const val CONTRACT_RULE_LAST_NAME =
+            "On customer issuing, the created customer's last name must not be blank."
+
+        internal const val CONTRACT_RULE_PREVIOUS_STATE_REF =
+            "On customer issuing, the created customer's previous state reference must be null."
+
+        internal const val CONTRACT_RULE_SIGNERS =
+            "On customer issuing, the created customer's owner must sign the transaction."
+
+        override fun verify(transaction: LedgerTransaction, signers: Set<PublicKey>) = requireThat {
+            val customerInputs = transaction.inRefsOfType<Customer>()
+            val customerOutputs = transaction.outputsOfType<Customer>()
+
+            CONTRACT_RULE_INPUTS using (customerInputs.isEmpty())
+            CONTRACT_RULE_OUTPUTS using (customerOutputs.size == 1)
+
+            val customerOutput = customerOutputs.single()
+
+            CONTRACT_RULE_FIRST_NAME using (customerOutput.firstName.isNotBlank())
+            CONTRACT_RULE_LAST_NAME using (customerOutput.lastName.isNotBlank())
+            CONTRACT_RULE_PREVIOUS_STATE_REF using (customerOutput.previousStateRef == null)
+            CONTRACT_RULE_SIGNERS using (customerOutput.owner.owningKey in signers)
+        }
+    }
+
+    object Amend : CustomerContractCommand {
+
+        internal const val CONTRACT_RULE_INPUTS =
+            "On customer amending, only one customer state must be consumed."
+
+        internal const val CONTRACT_RULE_OUTPUTS =
+            "On customer amending, only one customer state must be created."
+
+        internal const val CONTRACT_RULE_FIRST_NAME =
+            "On customer amending, the created customer's first name must not be blank."
+
+        internal const val CONTRACT_RULE_LAST_NAME =
+            "On customer amending, the created customer's last name must not be blank."
+
+        internal const val CONTRACT_RULE_PREVIOUS_STATE_REF =
+            "On customer amending, the created customer's previous state reference must be equal to the consumed customer's state reference."
+
+        internal const val CONTRACT_RULE_SIGNERS =
+            "On customer amending, the created customer's owner must sign the transaction."
+
+        override fun verify(transaction: LedgerTransaction, signers: Set<PublicKey>) = requireThat {
+            val customerInputs = transaction.inRefsOfType<Customer>()
+            val customerOutputs = transaction.outputsOfType<Customer>()
+
+            CONTRACT_RULE_INPUTS using (customerInputs.size == 1)
+            CONTRACT_RULE_OUTPUTS using (customerOutputs.size == 1)
+
+            val customerInput = customerInputs.single()
+            val customerOutput = customerOutputs.single()
+
+            CONTRACT_RULE_FIRST_NAME using (customerOutput.firstName.isNotBlank())
+            CONTRACT_RULE_LAST_NAME using (customerOutput.lastName.isNotBlank())
+            CONTRACT_RULE_PREVIOUS_STATE_REF using (customerOutput.previousStateRef == customerInput.ref)
+            CONTRACT_RULE_SIGNERS using (customerOutput.owner.owningKey in signers)
+        }
+    }
+
+    object Revoke : CustomerContractCommand {
+
+        internal const val CONTRACT_RULE_INPUTS =
+            "On customer revoking, only one customer state must be consumed."
+
+        internal const val CONTRACT_RULE_OUTPUTS =
+            "On customer revoking, zero customer states must be created."
+
+        internal const val CONTRACT_RULE_SIGNERS =
+            "On customer revoking, the consumed customer's owner must sign the transaction."
+
+        override fun verify(transaction: LedgerTransaction, signers: Set<PublicKey>) = requireThat {
+            val customerInputs = transaction.inRefsOfType<Customer>()
+            val customerOutputs = transaction.outputsOfType<Customer>()
+
+            CONTRACT_RULE_INPUTS using (customerInputs.size == 1)
+            CONTRACT_RULE_OUTPUTS using (customerOutputs.isEmpty())
+
+            val customerInput = customerInputs.single()
+
+            CONTRACT_RULE_SIGNERS using (customerInput.state.data.owner.owningKey in signers)
+        }
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/CustomerEntity.kt b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/CustomerEntity.kt
new file mode 100644
index 0000000..f830eff
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/CustomerEntity.kt
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import net.corda.core.crypto.NullKeys.NULL_PARTY
+import net.corda.core.identity.AbstractParty
+import net.corda.core.schemas.MappedSchema
+import net.corda.core.schemas.PersistentState
+import java.time.Instant
+import java.util.*
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.Table
+
+@Entity
+@Table(name = "onixlabs_customer_states")
+class CustomerEntity(
+    @Column(name = "linear_id", nullable = false)
+    val linearId: UUID = UUID.randomUUID(),
+
+    @Column(name = "external_id", nullable = true)
+    val externalId: String? = null,
+
+    @Column(name = "owner", nullable = false)
+    val owner: AbstractParty = NULL_PARTY,
+
+    @Column(name = "first_name", nullable = false)
+    val firstName: String = "",
+
+    @Column(name = "last_name", nullable = false)
+    val lastName: String = "",
+
+    @Column(name = "birthday", nullable = true)
+    val birthday: Instant = Instant.MIN,
+
+    /**
+     * Since chain state previous state references should start at null,
+     * including this in the schema allows queries for all new/un-evolved states.
+     */
+    @Column(name = "previous_state_ref")
+    val previousStateRef: String? = null,
+
+    @Column(name = "hash", nullable = false, unique = true)
+    val hash: String = ""
+) : PersistentState() {
+
+    companion object CustomerSchema {
+        object CustomerSchemaV1 : MappedSchema(CustomerSchema::class.java, 1, listOf(CustomerEntity::class.java)) {
+            override val migrationResource = "customer-schema.changelog-master"
+        }
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/Reward.kt b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/Reward.kt
new file mode 100644
index 0000000..26e18b0
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/Reward.kt
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import io.onixlabs.corda.core.contract.AbstractSingularResolvable
+import io.onixlabs.corda.core.contract.SingularResolvable
+import io.onixlabs.corda.core.services.vaultQuery
+import net.corda.core.contracts.BelongsToContract
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.contracts.UniqueIdentifier
+import net.corda.core.identity.AbstractParty
+import net.corda.core.node.services.Vault
+import net.corda.core.node.services.vault.QueryCriteria
+import net.corda.core.schemas.MappedSchema
+import net.corda.core.schemas.PersistentState
+import net.corda.core.schemas.QueryableState
+
+@BelongsToContract(RewardContract::class)
+data class Reward(
+    val issuer: AbstractParty,
+    val owner: AbstractParty,
+    val points: Int,
+    val customerLinearId: UniqueIdentifier
+) : QueryableState {
+
+    val customer: SingularResolvable<Customer> get() = CustomerResolver(this)
+
+    override val participants: List<AbstractParty>
+        get() = setOf(issuer, owner).toList()
+
+    override fun generateMappedObject(schema: MappedSchema): PersistentState = when (schema) {
+        is RewardEntity.RewardSchema.RewardSchemaV1 -> RewardEntity(
+            issuer = issuer,
+            owner = owner,
+            points = points,
+            customerLinearId = customerLinearId.id,
+            customerExternalId = customerLinearId.externalId
+        )
+        else -> throw IllegalArgumentException("Unrecognised schema: $schema.")
+    }
+
+    override fun supportedSchemas(): Iterable<MappedSchema> {
+        return listOf(RewardEntity.RewardSchema.RewardSchemaV1)
+    }
+
+    private class CustomerResolver(private val reward: Reward) : AbstractSingularResolvable<Customer>() {
+
+        override val criteria: QueryCriteria = vaultQuery<Customer> {
+            relevancyStatus(Vault.RelevancyStatus.ALL)
+            linearIds(reward.customerLinearId)
+        }
+
+        override fun isPointingTo(stateAndRef: StateAndRef<Customer>): Boolean {
+            return stateAndRef.state.data.linearId == reward.customerLinearId
+        }
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/RewardContract.kt b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/RewardContract.kt
new file mode 100644
index 0000000..016e03d
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/RewardContract.kt
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import io.onixlabs.corda.core.contract.*
+import net.corda.core.contracts.Contract
+import net.corda.core.contracts.hash
+import net.corda.core.contracts.requireThat
+import net.corda.core.transactions.LedgerTransaction
+import java.security.PublicKey
+
+class RewardContract : Contract {
+
+    companion object : ContractID
+
+    override fun verify(tx: LedgerTransaction) = tx.allowCommands(Issue::class.java, Spend::class.java)
+
+    interface RewardContractCommand : VerifiedCommandData
+
+    class Issue(override val signature: SignatureData) : RewardContractCommand, SignedCommandData {
+
+        internal companion object {
+            const val CONTRACT_RULE_INPUTS =
+                "On reward issuing, zero reward states must be consumed."
+
+            const val CONTRACT_RULE_OUTPUTS =
+                "On reward issuing, only one reward state must be created."
+
+            const val CONTRACT_RULE_REFERENCES =
+                "On reward issuing, only one customer state must be referenced."
+
+            const val CONTRACT_RULE_OWNER =
+                "On reward issuing, the created reward's owner must be equal to the referenced customer's owner."
+
+            const val CONTRACT_RULE_SIGNATURE_DATA =
+                "On reward issuing, the signature data must be equal to the hash of the created reward state."
+
+            const val CONTRACT_RULE_SIGNATURE_SIGNER =
+                "On reward issuing, the signature data must be signed by the issuer of the created reward state."
+
+            const val CONTRACT_RULE_SIGNERS =
+                "On reward issuing, all participants of the created reward state must sign the transaction."
+        }
+
+        override fun verify(transaction: LedgerTransaction, signers: Set<PublicKey>) = requireThat {
+            val rewardInputs = transaction.inputsOfType<Reward>()
+            val rewardOutputs = transaction.outputsOfType<Reward>()
+            val customerReferences = transaction.referenceInputsOfType<Customer>()
+
+            CONTRACT_RULE_INPUTS using (rewardInputs.isEmpty())
+            CONTRACT_RULE_OUTPUTS using (rewardOutputs.size == 1)
+            CONTRACT_RULE_REFERENCES using (customerReferences.size == 1)
+
+            val rewardOutput = rewardOutputs.single()
+            val customerReference = customerReferences.single()
+
+            CONTRACT_RULE_OWNER using (rewardOutput.owner == customerReference.owner)
+            CONTRACT_RULE_SIGNATURE_DATA using (rewardOutput.hash().bytes.contentEquals(signature.content))
+            CONTRACT_RULE_SIGNATURE_SIGNER using (signature.verify(rewardOutput.issuer.owningKey))
+            CONTRACT_RULE_SIGNERS using (rewardOutput.participants.owningKeys.all { it in signers })
+        }
+    }
+
+    class Spend(override val signature: SignatureData) : RewardContractCommand, SignedCommandData {
+
+        internal companion object {
+            const val CONTRACT_RULE_INPUTS =
+                "On reward spending, only one reward must be consumed."
+
+            const val CONTRACT_RULE_OUTPUTS =
+                "On reward spending, zero reward states must be created."
+
+            const val CONTRACT_RULE_REFERENCES =
+                "On reward spending, only one customer state must be referenced."
+
+            const val CONTRACT_RULE_OWNER =
+                "On reward spending, the consumed reward's owner must be equal to the referenced customer's owner."
+
+            const val CONTRACT_RULE_SIGNATURE_DATA =
+                "On reward spending, the signature data must be equal to the hash of the consumed reward state."
+
+            const val CONTRACT_RULE_SIGNATURE_SIGNER =
+                "On reward spending, the signature data must be signed by the owner of the reward state."
+
+            const val CONTRACT_RULE_SIGNERS =
+                "On reward spending, all participants of the consumed reward state must sign the transaction."
+        }
+
+        override fun verify(transaction: LedgerTransaction, signers: Set<PublicKey>) = requireThat {
+            val rewardInputs = transaction.inputsOfType<Reward>()
+            val rewardOutputs = transaction.outputsOfType<Reward>()
+            val customerReferences = transaction.referenceInputsOfType<Customer>()
+
+            CONTRACT_RULE_INPUTS using (rewardInputs.size == 1)
+            CONTRACT_RULE_OUTPUTS using (rewardOutputs.isEmpty())
+            CONTRACT_RULE_REFERENCES using (customerReferences.size == 1)
+
+            val rewardInput = rewardInputs.single()
+            val customerReference = customerReferences.single()
+
+            CONTRACT_RULE_OWNER using (rewardInput.owner == customerReference.owner)
+            CONTRACT_RULE_SIGNATURE_DATA using (rewardInput.hash().bytes.contentEquals(signature.content))
+            CONTRACT_RULE_SIGNATURE_SIGNER using (signature.verify(rewardInput.owner.owningKey))
+            CONTRACT_RULE_SIGNERS using (rewardInput.participants.owningKeys.all { it in signers })
+        }
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/RewardEntity.kt b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/RewardEntity.kt
new file mode 100644
index 0000000..0e4841b
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/main/kotlin/io/onixlabs/corda/test/contract/RewardEntity.kt
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import net.corda.core.crypto.NullKeys.NULL_PARTY
+import net.corda.core.identity.AbstractParty
+import net.corda.core.schemas.MappedSchema
+import net.corda.core.schemas.PersistentState
+import java.util.*
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.Table
+
+@Entity
+@Table(name = "onixlabs_reward_states")
+class RewardEntity(
+    @Column(name = "issuer", nullable = false)
+    val issuer: AbstractParty = NULL_PARTY,
+
+    @Column(name = "owner", nullable = false)
+    val owner: AbstractParty = NULL_PARTY,
+
+    @Column(name = "points", nullable = false)
+    val points: Int = 0,
+
+    @Column(name = "customer_linear_id", nullable = false)
+    val customerLinearId: UUID = UUID.randomUUID(),
+
+    @Column(name = "customer_external_id", nullable = true)
+    val customerExternalId: String? = null
+) : PersistentState() {
+
+    companion object RewardSchema {
+        object RewardSchemaV1 : MappedSchema(RewardSchema::class.java, 1, listOf(RewardEntity::class.java)) {
+            override val migrationResource = "reward-schema.changelog-master"
+        }
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/main/resources/migration/customer-schema.changelog-master.xml b/onixlabs-corda-test-contract/src/main/resources/migration/customer-schema.changelog-master.xml
new file mode 100644
index 0000000..6a2945a
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/main/resources/migration/customer-schema.changelog-master.xml
@@ -0,0 +1,6 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <include file="migration/customer-schema.changelog-v1.xml"/>
+</databaseChangeLog>
diff --git a/onixlabs-corda-test-contract/src/main/resources/migration/customer-schema.changelog-v1.xml b/onixlabs-corda-test-contract/src/main/resources/migration/customer-schema.changelog-v1.xml
new file mode 100644
index 0000000..0374bd6
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/main/resources/migration/customer-schema.changelog-v1.xml
@@ -0,0 +1,38 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <changeSet author="ONIXLabs" id="create-onixlabs_customer_states">
+        <createTable tableName="onixlabs_customer_states">
+            <column name="output_index" type="int">
+                <constraints nullable="false"/>
+            </column>
+            <column name="transaction_id" type="nvarchar(64)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="linear_id" type="uuid">
+                <constraints nullable="false"/>
+            </column>
+            <column name="external_id" type="nvarchar(256)"/>
+            <column name="owner" type="nvarchar(256)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="first_name" type="nvarchar(64)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="last_name" type="nvarchar(64)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="birthday" type="timestamp">
+                <constraints nullable="false"/>
+            </column>
+            <column name="previous_state_ref" type="nvarchar(128)"/>
+            <column name="hash" type="nvarchar(64)">
+                <constraints nullable="false" unique="true"/>
+            </column>
+        </createTable>
+        <addPrimaryKey columnNames="output_index, transaction_id"
+                       constraintName="PK_onixlabs_customer_states"
+                       tableName="onixlabs_customer_states"/>
+    </changeSet>
+</databaseChangeLog>
diff --git a/onixlabs-corda-test-contract/src/main/resources/migration/reward-schema.changelog-master.xml b/onixlabs-corda-test-contract/src/main/resources/migration/reward-schema.changelog-master.xml
new file mode 100644
index 0000000..64fa7f6
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/main/resources/migration/reward-schema.changelog-master.xml
@@ -0,0 +1,6 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <include file="migration/reward-schema.changelog-v1.xml"/>
+</databaseChangeLog>
diff --git a/onixlabs-corda-test-contract/src/main/resources/migration/reward-schema.changelog-v1.xml b/onixlabs-corda-test-contract/src/main/resources/migration/reward-schema.changelog-v1.xml
new file mode 100644
index 0000000..1bce6b7
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/main/resources/migration/reward-schema.changelog-v1.xml
@@ -0,0 +1,31 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.5.xsd">
+    <changeSet author="ONIXLabs" id="create-onixlabs_reward_states">
+        <createTable tableName="onixlabs_reward_states">
+            <column name="output_index" type="int">
+                <constraints nullable="false"/>
+            </column>
+            <column name="transaction_id" type="nvarchar(64)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="issuer" type="nvarchar(256)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="owner" type="nvarchar(256)">
+                <constraints nullable="false"/>
+            </column>
+            <column name="points" type="int">
+                <constraints nullable="false"/>
+            </column>
+            <column name="customer_linear_id" type="uuid">
+                <constraints nullable="false"/>
+            </column>
+            <column name="customer_external_id" type="nvarchar(256)"/>
+        </createTable>
+        <addPrimaryKey columnNames="output_index, transaction_id"
+                       constraintName="PK_onixlabs_reward_states"
+                       tableName="onixlabs_reward_states"/>
+    </changeSet>
+</databaseChangeLog>
diff --git a/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/AbstractPartyExtensionTests.kt b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/AbstractPartyExtensionTests.kt
similarity index 63%
rename from onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/AbstractPartyExtensionTests.kt
rename to onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/AbstractPartyExtensionTests.kt
index cdf951f..481259b 100644
--- a/onixlabs-corda-core-contract/src/test/kotlin/io/onixlabs/corda/core/contract/AbstractPartyExtensionTests.kt
+++ b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/AbstractPartyExtensionTests.kt
@@ -1,5 +1,23 @@
-package io.onixlabs.corda.core.contract
-
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import io.onixlabs.corda.core.contract.owningKeys
+import io.onixlabs.corda.core.contract.participantHash
 import org.junit.jupiter.api.Test
 import kotlin.test.assertEquals
 
diff --git a/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/ChainStateExtensionTests.kt b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/ChainStateExtensionTests.kt
new file mode 100644
index 0000000..1b28da4
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/ChainStateExtensionTests.kt
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import io.onixlabs.corda.core.contract.ChainState
+import io.onixlabs.corda.core.contract.isPointingTo
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.contracts.TransactionState
+import net.corda.core.crypto.NullKeys.NULL_PARTY
+import net.corda.core.internal.requiredContractClassName
+import org.junit.jupiter.api.Test
+import java.time.Instant
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class ChainStateExtensionTests {
+
+    @Test
+    fun `isPointingTo should return true when the current ChainState is pointing to the specified StateAndRef`() {
+
+        // Arrange
+        val oldChainState = createStateAndRef(Customer(NULL_PARTY, "John", "Smith", Instant.MIN))
+        val newChainState = oldChainState.state.data.copy(previousStateRef = oldChainState.ref)
+
+        // Act
+        val result = newChainState.isPointingTo(oldChainState)
+
+        // Assert
+        assertTrue(result)
+    }
+
+    @Test
+    fun `isPointingTo should return false when the current ChainState is not pointing to the specified StateAndRef`() {
+
+        // Arrange
+        val oldChainState = createStateAndRef(Customer(NULL_PARTY, "John", "Smith", Instant.MIN))
+        val newChainState = oldChainState.state.data.copy(previousStateRef = EMPTY_STATE_REF)
+
+        // Act
+        val result = newChainState.isPointingTo(oldChainState)
+
+        // Assert
+        assertFalse(result)
+    }
+
+    private fun <T : ChainState> createStateAndRef(state: T): StateAndRef<T> = StateAndRef(
+        state = TransactionState(state, state.requiredContractClassName ?: "", NOTARY.party),
+        ref = RANDOM_STATE_REF
+    )
+}
diff --git a/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/ContractIDTests.kt b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/ContractIDTests.kt
new file mode 100644
index 0000000..0327492
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/ContractIDTests.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class ContractIDTests {
+
+    @Test
+    fun `CustomerContract ID should resolve to the correct canonical name`() {
+
+        // Arrange
+        val expected = "io.onixlabs.corda.test.contract.CustomerContract"
+
+        // Act
+        val actual = CustomerContract.ID
+
+        // Assert
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun `RewardContract ID should resolve to the correct canonical name`() {
+
+        // Arrange
+        val expected = "io.onixlabs.corda.test.contract.RewardContract"
+
+        // Act
+        val actual = RewardContract.ID
+
+        // Assert
+        assertEquals(expected, actual)
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/ContractTest.kt b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/ContractTest.kt
new file mode 100644
index 0000000..1b851f3
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/ContractTest.kt
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.contracts.StateRef
+import net.corda.core.crypto.SecureHash
+import net.corda.core.node.NotaryInfo
+import net.corda.testing.common.internal.testNetworkParameters
+import net.corda.testing.core.TestIdentity
+import net.corda.testing.dsl.LedgerDSL
+import net.corda.testing.dsl.TestLedgerDSLInterpreter
+import net.corda.testing.dsl.TestTransactionDSLInterpreter
+import net.corda.testing.node.MockServices
+import org.junit.jupiter.api.BeforeEach
+
+typealias MockLedger = LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter>
+
+abstract class ContractTest {
+
+    protected companion object {
+        private val cordapps = listOf(
+            "io.onixlabs.corda.core.contract",
+            "io.onixlabs.corda.test.contract"
+        )
+
+        private val contracts = listOf(
+            CustomerContract.ID,
+            RewardContract.ID
+        )
+
+        fun keysOf(vararg identities: TestIdentity) = identities.map { it.publicKey }
+    }
+
+    private lateinit var _services: MockServices
+    protected val services: MockServices get() = _services
+
+    @BeforeEach
+    private fun setup() {
+        val networkParameters = testNetworkParameters(
+            minimumPlatformVersion = 8,
+            notaries = listOf(NotaryInfo(NOTARY.party, true))
+        )
+        _services = MockServices(cordapps, IDENTITY_A, networkParameters, IDENTITY_B, IDENTITY_C)
+        contracts.forEach { _services.addMockCordapp(it) }
+    }
+
+    fun MockLedger.issue(customer: Customer): StateAndRef<Customer> {
+        val label = SecureHash.randomSHA256().toString()
+
+        transaction {
+            output(CustomerContract.ID, label, customer)
+            command(listOf(customer.owner.owningKey), CustomerContract.Issue)
+            verifies()
+        }
+
+        return retrieveOutputStateAndRef(customer.javaClass, label)
+    }
+
+    fun StateAndRef<Customer>.evolve(ref: StateRef = this.ref): Customer {
+        return state.data.copy(previousStateRef = ref)
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/CustomerContractAmendCommandTests.kt b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/CustomerContractAmendCommandTests.kt
new file mode 100644
index 0000000..500cecd
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/CustomerContractAmendCommandTests.kt
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import net.corda.testing.node.ledger
+import org.junit.jupiter.api.Test
+
+class CustomerContractAmendCommandTests : ContractTest() {
+
+    @Test
+    fun `On customer amending, the transaction must include the Amend command`() {
+        services.ledger {
+            transaction {
+                val issuedCustomer = issue(CUSTOMER_A)
+                input(issuedCustomer.ref)
+                output(CustomerContract.ID, issuedCustomer.evolve())
+                fails()
+                command(keysOf(IDENTITY_A), CustomerContract.Amend)
+                verifies()
+            }
+        }
+    }
+
+    @Test
+    fun `On customer amending, only one customer state must be consumed`() {
+        services.ledger {
+            transaction {
+                val issuedCustomer = issue(CUSTOMER_A)
+                output(CustomerContract.ID, issuedCustomer.evolve())
+                command(keysOf(IDENTITY_A), CustomerContract.Amend)
+                failsWith(CustomerContract.Amend.CONTRACT_RULE_INPUTS)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer amending, only one customer state must be created`() {
+        services.ledger {
+            transaction {
+                val issuedCustomer = issue(CUSTOMER_A)
+                input(issuedCustomer.ref)
+                output(CustomerContract.ID, issuedCustomer.evolve())
+                output(CustomerContract.ID, issuedCustomer.evolve())
+                command(keysOf(IDENTITY_A), CustomerContract.Amend)
+                failsWith(CustomerContract.Amend.CONTRACT_RULE_OUTPUTS)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer amending, the created customer's first name must not be blank`() {
+        services.ledger {
+            transaction {
+                val issuedCustomer = issue(CUSTOMER_A)
+                input(issuedCustomer.ref)
+                output(CustomerContract.ID, issuedCustomer.evolve().copy(firstName = ""))
+                command(keysOf(IDENTITY_A), CustomerContract.Amend)
+                failsWith(CustomerContract.Amend.CONTRACT_RULE_FIRST_NAME)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer amending, the created customer's last name must not be blank`() {
+        services.ledger {
+            transaction {
+                val issuedCustomer = issue(CUSTOMER_A)
+                input(issuedCustomer.ref)
+                output(CustomerContract.ID, issuedCustomer.evolve().copy(lastName = ""))
+                command(keysOf(IDENTITY_A), CustomerContract.Amend)
+                failsWith(CustomerContract.Amend.CONTRACT_RULE_LAST_NAME)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer amending, the created customer's previous state reference must be equal to the consumed customer's state reference`() {
+        services.ledger {
+            transaction {
+                val issuedCustomer = issue(CUSTOMER_A)
+                input(issuedCustomer.ref)
+                output(CustomerContract.ID, issuedCustomer.evolve().copy(previousStateRef = EMPTY_STATE_REF))
+                command(keysOf(IDENTITY_A), CustomerContract.Amend)
+                failsWith(CustomerContract.Amend.CONTRACT_RULE_PREVIOUS_STATE_REF)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer amending, the created customer's owner must sign the transaction`() {
+        services.ledger {
+            transaction {
+                val issuedCustomer = issue(CUSTOMER_A)
+                input(issuedCustomer.ref)
+                output(CustomerContract.ID, issuedCustomer.evolve())
+                command(keysOf(IDENTITY_B), CustomerContract.Amend)
+                failsWith(CustomerContract.Amend.CONTRACT_RULE_SIGNERS)
+            }
+        }
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/CustomerContractIssueCommandTests.kt b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/CustomerContractIssueCommandTests.kt
new file mode 100644
index 0000000..763ef84
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/CustomerContractIssueCommandTests.kt
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import net.corda.testing.node.ledger
+import org.junit.jupiter.api.Test
+
+class CustomerContractIssueCommandTests : ContractTest() {
+
+    @Test
+    fun `On customer issuing, the transaction must include the Issue command`() {
+        services.ledger {
+            transaction {
+                output(CustomerContract.ID, CUSTOMER_A)
+                fails()
+                command(keysOf(IDENTITY_A), CustomerContract.Issue)
+                verifies()
+            }
+        }
+    }
+
+    @Test
+    fun `On customer issuing, zero customer states must be consumed`() {
+        services.ledger {
+            transaction {
+                input(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_A), CustomerContract.Issue)
+                failsWith(CustomerContract.Issue.CONTRACT_RULE_INPUTS)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer issuing, only one customer state must be created`() {
+        services.ledger {
+            transaction {
+                output(CustomerContract.ID, CUSTOMER_A)
+                output(CustomerContract.ID, CUSTOMER_B)
+                command(keysOf(IDENTITY_A), CustomerContract.Issue)
+                failsWith(CustomerContract.Issue.CONTRACT_RULE_OUTPUTS)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer issuing, the created customer's first name must not be blank`() {
+        services.ledger {
+            transaction {
+                output(CustomerContract.ID, CUSTOMER_A.copy(firstName = ""))
+                command(keysOf(IDENTITY_A), CustomerContract.Issue)
+                failsWith(CustomerContract.Issue.CONTRACT_RULE_FIRST_NAME)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer issuing, the created customer's last name must not be blank`() {
+        services.ledger {
+            transaction {
+                output(CustomerContract.ID, CUSTOMER_A.copy(lastName = ""))
+                command(keysOf(IDENTITY_A), CustomerContract.Issue)
+                failsWith(CustomerContract.Issue.CONTRACT_RULE_LAST_NAME)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer issuing, the created customer's previous state reference must be null`() {
+        services.ledger {
+            transaction {
+                output(CustomerContract.ID, CUSTOMER_A.copy(previousStateRef = EMPTY_STATE_REF))
+                command(keysOf(IDENTITY_A), CustomerContract.Issue)
+                failsWith(CustomerContract.Issue.CONTRACT_RULE_PREVIOUS_STATE_REF)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer issuing, the created customer's owner must sign the transaction`() {
+        services.ledger {
+            transaction {
+                output(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_B), CustomerContract.Issue)
+                failsWith(CustomerContract.Issue.CONTRACT_RULE_SIGNERS)
+            }
+        }
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/CustomerContractRevokeCommandTests.kt b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/CustomerContractRevokeCommandTests.kt
new file mode 100644
index 0000000..ea6a36b
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/CustomerContractRevokeCommandTests.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import net.corda.testing.node.ledger
+import org.junit.jupiter.api.Test
+
+class CustomerContractRevokeCommandTests : ContractTest() {
+
+    @Test
+    fun `On customer revoking, the transaction must include the Revoke command`() {
+        services.ledger {
+            transaction {
+                input(CustomerContract.ID, CUSTOMER_A)
+                fails()
+                command(keysOf(IDENTITY_A), CustomerContract.Revoke)
+                verifies()
+            }
+        }
+    }
+
+    @Test
+    fun `On customer revoking, only one customer state must be consumed`() {
+        services.ledger {
+            transaction {
+                input(CustomerContract.ID, CUSTOMER_A)
+                input(CustomerContract.ID, CUSTOMER_B)
+                command(keysOf(IDENTITY_A), CustomerContract.Revoke)
+                failsWith(CustomerContract.Revoke.CONTRACT_RULE_INPUTS)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer revoking, zero customer states must be created`() {
+        services.ledger {
+            transaction {
+                input(CustomerContract.ID, CUSTOMER_A)
+                output(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_A), CustomerContract.Revoke)
+                failsWith(CustomerContract.Revoke.CONTRACT_RULE_OUTPUTS)
+            }
+        }
+    }
+
+    @Test
+    fun `On customer revoking, the consumed customer's owner must sign the transaction`() {
+        services.ledger {
+            transaction {
+                input(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_B), CustomerContract.Revoke)
+                failsWith(CustomerContract.Revoke.CONTRACT_RULE_SIGNERS)
+            }
+        }
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/MockData.kt b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/MockData.kt
new file mode 100644
index 0000000..3b354ad
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/MockData.kt
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import net.corda.core.contracts.StateRef
+import net.corda.core.crypto.SecureHash
+import net.corda.core.identity.CordaX500Name
+import net.corda.testing.core.DUMMY_NOTARY_NAME
+import net.corda.testing.core.TestIdentity
+import java.time.Instant
+
+val IDENTITY_A = TestIdentity(CordaX500Name("PartyA", "London", "GB"))
+val IDENTITY_B = TestIdentity(CordaX500Name("PartyB", "New York", "US"))
+val IDENTITY_C = TestIdentity(CordaX500Name("PartyC", "Paris", "FR"))
+val NOTARY = TestIdentity(DUMMY_NOTARY_NAME)
+
+val CUSTOMER_A = Customer(IDENTITY_A.party, "John", "Smith", Instant.MIN)
+val CUSTOMER_B = Customer(IDENTITY_B.party, "Joan", "Smith", Instant.MAX)
+
+val REWARD_A = Reward(IDENTITY_C.party, IDENTITY_A.party, 100, CUSTOMER_A.linearId)
+val REWARD_B = Reward(IDENTITY_C.party, IDENTITY_B.party, 100, CUSTOMER_B.linearId)
+
+val EMPTY_STATE_REF: StateRef get() = StateRef(SecureHash.zeroHash, 0)
+val RANDOM_STATE_REF: StateRef get() = StateRef(SecureHash.randomSHA256(), 0)
\ No newline at end of file
diff --git a/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/RewardContractIssueCommandTests.kt b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/RewardContractIssueCommandTests.kt
new file mode 100644
index 0000000..8c78321
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/RewardContractIssueCommandTests.kt
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import io.onixlabs.corda.core.contract.SignatureData
+import net.corda.core.contracts.hash
+import net.corda.testing.node.ledger
+import org.junit.jupiter.api.Test
+
+class RewardContractIssueCommandTests : ContractTest() {
+
+    @Test
+    fun `On reward issuing, the transaction must include the Issue command`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_C.keyPair.private)
+                output(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                fails()
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Issue(signature))
+                verifies()
+            }
+        }
+    }
+
+    @Test
+    fun `On reward issuing, zero reward states must be consumed`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_C.keyPair.private)
+                input(RewardContract.ID, REWARD_A)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Issue(signature))
+                failsWith(RewardContract.Issue.CONTRACT_RULE_INPUTS)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward issuing, only one reward state must be created`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_C.keyPair.private)
+                output(RewardContract.ID, REWARD_A)
+                output(RewardContract.ID, REWARD_A)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Issue(signature))
+                failsWith(RewardContract.Issue.CONTRACT_RULE_OUTPUTS)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward issuing, only one customer state must be referenced`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_C.keyPair.private)
+                output(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                reference(CustomerContract.ID, CUSTOMER_B)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Issue(signature))
+                failsWith(RewardContract.Issue.CONTRACT_RULE_REFERENCES)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward issuing, the created reward's owner must be equal to the referenced customer's owner`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_C.keyPair.private)
+                output(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_B)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Issue(signature))
+                failsWith(RewardContract.Issue.CONTRACT_RULE_OWNER)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward issuing, the signature data must be equal to the hash of the created reward state`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_B.hash().bytes, IDENTITY_C.keyPair.private)
+                output(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Issue(signature))
+                failsWith(RewardContract.Issue.CONTRACT_RULE_SIGNATURE_DATA)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward issuing, the signature data must be signed by the issuer of the created reward state`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_A.keyPair.private)
+                output(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Issue(signature))
+                failsWith(RewardContract.Issue.CONTRACT_RULE_SIGNATURE_SIGNER)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward issuing, all participants of the created reward state must sign the transaction (IDENTITY_A missing)`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_C.keyPair.private)
+                output(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_C), RewardContract.Issue(signature))
+                failsWith(RewardContract.Issue.CONTRACT_RULE_SIGNERS)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward issuing, all participants of the created reward state must sign the transaction (IDENTITY_C missing)`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_C.keyPair.private)
+                output(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_A), RewardContract.Issue(signature))
+                failsWith(RewardContract.Issue.CONTRACT_RULE_SIGNERS)
+            }
+        }
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/RewardContractSpendCommandTests.kt b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/RewardContractSpendCommandTests.kt
new file mode 100644
index 0000000..4c5eb2f
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/RewardContractSpendCommandTests.kt
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import io.onixlabs.corda.core.contract.SignatureData
+import net.corda.core.contracts.hash
+import net.corda.testing.node.ledger
+import org.junit.jupiter.api.Test
+
+class RewardContractSpendCommandTests : ContractTest() {
+
+    @Test
+    fun `On reward spending, the transaction must include the Spend command`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_A.keyPair.private)
+                input(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                fails()
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Spend(signature))
+                verifies()
+            }
+        }
+    }
+
+    @Test
+    fun `On reward spending, only one reward must be consumed`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_A.keyPair.private)
+                input(RewardContract.ID, REWARD_A)
+                input(RewardContract.ID, REWARD_A)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Spend(signature))
+                failsWith(RewardContract.Spend.CONTRACT_RULE_INPUTS)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward spending, zero reward states must be created`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_A.keyPair.private)
+                input(RewardContract.ID, REWARD_A)
+                output(RewardContract.ID, REWARD_A)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Spend(signature))
+                failsWith(RewardContract.Spend.CONTRACT_RULE_OUTPUTS)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward spending, only one customer state must be referenced`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_A.keyPair.private)
+                input(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                reference(CustomerContract.ID, CUSTOMER_B)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Spend(signature))
+                failsWith(RewardContract.Spend.CONTRACT_RULE_REFERENCES)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward spending, the consumed reward's owner must be equal to the referenced customer's owner`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_A.keyPair.private)
+                input(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_B)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Spend(signature))
+                failsWith(RewardContract.Spend.CONTRACT_RULE_OWNER)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward spending, the signature data must be equal to the hash of the consumed reward state`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_B.hash().bytes, IDENTITY_A.keyPair.private)
+                input(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Spend(signature))
+                failsWith(RewardContract.Spend.CONTRACT_RULE_SIGNATURE_DATA)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward spending, the signature data must be signed by the owner of the reward state`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_C.keyPair.private)
+                input(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_A, IDENTITY_C), RewardContract.Spend(signature))
+                failsWith(RewardContract.Spend.CONTRACT_RULE_SIGNATURE_SIGNER)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward spending, all participants of the consumed reward state must sign the transaction (IDENTITY_A missing)`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_A.keyPair.private)
+                input(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_C), RewardContract.Spend(signature))
+                failsWith(RewardContract.Spend.CONTRACT_RULE_SIGNERS)
+            }
+        }
+    }
+
+    @Test
+    fun `On reward spending, all participants of the consumed reward state must sign the transaction (IDENTITY_C missing)`() {
+        services.ledger {
+            transaction {
+                val signature = SignatureData.create(REWARD_A.hash().bytes, IDENTITY_A.keyPair.private)
+                input(RewardContract.ID, REWARD_A)
+                reference(CustomerContract.ID, CUSTOMER_A)
+                command(keysOf(IDENTITY_A), RewardContract.Spend(signature))
+                failsWith(RewardContract.Spend.CONTRACT_RULE_SIGNERS)
+            }
+        }
+    }
+}
diff --git a/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/SignatureDataTests.kt b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/SignatureDataTests.kt
new file mode 100644
index 0000000..fc81166
--- /dev/null
+++ b/onixlabs-corda-test-contract/src/test/kotlin/io/onixlabs/corda/test/contract/SignatureDataTests.kt
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.contract
+
+import io.onixlabs.corda.core.contract.SignatureData
+import net.corda.core.crypto.SecureHash
+import net.corda.core.crypto.sign
+import org.junit.jupiter.api.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class SignatureDataTests {
+
+    @Test
+    fun `verify of SignatureData should return true when verified by the correct public key`() {
+
+        // Arrange
+        val content = SecureHash.randomSHA256().bytes
+        val signature = IDENTITY_A.keyPair.private.sign(content)
+        val signatureData = SignatureData(content, signature)
+
+        // Act
+        val result = signatureData.verify(IDENTITY_A.publicKey)
+
+        // Assert
+        assertTrue(result)
+    }
+
+    @Test
+    fun `verify of SignatureData should return false when verified by the incorrect public key`() {
+
+        // Arrange
+        val content = SecureHash.randomSHA256().bytes
+        val signature = IDENTITY_A.keyPair.private.sign(content)
+        val signatureData = SignatureData(content, signature)
+
+        // Act
+        val result = signatureData.verify(IDENTITY_B.publicKey)
+
+        // Assert
+        assertFalse(result)
+    }
+}
diff --git a/onixlabs-corda-test-workflow/build.gradle b/onixlabs-corda-test-workflow/build.gradle
new file mode 100644
index 0000000..837b8c5
--- /dev/null
+++ b/onixlabs-corda-test-workflow/build.gradle
@@ -0,0 +1,37 @@
+cordapp {
+    targetPlatformVersion cordapp_platform_version
+    minimumPlatformVersion cordapp_platform_version
+    workflow {
+        name 'ONIXLabs Corda Test Workflow'
+        vendor cordapp_vendor_name
+        licence cordapp_license
+        versionId cordapp_version_id
+    }
+    signing {
+        enabled = cordapp_signing_enabled
+        options {
+            keystore cordapp_signing_keystore
+            alias cordapp_signing_alias
+            storepass cordapp_signing_password
+            keypass cordapp_signing_password
+            storetype cordapp_signing_storetype
+        }
+    }
+}
+
+dependencies {
+    // Kotlin Dependencies
+    implementation "$kotlin_group:kotlin-stdlib-jdk8:$kotlin_version"
+
+    // Corda Development Dependencies
+    cordaCompile "$corda_group:corda-core:$corda_release_version"
+    cordapp project(":onixlabs-corda-core-contract")
+    cordapp project(":onixlabs-corda-test-contract")
+    cordapp project(":onixlabs-corda-core-workflow")
+
+    // Test Dependencies
+    testRuntimeOnly "$junit_group:junit-jupiter-engine:$junit_version"
+    testImplementation "$junit_group:junit-jupiter-api:$junit_version"
+    testImplementation "$kotlin_group:kotlin-test:$kotlin_version"
+    testImplementation "$corda_group:corda-node-driver:$corda_release_version"
+}
diff --git a/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/AmendCustomerFlow.kt b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/AmendCustomerFlow.kt
new file mode 100644
index 0000000..04f4884
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/AmendCustomerFlow.kt
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow
+
+import co.paralleluniverse.fibers.Suspendable
+import io.onixlabs.corda.core.workflow.firstNotary
+import io.onixlabs.corda.core.workflow.getPreferredNotary
+import io.onixlabs.corda.core.workflow.initiateFlows
+import io.onixlabs.corda.test.contract.Customer
+import io.onixlabs.corda.test.contract.CustomerContract
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.flows.*
+import net.corda.core.identity.Party
+import net.corda.core.transactions.SignedTransaction
+import net.corda.core.transactions.TransactionBuilder
+
+class AmendCustomerFlow(
+    private val oldCustomer: StateAndRef<Customer>,
+    private val newCustomer: Customer,
+    private val notary: Party,
+    private val sessions: Set<FlowSession> = emptySet()
+) : FlowLogic<SignedTransaction>() {
+
+    @Suspendable
+    override fun call(): SignedTransaction {
+        val transaction = with(TransactionBuilder(notary)) {
+            addInputState(oldCustomer)
+            addOutputState(newCustomer)
+            addCommand(CustomerContract.Amend, newCustomer.owner.owningKey)
+        }
+
+        transaction.verify(serviceHub)
+        val signedTransaction = serviceHub.signInitialTransaction(transaction, newCustomer.owner.owningKey)
+        return subFlow(FinalityFlow(signedTransaction, sessions))
+    }
+
+    @StartableByRPC
+    @StartableByService
+    @InitiatingFlow(version = 1)
+    class Initiator(
+        private val oldCustomer: StateAndRef<Customer>,
+        private val newCustomer: Customer,
+        private val notary: Party? = null,
+        private val observers: Set<Party> = emptySet()
+    ) : FlowLogic<SignedTransaction>() {
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            val sessions = initiateFlows(observers)
+            return subFlow(
+                AmendCustomerFlow(
+                    oldCustomer,
+                    newCustomer,
+                    notary ?: getPreferredNotary { firstNotary },
+                    sessions
+                )
+            )
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/AmendCustomerFlowHandler.kt b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/AmendCustomerFlowHandler.kt
new file mode 100644
index 0000000..b5ba139
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/AmendCustomerFlowHandler.kt
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow
+
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.FlowSession
+import net.corda.core.flows.InitiatedBy
+import net.corda.core.flows.ReceiveFinalityFlow
+import net.corda.core.node.StatesToRecord
+import net.corda.core.transactions.SignedTransaction
+
+class AmendCustomerFlowHandler(private val session: FlowSession) : FlowLogic<SignedTransaction>() {
+
+    @Suspendable
+    override fun call(): SignedTransaction {
+        return subFlow(ReceiveFinalityFlow(session, statesToRecord = StatesToRecord.ALL_VISIBLE))
+    }
+
+    @InitiatedBy(AmendCustomerFlow.Initiator::class)
+    private class Handler(private val session: FlowSession) : FlowLogic<SignedTransaction>() {
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            return subFlow(AmendCustomerFlowHandler(session))
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/GetCustomerRewardBalanceFlow.kt b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/GetCustomerRewardBalanceFlow.kt
new file mode 100644
index 0000000..8084248
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/GetCustomerRewardBalanceFlow.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow
+
+import co.paralleluniverse.fibers.Suspendable
+import io.onixlabs.corda.test.contract.Customer
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.StartableByRPC
+import net.corda.core.flows.StartableByService
+
+@StartableByRPC
+@StartableByService
+class GetCustomerRewardBalanceFlow(private val customer: Customer) : FlowLogic<Int>() {
+
+    @Suspendable
+    override fun call(): Int {
+        return customer.rewards.resolve(serviceHub).sumBy { it.state.data.points }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueCustomerFlow.kt b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueCustomerFlow.kt
new file mode 100644
index 0000000..0de043c
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueCustomerFlow.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow
+
+import co.paralleluniverse.fibers.Suspendable
+import io.onixlabs.corda.core.workflow.firstNotary
+import io.onixlabs.corda.core.workflow.getPreferredNotary
+import io.onixlabs.corda.core.workflow.initiateFlows
+import io.onixlabs.corda.test.contract.Customer
+import io.onixlabs.corda.test.contract.CustomerContract
+import net.corda.core.flows.*
+import net.corda.core.identity.Party
+import net.corda.core.transactions.SignedTransaction
+import net.corda.core.transactions.TransactionBuilder
+
+class IssueCustomerFlow(
+    private val customer: Customer,
+    private val notary: Party,
+    private val sessions: Set<FlowSession> = emptySet()
+) : FlowLogic<SignedTransaction>() {
+
+    @Suspendable
+    override fun call(): SignedTransaction {
+        val transaction = with(TransactionBuilder(notary)) {
+            addOutputState(customer)
+            addCommand(CustomerContract.Issue, customer.owner.owningKey)
+        }
+
+        transaction.verify(serviceHub)
+        val signedTransaction = serviceHub.signInitialTransaction(transaction, customer.owner.owningKey)
+        return subFlow(FinalityFlow(signedTransaction, sessions))
+    }
+
+    @StartableByRPC
+    @StartableByService
+    @InitiatingFlow(version = 1)
+    class Initiator(
+        private val customer: Customer,
+        private val notary: Party? = null,
+        private val observers: Set<Party> = emptySet()
+    ) : FlowLogic<SignedTransaction>() {
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            val sessions = initiateFlows(observers)
+            return subFlow(
+                IssueCustomerFlow(
+                    customer,
+                    notary ?: getPreferredNotary { firstNotary },
+                    sessions
+                )
+            )
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueCustomerFlowHandler.kt b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueCustomerFlowHandler.kt
new file mode 100644
index 0000000..e6ec3f2
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueCustomerFlowHandler.kt
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow
+
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.FlowSession
+import net.corda.core.flows.InitiatedBy
+import net.corda.core.flows.ReceiveFinalityFlow
+import net.corda.core.node.StatesToRecord
+import net.corda.core.transactions.SignedTransaction
+
+class IssueCustomerFlowHandler(private val session: FlowSession) : FlowLogic<SignedTransaction>() {
+
+    @Suspendable
+    override fun call(): SignedTransaction {
+        return subFlow(ReceiveFinalityFlow(session, statesToRecord = StatesToRecord.ALL_VISIBLE))
+    }
+
+    @InitiatedBy(IssueCustomerFlow.Initiator::class)
+    private class Handler(private val session: FlowSession) : FlowLogic<SignedTransaction>() {
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            return subFlow(IssueCustomerFlowHandler(session))
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueRewardFlow.kt b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueRewardFlow.kt
new file mode 100644
index 0000000..4c87f2a
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueRewardFlow.kt
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow
+
+import co.paralleluniverse.fibers.Suspendable
+import io.onixlabs.corda.core.contract.SignatureData
+import io.onixlabs.corda.core.contract.owningKeys
+import io.onixlabs.corda.core.contract.resolveOrThrow
+import io.onixlabs.corda.core.workflow.firstNotary
+import io.onixlabs.corda.core.workflow.getPreferredNotary
+import io.onixlabs.corda.core.workflow.initiateFlows
+import io.onixlabs.corda.test.contract.Reward
+import io.onixlabs.corda.test.contract.RewardContract
+import net.corda.core.contracts.hash
+import net.corda.core.flows.*
+import net.corda.core.identity.Party
+import net.corda.core.transactions.SignedTransaction
+import net.corda.core.transactions.TransactionBuilder
+
+class IssueRewardFlow(
+    private val reward: Reward,
+    private val notary: Party,
+    private val sessions: Set<FlowSession> = emptySet()
+) : FlowLogic<SignedTransaction>() {
+
+    @Suspendable
+    override fun call(): SignedTransaction {
+        val customer = reward.customer.resolveOrThrow(serviceHub)
+        val signature = SignatureData.create(reward.hash().bytes, reward.issuer.owningKey, serviceHub)
+
+        val transaction = with(TransactionBuilder(notary)) {
+            addOutputState(reward)
+            addReferenceState(customer.referenced())
+            addCommand(RewardContract.Issue(signature), reward.participants.owningKeys.toList())
+        }
+
+        transaction.verify(serviceHub)
+        val partiallySignedTransaction = serviceHub.signInitialTransaction(transaction, reward.issuer.owningKey)
+
+        sessions.forEach { it.send(it.counterparty.owningKey in reward.participants.owningKeys) }
+        val signingSessions = sessions.filter { it.counterparty.owningKey in reward.participants.owningKeys }
+        val fullySignedTransaction = subFlow(CollectSignaturesFlow(partiallySignedTransaction, signingSessions))
+
+        return subFlow(FinalityFlow(fullySignedTransaction, sessions))
+    }
+
+    @StartableByRPC
+    @StartableByService
+    @InitiatingFlow(version = 1)
+    class Initiator(
+        private val reward: Reward,
+        private val notary: Party? = null,
+        private val observers: Set<Party> = emptySet()
+    ) : FlowLogic<SignedTransaction>() {
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            val sessions = initiateFlows(observers, reward)
+            return subFlow(
+                IssueRewardFlow(
+                    reward,
+                    notary ?: getPreferredNotary { firstNotary },
+                    sessions
+                )
+            )
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueRewardFlowHandler.kt b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueRewardFlowHandler.kt
new file mode 100644
index 0000000..fc717d0
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/IssueRewardFlowHandler.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow
+
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.flows.*
+import net.corda.core.node.StatesToRecord
+import net.corda.core.transactions.SignedTransaction
+import net.corda.core.utilities.unwrap
+
+class IssueRewardFlowHandler(private val session: FlowSession) : FlowLogic<SignedTransaction>() {
+
+    @Suspendable
+    override fun call(): SignedTransaction {
+        return subFlow(ReceiveFinalityFlow(session, statesToRecord = StatesToRecord.ALL_VISIBLE))
+    }
+
+    @InitiatedBy(IssueRewardFlow.Initiator::class)
+    private class Handler(private val session: FlowSession) : FlowLogic<SignedTransaction>() {
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            val isRequiredToSign = session.receive<Boolean>().unwrap { it }
+
+            if (isRequiredToSign) {
+                subFlow(object : SignTransactionFlow(session) {
+                    override fun checkTransaction(stx: SignedTransaction) {
+                    }
+                })
+            }
+
+            return subFlow(IssueRewardFlowHandler(session))
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/RevokeCustomerFlow.kt b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/RevokeCustomerFlow.kt
new file mode 100644
index 0000000..bc0734f
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/RevokeCustomerFlow.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow
+
+import co.paralleluniverse.fibers.Suspendable
+import io.onixlabs.corda.core.workflow.firstNotary
+import io.onixlabs.corda.core.workflow.getPreferredNotary
+import io.onixlabs.corda.core.workflow.initiateFlows
+import io.onixlabs.corda.test.contract.Customer
+import io.onixlabs.corda.test.contract.CustomerContract
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.flows.*
+import net.corda.core.identity.Party
+import net.corda.core.transactions.SignedTransaction
+import net.corda.core.transactions.TransactionBuilder
+
+class RevokeCustomerFlow(
+    private val customer: StateAndRef<Customer>,
+    private val notary: Party,
+    private val sessions: Set<FlowSession> = emptySet()
+) : FlowLogic<SignedTransaction>() {
+
+    @Suspendable
+    override fun call(): SignedTransaction {
+        val transaction = with(TransactionBuilder(notary)) {
+            addInputState(customer)
+            addCommand(CustomerContract.Revoke, customer.state.data.owner.owningKey)
+        }
+
+        transaction.verify(serviceHub)
+        val signedTransaction = serviceHub.signInitialTransaction(transaction, customer.state.data.owner.owningKey)
+        return subFlow(FinalityFlow(signedTransaction, sessions))
+    }
+
+    @StartableByRPC
+    @StartableByService
+    @InitiatingFlow(version = 1)
+    class Initiator(
+        private val customer: StateAndRef<Customer>,
+        private val notary: Party? = null,
+        private val observers: Set<Party> = emptySet()
+    ) : FlowLogic<SignedTransaction>() {
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            val sessions = initiateFlows(observers)
+            return subFlow(
+                RevokeCustomerFlow(
+                    customer,
+                    notary ?: getPreferredNotary { firstNotary },
+                    sessions
+                )
+            )
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/RevokeCustomerFlowHandler.kt b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/RevokeCustomerFlowHandler.kt
new file mode 100644
index 0000000..0cebac9
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/RevokeCustomerFlowHandler.kt
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow
+
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.FlowSession
+import net.corda.core.flows.InitiatedBy
+import net.corda.core.flows.ReceiveFinalityFlow
+import net.corda.core.node.StatesToRecord
+import net.corda.core.transactions.SignedTransaction
+
+class RevokeCustomerFlowHandler(private val session: FlowSession) : FlowLogic<SignedTransaction>() {
+
+    @Suspendable
+    override fun call(): SignedTransaction {
+        return subFlow(ReceiveFinalityFlow(session, statesToRecord = StatesToRecord.ALL_VISIBLE))
+    }
+
+    @InitiatedBy(RevokeCustomerFlow.Initiator::class)
+    private class Handler(private val session: FlowSession) : FlowLogic<SignedTransaction>() {
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            return subFlow(RevokeCustomerFlowHandler(session))
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/SpendRewardFlow.kt b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/SpendRewardFlow.kt
new file mode 100644
index 0000000..50e071b
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/SpendRewardFlow.kt
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow
+
+import co.paralleluniverse.fibers.Suspendable
+import io.onixlabs.corda.core.contract.SignatureData
+import io.onixlabs.corda.core.contract.owningKeys
+import io.onixlabs.corda.core.contract.resolveOrThrow
+import io.onixlabs.corda.core.workflow.firstNotary
+import io.onixlabs.corda.core.workflow.getPreferredNotary
+import io.onixlabs.corda.core.workflow.initiateFlows
+import io.onixlabs.corda.test.contract.Reward
+import io.onixlabs.corda.test.contract.RewardContract
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.contracts.hash
+import net.corda.core.flows.*
+import net.corda.core.identity.Party
+import net.corda.core.transactions.SignedTransaction
+import net.corda.core.transactions.TransactionBuilder
+
+class SpendRewardFlow(
+    private val reward: StateAndRef<Reward>,
+    private val notary: Party,
+    private val sessions: Set<FlowSession> = emptySet()
+) : FlowLogic<SignedTransaction>() {
+
+    @Suspendable
+    override fun call(): SignedTransaction {
+        val rewardState = reward.state.data
+        val customer = rewardState.customer.resolveOrThrow(serviceHub)
+        val signature = SignatureData.create(rewardState.hash().bytes, rewardState.owner.owningKey, serviceHub)
+
+        val transaction = with(TransactionBuilder(notary)) {
+            addInputState(reward)
+            addReferenceState(customer.referenced())
+            addCommand(RewardContract.Spend(signature), rewardState.participants.owningKeys.toList())
+        }
+
+        transaction.verify(serviceHub)
+        val partiallySignedTransaction = serviceHub.signInitialTransaction(transaction, rewardState.owner.owningKey)
+
+        sessions.forEach { it.send(it.counterparty.owningKey in rewardState.participants.owningKeys) }
+        val signingSessions = sessions.filter { it.counterparty.owningKey in rewardState.participants.owningKeys }
+        val fullySignedTransaction = subFlow(CollectSignaturesFlow(partiallySignedTransaction, signingSessions))
+
+        return subFlow(FinalityFlow(fullySignedTransaction, sessions))
+    }
+
+    @StartableByRPC
+    @StartableByService
+    @InitiatingFlow(version = 1)
+    class Initiator(
+        private val reward: StateAndRef<Reward>,
+        private val notary: Party? = null,
+        private val observers: Set<Party> = emptySet()
+    ) : FlowLogic<SignedTransaction>() {
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            val sessions = initiateFlows(observers, reward.state.data)
+            return subFlow(
+                SpendRewardFlow(
+                    reward,
+                    notary ?: getPreferredNotary { firstNotary },
+                    sessions
+                )
+            )
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/SpendRewardFlowHandler.kt b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/SpendRewardFlowHandler.kt
new file mode 100644
index 0000000..1ef1062
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/main/kotlin/io/onixlabs/corda/test/workflow/SpendRewardFlowHandler.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow
+
+import co.paralleluniverse.fibers.Suspendable
+import net.corda.core.flows.*
+import net.corda.core.node.StatesToRecord
+import net.corda.core.transactions.SignedTransaction
+import net.corda.core.utilities.unwrap
+
+class SpendRewardFlowHandler(private val session: FlowSession) : FlowLogic<SignedTransaction>() {
+
+    @Suspendable
+    override fun call(): SignedTransaction {
+        return subFlow(ReceiveFinalityFlow(session, statesToRecord = StatesToRecord.ALL_VISIBLE))
+    }
+
+    @InitiatedBy(SpendRewardFlow.Initiator::class)
+    private class Handler(private val session: FlowSession) : FlowLogic<SignedTransaction>() {
+
+        @Suspendable
+        override fun call(): SignedTransaction {
+            val isRequiredToSign = session.receive<Boolean>().unwrap { it }
+
+            if (isRequiredToSign) {
+                subFlow(object : SignTransactionFlow(session) {
+                    override fun checkTransaction(stx: SignedTransaction) {
+                    }
+                })
+            }
+
+            return subFlow(IssueRewardFlowHandler(session))
+        }
+    }
+}
diff --git a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/FlowTest.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/FlowTest.kt
similarity index 61%
rename from onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/FlowTest.kt
rename to onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/FlowTest.kt
index f98cf66..6c8351c 100644
--- a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/FlowTest.kt
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/FlowTest.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -14,8 +14,11 @@
  * limitations under the License.
  */
 
-package io.onixlabs.corda.core.workflow
+package io.onixlabs.corda.test.workflow
 
+import io.onixlabs.corda.test.contract.Customer
+import io.onixlabs.corda.test.contract.Reward
+import net.corda.core.contracts.UniqueIdentifier
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.testing.common.internal.testNetworkParameters
@@ -27,10 +30,34 @@ import net.corda.testing.node.internal.cordappsForPackages
 import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.TestInstance
+import java.time.Instant
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 abstract class FlowTest {
 
+    protected val CUSTOMER_1_ID = UniqueIdentifier("Customer 1")
+    protected val CUSTOMER_2_ID = UniqueIdentifier("Customer 2")
+    protected val CUSTOMER_3_ID = UniqueIdentifier()
+    protected val CUSTOMER_4_ID = UniqueIdentifier()
+
+    protected val CUSTOMER_1_BIRTHDAY = Instant.parse("1970-01-01T00:00:00Z")
+    protected val CUSTOMER_2_BIRTHDAY = Instant.parse("1975-01-01T00:00:00Z")
+    protected val CUSTOMER_3_BIRTHDAY = Instant.parse("2000-01-01T00:00:00Z")
+    protected val CUSTOMER_4_BIRTHDAY = Instant.parse("2010-01-01T00:00:00Z")
+
+    protected val CUSTOMER_1 by lazy { Customer(partyA, "John", "Smith", CUSTOMER_1_BIRTHDAY, null, CUSTOMER_1_ID) }
+    protected val CUSTOMER_2 by lazy { Customer(partyA, "Jane", "Smith", CUSTOMER_2_BIRTHDAY, null, CUSTOMER_2_ID) }
+    protected val CUSTOMER_3 by lazy { Customer(partyB, "Jack", "Smith", CUSTOMER_3_BIRTHDAY, null, CUSTOMER_3_ID) }
+    protected val CUSTOMER_4 by lazy { Customer(partyB, "Jill", "Smith", CUSTOMER_4_BIRTHDAY, null, CUSTOMER_4_ID) }
+
+    protected val REWARD_A1 by lazy { Reward(partyC, partyA, 100, CUSTOMER_1_ID) }
+    protected val REWARD_A2 by lazy { Reward(partyC, partyA, 200, CUSTOMER_1_ID) }
+    protected val REWARD_A3 by lazy { Reward(partyC, partyA, 300, CUSTOMER_1_ID) }
+
+    protected val REWARD_B1 by lazy { Reward(partyC, partyB, 100, CUSTOMER_3_ID) }
+    protected val REWARD_B2 by lazy { Reward(partyC, partyB, 200, CUSTOMER_3_ID) }
+    protected val REWARD_B3 by lazy { Reward(partyC, partyB, 300, CUSTOMER_3_ID) }
+
     private lateinit var _network: MockNetwork
     protected val network: MockNetwork get() = _network
 
@@ -62,7 +89,8 @@ abstract class FlowTest {
         _network = MockNetwork(
             MockNetworkParameters(
                 cordappsForAllNodes = cordappsForPackages(
-                    "io.onixlabs.corda.core.workflow"
+                    "io.onixlabs.corda.test.contract",
+                    "io.onixlabs.corda.test.workflow"
                 ),
                 networkParameters = testNetworkParameters(
                     minimumPlatformVersion = 8
@@ -88,4 +116,4 @@ abstract class FlowTest {
         network.stopNodes()
         finalize()
     }
-}
+}
\ No newline at end of file
diff --git a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/Pipeline.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/Pipeline.kt
similarity index 91%
rename from onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/Pipeline.kt
rename to onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/Pipeline.kt
index cc6392e..3bfd8fd 100644
--- a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/Pipeline.kt
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/Pipeline.kt
@@ -1,11 +1,11 @@
-/**
- * Copyright 2020 Matthew Layton
+/*
+ * Copyright 2020-2021 ONIXLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.onixlabs.corda.core.workflow
+package io.onixlabs.corda.test.workflow
 
 import net.corda.core.flows.FlowLogic
 import net.corda.core.utilities.getOrThrow
@@ -39,4 +39,4 @@ class Pipeline<T>(val result: T, val network: MockNetwork, val timeout: Duration
     fun finally(action: (T) -> Unit) {
         action(result)
     }
-}
\ No newline at end of file
+}
diff --git a/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/AmendCustomerFlowTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/AmendCustomerFlowTests.kt
new file mode 100644
index 0000000..11e6153
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/AmendCustomerFlowTests.kt
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.customer
+
+import io.onixlabs.corda.test.contract.Customer
+import io.onixlabs.corda.test.workflow.AmendCustomerFlow
+import io.onixlabs.corda.test.workflow.FlowTest
+import io.onixlabs.corda.test.workflow.IssueCustomerFlow
+import io.onixlabs.corda.test.workflow.Pipeline
+import net.corda.core.transactions.SignedTransaction
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.fail
+import kotlin.test.assertEquals
+
+class AmendCustomerFlowTests : FlowTest() {
+
+    private lateinit var customer: Customer
+    private lateinit var transaction: SignedTransaction
+
+    override fun initialize() {
+        Pipeline
+            .create(network)
+            .run(nodeA) {
+                IssueCustomerFlow.Initiator(CUSTOMER_1, observers = setOf(partyB, partyC))
+            }
+            .run(nodeA) {
+                val issuedCustomer = it.tx.outRefsOfType<Customer>().single()
+                val amendedCustomer = issuedCustomer.state.data.copy(previousStateRef = issuedCustomer.ref)
+                AmendCustomerFlow.Initiator(issuedCustomer, amendedCustomer, observers = setOf(partyB, partyC))
+            }
+            .finally {
+                transaction = it
+                customer = it.tx.outputsOfType<Customer>().single()
+            }
+    }
+
+    @Test
+    fun `IssueCustomerFlow transaction should be signed by the initiator`() {
+        transaction.verifyRequiredSignatures()
+    }
+
+    @Test
+    fun `IssueCustomerFlow should record a transaction for the owner and observers`() {
+        listOf(nodeA, nodeB, nodeC).forEach {
+            it.transaction {
+                val recordedTransaction = it.services.validatedTransactions.getTransaction(transaction.id)
+                    ?: fail("Failed to find a recorded transaction with id: ${transaction.id}.")
+
+                assertEquals(transaction, recordedTransaction)
+            }
+        }
+    }
+
+    @Test
+    fun `IssueCustomerFlow should record a customer for the owner and observers`() {
+        listOf(nodeA, nodeB, nodeC).forEach {
+            it.transaction {
+                val recordedTransaction = it.services.validatedTransactions.getTransaction(transaction.id)
+                    ?: fail("Failed to find a recorded transaction with id: ${transaction.id}.")
+
+                val recordedCustomer = recordedTransaction
+                    .tx.outputsOfType<Customer>().singleOrNull()
+                    ?: fail("Failed to find a recorded customer.")
+
+                assertEquals(customer, recordedCustomer)
+            }
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/CustomerVaultServiceTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/CustomerVaultServiceTests.kt
new file mode 100644
index 0000000..0305823
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/CustomerVaultServiceTests.kt
@@ -0,0 +1,350 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.customer
+
+import io.onixlabs.corda.core.services.*
+import io.onixlabs.corda.test.contract.Customer
+import io.onixlabs.corda.test.contract.CustomerEntity
+import io.onixlabs.corda.test.workflow.FlowTest
+import io.onixlabs.corda.test.workflow.IssueCustomerFlow
+import io.onixlabs.corda.test.workflow.Pipeline
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class CustomerVaultServiceTests : FlowTest() {
+
+    override fun initialize() {
+        Pipeline
+            .create(network)
+            .run(nodeA) { IssueCustomerFlow.Initiator(CUSTOMER_1, observers = setOf(partyB)) }
+            .run(nodeA) { IssueCustomerFlow.Initiator(CUSTOMER_2, observers = setOf(partyB)) }
+            .run(nodeB) { IssueCustomerFlow.Initiator(CUSTOMER_3, observers = setOf(partyA)) }
+            .run(nodeB) { IssueCustomerFlow.Initiator(CUSTOMER_4, observers = setOf(partyA)) }
+    }
+
+    @Test
+    fun `VaultService linearIds should find all matching customers by linearId`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                linearIds(CUSTOMER_1_ID)
+            }.toList()
+
+            assertEquals(1, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_1 })
+        }
+    }
+
+    @Test
+    fun `VaultService notEqualTo should find all matching customers by linearId`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::linearId notEqualTo CUSTOMER_1_ID.id)
+            }.toList()
+
+            assertEquals(3, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_4 })
+        }
+    }
+
+    @Test
+    fun `VaultService equalTo should find all matching customers by owner`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::owner equalTo partyA)
+            }.toList()
+
+            assertEquals(2, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_1 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+        }
+    }
+
+    @Test
+    fun `VaultService notEqualTo should find all matching customers by owner`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::owner notEqualTo partyA)
+            }.toList()
+
+            assertEquals(2, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_4 })
+        }
+    }
+
+    @Test
+    fun `VaultService notEqualTo find all matching customers by previousStateRef`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::previousStateRef notEqualTo null)
+            }.toList()
+
+            assertEquals(0, results.count())
+        }
+    }
+
+    @Test
+    fun `VaultService equalTo should find all matching customers by firstName`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::firstName equalTo "John")
+            }.toList()
+
+            assertEquals(1, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_1 })
+        }
+    }
+
+    @Test
+    fun `VaultService notEqualTo should find all matching customers by firstName`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::firstName notEqualTo "John")
+            }.toList()
+
+            assertEquals(3, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_4 })
+        }
+    }
+
+    @Test
+    fun `VaultService equalTo should find all matching customers by externalId`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::externalId equalTo CUSTOMER_1_ID.externalId)
+            }.toList()
+
+            assertEquals(1, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_1 })
+        }
+    }
+
+    @Test
+    fun `VaultService isNull should find all matching customers by externalId (null)`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::externalId.isNull())
+            }.toList()
+
+            assertEquals(2, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_4 })
+        }
+    }
+
+    @Test
+    fun `VaultService notEqualTo should find all matching customers by externalId`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::externalId notEqualTo CUSTOMER_1_ID.externalId)
+            }.toList()
+
+            assertEquals(1, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+            //assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+            //assertEquals(1, results.count { it.state.data == CUSTOMER_4 })
+        }
+    }
+
+    @Test
+    fun `VaultService notEqualTo and isNull should find all matching customers by externalId`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::externalId notEqualTo CUSTOMER_1_ID.externalId)
+                or {
+                    expression(CustomerEntity::externalId.isNull())
+                }
+            }.toList()
+
+            assertEquals(3, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_4 })
+        }
+    }
+
+    @Test
+    fun `VaultService isNotNull should find all matching customers by externalId (null)`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::externalId.isNotNull())
+            }.toList()
+
+            assertEquals(2, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_1 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+        }
+    }
+
+    @Test
+    fun `VaultService isNull should find all matching customers by previousStateRef`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::previousStateRef.isNull())
+            }.toList()
+
+            assertEquals(4, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_1 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_4 })
+        }
+    }
+
+    @Test
+    fun `VaultService isNotNull find all matching customers by previousStateRef`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::previousStateRef.isNotNull())
+            }.toList()
+
+            assertEquals(0, results.count())
+        }
+    }
+
+    @Test
+    fun `VaultService like should find all matching customers by firstName`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::firstName like "Ja%")
+            }.toList()
+
+            assertEquals(2, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+        }
+    }
+
+    @Test
+    fun `VaultService notLike should find all matching customers by firstName`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::firstName notLike "Ja%")
+            }.toList()
+
+            assertEquals(2, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_1 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_4 })
+        }
+    }
+
+    @Test
+    fun `VaultService equalTo should find all matching customers by birthday`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::birthday equalTo CUSTOMER_1_BIRTHDAY)
+            }.toList()
+
+            assertEquals(1, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_1 })
+        }
+    }
+
+    @Test
+    fun `VaultService notEqualTo should find all matching customers by birthday`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::birthday notEqualTo CUSTOMER_1_BIRTHDAY)
+            }.toList()
+
+            assertEquals(3, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_4 })
+        }
+    }
+
+    @Test
+    fun `VaultService greaterThan should find all matching customers by birthday`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::birthday greaterThan CUSTOMER_2_BIRTHDAY)
+            }.toList()
+
+            assertEquals(2, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_4 })
+        }
+    }
+
+    @Test
+    fun `VaultService greaterThanOrEqualTo should find all matching customers by birthday`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::birthday greaterThanOrEqualTo CUSTOMER_2_BIRTHDAY)
+            }.toList()
+
+            assertEquals(3, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_4 })
+        }
+    }
+
+    @Test
+    fun `VaultService lessThan should find all matching customers by birthday`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::birthday lessThan CUSTOMER_3_BIRTHDAY)
+            }.toList()
+
+            assertEquals(2, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_1 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+        }
+    }
+
+    @Test
+    fun `VaultService lessThanOtEqualTo should find all matching customers by birthday`() {
+        listOf(nodeA, nodeB).forEach {
+
+            val results = it.services.vaultServiceFor<Customer>().filter {
+                expression(CustomerEntity::birthday lessThanOrEqualTo CUSTOMER_3_BIRTHDAY)
+            }.toList()
+
+            assertEquals(3, results.count())
+            assertEquals(1, results.count { it.state.data == CUSTOMER_1 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_2 })
+            assertEquals(1, results.count { it.state.data == CUSTOMER_3 })
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/IssueCustomerFlowTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/IssueCustomerFlowTests.kt
new file mode 100644
index 0000000..713854e
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/IssueCustomerFlowTests.kt
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.customer
+
+import io.onixlabs.corda.test.contract.Customer
+import io.onixlabs.corda.test.workflow.FlowTest
+import io.onixlabs.corda.test.workflow.IssueCustomerFlow
+import io.onixlabs.corda.test.workflow.Pipeline
+import net.corda.core.transactions.SignedTransaction
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.fail
+import kotlin.test.assertEquals
+
+class IssueCustomerFlowTests : FlowTest() {
+
+    private lateinit var customer: Customer
+    private lateinit var transaction: SignedTransaction
+
+    override fun initialize() {
+        Pipeline
+            .create(network)
+            .run(nodeA) {
+                IssueCustomerFlow.Initiator(CUSTOMER_1, observers = setOf(partyB, partyC))
+            }
+            .finally {
+                transaction = it
+                customer = it.tx.outputsOfType<Customer>().single()
+            }
+    }
+
+    @Test
+    fun `IssueCustomerFlow transaction should be signed by the initiator`() {
+        transaction.verifyRequiredSignatures()
+    }
+
+    @Test
+    fun `IssueCustomerFlow should record a transaction for the owner and observers`() {
+        listOf(nodeA, nodeB, nodeC).forEach {
+            it.transaction {
+                val recordedTransaction = it.services.validatedTransactions.getTransaction(transaction.id)
+                    ?: fail("Failed to find a recorded transaction with id: ${transaction.id}.")
+
+                assertEquals(transaction, recordedTransaction)
+            }
+        }
+    }
+
+    @Test
+    fun `IssueCustomerFlow should record a customer for the owner and observers`() {
+        listOf(nodeA, nodeB, nodeC).forEach {
+            it.transaction {
+                val recordedTransaction = it.services.validatedTransactions.getTransaction(transaction.id)
+                    ?: fail("Failed to find a recorded transaction with id: ${transaction.id}.")
+
+                val recordedCustomer = recordedTransaction
+                    .tx.outputsOfType<Customer>().singleOrNull()
+                    ?: fail("Failed to find a recorded customer.")
+
+                assertEquals(customer, recordedCustomer)
+            }
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/RevokeCustomerFlowTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/RevokeCustomerFlowTests.kt
new file mode 100644
index 0000000..2073ada
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/customer/RevokeCustomerFlowTests.kt
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.customer
+
+import io.onixlabs.corda.test.contract.Customer
+import io.onixlabs.corda.test.workflow.FlowTest
+import io.onixlabs.corda.test.workflow.IssueCustomerFlow
+import io.onixlabs.corda.test.workflow.Pipeline
+import io.onixlabs.corda.test.workflow.RevokeCustomerFlow
+import net.corda.core.transactions.SignedTransaction
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.fail
+import kotlin.test.assertEquals
+
+class RevokeCustomerFlowTests : FlowTest() {
+
+    private lateinit var transaction: SignedTransaction
+
+    override fun initialize() {
+        Pipeline
+            .create(network)
+            .run(nodeA) {
+                IssueCustomerFlow.Initiator(CUSTOMER_1, observers = setOf(partyB, partyC))
+            }
+            .run(nodeA) {
+                val issuedCustomer = it.tx.outRefsOfType<Customer>().single()
+                RevokeCustomerFlow.Initiator(issuedCustomer, observers = setOf(partyB, partyC))
+            }
+            .finally {
+                transaction = it
+            }
+    }
+
+    @Test
+    fun `IssueCustomerFlow transaction should be signed by the initiator`() {
+        transaction.verifyRequiredSignatures()
+    }
+
+    @Test
+    fun `IssueCustomerFlow should record a transaction for the owner and observers`() {
+        listOf(nodeA, nodeB, nodeC).forEach {
+            it.transaction {
+                val recordedTransaction = it.services.validatedTransactions.getTransaction(transaction.id)
+                    ?: fail("Failed to find a recorded transaction with id: ${transaction.id}.")
+
+                assertEquals(transaction, recordedTransaction)
+            }
+        }
+    }
+}
diff --git a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/MessageAcknowledgementFlowTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/messaging/MessageAcknowledgementFlowTests.kt
similarity index 57%
rename from onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/MessageAcknowledgementFlowTests.kt
rename to onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/messaging/MessageAcknowledgementFlowTests.kt
index 43c7491..0e6c145 100644
--- a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/MessageAcknowledgementFlowTests.kt
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/messaging/MessageAcknowledgementFlowTests.kt
@@ -1,6 +1,26 @@
-package io.onixlabs.corda.core.workflow.messaging
-
-import io.onixlabs.corda.core.workflow.*
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.messaging
+
+import io.onixlabs.corda.core.workflow.MessageAcknowledgement
+import io.onixlabs.corda.core.workflow.ReceiveMessageAcknowledgementFlow
+import io.onixlabs.corda.core.workflow.SendMessageAcknowledgementFlow
+import io.onixlabs.corda.test.workflow.FlowTest
+import io.onixlabs.corda.test.workflow.Pipeline
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.identity.Party
 import net.corda.core.toFuture
diff --git a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/MessageFlowTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/messaging/MessageFlowTests.kt
similarity index 58%
rename from onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/MessageFlowTests.kt
rename to onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/messaging/MessageFlowTests.kt
index 02de9de..27ef37e 100644
--- a/onixlabs-corda-core-workflow/src/test/kotlin/io/onixlabs/corda/core/workflow/messaging/MessageFlowTests.kt
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/messaging/MessageFlowTests.kt
@@ -1,6 +1,26 @@
-package io.onixlabs.corda.core.workflow.messaging
-
-import io.onixlabs.corda.core.workflow.*
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.messaging
+
+import io.onixlabs.corda.core.workflow.Message
+import io.onixlabs.corda.core.workflow.ReceiveMessageFlow
+import io.onixlabs.corda.core.workflow.SendMessageFlow
+import io.onixlabs.corda.test.workflow.FlowTest
+import io.onixlabs.corda.test.workflow.Pipeline
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.identity.Party
 import net.corda.core.toFuture
diff --git a/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/messaging/flows/SendAndReceiveAcknowledgementFlow.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/messaging/flows/SendAndReceiveAcknowledgementFlow.kt
new file mode 100644
index 0000000..205df04
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/messaging/flows/SendAndReceiveAcknowledgementFlow.kt
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.messaging.flows
+
+import co.paralleluniverse.fibers.Suspendable
+import io.onixlabs.corda.core.workflow.*
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.FlowSession
+import net.corda.core.flows.InitiatedBy
+import net.corda.core.flows.InitiatingFlow
+import net.corda.core.identity.Party
+
+@InitiatingFlow
+class SendAndReceiveAcknowledgementFlow<T>(
+    private val message: T,
+    private val counterparties: Set<Party>
+) : FlowLogic<Map<Party, MessageAcknowledgement>>() where T : Message<*> {
+
+    @Suspendable
+    override fun call(): Map<Party, MessageAcknowledgement> {
+        val sessions = initiateFlows(counterparties)
+        return subFlow(SendMessageFlow(message, sessions, true))
+    }
+
+    @InitiatedBy(SendAndReceiveAcknowledgementFlow::class)
+    private class Handler<T>(private val session: FlowSession) : FlowLogic<Pair<Party, T>>() where T : Message<*> {
+
+        @Suspendable
+        override fun call(): Pair<Party, T> {
+            return subFlow(ReceiveMessageFlow(session, true))
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/GetCustomerRewardBalanceFlowTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/GetCustomerRewardBalanceFlowTests.kt
new file mode 100644
index 0000000..0a056c7
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/GetCustomerRewardBalanceFlowTests.kt
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.reward
+
+import io.onixlabs.corda.test.workflow.*
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class GetCustomerRewardBalanceFlowTests : FlowTest() {
+
+    override fun initialize() {
+        Pipeline
+            .create(network)
+            .run(nodeA) { IssueCustomerFlow.Initiator(CUSTOMER_1, observers = setOf(partyC)) }
+            .run(nodeC) { IssueRewardFlow.Initiator(REWARD_A1) }
+            .run(nodeC) { IssueRewardFlow.Initiator(REWARD_A2) }
+            .run(nodeC) { IssueRewardFlow.Initiator(REWARD_A3) }
+    }
+
+    @Test
+    fun `GetCustomerRewardBalanceFlow should produce the correct sum of all rewards`() {
+        Pipeline
+            .create(network)
+            .run(nodeA) {
+                GetCustomerRewardBalanceFlow(CUSTOMER_1)
+            }
+            .finally {
+                assertEquals(600, it)
+            }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/IssueRewardFlowSignatureDataTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/IssueRewardFlowSignatureDataTests.kt
new file mode 100644
index 0000000..64190a0
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/IssueRewardFlowSignatureDataTests.kt
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.reward
+
+import io.onixlabs.corda.test.workflow.FlowTest
+import io.onixlabs.corda.test.workflow.IssueCustomerFlow
+import io.onixlabs.corda.test.workflow.IssueRewardFlow
+import io.onixlabs.corda.test.workflow.Pipeline
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import java.security.SignatureException
+import kotlin.test.assertEquals
+
+class IssueRewardFlowSignatureDataTests : FlowTest() {
+
+    private val expectedMessage =
+        "Failed to obtain a private key matching the specified public key from the key management service."
+
+    @Test
+    fun `IssueRewardFlow cannot issue a reward when the owner is the initiator`() {
+        val exception = assertThrows<SignatureException> {
+            Pipeline
+                .create(network)
+                .run(nodeA) {
+                    IssueCustomerFlow.Initiator(CUSTOMER_1)
+                }
+                .run(nodeA) {
+                    IssueRewardFlow.Initiator(REWARD_A1)
+                }
+        }
+
+        assertEquals(expectedMessage, exception.message)
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/IssueRewardFlowTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/IssueRewardFlowTests.kt
new file mode 100644
index 0000000..6a3c825
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/IssueRewardFlowTests.kt
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.reward
+
+import io.onixlabs.corda.test.contract.Reward
+import io.onixlabs.corda.test.workflow.FlowTest
+import io.onixlabs.corda.test.workflow.IssueCustomerFlow
+import io.onixlabs.corda.test.workflow.IssueRewardFlow
+import io.onixlabs.corda.test.workflow.Pipeline
+import net.corda.core.transactions.SignedTransaction
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.api.fail
+import kotlin.test.assertEquals
+
+class IssueRewardFlowTests : FlowTest() {
+
+    private lateinit var reward: Reward
+    private lateinit var transaction: SignedTransaction
+
+    override fun initialize() {
+        Pipeline
+            .create(network)
+            .run(nodeA) {
+                IssueCustomerFlow.Initiator(CUSTOMER_1, observers = setOf(partyB, partyC))
+            }
+            .run(nodeC) {
+                IssueRewardFlow.Initiator(REWARD_A1)
+            }
+            .finally {
+                transaction = it
+                reward = it.tx.outputsOfType<Reward>().single()
+            }
+    }
+
+    @Test
+    fun `IssueRewardFlow transaction should be signed by the initiator`() {
+        transaction.verifyRequiredSignatures()
+    }
+
+    @Test
+    fun `IssueRewardFlow should record a transaction for the owner and observers`() {
+        listOf(nodeA, nodeC).forEach {
+            it.transaction {
+                val recordedTransaction = it.services.validatedTransactions.getTransaction(transaction.id)
+                    ?: fail("Failed to find a recorded transaction with id: ${transaction.id}.")
+
+                assertEquals(transaction, recordedTransaction)
+            }
+        }
+    }
+
+    @Test
+    fun `IssueRewardFlow should record a reward for the owner and observers`() {
+        listOf(nodeA, nodeC).forEach {
+            it.transaction {
+                val recordedTransaction = it.services.validatedTransactions.getTransaction(transaction.id)
+                    ?: fail("Failed to find a recorded transaction with id: ${transaction.id}.")
+
+                val recordedReward = recordedTransaction
+                    .tx.outputsOfType<Reward>().singleOrNull()
+                    ?: fail("Failed to find a recorded reward.")
+
+                assertEquals(reward, recordedReward)
+            }
+        }
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/RewardVaultServiceTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/RewardVaultServiceTests.kt
new file mode 100644
index 0000000..f4a7db0
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/RewardVaultServiceTests.kt
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.reward
+
+import io.onixlabs.corda.core.services.*
+import io.onixlabs.corda.test.contract.Reward
+import io.onixlabs.corda.test.contract.RewardEntity
+import io.onixlabs.corda.test.workflow.FlowTest
+import io.onixlabs.corda.test.workflow.IssueCustomerFlow
+import io.onixlabs.corda.test.workflow.IssueRewardFlow
+import io.onixlabs.corda.test.workflow.Pipeline
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class RewardVaultServiceTests : FlowTest() {
+
+    override fun initialize() {
+        Pipeline
+            .create(network)
+            .run(nodeA) { IssueCustomerFlow.Initiator(CUSTOMER_1, observers = setOf(partyC)) }
+            .run(nodeB) { IssueCustomerFlow.Initiator(CUSTOMER_3, observers = setOf(partyC)) }
+            .run(nodeC) { IssueRewardFlow.Initiator(REWARD_A1) }
+            .run(nodeC) { IssueRewardFlow.Initiator(REWARD_A2) }
+            .run(nodeC) { IssueRewardFlow.Initiator(REWARD_A3) }
+            .run(nodeC) { IssueRewardFlow.Initiator(REWARD_B1) }
+            .run(nodeC) { IssueRewardFlow.Initiator(REWARD_B2) }
+            .run(nodeC) { IssueRewardFlow.Initiator(REWARD_B3) }
+    }
+
+    @Test
+    fun `VaultService equalTo should find all matching rewards by issuer`() {
+
+        val results = nodeC.services.vaultServiceFor<Reward>().filter {
+            expression(RewardEntity::issuer equalTo partyC)
+        }.toList()
+
+        assertEquals(6, results.count())
+        assertEquals(1, results.count { it.state.data == REWARD_A1 })
+        assertEquals(1, results.count { it.state.data == REWARD_A2 })
+        assertEquals(1, results.count { it.state.data == REWARD_A3 })
+        assertEquals(1, results.count { it.state.data == REWARD_B1 })
+        assertEquals(1, results.count { it.state.data == REWARD_B2 })
+        assertEquals(1, results.count { it.state.data == REWARD_B3 })
+    }
+
+    @Test
+    fun `VaultService notEqualTo should find all matching rewards by issuer`() {
+
+        val results = nodeC.services.vaultServiceFor<Reward>().filter {
+            expression(RewardEntity::issuer notEqualTo partyC)
+        }.toList()
+
+        assertEquals(0, results.count())
+    }
+
+    @Test
+    fun `VaultService equalTo should find all matching rewards by owner`() {
+
+        val results = nodeC.services.vaultServiceFor<Reward>().filter {
+            expression(RewardEntity::owner equalTo partyA)
+        }.toList()
+
+        assertEquals(3, results.count())
+        assertEquals(1, results.count { it.state.data == REWARD_A1 })
+        assertEquals(1, results.count { it.state.data == REWARD_A2 })
+        assertEquals(1, results.count { it.state.data == REWARD_A3 })
+    }
+
+    @Test
+    fun `VaultService notEqualTo should find all matching rewards by owner`() {
+
+        val results = nodeC.services.vaultServiceFor<Reward>().filter {
+            expression(RewardEntity::owner notEqualTo partyA)
+        }.toList()
+
+        assertEquals(3, results.count())
+        assertEquals(1, results.count { it.state.data == REWARD_B1 })
+        assertEquals(1, results.count { it.state.data == REWARD_B2 })
+        assertEquals(1, results.count { it.state.data == REWARD_B3 })
+    }
+
+    @Test
+    fun `VaultService equalTo should find all matching rewards by points`() {
+
+        val results = nodeC.services.vaultServiceFor<Reward>().filter {
+            expression(RewardEntity::points equalTo 200)
+        }.toList()
+
+        assertEquals(2, results.count())
+        assertEquals(1, results.count { it.state.data == REWARD_A2 })
+        assertEquals(1, results.count { it.state.data == REWARD_B2 })
+    }
+
+    @Test
+    fun `VaultService notEqualTo should find all matching rewards by points`() {
+
+        val results = nodeC.services.vaultServiceFor<Reward>().filter {
+            expression(RewardEntity::points notEqualTo 200)
+        }.toList()
+
+        assertEquals(4, results.count())
+        assertEquals(1, results.count { it.state.data == REWARD_A1 })
+        assertEquals(1, results.count { it.state.data == REWARD_A3 })
+        assertEquals(1, results.count { it.state.data == REWARD_B1 })
+        assertEquals(1, results.count { it.state.data == REWARD_B3 })
+    }
+
+    @Test
+    fun `VaultService greaterThan should find all matching rewards by points`() {
+
+        val results = nodeC.services.vaultServiceFor<Reward>().filter {
+            expression(RewardEntity::points greaterThan 100)
+        }.toList()
+
+        assertEquals(4, results.count())
+        assertEquals(1, results.count { it.state.data == REWARD_A2 })
+        assertEquals(1, results.count { it.state.data == REWARD_A3 })
+        assertEquals(1, results.count { it.state.data == REWARD_B2 })
+        assertEquals(1, results.count { it.state.data == REWARD_B3 })
+    }
+
+    @Test
+    fun `VaultService greaterThanOrEqualTo should find all matching rewards by points`() {
+
+        val results = nodeC.services.vaultServiceFor<Reward>().filter {
+            expression(RewardEntity::points greaterThanOrEqualTo 200)
+        }.toList()
+
+        assertEquals(4, results.count())
+        assertEquals(1, results.count { it.state.data == REWARD_A2 })
+        assertEquals(1, results.count { it.state.data == REWARD_A3 })
+        assertEquals(1, results.count { it.state.data == REWARD_B2 })
+        assertEquals(1, results.count { it.state.data == REWARD_B3 })
+    }
+
+    @Test
+    fun `VaultService lessThan should find all matching rewards by points`() {
+
+        val results = nodeC.services.vaultServiceFor<Reward>().filter {
+            expression(RewardEntity::points lessThan 200)
+        }.toList()
+
+        assertEquals(2, results.count())
+        assertEquals(1, results.count { it.state.data == REWARD_A1 })
+        assertEquals(1, results.count { it.state.data == REWARD_B1 })
+    }
+
+    @Test
+    fun `VaultService lessThanOrEqualTo should find all matching rewards by points`() {
+
+        val results = nodeC.services.vaultServiceFor<Reward>().filter {
+            expression(RewardEntity::points lessThanOrEqualTo 200)
+        }.toList()
+
+        assertEquals(4, results.count())
+        assertEquals(1, results.count { it.state.data == REWARD_A1 })
+        assertEquals(1, results.count { it.state.data == REWARD_A2 })
+        assertEquals(1, results.count { it.state.data == REWARD_B1 })
+        assertEquals(1, results.count { it.state.data == REWARD_B2 })
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/SpendRewardFlowSignatureDataTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/SpendRewardFlowSignatureDataTests.kt
new file mode 100644
index 0000000..db31101
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/SpendRewardFlowSignatureDataTests.kt
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.reward
+
+import io.onixlabs.corda.test.contract.Reward
+import io.onixlabs.corda.test.workflow.*
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import java.security.SignatureException
+import kotlin.test.assertEquals
+
+class SpendRewardFlowSignatureDataTests : FlowTest() {
+
+    private val expectedMessage =
+        "Failed to obtain a private key matching the specified public key from the key management service."
+
+    @Test
+    fun `SpendRewardFlow cannot spend a reward when the issuer is the initiator`() {
+        val exception = assertThrows<SignatureException> {
+            Pipeline
+                .create(network)
+                .run(nodeA) {
+                    IssueCustomerFlow.Initiator(CUSTOMER_1, observers = setOf(partyC))
+                }
+                .run(nodeC) {
+                    IssueRewardFlow.Initiator(REWARD_A1)
+                }
+                .run(nodeC) {
+                    val reward = it.tx.outRefsOfType<Reward>().single()
+                    SpendRewardFlow.Initiator(reward)
+                }
+        }
+
+        assertEquals(expectedMessage, exception.message)
+    }
+}
diff --git a/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/SpendRewardFlowTests.kt b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/SpendRewardFlowTests.kt
new file mode 100644
index 0000000..38ab6b4
--- /dev/null
+++ b/onixlabs-corda-test-workflow/src/test/kotlin/io/onixlabs/corda/test/workflow/reward/SpendRewardFlowTests.kt
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2020-2021 ONIXLabs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.onixlabs.corda.test.workflow.reward
+
+import io.onixlabs.corda.test.contract.Reward
+import io.onixlabs.corda.test.workflow.*
+import net.corda.core.transactions.SignedTransaction
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.fail
+import kotlin.test.assertEquals
+
+class SpendRewardFlowTests : FlowTest() {
+
+    private lateinit var transaction: SignedTransaction
+
+    override fun initialize() {
+        Pipeline
+            .create(network)
+            .run(nodeA) {
+                IssueCustomerFlow.Initiator(CUSTOMER_1, observers = setOf(partyB, partyC))
+            }
+            .run(nodeC) {
+                IssueRewardFlow.Initiator(REWARD_A1)
+            }
+            .run(nodeA) {
+                val reward = it.tx.outRefsOfType<Reward>().single()
+                SpendRewardFlow.Initiator(reward)
+            }
+            .finally { transaction = it }
+    }
+
+    @Test
+    fun `SpendRewardFlow transaction should be signed by the initiator`() {
+        transaction.verifyRequiredSignatures()
+    }
+
+    @Test
+    fun `SpendRewardFlow should record a transaction for the owner and observers`() {
+        listOf(nodeA, nodeC).forEach {
+            it.transaction {
+                val recordedTransaction = it.services.validatedTransactions.getTransaction(transaction.id)
+                    ?: fail("Failed to find a recorded transaction with id: ${transaction.id}.")
+
+                assertEquals(transaction, recordedTransaction)
+            }
+        }
+    }
+}
diff --git a/settings.gradle b/settings.gradle
index f0d9bd7..79fda3e 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -2,3 +2,5 @@ rootProject.name = 'onixlabs-corda-core'
 include 'onixlabs-corda-core-contract'
 include 'onixlabs-corda-core-workflow'
 include 'onixlabs-corda-core-integration'
+include 'onixlabs-corda-test-contract'
+include 'onixlabs-corda-test-workflow'