ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2024-12-19 04:57:58 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Regen docsite

Browse Source
This commit is contained in:
Mike Hearn 2016-06-30 14:49:28 +02:00
parent f2185089b7
commit 4356cef1cd
994 changed files with 23519 additions and 2434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
docs/build/html/_sources/codestyle.txt vendored
View File

@ -185,3 +185,38 @@ instead do this
The latter is easier to catch and handle if later necessary, and the type name should explain what went wrong.
Note that Kotlin does not require exception types to be declared in method prototypes like Java does.
5. Properties
#############
Where we want a public property to have one super-type in public and another sub-type in private (or internal), perhaps
to expose additional methods with a greater level of access to the code within the enclosing class, the style should be:
.. sourcecode:: kotlin
class PrivateFoo : PublicFoo
private val _foo = PrivateFoo()
val foo: PublicFoo get() = _foo
Notably:
* The public property should have an explicit and more restrictive type, most likely a super class or interface.
* The private, backed property should begin with underscore but otherwise have the same name as the public property.
The underscore resolves a potential property name clash, and avoids naming such as "privateFoo". If the type or use
of the private property is different enough that there is no naming collision, prefer the distinct names without
an underscore.
* The underscore prefix is not a general pattern for private properties.
* The public property should not have an additional backing field but use "get()" to return an appropriate copy of the
private field.
* The public property should optionally wrap the returned value in an immutable wrapper, such as Guava's immutable
collection wrappers, if that is appropriate.
* If the code following "get()" is succinct, prefer a one-liner formatting of the public property as above, otherwise
put the "get()" on the line below, indented.
6. Compiler warnings
####################
We do not allow compiler warnings, except in the experimental module where the usual standards do not apply and warnings
are suppressed. If a warning exists it should be either fixed or suppressed using @SuppressWarnings and if suppressed
there must be an accompanying explanation in the code for why the warning is a false positive.

143
docs/build/html/_sources/consensus.txt vendored
View File

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

102
docs/build/html/_sources/event-scheduling.txt vendored Normal file
View File

@ -0,0 +1,102 @@
.. highlight:: kotlin
.. raw:: html
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/codesets.js"></script>
Event scheduling
================
This article explains our experimental approach to modelling time based events in code. It explains how a contract
state can expose an upcoming event and what action to take if the scheduled time for that event is reached.
Introduction
------------
Many financial instruments have time sensitive components to them. For example, an Interest Rate Swap has a schedule
for when:
* Interest rate fixings should take place for floating legs, so that the interest rate used as the basis for payments
can be agreed.
* Any payments between the parties are expected to take place.
* Any payments between the parties become overdue.
Each of these is dependent on the current state of the financial instrument. What payments and interest rate fixings
have already happened should already be recorded in the state, for example. This means that the *next* time sensitive
event is thus a property of the current contract state. By next, we mean earliest in chronological terms, that is still
due. If a contract state is consumed in the UTXO model, then what *was* the next event becomes irrelevant and obsolete
and the next time sensitive event is determined by any successor contract state.
Knowing when the next time sensitive event is due to occur is useful, but typically some *activity* is expected to take
place when this event occurs. We already have a model for business processes in the form of the protocol state machines,
so in the platform we have introduced the concept of *scheduled activities* that can invoke protocol state machines
at a scheduled time. A contract state can optionally described the next scheduled activity for itself. If it omits
to do so, then nothing will be scheduled.
How to implement scheduled events
---------------------------------
There are two main steps to implementing scheduled events:
* Have your ``ContractState`` implementation also implement ``SchedulableState``. This requires a method named
``nextScheduledActivity`` to be implemented which returns an optional ``ScheduledActivity`` instance.
``ScheduledActivity`` captures what ``ProtocolLogic`` instance each node will run, to perform the activity, and when it
will run is described by a ``java.time.Instant``. Once your state implements this interface and is tracked by the
wallet, it can expect to be queried for the next activity when recorded via the ``ServiceHub.recordTransactions``
method during protocols execution.
* If nothing suitable exists, implement a ``ProtocolLogic`` to be executed by each node as the activity itself.
The important thing to remember is that each node that is party to the transaction, in the current implementation,
will execute the same ``ProtocolLogic`` so that needs to establish roles in the business process based on the contract
state and the node it is running on, and follow different but complementary paths through the business logic.
.. note:: The scheduler's clock always operates in the UTC time zone for uniformity, so any time zone logic must be
performed by the contract, using ``ZonedDateTime``.
In the short term, until we have automatic protocol session set up, you will also likely need to install a network
handler to help with obtaining a unqiue and secure random session. An example is described below.
The production and consumption of ``ContractStates`` is observed by the scheduler and the activities associated with
any consumed states are unscheduled. Any newly produced states are then queried via the ``nextScheduledActivity``
method and if they do not return ``null`` then that activity is scheduled based on the content of the
``ScheduledActivity`` object returned.
An example
----------
Let's take an example of the Interest Rate Swap fixings for our scheduled events. The first task is to implement the
``nextScheduledActivity`` method on the ``State``.
.. container:: codeset
.. sourcecode:: kotlin
override fun nextScheduledActivity(thisStateRef: StateRef,
protocolLogicRefFactory: ProtocolLogicRefFactory): ScheduledActivity? {
val nextFixingOf = nextFixingOf() ?: return null
// This is perhaps not how we should determine the time point in the business day, but instead expect the
// schedule to detail some of these aspects.
val (instant, duration) = suggestInterestRateAnnouncementTimeWindow(index = nextFixingOf.name,
source = floatingLeg.indexSource,
date = nextFixingOf.forDay)
return ScheduledActivity(protocolLogicRefFactory.create(TwoPartyDealProtocol.FixingRoleDecider::class.java,
thisStateRef, duration), instant)
}
The first thing this does is establish if there are any remaining fixings. If there are none, then it returns ``null``
to indicate that there is no activity to schedule. Otherwise it calculates the ``Instant`` at which the interest rate
should become available and schedules an activity at that time to work out what roles each node will take in the fixing
business process and to take on those roles. That ``ProtocolLogic`` will be handed the ``StateRef`` for the interest
rate swap ``State`` in question, as well as a tolerance ``Duration`` of how long to wait after the activity is triggered
for the interest rate before indicating an error.
.. note:: The use of the factory to create a ``ProtocolLogicRef`` instance to embed in the ``ScheduledActivity``. This is a
way to create a reference to the ``ProtocolLogic`` class and it's constructor parameters to instantiate that can be
checked against a per node whitelist of approved and allowable types as part of our overall security sandboxing.
As previously mentioned, we currently need a small network handler to assist with session setup until the work to
automate that is complete. See the interest rate swap specific implementation ``FixingSessionInitiationHandler`` which
is responsible for starting a ``ProtocolLogic`` to perform one role in the fixing protocol with the ``sessionID`` sent
by the ``FixingRoleDecider`` on the other node which then launches the other role in the fixing protocol. Currently
the handler needs to be manually installed in the node.

1
docs/build/html/_sources/index.txt vendored
View File

@ -41,6 +41,7 @@ Read on to learn:
tutorial-contract
protocol-state-machines
oracles
event-scheduling
.. toctree::
:maxdepth: 2

43
docs/build/html/_sources/inthebox.txt vendored
View File

