Merge pull request corda#3170 from corda/CORDA-1459

Corda 1459

Author: ischasny

.idea/compiler.xml

@@ -16,7 +16,6 @@ import net.corda.core.flows.FlowException
 import net.corda.core.identity.Party
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.transactions.TransactionBuilder
-import net.corda.finance.contracts.asset.CommodityContract
 import java.math.BigDecimal
 import java.time.DayOfWeek
 import java.time.LocalDate

finance/src/main/kotlin/net/corda/finance/contracts/FinanceTypes.kt

@@ -10,9 +10,7 @@ import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.FungibleAsset
 import net.corda.core.contracts.Issued
 import net.corda.core.identity.AbstractParty
-import net.corda.finance.contracts.Commodity
 import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.CommodityContract
 import net.corda.finance.contracts.asset.Obligation
 import java.util.*
 
@@ -45,19 +43,6 @@ fun <T : Any> Iterable<ContractState>.sumFungibleOrNull() = filterIsInstance<Fun
 /** Sums the asset states in the list, returning zero of the given token if there are none. */
 fun <T : Any> Iterable<ContractState>.sumFungibleOrZero(token: Issued<T>) = filterIsInstance<FungibleAsset<T>>().map { it.amount }.sumOrZero(token)
 
-/**
- * Sums the cash states in the list, throwing an exception if there are none, or if any of the cash
- * states cannot be added together (i.e. are different currencies).
- */
-fun Iterable<ContractState>.sumCommodities() = filterIsInstance<CommodityContract.State>().map { it.amount }.sumOrThrow()
-
-/** Sums the cash states in the list, returning null if there are none. */
-@Suppress("unused")
-fun Iterable<ContractState>.sumCommoditiesOrNull() = filterIsInstance<CommodityContract.State>().map { it.amount }.sumOrNull()
-
-/** Sums the cash states in the list, returning zero of the given currency if there are none. */
-fun Iterable<ContractState>.sumCommoditiesOrZero(currency: Issued<Commodity>) = filterIsInstance<CommodityContract.State>().map { it.amount }.sumOrZero(currency)
-
 /**
  * Sums the obligation states in the list, throwing an exception if there are none. All state objects in the
  * list are presumed to be nettable.

finance/src/main/kotlin/net/corda/finance/contracts/asset/CommodityContract.kt

@@ -25,6 +25,7 @@ import net.corda.testing.core.*
 import net.corda.testing.dsl.*
 import net.corda.testing.internal.TEST_TX_TIME
 import net.corda.testing.internal.rigorousMock
+import net.corda.testing.internal.vault.CommodityState
 import net.corda.testing.node.MockServices
 import net.corda.testing.node.ledger
 import net.corda.testing.node.transaction
@@ -574,15 +575,15 @@ class ObligationTests {
             unverifiedTransaction {
                 attachments(Obligation.PROGRAM_ID)
                 output(Obligation.PROGRAM_ID, "Alice's 1 FCOJ obligation to Bob", oneUnitFcojObligation between Pair(ALICE, BOB))
-                output(Obligation.PROGRAM_ID, "Alice's 1 FCOJ", CommodityContract.State(oneUnitFcoj, ALICE))
+                output(Obligation.PROGRAM_ID, "Alice's 1 FCOJ", CommodityState(oneUnitFcoj, ALICE))
             }
             transaction("Settlement") {
                 attachments(Obligation.PROGRAM_ID)
                 input("Alice's 1 FCOJ obligation to Bob")
                 input("Alice's 1 FCOJ")
-                output(Obligation.PROGRAM_ID, "Bob's 1 FCOJ", CommodityContract.State(oneUnitFcoj, BOB))
+                output(Obligation.PROGRAM_ID, "Bob's 1 FCOJ", CommodityState(oneUnitFcoj, BOB))
                 command(ALICE_PUBKEY, Obligation.Commands.Settle(Amount(oneUnitFcoj.quantity, oneUnitFcojObligation.amount.token)))
-                command(ALICE_PUBKEY, CommodityContract.Commands.Move(Obligation::class.java))
+                command(ALICE_PUBKEY, Obligation.Commands.Move(Obligation::class.java))
                 attachment(attachment(commodityContractBytes.inputStream()))
                 verifies()
             }

finance/src/main/kotlin/net/corda/finance/utils/StateSummingUtilities.kt

@@ -15,7 +15,8 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.finance.contracts.Commodity
 import net.corda.finance.contracts.DealState
 import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.CommodityContract
+import net.corda.finance.contracts.asset.Obligation
+import net.corda.finance.contracts.asset.OnLedgerAsset
 import net.corda.testing.core.*
 import net.corda.testing.internal.chooseIdentity
 import net.corda.testing.internal.chooseIdentityAndCert
@@ -166,19 +167,26 @@ class VaultFiller @JvmOverloads constructor(
         return Vault(states)
     }
 
+
+    /**
+     * Puts together an issuance transaction for the specified amount that starts out being owned by the given pubkey.
+     */
+    fun generateCommoditiesIssue(tx: TransactionBuilder, amount: Amount<Issued<Commodity>>, owner: AbstractParty, notary: Party)
+            = OnLedgerAsset.generateIssue(tx, TransactionState(CommodityState(amount, owner), Obligation.PROGRAM_ID, notary), Obligation.Commands.Issue())
+
+
     /**
      *
      * @param issuerServices service hub of the issuer node, which will be used to sign the transaction.
      * @return a vault object that represents the generated states (it will NOT be the full vault from the service hub!).
      */
     // TODO: need to make all FungibleAsset commands (issue, move, exit) generic
