MACRO NEPAL
Enterprise Blockchain Development with Corda CorDapp in Java
awiskar acharya
November 16, 2025
8:16 am

Building Distributed Business Applications on Corda Platform

Article

Corda is an open-source blockchain platform designed specifically for business applications. Unlike traditional blockchains, Corda focuses on privacy, scalability, and legal enforceability. CorDapps (Corda Distributed Applications) are the building blocks that run on Corda networks, enabling businesses to transact directly with strong privacy guarantees.

Corda Architecture Overview

Key Concepts:

  • States: Shared facts on the ledger
  • Contracts: Rules governing state evolution
  • Flows: Business processes that coordinate updates
  • Transactions: Proposed updates to the ledger
  • Nodes: Network participants running Corda
  • Notary: Prevents double-spends and provides finality

Corda vs Traditional Blockchains:

  • No Global Broadcast: Only relevant parties see transactions
  • Legal Identity: Real-world legal entities on the network
  • Pluggable Consensus: Flexible consensus mechanisms
  • No Native Cryptocurrency: Focus on business assets

1. Project Setup and Dependencies

Gradle Configuration (build.gradle):

plugins {
id 'java'
id 'net.corda.plugins.cordapp' version '6.0.0'
id 'net.corda.plugins.quasar-utils' version '6.0.0'
}
repositories {
mavenCentral()
maven { url 'https://software.r3.com/artifactory/corda' }
}
cordapp {
targetPlatformVersion 6
minimumPlatformVersion 6
contract {
name "Trade Finance CorDapp"
versionId 1
vendor "My Company"
licence "Apache 2"
}
workflow {
name "Trade Finance CorDapp"
versionId 1
vendor "My Company"
licence "Apache 2"
}
}
dependencies {
// Corda dependencies
cordaCompile "net.corda:corda-core:4.9"
cordaCompile "net.corda:corda-node-api:4.9"
cordaRuntime "net.corda:corda:4.9"
// CorDapp dependencies
cordapp "net.corda:corda-finance-contracts:4.9"
cordapp "net.corda:corda-finance-workflows:4.9"
// Testing
testCompile "net.corda:corda-node-driver:4.9"
testCompile "junit:junit:4.13.2"
// Quasar for flow checkpoints
cordaCompile "co.paralleluniverse:quasar-core:0.7.15"
}
tasks.withType(JavaCompile) {
options.compilerArgs << "-parameters"
}

2. State Definition

States represent shared facts on the ledger. Let's create a trade finance state:

package com.tradefinance.states;
import net.corda.core.contracts.BelongsToContract;
import net.corda.core.contracts.ContractState;
import net.corda.core.contracts.LinearState;
import net.corda.core.contracts.UniqueIdentifier;
import net.corda.core.identity.AbstractParty;
import net.corda.core.identity.Party;
import net.corda.core.serialization.CordaSerializable;
import java.util.Arrays;
import java.util.List;
/**
* Letter of Credit State representing a trade finance instrument
*/
@BelongsToContract(LetterOfCreditContract.class)
public class LetterOfCreditState implements LinearState {
private final UniqueIdentifier linearId;
private final Party applicant;       // Buyer (importer)
private final Party beneficiary;     // Seller (exporter)
private final Party issuingBank;     // Issuing bank
private final Party advisingBank;    // Advising bank (optional)
private final String lcNumber;
private final Double amount;
private final String currency;
private final String goodsDescription;
private final String shippingTerms;
private final LCStatus status;
private final java.time.Instant issueDate;
private final java.time.Instant expiryDate;
public LetterOfCreditState(UniqueIdentifier linearId,
Party applicant,
Party beneficiary,
Party issuingBank,
Party advisingBank,
String lcNumber,
Double amount,
String currency,
String goodsDescription,
String shippingTerms,
LCStatus status,
java.time.Instant issueDate,
java.time.Instant expiryDate) {
this.linearId = linearId;
this.applicant = applicant;
this.beneficiary = beneficiary;
this.issuingBank = issuingBank;
this.advisingBank = advisingBank;
this.lcNumber = lcNumber;
this.amount = amount;
this.currency = currency;
this.goodsDescription = goodsDescription;
this.shippingTerms = shippingTerms;
this.status = status;
this.issueDate = issueDate;
this.expiryDate = expiryDate;
}
// Getters
@Override
public UniqueIdentifier getLinearId() { return linearId; }
public Party getApplicant() { return applicant; }
public Party getBeneficiary() { return beneficiary; }
public Party getIssuingBank() { return issuingBank; }
public Party getAdvisingBank() { return advisingBank; }
public String getLcNumber() { return lcNumber; }
public Double getAmount() { return amount; }
public String getCurrency() { return currency; }
public String getGoodsDescription() { return goodsDescription; }
public String getShippingTerms() { return shippingTerms; }
public LCStatus getStatus() { return status; }
public java.time.Instant getIssueDate() { return issueDate; }
public java.time.Instant getExpiryDate() { return expiryDate; }
@Override
public List<AbstractParty> getParticipants() {
if (advisingBank != null) {
return Arrays.asList(applicant, beneficiary, issuingBank, advisingBank);
}
return Arrays.asList(applicant, beneficiary, issuingBank);
}
// State evolution methods
public LetterOfCreditState withStatus(LCStatus newStatus) {
return new LetterOfCreditState(
linearId, applicant, beneficiary, issuingBank, advisingBank,
lcNumber, amount, currency, goodsDescription, shippingTerms,
newStatus, issueDate, expiryDate
);
}
public LetterOfCreditState withAdvisingBank(Party newAdvisingBank) {
return new LetterOfCreditState(
linearId, applicant, beneficiary, issuingBank, newAdvisingBank,
lcNumber, amount, currency, goodsDescription, shippingTerms,
status, issueDate, expiryDate
);
}
// Status enumeration
@CordaSerializable
public enum LCStatus {
ISSUED,
ADVISED,
AMENDED,
UTILIZED,
ACCEPTED,
EXPIRED,
CANCELLED
}
}

