Implementing FungibleAsset - corda

Question

I have some troubles implementing a FungibleAsset contract.
The Dapp should consist of a Pool which is tokenized through PoolToken. For the PoolToken I implement the FungibleAsset class. There is a flow called CreatePoolFlow which uses the Create-Command from the Pool and the Issue-Command from the PoolToken. This flow should create a new Pool and Issue a specified number of Tokens the the Creator. When invoking the Flow an Error occurs.
Is there any guide on how to implement FungibleAsset or in general Tokens?
Thanks in advance for any help!
Pool.kt:
package com.company
//imports here
// *****************
// * Contract Code *
// *****************
class Pool : Contract {
// This is used to identify our contract when building a transaction
companion object {
const val POOL_CONTRACT_ID: ContractClassName = "com.company.Pool"
}
// A transaction is considered valid if the verify() function of the contract of each of the transaction's input
// and output states does not throw an exception.
override fun verify(tx: LedgerTransaction) {
//requireSingleCommand
var command = tx.commands.requireSingleCommand<Pool.Commands>()
val timeWindow: TimeWindow? = tx.timeWindow
when (command.value) {
is Commands.Create -> {
}
else -> throw IllegalArgumentException("Unrecognised command!")
}
}
// Used to indicate the transaction's intent.
interface Commands : CommandData {
class Create : TypeOnlyCommandData(), Commands
}
}
// *********
// * State *
// *********
data class PoolState(val issuer: Party,
override val participants: List<Party> = listOf(issuer),
val id: UniqueIdentifier = UniqueIdentifier())
//val id: UniqueIdentifier = UniqueIdentifier()) //val loans: Array<StateRef<Loan>>
: ContractState {
//override val participants = listOf(issuer)
//fun withoutOwner() = copy(issuer = AnonymousParty(NullKeys.NullPublicKey))
}
PoolToken.kt:
package com.company
//imports here
// *****************
// * Contract Code *
// *****************
class PoolToken : Contract {
// This is used to identify our contract when building a transaction
companion object {
const val POOLTOKEN_CONTRACT_ID: ContractClassName = "com.company.PoolToken"
}
// A transaction is considered valid if the verify() function of the contract of each of the transaction's input
// and output states does not throw an exception.
override fun verify(tx: LedgerTransaction) {
//requireSingleCommand
var command = tx.commands.requireSingleCommand<PoolToken.Commands>()
val timeWindow: TimeWindow? = tx.timeWindow
when (command.value) {
is Commands.Issue -> {
}
is Commands.Move -> {
}
is Commands.Exit -> {
}
else -> throw IllegalArgumentException("Unrecognised command!")
}
}
// Used to indicate the transaction's intent.
interface Commands : CommandData {
class Move : TypeOnlyCommandData(), Commands
class Issue : TypeOnlyCommandData(), Commands
class Exit : TypeOnlyCommandData(), Commands
}
}
// *********
// * State *
// *********
data class PoolTokenState(override val owner: AbstractParty,
override val amount: Amount<Issued<UniqueIdentifier>>)
: FungibleAsset<UniqueIdentifier> { //TODO: Change to BigDecimal
override val exitKeys = setOf(owner.owningKey) //, amount.token.issuer.party.owningKey
override val participants = listOf(owner)
override fun withNewOwnerAndAmount(newAmount: Amount<Issued<UniqueIdentifier>>, newOwner: AbstractParty): FungibleAsset<UniqueIdentifier>
= copy(amount = amount.copy(newAmount.quantity), owner = newOwner)
//override fun toString() = "$amount Tokens of Pool ${amount.token.product} from ${amount.token.issuer} owned by $owner"
override fun withNewOwner(newOwner: AbstractParty) = CommandAndState(PoolToken.Commands.Move(), copy(owner = newOwner))
//fun withoutOwner() = copy(issuer = AnonymousParty(NullKeys.NullPublicKey))
}
PoolFlows.kt:
package com.company
//imports here
#InitiatingFlow
#StartableByRPC
class CreatePoolFlow(val tokens: Long) : FlowLogic<SignedTransaction>() { //val auditor: Party
override val progressTracker = ProgressTracker()
#Suspendable
override fun call(): SignedTransaction {
//retrieve the notary identity from the network map
val notary = serviceHub.networkMapCache.notaryIdentities.first()
//create a transaction builder
val txBuilder = TransactionBuilder(notary = notary)
//get all parties in the network
//TODO: Construct as set and convert to list in order to prevent duplicates?
val nodes = serviceHub.networkMapCache.allNodes
val _parties = mutableListOf<Party>()
for (node in nodes) {
for (party in node.legalIdentities) {
_parties.add(party)
}
}
val parties: List<Party> = _parties
//create the Pool transaction components
val outputStatePool = PoolState(ourIdentity,parties)
val outputContractAndStatePool = StateAndContract(outputStatePool, POOL_CONTRACT_ID)
val cmdPool = Command(Pool.Commands.Create(), ourIdentity.owningKey)
//create the PoolToken transaction components
val outputStatePoolToken = PoolTokenState(ourIdentity, Amount(tokens,Issued(ourIdentity.ref(),outputStatePool.id)))
val outputContractAndStatePoolToken = StateAndContract(outputStatePoolToken, POOLTOKEN_CONTRACT_ID)
val cmdPoolToken = Command(PoolToken.Commands.Issue(), ourIdentity.owningKey)
//add the items to the builder
txBuilder.withItems(outputContractAndStatePool, cmdPool, outputContractAndStatePoolToken, cmdPoolToken)
//add time
val currentTime = serviceHub.clock.instant()
txBuilder.setTimeWindow(currentTime, 60.seconds)
//verifying the transaction
txBuilder.verify(serviceHub)
//signing the transaction
val signedTx = serviceHub.signInitialTransaction(txBuilder)
// Finalising the transaction.
subFlow(FinalityFlow(signedTx))
return signedTx
}
}
Error when executing the flow:
java.util.concurrent.ExecutionException: java.lang.IllegalArgumentException: Failed requirement.
at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
at com.company.FlowTests.create pool and tokens(FlowTests.kt:48)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:27)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)
Caused by: java.lang.IllegalArgumentException: Failed requirement.
at net.corda.core.utilities.OpaqueBytes.<init>(ByteArrays.kt:154)
at net.corda.core.utilities.OpaqueBytes$Companion.of(ByteArrays.kt:150)
at net.corda.core.identity.AbstractParty.ref(AbstractParty.kt:32)
at com.company.CreatePoolFlow.call(PoolFlows.kt:63)
at com.company.CreatePoolFlow.call(PoolFlows.kt:34)
at net.corda.node.services.statemachine.FlowStateMachineImpl.run(FlowStateMachineImpl.kt:96)
at net.corda.node.services.statemachine.FlowStateMachineImpl.run(FlowStateMachineImpl.kt:44)
at co.paralleluniverse.fibers.Fiber.run1(Fiber.java:1092)
at co.paralleluniverse.fibers.Fiber.exec(Fiber.java:788)
at co.paralleluniverse.fibers.RunnableFiberTask.doExec(RunnableFiberTask.java:100)
at co.paralleluniverse.fibers.RunnableFiberTask.run(RunnableFiberTask.java:91)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
at java.util.concurrent.FutureTask.run$$$capture(FutureTask.java:266)
at java.util.concurrent.FutureTask.run(FutureTask.java)
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$201(ScheduledThreadPoolExecutor.java:180)
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:293)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
at net.corda.node.utilities.AffinityExecutor$ServiceAffinityExecutor$1$thread$1.run(AffinityExecutor.kt:62)

Answer 1

I assume the problem is in the line
val outputStatePoolToken = PoolTokenState(ourIdentity, Amount(tokens,Issued(ourIdentity.ref(),outputStatePool.id)))
You are creating ourIdenity.ref() with empty bytes, which will cause the exact error.
Pass something like OpaqueBytes.of(0) to it and see if it helps