net.corda.contracts.asset

Class Cash.State

net.corda.contracts.asset.Cash.State

All Implemented Interfaces:

ContractState, FungibleAsset<T>, OwnableState, QueryableState

Enclosing class:

Cash

public static class Cash.State
implements FungibleAsset<T>, QueryableState

A state representing a cash claim against some party.

Constructor Summary

Constructors

Constructor and Description
State(Amount<net.corda.core.contracts.Issued> amount, AbstractParty owner) A state representing a cash claim against some party.
State(PartyAndReference deposit, Amount<java.util.Currency> amount, AbstractParty owner)

Method Summary

Modifier and Type	Method and Description
Amount<net.corda.core.contracts.Issued>	component1()
AbstractParty	component2() There must be a MoveCommand signed by this key to claim the amount.
Cash.State	copy(Amount<net.corda.core.contracts.Issued> amount, AbstractParty owner) A state representing a cash claim against some party.
boolean	equals(java.lang.Object p)
PersistentState	generateMappedObject(MappedSchema schema) Object Relational Mapping support.
Amount<net.corda.core.contracts.Issued>	getAmount()
Cash	getContract() An instance of the contract class that will verify this state.
java.util.Set<java.security.PublicKey>	getExitKeys() 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.
AbstractParty	getOwner() There must be a MoveCommand signed by this key to claim the amount.
java.util.List<net.corda.core.identity.AbstractParty>	getParticipants() A participant is any party that is able to consume this state in a valid transaction.
int	hashCode()
FungibleAsset<java.util.Currency>	move(Amount<net.corda.core.contracts.Issued> newAmount, AbstractParty newOwner)
java.lang.Iterable<net.corda.core.schemas.MappedSchema>	supportedSchemas() Object Relational Mapping support.
java.lang.String	toString()
kotlin.Pair<net.corda.contracts.asset.Cash.Commands.Move,net.corda.contracts.asset.Cash.State>	withNewOwner(AbstractParty newOwner) Copies the underlying data structure, replacing the owner field with this new value and leaving the rest alone

Methods inherited from interface net.corda.core.contracts.FungibleAsset

getAmount, getExitKeys, getOwner, move

Methods inherited from interface net.corda.core.contracts.OwnableState

getOwner, withNewOwner

Methods inherited from interface net.corda.core.contracts.ContractState

getContract, getParticipants

Methods inherited from interface net.corda.core.schemas.QueryableState

generateMappedObject, supportedSchemas

Constructor Detail

State

public State(Amount<net.corda.core.contracts.Issued> amount,
             AbstractParty owner)

A state representing a cash claim against some party.

Parameters:

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

State

public State(PartyAndReference deposit,
             Amount<java.util.Currency> amount,
             AbstractParty owner)

Method Detail

getExitKeys

public java.util.Set<java.security.PublicKey> getExitKeys()

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.

getContract

public Cash getContract()

An instance of the contract class that will verify this state.

Discussion

This field is not the final design, it's just a piece of temporary scaffolding. Once the contract sandbox is further along, this field will become a description of which attachments are acceptable for defining the contract.

Recall that an attachment is a zip file that can be referenced from any transaction. The contents of the attachments are merged together and cannot define any overlapping files, thus for any given transaction there is a miniature file system in which each file can be precisely mapped to the defining attachment.

Attachments may contain many things (data files, legal documents, etc) but mostly they contain JVM bytecode. The class files inside define not only interface Contract implementations but also the classes that define the states. Within the rest of a transaction, user-providable components are referenced by name only.

This means that a smart contract in Corda does two things:

1. Define the data structures that compose the ledger (the states)

2. Define the rules for updating those structures

The first is merely a utility role ... in theory contract code could manually parse byte streams by hand. The second is vital to the integrity of the ledger. So this field needs to be able to express constraints like:

• Only attachment 733c350f396a727655be1363c06635ba355036bd54a5ed6e594fd0b5d05f42f6 may be used with this state.

• Any attachment signed by public key 2d1ce0e330c52b8055258d776c40 may be used with this state.

• Attachments (1, 2, 3) may all be used with this state.

and so on. In this way it becomes possible for the business logic governing a state to be evolved, if the constraints are flexible enough.

Because contract classes often also define utilities that generate relevant transactions, and because attachments cannot know their own hashes, we will have to provide various utilities to assist with obtaining the right code constraints from within the contract code itself.

TODO: Implement the above description. See COR-226

See Also:

interface Contract

getParticipants

public java.util.List<net.corda.core.identity.AbstractParty> getParticipants()

A participant is any party that is able to consume this state in a valid transaction.

The list of participants is required for certain types of transactions. For example, when changing the notary for this state (class TransactionType.NotaryChange), every participant has to be involved and approve the transaction so that they receive the updated state, and don't end up in a situation where they can no longer use a state they possess, since someone consumed that state during the notary change process.

The participants list should normally be derived from the contents of the state.

See Also:

class TransactionType.NotaryChange

move

public FungibleAsset<java.util.Currency> move(Amount<net.corda.core.contracts.Issued> newAmount,
                                              AbstractParty newOwner)

toString

public java.lang.String toString()

withNewOwner

public kotlin.Pair<net.corda.contracts.asset.Cash.Commands.Move,net.corda.contracts.asset.Cash.State> withNewOwner(AbstractParty newOwner)

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

generateMappedObject

public PersistentState generateMappedObject(MappedSchema schema)

Object Relational Mapping support.

supportedSchemas

public java.lang.Iterable<net.corda.core.schemas.MappedSchema> supportedSchemas()

Object Relational Mapping support.

getAmount

public Amount<net.corda.core.contracts.Issued> getAmount()

getOwner

public AbstractParty getOwner()

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

component1

public Amount<net.corda.core.contracts.Issued> component1()

component2

public AbstractParty component2()

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

copy

public Cash.State copy(Amount<net.corda.core.contracts.Issued> amount,
                       AbstractParty owner)

A state representing a cash claim against some party.

hashCode

public int hashCode()

equals

public boolean equals(java.lang.Object p)