-    fun fillWithSomeTestCommodity(amount: Amount<Commodity>, issuerServices: ServiceHub, issuedBy: PartyAndReference): Vault<CommodityContract.State> {
+    fun fillWithSomeTestCommodity(amount: Amount<Commodity>, issuerServices: ServiceHub, issuedBy: PartyAndReference): Vault<CommodityState> {
         val myKey: PublicKey = services.myInfo.chooseIdentity().owningKey
         val me = AnonymousParty(myKey)
 
-        val commodity = CommodityContract()
         val issuance = TransactionBuilder(null as Party?)
-        commodity.generateIssue(issuance, Amount(amount.quantity, Issued(issuedBy, amount.token)), me, altNotary)
+        generateCommoditiesIssue(issuance, Amount(amount.quantity, Issued(issuedBy, amount.token)), me, altNotary)
         val transaction = issuerServices.signInitialTransaction(issuance, issuedBy.party.owningKey)
         services.recordTransactions(transaction)
         return Vault(setOf(transaction.tx.outRef(0)))
@@ -241,3 +249,27 @@ class VaultFiller @JvmOverloads constructor(
         return update.getOrThrow(Duration.ofSeconds(3))
     }
 }
+
+
+
+/** A state representing a commodity claim against some party */
+data class CommodityState(
+        override val amount: Amount<Issued<Commodity>>,
+
+        /** There must be a MoveCommand signed by this key to claim the amount */
+        override val owner: AbstractParty
+) : FungibleAsset<Commodity> {
+    constructor(deposit: PartyAndReference, amount: Amount<Commodity>, owner: AbstractParty)
+            : this(Amount(amount.quantity, Issued(deposit, amount.token)), owner)
+
+    override val exitKeys: Set<PublicKey> = Collections.singleton(owner.owningKey)
+    override val participants = listOf(owner)
+
+    override fun withNewOwnerAndAmount(newAmount: Amount<Issued<Commodity>>, newOwner: AbstractParty): FungibleAsset<Commodity>
+            = copy(amount = amount.copy(newAmount.quantity), owner = newOwner)
+
+    override fun toString() = "Commodity($amount at ${amount.token.issuer} owned by $owner)"
+
+    override fun withNewOwner(newOwner: AbstractParty) = CommandAndState(Obligation.Commands.Move(), copy(owner = newOwner))
+}
+