@ -1,46 +1,46 @@
What's included?
================
The current prototype consists of a small amount of code that defines:
The Corda prototype currently includes:
* Key data structures.
* A peer to peer network with message persistence and delivery retries.
* Key data structures for defining contracts and states.
* Smart contracts:
* Cash
* Cash obligations
* Interest rate swaps
* Commercial paper (implemented in both Java and Kotlin for comparison)
* Algorithms that work with them, such as serialising, hashing, signing, and verification of the signatures.
* Two smart contracts that implement a notion of a cash claim and basic commercial paper (implemented twice, in two
different programming languages). These are simplified versions of the real things.
* Unit tests that check the algorithms do what is expected, and which verify the behaviour of the smart contracts.
* API documentation and tutorials (what you're reading)
* A simple standalone node that uses an embedded message queue broker as its P2P messaging layer.
* A trading demo that runs the node in either a listening/buying mode, or a connecting/selling mode, and swaps some
fake commercial paper assets for some self-issued IOU cash, using a generic *protocol framework*.
* It also includes two oracles: one for precise timestamping and another for interest rate swaps.
* API documentation and tutorials (what you're reading).
* A business process orchestration framework.
* Notary infrastructure for precise timestamping, and elimination of double spending without a blockchain.
* A simple REST API.
Some things it does not currently include but should gain later are:
* Sandboxing, distribution or publication of smart contract code
* A peer to peer network
* Database persistence
* An API for integrating external software
* A user interface for administration
* Many other things
You can browse `the JIRA bug tracker <https://r3-cev.atlassian.net/>`_.
The prototype's goal is rapid exploration of ideas. Therefore in places it takes shortcuts that a production system
would not in order to boost productivity:
* It uses an object graph serialization framework instead of a well specified, vendor neutral protocol.
* It uses secp256r1, an obsolete elliptic curve.
* It uses the default, out of the box Apache Artemis MQ protocol instead of AMQP/1.0 (although switching should be easy)
* There is no inter-node SSL or other encryption yet.
Contracts
---------
The primary goal of this prototype is to implement various kinds of contracts and verify that useful business logic
can be expressed with the data model, developing and refining an API along the way. To that end there are currently
two contracts in the repository:
four contracts in the repository:
1. Cash
2. Commercial paper
3. Nettable obligations
4. Interest rate swaps
``Cash`` implements the idea of a claim on some quantity of deposits at some institutional party, denominated in some currency,
identified by some *deposit reference*. A deposit reference is an opaque byte array which is usable by
@ -57,12 +57,14 @@ contract is implemented twice, once in Java and once in a language called Kotlin
``InterestRateSwap`` implements a vanilla OTC same currency bilateral fixed / floating leg swap. For further details,
see :doc:`irs`
``Obligation`` implements a bilaterally or multi-laterally nettable, fungible obligation that can default.
Each contract comes with unit tests.
Kotlin
------
The prototype is written in a language called `Kotlin <https://kotlinlang.org/>`_. Kotlin is a language that targets the JVM
Corda is written in a language called `Kotlin <https://kotlinlang.org/>`_. Kotlin is a language that targets the JVM
and can be thought of as a simpler Scala, with much better Java interop. It is developed by and has commercial support
from JetBrains, the makers of the IntelliJ IDE and other popular developer tools.
@ -72,10 +74,3 @@ the language, after only a few minutes of introduction.
Due to the seamless Java interop the use of Kotlin to extend the platform is *not* required and the tutorial shows how
to write contracts in both Kotlin and Java. You can `read more about why Kotlin is a potentially strong successor to Java here <https://medium.com/@octskyward/why-kotlin-is-my-next-programming-language-c25c001e26e3>`_.
Kotlin programs use the regular Java standard library and ordinary Java frameworks. Frameworks used at this time are:
* JUnit for unit testing
* Kryo for serialisation (this is not intended to be permanent)
* Gradle for the build
* Guava for a few utility functions

65
docs/build/html/_sources/release-notes.txt vendored
View File

@ -6,13 +6,72 @@ Here are brief summaries of what's changed between each snapshot release.
Unreleased
----------
Here are changes in git master that haven't yet made it to a snapshot release:
There are currently no unreleased changes.
* The cash contract has moved from com.r3corda.contracts to com.r3corda.contracts.cash.
* Amount class is now generic, to support non-currency types (such as assets, or currency with additional information).
Milestone 1
-----------
Highlights of this release:
* Event scheduling. States in the ledger can now request protocols to be invoked at particular times, for states
considered relevant by the wallet.
* Upgrades to the notary/consensus service support:
* There is now a way to change the notary controlling a state.
* You can pick between validating and non-validating notaries, these let you select your privacy/robustness tradeoff.
* A new obligation contract that supports bilateral and multilateral netting of obligations, default tracking and
more.
* Improvements to the financial type system, with core classes and contracts made more generic.
* Switch to a better digital signature algorithm: ed25519 instead of the previous JDK default of secp256r1.
* A new integration test suite.
* A new Java unit testing DSL for contracts, similar in spirit to the one already developed for Kotlin users (which
depended on Kotlin specific features).
* An experimental module, where developers who want to work with the latest Corda code can check in contracts/cordapp
code before it's been fully reviewed. Code in this module has compiler warnings suppressed but we will still make
sure it compiles across refactorings.
* Persistence improvements: transaction data is now stored to disk and automatic protocol resume is now implemented.
* Many smaller bug fixes, cleanups and improvements.
We have new documentation on:
* :doc:`event-scheduling`
* :doc:`transaction-data-types`
* :doc:`consensus`
Summary of API changes (not exhaustive):
* Notary/consensus service:
* ``NotaryService`` is now extensible.
* Every ``ContractState`` now has to specify a *participants* field, which is a list of parties that are able to
consume this state in a valid transaction. This is used for e.g. making sure all relevant parties obtain the updated
state when changing a notary.
* Introduced ``TransactionState``, which wraps ``ContractState``, and is used when defining a transaction output.
The notary field is moved from ``ContractState`` into ``TransactionState``.
* Every transaction now has a *type* field, which specifies custom build & validation rules for that transaction type.
Currently two types are supported: General (runs the default build and validation logic) and NotaryChange (
contract code is not run during validation, checks that the notary field is the only difference between the
inputs and outputs).
``TransactionBuilder()`` is now abstract, you should use ``TransactionType.General.Builder()`` for building transactions.
* The cash contract has moved from ``com.r3corda.contracts`` to ``com.r3corda.contracts.cash``
* ``Amount`` class is now generic, to support non-currency types such as physical assets. Where you previously had just
``Amount``, you should now use ``Amount<Currency>``.
* Refactored the Cash contract to have a new FungibleAsset superclass, to model all countable assets that can be merged
and split (currency, barrels of oil, etc.)
* Messaging:
* ``addMessageHandler`` now has a different signature as part of error handling changes.
* If you want to return nothing to a protocol, use ``Ack`` instead of ``Unit`` from now on.
* In the IRS contract, dateOffset is now an integer instead of an enum.
* In contracts, you now use ``tx.getInputs`` and ``tx.getOutputs`` instead of ``getInStates`` and ``getOutStates``. This is
just a renaming.
* A new ``NonEmptySet`` type has been added for cases where you wish to express that you have a collection of unique
objects which cannot be empty.
* Please use the global ``newSecureRandom()`` function rather than instantiating your own SecureRandom's from now on, as
the custom function forces the use of non-blocking random drivers on Linux.
Milestone 0
-----------

4
docs/build/html/_sources/running-the-demos.txt vendored
View File

@ -73,9 +73,7 @@ And in the second run:
./build/install/r3prototyping/bin/irsdemo --role=NodeB
The node in the first terminal will complain that it didn't know about nodeB, so restart it. It'll then find the
location and identity keys of nodeA and be happy. NodeB also doubles up as the interest rates oracle and you should
see some rates data get loaded.
NodeB also doubles up as the interest rates oracle and you should see some rates data get loaded.
Now in the third terminal run:

19
docs/build/html/_sources/transaction-data-types.txt vendored
View File

@ -1,5 +1,5 @@
Transaction Data Types
======================
Data types
==========
There is a large library of data types used in Corda transactions and contract state objects.
@ -27,15 +27,18 @@ delivered (themselves referring to a currency), an ``Amount`` such as the follow
Amount<Obligation.State<Currency>>
Contract State
--------------
State
-----
A Corda contract is composed of three parts; the executable code, the legal prose, and the state objects that represent
the details of the contract (see :doc:`data-model` for further detail). States essentially convert the generic template
(code and legal prose) into a specific instance. In a ``WireTransaction``, outputs are provided as ``ContractState``
(code and legal prose) into a specific instance. In a ``WireTransaction``, outputs are provided as ``TransactionState``
implementations, while the inputs are references to the outputs of a previous transaction. These references are then
stored as ``StateRef`` objects, which are converted to ``StateAndRef`` on demand.
The ``TransactionState`` is a container for a ``ContractState`` (the custom data used by a contract program) and additional
platform-level state information, such as the *notary* pointer (see :doc:`consensus`).
A number of interfaces then extend ``ContractState``, representing standardised functionality for states:
``OwnableState``
@ -64,8 +67,8 @@ interface for its subclasses' state objects to implement. The clear use-case is
intended to be readily extensible to cover other assets, for example commodities could be modelled by using a subclass
whose state objects include further details (location of the commodity, origin, grade, etc.) as needed.
Transaction Types
-----------------
Transaction lifecycle types
---------------------------
The ``WireTransaction`` class contains the core of a transaction without signatures, and with references to attachments
in place of the attachments themselves (see also :doc:`data-model`). Once signed these are encapsulated in the
@ -84,7 +87,7 @@ for signatures present on the transaction, as well as list of parties for those
.. note:: These types are provisional and are likely to change in future, for example to add additional information to
``Party``.
Date Support
Date support
------------
There are a number of supporting interfaces and classes for use by contract which deal with dates (especially in the

438
docs/build/html/api/alltypes/index.html vendored
View File

@ -56,8 +56,15 @@ I/O), or a mock implementation suitable for unit test environments.</p>
<td>
<a href="../com.r3corda.protocols/-abstract-request-message/index.html">com.r3corda.protocols.AbstractRequestMessage</a></td>
<td>
<p>Abstract superclass for request messages sent to services, which includes common
fields such as replyTo and replyToTopic.</p>
</td>
</tr>
<tr>
<td>
<a href="../protocols/-abstract-state-replacement-protocol/index.html">protocols.AbstractStateReplacementProtocol</a></td>
<td>
<p>Abstract protocol to be used for replacing one state with another, for example when changing the notary of a state.
Notably this requires a one to one replacement of states, states cannot be split, merged or issued as part of these
protocols.</p>
</td>
</tr>
<tr>
@ -83,6 +90,14 @@ We dont actually do anything with this yet though, so its ignored for now.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.messaging/-ack.html">com.r3corda.core.messaging.Ack</a></td>
<td>
<p>A general Ack message that conveys no content other than its presence for use when you want an acknowledgement
from a recipient. Using <a href="#">Unit</a> can be ambiguous as it is similar to <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Void.html">Void</a> and so could mean no response.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.utilities/-add-or-remove/index.html">com.r3corda.node.utilities.AddOrRemove</a></td>
<td>
<p>Enum for when adding/removing something, for example adding or removing an entry in a directory.</p>
@ -105,6 +120,12 @@ for ensuring code runs on the right thread, and also for unit testing.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.testing/-always-succeed-contract/index.html">com.r3corda.core.testing.AlwaysSucceedContract</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-amount/index.html">com.r3corda.core.contracts.Amount</a></td>
<td>
<p>Amount represents a positive quantity of some token (currency, asset, etc.), measured in quantity of the smallest
@ -114,6 +135,14 @@ amount used in whatever underlying thing the amount represents.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.protocols/-app-context/index.html">com.r3corda.core.protocols.AppContext</a></td>
<td>
<p>This is just some way to track what attachments need to be in the class loader, but may later include some app
properties loaded from the attachments. And perhaps the authenticated user for an API call?</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.services.messaging/-artemis-messaging-service/index.html">com.r3corda.node.services.messaging.ArtemisMessagingService</a></td>
<td>
<p>This class implements the <a href="../com.r3corda.core.messaging/-messaging-service/index.html">MessagingService</a> API using Apache Artemis, the successor to their ActiveMQ product.
@ -124,14 +153,6 @@ as well.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.contracts.cash/-asset-issuance-definition/index.html">com.r3corda.contracts.asset.AssetIssuanceDefinition</a></td>
<td>
<p>Subset of cash-like contract state, containing the issuance definition. If these definitions match for two
contracts states, those states can be aggregated.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-attachment/index.html">com.r3corda.core.contracts.Attachment</a></td>
<td>
<p>An attachment is a ZIP (or an optionally signed JAR) that contains one or more files. Attachments are meant to
@ -150,8 +171,7 @@ of how attachments are meant to be used include:</p>
<td>
<a href="../com.r3corda.core.node.services/-attachment-storage/index.html">com.r3corda.core.node.services.AttachmentStorage</a></td>
<td>
<p>An attachment store records potentially large binary objects, identified by their hash. Note that attachments are
immutable and can never be erased once inserted</p>
<p>An attachment store records potentially large binary objects, identified by their hash.</p>
</td>
</tr>
<tr>
@ -181,6 +201,13 @@ API call from a single party without bi-directional access to the database of of
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-bilateral-nettable-state/index.html">com.r3corda.core.contracts.BilateralNettableState</a></td>
<td>
<p>Interface for state objects that support being netted with other state objects.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.utilities/-brief-log-formatter/index.html">com.r3corda.core.utilities.BriefLogFormatter</a></td>
<td>
<p>A Java logging formatter that writes more compact output than the default.</p>
@ -209,7 +236,7 @@ no staff are around to handle problems.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.contracts.cash/-cash/index.html">com.r3corda.contracts.asset.Cash</a></td>
<a href="../com.r3corda.contracts.asset/-cash/index.html">com.r3corda.contracts.asset.Cash</a></td>
<td>
<p>A cash transaction may split and merge money represented by a set of (issuer, depositRef) pairs, across multiple
input and output states. Imagine a Bitcoin transaction but in which all UTXOs had a colour
@ -246,6 +273,19 @@ the same transaction.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.demos/-cli-params/index.html">com.r3corda.demos.CliParams</a></td>
<td>
<p>Parsed command line parameters.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.demos/-cli-params-spec/index.html">com.r3corda.demos.CliParamsSpec</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.utilities/java.time.-clock/index.html">java.time.Clock</a> (extensions in package com.r3corda.node.utilities)</td>
<td>
</td>
@ -319,7 +359,9 @@ timestamp attached to the transaction itself i.e. it is NOT necessarily the curr
<td>
<p>A contract state (or just "state") contains opaque data used by a contract program. It can be thought of as a disk
file that the program can use to persist data across transactions. States are immutable: once created they are never
updated, instead, any changes must generate a new successor state.</p>
updated, instead, any changes must generate a new successor state. States can be updated (consumed) only once: the
notary is responsible for ensuring there is no "double spending" by only signing a transaction if the input states
are all free.</p>
</td>
</tr>
<tr>
@ -331,6 +373,12 @@ updated, instead, any changes must generate a new successor state.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/java.util.-currency/index.html">java.util.Currency</a> (extensions in package com.r3corda.core.contracts)</td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.servlets/-data-upload-servlet/index.html">com.r3corda.node.servlets.DataUploadServlet</a></td>
<td>
<p>Accepts binary streams, finds the right <a href="../com.r3corda.node.services.api/-accepts-file-upload/index.html">AcceptsFileUpload</a> implementor and hands the stream off to it.</p>
@ -346,14 +394,6 @@ glue that sits between the network layer and the database layer.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-date-offset/index.html">com.r3corda.core.contracts.DateOffset</a></td>
<td>
<p>Date offset that the fixing is done prior to the accrual start date.
Currently not used in the calculation.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-date-roll-convention/index.html">com.r3corda.core.contracts.DateRollConvention</a></td>
<td>
<p>This reflects what happens if a date on which a business event is supposed to happen actually falls upon a non-working day
@ -402,6 +442,13 @@ implementation of general protocols that manipulate many agreement types.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.serialization/-deserialize-as-kotlin-object-def.html">com.r3corda.core.serialization.DeserializeAsKotlinObjectDef</a></td>
<td>
<p>Marker interface for kotlin object definitions so that they are deserialized as the singleton instance.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.crypto/-digital-signature/index.html">com.r3corda.core.crypto.DigitalSignature</a></td>
<td>
<p>A wrapper around a digital signature. The covering field is a generic tag usable by whatever is interpreting the
@ -429,12 +476,25 @@ building partially signed transactions.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.testing/-dummy-linear-state/index.html">com.r3corda.core.testing.DummyLinearState</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.crypto/-dummy-public-key/index.html">com.r3corda.core.crypto.DummyPublicKey</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-dummy-state/index.html">com.r3corda.core.contracts.DummyState</a></td>
<td>
<p>Dummy state for use in testing. Not part of any real contract.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.services.keys/-e2-e-test-key-management-service/index.html">com.r3corda.node.services.keys.E2ETestKeyManagementService</a></td>
<td>
<p>A simple in-memory KMS that doesnt bother saving keys to disk. A real implementation would:</p>
@ -442,6 +502,20 @@ building partially signed transactions.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.serialization/-ed25519-private-key-serializer/index.html">com.r3corda.core.serialization.Ed25519PrivateKeySerializer</a></td>
<td>
<p>For serialising an ed25519 private key</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.serialization/-ed25519-public-key-serializer/index.html">com.r3corda.core.serialization.Ed25519PublicKeySerializer</a></td>
<td>
<p>For serialising an ed25519 public key</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.utilities/-emoji/index.html">com.r3corda.core.utilities.Emoji</a></td>
<td>
<p>A simple wrapper class that contains icons and support for printing them only when were connected to a terminal.</p>
@ -546,6 +620,14 @@ Assumes that the rate is valid.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.services/-fixing-session-initiation-handler/index.html">com.r3corda.node.services.FixingSessionInitiationHandler</a></td>
<td>
<p>This is a temporary handler required for establishing random sessionIDs for the <a href="#">Fixer</a> and <a href="#">Floater</a> as part of
running scheduled fixings for the <a href="#">InterestRateSwap</a> contract.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.contracts/-floating-rate/index.html">com.r3corda.contracts.FloatingRate</a></td>
<td>
<p>The parent class of the Floating rate classes</p>
@ -569,7 +651,7 @@ that would divide into (eg annually = 1, semiannual = 2, monthly = 12 etc).</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.contracts.cash/-fungible-asset/index.html">com.r3corda.contracts.asset.FungibleAsset</a></td>
<a href="../com.r3corda.contracts.asset/-fungible-asset/index.html">com.r3corda.contracts.asset.FungibleAsset</a></td>
<td>
<p>Superclass for contracts representing assets which are fungible, countable and issued by a specific party. States
contain assets which are equivalent (such as cash of the same currency), so records of their existence can
@ -581,15 +663,22 @@ countable, and so on.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.contracts.cash/-fungible-asset-state/index.html">com.r3corda.contracts.asset.FungibleAssetState</a></td>
<a href="../com.r3corda.contracts.asset/-fungible-asset-state/index.html">com.r3corda.contracts.asset.FungibleAssetState</a></td>
<td>
<p>Common elements of cash contract states.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.demos/-i-r-s-demo-node/index.html">com.r3corda.demos.IRSDemoNode</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.demos/-i-r-s-demo-role/index.html">com.r3corda.demos.IRSDemoRole</a></td>
<td>
<p>Roles. There are 4 modes this demo can be run:</p>
</td>
</tr>
<tr>
@ -610,6 +699,12 @@ service would provide.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.protocols/-illegal-protocol-logic-exception/index.html">com.r3corda.core.protocols.IllegalProtocolLogicException</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.serialization/-immutable-class-serializer/index.html">com.r3corda.core.serialization.ImmutableClassSerializer</a></td>
<td>
<p>Serializes properties and deserializes by using the constructor. This assumes that all backed properties are
@ -656,7 +751,16 @@ testing).</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.contracts.cash/-insufficient-balance-exception/index.html">com.r3corda.contracts.asset.InsufficientBalanceException</a></td>
<a href="../com.r3corda.core.testing/-in-memory-wallet-service/index.html">com.r3corda.core.testing.InMemoryWalletService</a></td>
<td>
<p>This class implements a simple, in memory wallet that tracks states that are owned by us, and also has a convenience
method to auto-generate some self-issued cash states that can be used for test trading. A real wallet would persist
states relevant to us into a database and once such a wallet is implemented, this scaffolding can be removed.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.contracts.asset/-insufficient-balance-exception/index.html">com.r3corda.contracts.asset.InsufficientBalanceException</a></td>
<td>
</td>
</tr>
@ -718,6 +822,21 @@ from which the state object is initialised.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-issue-command/index.html">com.r3corda.core.contracts.IssueCommand</a></td>
<td>
<p>A common issue command, to enforce that issue commands have a nonce value.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-issued/index.html">com.r3corda.core.contracts.Issued</a></td>
<td>
<p>Definition for an issued product, which can be cash, a cash-like thing, assets, or generally anything else thats
quantifiable with integer quantities.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/kotlin.collections.-iterable/index.html">kotlin.collections.Iterable</a> (extensions in package com.r3corda.core.contracts)</td>
<td>
</td>
@ -730,7 +849,32 @@ from which the state object is initialised.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.contracts.cash/kotlin.collections.-iterable/index.html">kotlin.collections.Iterable</a> (extensions in package com.r3corda.contracts.cash)</td>
<a href="../com.r3corda.contracts.asset/kotlin.collections.-iterable/index.html">kotlin.collections.Iterable</a> (extensions in package com.r3corda.contracts.asset)</td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.internal.testing/kotlin.collections.-iterable/index.html">kotlin.collections.Iterable</a> (extensions in package com.r3corda.node.internal.testing)</td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-java-test-helpers/index.html">com.r3corda.core.contracts.JavaTestHelpers</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.testing/-java-test-helpers/index.html">com.r3corda.core.testing.JavaTestHelpers</a></td>
<td>
<p>JAVA INTEROP. Please keep the following points in mind when extending the Kotlin DSL</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.contracts.testing/-java-test-helpers/index.html">com.r3corda.contracts.testing.JavaTestHelpers</a></td>
<td>
</td>
</tr>
@ -758,12 +902,29 @@ call out to a hardware security module that enforces various auditing and freque
</tr>
<tr>
<td>
<a href="../com.r3corda.core.serialization/-kotlin-object-serializer/index.html">com.r3corda.core.serialization.KotlinObjectSerializer</a></td>
<td>
<p>Serializer to deserialize kotlin object definitions marked with <a href="../com.r3corda.core.serialization/-deserialize-as-kotlin-object-def.html">DeserializeAsKotlinObjectDef</a>.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.testing/-labeled-output/index.html">com.r3corda.core.testing.LabeledOutput</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.testing/-last-line-should-test-for-accept-or-failure.html">com.r3corda.core.testing.LastLineShouldTestForAcceptOrFailure</a></td>
<td>
<p>If you jumped here from a compiler error make sure the last line of your test tests for a transaction accept or fail
This is a dummy type that can only be instantiated by functions in this module. This way we can ensure that all tests
will have as the last line either an accept or a failure test. The name is deliberately long to help make sense of
the triggered diagnostic</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-ledger-transaction/index.html">com.r3corda.core.contracts.LedgerTransaction</a></td>
<td>
<p>A LedgerTransaction wraps the data needed to calculate one or more successor states from a set of input states.
@ -917,6 +1078,13 @@ This is not an interface because it is too lightweight to bother mocking out.</p
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-move-command/index.html">com.r3corda.core.contracts.MoveCommand</a></td>
<td>
<p>A common move command for contracts which can change owner.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.utilities/-mutable-clock/index.html">com.r3corda.node.utilities.MutableClock</a></td>
<td>
<p>An abstract class with helper methods for a type of Clock that might have its concept of "now"
@ -932,6 +1100,14 @@ adjusted externally.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-net-type/index.html">com.r3corda.core.contracts.NetType</a></td>
<td>
<p>Enum for the types of netting that can be applied to state objects. Exact behaviour
for each type of netting is left to the contract to determine.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.node.services/-network-cache-error/index.html">com.r3corda.core.node.services.NetworkCacheError</a></td>
<td>
</td>
@ -1026,11 +1202,18 @@ rate fix (e.g. LIBOR, EURIBOR ...).</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.services.events/-node-scheduler-service/index.html">com.r3corda.node.services.events.NodeSchedulerService</a></td>
<td>
<p>A first pass of a simple <a href="../com.r3corda.core.node.services/-scheduler-service/index.html">SchedulerService</a> that works with <a href="#">MutableClock</a>s for testing, demonstrations and simulations
that also encompasses the <a href="#">Wallet</a> observer for processing transactions.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.services.wallet/-node-wallet-service/index.html">com.r3corda.node.services.wallet.NodeWalletService</a></td>
<td>
<p>This class implements a simple, in memory wallet that tracks states that are owned by us, and also has a convenience
method to auto-generate some self-issued cash states that can be used for test trading. A real wallet would persist
states relevant to us into a database and once such a wallet is implemented, this scaffolding can be removed.</p>
<p>Currently, the node wallet service is just the in-memory wallet service until we have finished evaluating and
selecting a persistence layer (probably an ORM over a SQL DB).</p>
</td>
</tr>
<tr>
@ -1038,7 +1221,32 @@ states relevant to us into a database and once such a wallet is implemented, thi
<a href="../com.r3corda.core.utilities/-non-empty-set/index.html">com.r3corda.core.utilities.NonEmptySet</a></td>
<td>
<p>A set which is constrained to ensure it can never be empty. An initial value must be provided at
construction, and attempting to remove the last element will cause an IllegalStateException.</p>
construction, and attempting to remove the last element will cause an IllegalStateException.
The underlying set is exposed for Kryo to access, but should not be accessed directly.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.utilities/-non-empty-set-serializer/index.html">com.r3corda.core.utilities.NonEmptySetSerializer</a></td>
<td>
<p>Custom serializer which understands it has to read in an item before
trying to construct the set.</p>
</td>
</tr>
<tr>
<td>
<a href="../protocols/-notary-change-protocol/index.html">protocols.NotaryChangeProtocol</a></td>
<td>
<p>A protocol to be used for changing a states Notary. This is required since all input states to a transaction
must point to the same notary.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.services/-notary-change-service/index.html">com.r3corda.node.services.NotaryChangeService</a></td>
<td>
<p>A service that monitors the network for requests for changing the notary of a state,
and immediately runs the <a href="../protocols/-notary-change-protocol/index.html">NotaryChangeProtocol</a> if the auto-accept criteria are met.</p>
</td>
</tr>
<tr>
@ -1074,6 +1282,16 @@ construction, and attempting to remove the last element will cause an IllegalSta
</tr>
<tr>
<td>
<a href="../com.r3corda.contracts.asset/-obligation/index.html">com.r3corda.contracts.asset.Obligation</a></td>
<td>
<p>An obligation contract commits the obligor to delivering a specified amount of a fungible asset (for example the
<a href="../com.r3corda.contracts.asset/-cash/index.html">Cash</a> contract) at a specified future point in time. Settlement transactions may split and merge contracts across
multiple input and output states. The goal of this design is to handle amounts owed, and these contracts are expected
to be netted/merged, with settlement only for any remainder amount.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.serialization/-opaque-bytes/index.html">com.r3corda.core.serialization.OpaqueBytes</a></td>
<td>
<p>A simple class that wraps a byte array and makes the equals/hashCode/toString methods work as you actually expect.
@ -1197,6 +1415,20 @@ a node crash, how many instances of your protocol there are running and so on.</
</tr>
<tr>
<td>
<a href="../com.r3corda.core.protocols/-protocol-logic-ref/index.html">com.r3corda.core.protocols.ProtocolLogicRef</a></td>
<td>
<p>A class representing a <a href="../com.r3corda.core.protocols/-protocol-logic/index.html">ProtocolLogic</a> instance which would be possible to safely pass out of the contract sandbox</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.protocols/-protocol-logic-ref-factory/index.html">com.r3corda.core.protocols.ProtocolLogicRefFactory</a></td>
<td>
<p>A class for conversion to and from <a href="../com.r3corda.core.protocols/-protocol-logic/index.html">ProtocolLogic</a> and <a href="../com.r3corda.core.protocols/-protocol-logic-ref/index.html">ProtocolLogicRef</a> instances</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.api/-protocol-ref.html">com.r3corda.node.api.ProtocolRef</a></td>
<td>
<p>Encapsulates the protocol to be instantiated. e.g. TwoPartyTradeProtocol.Buyer.</p>
@ -1267,6 +1499,13 @@ for each step.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.node.services/-read-only-transaction-storage/index.html">com.r3corda.core.node.services.ReadOnlyTransactionStorage</a></td>
<td>
<p>Thread-safe storage of transactions.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.utilities/-recording-map/index.html">com.r3corda.core.utilities.RecordingMap</a></td>
<td>
<p>A RecordingMap wraps a regular Map&lt;K, V&gt; and records the sequence of gets and puts to it. This is useful in
@ -1333,6 +1572,51 @@ again.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-schedulable-state/index.html">com.r3corda.core.contracts.SchedulableState</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-scheduled/index.html">com.r3corda.core.contracts.Scheduled</a></td>
<td>
<p>Something which is scheduled to happen at a point in time</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-scheduled-activity/index.html">com.r3corda.core.contracts.ScheduledActivity</a></td>
<td>
<p>This class represents the lifecycle activity that a contract state of type <a href="../com.r3corda.core.contracts/-linear-state/index.html">LinearState</a> would like to perform at a given point in time.
e.g. run a fixing protocol</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.services.events/-scheduled-activity-observer/index.html">com.r3corda.node.services.events.ScheduledActivityObserver</a></td>
<td>
<p>This observes the wallet and schedules and unschedules activities appropriately based on state production and
consumption.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-scheduled-state-ref/index.html">com.r3corda.core.contracts.ScheduledStateRef</a></td>
<td>
<p>Represents a contract state (unconsumed output) of type <a href="../com.r3corda.core.contracts/-linear-state/index.html">LinearState</a> and a point in time that a lifecycle event is expected to take place
for that contract state.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.node.services/-scheduler-service/index.html">com.r3corda.core.node.services.SchedulerService</a></td>
<td>
<p>Provides access to schedule activity at some point in time. This interface might well be expanded to
increase the feature set in the future.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.crypto/-secure-hash/index.html">com.r3corda.core.crypto.SecureHash</a></td>
<td>
</td>
@ -1399,6 +1683,14 @@ functionality and you dont want to hard-code which types in the interface.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.protocols/-service-request-message/index.html">com.r3corda.protocols.ServiceRequestMessage</a></td>
<td>
<p>Abstract superclass for request messages sent to services, which includes common
fields such as replyTo and replyToTopic.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.node.services/-service-type/index.html">com.r3corda.core.node.services.ServiceType</a></td>
<td>
<p>Identifier for service types a node can expose over the network to other peers. These types are placed into network
@ -1497,6 +1789,19 @@ transaction defined the state and where in that transaction it was.</p>
</tr>
<tr>
<td>
<a href="../protocols/-state-replacement-exception/index.html">protocols.StateReplacementException</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../protocols/-state-replacement-refused/index.html">protocols.StateReplacementRefused</a></td>
<td>
<p>Thrown when a participant refuses proposed the state replacement</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.api/-states-query/index.html">com.r3corda.node.api.StatesQuery</a></td>
<td>
<p>Extremely rudimentary query language which should most likely be replaced with a product</p>
@ -1567,6 +1872,13 @@ way that ensures itll be released if theres an exception.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.utilities/-time-window/index.html">com.r3corda.core.utilities.TimeWindow</a></td>
<td>
<p>A class representing a window in time from a particular instant, lasting a specified duration.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.node.services/-timestamp-checker/index.html">com.r3corda.core.node.services.TimestampChecker</a></td>
<td>
<p>Checks if the given timestamp falls within the allowed tolerance interval</p>
@ -1597,18 +1909,6 @@ then B and C trade with each other, then C and A etc).</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.demos/-trader-demo-protocol-buyer/index.html">com.r3corda.demos.TraderDemoProtocolBuyer</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.demos/-trader-demo-protocol-seller/index.html">com.r3corda.demos.TraderDemoProtocolSeller</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.api/-transaction-build-step/index.html">com.r3corda.node.api.TransactionBuildStep</a></td>
<td>
<p>Encapsulate a generateXXX method call on a contract.</p>
@ -1619,9 +1919,8 @@ then B and C trade with each other, then C and A etc).</p>
<a href="../com.r3corda.core.contracts/-transaction-builder/index.html">com.r3corda.core.contracts.TransactionBuilder</a></td>
<td>
<p>A TransactionBuilder is a transaction class thats mutable (unlike the others which are all immutable). It is
intended to be passed around contracts that may edit it by adding new states/commands or modifying the existing set.
Then once the states and commands are right, this class can be used as a holding bucket to gather signatures from
multiple parties.</p>
intended to be passed around contracts that may edit it by adding new states/commands. Then once the states
and commands are right, this class can be used as a holding bucket to gather signatures from multiple parties.</p>
</td>
</tr>
<tr>
@ -1632,6 +1931,14 @@ multiple parties.</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-transaction-for-contract/index.html">com.r3corda.core.contracts.TransactionForContract</a></td>
<td>
<p>A transaction to be passed as input to a contract verification function. Defines helper methods to
simplify verification logic in contracts.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.testing/-transaction-for-test/index.html">com.r3corda.core.testing.TransactionForTest</a></td>
<td>
</td>
@ -1674,6 +1981,14 @@ this subgraph does not contain conflicts and is accepted by the involved contrac
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-transaction-state/index.html">com.r3corda.core.contracts.TransactionState</a></td>
<td>
<p>A wrapper for <a href="../com.r3corda.core.contracts/-contract-state/index.html">ContractState</a> containing additional platform-level state information.
This is the definitive state that is stored on the ledger and used in transaction outputs.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.node.services/-transaction-storage/index.html">com.r3corda.core.node.services.TransactionStorage</a></td>
<td>
<p>Thread-safe storage of transactions.</p>
@ -1681,6 +1996,13 @@ this subgraph does not contain conflicts and is accepted by the involved contrac
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-transaction-type/index.html">com.r3corda.core.contracts.TransactionType</a></td>
<td>
<p>Defines transaction build &amp; validation logic for a specific transaction type</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-transaction-verification-exception/index.html">com.r3corda.core.contracts.TransactionVerificationException</a></td>
<td>
</td>
@ -1711,6 +2033,13 @@ and seller) and the following steps:</p>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.node.services/-tx-writable-storage-service/index.html">com.r3corda.core.node.services.TxWritableStorageService</a></td>
<td>
<p>Storage service, with extensions to allow validated transactions to be added to. For use only within <a href="#">ServiceHub</a>.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.contracts/-type-only-command-data/index.html">com.r3corda.core.contracts.TypeOnlyCommandData</a></td>
<td>
<p>Commands that inherit from this are intended to have no data items: its only their presence that matters.</p>
@ -1749,8 +2078,7 @@ first. The wrapper helps you to avoid forgetting this vital step. Things you mig
<td>
<a href="../com.r3corda.demos.protocols/-update-business-day-protocol/index.html">com.r3corda.demos.protocols.UpdateBusinessDayProtocol</a></td>
<td>
<p>This is a very temporary, demo-oriented way of initiating processing of temporal events and is not
intended as the way things will necessarily be done longer term</p>
<p>This is a less temporary, demo-oriented way of initiating processing of temporal events</p>
</td>
</tr>
<tr>
@ -1782,22 +2110,6 @@ about new transactions from our peers and generate new transactions that consume
</tr>
<tr>
<td>
<a href="../com.r3corda.node.internal.testing/-wallet-filler/index.html">com.r3corda.node.internal.testing.WalletFiller</a></td>
<td>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.node.services.wallet/-wallet-impl/index.html">com.r3corda.node.services.wallet.WalletImpl</a></td>
<td>
<p>A wallet (name may be temporary) wraps a set of states that are useful for us to keep track of, for instance,
because we own them. This class represents an immutable, stable state of a wallet: it is guaranteed not to
change out from underneath you, even though the canonical currently-best-known wallet may change as we learn
about new transactions from our peers and generate new transactions that consume states ourselves.</p>
</td>
</tr>
<tr>
<td>
<a href="../com.r3corda.core.node.services/-wallet-service/index.html">com.r3corda.core.node.services.WalletService</a></td>
<td>
<p>A <a href="../com.r3corda.core.node.services/-wallet-service/index.html">WalletService</a> is responsible for securely and safely persisting the current state of a wallet to storage. The

