com.r3corda.contracts.asset / Obligation / State

# State

`data class State<P> : FungibleAssetState<P, IssuanceDefinition<P>>, BilateralNettableState<State<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.

### Parameters

`P` - the product the obligation is for payment of.

### Constructors

<init> | `State(lifecycle: Lifecycle = Lifecycle.NORMAL, obligor: Party, template: StateTemplate<P>, quantity: Long, beneficiary: PublicKey)` 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.

### Properties

acceptableContracts | `val acceptableContracts: NonEmptySet<SecureHash>`
acceptableIssuanceDefinitions | `val acceptableIssuanceDefinitions: NonEmptySet<*>`
aggregateState | `val aggregateState: IssuanceDefinition<P>`
amount | `val amount: Amount<P>`
beneficiary | `val beneficiary: PublicKey` The public key of the entity the contract pays to
bilateralNetState | `val bilateralNetState: BilateralNetState<P>` 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.
contract | `val contract: Obligation<Currency>` An instance of the contract class that will verify this state.
dueBefore | `val dueBefore: Instant`
issuanceDef | `val issuanceDef: IssuanceDefinition<P>`
lifecycle | `var lifecycle: Lifecycle`
multilateralNetState | `val multilateralNetState: MultilateralNetState<P>`
obligor | `val obligor: Party` Where the debt originates from (obligor)
owner | `val owner: PublicKey` There must be a MoveCommand signed by this key to claim the amount
participants | `val participants: List<PublicKey>` A participant is any party that is able to consume this state in a valid transaction.
productAmount | `val productAmount: Amount<P>`
quantity | `val quantity: Long`
template | `val template: StateTemplate<P>`

### Functions

move | `fun move(newAmount: Amount<P>, newOwner: PublicKey): State<P>`
net | `fun net(other: State<P>): State<P>` Perform bilateral netting of this state with another state. The two states must be compatible (as in bilateralNetState objects are equal).
toString | `fun toString(): String`
withNewOwner | `fun withNewOwner(newOwner: PublicKey): <ERROR CLASS>` Copies the underlying data structure, replacing the owner field with this new value and leaving the rest alone

### Extension Functions

at | `infix fun <T> State<T>.at(dueBefore: Instant): State<T>`
between | `infix fun <T> State<T>.between(parties: <ERROR CLASS><Party, PublicKey>): State<T>`
issued by | `infix fun <T> State<T>.issued by(party: Party): State<T>`
owned by | `infix fun <T> State<T>.owned by(owner: PublicKey): <ERROR CLASS>`