interface Contract, or see the examples in
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:
Constrain which contract-code-containing attachment can be used with a
Marker interface for classes that represent commands
Implemented by a program that implements business logic on the shared ledger. All participants run this code for every
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.
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.
A state that evolves by superseding itself, all of which share the common "linearId".
A common move command for contract states which can change owner.
Implemented by anything that can be named by a secure hash value (e.g. transactions, attachments).
A contract state that can have a single owner.
Something which is scheduled to happen at a point in time.
|UpgradedContract<OldState extends ContractState,NewState extends ContractState>||
Interface which can upgrade state objects issued by a contract to a new state object issued by a different contract. The upgraded contract should specify the legacy contract class name, and provide an upgrade function that will convert legacy contract states into states defined by this contract.
|UpgradedContractWithLegacyConstraint<OldState extends ContractState,NewState extends ContractState>|
Amount represents a positive quantity of some token (currency, asset, etc.), measured in quantity of the smallest representable units. The nominal quantity represented by each individual token is equal to the displayTokenSize. The scale property of the displayTokenSize should correctly reflect the displayed decimal places and is used when rounding conversions from indicative/displayed amounts in BigDecimal to Amount occur via the
This class represents a possibly negative transfer of tokens from one vault state to another, possibly at a future date.
|Command<T extends CommandData>||
Command data/content plus pubkey pair: the signature is stored at the end of the serialized bytes
Return structure for
|CommandWithParties<T extends CommandData>||
Wrap an attachment in this if it is to be used as an executable contract attachment
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.
A privacy salt is required to compute nonces per transaction component in order to ensure that an adversary cannot use brute force techniques and reveal the content of a Merkle-leaf hashed value. Because this salt serves the role of the seed to compute nonces, its size and entropy should be equal to the underlying hash function used for Merkle tree generation, currently
Defines a simple domain specific language for the specification of financial contracts. Currently covers:
This class represents the lifecycle activity that a contract state of type
Represents a contract state (unconsumed output) of type
Simple data class to associate the origin, owner, or holder of a particular Amount object.
A convenience class for passing around a state and it's contract
|StateAndRef<T extends ContractState>||
A StateAndRef is simply a (state, ref) pair. For instance, a vault (which holds available assets) contains these.
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.
An interval on the time-line; not a single instantaneous point.
|TransactionState<T extends ContractState>||
A wrapper for
Commands that inherit from this are intended to have no data items: it's only their presence that matters.
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.
An enum, for which each property corresponds to a transaction component group. The position in the enum class declaration (ordinal) is used for component-leaf ordering when computing the Merkle tree.
The node asked a remote peer for the attachment identified by hash because it is a dependency of a transaction being resolved, but the remote peer would not provide it.
The node asked a remote peer for the transaction identified by hash because it is a dependency of a transaction being resolved, but the remote peer would not provide it.
Indicates that some aspect of the transaction named by txId violates the platform rules. The exact type of failure is expressed using a subclass. TransactionVerificationException is a
This package contains the base data types for smarts contracts implemented in Corda. To implement a new contract start
interface Contract, or see the examples in
Corda smart contracts are a combination of state held on the distributed ledger, and verification logic which defines which transformations of state are valid.