docs/net.corda.finance.contracts.asset/Obligation/State

State

data class State(var lifecycle: Obligation.Lifecycle = Lifecycle.NORMAL, val obligor: AbstractParty, val template: Obligation.Terms, val quantity: Long, val beneficiary: AbstractParty) : FungibleAsset<Obligation.Terms> , NettableState<Obligation.State, MultilateralNetState>

A state representing the obligation of one party (obligor) to deliver a specified number of units of an underlying asset (described as token.acceptableIssuedProducts) to the beneficiary no later than the specified time.

Parameters

the product the obligation is for payment of.

Constructors

State

constructor(lifecycle: Obligation.Lifecycle = Lifecycle.NORMAL, obligor: AbstractParty, template: Obligation.Terms, quantity: Long, beneficiary: AbstractParty)

Properties

amount

open override val amount: Amount<Issued<Obligation.Terms>>

Amount represents a positive quantity of some issued product which can be cash, tokens, assets, or generally anything else that's quantifiable with integer quantities. See Issued and Amount for more details.

beneficiary

val beneficiary: AbstractParty

The public key of the entity the contract pays to

bilateralNetState

open override val bilateralNetState: BilateralNetState

Returns an object used to determine if two states can be subject to close-out netting. If two states return equal objects, they can be close out netted together.

dueBefore

val dueBefore: Instant

exitKeys

open override val exitKeys: Collection<PublicKey>

There must be an ExitCommand signed by these keys to destroy the amount. While all states require their owner to sign, some (i.e. cash) also require the issuer.

lifecycle

var lifecycle: Obligation.Lifecycle

multilateralNetState

open override val multilateralNetState: MultilateralNetState

Returns an object used to determine if two states can be subject to close-out netting. If two states return equal objects, they can be close out netted together.

obligor

val obligor: AbstractParty

Where the debt originates from (obligor)

owner

open override val owner: AbstractParty

There must be a MoveCommand signed by this key to claim the amount.

participants

open override val participants: List<AbstractParty>

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

quantity

val quantity: Long

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.

template

val template: Obligation.Terms

Functions

infix fun <T : Any> Obligation.State<T>.at(dueBefore: Instant): Obligation.State<T>

between

infix fun <T : Any> Obligation.State<T>.between(parties: <Error class: unknown class><AbstractParty, AbstractParty>): Obligation.State<T>

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!)

issued by

infix fun <T : Any> Obligation.State<T>.issued by(party: AbstractParty): Obligation.State<T>

issuedBy

fun <T : Any> Obligation.State<T>.issuedBy(party: AnonymousParty): Obligation.State<T>

net

open override fun net(other: Obligation.State): Obligation.State

Perform bilateral netting of this state with another state. The two states must be compatible (as in bilateralNetState objects are equal).

owned by

infix fun <T : Any> Obligation.State<T>.owned by(owner: AbstractParty): Obligation.State<T>

ownedBy

fun <T : Any> Obligation.State<T>.ownedBy(owner: AbstractParty): Obligation.State<T>

toString

open override fun toString(): String

withNewOwner

open override fun withNewOwner(newOwner: AbstractParty): CommandAndState

Copies the underlying data structure, replacing the owner field with this new value and leaving the rest alone.

withNewOwnerAndAmount

open override fun withNewOwnerAndAmount(newAmount: Amount<Issued<Obligation.Terms>>, newOwner: AbstractParty): Obligation.State

Copies the underlying data structure, replacing the amount and owner fields with the new values and leaving the rest (exitKeys) alone.