15
docs/build/html/api/com.r3corda.contracts.asset/-c-a-s-h_-p-r-o-g-r-a-m_-i-d.html vendored Normal file
View File

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

16
docs/build/html/api/com.r3corda.contracts.asset/-cash/-commands/-exit/-init-.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Cash.Commands.Exit.<init> - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Cash</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Exit</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">Exit</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.Commands.Exit$<init>(com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))))/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><br/>
<p>A command stating that money has been withdrawn from the shared ledger and is now accounted for
in some other way.</p>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-cash/-commands/-exit/amount.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Cash.Commands.Exit.amount - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Cash</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Exit</a>&nbsp;/&nbsp;<a href=".">amount</a><br/>
<br/>
<h1>amount</h1>
<a name="com.r3corda.contracts.asset.Cash.Commands.Exit$amount"></a>
<code><span class="keyword">val </span><span class="identifier">amount</span><span class="symbol">: </span><a href="../../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../../../-fungible-asset/-commands/-exit/amount.html">Exit.amount</a><br/>
<br/>
<br/>
</BODY>
</HTML>

40
docs/build/html/api/com.r3corda.contracts.asset/-cash/-commands/-exit/index.html vendored Normal file
View File

@ -0,0 +1,40 @@
<HTML>
<HEAD>
<title>Cash.Commands.Exit - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Cash</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href=".">Exit</a><br/>
<br/>
<h1>Exit</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Exit</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><a href="../../../-fungible-asset/-commands/-exit/index.html"><span class="identifier">Exit</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><br/>
<p>A command stating that money has been withdrawn from the shared ledger and is now accounted for
in some other way.</p>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">Exit</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.Commands.Exit$<init>(com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))))/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><p>A command stating that money has been withdrawn from the shared ledger and is now accounted for
in some other way.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="amount.html">amount</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">amount</span><span class="symbol">: </span><a href="../../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-cash/-commands/-issue/-init-.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Cash.Commands.Issue.<init> - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Cash</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Issue</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">Issue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.Commands.Issue$<init>(kotlin.Long)/nonce">nonce</span><span class="symbol">:</span>&nbsp;<span class="identifier">Long</span>&nbsp;<span class="symbol">=</span>&nbsp;newSecureRandom().nextLong()<span class="symbol">)</span></code><br/>
<p>Allows new cash states to be issued into existence: the nonce ("number used once") ensures the transaction
has a unique ID even when there are no inputs.</p>
<br/>
<br/>
</BODY>
</HTML>

40
docs/build/html/api/com.r3corda.contracts.asset/-cash/-commands/-issue/index.html vendored Normal file
View File

@ -0,0 +1,40 @@
<HTML>
<HEAD>
<title>Cash.Commands.Issue - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Cash</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href=".">Issue</a><br/>
<br/>
<h1>Issue</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Issue</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../-fungible-asset/-commands/-issue.html"><span class="identifier">Issue</span></a><span class="symbol">, </span><a href="../index.html"><span class="identifier">Commands</span></a></code><br/>
<p>Allows new cash states to be issued into existence: the nonce ("number used once") ensures the transaction
has a unique ID even when there are no inputs.</p>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">Issue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.Commands.Issue$<init>(kotlin.Long)/nonce">nonce</span><span class="symbol">:</span>&nbsp;<span class="identifier">Long</span>&nbsp;<span class="symbol">=</span>&nbsp;newSecureRandom().nextLong()<span class="symbol">)</span></code><p>Allows new cash states to be issued into existence: the nonce ("number used once") ensures the transaction
has a unique ID even when there are no inputs.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="nonce.html">nonce</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">nonce</span><span class="symbol">: </span><span class="identifier">Long</span></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-cash/-commands/-issue/nonce.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Cash.Commands.Issue.nonce - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Cash</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Issue</a>&nbsp;/&nbsp;<a href=".">nonce</a><br/>
<br/>
<h1>nonce</h1>
<a name="com.r3corda.contracts.asset.Cash.Commands.Issue$nonce"></a>
<code><span class="keyword">val </span><span class="identifier">nonce</span><span class="symbol">: </span><span class="identifier">Long</span></code><br/>
Overrides <a href="../../../../com.r3corda.core.contracts/-issue-command/nonce.html">IssueCommand.nonce</a><br/>
<br/>
<br/>
</BODY>
</HTML>

20
docs/build/html/api/com.r3corda.contracts.asset/-cash/-commands/-move/-init-.html vendored Normal file
View File

@ -0,0 +1,20 @@
<HTML>
<HEAD>
<title>Cash.Commands.Move.<init> - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Cash</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Move</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">Move</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.Commands.Move$<init>(com.r3corda.core.crypto.SecureHash)/contractHash">contractHash</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">?</span>&nbsp;<span class="symbol">=</span>&nbsp;null<span class="symbol">)</span></code><br/>
<p>A command stating that money has been moved, optionally to fulfil another contract.</p>
<h3>Parameters</h3>
<a name="contractHash"></a>
<code>contractHash</code> - the contract this move is for the attention of. Only that contracts verify function
should take the moved states into account when considering whether it is valid. Typically this will be
null.<br/>
<br/>
<br/>
</BODY>
</HTML>

18
docs/build/html/api/com.r3corda.contracts.asset/-cash/-commands/-move/contract-hash.html vendored Normal file
View File

@ -0,0 +1,18 @@
<HTML>
<HEAD>
<title>Cash.Commands.Move.contractHash - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Cash</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Move</a>&nbsp;/&nbsp;<a href=".">contractHash</a><br/>
<br/>
<h1>contractHash</h1>
<a name="com.r3corda.contracts.asset.Cash.Commands.Move$contractHash"></a>
<code><span class="keyword">val </span><span class="identifier">contractHash</span><span class="symbol">: </span><a href="../../../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">?</span></code><br/>
Overrides <a href="../../../../com.r3corda.core.contracts/-move-command/contract-hash.html">MoveCommand.contractHash</a><br/>
<p>Contract code the moved state(s) are for the attention of, for example to indicate that the states are moved in
order to settle an obligation contracts state object(s).</p>
<br/>
<br/>
</BODY>
</HTML>

45
docs/build/html/api/com.r3corda.contracts.asset/-cash/-commands/-move/index.html vendored Normal file
View File

@ -0,0 +1,45 @@
<HTML>
<HEAD>
<title>Cash.Commands.Move - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Cash</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href=".">Move</a><br/>
<br/>
<h1>Move</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Move</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../-fungible-asset/-commands/-move.html"><span class="identifier">Move</span></a><span class="symbol">, </span><a href="../index.html"><span class="identifier">Commands</span></a></code><br/>
<p>A command stating that money has been moved, optionally to fulfil another contract.</p>
<h3>Parameters</h3>
<a name="contractHash"></a>
<code>contractHash</code> - the contract this move is for the attention of. Only that contracts verify function
should take the moved states into account when considering whether it is valid. Typically this will be
null.<br/>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">Move</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.Commands.Move$<init>(com.r3corda.core.crypto.SecureHash)/contractHash">contractHash</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">?</span>&nbsp;<span class="symbol">=</span>&nbsp;null<span class="symbol">)</span></code><p>A command stating that money has been moved, optionally to fulfil another contract.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="contract-hash.html">contractHash</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">contractHash</span><span class="symbol">: </span><a href="../../../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">?</span></code><p>Contract code the moved state(s) are for the attention of, for example to indicate that the states are moved in
order to settle an obligation contracts state object(s).</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

70
docs/build/html/api/com.r3corda.contracts.asset/-cash/-commands/index.html vendored Normal file
View File

@ -0,0 +1,70 @@
<HTML>
<HEAD>
<title>Cash.Commands - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href=".">Commands</a><br/>
<br/>
<h1>Commands</h1>
<code><span class="keyword">interface </span><span class="identifier">Commands</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-command-data.html"><span class="identifier">CommandData</span></a></code><br/>
<br/>
<br/>
<h3>Types</h3>
<table>
<tbody>
<tr>
<td>
<a href="-exit/index.html">Exit</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Exit</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../../-fungible-asset/-commands/-exit/index.html"><span class="identifier">Exit</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><p>A command stating that money has been withdrawn from the shared ledger and is now accounted for
in some other way.</p>
</td>
</tr>
<tr>
<td>
<a href="-issue/index.html">Issue</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Issue</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../-fungible-asset/-commands/-issue.html"><span class="identifier">Issue</span></a><span class="symbol">, </span><span class="identifier">Commands</span></code><p>Allows new cash states to be issued into existence: the nonce ("number used once") ensures the transaction
has a unique ID even when there are no inputs.</p>
</td>
</tr>
<tr>
<td>
<a href="-move/index.html">Move</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Move</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../-fungible-asset/-commands/-move.html"><span class="identifier">Move</span></a><span class="symbol">, </span><span class="identifier">Commands</span></code><p>A command stating that money has been moved, optionally to fulfil another contract.</p>
</td>
</tr>
</tbody>
</table>
<h3>Inheritors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-exit/index.html">Exit</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Exit</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../../-fungible-asset/-commands/-exit/index.html"><span class="identifier">Exit</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><p>A command stating that money has been withdrawn from the shared ledger and is now accounted for
in some other way.</p>
</td>
</tr>
<tr>
<td>
<a href="-issue/index.html">Issue</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Issue</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../-fungible-asset/-commands/-issue.html"><span class="identifier">Issue</span></a><span class="symbol">, </span><span class="identifier">Commands</span></code><p>Allows new cash states to be issued into existence: the nonce ("number used once") ensures the transaction
has a unique ID even when there are no inputs.</p>
</td>
</tr>
<tr>
<td>
<a href="-move/index.html">Move</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Move</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../-fungible-asset/-commands/-move.html"><span class="identifier">Move</span></a><span class="symbol">, </span><span class="identifier">Commands</span></code><p>A command stating that money has been moved, optionally to fulfil another contract.</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

25
docs/build/html/api/com.r3corda.contracts.asset/-cash/-init-.html vendored Normal file
View File

@ -0,0 +1,25 @@
<HTML>
<HEAD>
<title>Cash.<init> - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="index.html">Cash</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">Cash</span><span class="symbol">(</span><span class="symbol">)</span></code><br/>
<p>A cash transaction may split and merge money represented by a set of (issuer, depositRef) pairs, across multiple
input and output states. Imagine a Bitcoin transaction but in which all UTXOs had a colour
(a blend of issuer+depositRef) and you couldnt merge outputs of two colours together, but you COULD put them in
the same transaction.</p>
<p>The goal of this design is to ensure that money can be withdrawn from the ledger easily: if you receive some money
via this contract, you always know where to go in order to extract it from the R3 ledger, no matter how many hands
it has passed through in the intervening time.</p>
<p>At the same time, other contracts that just want money and dont care much who is currently holding it in their
vaults can ignore the issuer/depositRefs and just examine the amount fields.</p>
<br/>
<br/>
<br/>
<br/>
</BODY>
</HTML>

