An Introduction to Corda Blockchain Platform with its Key Concepts

Corda is an open-source blockchain project, designed to build businesses from scratch. It enables developers to build interoperable blockchain networks that transact in strict privacy. Further, Corda's smart contract technology enables businesses to transact directly with value.

Key concepts of Corda

The Network
- Communication between nodes is point-to-point, instead of relying on global broadcasts.
- Each node has a certificate mapping their network identity to a real-world legal identity.
The Ledger
- The Corda Ledger allows for the management and synchronization of business agreements between multiple parties.
- In Corda, Ledger is a subjective construct from each peer's point of view. There are no peers who can see everything.
- Each set contains known facts. Where the sets overlap are shared facts that are stored on the Corda ledger.
States
- States are immutable objects representing shared facts such as an agreement or contract at a specific point in time.
- States represent on-ledger facts.
- States are evolved by marking the current state as historic and creating an updated state.
- Each node has a vault where it stores any relevant states to itself.
In Corda, states are instances of classes that implement ContractState.
```
interface ContractState {
    val participants: List<AbstractParty>
}
```
Transactions

Transactions facilitate the update of states onto the ledger

A transaction proposal will only be committed if:
- It doesn’t contain double-spends
- It is contractually valid
- It is signed by the required parties
Contracts
- Contracts are used to control the evolution of on-ledger states.
- In Corda Smart contracts that can be written in Java and other JVM languages.
- In Corda Contract has a single method, verify, which takes a Transaction as input.
The verification function is defined in the contract code. This is the verify method signature in Kotlin.
```
       fun verify(tx: Transaction): Unit
```
The function takes a transaction as a parameter. It will execute all of the constraints that the Cordapp developer has defined. If any of the constraints fails, it will throw an exception. If all of the constraints pass, then it will return nothing and consider the transaction which was passed in to be valid.

Also Read: Corda Blockchain: Finding its Applications in the Real World

The flow of the network Nodes (Peers) in Corda Blockchain

Flows are a series of steps required of the necessary peers to execute a transaction. Understanding the flow framework is essential to working with Corda as they reflect the core business logic of a CorDapp.

In Corda Flow are instances of classes, made of FlowLogic subclass.
```
class InitiatorFlow(val otherParty: Party): FlowLogic<Unit>() {
    @Suspendable
    override fun call() { }
}
```
To understand how flows work, let's consider Alice and Bob, who wish to agree on an IOU.

Diagram of a flow framework, continuing with Alice and Bob's IOU:

Notary

A Corda network has one or more notary clusters that provide transaction ordering and timestamping services.

Consensus

The consensus is required because different entities, individuals, or parties can try to add information to Corda nodes, distributed operators on the system must evaluate and agree on all additions before they are incorporated into their ledger.

Two types of consensus
- Validity consensus - guarantees no conflicts and ensures that a proposed transaction is valid per the contract code that governs how the shared state can evolve.
- Uniqueness consensus -guarantees that conflicting updates to the ledger can never occur, this is only checked by a notary service.
We are a blockchain development company that leverages the Corda platform's capabilities to provide Corda blockchain development services. It enables us to develop and deploy public and permissioned blockchain solutions for a range of industries and business operations.