3. Contract Definition

Contracts define the rules for state evolution:

package com.tradefinance.contracts;
import com.tradefinance.states.LetterOfCreditState;
import net.corda.core.contracts.Command;
import net.corda.core.contracts.CommandData;
import net.corda.core.contracts.Contract;
import net.corda.core.contracts.ContractState;
import net.corda.core.identity.Party;
import net.corda.core.transactions.LedgerTransaction;
import java.security.PublicKey;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import static net.corda.core.contracts.ContractsDSL.requireThat;
/**
* Contract for Letter of Credit transactions
*/
public class LetterOfCreditContract implements Contract {
public static final String ID = "com.tradefinance.contracts.LetterOfCreditContract";
@Override
public void verify(LedgerTransaction tx) {
// Extract commands
final List<Command<CommandData>> commands = tx.getCommands();
for (Command<?> command : commands) {
final CommandData commandData = command.getValue();
if (commandData instanceof Commands.Issue) {
verifyIssue(tx, command);
} else if (commandData instanceof Commands.Advise) {
verifyAdvise(tx, command);
} else if (commandData instanceof Commands.Amend) {
verifyAmend(tx, command);
} else if (commandData instanceof Commands.Utilize) {
verifyUtilize(tx, command);
} else if (commandData instanceof Commands.Accept) {
verifyAccept(tx, command);
} else {
throw new IllegalArgumentException("Unrecognized command");
}
}
}
private void verifyIssue(LedgerTransaction tx, Command<?> command) {
requireThat(require -> {
// Structural requirements
require.using("No inputs should be consumed when issuing an LC", 
tx.getInputStates().isEmpty());
require.using("Only one LC state should be created", 
tx.getOutputStates().size() == 1);
// Output state requirements
ContractState outputState = tx.getOutputStates().get(0);
require.using("Output must be a LetterOfCreditState", 
outputState instanceof LetterOfCreditState);
LetterOfCreditState lcState = (LetterOfCreditState) outputState;
// Business rules
require.using("LC amount must be positive", 
lcState.getAmount() > 0);
require.using("Issue date must be before expiry date", 
lcState.getIssueDate().isBefore(lcState.getExpiryDate()));
require.using("LC must be in ISSUED status", 
lcState.getStatus() == LetterOfCreditState.LCStatus.ISSUED);
// Signer requirements
Set<PublicKey> signers = new HashSet<>(command.getSigners());
Set<PublicKey> expectedSigners = getExpectedSigners(lcState);
require.using("Applicant and issuing bank must sign issue transaction",
signers.containsAll(expectedSigners));
return null;
});
}
private void verifyAdvise(LedgerTransaction tx, Command<?> command) {
requireThat(require -> {
// Structural requirements
require.using("Advise transaction must have exactly one input and one output",
tx.getInputStates().size() == 1 && tx.getOutputStates().size() == 1);
// State type requirements
ContractState inputState = tx.getInputStates().get(0);
ContractState outputState = tx.getOutputStates().get(0);
require.using("Input must be a LetterOfCreditState", 
inputState instanceof LetterOfCreditState);
require.using("Output must be a LetterOfCreditState", 
outputState instanceof LetterOfCreditState);
LetterOfCreditState inputLC = (LetterOfCreditState) inputState;
LetterOfCreditState outputLC = (LetterOfCreditState) outputState;
// Business rules for advising
require.using("Input LC must be in ISSUED status",
inputLC.getStatus() == LetterOfCreditState.LCStatus.ISSUED);
require.using("Output LC must be in ADVISED status",
outputLC.getStatus() == LetterOfCreditState.LCStatus.ADVISED);
require.using("Only status should change during advise",
statesEqualExceptStatus(inputLC, outputLC));
// Signer requirements
Set<PublicKey> signers = new HashSet<>(command.getSigners());
require.using("Advising bank must sign advise transaction",
signers.contains(outputLC.getAdvisingBank().getOwningKey()));
return null;
});
}
private void verifyAmend(LedgerTransaction tx, Command<?> command) {
requireThat(require -> {
// Similar verification logic for amendments
require.using("Amend transaction must have exactly one input and one output",
tx.getInputStates().size() == 1 && tx.getOutputStates().size() == 1);
LetterOfCreditState inputLC = (LetterOfCreditState) tx.getInputStates().get(0);
LetterOfCreditState outputLC = (LetterOfCreditState) tx.getOutputStates().get(0);
require.using("All parties must agree to amendment",
command.getSigners().containsAll(getAllParticipantKeys(inputLC)));
return null;
});
}
private void verifyUtilize(LedgerTransaction tx, Command<?> command) {
requireThat(require -> {
// Utilization verification logic
require.using("Utilize transaction must have exactly one input and one output",
tx.getInputStates().size() == 1 && tx.getOutputStates().size() == 1);
LetterOfCreditState inputLC = (LetterOfCreditState) tx.getInputStates().get(0);
LetterOfCreditState outputLC = (LetterOfCreditState) tx.getOutputStates().get(0);
require.using("LC must not be expired for utilization",
java.time.Instant.now().isBefore(inputLC.getExpiryDate()));
require.using("Beneficiary must sign utilization",
command.getSigners().contains(inputLC.getBeneficiary().getOwningKey()));
return null;
});
}
private void verifyAccept(LedgerTransaction tx, Command<?> command) {
requireThat(require -> {
// Acceptance verification logic
require.using("Accept transaction must have exactly one input and one output",
tx.getInputStates().size() == 1 && tx.getOutputStates().size() == 1);
LetterOfCreditState inputLC = (LetterOfCreditState) tx.getInputStates().get(0);
LetterOfCreditState outputLC = (LetterOfCreditState) tx.getOutputStates().get(0);
require.using("Applicant must sign acceptance",
command.getSigners().contains(inputLC.getApplicant().getOwningKey()));
return null;
});
}
// Helper methods
private boolean statesEqualExceptStatus(LetterOfCreditState state1, LetterOfCreditState state2) {
return state1.getLinearId().equals(state2.getLinearId()) &&
state1.getApplicant().equals(state2.getApplicant()) &&
state1.getBeneficiary().equals(state2.getBeneficiary()) &&
state1.getIssuingBank().equals(state2.getIssuingBank()) &&
state1.getAmount().equals(state2.getAmount()) &&
state1.getCurrency().equals(state2.getCurrency());
}
private Set<PublicKey> getExpectedSigners(LetterOfCreditState state) {
Set<PublicKey> expected = new HashSet<>();
expected.add(state.getApplicant().getOwningKey());
expected.add(state.getIssuingBank().getOwningKey());
return expected;
}
private Set<PublicKey> getAllParticipantKeys(LetterOfCreditState state) {
return state.getParticipants().stream()
.map(AbstractParty::getOwningKey)
.collect(Collectors.toSet());
}
// Command definitions
public interface Commands extends CommandData {
class Issue implements Commands {}
class Advise implements Commands {}
class Amend implements Commands {}
class Utilize implements Commands {}
class Accept implements Commands {}
class Expire implements Commands {}
}
}