18
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/-init-.html vendored Normal file
View File

@ -0,0 +1,18 @@
<HTML>
<HEAD>
<title>Cash.State.<init> - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href="index.html">State</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">State</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$<init>(com.r3corda.core.contracts.PartyAndReference, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey)/deposit">deposit</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-party-and-reference/index.html"><span class="identifier">PartyAndReference</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$<init>(com.r3corda.core.contracts.PartyAndReference, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey)/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$<init>(com.r3corda.core.contracts.PartyAndReference, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey)/owner">owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span></code><br/>
<br/>
<br/>
<code><span class="identifier">State</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$<init>(com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey)/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$<init>(com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey)/owner">owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span></code><br/>
<p>A state representing a cash claim against some party</p>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/amount.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Cash.State.amount - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href="index.html">State</a>&nbsp;/&nbsp;<a href=".">amount</a><br/>
<br/>
<h1>amount</h1>
<a name="com.r3corda.contracts.asset.Cash.State$amount"></a>
<code><span class="keyword">val </span><span class="identifier">amount</span><span class="symbol">: </span><a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../../-fungible-asset/-state/amount.html">State.amount</a><br/>
<br/>
<br/>
</BODY>
</HTML>

43
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/contract.html vendored Normal file
View File

@ -0,0 +1,43 @@
<HTML>
<HEAD>
<title>Cash.State.contract - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href="index.html">State</a>&nbsp;/&nbsp;<a href=".">contract</a><br/>
<br/>
<h1>contract</h1>
<a name="com.r3corda.contracts.asset.Cash.State$contract"></a>
<code><span class="keyword">val </span><span class="identifier">contract</span><span class="symbol">: </span><a href="../index.html"><span class="identifier">Cash</span></a></code><br/>
Overrides <a href="../../../com.r3corda.core.contracts/-contract-state/contract.html">ContractState.contract</a><br/>
<p>An instance of the contract class that will verify this state.</p>
<h1>Discussion</h1>
<p>This field is not the final design, its just a piece of temporary scaffolding. Once the contract sandbox is
further along, this field will become a description of which attachments are acceptable for defining the
contract.</p>
<p>Recall that an attachment is a zip file that can be referenced from any transaction. The contents of the
attachments are merged together and cannot define any overlapping files, thus for any given transaction there
is a miniature file system in which each file can be precisely mapped to the defining attachment.</p>
<p>Attachments may contain many things (data files, legal documents, etc) but mostly they contain JVM bytecode.
The class files inside define not only <a href="../../../com.r3corda.core.contracts/-contract/index.html">Contract</a> implementations but also the classes that define the states.
Within the rest of a transaction, user-providable components are referenced by name only.</p>
<p>This means that a smart contract in Corda does two things:</p>
<ol><li><p>Define the data structures that compose the ledger (the states)</p>
</li><li><p>Define the rules for updating those structures</p>
</li></ol><p>The first is merely a utility role ... in theory contract code could manually parse byte streams by hand.
The second is vital to the integrity of the ledger. So this field needs to be able to express constraints like:</p>
<ul><li><p>Only attachment 733c350f396a727655be1363c06635ba355036bd54a5ed6e594fd0b5d05f42f6 may be used with this state.</p>
</li><li><p>Any attachment signed by public key 2d1ce0e330c52b8055258d776c40 may be used with this state.</p>
</li><li><p>Attachments (1, 2, 3) may all be used with this state.</p>
</li></ul><p>and so on. In this way it becomes possible for the business logic governing a state to be evolved, if the
constraints are flexible enough.</p>
<p>Because contract classes often also define utilities that generate relevant transactions, and because attachments
cannot know their own hashes, we will have to provide various utilities to assist with obtaining the right
code constraints from within the contract code itself.</p>
<p>TODO: Implement the above description. See COR-226</p>
<br/>
<br/>
<br/>
<br/>
</BODY>
</HTML>

20
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/deposit.html vendored Normal file
View File

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

132
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/index.html vendored Normal file
View File

@ -0,0 +1,132 @@
<HTML>
<HEAD>
<title>Cash.State - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href=".">State</a><br/>
<br/>
<h1>State</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">State</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../-fungible-asset/-state/index.html"><span class="identifier">State</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><br/>
<p>A state representing a cash claim against some party</p>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">State</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$<init>(com.r3corda.core.contracts.PartyAndReference, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey)/deposit">deposit</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-party-and-reference/index.html"><span class="identifier">PartyAndReference</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$<init>(com.r3corda.core.contracts.PartyAndReference, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey)/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$<init>(com.r3corda.core.contracts.PartyAndReference, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey)/owner">owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span></code><code><span class="identifier">State</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$<init>(com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey)/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$<init>(com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey)/owner">owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span></code><p>A state representing a cash claim against some party</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="amount.html">amount</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">amount</span><span class="symbol">: </span><a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code></td>
</tr>
<tr>
<td>
<a href="contract.html">contract</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">contract</span><span class="symbol">: </span><a href="../index.html"><span class="identifier">Cash</span></a></code><p>An instance of the contract class that will verify this state.</p>
</td>
</tr>
<tr>
<td>
<a href="deposit.html">deposit</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">deposit</span><span class="symbol">: </span><a href="../../../com.r3corda.core.contracts/-party-and-reference/index.html"><span class="identifier">PartyAndReference</span></a></code><p>Where the underlying currency backing this ledger entry can be found (propagated)</p>
</td>
</tr>
<tr>
<td>
<a href="issuance-def.html">issuanceDef</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">issuanceDef</span><span class="symbol">: </span><a href="../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code></td>
</tr>
<tr>
<td>
<a href="owner.html">owner</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">owner</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a></code><p>There must be a MoveCommand signed by this key to claim the amount</p>
</td>
</tr>
<tr>
<td>
<a href="participants.html">participants</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">participants</span><span class="symbol">: </span><span class="identifier">List</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">&gt;</span></code><p>A <emph>participant</emph> is any party that is able to consume this state in a valid transaction.</p>
</td>
</tr>
<tr>
<td>
<a href="product-amount.html">productAmount</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">productAmount</span><span class="symbol">: </span><a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
<h3>Functions</h3>
<table>
<tbody>
<tr>
<td>
<a href="move.html">move</a></td>
<td>
<code><span class="keyword">fun </span><span class="identifier">move</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$move(com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey)/newAmount">newAmount</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$move(com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey)/newOwner">newOwner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><a href="../../-fungible-asset/-state/index.html"><span class="identifier">State</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code></td>
</tr>
<tr>
<td>
<a href="to-string.html">toString</a></td>
<td>
<code><span class="keyword">fun </span><span class="identifier">toString</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">String</span></code></td>
</tr>
<tr>
<td>
<a href="with-new-owner.html">withNewOwner</a></td>
<td>
<code><span class="keyword">fun </span><span class="identifier">withNewOwner</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$withNewOwner(java.security.PublicKey)/newOwner">newOwner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code><p>Copies the underlying data structure, replacing the owner field with this new value and leaving the rest alone</p>
</td>
</tr>
</tbody>
</table>
<h3>Extension Functions</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../../com.r3corda.contracts.testing/issued by.html">issued by</a></td>
<td>
<code><span class="keyword">infix</span> <span class="keyword">fun </span><span class="identifier">State</span><span class="symbol">.</span><span class="identifier">issued by</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$issued by(com.r3corda.contracts.asset.Cash.State, com.r3corda.core.crypto.Party)/party">party</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">State</span></code><br/>
<code><span class="keyword">infix</span> <span class="keyword">fun </span><span class="identifier">State</span><span class="symbol">.</span><span class="identifier">issued by</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$issued by(com.r3corda.contracts.asset.Cash.State, com.r3corda.core.contracts.PartyAndReference)/deposit">deposit</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-party-and-reference/index.html"><span class="identifier">PartyAndReference</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">State</span></code></td>
</tr>
<tr>
<td>
<a href="../../../com.r3corda.contracts.testing/owned by.html">owned by</a></td>
<td>
<code><span class="keyword">infix</span> <span class="keyword">fun </span><span class="identifier">State</span><span class="symbol">.</span><span class="identifier">owned by</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$owned by(com.r3corda.contracts.asset.Cash.State, java.security.PublicKey)/owner">owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code></td>
</tr>
<tr>
<td>
<a href="../../../com.r3corda.contracts.testing/with deposit.html">with deposit</a></td>
<td>
<code><span class="keyword">infix</span> <span class="keyword">fun </span><span class="identifier">State</span><span class="symbol">.</span><span class="identifier">with deposit</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$with deposit(com.r3corda.contracts.asset.Cash.State, com.r3corda.core.contracts.PartyAndReference)/deposit">deposit</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-party-and-reference/index.html"><span class="identifier">PartyAndReference</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">State</span></code></td>
</tr>
<tr>
<td>
<a href="../../../com.r3corda.contracts.testing/with notary.html">with notary</a></td>
<td>
<code><span class="keyword">infix</span> <span class="keyword">fun </span><span class="identifier">State</span><span class="symbol">.</span><span class="identifier">with notary</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$with notary(com.r3corda.contracts.asset.Cash.State, com.r3corda.core.crypto.Party)/notary">notary</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">)</span><span class="symbol">: </span><a href="../../../com.r3corda.core.contracts/-transaction-state/index.html"><span class="identifier">TransactionState</span></a><span class="symbol">&lt;</span><span class="identifier">State</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/issuance-def.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Cash.State.issuanceDef - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href="index.html">State</a>&nbsp;/&nbsp;<a href=".">issuanceDef</a><br/>
<br/>
<h1>issuanceDef</h1>
<a name="com.r3corda.contracts.asset.Cash.State$issuanceDef"></a>
<code><span class="keyword">val </span><span class="identifier">issuanceDef</span><span class="symbol">: </span><a href="../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../../-fungible-asset-state/issuance-def.html">FungibleAssetState.issuanceDef</a><br/>
<br/>
<br/>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/move.html vendored Normal file
View File

@ -0,0 +1,15 @@
<HTML>
<HEAD>
<title>Cash.State.move - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href="index.html">State</a>&nbsp;/&nbsp;<a href=".">move</a><br/>
<br/>
<h1>move</h1>
<a name="com.r3corda.contracts.asset.Cash.State$move(com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey)"></a>
<code><span class="keyword">fun </span><span class="identifier">move</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$move(com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey)/newAmount">newAmount</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$move(com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey)/newOwner">newOwner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><a href="../../-fungible-asset/-state/index.html"><span class="identifier">State</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><br/>
<br/>
<br/>
</BODY>
</HTML>

17
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/owner.html vendored Normal file
View File

@ -0,0 +1,17 @@
<HTML>
<HEAD>
<title>Cash.State.owner - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href="index.html">State</a>&nbsp;/&nbsp;<a href=".">owner</a><br/>
<br/>
<h1>owner</h1>
<a name="com.r3corda.contracts.asset.Cash.State$owner"></a>
<code><span class="keyword">val </span><span class="identifier">owner</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a></code><br/>
Overrides <a href="../../-fungible-asset/-state/owner.html">State.owner</a><br/>
<p>There must be a MoveCommand signed by this key to claim the amount</p>
<br/>
<br/>
</BODY>
</HTML>

34
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/participants.html vendored Normal file
View File

@ -0,0 +1,34 @@
<HTML>
<HEAD>
<title>Cash.State.participants - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href="index.html">State</a>&nbsp;/&nbsp;<a href=".">participants</a><br/>
<br/>
<h1>participants</h1>
<a name="com.r3corda.contracts.asset.Cash.State$participants"></a>
<code><span class="keyword">val </span><span class="identifier">participants</span><span class="symbol">: </span><span class="identifier">List</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../../../com.r3corda.core.contracts/-contract-state/participants.html">ContractState.participants</a><br/>
<p>A <emph>participant</emph> is any party that is able to consume this state in a valid transaction.</p>
<p>The list of participants is required for certain types of transactions. For example, when changing the notary
for this state (<a href="../../../com.r3corda.core.contracts/-transaction-type/-notary-change/index.html">TransactionType.NotaryChange</a>), every participants has to be involved and approve the transaction
so that they receive the updated state, and dont end up in a situation where they can no longer use a state
they possess, since someone consumed that state during the notary change process.</p>
<p>The participants list should normally be derived from the contents of the state. E.g. for <a href="../index.html">Cash</a> the participants
list should just contain the owner.</p>
<br/>
<br/>
<p><strong>Getter</strong><br/>
<p>A <emph>participant</emph> is any party that is able to consume this state in a valid transaction.</p>
<p>The list of participants is required for certain types of transactions. For example, when changing the notary
for this state (<a href="../../../com.r3corda.core.contracts/-transaction-type/-notary-change/index.html">TransactionType.NotaryChange</a>), every participants has to be involved and approve the transaction
so that they receive the updated state, and dont end up in a situation where they can no longer use a state
they possess, since someone consumed that state during the notary change process.</p>
<p>The participants list should normally be derived from the contents of the state. E.g. for <a href="../index.html">Cash</a> the participants
list should just contain the owner.</p>
</p>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/product-amount.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Cash.State.productAmount - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href="index.html">State</a>&nbsp;/&nbsp;<a href=".">productAmount</a><br/>
<br/>
<h1>productAmount</h1>
<a name="com.r3corda.contracts.asset.Cash.State$productAmount"></a>
<code><span class="keyword">val </span><span class="identifier">productAmount</span><span class="symbol">: </span><a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../../-fungible-asset-state/product-amount.html">FungibleAssetState.productAmount</a><br/>
<br/>
<br/>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/to-string.html vendored Normal file
View File

@ -0,0 +1,15 @@
<HTML>
<HEAD>
<title>Cash.State.toString - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href="index.html">State</a>&nbsp;/&nbsp;<a href=".">toString</a><br/>
<br/>
<h1>toString</h1>
<a name="com.r3corda.contracts.asset.Cash.State$toString()"></a>
<code><span class="keyword">fun </span><span class="identifier">toString</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">String</span></code><br/>
<br/>
<br/>
</BODY>
</HTML>

17
docs/build/html/api/com.r3corda.contracts.asset/-cash/-state/with-new-owner.html vendored Normal file
View File

@ -0,0 +1,17 @@
<HTML>
<HEAD>
<title>Cash.State.withNewOwner - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Cash</a>&nbsp;/&nbsp;<a href="index.html">State</a>&nbsp;/&nbsp;<a href=".">withNewOwner</a><br/>
<br/>
<h1>withNewOwner</h1>
<a name="com.r3corda.contracts.asset.Cash.State$withNewOwner(java.security.PublicKey)"></a>
<code><span class="keyword">fun </span><span class="identifier">withNewOwner</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash.State$withNewOwner(java.security.PublicKey)/newOwner">newOwner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span></code><br/>
Overrides <a href="../../../com.r3corda.core.contracts/-ownable-state/with-new-owner.html">OwnableState.withNewOwner</a><br/>
<p>Copies the underlying data structure, replacing the owner field with this new value and leaving the rest alone</p>
<br/>
<br/>
</BODY>
</HTML>

21
docs/build/html/api/com.r3corda.contracts.asset/-cash/generate-issue.html vendored Normal file
View File

@ -0,0 +1,21 @@
<HTML>
<HEAD>
<title>Cash.generateIssue - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="index.html">Cash</a>&nbsp;/&nbsp;<a href=".">generateIssue</a><br/>
<br/>
<h1>generateIssue</h1>
<a name="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Issued((java.util.Currency)), kotlin.Long, java.security.PublicKey, com.r3corda.core.crypto.Party)"></a>
<code><span class="keyword">fun </span><span class="identifier">generateIssue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Issued((java.util.Currency)), kotlin.Long, java.security.PublicKey, com.r3corda.core.crypto.Party)/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-transaction-builder/index.html"><span class="identifier">TransactionBuilder</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Issued((java.util.Currency)), kotlin.Long, java.security.PublicKey, com.r3corda.core.crypto.Party)/tokenDef">tokenDef</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Issued((java.util.Currency)), kotlin.Long, java.security.PublicKey, com.r3corda.core.crypto.Party)/pennies">pennies</span><span class="symbol">:</span>&nbsp;<span class="identifier">Long</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Issued((java.util.Currency)), kotlin.Long, java.security.PublicKey, com.r3corda.core.crypto.Party)/owner">owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Issued((java.util.Currency)), kotlin.Long, java.security.PublicKey, com.r3corda.core.crypto.Party)/notary">notary</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
<p>Puts together an issuance transaction from the given template, that starts out being owned by the given pubkey.</p>
<br/>
<br/>
<a name="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, com.r3corda.core.crypto.Party)"></a>
<code><span class="keyword">fun </span><span class="identifier">generateIssue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, com.r3corda.core.crypto.Party)/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-transaction-builder/index.html"><span class="identifier">TransactionBuilder</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, com.r3corda.core.crypto.Party)/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, com.r3corda.core.crypto.Party)/owner">owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, com.r3corda.core.crypto.Party)/notary">notary</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
<p>Puts together an issuance transaction for the specified amount that starts out being owned by the given pubkey.</p>
<br/>
<br/>
</BODY>
</HTML>

28
docs/build/html/api/com.r3corda.contracts.asset/-cash/generate-spend.html vendored Normal file
View File

