net.corda.contracts.asset / CommodityContract

# CommodityContract

`class CommodityContract : OnLedgerAsset<Commodity, Commands, State>`

A commodity contract represents an amount of some commodity, tracked on a distributed ledger. The design of this contract is intentionally similar to the Cash contract, and the same commands (issue, move, exit) apply, the differences are in representation of the underlying commodity. Issuer in this context means the party who has the commodity, or is otherwise responsible for delivering the commodity on demand, and the deposit reference is use for internal accounting by the issuer (it might be, for example, a warehouse and/or location within a warehouse).

This is an early stage example contract used to illustrate non-cash fungible assets, and is likely to change significantly in future.

### Types

Clauses | `interface Clauses` The clauses for this contract are essentially:
Commands | `interface Commands : Commands`
State | `data class State : FungibleAsset<Commodity>` A state representing a commodity claim against some party

### Constructors

<init> | `CommodityContract()` A commodity contract represents an amount of some commodity, tracked on a distributed ledger. The design of this contract is intentionally similar to the Cash contract, and the same commands (issue, move, exit) apply, the differences are in representation of the underlying commodity. Issuer in this context means the party who has the commodity, or is otherwise responsible for delivering the commodity on demand, and the deposit reference is use for internal accounting by the issuer (it might be, for example, a warehouse and/or location within a warehouse).

### Properties

conserveClause | `val conserveClause: AbstractConserveAmount<State, Commands, Commodity>`
legalContractReference | `val legalContractReference: SecureHash` TODO:

### Functions

deriveState | `fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Commodity>>, owner: PublicKeyTree): TransactionState<State>` Derive a new transaction state based on the given example, with amount and owner modified. This allows concrete implementations to have fields in their state which we dont know about here, and we simply leave them untouched when sending out "change" from spending/exiting.
extractCommands | `fun extractCommands(commands: Collection<AuthenticatedObject<CommandData>>): List<AuthenticatedObject<Commands>>`
generateExitCommand | `fun generateExitCommand(amount: Amount<Issued<Commodity>>): Exit`
generateIssue | `fun generateIssue(tx: TransactionBuilder, tokenDef: Issued<Commodity>, pennies: Long, owner: PublicKeyTree, notary: Party): Unit` Puts together an issuance transaction from the given template, that starts out being owned by the given pubkey. `fun generateIssue(tx: TransactionBuilder, amount: Amount<Issued<Commodity>>, owner: PublicKeyTree, notary: Party): Unit` Puts together an issuance transaction for the specified amount that starts out being owned by the given pubkey.
generateIssueCommand | `fun generateIssueCommand(): Issue`
generateMoveCommand | `fun generateMoveCommand(): Move`
verify | `fun verify(tx: TransactionForContract): Unit` Takes an object that represents a state transition, and ensures the inputs/outputs/commands make sense. Must throw an exception if theres a problem that should prevent state transition. Takes a single object rather than an argument so that additional data can be added without breaking binary compatibility with existing contract code.