4. Flow Development

Flows coordinate the business processes between parties:

Issue Letter of Credit Flow:

package com.tradefinance.flows;
import co.paralleluniverse.fibers.Suspendable;
import com.tradefinance.contracts.LetterOfCreditContract;
import com.tradefinance.states.LetterOfCreditState;
import net.corda.core.contracts.Command;
import net.corda.core.contracts.StateAndRef;
import net.corda.core.contracts.UniqueIdentifier;
import net.corda.core.flows.*;
import net.corda.core.identity.Party;
import net.corda.core.node.services.Vault;
import net.corda.core.node.services.vault.QueryCriteria;
import net.corda.core.transactions.SignedTransaction;
import net.corda.core.transactions.TransactionBuilder;
import net.corda.core.utilities.ProgressTracker;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
import java.util.Collections;
/**
* Flow for issuing a new Letter of Credit
*/
@InitiatingFlow
@StartableByRPC
public class IssueLetterOfCreditFlow extends FlowLogic<SignedTransaction> {
private final Party beneficiary;
private final Party issuingBank;
private final String lcNumber;
private final Double amount;
private final String currency;
private final String goodsDescription;
private final String shippingTerms;
private final Long validityDays;
private final ProgressTracker progressTracker = new ProgressTracker(
GENERATING_TRANSACTION,
VERIFYING_TRANSACTION,
SIGNING_TRANSACTION,
GATHERING_SIGNATURES,
FINALISING_TRANSACTION
);
public IssueLetterOfCreditFlow(Party beneficiary,
Party issuingBank,
String lcNumber,
Double amount,
String currency,
String goodsDescription,
String shippingTerms,
Long validityDays) {
this.beneficiary = beneficiary;
this.issuingBank = issuingBank;
this.lcNumber = lcNumber;
this.amount = amount;
this.currency = currency;
this.goodsDescription = goodsDescription;
this.shippingTerms = shippingTerms;
this.validityDays = validityDays;
}
@Override
public ProgressTracker getProgressTracker() {
return progressTracker;
}
@Suspendable
@Override
public SignedTransaction call() throws FlowException {
// Get current node identity
final Party applicant = getOurIdentity();
progressTracker.setCurrentStep(GENERATING_TRANSACTION);
// Create the output state
final UniqueIdentifier linearId = new UniqueIdentifier();
final Instant issueDate = Instant.now();
final Instant expiryDate = issueDate.plus(validityDays, ChronoUnit.DAYS);
final LetterOfCreditState outputState = new LetterOfCreditState(
linearId,
applicant,
beneficiary,
issuingBank,
null, // No advising bank initially
lcNumber,
amount,
currency,
goodsDescription,
shippingTerms,
LetterOfCreditState.LCStatus.ISSUED,
issueDate,
expiryDate
);
// Build transaction
final TransactionBuilder txBuilder = new TransactionBuilder();
// Get notary
final Party notary = getServiceHub().getNetworkMapCache()
.getNotaryIdentities().get(0);
txBuilder.setNotary(notary);
// Add output state and command
final Command<LetterOfCreditContract.Commands.Issue> issueCommand = 
new Command<>(new LetterOfCreditContract.Commands.Issue(),
Arrays.asList(applicant.getOwningKey(), issuingBank.getOwningKey()));
txBuilder.addOutputState(outputState, LetterOfCreditContract.ID);
txBuilder.addCommand(issueCommand);
progressTracker.setCurrentStep(VERIFYING_TRANSACTION);
// Verify transaction
txBuilder.verify(getServiceHub());
progressTracker.setCurrentStep(SIGNING_TRANSACTION);
// Sign transaction
final SignedTransaction partiallySignedTx = getServiceHub().signInitialTransaction(txBuilder);
progressTracker.setCurrentStep(GATHERING_SIGNATURES);
// Collect counterparty signatures
final FlowSession issuingBankSession = initiateFlow(issuingBank);
final SignedTransaction fullySignedTx = subFlow(new CollectSignaturesFlow(
partiallySignedTx, Collections.singletonList(issuingBankSession)));
progressTracker.setCurrentStep(FINALISING_TRANSACTION);
// Finalize transaction
return subFlow(new FinalityFlow(fullySignedTx, Arrays.asList(issuingBankSession)));
}
}