@ -0,0 +1,28 @@
<HTML>
<HEAD>
<title>Cash.generateSpend - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="index.html">Cash</a>&nbsp;/&nbsp;<a href=".">generateSpend</a><br/>
<br/>
<h1>generateSpend</h1>
<a name="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))))"></a>
<code><span class="keyword">fun </span><span class="identifier">generateSpend</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-transaction-builder/index.html"><span class="identifier">TransactionBuilder</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))))/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))))/to">to</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))))/cashStates">cashStates</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../com.r3corda.core.contracts/-state-and-ref/index.html"><span class="identifier">StateAndRef</span></a><span class="symbol">&lt;</span><a href="-state/index.html"><span class="identifier">State</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">List</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">&gt;</span></code><br/>
<p>Generate a transaction that consumes one or more of the given input states to move money to the given pubkey.
Note that the wallet list is not updated: its up to you to do that.</p>
<br/>
<br/>
<a name="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))), kotlin.collections.Set((com.r3corda.core.crypto.Party)))"></a>
<code><span class="keyword">fun </span><span class="identifier">generateSpend</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))), kotlin.collections.Set((com.r3corda.core.crypto.Party)))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-transaction-builder/index.html"><span class="identifier">TransactionBuilder</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))), kotlin.collections.Set((com.r3corda.core.crypto.Party)))/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))), kotlin.collections.Set((com.r3corda.core.crypto.Party)))/to">to</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))), kotlin.collections.Set((com.r3corda.core.crypto.Party)))/cashStates">cashStates</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../com.r3corda.core.contracts/-state-and-ref/index.html"><span class="identifier">StateAndRef</span></a><span class="symbol">&lt;</span><a href="-state/index.html"><span class="identifier">State</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))), kotlin.collections.Set((com.r3corda.core.crypto.Party)))/onlyFromParties">onlyFromParties</span><span class="symbol">:</span>&nbsp;<span class="identifier">Set</span><span class="symbol">&lt;</span><a href="../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">&gt;</span><span class="symbol">?</span>&nbsp;<span class="symbol">=</span>&nbsp;null<span class="symbol">)</span><span class="symbol">: </span><span class="identifier">List</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">&gt;</span></code><br/>
<p>Generate a transaction that consumes one or more of the given input states to move money to the given pubkey.
Note that the wallet list is not updated: its up to you to do that.</p>
<h3>Parameters</h3>
<a name="onlyFromParties"></a>
<code>onlyFromParties</code> - if non-null, the wallet will be filtered to only include cash states issued by the set
of given parties. This can be useful if the party youre trying to pay has expectations
about which type of cash claims they are willing to accept.<br/>
<br/>
<br/>
</BODY>
</HTML>

104
docs/build/html/api/com.r3corda.contracts.asset/-cash/index.html vendored Normal file
View File

@ -0,0 +1,104 @@
<HTML>
<HEAD>
<title>Cash - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href=".">Cash</a><br/>
<br/>
<h1>Cash</h1>
<code><span class="keyword">class </span><span class="identifier">Cash</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-fungible-asset/index.html"><span class="identifier">FungibleAsset</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><br/>
<p>A cash transaction may split and merge money represented by a set of (issuer, depositRef) pairs, across multiple
input and output states. Imagine a Bitcoin transaction but in which all UTXOs had a colour
(a blend of issuer+depositRef) and you couldnt merge outputs of two colours together, but you COULD put them in
the same transaction.</p>
<p>The goal of this design is to ensure that money can be withdrawn from the ledger easily: if you receive some money
via this contract, you always know where to go in order to extract it from the R3 ledger, no matter how many hands
it has passed through in the intervening time.</p>
<p>At the same time, other contracts that just want money and dont care much who is currently holding it in their
vaults can ignore the issuer/depositRefs and just examine the amount fields.</p>
<br/>
<br/>
<br/>
<br/>
<h3>Types</h3>
<table>
<tbody>
<tr>
<td>
<a href="-commands/index.html">Commands</a></td>
<td>
<code><span class="keyword">interface </span><span class="identifier">Commands</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-command-data.html"><span class="identifier">CommandData</span></a></code></td>
</tr>
<tr>
<td>
<a href="-state/index.html">State</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">State</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-fungible-asset/-state/index.html"><span class="identifier">State</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><p>A state representing a cash claim against some party</p>
</td>
</tr>
</tbody>
</table>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">Cash</span><span class="symbol">(</span><span class="symbol">)</span></code><p>A cash transaction may split and merge money represented by a set of (issuer, depositRef) pairs, across multiple
input and output states. Imagine a Bitcoin transaction but in which all UTXOs had a colour
(a blend of issuer+depositRef) and you couldnt merge outputs of two colours together, but you COULD put them in
the same transaction.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="legal-contract-reference.html">legalContractReference</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">legalContractReference</span><span class="symbol">: </span><a href="../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code><p>TODO:</p>
</td>
</tr>
</tbody>
</table>
<h3>Functions</h3>
<table>
<tbody>
<tr>
<td>
<a href="generate-issue.html">generateIssue</a></td>
<td>
<code><span class="keyword">fun </span><span class="identifier">generateIssue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Issued((java.util.Currency)), kotlin.Long, java.security.PublicKey, com.r3corda.core.crypto.Party)/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-transaction-builder/index.html"><span class="identifier">TransactionBuilder</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Issued((java.util.Currency)), kotlin.Long, java.security.PublicKey, com.r3corda.core.crypto.Party)/tokenDef">tokenDef</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Issued((java.util.Currency)), kotlin.Long, java.security.PublicKey, com.r3corda.core.crypto.Party)/pennies">pennies</span><span class="symbol">:</span>&nbsp;<span class="identifier">Long</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Issued((java.util.Currency)), kotlin.Long, java.security.PublicKey, com.r3corda.core.crypto.Party)/owner">owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Issued((java.util.Currency)), kotlin.Long, java.security.PublicKey, com.r3corda.core.crypto.Party)/notary">notary</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><p>Puts together an issuance transaction from the given template, that starts out being owned by the given pubkey.</p>
<code><span class="keyword">fun </span><span class="identifier">generateIssue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, com.r3corda.core.crypto.Party)/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-transaction-builder/index.html"><span class="identifier">TransactionBuilder</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, com.r3corda.core.crypto.Party)/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, com.r3corda.core.crypto.Party)/owner">owner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateIssue(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, com.r3corda.core.crypto.Party)/notary">notary</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><p>Puts together an issuance transaction for the specified amount that starts out being owned by the given pubkey.</p>
</td>
</tr>
<tr>
<td>
<a href="generate-spend.html">generateSpend</a></td>
<td>
<code><span class="keyword">fun </span><span class="identifier">generateSpend</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-transaction-builder/index.html"><span class="identifier">TransactionBuilder</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))))/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))))/to">to</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((com.r3corda.core.contracts.Issued((java.util.Currency)))), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))))/cashStates">cashStates</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../com.r3corda.core.contracts/-state-and-ref/index.html"><span class="identifier">StateAndRef</span></a><span class="symbol">&lt;</span><a href="-state/index.html"><span class="identifier">State</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">List</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">&gt;</span></code><br/>
<code><span class="keyword">fun </span><span class="identifier">generateSpend</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))), kotlin.collections.Set((com.r3corda.core.crypto.Party)))/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-transaction-builder/index.html"><span class="identifier">TransactionBuilder</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))), kotlin.collections.Set((com.r3corda.core.crypto.Party)))/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))), kotlin.collections.Set((com.r3corda.core.crypto.Party)))/to">to</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))), kotlin.collections.Set((com.r3corda.core.crypto.Party)))/cashStates">cashStates</span><span class="symbol">:</span>&nbsp;<span class="identifier">List</span><span class="symbol">&lt;</span><a href="../../com.r3corda.core.contracts/-state-and-ref/index.html"><span class="identifier">StateAndRef</span></a><span class="symbol">&lt;</span><a href="-state/index.html"><span class="identifier">State</span></a><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Cash$generateSpend(com.r3corda.core.contracts.TransactionBuilder, com.r3corda.core.contracts.Amount((java.util.Currency)), java.security.PublicKey, kotlin.collections.List((com.r3corda.core.contracts.StateAndRef((com.r3corda.contracts.asset.Cash.State)))), kotlin.collections.Set((com.r3corda.core.crypto.Party)))/onlyFromParties">onlyFromParties</span><span class="symbol">:</span>&nbsp;<span class="identifier">Set</span><span class="symbol">&lt;</span><a href="../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">&gt;</span><span class="symbol">?</span>&nbsp;<span class="symbol">=</span>&nbsp;null<span class="symbol">)</span><span class="symbol">: </span><span class="identifier">List</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">&gt;</span></code><p>Generate a transaction that consumes one or more of the given input states to move money to the given pubkey.
Note that the wallet list is not updated: its up to you to do that.</p>
</td>
</tr>
</tbody>
</table>
<h3>Inherited Functions</h3>
<table>
<tbody>
<tr>
<td>
<a href="../-fungible-asset/verify.html">verify</a></td>
<td>
<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">verify</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.FungibleAsset$verify(com.r3corda.core.contracts.TransactionForContract)/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-transaction-for-contract/index.html"><span class="identifier">TransactionForContract</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><p>This is the function EVERYONE runs</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

25
docs/build/html/api/com.r3corda.contracts.asset/-cash/legal-contract-reference.html vendored Normal file
View File

@ -0,0 +1,25 @@
<HTML>
<HEAD>
<title>Cash.legalContractReference - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="index.html">Cash</a>&nbsp;/&nbsp;<a href=".">legalContractReference</a><br/>
<br/>
<h1>legalContractReference</h1>
<a name="com.r3corda.contracts.asset.Cash$legalContractReference"></a>
<code><span class="keyword">val </span><span class="identifier">legalContractReference</span><span class="symbol">: </span><a href="../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code><br/>
Overrides <a href="../../com.r3corda.core.contracts/-contract/legal-contract-reference.html">Contract.legalContractReference</a><br/>
<p>TODO:</p>
<ol><li><p>hash should be of the contents, not the URI</p>
</li><li><p>allow the content to be specified at time of instance creation?</p>
</li></ol><p>Motivation: its the difference between a state object referencing a programRef, which references a
legalContractReference and a state object which directly references both. The latter allows the legal wording
to evolve without requiring code changes. But creates a risk that users create objects governed by a program
that is inconsistent with the legal contract</p>
<br/>
<br/>
<br/>
<br/>
</BODY>
</HTML>

106
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset-state/index.html vendored Normal file
View File

@ -0,0 +1,106 @@
<HTML>
<HEAD>
<title>FungibleAssetState - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href=".">FungibleAssetState</a><br/>
<br/>
<h1>FungibleAssetState</h1>
<code><span class="keyword">interface </span><span class="identifier">FungibleAssetState</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">, </span><span class="identifier">I</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-ownable-state/index.html"><span class="identifier">OwnableState</span></a></code><br/>
<p>Common elements of cash contract states.</p>
<br/>
<br/>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="issuance-def.html">issuanceDef</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">issuanceDef</span><span class="symbol">: </span><span class="identifier">I</span></code></td>
</tr>
<tr>
<td>
<a href="product-amount.html">productAmount</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">productAmount</span><span class="symbol">: </span><a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
<h3>Inherited Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../com.r3corda.core.contracts/-ownable-state/owner.html">owner</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">owner</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a></code><p>There must be a MoveCommand signed by this key to claim the amount</p>
</td>
</tr>
</tbody>
</table>
<h3>Functions</h3>
<table>
<tbody>
<tr>
<td>
<a href="move.html">move</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">move</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.FungibleAssetState$move(com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.FungibleAssetState.T)), java.security.PublicKey)/newAmount">newAmount</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.FungibleAssetState$move(com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.FungibleAssetState.T)), java.security.PublicKey)/newOwner">newOwner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">FungibleAssetState</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">,</span>&nbsp;<span class="identifier">I</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
<h3>Inherited Functions</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../com.r3corda.core.contracts/-ownable-state/with-new-owner.html">withNewOwner</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">withNewOwner</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.core.contracts.OwnableState$withNewOwner(java.security.PublicKey)/newOwner">newOwner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">&lt;ERROR CLASS&gt;</span><span class="symbol">&lt;</span><a href="../../com.r3corda.core.contracts/-command-data.html"><span class="identifier">CommandData</span></a><span class="symbol">,</span>&nbsp;<a href="../../com.r3corda.core.contracts/-ownable-state/index.html"><span class="identifier">OwnableState</span></a><span class="symbol">&gt;</span></code><p>Copies the underlying data structure, replacing the owner field with this new value and leaving the rest alone</p>
</td>
</tr>
</tbody>
</table>
<h3>Extension Functions</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../com.r3corda.core.contracts/hash.html">hash</a></td>
<td>
<code><span class="keyword">fun </span><a href="../../com.r3corda.core.contracts/-contract-state/index.html"><span class="identifier">ContractState</span></a><span class="symbol">.</span><span class="identifier">hash</span><span class="symbol">(</span><span class="symbol">)</span><span class="symbol">: </span><a href="../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code><p>Returns the SHA-256 hash of the serialised contents of this state (not cached)</p>
</td>
</tr>
<tr>
<td>
<a href="../../com.r3corda.contracts.testing/with notary.html">with notary</a></td>
<td>
<code><span class="keyword">infix</span> <span class="keyword">fun </span><a href="../../com.r3corda.core.contracts/-contract-state/index.html"><span class="identifier">ContractState</span></a><span class="symbol">.</span><span class="identifier">with notary</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$with notary(com.r3corda.core.contracts.ContractState, com.r3corda.core.crypto.Party)/notary">notary</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">)</span><span class="symbol">: </span><a href="../../com.r3corda.core.contracts/-transaction-state/index.html"><span class="identifier">TransactionState</span></a><span class="symbol">&lt;</span><a href="../../com.r3corda.core.contracts/-contract-state/index.html"><span class="identifier">ContractState</span></a><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
<h3>Inheritors</h3>
<table>
<tbody>
<tr>
<td>
<a href="../-fungible-asset/-state/index.html">State</a></td>
<td>
<code><span class="keyword">interface </span><span class="identifier">State</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">FungibleAssetState</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">,</span>&nbsp;<a href="../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>A state representing a cash claim against some party</p>
</td>
</tr>
<tr>
<td>
<a href="../-obligation/-state/index.html">State</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">State</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">FungibleAssetState</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">,</span>&nbsp;<a href="../-obligation/-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span><span class="symbol">, </span><a href="../../com.r3corda.core.contracts/-bilateral-nettable-state/index.html"><span class="identifier">BilateralNettableState</span></a><span class="symbol">&lt;</span><a href="../-obligation/-state/index.html"><span class="identifier">State</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>A state representing the obligation of one party (obligor) to deliver a specified number of
units of an underlying asset (described as issuanceDef.acceptableIssuedProducts) to the beneficiary
no later than the specified time.</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset-state/issuance-def.html vendored Normal file
View File

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

15
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset-state/move.html vendored Normal file
View File

@ -0,0 +1,15 @@
<HTML>
<HEAD>
<title>FungibleAssetState.move - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="index.html">FungibleAssetState</a>&nbsp;/&nbsp;<a href=".">move</a><br/>
<br/>
<h1>move</h1>
<a name="com.r3corda.contracts.asset.FungibleAssetState$move(com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.FungibleAssetState.T)), java.security.PublicKey)"></a>
<code><span class="keyword">abstract</span> <span class="keyword">fun </span><span class="identifier">move</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.FungibleAssetState$move(com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.FungibleAssetState.T)), java.security.PublicKey)/newAmount">newAmount</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.FungibleAssetState$move(com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.FungibleAssetState.T)), java.security.PublicKey)/newOwner">newOwner</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">)</span><span class="symbol">: </span><a href="index.html"><span class="identifier">FungibleAssetState</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">,</span>&nbsp;<span class="identifier">I</span><span class="symbol">&gt;</span></code><br/>
<br/>
<br/>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset-state/product-amount.html vendored Normal file
View File

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

15
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/-commands/-exit/amount.html vendored Normal file
View File

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

40
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/-commands/-exit/index.html vendored Normal file
View File

@ -0,0 +1,40 @@
<HTML>
<HEAD>
<title>FungibleAsset.Commands.Exit - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">FungibleAsset</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href=".">Exit</a><br/>
<br/>
<h1>Exit</h1>
<code><span class="keyword">interface </span><span class="identifier">Exit</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../index.html"><span class="identifier">Commands</span></a></code><br/>
<p>A command stating that money has been withdrawn from the shared ledger and is now accounted for
in some other way.</p>
<br/>
<br/>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="amount.html">amount</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">amount</span><span class="symbol">: </span><a href="../../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
<h3>Inheritors</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../../-cash/-commands/-exit/index.html">Exit</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Exit</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../-cash/-commands/index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><span class="identifier">Exit</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><p>A command stating that money has been withdrawn from the shared ledger and is now accounted for
in some other way.</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

40
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/-commands/-issue.html vendored Normal file
View File

@ -0,0 +1,40 @@
<HTML>
<HEAD>
<title>FungibleAsset.Commands.Issue - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">FungibleAsset</a>&nbsp;/&nbsp;<a href="index.html">Commands</a>&nbsp;/&nbsp;<a href=".">Issue</a><br/>
<br/>
<h1>Issue</h1>
<code><span class="keyword">interface </span><span class="identifier">Issue</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-issue-command/index.html"><span class="identifier">IssueCommand</span></a><span class="symbol">, </span><a href="index.html"><span class="identifier">Commands</span></a></code><br/>
<p>Allows new asset states to be issued into existence: the nonce ("number used once") ensures the transaction
has a unique ID even when there are no inputs.</p>
<br/>
<br/>
<h3>Inherited Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../../com.r3corda.core.contracts/-issue-command/nonce.html">nonce</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">nonce</span><span class="symbol">: </span><span class="identifier">Long</span></code></td>
</tr>
</tbody>
</table>
<h3>Inheritors</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../-cash/-commands/-issue/index.html">Issue</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Issue</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Issue</span><span class="symbol">, </span><a href="../../-cash/-commands/index.html"><span class="identifier">Commands</span></a></code><p>Allows new cash states to be issued into existence: the nonce ("number used once") ensures the transaction
has a unique ID even when there are no inputs.</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

39
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/-commands/-move.html vendored Normal file
View File

