• R3 Corda is a distributed ledger platform for permissioned networks, inspired by blockchain technology.

•Designed specifically considering requirements of  financial use cases

•A distributed ledger, but no blockchain

•Designed for data privacy

•Corda opened sourced on nov 2016.

•R3 offers corda  enterprise edition:

  •    -Compatible with open sourced corda.
  •    -High availability and performance.
  •    -Enhanced security by leveraging intel’s                
  •       SGX and integration with HSM for key
  •        management.
  •    -Modular database such as SQL  server,  
  •        oracle and SQL   Azure.
  •    -LDAP and active  directory integration.

•R3 is a consortium of more than 60 of the world’s  biggest financial institutions.

•R3 partnered with microsoft to offer corda on Azure.


Element of a legal agreement(state)

Issue:- Australia and New Zealand banking group     

Beneficiary: Scentre group application: Smith co

Parties (Identities, private ledger)

Time (Time window)        
 -Before (expiry)         
-after (maturity data)         
 -with in period
Amount $….Effective date               

-from may 10th 2018               
-to may  10th 2020
External facts and conditions that

the contract

(oracle)corporate action,

Interest rates, share price,

bankruptcy, fx conversion etc.
Interest :..%      
           Amount payable to be   
computed based on  
share price as of….

Witness(notaries, observers) 
Terms and conditions (legal prose)
Supporting documentation (attachment)




Amendment novation  renewal etc



In foundational concept, r3 is founder and Corda creators they felt that with financial services use case legal agreements are a critical part of these use cases.

So this could be an agreement between banks on how they are going to operate on the assumption of liability and risk.

It could be regulatory that a given agreement may be between a regulator and a bank.

So they want to associate a smart contract with the legal agreement.in Corda, they consider the code and the legal agreement as two distinct aspects.

The code is something that tries to support what is mentioned in the legal agreement but is not is distinct from the legal agreement.but is not distinct from the legal agreement So the legal agreement is acceptable in a court of law.

But the smart contract code and the distributed ledger information can support a legal agreement but it is not really legally admissible. So elements of a legal agreement to be captured as a document can be stored together with the smart contract.

This is optional but typically there is a legal agreement that goes together with a smart contract, whether it is a bond issuance or anything else.there are legal agreements associated with the smart contracts.

So the parties of the agreement are specified.

The time window is for when the contract is valid. So, what is valid before particular expiry date or until a particular maturity date maybe there is an agreement.

There is maturity date for it or the duration of a period of time. There could be external facts and conditions that govern the contract and these facts may be provided by oracles.

Oracle is also a first-class entity in Corda. These external facts can be various it could be particular interest rates that are fixed, it could be share price that changes over time, but it is fixed for foreign exchange conversion there in many different notions of external facts that might influence a contract, and these external facts are provided to the contract through trusted oracles that could be witnesses.

There are terms and conditions of the contract that could be in legal prose and there could always be supporting documents and attachments along with the legal agreement.

And you can actually track the life cycle of the agreement itself from creation to the amendment to actual execution of the agreement to an exit. where the agreement is no longer valid.

So all of this is captured as a legal agreement and goes together with a smart contract.


Corda is a peer to peer network, where we can there are multiple entities of this network.

Let us say, Alice, Bob, and Charlie could be banks or it could be financial institutions could be others who are part of this Corda network. There are other entities like notaries and oracles.

sO all the message exchange between peers as well as notaries and oracle all of them happen over TLS encrypted messages sent over AMQP. as I mentioned there is a Doorman service.

The Doorman service is the one that is going to do some form of KYC to know your customer.

They will make sure these are legitimate entities and they require access into this network they need to be part of this Corda network and the doorman once it is approved this entity for access you then issues an identity based on a TLS and this is from a permissioning service.

Creates the cert for the participating entities. So this is how the permissioning itself works.

There is a Doorman service providing KYC and there is the permission service that issues the certificates itself once the doorman service enrolls it.

There is a network map service that maps entities to their peer IP addresses as well as their identity. 

So this is how people will know which entities are part of the system, how do I send a message to another peer, what is the IP address on which I should send it, what is the certificate that I should address it by.

So all that is captured in a network map service that is maintained by the network and anyone can query it.

So the Corda and node itself as I mentioned runs on a java virtual machine all the state information is and is stored in an RDBMS it is a relational database.

There is an AMQP messaging service that is how peer to peer message exchanges happen.

Then there could be one or more Corda services and then Corda applications that are running in this in a single node.


•Shared facts are represented by states using a UTXO state-machine model.

•States are similar to Bitcoin transactions, but can represent arbitrary data.

•States are immutable and represent a shared fact at a specific point in time.

•States evolve by allowing new states to replace old states, resulting in a state sequence.

In the transaction model, so Corda use the UTXO model, in each time a new transaction is created it has a reference back to a previous transaction that is unspent and then the previous once a new transaction is created the previous transaction is marked as historic the historic basically is synonymous with being consumed or that transaction being spent.

And this provides a full audit trail. So because of these links from one state to another, you can have a full audit trail of all of these agreements over a period of time. So far, if there is your maintaining balance in some sense Alice balances.

So you could have a transaction where Alice pays Bobs Alice borrows money from Bob and then  Alice may repay a part of that money.