Responder Flow for LC Issuance:

@InitiatedBy(IssueLetterOfCreditFlow.class)
public class IssueLetterOfCreditResponder extends FlowLogic<SignedTransaction> {
private final FlowSession otherPartySession;
public IssueLetterOfCreditResponder(FlowSession otherPartySession) {
this.otherPartySession = otherPartySession;
}
@Suspendable
@Override
public SignedTransaction call() throws FlowException {
class SignTxFlow extends SignTransactionFlow {
private SignTxFlow(FlowSession otherPartySession) {
super(otherPartySession);
}
@Override
protected void checkTransaction(SignedTransaction stx) {
// Add any custom verification logic for the issuing bank
// For example, check if the bank's policies are satisfied
}
}
final SignedTransaction signedTx = subFlow(new SignTxFlow(otherPartySession));
return subFlow(new ReceiveFinalityFlow(otherPartySession, signedTx.getId()));
}
}

Advise Letter of Credit Flow:

@InitiatingFlow
@StartableByRPC
public class AdviseLetterOfCreditFlow extends FlowLogic<SignedTransaction> {
private final UniqueIdentifier linearId;
private final Party advisingBank;
private final ProgressTracker progressTracker = new ProgressTracker(
RETRIEVING_STATE,
BUILDING_TRANSACTION,
VERIFYING_TRANSACTION,
SIGNING_TRANSACTION,
GATHERING_SIGNATURES,
FINALISING_TRANSACTION
);
public AdviseLetterOfCreditFlow(UniqueIdentifier linearId, Party advisingBank) {
this.linearId = linearId;
this.advisingBank = advisingBank;
}
@Suspendable
@Override
public SignedTransaction call() throws FlowException {
progressTracker.setCurrentStep(RETRIEVING_STATE);
// Retrieve the LC state from vault
final QueryCriteria.LinearStateQueryCriteria criteria = 
new QueryCriteria.LinearStateQueryCriteria(
null, 
Collections.singletonList(linearId.getId()),
Vault.StateStatus.UNCONSUMED,
null);
final StateAndRef<LetterOfCreditState> inputStateAndRef = 
getServiceHub().getVaultService()
.queryBy(LetterOfCreditState.class, criteria)
.getStates().get(0);
final LetterOfCreditState inputState = inputStateAndRef.getState().getData();
// Verify we are the beneficiary
if (!inputState.getBeneficiary().equals(getOurIdentity())) {
throw new FlowException("Only beneficiary can advise an LC");
}
progressTracker.setCurrentStep(BUILDING_TRANSACTION);
// Create advised state
final LetterOfCreditState outputState = inputState
.withAdvisingBank(advisingBank)
.withStatus(LetterOfCreditState.LCStatus.ADVISED);
// Build transaction
final TransactionBuilder txBuilder = new TransactionBuilder();
final Party notary = inputStateAndRef.getState().getNotary();
txBuilder.setNotary(notary);
// Add input and output states
txBuilder.addInputState(inputStateAndRef);
txBuilder.addOutputState(outputState, LetterOfCreditContract.ID);
// Add command
final Command<LetterOfCreditContract.Commands.Advise> adviseCommand = 
new Command<>(new LetterOfCreditContract.Commands.Advise(),
Collections.singletonList(advisingBank.getOwningKey()));
txBuilder.addCommand(adviseCommand);
progressTracker.setCurrentStep(VERIFYING_TRANSACTION);
txBuilder.verify(getServiceHub());
progressTracker.setCurrentStep(SIGNING_TRANSACTION);
final SignedTransaction partiallySignedTx = getServiceHub().signInitialTransaction(txBuilder);
progressTracker.setCurrentStep(GATHERING_SIGNATURES);
final FlowSession advisingBankSession = initiateFlow(advisingBank);
final SignedTransaction fullySignedTx = subFlow(new CollectSignaturesFlow(
partiallySignedTx, Collections.singletonList(advisingBankSession)));
progressTracker.setCurrentStep(FINALISING_TRANSACTION);
return subFlow(new FinalityFlow(fullySignedTx, Arrays.asList(advisingBankSession)));
}
}