@ -0,0 +1,39 @@
<HTML>
<HEAD>
<title>FungibleAsset.Commands.Move - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">FungibleAsset</a>&nbsp;/&nbsp;<a href="index.html">Commands</a>&nbsp;/&nbsp;<a href=".">Move</a><br/>
<br/>
<h1>Move</h1>
<code><span class="keyword">interface </span><span class="identifier">Move</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-move-command/index.html"><span class="identifier">MoveCommand</span></a><span class="symbol">, </span><a href="index.html"><span class="identifier">Commands</span></a></code><br/>
<br/>
<br/>
<h3>Inherited Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../../com.r3corda.core.contracts/-move-command/contract-hash.html">contractHash</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">contractHash</span><span class="symbol">: </span><a href="../../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">?</span></code><p>Contract code the moved state(s) are for the attention of, for example to indicate that the states are moved in
order to settle an obligation contracts state object(s).</p>
</td>
</tr>
</tbody>
</table>
<h3>Inheritors</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../-cash/-commands/-move/index.html">Move</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Move</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Move</span><span class="symbol">, </span><a href="../../-cash/-commands/index.html"><span class="identifier">Commands</span></a></code><p>A command stating that money has been moved, optionally to fulfil another contract.</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

68
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/-commands/index.html vendored Normal file
View File

@ -0,0 +1,68 @@
<HTML>
<HEAD>
<title>FungibleAsset.Commands - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">FungibleAsset</a>&nbsp;/&nbsp;<a href=".">Commands</a><br/>
<br/>
<h1>Commands</h1>
<code><span class="keyword">interface </span><span class="identifier">Commands</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-command-data.html"><span class="identifier">CommandData</span></a></code><br/>
<br/>
<br/>
<h3>Types</h3>
<table>
<tbody>
<tr>
<td>
<a href="-exit/index.html">Exit</a></td>
<td>
<code><span class="keyword">interface </span><span class="identifier">Exit</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span></code><p>A command stating that money has been withdrawn from the shared ledger and is now accounted for
in some other way.</p>
</td>
</tr>
<tr>
<td>
<a href="-issue.html">Issue</a></td>
<td>
<code><span class="keyword">interface </span><span class="identifier">Issue</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-issue-command/index.html"><span class="identifier">IssueCommand</span></a><span class="symbol">, </span><span class="identifier">Commands</span></code><p>Allows new asset states to be issued into existence: the nonce ("number used once") ensures the transaction
has a unique ID even when there are no inputs.</p>
</td>
</tr>
<tr>
<td>
<a href="-move.html">Move</a></td>
<td>
<code><span class="keyword">interface </span><span class="identifier">Move</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-move-command/index.html"><span class="identifier">MoveCommand</span></a><span class="symbol">, </span><span class="identifier">Commands</span></code></td>
</tr>
</tbody>
</table>
<h3>Inheritors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-exit/index.html">Exit</a></td>
<td>
<code><span class="keyword">interface </span><span class="identifier">Exit</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span></code><p>A command stating that money has been withdrawn from the shared ledger and is now accounted for
in some other way.</p>
</td>
</tr>
<tr>
<td>
<a href="-issue.html">Issue</a></td>
<td>
<code><span class="keyword">interface </span><span class="identifier">Issue</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-issue-command/index.html"><span class="identifier">IssueCommand</span></a><span class="symbol">, </span><span class="identifier">Commands</span></code><p>Allows new asset states to be issued into existence: the nonce ("number used once") ensures the transaction
has a unique ID even when there are no inputs.</p>
</td>
</tr>
<tr>
<td>
<a href="-move.html">Move</a></td>
<td>
<code><span class="keyword">interface </span><span class="identifier">Move</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-move-command/index.html"><span class="identifier">MoveCommand</span></a><span class="symbol">, </span><span class="identifier">Commands</span></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

27
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/-init-.html vendored Normal file
View File

@ -0,0 +1,27 @@
<HTML>
<HEAD>
<title>FungibleAsset.<init> - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="index.html">FungibleAsset</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">FungibleAsset</span><span class="symbol">(</span><span class="symbol">)</span></code><br/>
<p>Superclass for contracts representing assets which are fungible, countable and issued by a specific party. States
contain assets which are equivalent (such as cash of the same currency), so records of their existence can
be merged or split as needed where the issuer is the same. For instance, dollars issued by the Fed are fungible and
countable (in cents), barrels of West Texas crude are fungible and countable (oil from two small containers
can be poured into one large container), shares of the same class in a specific company are fungible and
countable, and so on.</p>
<p>See <a href="../-cash/index.html">Cash</a> for an example subclass that implements currency.</p>
<br/>
<br/>
<h3>Parameters</h3>
<a name="T"></a>
<code>T</code> - a type that represents the asset in question. This should describe the basic type of the asset
(GBP, USD, oil, shares in company , etc.) and any additional metadata (issuer, grade, class, etc.)<br/>
<br/>
<br/>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/-state/amount.html vendored Normal file
View File

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

16
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/-state/deposit.html vendored Normal file
View File

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

69
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/-state/index.html vendored Normal file
View File

@ -0,0 +1,69 @@
<HTML>
<HEAD>
<title>FungibleAsset.State - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">FungibleAsset</a>&nbsp;/&nbsp;<a href=".">State</a><br/>
<br/>
<h1>State</h1>
<code><span class="keyword">interface </span><span class="identifier">State</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../-fungible-asset-state/index.html"><span class="identifier">FungibleAssetState</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">,</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><br/>
<p>A state representing a cash claim against some party</p>
<br/>
<br/>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="amount.html">amount</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">amount</span><span class="symbol">: </span><a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="../../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code></td>
</tr>
<tr>
<td>
<a href="deposit.html">deposit</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">deposit</span><span class="symbol">: </span><a href="../../../com.r3corda.core.contracts/-party-and-reference/index.html"><span class="identifier">PartyAndReference</span></a></code><p>Where the underlying currency backing this ledger entry can be found (propagated)</p>
</td>
</tr>
<tr>
<td>
<a href="owner.html">owner</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">owner</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a></code><p>There must be a MoveCommand signed by this key to claim the amount</p>
</td>
</tr>
</tbody>
</table>
<h3>Inherited Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../-fungible-asset-state/issuance-def.html">issuanceDef</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">issuanceDef</span><span class="symbol">: </span><span class="identifier">I</span></code></td>
</tr>
<tr>
<td>
<a href="../../-fungible-asset-state/product-amount.html">productAmount</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">productAmount</span><span class="symbol">: </span><a href="../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
<h3>Inheritors</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../-cash/-state/index.html">State</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">State</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">State</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><p>A state representing a cash claim against some party</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

17
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/-state/owner.html vendored Normal file
View File

@ -0,0 +1,17 @@
<HTML>
<HEAD>
<title>FungibleAsset.State.owner - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">FungibleAsset</a>&nbsp;/&nbsp;<a href="index.html">State</a>&nbsp;/&nbsp;<a href=".">owner</a><br/>
<br/>
<h1>owner</h1>
<a name="com.r3corda.contracts.asset.FungibleAsset.State$owner"></a>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">owner</span><span class="symbol">: </span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a></code><br/>
Overrides <a href="../../../com.r3corda.core.contracts/-ownable-state/owner.html">OwnableState.owner</a><br/>
<p>There must be a MoveCommand signed by this key to claim the amount</p>
<br/>
<br/>
</BODY>
</HTML>

102
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/index.html vendored Normal file
View File

@ -0,0 +1,102 @@
<HTML>
<HEAD>
<title>FungibleAsset - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href=".">FungibleAsset</a><br/>
<br/>
<h1>FungibleAsset</h1>
<code><span class="keyword">abstract</span> <span class="keyword">class </span><span class="identifier">FungibleAsset</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-contract/index.html"><span class="identifier">Contract</span></a></code><br/>
<p>Superclass for contracts representing assets which are fungible, countable and issued by a specific party. States
contain assets which are equivalent (such as cash of the same currency), so records of their existence can
be merged or split as needed where the issuer is the same. For instance, dollars issued by the Fed are fungible and
countable (in cents), barrels of West Texas crude are fungible and countable (oil from two small containers
can be poured into one large container), shares of the same class in a specific company are fungible and
countable, and so on.</p>
<p>See <a href="../-cash/index.html">Cash</a> for an example subclass that implements currency.</p>
<br/>
<br/>
<h3>Parameters</h3>
<a name="T"></a>
<code>T</code> - a type that represents the asset in question. This should describe the basic type of the asset
(GBP, USD, oil, shares in company , etc.) and any additional metadata (issuer, grade, class, etc.)<br/>
<br/>
<br/>
<h3>Types</h3>
<table>
<tbody>
<tr>
<td>
<a href="-commands/index.html">Commands</a></td>
<td>
<code><span class="keyword">interface </span><span class="identifier">Commands</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-command-data.html"><span class="identifier">CommandData</span></a></code></td>
</tr>
<tr>
<td>
<a href="-state/index.html">State</a></td>
<td>
<code><span class="keyword">interface </span><span class="identifier">State</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-fungible-asset-state/index.html"><span class="identifier">FungibleAssetState</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">,</span>&nbsp;<a href="../../com.r3corda.core.contracts/-issued/index.html"><span class="identifier">Issued</span></a><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">&gt;</span></code><p>A state representing a cash claim against some party</p>
</td>
</tr>
</tbody>
</table>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">FungibleAsset</span><span class="symbol">(</span><span class="symbol">)</span></code><p>Superclass for contracts representing assets which are fungible, countable and issued by a specific party. States
contain assets which are equivalent (such as cash of the same currency), so records of their existence can
be merged or split as needed where the issuer is the same. For instance, dollars issued by the Fed are fungible and
countable (in cents), barrels of West Texas crude are fungible and countable (oil from two small containers
can be poured into one large container), shares of the same class in a specific company are fungible and
countable, and so on.</p>
</td>
</tr>
</tbody>
</table>
<h3>Inherited Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../com.r3corda.core.contracts/-contract/legal-contract-reference.html">legalContractReference</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">legalContractReference</span><span class="symbol">: </span><a href="../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a></code><p>Unparsed reference to the natural language contract that this code is supposed to express (usually a hash of
the contracts contents).</p>
</td>
</tr>
</tbody>
</table>
<h3>Functions</h3>
<table>
<tbody>
<tr>
<td>
<a href="verify.html">verify</a></td>
<td>
<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">verify</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.FungibleAsset$verify(com.r3corda.core.contracts.TransactionForContract)/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-transaction-for-contract/index.html"><span class="identifier">TransactionForContract</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><p>This is the function EVERYONE runs</p>
</td>
</tr>
</tbody>
</table>
<h3>Inheritors</h3>
<table>
<tbody>
<tr>
<td>
<a href="../-cash/index.html">Cash</a></td>
<td>
<code><span class="keyword">class </span><span class="identifier">Cash</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">FungibleAsset</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code><p>A cash transaction may split and merge money represented by a set of (issuer, depositRef) pairs, across multiple
input and output states. Imagine a Bitcoin transaction but in which all UTXOs had a colour
(a blend of issuer+depositRef) and you couldnt merge outputs of two colours together, but you COULD put them in
the same transaction.</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

17
docs/build/html/api/com.r3corda.contracts.asset/-fungible-asset/verify.html vendored Normal file
View File

@ -0,0 +1,17 @@
<HTML>
<HEAD>
<title>FungibleAsset.verify - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="index.html">FungibleAsset</a>&nbsp;/&nbsp;<a href=".">verify</a><br/>
<br/>
<h1>verify</h1>
<a name="com.r3corda.contracts.asset.FungibleAsset$verify(com.r3corda.core.contracts.TransactionForContract)"></a>
<code><span class="keyword">open</span> <span class="keyword">fun </span><span class="identifier">verify</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.FungibleAsset$verify(com.r3corda.core.contracts.TransactionForContract)/tx">tx</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-transaction-for-contract/index.html"><span class="identifier">TransactionForContract</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">Unit</span></code><br/>
Overrides <a href="../../com.r3corda.core.contracts/-contract/verify.html">Contract.verify</a><br/>
<p>This is the function EVERYONE runs</p>
<br/>
<br/>
</BODY>
</HTML>

14
docs/build/html/api/com.r3corda.contracts.asset/-insufficient-balance-exception/-init-.html vendored Normal file
View File

@ -0,0 +1,14 @@
<HTML>
<HEAD>
<title>InsufficientBalanceException.<init> - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="index.html">InsufficientBalanceException</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">InsufficientBalanceException</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.InsufficientBalanceException$<init>(com.r3corda.core.contracts.Amount((java.util.Currency)))/amountMissing">amountMissing</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">)</span></code><br/>
<br/>
<br/>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-insufficient-balance-exception/amount-missing.html vendored Normal file
View File

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

36
docs/build/html/api/com.r3corda.contracts.asset/-insufficient-balance-exception/index.html vendored Normal file
View File

@ -0,0 +1,36 @@
<HTML>
<HEAD>
<title>InsufficientBalanceException - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href=".">InsufficientBalanceException</a><br/>
<br/>
<h1>InsufficientBalanceException</h1>
<code><span class="keyword">class </span><span class="identifier">InsufficientBalanceException</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Exception.html"><span class="identifier">Exception</span></a></code><br/>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">InsufficientBalanceException</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.InsufficientBalanceException$<init>(com.r3corda.core.contracts.Amount((java.util.Currency)))/amountMissing">amountMissing</span><span class="symbol">:</span>&nbsp;<a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span><span class="symbol">)</span></code></td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="amount-missing.html">amountMissing</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">amountMissing</span><span class="symbol">: </span><a href="../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/util/Currency.html"><span class="identifier">Currency</span></a><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-o-b-l-i-g-a-t-i-o-n_-p-r-o-g-r-a-m_-i-d.html vendored Normal file
View File

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

17
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-bilateral-net-state/-init-.html vendored Normal file
View File

@ -0,0 +1,17 @@
<HTML>
<HEAD>
<title>Obligation.BilateralNetState.<init> - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href="index.html">BilateralNetState</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">BilateralNetState</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.BilateralNetState$<init>(kotlin.collections.Set((java.security.PublicKey)), com.r3corda.contracts.asset.Obligation.StateTemplate((com.r3corda.contracts.asset.Obligation.BilateralNetState.P)))/partyKeys">partyKeys</span><span class="symbol">:</span>&nbsp;<span class="identifier">Set</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.BilateralNetState$<init>(kotlin.collections.Set((java.security.PublicKey)), com.r3corda.contracts.asset.Obligation.StateTemplate((com.r3corda.contracts.asset.Obligation.BilateralNetState.P)))/template">template</span><span class="symbol">:</span>&nbsp;<a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><br/>
<p>Subset of state, containing the elements which must match for two obligation transactions to be nettable.
If two obligation state objects produce equal bilateral net states, they are considered safe to net directly.
Bilateral states are used in close-out netting.</p>
<br/>
<br/>
</BODY>
</HTML>

48
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-bilateral-net-state/index.html vendored Normal file
View File

@ -0,0 +1,48 @@
<HTML>
<HEAD>
<title>Obligation.BilateralNetState - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href=".">BilateralNetState</a><br/>
<br/>
<h1>BilateralNetState</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">BilateralNetState</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-net-state/index.html"><span class="identifier">NetState</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
<p>Subset of state, containing the elements which must match for two obligation transactions to be nettable.
If two obligation state objects produce equal bilateral net states, they are considered safe to net directly.
Bilateral states are used in close-out netting.</p>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">BilateralNetState</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.BilateralNetState$<init>(kotlin.collections.Set((java.security.PublicKey)), com.r3corda.contracts.asset.Obligation.StateTemplate((com.r3corda.contracts.asset.Obligation.BilateralNetState.P)))/partyKeys">partyKeys</span><span class="symbol">:</span>&nbsp;<span class="identifier">Set</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.BilateralNetState$<init>(kotlin.collections.Set((java.security.PublicKey)), com.r3corda.contracts.asset.Obligation.StateTemplate((com.r3corda.contracts.asset.Obligation.BilateralNetState.P)))/template">template</span><span class="symbol">:</span>&nbsp;<a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><p>Subset of state, containing the elements which must match for two obligation transactions to be nettable.
If two obligation state objects produce equal bilateral net states, they are considered safe to net directly.
Bilateral states are used in close-out netting.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="party-keys.html">partyKeys</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">partyKeys</span><span class="symbol">: </span><span class="identifier">Set</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">&gt;</span></code></td>
</tr>
<tr>
<td>
<a href="template.html">template</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">template</span><span class="symbol">: </span><a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-bilateral-net-state/party-keys.html vendored Normal file
View File

@ -0,0 +1,15 @@
<HTML>
<HEAD>
<title>Obligation.BilateralNetState.partyKeys - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href="index.html">BilateralNetState</a>&nbsp;/&nbsp;<a href=".">partyKeys</a><br/>
<br/>
<h1>partyKeys</h1>
<a name="com.r3corda.contracts.asset.Obligation.BilateralNetState$partyKeys"></a>
<code><span class="keyword">val </span><span class="identifier">partyKeys</span><span class="symbol">: </span><span class="identifier">Set</span><span class="symbol">&lt;</span><a href="http://docs.oracle.com/javase/6/docs/api/java/security/PublicKey.html"><span class="identifier">PublicKey</span></a><span class="symbol">&gt;</span></code><br/>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-bilateral-net-state/template.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.BilateralNetState.template - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href="index.html">BilateralNetState</a>&nbsp;/&nbsp;<a href=".">template</a><br/>
<br/>
<h1>template</h1>
<a name="com.r3corda.contracts.asset.Obligation.BilateralNetState$template"></a>
<code><span class="keyword">val </span><span class="identifier">template</span><span class="symbol">: </span><a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../-net-state/template.html">NetState.template</a><br/>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-exit/-init-.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Exit.<init> - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Exit</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">Exit</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Exit$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Exit.P)), com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.Obligation.Commands.Exit.P)))/aggregateState">aggregateState</span><span class="symbol">:</span>&nbsp;<a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Exit$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Exit.P)), com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.Obligation.Commands.Exit.P)))/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><br/>
<p>A command stating that the debt is being released by the beneficiary. Normally would indicate
either settlement outside of the ledger, or that the obligor is unable to pay.</p>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-exit/aggregate-state.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Exit.aggregateState - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Exit</a>&nbsp;/&nbsp;<a href=".">aggregateState</a><br/>
<br/>
<h1>aggregateState</h1>
<a name="com.r3corda.contracts.asset.Obligation.Commands.Exit$aggregateState"></a>
<code><span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../../-issuance-commands/aggregate-state.html">IssuanceCommands.aggregateState</a><br/>
<br/>
<br/>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-exit/amount.html vendored Normal file
View File

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

