Interface | Description |
---|---|
Attachment |
An attachment is a ZIP (or an optionally signed JAR) that contains one or more files. Attachments are meant to
contain public static data which can be referenced from transactions and utilised from contracts. Good examples
of how attachments are meant to be used include:
|
BilateralNettableState<N extends BilateralNettableState<N>> |
Interface for state objects that support being netted with other state objects.
|
CommandData |
Marker interface for classes that represent commands
|
Contract |
Implemented by a program that implements business logic on the shared ledger. All participants run this code for
every LedgerTransaction they see on the network, for every input and output state. All contracts must accept the
transaction for it to be accepted: failure of any aborts the entire thing. The time is taken from a trusted
timestamp attached to the transaction itself i.e. it is NOT necessarily the current time.
|
ContractState |
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. 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.
|
DealState |
Interface representing an agreement that exposes various attributes that are common. Implementing it simplifies
implementation of general flows that manipulate many agreement types.
|
FixableDealState |
Interface adding fixing specific methods.
|
FungibleAsset<T> |
Interface for contract states 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.
|
IssuanceDefinition |
Marker interface for data classes that represent the issuance state for a contract. These are intended as templates
from which the state object is initialised.
|
IssueCommand |
A common issue command, to enforce that issue commands have a nonce value.
|
LinearState |
A state that evolves by superseding itself, all of which share the common "linearId".
|
MoveCommand |
A common move command for contracts which can change owner.
|
MultilateralNettableState<T> |
Interface for state objects that support being netted with other state objects.
|
NamedByHash |
Implemented by anything that can be named by a secure hash value (e.g. transactions, attachments).
|
NetCommand |
A common netting command for contracts whose states can be netted.
|
NettableState<N extends BilateralNettableState<N>,T> | |
OwnableState |
A contract state that can have a single owner.
|
SchedulableState | |
Scheduled |
Something which is scheduled to happen at a point in time
|
Class | Description |
---|---|
Amount<T> |
Amount represents a positive quantity of some token (currency, asset, etc.), measured in quantity of the smallest
representable units. Note that quantity is not necessarily 1/100ths of a currency unit, but are the actual smallest
amount used in whatever underlying thing the amount represents.
|
AuthenticatedObject<T> |
Wraps an object that was signed by a public key, which may be a well known/recognised institutional key.
|
BusinessCalendar |
A business calendar performs date calculations that take into account national holidays and weekends. This is a
typical feature of financial contracts, in which a business may not want a payment event to fall on a day when
no staff are around to handle problems.
|
Command |
Command data/content plus pubkey pair: the signature is stored at the end of the serialized bytes
|
Commodity |
Class representing a commodity, as an equivalent to the Currency class. This exists purely to enable the
CommodityContract contract, and is likely to change in future.
|
ContractsDSL | |
DummyContract | |
DummyContractKt | |
DummyState |
Dummy state for use in testing. Not part of any contract, not even the
class DummyContract . |
Expression |
Represents a textual expression of e.g. a formula
|
ExpressionDeserializer | |
ExpressionSerializer | |
FinanceTypesKt | |
Fix |
A
class Fix represents a named interest rate, on a given day, for a given duration. It can be embedded in a tx. |
FixOf |
A
class FixOf identifies the question side of a fix: what day, tenor and type of fix ("LIBOR", "EURIBOR" etc) |
FungibleAssetKt | |
Issued<P> |
Definition for an issued product, which can be cash, a cash-like thing, assets, or generally anything else that's
quantifiable with integer quantities.
|
PartyAndReference |
Reference to something being stored or issued by a party e.g. in a vault or (more likely) on their normal
ledger. The reference is intended to be encrypted so it's meaningless to anyone other than the party.
|
Requirements | |
ScheduledActivity |
This class represents the lifecycle activity that a contract state of type
interface LinearState would like to perform at a given point in time.
e.g. run a fixing flow. |
ScheduledStateRef |
Represents a contract state (unconsumed output) of type
interface LinearState and a point in time that a lifecycle event is expected to take place
for that contract state. |
StateAndRef<T extends ContractState> |
A StateAndRef is simply a (state, ref) pair. For instance, a vault (which holds available assets) contains these.
|
StateRef |
A stateref is a pointer (reference) to a state, this is an equivalent of an "outpoint" in Bitcoin. It records which
transaction defined the state and where in that transaction it was.
|
StructuresKt | |
Tenor |
Placeholder class for the Tenor datatype - which is a standardised duration of time until maturity
|
Timestamp |
If present in a transaction, contains a time that was verified by the uniqueness service. The true time must be
between (after, before).
|
TransactionForContract |
A transaction to be passed as input to a contract verification function. Defines helper methods to
simplify verification logic in contracts.
|
TransactionGraphSearch |
Given a map of transaction id to
class SignedTransaction , performs a breadth first search of the dependency graph from
the starting point down in order to find transactions that match the given query criteria. |
TransactionState<T extends ContractState> |
A wrapper for
interface ContractState containing additional platform-level state information.
This is the definitive state that is stored on the ledger and used in transaction outputs. |
TransactionType |
Defines transaction build & validation logic for a specific transaction type
|
TypeOnlyCommandData |
Commands that inherit from this are intended to have no data items: it's only their presence that matters.
|
UniqueIdentifier |
This class provides a truly unique identifier of a trade, state, or other business object, bound to any existing
external ID. Equality and comparison are based on the unique ID only; if two states somehow have the same UUID but
different external IDs, it would indicate a problem with handling of IDs.
|
Enum | Description |
---|---|
AccrualAdjustment |
Simple enum for returning accurals adjusted or unadjusted.
We don't actually do anything with this yet though, so it's ignored for now.
|
DateRollConvention |
This reflects what happens if a date on which a business event is supposed to happen actually falls upon a non-working day.
Depending on the accounting requirement, we can move forward until we get to a business day, or backwards.
There are some additional rules which are explained in the individual cases below.
|
DateRollDirection |
This is utilised in the
enum DateRollConvention class to determine which way we should initially step when
finding a business day. |
DayCountBasisDay |
This forms the day part of the "Day Count Basis" used for interest calculation.
Note that the first character cannot be a number (enum naming constraints), so we drop that
in the toString lest some people get confused.
|
DayCountBasisYear |
This forms the year part of the "Day Count Basis" used for interest calculation.
|
Frequency |
Frequency at which an event occurs - the enumerator also casts to an integer specifying the number of times per year
that would divide into (eg annually = 1, semiannual = 2, monthly = 12 etc).
|
NetType |
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.
|
PaymentRule |
Whether the payment should be made before the due date, or after it.
|
Exception | Description |
---|---|
InsufficientBalanceException | |
TransactionConflictException | |
TransactionResolutionException | |
TransactionVerificationException |