5. API Development

Expose CorDapp functionality via REST API:

package com.tradefinance.api;
import com.tradefinance.flows.AdviseLetterOfCreditFlow;
import com.tradefinance.flows.IssueLetterOfCreditFlow;
import com.tradefinance.states.LetterOfCreditState;
import net.corda.core.contracts.StateAndRef;
import net.corda.core.identity.CordaX500Name;
import net.corda.core.identity.Party;
import net.corda.core.messaging.CordaRPCOps;
import net.corda.core.node.NodeInfo;
import net.corda.core.node.services.Vault;
import net.corda.core.node.services.vault.QueryCriteria;
import net.corda.core.transactions.SignedTransaction;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;
import java.util.stream.Collectors;
@Path("letterofcredit")
public class LetterOfCreditApi {
private final CordaRPCOps rpcOps;
private final Party myIdentity;
public LetterOfCreditApi(CordaRPCOps rpcOps) {
this.rpcOps = rpcOps;
this.myIdentity = rpcOps.nodeInfo().getLegalIdentities().get(0);
}
@GET
@Path("mylcs")
@Produces(MediaType.APPLICATION_JSON)
public List<LetterOfCreditState> getMyLetterOfCredits() {
QueryCriteria.VaultQueryCriteria criteria = 
new QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED);
List<StateAndRef<LetterOfCreditState>> lcStates = 
rpcOps.vaultQueryByCriteria(criteria, LetterOfCreditState.class).getStates();
return lcStates.stream()
.map(stateAndRef -> stateAndRef.getState().getData())
.collect(Collectors.toList());
}
@GET
@Path("lcs-as-applicant")
@Produces(MediaType.APPLICATION_JSON)
public List<LetterOfCreditState> getLCsAsApplicant() {
return getMyLetterOfCredits().stream()
.filter(lc -> lc.getApplicant().equals(myIdentity))
.collect(Collectors.toList());
}
@GET
@Path("lcs-as-beneficiary")
@Produces(MediaType.APPLICATION_JSON)
public List<LetterOfCreditState> getLCsAsBeneficiary() {
return getMyLetterOfCredits().stream()
.filter(lc -> lc.getBeneficiary().equals(myIdentity))
.collect(Collectors.toList());
}
@POST
@Path("issue")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public Response issueLetterOfCredit(IssueLCRequest request) {
try {
// Find counterparties from network map
Party beneficiary = resolveParty(request.getBeneficiaryName());
Party issuingBank = resolveParty(request.getIssuingBankName());
// Start flow
SignedTransaction result = rpcOps.startTrackedFlowDynamic(
IssueLetterOfCreditFlow.class,
beneficiary,
issuingBank,
request.getLcNumber(),
request.getAmount(),
request.getCurrency(),
request.getGoodsDescription(),
request.getShippingTerms(),
request.getValidityDays()
).getReturnValue().get();
return Response.status(Response.Status.CREATED)
.entity(new FlowResult("LC issued successfully", result.getId().toString()))
.build();
} catch (Exception e) {
return Response.status(Response.Status.BAD_REQUEST)
.entity(new ErrorResponse(e.getMessage()))
.build();
}
}
@POST
@Path("advise")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public Response adviseLetterOfCredit(AdviseLCRequest request) {
try {
Party advisingBank = resolveParty(request.getAdvisingBankName());
SignedTransaction result = rpcOps.startTrackedFlowDynamic(
AdviseLetterOfCreditFlow.class,
request.getLinearId(),
advisingBank
).getReturnValue().get();
return Response.ok(new FlowResult("LC advised successfully", result.getId().toString()))
.build();
} catch (Exception e) {
return Response.status(Response.Status.BAD_REQUEST)
.entity(new ErrorResponse(e.getMessage()))
.build();
}
}
@GET
@Path("network-parties")
@Produces(MediaType.APPLICATION_JSON)
public List<PartyInfo> getNetworkParties() {
return rpcOps.networkMapSnapshot().stream()
.map(NodeInfo::getLegalIdentities)
.flatMap(List::stream)
.map(party -> new PartyInfo(
party.getName().getOrganisation(),
party.getName().getLocality(),
party.getName().getCountry()
))
.distinct()
.collect(Collectors.toList());
}
private Party resolveParty(String organisation) {
return rpcOps.networkMapSnapshot().stream()
.flatMap(node -> node.getLegalIdentities().stream())
.filter(party -> party.getName().getOrganisation().equals(organisation))
.findFirst()
.orElseThrow(() -> new WebApplicationException("Party not found: " + organisation, 404));
}
// DTO classes
public static class IssueLCRequest {
private String beneficiaryName;
private String issuingBankName;
private String lcNumber;
private Double amount;
private String currency;
private String goodsDescription;
private String shippingTerms;
private Long validityDays;
// getters and setters
public String getBeneficiaryName() { return beneficiaryName; }
public void setBeneficiaryName(String beneficiaryName) { this.beneficiaryName = beneficiaryName; }
public String getIssuingBankName() { return issuingBankName; }
public void setIssuingBankName(String issuingBankName) { this.issuingBankName = issuingBankName; }
public String getLcNumber() { return lcNumber; }
public void setLcNumber(String lcNumber) { this.lcNumber = lcNumber; }
public Double getAmount() { return amount; }
public void setAmount(Double amount) { this.amount = amount; }
public String getCurrency() { return currency; }
public void setCurrency(String currency) { this.currency = currency; }
public String getGoodsDescription() { return goodsDescription; }
public void setGoodsDescription(String goodsDescription) { this.goodsDescription = goodsDescription; }
public String getShippingTerms() { return shippingTerms; }
public void setShippingTerms(String shippingTerms) { this.shippingTerms = shippingTerms; }
public Long getValidityDays() { return validityDays; }
public void setValidityDays(Long validityDays) { this.validityDays = validityDays; }
}
public static class AdviseLCRequest {
private net.corda.core.contracts.UniqueIdentifier linearId;
private String advisingBankName;
// getters and setters
public net.corda.core.contracts.UniqueIdentifier getLinearId() { return linearId; }
public void setLinearId(net.corda.core.contracts.UniqueIdentifier linearId) { this.linearId = linearId; }
public String getAdvisingBankName() { return advisingBankName; }
public void setAdvisingBankName(String advisingBankName) { this.advisingBankName = advisingBankName; }
}
public static class FlowResult {
private final String message;
private final String transactionId;
public FlowResult(String message, String transactionId) {
this.message = message;
this.transactionId = transactionId;
}
public String getMessage() { return message; }
public String getTransactionId() { return transactionId; }
}
public static class ErrorResponse {
private final String error;
public ErrorResponse(String error) {
this.error = error;
}
public String getError() { return error; }
}
public static class PartyInfo {
private final String organisation;
private final String locality;
private final String country;
public PartyInfo(String organisation, String locality, String country) {
this.organisation = organisation;
this.locality = locality;
this.country = country;
}
public String getOrganisation() { return organisation; }
public String getLocality() { return locality; }
public String getCountry() { return country; }
}
}

