How to start a flow in Corda - corda

Question

I am exploring this cordapp example https://github.com/corda/corda-training-template.git
I have modified the code as per the solution template available in Github. Whenever I am starting the flow, I am getting error like (no constructor found, missing parameter state), please refer to the below screenshot.
I have initiated this flow from node A so I am confused about what will be the constructor parameter. I have pasted the state code below.
Flow issue screenshot
IOUState Constructor code
#BelongsToContract(IOUContract.class)
public class IOUState implements ContractState, LinearState {
public final Amount<Currency> amount;
public final Party lender;
public final Party borrower;
public final Amount<Currency> paid;
private final UniqueIdentifier linearId;
// Private constructor used only for copying a State object
#ConstructorForDeserialization
private IOUState(Amount<Currency> amount, Party lender, Party borrower, Amount<Currency> paid, UniqueIdentifier linearId){
this.amount = amount;
this.lender = lender;
this.borrower = borrower;
this.paid = paid;
this.linearId = linearId;
}
public IOUState(Amount<Currency> amount, Party lender, Party borrower) {
this(amount, lender, borrower, new Amount<>(0, amount.getToken()), new UniqueIdentifier());
}
public Amount<Currency> getAmount() {
return amount;
}
public Party getLender() {
return lender;
}
public Party getBorrower() {
return borrower;
}
public Amount<Currency> getPaid() {
return paid;
}
#Override
public UniqueIdentifier getLinearId() {
return linearId;
}
/**
* This method will return a list of the nodes which can "use" this state in a valid transaction. In this case, the
* lender or the borrower.
*/
#Override
public List<AbstractParty> getParticipants() {
return ImmutableList.of(lender, borrower);
}
/**
* Helper methods for when building transactions for settling and transferring IOUs.
* - [pay] adds an amount to the paid property. It does no validation.
* - [withNewLender] creates a copy of the current state with a newly specified lender. For use when transferring.
* - [copy] creates a copy of the state using the internal copy constructor ensuring the LinearId is preserved.
*/
public IOUState pay(Amount<Currency> amountToPay) {
Amount<Currency> newAmountPaid = this.paid.plus(amountToPay);
return new IOUState(amount, lender, borrower, newAmountPaid, linearId);
}
public IOUState withNewLender(Party newLender) {
return new IOUState(amount, newLender, borrower, paid, linearId);
}
public IOUState copy(Amount<Currency> amount, Party lender, Party borrower, Amount<Currency> paid) {
return new IOUState(amount, lender, borrower, paid, this.getLinearId());
}
}

Answer 1

I assume that one of the input parameters in your flow's constructor is a class (Amount<Currency>), so you have to pass an instance of that class when you start the flow in the node's shell.
See here how to create an instance of a class in the node's shell.
The problem in your code is that you're using Amount<Currency>; meaning to construct an instance, you'd have to do something like this:
Amount<Currency> usdAmount = new Amount(100, Currency.getInstance("USD"));
We have to use Currency.getInstance(), because Currency doesn't have a public constructor. From Currency code:
/**
* Constructs a <code>Currency</code> instance. The constructor is private
* so that we can insure that there's never more than one instance for a
* given currency.
*/
private Currency(String currencyCode, int defaultFractionDigits, int numericCode) {
this.currencyCode = currencyCode;
this.defaultFractionDigits = defaultFractionDigits;
this.numericCode = numericCode;
}
The node shell doesn't allow calling functions (i.e. Currency.getInstance()).
So in order for your flow to work, you have to modify its constructor and make it accept only primitive parameters as opposed to taking classes as well; then inside the constructor you can create an instance of the Amount class. It would look like this:
// Class attributes.
private Amount<Currency> iouAmount;
private Party otherParty;
// Constructor.
public Initiator(String currencyCode, long quantity, Party otherParty) {
this.iouAmount = new Amount(quantity, Currency.getInstance(currencyCode));
this.otherParty = otherParty;
}
Now inside the node's shell:
flow start IOUIssueFlow$Initiator currencyCode: USD, quantity: 100, otherParty: PartyB
Please note that you're using Amount, so quantity must be of type long. See here.