46
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-exit/index.html vendored Normal file
View File

@ -0,0 +1,46 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Exit - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href=".">Exit</a><br/>
<br/>
<h1>Exit</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Exit</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><a href="../../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
<p>A command stating that the debt is being released by the beneficiary. Normally would indicate
either settlement outside of the ledger, or that the obligor is unable to pay.</p>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">Exit</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Exit$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Exit.P)), com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.Obligation.Commands.Exit.P)))/aggregateState">aggregateState</span><span class="symbol">:</span>&nbsp;<a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Exit$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Exit.P)), com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.Obligation.Commands.Exit.P)))/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><p>A command stating that the debt is being released by the beneficiary. Normally would indicate
either settlement outside of the ledger, or that the obligor is unable to pay.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="aggregate-state.html">aggregateState</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
<tr>
<td>
<a href="amount.html">amount</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">amount</span><span class="symbol">: </span><a href="../../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-issue/-init-.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Issue.<init> - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Issue</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">Issue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Issue$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Issue.P)), kotlin.Long)/aggregateState">aggregateState</span><span class="symbol">:</span>&nbsp;<a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Issue$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Issue.P)), kotlin.Long)/nonce">nonce</span><span class="symbol">:</span>&nbsp;<span class="identifier">Long</span>&nbsp;<span class="symbol">=</span>&nbsp;random63BitValue()<span class="symbol">)</span></code><br/>
<p>Allows new obligation states to be issued into existence: the nonce ("number used once") ensures the
transaction has a unique ID even when there are no inputs.</p>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-issue/aggregate-state.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Issue.aggregateState - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Issue</a>&nbsp;/&nbsp;<a href=".">aggregateState</a><br/>
<br/>
<h1>aggregateState</h1>
<a name="com.r3corda.contracts.asset.Obligation.Commands.Issue$aggregateState"></a>
<code><span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../../-issuance-commands/aggregate-state.html">IssuanceCommands.aggregateState</a><br/>
<br/>
<br/>
</BODY>
</HTML>

46
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-issue/index.html vendored Normal file
View File

@ -0,0 +1,46 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Issue - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href=".">Issue</a><br/>
<br/>
<h1>Issue</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Issue</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><a href="../../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
<p>Allows new obligation states to be issued into existence: the nonce ("number used once") ensures the
transaction has a unique ID even when there are no inputs.</p>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">Issue</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Issue$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Issue.P)), kotlin.Long)/aggregateState">aggregateState</span><span class="symbol">:</span>&nbsp;<a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Issue$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Issue.P)), kotlin.Long)/nonce">nonce</span><span class="symbol">:</span>&nbsp;<span class="identifier">Long</span>&nbsp;<span class="symbol">=</span>&nbsp;random63BitValue()<span class="symbol">)</span></code><p>Allows new obligation states to be issued into existence: the nonce ("number used once") ensures the
transaction has a unique ID even when there are no inputs.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="aggregate-state.html">aggregateState</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
<tr>
<td>
<a href="nonce.html">nonce</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">nonce</span><span class="symbol">: </span><span class="identifier">Long</span></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-issue/nonce.html vendored Normal file
View File

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

20
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-move/-init-.html vendored Normal file
View File

@ -0,0 +1,20 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Move.<init> - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Move</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">Move</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Move$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Move.P)), com.r3corda.core.crypto.SecureHash)/aggregateState">aggregateState</span><span class="symbol">:</span>&nbsp;<a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Move$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Move.P)), com.r3corda.core.crypto.SecureHash)/contractHash">contractHash</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">?</span>&nbsp;<span class="symbol">=</span>&nbsp;null<span class="symbol">)</span></code><br/>
<p>A command stating that a debt has been moved, optionally to fulfil another contract.</p>
<h3>Parameters</h3>
<a name="contractHash"></a>
<code>contractHash</code> - the contract this move is for the attention of. Only that contracts verify function
should take the moved states into account when considering whether it is valid. Typically this will be
null.<br/>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-move/aggregate-state.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Move.aggregateState - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Move</a>&nbsp;/&nbsp;<a href=".">aggregateState</a><br/>
<br/>
<h1>aggregateState</h1>
<a name="com.r3corda.contracts.asset.Obligation.Commands.Move$aggregateState"></a>
<code><span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../../-issuance-commands/aggregate-state.html">IssuanceCommands.aggregateState</a><br/>
<br/>
<br/>
</BODY>
</HTML>

18
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-move/contract-hash.html vendored Normal file
View File

@ -0,0 +1,18 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Move.contractHash - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Move</a>&nbsp;/&nbsp;<a href=".">contractHash</a><br/>
<br/>
<h1>contractHash</h1>
<a name="com.r3corda.contracts.asset.Obligation.Commands.Move$contractHash"></a>
<code><span class="keyword">val </span><span class="identifier">contractHash</span><span class="symbol">: </span><a href="../../../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">?</span></code><br/>
Overrides <a href="../../../../com.r3corda.core.contracts/-move-command/contract-hash.html">MoveCommand.contractHash</a><br/>
<p>Contract code the moved state(s) are for the attention of, for example to indicate that the states are moved in
order to settle an obligation contracts state object(s).</p>
<br/>
<br/>
</BODY>
</HTML>

51
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-move/index.html vendored Normal file
View File

@ -0,0 +1,51 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Move - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href=".">Move</a><br/>
<br/>
<h1>Move</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Move</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><a href="../../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><a href="../../../../com.r3corda.core.contracts/-move-command/index.html"><span class="identifier">MoveCommand</span></a></code><br/>
<p>A command stating that a debt has been moved, optionally to fulfil another contract.</p>
<h3>Parameters</h3>
<a name="contractHash"></a>
<code>contractHash</code> - the contract this move is for the attention of. Only that contracts verify function
should take the moved states into account when considering whether it is valid. Typically this will be
null.<br/>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">Move</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Move$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Move.P)), com.r3corda.core.crypto.SecureHash)/aggregateState">aggregateState</span><span class="symbol">:</span>&nbsp;<a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Move$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Move.P)), com.r3corda.core.crypto.SecureHash)/contractHash">contractHash</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">?</span>&nbsp;<span class="symbol">=</span>&nbsp;null<span class="symbol">)</span></code><p>A command stating that a debt has been moved, optionally to fulfil another contract.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="aggregate-state.html">aggregateState</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
<tr>
<td>
<a href="contract-hash.html">contractHash</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">contractHash</span><span class="symbol">: </span><a href="../../../../com.r3corda.core.crypto/-secure-hash/index.html"><span class="identifier">SecureHash</span></a><span class="symbol">?</span></code><p>Contract code the moved state(s) are for the attention of, for example to indicate that the states are moved in
order to settle an obligation contracts state object(s).</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-net/-init-.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Net.<init> - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Net</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">Net</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Net$<init>(com.r3corda.core.contracts.NetType)/type">type</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.contracts/-net-type/index.html"><span class="identifier">NetType</span></a><span class="symbol">)</span></code><br/>
<p>Net two or more obligation states together in a close-out netting style. Limited to bilateral netting
as only the beneficiary (not the obligor) needs to sign.</p>
<br/>
<br/>
</BODY>
</HTML>

40
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-net/index.html vendored Normal file
View File

@ -0,0 +1,40 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Net - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href=".">Net</a><br/>
<br/>
<h1>Net</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Net</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../index.html"><span class="identifier">Commands</span></a></code><br/>
<p>Net two or more obligation states together in a close-out netting style. Limited to bilateral netting
as only the beneficiary (not the obligor) needs to sign.</p>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">Net</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Net$<init>(com.r3corda.core.contracts.NetType)/type">type</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.contracts/-net-type/index.html"><span class="identifier">NetType</span></a><span class="symbol">)</span></code><p>Net two or more obligation states together in a close-out netting style. Limited to bilateral netting
as only the beneficiary (not the obligor) needs to sign.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="type.html">type</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">type</span><span class="symbol">: </span><a href="../../../../com.r3corda.core.contracts/-net-type/index.html"><span class="identifier">NetType</span></a></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-net/type.html vendored Normal file
View File

@ -0,0 +1,15 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Net.type - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Net</a>&nbsp;/&nbsp;<a href=".">type</a><br/>
<br/>
<h1>type</h1>
<a name="com.r3corda.contracts.asset.Obligation.Commands.Net$type"></a>
<code><span class="keyword">val </span><span class="identifier">type</span><span class="symbol">: </span><a href="../../../../com.r3corda.core.contracts/-net-type/index.html"><span class="identifier">NetType</span></a></code><br/>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-set-lifecycle/-init-.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.Commands.SetLifecycle.<init> - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">SetLifecycle</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">SetLifecycle</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.SetLifecycle$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.SetLifecycle.P)), com.r3corda.contracts.asset.Obligation.Lifecycle)/aggregateState">aggregateState</span><span class="symbol">:</span>&nbsp;<a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.SetLifecycle$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.SetLifecycle.P)), com.r3corda.contracts.asset.Obligation.Lifecycle)/lifecycle">lifecycle</span><span class="symbol">:</span>&nbsp;<a href="../../-lifecycle/index.html"><span class="identifier">Lifecycle</span></a><span class="symbol">)</span></code><br/>
<p>A command stating that the beneficiary is moving the contract into the defaulted state as it has not been settled
by the due date, or resetting a defaulted contract back to the issued state.</p>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-set-lifecycle/aggregate-state.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.Commands.SetLifecycle.aggregateState - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">SetLifecycle</a>&nbsp;/&nbsp;<a href=".">aggregateState</a><br/>
<br/>
<h1>aggregateState</h1>
<a name="com.r3corda.contracts.asset.Obligation.Commands.SetLifecycle$aggregateState"></a>
<code><span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../../-issuance-commands/aggregate-state.html">IssuanceCommands.aggregateState</a><br/>
<br/>
<br/>
</BODY>
</HTML>

52
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-set-lifecycle/index.html vendored Normal file
View File

@ -0,0 +1,52 @@
<HTML>
<HEAD>
<title>Obligation.Commands.SetLifecycle - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href=".">SetLifecycle</a><br/>
<br/>
<h1>SetLifecycle</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">SetLifecycle</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><a href="../../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
<p>A command stating that the beneficiary is moving the contract into the defaulted state as it has not been settled
by the due date, or resetting a defaulted contract back to the issued state.</p>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">SetLifecycle</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.SetLifecycle$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.SetLifecycle.P)), com.r3corda.contracts.asset.Obligation.Lifecycle)/aggregateState">aggregateState</span><span class="symbol">:</span>&nbsp;<a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.SetLifecycle$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.SetLifecycle.P)), com.r3corda.contracts.asset.Obligation.Lifecycle)/lifecycle">lifecycle</span><span class="symbol">:</span>&nbsp;<a href="../../-lifecycle/index.html"><span class="identifier">Lifecycle</span></a><span class="symbol">)</span></code><p>A command stating that the beneficiary is moving the contract into the defaulted state as it has not been settled
by the due date, or resetting a defaulted contract back to the issued state.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="aggregate-state.html">aggregateState</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
<tr>
<td>
<a href="inverse.html">inverse</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">inverse</span><span class="symbol">: </span><a href="../../-lifecycle/index.html"><span class="identifier">Lifecycle</span></a></code></td>
</tr>
<tr>
<td>
<a href="lifecycle.html">lifecycle</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">lifecycle</span><span class="symbol">: </span><a href="../../-lifecycle/index.html"><span class="identifier">Lifecycle</span></a></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-set-lifecycle/inverse.html vendored Normal file
View File

@ -0,0 +1,15 @@
<HTML>
<HEAD>
<title>Obligation.Commands.SetLifecycle.inverse - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">SetLifecycle</a>&nbsp;/&nbsp;<a href=".">inverse</a><br/>
<br/>
<h1>inverse</h1>
<a name="com.r3corda.contracts.asset.Obligation.Commands.SetLifecycle$inverse"></a>
<code><span class="keyword">val </span><span class="identifier">inverse</span><span class="symbol">: </span><a href="../../-lifecycle/index.html"><span class="identifier">Lifecycle</span></a></code><br/>
<br/>
<br/>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-set-lifecycle/lifecycle.html vendored Normal file
View File

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

19
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-settle/-init-.html vendored Normal file
View File

@ -0,0 +1,19 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Settle.<init> - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Settle</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">Settle</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Settle$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Settle.P)), com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.Obligation.Commands.Settle.P)))/aggregateState">aggregateState</span><span class="symbol">:</span>&nbsp;<a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Settle$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Settle.P)), com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.Obligation.Commands.Settle.P)))/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><br/>
<p>A command stating that the obligor is settling some or all of the amount owed by transferring a suitable
state object to the beneficiary. If this reduces the balance to zero, the state object is destroyed.</p>
<p><strong>See Also</strong><br/>
<p><a href="../../../../com.r3corda.core.contracts/-move-command/index.html">MoveCommand</a></p>
</p>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-settle/aggregate-state.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Settle.aggregateState - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href="index.html">Settle</a>&nbsp;/&nbsp;<a href=".">aggregateState</a><br/>
<br/>
<h1>aggregateState</h1>
<a name="com.r3corda.contracts.asset.Obligation.Commands.Settle$aggregateState"></a>
<code><span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../../-issuance-commands/aggregate-state.html">IssuanceCommands.aggregateState</a><br/>
<br/>
<br/>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-settle/amount.html vendored Normal file
View File

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

49
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/-settle/index.html vendored Normal file
View File

@ -0,0 +1,49 @@
<HTML>
<HEAD>
<title>Obligation.Commands.Settle - </title>
<link rel="stylesheet" href="../../../../style.css">
</HEAD>
<BODY>
<a href="../../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../../index.html">Obligation</a>&nbsp;/&nbsp;<a href="../index.html">Commands</a>&nbsp;/&nbsp;<a href=".">Settle</a><br/>
<br/>
<h1>Settle</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Settle</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><a href="../../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
<p>A command stating that the obligor is settling some or all of the amount owed by transferring a suitable
state object to the beneficiary. If this reduces the balance to zero, the state object is destroyed.</p>
<p><strong>See Also</strong><br/>
<p><a href="../../../../com.r3corda.core.contracts/-move-command/index.html">MoveCommand</a></p>
</p>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">Settle</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Settle$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Settle.P)), com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.Obligation.Commands.Settle.P)))/aggregateState">aggregateState</span><span class="symbol">:</span>&nbsp;<a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.Commands.Settle$<init>(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.asset.Obligation.Commands.Settle.P)), com.r3corda.core.contracts.Amount((com.r3corda.contracts.asset.Obligation.Commands.Settle.P)))/amount">amount</span><span class="symbol">:</span>&nbsp;<a href="../../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><p>A command stating that the obligor is settling some or all of the amount owed by transferring a suitable
state object to the beneficiary. If this reduces the balance to zero, the state object is destroyed.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="aggregate-state.html">aggregateState</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
<tr>
<td>
<a href="amount.html">amount</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">amount</span><span class="symbol">: </span><a href="../../../../com.r3corda.core.contracts/-amount/index.html"><span class="identifier">Amount</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

118
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-commands/index.html vendored Normal file
View File

@ -0,0 +1,118 @@
<HTML>
<HEAD>
<title>Obligation.Commands - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href=".">Commands</a><br/>
<br/>
<h1>Commands</h1>
<code><span class="keyword">interface </span><span class="identifier">Commands</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-command-data.html"><span class="identifier">CommandData</span></a></code><br/>
<br/>
<br/>
<h3>Types</h3>
<table>
<tbody>
<tr>
<td>
<a href="-exit/index.html">Exit</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Exit</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>A command stating that the debt is being released by the beneficiary. Normally would indicate
either settlement outside of the ledger, or that the obligor is unable to pay.</p>
</td>
</tr>
<tr>
<td>
<a href="-issue/index.html">Issue</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Issue</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>Allows new obligation states to be issued into existence: the nonce ("number used once") ensures the
transaction has a unique ID even when there are no inputs.</p>
</td>
</tr>
<tr>
<td>
<a href="-move/index.html">Move</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Move</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><a href="../../../com.r3corda.core.contracts/-move-command/index.html"><span class="identifier">MoveCommand</span></a></code><p>A command stating that a debt has been moved, optionally to fulfil another contract.</p>
</td>
</tr>
<tr>
<td>
<a href="-net/index.html">Net</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Net</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span></code><p>Net two or more obligation states together in a close-out netting style. Limited to bilateral netting
as only the beneficiary (not the obligor) needs to sign.</p>
</td>
</tr>
<tr>
<td>
<a href="-set-lifecycle/index.html">SetLifecycle</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">SetLifecycle</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>A command stating that the beneficiary is moving the contract into the defaulted state as it has not been settled
by the due date, or resetting a defaulted contract back to the issued state.</p>
</td>
</tr>
<tr>
<td>
<a href="-settle/index.html">Settle</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Settle</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>A command stating that the obligor is settling some or all of the amount owed by transferring a suitable
state object to the beneficiary. If this reduces the balance to zero, the state object is destroyed.</p>
</td>
</tr>
</tbody>
</table>
<h3>Inheritors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-exit/index.html">Exit</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Exit</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>A command stating that the debt is being released by the beneficiary. Normally would indicate
either settlement outside of the ledger, or that the obligor is unable to pay.</p>
</td>
</tr>
<tr>
<td>
<a href="-issue/index.html">Issue</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Issue</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>Allows new obligation states to be issued into existence: the nonce ("number used once") ensures the
transaction has a unique ID even when there are no inputs.</p>
</td>
</tr>
<tr>
<td>
<a href="-move/index.html">Move</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Move</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><a href="../../../com.r3corda.core.contracts/-move-command/index.html"><span class="identifier">MoveCommand</span></a></code><p>A command stating that a debt has been moved, optionally to fulfil another contract.</p>
</td>
</tr>
<tr>
<td>
<a href="-net/index.html">Net</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Net</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span></code><p>Net two or more obligation states together in a close-out netting style. Limited to bilateral netting
as only the beneficiary (not the obligor) needs to sign.</p>
</td>
</tr>
<tr>
<td>
<a href="-set-lifecycle/index.html">SetLifecycle</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">SetLifecycle</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>A command stating that the beneficiary is moving the contract into the defaulted state as it has not been settled
by the due date, or resetting a defaulted contract back to the issued state.</p>
</td>
</tr>
<tr>
<td>
<a href="-settle/index.html">Settle</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Settle</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">Commands</span><span class="symbol">, </span><a href="../-issuance-commands/index.html"><span class="identifier">IssuanceCommands</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>A command stating that the obligor is settling some or all of the amount owed by transferring a suitable
state object to the beneficiary. If this reduces the balance to zero, the state object is destroyed.</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