6. Testing CorDapps

Comprehensive testing for states, contracts, and flows:

package com.tradefinance.test;
import com.tradefinance.contracts.LetterOfCreditContract;
import com.tradefinance.flows.IssueLetterOfCreditFlow;
import com.tradefinance.states.LetterOfCreditState;
import net.corda.core.contracts.Command;
import net.corda.core.contracts.TransactionState;
import net.corda.core.identity.CordaX500Name;
import net.corda.core.identity.Party;
import net.corda.core.transactions.TransactionBuilder;
import net.corda.testing.core.TestIdentity;
import net.corda.testing.node.MockServices;
import net.corda.testing.node.StartedMockNode;
import net.corda.testing.node.TestNetwork;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
import java.util.Collections;
import static net.corda.testing.node.NodeTestUtils.ledger;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
public class LetterOfCreditTests {
private TestNetwork network;
private StartedMockNode applicantNode;
private StartedMockNode beneficiaryNode;
private StartedMockNode issuingBankNode;
private StartedMockNode advisingBankNode;
private TestIdentity applicant;
private TestIdentity beneficiary;
private TestIdentity issuingBank;
private TestIdentity advisingBank;
private final MockServices ledgerServices = new MockServices(
Arrays.asList("com.tradefinance")
);
@Before
public void setup() {
network = new TestNetwork();
applicantNode = network.createNode();
beneficiaryNode = network.createNode();
issuingBankNode = network.createNode();
advisingBankNode = network.createNode();
applicant = new TestIdentity(new CordaX500Name("Applicant", "London", "GB"));
beneficiary = new TestIdentity(new CordaX500Name("Beneficiary", "New York", "US"));
issuingBank = new TestIdentity(new CordaX500Name("IssuingBank", "London", "GB"));
advisingBank = new TestIdentity(new CordaX500Name("AdvisingBank", "New York", "US"));
network.runNetwork();
}
@After
public void tearDown() {
network.stopNodes();
}
@Test
public void testLetterOfCreditStateCreation() {
LetterOfCreditState.LCStatus status = LetterOfCreditState.LCStatus.ISSUED;
Instant issueDate = Instant.now();
Instant expiryDate = issueDate.plus(30, ChronoUnit.DAYS);
LetterOfCreditState state = new LetterOfCreditState(
new net.corda.core.contracts.UniqueIdentifier(),
applicant.getParty(),
beneficiary.getParty(),
issuingBank.getParty(),
null,
"LC123456",
100000.0,
"USD",
"Electronics Components",
"CIF",
status,
issueDate,
expiryDate
);
assertEquals(applicant.getParty(), state.getApplicant());
assertEquals(beneficiary.getParty(), state.getBeneficiary());
assertEquals("LC123456", state.getLcNumber());
assertEquals(LetterOfCreditState.LCStatus.ISSUED, state.getStatus());
assertEquals(3, state.getParticipants().size());
}
@Test
public void testIssueTransaction() {
ledger(ledgerServices, l -> {
l.transaction(tx -> {
Instant issueDate = Instant.now();
Instant expiryDate = issueDate.plus(30, ChronoUnit.DAYS);
LetterOfCreditState outputState = new LetterOfCreditState(
new net.corda.core.contracts.UniqueIdentifier(),
applicant.getParty(),
beneficiary.getParty(),
issuingBank.getParty(),
null,
"LC123456",
100000.0,
"USD",
"Electronics Components",
"CIF",
LetterOfCreditState.LCStatus.ISSUED,
issueDate,
expiryDate
);
Command<LetterOfCreditContract.Commands.Issue> issueCommand = 
new Command<>(new LetterOfCreditContract.Commands.Issue(),
Arrays.asList(applicant.getParty().getOwningKey(), 
issuingBank.getParty().getOwningKey()));
tx.output(LetterOfCreditContract.ID, outputState);
tx.command(issueCommand);
tx.verifies();
return null;
});
return null;
});
}
@Test
public void testIssueFlow() throws Exception {
IssueLetterOfCreditFlow flow = new IssueLetterOfCreditFlow(
beneficiary.getParty(),
issuingBank.getParty(),
"LC123456",
100000.0,
"USD",
"Electronics Components",
"CIF",
30L
);
applicantNode.startFlow(flow);
network.runNetwork();
// Verify state is recorded in vault
applicantNode.transaction(() -> {
assertEquals(1, applicantNode.getServices().getVaultService()
.queryBy(LetterOfCreditState.class).getStates().size());
return null;
});
}
@Test
public void testInvalidIssueTransaction() {
ledger(ledgerServices, l -> {
l.transaction(tx -> {
Instant issueDate = Instant.now();
Instant expiryDate = issueDate.minus(1, ChronoUnit.DAYS); // Invalid: expiry before issue
LetterOfCreditState outputState = new LetterOfCreditState(
new net.corda.core.contracts.UniqueIdentifier(),
applicant.getParty(),
beneficiary.getParty(),
issuingBank.getParty(),
null,
"LC123456",
-1000.0, // Invalid: negative amount
"USD",
"Electronics Components",
"CIF",
LetterOfCreditState.LCStatus.ISSUED,
issueDate,
expiryDate
);
Command<LetterOfCreditContract.Commands.Issue> issueCommand = 
new Command<>(new LetterOfCreditContract.Commands.Issue(),
Arrays.asList(applicant.getParty().getOwningKey(), 
issuingBank.getParty().getOwningKey()));
tx.output(LetterOfCreditContract.ID, outputState);
tx.command(issueCommand);
tx.failsWith("LC amount must be positive");
return null;
});
return null;
});
}
}

