ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2024-12-19 04:57:58 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

FungibleAsset reverted back to original filename.

Browse Source
This commit is contained in:
Jose Coll 2016-10-27 16:21:05 +01:00
parent f94c9f8239
commit bc525aabdf
2 changed files with 66 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
core/src/main/kotlin/com/r3corda/core/contracts/FungibleAsset.kt Normal file
View File

@ -0,0 +1,66 @@
package com.r3corda.core.contracts
import java.security.PublicKey
class InsufficientBalanceException(val amountMissing: Amount<*>) : Exception() {
override fun toString() = "Insufficient balance, missing $amountMissing"
}
/**
* Interface for contract states representing assets which are fungible, countable and issued by a
* specific party. States contain assets which are equivalent (such as cash of the same currency),
* so records of their existence can be merged or split as needed where the issuer is the same. For
* instance, dollars issued by the Fed are fungible and countable (in cents), barrels of West Texas
* crude are fungible and countable (oil from two small containers can be poured into one large
* container), shares of the same class in a specific company are fungible and countable, and so on.
*
* See [Cash] for an example contract that implements currency using state objects that implement
* this interface.
*
* @param T a type that represents the asset in question. This should describe the basic type of the asset
* (GBP, USD, oil, shares in company <X>, etc.) and any additional metadata (issuer, grade, class, etc.).
*/
interface FungibleAsset<T> : OwnableState {
/**
* Where the underlying asset backing this ledger entry can be found. The reference
* is only intended for use by the issuer, and is not intended to be meaningful to others.
*/
val deposit: PartyAndReference
val issuanceDef: Issued<T>
val amount: Amount<Issued<T>>
/**
* 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.
*/
val exitKeys: Collection<PublicKey>
/** There must be a MoveCommand signed by this key to claim the amount */
override val owner: PublicKey
fun move(newAmount: Amount<Issued<T>>, newOwner: PublicKey): FungibleAsset<T>
// Just for grouping
interface Commands : CommandData {
interface Move : MoveCommand, Commands
/**
* Allows new asset states to be issued into existence: the nonce ("number used once") ensures the transaction
* has a unique ID even when there are no inputs.
*/
interface Issue : IssueCommand, Commands
/**
* A command stating that money has been withdrawn from the shared ledger and is now accounted for
* in some other way.
*/
interface Exit<T> : Commands { val amount: Amount<Issued<T>> }
}
}
// Small DSL extensions.
/** Sums the asset states in the list, returning null if there are none. */
fun <T> Iterable<ContractState>.sumFungibleOrNull() = filterIsInstance<FungibleAsset<T>>().map { it.amount }.sumOrNull()
/** Sums the asset states in the list, returning zero of the given token if there are none. */
fun <T> Iterable<ContractState>.sumFungibleOrZero(token: Issued<T>) = filterIsInstance<FungibleAsset<T>>().map { it.amount }.sumOrZero(token)

62
core/src/main/kotlin/com/r3corda/core/contracts/Structures.kt
View File

@ -468,66 +468,4 @@ interface Attachment : NamedByHash {
}
}
class InsufficientBalanceException(val amountMissing: Amount<*>) : Exception() {
override fun toString() = "Insufficient balance, missing $amountMissing"
}
/**
* Interface for contract states representing assets which are fungible, countable and issued by a
* specific party. States contain assets which are equivalent (such as cash of the same currency),
* so records of their existence can be merged or split as needed where the issuer is the same. For
* instance, dollars issued by the Fed are fungible and countable (in cents), barrels of West Texas
* crude are fungible and countable (oil from two small containers can be poured into one large
* container), shares of the same class in a specific company are fungible and countable, and so on.
*
* See [Cash] for an example contract that implements currency using state objects that implement
* this interface.
*
* @param T a type that represents the asset in question. This should describe the basic type of the asset
* (GBP, USD, oil, shares in company <X>, etc.) and any additional metadata (issuer, grade, class, etc.).
*/
interface FungibleAsset<T> : OwnableState {
/**
* Where the underlying asset backing this ledger entry can be found. The reference
* is only intended for use by the issuer, and is not intended to be meaningful to others.
*/
val deposit: PartyAndReference
val issuanceDef: Issued<T>
val amount: Amount<Issued<T>>
/**
* 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.
*/
val exitKeys: Collection<PublicKey>
/** There must be a MoveCommand signed by this key to claim the amount */
override val owner: PublicKey
fun move(newAmount: Amount<Issued<T>>, newOwner: PublicKey): FungibleAsset<T>
// Just for grouping
interface Commands : CommandData {
interface Move : MoveCommand, Commands
/**
* Allows new asset states to be issued into existence: the nonce ("number used once") ensures the transaction
* has a unique ID even when there are no inputs.
*/
interface Issue : IssueCommand, Commands
/**
* A command stating that money has been withdrawn from the shared ledger and is now accounted for
* in some other way.
*/
interface Exit<T> : Commands { val amount: Amount<Issued<T>> }
}
}
// Small DSL extensions.
/** Sums the asset states in the list, returning null if there are none. */
fun <T> Iterable<ContractState>.sumFungibleOrNull() = filterIsInstance<FungibleAsset<T>>().map { it.amount }.sumOrNull()
/** Sums the asset states in the list, returning zero of the given token if there are none. */
fun <T> Iterable<ContractState>.sumFungibleOrZero(token: Issued<T>) = filterIsInstance<FungibleAsset<T>>().map { it.amount }.sumOrZero(token)