docs/net.corda.core.contracts/FungibleState

FungibleState

interface FungibleState<T : Any> : ContractState

Interface to represent things which are fungible, this means that there is an expectation that these things can be split and merged. That's the only assumption made by this interface.

This interface has been defined in addition to FungibleAsset to provide some additional flexibility which FungibleAsset lacks, in particular:

FungibleAsset defines an amount property of type Amount>, therefore there is an assumption that all fungible things are issued by a single well known party but this is not always the case. For example, crypto-currencies like Bitcoin are generated periodically by a pool of pseudo-anonymous miners and Corda can support such crypto-currencies.
FungibleAsset implements OwnableState, as such there is an assumption that all fungible things are ownable. This is not always true as fungible derivative contracts exist, for example.

The expectation is that this interface should be combined with the other core state interfaces such as OwnableState and others created at the application layer.

Parameters

a type that represents the fungible thing 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.). An upper-bound is not specified for T to ensure flexibility. Typically, a class would be provided that implements TokenizableAssetInfo.

Inheritors

FungibleAsset

Properties

amount

abstract val amount: Amount<T>

Amount represents a positive quantity of some token which can be cash, tokens, stock, agreements, or generally anything else that's quantifiable with integer quantities. See Amount for more details.

participants

abstract val participants: List<AbstractParty>

A participant is any party that should be notified when the state is created or consumed.

requiredContractClassName

val ContractState.requiredContractClassName: String?

Obtain the typename of the required ContractClass associated with the target ContractState, using the BelongsToContract annotation by default, but falling through to checking the state's enclosing class if there is one and it inherits from Contract.

Functions

hash

fun ContractState.hash(): SecureHash

Returns the SHA-256 hash of the serialised contents of this state (not cached!)

fun ContractState.hash(algorithm: String): SecureHash

Returns the hash of the serialised contents of this state (not cached!)