Mastering Corda

Foreword
Preface
Conventions Used in This Book
Using Code Examples
O’Reilly Online Learning
How to Contact Us
Acknowledgments

1. Business Cases for Corda
What Is Blockchain?
Solving Double Spend
What Is Corda?
Business Cases
Decentralized Finance and Digital Assets
Tokenization
Capital Raising
Traceability and Provenance
Reconciliation Cost Reduction
Reconciliation Revenue Streams
Better AI
Enterprise Requirements
Privacy
Know Your Counterparty
Permissioning
Scalability and Performance
Integration and Developer Adoption
A Brief History of Corda
On-Ledger Versus Off-Ledger Data
Challenges to Adoption
The Critical Mass Challenge
Alternatives to Corda
Portability
Corda Enterprise
Corda Business Networks Toolkit
Wrap-Up

2. Essential Corda and Blockchain Cryptography
Understanding Hashes
The SHA-256 Hash Algorithm
Hashes in Corda
Asymmetric Cryptography
Symmetric Key Cryptography
Modern Cryptography
The Encryption Process
Combining Encryption with Hashes
Proof of Origin
Combining Encryption with Proof of Origin
Proof of Ownership of a Public Key
Key Generation Algorithms: Elliptical Curves
Corda and Keys
Digital Signatures
Corda Digital Signatures
Digital Certificates
The X.509 Digital Certificate Structure
Corda Digital Certificates
Merkle Trees
Corda Merkle Trees
Wrap-Up

3. Your First Corda Smart Contract
The Echo CorDapp
Flow Basics
High-Level Overview of the Echo CorDapp
Creating a New CorDapp Project
Loading the Template Code into IntelliJ
Overview of Scaffolding Code
The Initiator
The Responder
The Gradle Build File
Gradle Wrapper Scripts
Underlying Mechanics of the Echo CorDapp
Coding the Echo CorDapp
Coding the Responder Flow
Completing the EchoInitiatorFlow
Deploying the Echo CorDapp
Launching the Echo CorDapp
Invoking Echo Flows
Template Web App and Mock Testing
Wrap-Up

4. Blockchain Fundamentals
Apocalypse Now
Going Digital
A Digital Ledger
A Digital Asset
Digital Asset Valuation Factors
Trust the System
The Parallels
Distrust the System, Trust Algorithms
The Blockchain Symphony
Dispute Resolution
Consensus
Blockchain Components
Nodes
Network
Data Structures
Machinery in Action
Mining
Asymmetric: Work Versus Verification
Consensus, Byzantine Fault Tolerance, and Forks
Difficulty
Wrap-Up

5. Corda Fundamentals
Corda and Corda Networks
Corda Network Participants and Services
Identity Manager
Network Map Service
Notary
Oracles
Transaction Model
Transaction Finality
Consensus
Node Design and Architecture
Vault and Ledger
Node Services
Vault Service
Key Management Service
Network Service
Corda RPC
Node Technology Components
Turing-Complete Smart Contracts
Deterministic JVM
Data Storage
Messaging and Message Queue
Quasar
Corda Applications
The Corda Network
Corda Testnet
The Marketplace
Wrap-Up

6. Building a Distributed Task CorDapp
Understanding States
Aspects of States
State Transitions Between Multiple Parties
Creating States in Corda
Understanding Transactions
Transaction Inputs and Outputs
Transactions in Corda
Transaction Propagation
Flows That Manage Transactions
Building the ToDoDist CorDapp
Model and Code the ToDoState State
Creating a ToDoState on the Ledger
Running CreateToDoFlow to Create a To-Do Item
Assigning a To-Do to Another Party
Wrap-Up

7. Extending ToDoDist with Advanced States
Commands: Transaction Intent
Corda Commands
Creating Commands
Organizing Commands
Contracts: State Transition Constraints and Validations
Create a ToDo Contract
Making States Queryable
Step 1: Create a Model Class
Step 2: Create a Grouping Marker for the Versions
Step 3: Define a Schema Version of the Model
Step 4: Refactor TaskModel as an Inner Class in ToDoSchemaV1
Step 5: Implement the QueryableState Interface
Inspecting a Queryable State
Schedulable States
Requiring Signatures by a Certain Time
Corda TimeWindows
Creating To-Do Time Windows
Attaching a File to a To-Do
ToDoDist Attachment
Running AttachDocToDoInitiator
Wrap-Up

8. State Linking, Fungibility, Coin Selection, and Observers
Complex States
Linking States
Locating States on the Ledger
Linking States via StateRef
Linking States via linearId
Reference States
Publishing and Using a Reference State
Example: Stock Symbol
Fungibility
Non-fungible States
Fungible States
Coin Selection
Soft Locking
Fungible Stablecoin Cash on Ledger
Refactoring for Multiple Coin Selection and Fractional Amounts
Redemption: Burning a State
Propagating States to Observers
State Design
Wrap-Up

9. Tokens and the Token SDK
What Are Tokens?
Why Do We Use Tokens?
The Era of Tokens Is Upon Us
A Brief History of Tokens on Blockchain
Bitcoin as a Rigidly Defined Token
Ethereum: Programmable Tokens with Rigid Transactions
Corda: Coming Full Circle
Illustrating Token Fundamentals with Code
Token Ownership
Token with Owner
Types of Tokens
Controlling the Volume
Transferring Tokens Out
Transferring Tokens In
Using the Kotlin infix Operator
Non-fungible Tokens
Coding a Non-fungible Token
The Token SDK
Corda Settler and Redemption
Wrap-Up

10. Oracles and Corda Services
Corda Oracles
Prime: The Example Corda Oracle CorDapp
The Oracle Node
The Client Node
Filtered Transactions
Running the Prime Oracle
Corda Oracles with Java: The SDR Oracle
Obtaining SDR Data
Project Setup
Coding the Command Object
Coding the SDR Corda Service
The sign Method
The Client’s Initiator Flow
Running the SDR Oracle
The Economics of Oracles
Wrap-Up

11. Node Internals and Analytics
Why Python?
Quick Start
Installing PyCorda
The Python REPL
Programmatically Downloading the H2 DB Drivers
Exploring a Node
Reading the Java Keystore for a Node
Node and Vault Snapshot to File
Exploring the Vault and CorDapp
Analyzing a Transaction
Invoking the Obligation CorDapp’s API Directly from Python
Generating Tons of Transactions
Time-Series Charts
Piping Monitoring Data to Plotly
Building a Simple Monitoring Web App with PyCorda and Flask
PyCorda’s Future

12. Corda RPC and Vault Queries
CordaIQ
Obtaining a CordaRPCOps Instance
RPC Client Setup
RPC Methods
Network
Party and Public Key Query
Flows
Querying and Managing the Vault
Transaction Notes
Attachment Management
Node Management
Notary
State Machine Management
Monitoring RPC Calls
Using Jolokia
Using Hawtio
Pause and Resume via Browser
Wrap-Up

A: The Obligation CorDapp
Installing the Obligation CorDapp
B: Kotlin Cheat Sheet
Key Kotlin Points
C: Comparison Tables
D: DAML for Corda
What Is DAML?
What Is DAML for Corda?
What Does It Mean for Corda Developers?

Index