So all of these are recorded as independent transactions and as a new transaction gets added the previous transaction that it is referred to is marked as a spender.

This is very similar to the UTXO model except that each of these transactions is going to hold state.

The states apart from unlike bitcoin although this UTXO, unlike bitcoin where bitcoin-only refer to bitcoin input and bitcoin output here you can really in your state information you can actually have arbitrary data.

So this can really refer to maybe a table in your database and have data pertaining to different rows and columns of that table, so arbitrary data can be captured as part of the state but as in when the state gets modified previous states are linked and they are marked as historic.

So that way states once they are historic they are immutable And represent a shared fact.

So as in when states get created, they are all immutable so again it is an append-only log of transaction but it is just that it is not a globally synchronized log it is that all nodes are not maintaining a single blockchain in some sense.

So this is just a pictorial view of how UTXO works. This is input and output again but just that input and output can have arbitrary data.


•No global broadcast : Point to Point transactions between parties ensures data received and stored only by parties with a legitimate need to know.

•No blockchain.

•UTXO state –machine model

    -not based on account model (fabric  and ethereum)

•Identity issuance on the network controlled by a trusted ‘Door man’ service

•All communication between nodes is direct, with TLS –encrypted messages sent over AMQP/1.0. there are no global broadcasts.

•Relational  database for the ledger entries.

•JVM- based, written in kotlin. Contracts Can be written in JVM-based languages such as  kotlin, scala, java.


• R3 is creating a global shared network for      interoperability of permissioned corda networks

    -privacy of permissioned networks, with with

      Interoperability of public networks.

• A corda network exists within an interopera-

      bility zone and can transact with other nodes in a


  • –  The global interoperability zone allows 
  •         nodes to transact across different zones
  • –  Global corda network allows assets to
  •         flow across different zones.

• Corda 3.0 delivered stable wire


  • –  Future releases of corda will be
  •         backward compatible at the network
  •      Layer. 


•Each node on the network maintains a vault – a database where it tracks all the current and historic states  that it is aware of.

•Vaults are currently based on the H2 embedded SQL engine. Other databases supporting JDBC are planned.

The current state of the ledger comprises all unconsumed transactions.

Corda allows for fine –grained access control  at the level of the state-sequence.

In fabric, data  partitioning is managed at the level of channels and collections (side DB)


The ledger is subjective from each peer’s perspective and is a union of all facts the peer’s perspective and is a union of all facts the peer intersects with (including facts that are not shared). There is no global broadcast. The whole ledger is everything that’s on ledgerP: {1,7,6,5,9,4,3,2,8}.

No account:  allows for transactions to be applied in parallel.

Transaction ordering:  transactions odering is enforced by hash functions that identity previous states.

Consensus: conflict is a double spend problem.

Fabric is based on a broadcast architecture. Corda takes a need-to-know approach.

In corda, there’s no trace of private multilateral transaction on a ‘main-chain’

What is contracts in r3 corda

•contracts  can be  written in any jvm language (java,  kotlin  etc) and are  executed  in a sandbox (modified  version of JVM).

•Contract code must be deterministic  (eg. No reference external  information)and produce the same result on all peers.

  • -Determinism guaranteed by sandbox.
  •      -Determinism ensures contract code returns the  same  results across all peers. 

•Contract code can only access data in the supplied transaction, nothing  else.

•Deployed on all peers that are party to the agreement.

•A transaction may have multiple states that refer to multiple  contracts (e.g. transaction for swapping  BOND  for Cash).

Contracts  can also refer  to a legal  prose  document, to explicity state  the rules  governing the evolution of  the ledger in case  of legal disputes.

Corda has made the notion  of “code is Not law” explicit, by allowing a contract  to refer to a legal prose that serves as a reference  to the real-world legal  agreement between parties  should disputes arise.

Corda has made the notion  of “code is Not law” explicit, by allowing a contract  to refer to a legal prose that serves as a reference  to the real-world legal  agreement between parties  should disputes arise

What is transaction in r3 corda

•Transactions reference zero or more input states and  create zero or more output states .

•The newly created  output states replace the inputs states which are marked as historic.

There are three broad types of change which can be facilitated by transactions:




Corda has made the notion  of “code is Not law” explicit, by allowing a contract  to refer to a legal prose that serves as a reference  to the real-world legal  agreement between parties  should disputes arise.

Corda has made the notion of “code is Not law” explicit, by allowing a contract to refer to legal prose that serves as a reference to the real-world legal agreement between parties should dispute arise.


 In transaction look like. Transaction reference zero or more input states. And creates zero or more output states.

This is very similar to bitcoin except that the state can have arbitrary information.

Newly created output states mark the input states as historic. There are three broad types of exchanges or transactions.

That is specified by Corda. So these are issuance, updates, and exits.

It could be an issuance transaction where a new state is created from nothing.

Only these entities issue an issuance transaction as fine-grained access control.

Only a bank can issue let us say a financial instrument. So then that issuance is created and then the next one may be an update.

So the state can go from S0 to S1 and then that will mark the previous S0 as historic. So that is again just basic use UTXO.

and finally, you could have an exit transaction where an input state is basically expired or matured basically it is a financial instrument that is now no longer valid.

So you can exit. So that is also possible.



Leave a Comment