7. Deployment and Configuration

Node Configuration (node.conf):

# Node configuration
myLegalName="O=Applicant,L=London,C=GB"
p2pAddress="localhost:10005"
rpcSettings {
address="localhost:10006"
adminAddress="localhost:10046"
}
rpcUsers=[
{
username=user1
password=letmein
permissions=[
ALL
]
}
]
# Cordapp configuration
cordappSignerKeyFingerprintBlacklist = []
cordappsDirectory = "cordapps"
devMode = true
# Network services
networkServices {
doormanURL="https://doorman.corda.network"
networkMapURL="https://netmap.corda.network"
}
# Security
keyStorePassword = "cordacadevpass"
trustStorePassword = "trustpass"
# Database
dataSourceProperties = {
dataSourceClassName = "org.h2.jdbcx.JdbcDataSource"
"dataSource.url" = "jdbc:h2:file:"${baseDirectory}"/persistence"
"dataSource.user" = sa
"dataSource.password" = ""
}
database = {
transactionIsolationLevel = READ_COMMITTED
}

Docker Deployment:

FROM corda/corda-zulu-java1.8-4.9:latest
USER root
# Create Corda user
RUN adduser --disabled-password --gecos '' corda
# Create directories
RUN mkdir -p /opt/corda/cordapps
RUN mkdir -p /opt/corda/logs
RUN mkdir -p /opt/corda/certificates
# Copy CorDapp JAR
COPY build/libs/trade-finance-cordapp-1.0.jar /opt/corda/cordapps/
# Copy node configuration
COPY node.conf /opt/corda/node.conf
# Set permissions
RUN chown -R corda:corda /opt/corda
USER corda
WORKDIR /opt/corda
EXPOSE 10005 10006 10007 10008 10009 10010 10011 10012 10013 10014 10015 10016
CMD ["bash", "-c", "java -jar /opt/corda/corda.jar"]