21
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-init-.html vendored Normal file
View File

@ -0,0 +1,21 @@
<HTML>
<HEAD>
<title>Obligation.<init> - </title>
<link rel="stylesheet" href="../../style.css">
</HEAD>
<BODY>
<a href="../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="index.html">Obligation</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">Obligation</span><span class="symbol">(</span><span class="symbol">)</span></code><br/>
<p>An obligation contract commits the obligor to delivering a specified amount of a fungible asset (for example the
<a href="../-cash/index.html">Cash</a> contract) at a specified future point in time. Settlement transactions may split and merge contracts across
multiple input and output states. The goal of this design is to handle amounts owed, and these contracts are expected
to be netted/merged, with settlement only for any remainder amount.</p>
<h3>Parameters</h3>
<a name="P"></a>
<code>P</code> - the product the obligation is for payment of.<br/>
<br/>
<br/>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-issuance-commands/aggregate-state.html vendored Normal file
View File

@ -0,0 +1,15 @@
<HTML>
<HEAD>
<title>Obligation.IssuanceCommands.aggregateState - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href="index.html">IssuanceCommands</a>&nbsp;/&nbsp;<a href=".">aggregateState</a><br/>
<br/>
<h1>aggregateState</h1>
<a name="com.r3corda.contracts.asset.Obligation.IssuanceCommands$aggregateState"></a>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
<br/>
<br/>
</BODY>
</HTML>

70
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-issuance-commands/index.html vendored Normal file
View File

@ -0,0 +1,70 @@
<HTML>
<HEAD>
<title>Obligation.IssuanceCommands - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href=".">IssuanceCommands</a><br/>
<br/>
<h1>IssuanceCommands</h1>
<code><span class="keyword">interface </span><span class="identifier">IssuanceCommands</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.contracts/-command-data.html"><span class="identifier">CommandData</span></a></code><br/>
<p>Interface for commands that apply to states grouped by issuance definition</p>
<br/>
<br/>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="aggregate-state.html">aggregateState</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">aggregateState</span><span class="symbol">: </span><a href="../-issuance-definition/index.html"><span class="identifier">IssuanceDefinition</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
<h3>Inheritors</h3>
<table>
<tbody>
<tr>
<td>
<a href="../-commands/-exit/index.html">Exit</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Exit</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-commands/index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><span class="identifier">IssuanceCommands</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>A command stating that the debt is being released by the beneficiary. Normally would indicate
either settlement outside of the ledger, or that the obligor is unable to pay.</p>
</td>
</tr>
<tr>
<td>
<a href="../-commands/-issue/index.html">Issue</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Issue</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-commands/index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><span class="identifier">IssuanceCommands</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>Allows new obligation states to be issued into existence: the nonce ("number used once") ensures the
transaction has a unique ID even when there are no inputs.</p>
</td>
</tr>
<tr>
<td>
<a href="../-commands/-move/index.html">Move</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Move</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-commands/index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><span class="identifier">IssuanceCommands</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">, </span><a href="../../../com.r3corda.core.contracts/-move-command/index.html"><span class="identifier">MoveCommand</span></a></code><p>A command stating that a debt has been moved, optionally to fulfil another contract.</p>
</td>
</tr>
<tr>
<td>
<a href="../-commands/-set-lifecycle/index.html">SetLifecycle</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">SetLifecycle</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-commands/index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><span class="identifier">IssuanceCommands</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>A command stating that the beneficiary is moving the contract into the defaulted state as it has not been settled
by the due date, or resetting a defaulted contract back to the issued state.</p>
</td>
</tr>
<tr>
<td>
<a href="../-commands/-settle/index.html">Settle</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">Settle</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-commands/index.html"><span class="identifier">Commands</span></a><span class="symbol">, </span><span class="identifier">IssuanceCommands</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>A command stating that the obligor is settling some or all of the amount owed by transferring a suitable
state object to the beneficiary. If this reduces the balance to zero, the state object is destroyed.</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

20
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-issuance-definition/-init-.html vendored Normal file
View File

@ -0,0 +1,20 @@
<HTML>
<HEAD>
<title>Obligation.IssuanceDefinition.<init> - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href="index.html">IssuanceDefinition</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">IssuanceDefinition</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.IssuanceDefinition$<init>(com.r3corda.core.crypto.Party, com.r3corda.contracts.asset.Obligation.StateTemplate((com.r3corda.contracts.asset.Obligation.IssuanceDefinition.P)))/obligor">obligor</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.IssuanceDefinition$<init>(com.r3corda.core.crypto.Party, com.r3corda.contracts.asset.Obligation.StateTemplate((com.r3corda.contracts.asset.Obligation.IssuanceDefinition.P)))/template">template</span><span class="symbol">:</span>&nbsp;<a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><br/>
<p>Subset of state, containing the elements specified when issuing a new settlement contract.
TODO: This needs to be something common to contracts that we can be obliged to pay, and moved
out into core accordingly.</p>
<h3>Parameters</h3>
<a name="P"></a>
<code>P</code> - the product the obligation is for payment of.<br/>
<br/>
<br/>
</BODY>
</HTML>

62
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-issuance-definition/index.html vendored Normal file
View File

@ -0,0 +1,62 @@
<HTML>
<HEAD>
<title>Obligation.IssuanceDefinition - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href=".">IssuanceDefinition</a><br/>
<br/>
<h1>IssuanceDefinition</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">IssuanceDefinition</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
<p>Subset of state, containing the elements specified when issuing a new settlement contract.
TODO: This needs to be something common to contracts that we can be obliged to pay, and moved
out into core accordingly.</p>
<h3>Parameters</h3>
<a name="P"></a>
<code>P</code> - the product the obligation is for payment of.<br/>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">IssuanceDefinition</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.IssuanceDefinition$<init>(com.r3corda.core.crypto.Party, com.r3corda.contracts.asset.Obligation.StateTemplate((com.r3corda.contracts.asset.Obligation.IssuanceDefinition.P)))/obligor">obligor</span><span class="symbol">:</span>&nbsp;<a href="../../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a><span class="symbol">, </span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.IssuanceDefinition$<init>(com.r3corda.core.crypto.Party, com.r3corda.contracts.asset.Obligation.StateTemplate((com.r3corda.contracts.asset.Obligation.IssuanceDefinition.P)))/template">template</span><span class="symbol">:</span>&nbsp;<a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><p>Subset of state, containing the elements specified when issuing a new settlement contract.
TODO: This needs to be something common to contracts that we can be obliged to pay, and moved
out into core accordingly.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="obligor.html">obligor</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">obligor</span><span class="symbol">: </span><a href="../../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a></code></td>
</tr>
<tr>
<td>
<a href="template.html">template</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">template</span><span class="symbol">: </span><a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
<h3>Extension Functions</h3>
<table>
<tbody>
<tr>
<td>
<a href="../../../com.r3corda.contracts.testing/at.html">at</a></td>
<td>
<code><span class="keyword">infix</span> <span class="keyword">fun </span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span> <span class="identifier">IssuanceDefinition</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span><span class="symbol">.</span><span class="identifier">at</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.testing$at(com.r3corda.contracts.asset.Obligation.IssuanceDefinition((com.r3corda.contracts.testing.at.T)), java.time.Instant)/dueBefore">dueBefore</span><span class="symbol">:</span>&nbsp;<a href="http://docs.oracle.com/javase/6/docs/api/java/time/Instant.html"><span class="identifier">Instant</span></a><span class="symbol">)</span><span class="symbol">: </span><span class="identifier">IssuanceDefinition</span><span class="symbol">&lt;</span><span class="identifier">T</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-issuance-definition/obligor.html vendored Normal file
View File

@ -0,0 +1,15 @@
<HTML>
<HEAD>
<title>Obligation.IssuanceDefinition.obligor - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href="index.html">IssuanceDefinition</a>&nbsp;/&nbsp;<a href=".">obligor</a><br/>
<br/>
<h1>obligor</h1>
<a name="com.r3corda.contracts.asset.Obligation.IssuanceDefinition$obligor"></a>
<code><span class="keyword">val </span><span class="identifier">obligor</span><span class="symbol">: </span><a href="../../../com.r3corda.core.crypto/-party/index.html"><span class="identifier">Party</span></a></code><br/>
<br/>
<br/>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-issuance-definition/template.html vendored Normal file
View File

@ -0,0 +1,15 @@
<HTML>
<HEAD>
<title>Obligation.IssuanceDefinition.template - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href="index.html">IssuanceDefinition</a>&nbsp;/&nbsp;<a href=".">template</a><br/>
<br/>
<h1>template</h1>
<a name="com.r3corda.contracts.asset.Obligation.IssuanceDefinition$template"></a>
<code><span class="keyword">val </span><span class="identifier">template</span><span class="symbol">: </span><a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
<br/>
<br/>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-lifecycle/-d-e-f-a-u-l-t-e-d.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.Lifecycle.DEFAULTED - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href="index.html">Lifecycle</a>&nbsp;/&nbsp;<a href=".">DEFAULTED</a><br/>
<br/>
<h1>DEFAULTED</h1>
<code><span class="identifier">DEFAULTED</span></code><br/>
<p>Indicates the contract has not been settled by its due date. Once in the defaulted state,
it can only be reverted to <a href="-n-o-r-m-a-l.html">NORMAL</a> state by the beneficiary.</p>
<br/>
<br/>
</BODY>
</HTML>

15
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-lifecycle/-n-o-r-m-a-l.html vendored Normal file
View File

@ -0,0 +1,15 @@
<HTML>
<HEAD>
<title>Obligation.Lifecycle.NORMAL - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href="index.html">Lifecycle</a>&nbsp;/&nbsp;<a href=".">NORMAL</a><br/>
<br/>
<h1>NORMAL</h1>
<code><span class="identifier">NORMAL</span></code><br/>
<p>Default lifecycle state for a contract, in which it can be settled normally</p>
<br/>
<br/>
</BODY>
</HTML>

37
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-lifecycle/index.html vendored Normal file
View File

@ -0,0 +1,37 @@
<HTML>
<HEAD>
<title>Obligation.Lifecycle - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href=".">Lifecycle</a><br/>
<br/>
<h1>Lifecycle</h1>
<code><span class="keyword">enum</span> <span class="keyword">class </span><span class="identifier">Lifecycle</span></code><br/>
<p>Represents where in its lifecycle a contract state is, which in turn controls the commands that can be applied
to the state. Most states will not leave the <a href="-n-o-r-m-a-l.html">NORMAL</a> lifecycle. Note that settled (as an end lifecycle) is
represented by absence of the state on transaction output.</p>
<br/>
<br/>
<h3>Enum Values</h3>
<table>
<tbody>
<tr>
<td>
<a href="-n-o-r-m-a-l.html">NORMAL</a></td>
<td>
<p>Default lifecycle state for a contract, in which it can be settled normally</p>
</td>
</tr>
<tr>
<td>
<a href="-d-e-f-a-u-l-t-e-d.html">DEFAULTED</a></td>
<td>
<p>Indicates the contract has not been settled by its due date. Once in the defaulted state,
it can only be reverted to <a href="-n-o-r-m-a-l.html">NORMAL</a> state by the beneficiary.</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

20
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-multilateral-net-state/-init-.html vendored Normal file
View File

@ -0,0 +1,20 @@
<HTML>
<HEAD>
<title>Obligation.MultilateralNetState.<init> - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href="index.html">MultilateralNetState</a>&nbsp;/&nbsp;<a href=".">&lt;init&gt;</a><br/>
<br/>
<h1>&lt;init&gt;</h1>
<code><span class="identifier">MultilateralNetState</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.MultilateralNetState$<init>(com.r3corda.contracts.asset.Obligation.StateTemplate((com.r3corda.contracts.asset.Obligation.MultilateralNetState.P)))/template">template</span><span class="symbol">:</span>&nbsp;<a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><br/>
<p>Subset of state, containing the elements which must match for two or more obligation transactions to be candidates
for netting (this does not include the checks to enforce that everyones amounts received are the same at the end,
which is handled under the verify() function).
In comparison to <a href="../-bilateral-net-state/index.html">BilateralNetState</a>, this doesnt include the parties keys, as ensuring balances match on
input and output is handled elsewhere.
Used in cases where all parties (or their proxies) are signing, such as central clearing.</p>
<br/>
<br/>
</BODY>
</HTML>

48
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-multilateral-net-state/index.html vendored Normal file
View File

@ -0,0 +1,48 @@
<HTML>
<HEAD>
<title>Obligation.MultilateralNetState - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href=".">MultilateralNetState</a><br/>
<br/>
<h1>MultilateralNetState</h1>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">MultilateralNetState</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<a href="../-net-state/index.html"><span class="identifier">NetState</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
<p>Subset of state, containing the elements which must match for two or more obligation transactions to be candidates
for netting (this does not include the checks to enforce that everyones amounts received are the same at the end,
which is handled under the verify() function).
In comparison to <a href="../-bilateral-net-state/index.html">BilateralNetState</a>, this doesnt include the parties keys, as ensuring balances match on
input and output is handled elsewhere.
Used in cases where all parties (or their proxies) are signing, such as central clearing.</p>
<br/>
<br/>
<h3>Constructors</h3>
<table>
<tbody>
<tr>
<td>
<a href="-init-.html">&lt;init&gt;</a></td>
<td>
<code><span class="identifier">MultilateralNetState</span><span class="symbol">(</span><span class="identifier" id="com.r3corda.contracts.asset.Obligation.MultilateralNetState$<init>(com.r3corda.contracts.asset.Obligation.StateTemplate((com.r3corda.contracts.asset.Obligation.MultilateralNetState.P)))/template">template</span><span class="symbol">:</span>&nbsp;<a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span><span class="symbol">)</span></code><p>Subset of state, containing the elements which must match for two or more obligation transactions to be candidates
for netting (this does not include the checks to enforce that everyones amounts received are the same at the end,
which is handled under the verify() function).
In comparison to <a href="../-bilateral-net-state/index.html">BilateralNetState</a>, this doesnt include the parties keys, as ensuring balances match on
input and output is handled elsewhere.
Used in cases where all parties (or their proxies) are signing, such as central clearing.</p>
</td>
</tr>
</tbody>
</table>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="template.html">template</a></td>
<td>
<code><span class="keyword">val </span><span class="identifier">template</span><span class="symbol">: </span><a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

16
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-multilateral-net-state/template.html vendored Normal file
View File

@ -0,0 +1,16 @@
<HTML>
<HEAD>
<title>Obligation.MultilateralNetState.template - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href="index.html">MultilateralNetState</a>&nbsp;/&nbsp;<a href=".">template</a><br/>
<br/>
<h1>template</h1>
<a name="com.r3corda.contracts.asset.Obligation.MultilateralNetState$template"></a>
<code><span class="keyword">val </span><span class="identifier">template</span><span class="symbol">: </span><a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
Overrides <a href="../-net-state/template.html">NetState.template</a><br/>
<br/>
<br/>
</BODY>
</HTML>

53
docs/build/html/api/com.r3corda.contracts.asset/-obligation/-net-state/index.html vendored Normal file
View File

@ -0,0 +1,53 @@
<HTML>
<HEAD>
<title>Obligation.NetState - </title>
<link rel="stylesheet" href="../../../style.css">
</HEAD>
<BODY>
<a href="../../index.html">com.r3corda.contracts.asset</a>&nbsp;/&nbsp;<a href="../index.html">Obligation</a>&nbsp;/&nbsp;<a href=".">NetState</a><br/>
<br/>
<h1>NetState</h1>
<code><span class="keyword">interface </span><span class="identifier">NetState</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><br/>
<p>Common interface for the state subsets used when determining nettability of two or more states. Exposes the
underlying issued thing.</p>
<br/>
<br/>
<h3>Properties</h3>
<table>
<tbody>
<tr>
<td>
<a href="template.html">template</a></td>
<td>
<code><span class="keyword">abstract</span> <span class="keyword">val </span><span class="identifier">template</span><span class="symbol">: </span><a href="../-state-template/index.html"><span class="identifier">StateTemplate</span></a><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code></td>
</tr>
</tbody>
</table>
<h3>Inheritors</h3>
<table>
<tbody>
<tr>
<td>
<a href="../-bilateral-net-state/index.html">BilateralNetState</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">BilateralNetState</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">NetState</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>Subset of state, containing the elements which must match for two obligation transactions to be nettable.
If two obligation state objects produce equal bilateral net states, they are considered safe to net directly.
Bilateral states are used in close-out netting.</p>
</td>
</tr>
<tr>
<td>
<a href="../-multilateral-net-state/index.html">MultilateralNetState</a></td>
<td>
<code><span class="keyword">data</span> <span class="keyword">class </span><span class="identifier">MultilateralNetState</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span>&nbsp;<span class="symbol">:</span>&nbsp;<span class="identifier">NetState</span><span class="symbol">&lt;</span><span class="identifier">P</span><span class="symbol">&gt;</span></code><p>Subset of state, containing the elements which must match for two or more obligation transactions to be candidates
for netting (this does not include the checks to enforce that everyones amounts received are the same at the end,
which is handled under the verify() function).
In comparison to <a href="../-bilateral-net-state/index.html">BilateralNetState</a>, this doesnt include the parties keys, as ensuring balances match on
input and output is handled elsewhere.
Used in cases where all parties (or their proxies) are signing, such as central clearing.</p>
</td>
</tr>
</tbody>
</table>
</BODY>
</HTML>

Some files were not shown because too many files have changed in this diff Show More