Best Practices for CorDapp Development

1. State Design:

  • Keep states focused and minimal
  • Use LinearState for evolving assets
  • Include all relevant participants
  • Consider privacy requirements

2. Contract Verification:

  • Verify all possible command types
  • Check signer requirements thoroughly
  • Validate business rules explicitly
  • Use descriptive error messages

3. Flow Development:

  • Use progress tracking for long-running flows
  • Implement proper error handling
  • Consider flow versioning
  • Test with multiple parties

4. Security Considerations:

public class SecurityBestPractices {
// Always verify transaction signatures
private void verifySigners(Set<PublicKey> requiredSigners, Set<PublicKey> actualSigners) {
if (!actualSigners.containsAll(requiredSigners)) {
throw new IllegalArgumentException("Missing required signatures");
}
}
// Validate time windows
private void validateTimeWindow(Instant timestamp, Instant expiry) {
if (timestamp.isAfter(expiry)) {
throw new IllegalArgumentException("Transaction expired");
}
}
}

Common CorDapp Patterns

1. State Evolution:

public class StateEvolution {
public LetterOfCreditState evolveState(LetterOfCreditState current, 
LetterOfCreditState.LCStatus newStatus) {
return current.withStatus(newStatus);
}
}

2. Querying the Vault:

public class VaultQueries {
public List<StateAndRef<LetterOfCreditState>> queryLCsByStatus(
ServiceHub serviceHub, LetterOfCreditState.LCStatus status) {
QueryCriteria.VaultCustomQueryCriteria criteria = 
new QueryCriteria.VaultCustomQueryCriteria(
Builder.equal(getStatusField("status"), status.name()));
return serviceHub.getVaultService()
.queryBy(LetterOfCreditState.class, criteria)
.getStates();
}
}

Conclusion

Corda CorDapp development in Java enables building enterprise-grade blockchain applications with strong privacy guarantees. Key takeaways:

  1. States: Represent shared facts with clear ownership
  2. Contracts: Enforce business rules with legal precision
  3. Flows: Coordinate complex multi-party processes
  4. Transactions: Ensure atomic updates across parties
  5. Privacy: Share data only with relevant participants

Implementation Checklist:

  • ✅ Design focused states with clear participants
  • ✅ Implement comprehensive contract verification
  • ✅ Develop robust flows with error handling
  • ✅ Create REST APIs for external integration
  • ✅ Write comprehensive tests for all components
  • ✅ Configure nodes for target environment
  • ✅ Plan for deployment and operations

Corda is particularly well-suited for:

  • Financial services applications
  • Supply chain and trade finance
  • Healthcare data sharing
  • Legal and regulatory compliance
  • Any scenario requiring privacy and legal enforceability

By following these patterns and best practices, you can build robust, secure, and scalable distributed applications on the Corda platform.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper