Corda is an open source blockchain project, designed for business from the start. Only Corda allows you to build interoperable blockchain networks that transact in strict privacy. Corda's smart contract technology allows businesses to transact directly, with value.
Corda DemoBench:
.profile file that can be reloaded later.Vault:
Corda Shell :
CRaSH project <http://www.crashub.org/>_ and new commands can be easily added to the node by simply dropping Groovy or Java files into the node's shell-commands directory.API changes:
The new Jackson module provides JSON/YAML serialisers for common Corda datatypes.
If you have previously been using the JSON support in the standalone web server,
please be aware that Amounts are now serialised as strings instead of { quantity, token } pairs as before.
The old format is still accepted, but the new JSON will be produced using strings like "1000.00 USD" when writing.
You can use any format supported by Amount.parseCurrency as input.
We have restructured client package in this milestone.
CordaClientRPC is now in the new :client:rpc module.:client module has been split up into :client:jfx and :client:mock.:node-api module (package net.corda.nodeapi) which contains the shared code between node and client.The basic Amount API has been upgraded to have support for advanced financial use cases and to better integrate with currency reference data.
Configuration:
artemisPort with p2pPort in Gradle configuration.artemisAddress with p2pAddress in node configuration.rpcAddress in node configuration for non-ssl RPC connection.Object Serialization:
RPC client changes:
rpcAddress rather than p2pAddress.Dependencies changes:
Improvements:
--version command line flag to print the version of the node.UntrustworthyData.unwrap.Bug fixes:
--logging-level command line flag was previously broken, now correctly sets the logging level.Changes in NodeInfo:
PhysicalLocation was renamed to WorldMapLocation to emphasise that it doesn't need to map to a truly physical
location of the node server.legalIdentitiesAndCerts were introduced. Addresses are no longer of type
SingleMessageRecipient, but of NetworkHostAndPort.ServiceHub.storageService has been removed. attachments and validatedTransactions are now direct members of
ServiceHub.
Mock identity constants used in tests, such as ALICE, BOB, DUMMY_NOTARY, have moved to net.corda.testing
in the test-utils module.
DummyContract, DummyContractV2, DummyLinearContract and DummyState have moved to net.corda.testing.contracts
in the test-utils modules.
In Java, QueryCriteriaUtilsKt has moved to QueryCriteriaUtils. Also and and or are now instance methods
of QueryCrtieria.
random63BitValue() has moved to CryptoUtils
Added additional common Sort attributes (see Sort.CommandStateAttribute) for use in Vault Query criteria
to include STATE_REF, STATE_REF_TXN_ID, STATE_REF_INDEX
Moved the core flows previously found in net.corda.flows into net.corda.core.flows. This is so that all packages
in the core module begin with net.corda.core.
FinalityFlow can now be subclassed, and the broadcastTransaction and lookupParties function can be
overriden in order to handle cases where no single transaction participant is aware of all parties, and therefore
the transaction must be relayed between participants rather than sent from a single node.
TransactionForContract has been removed and all usages of this class have been replaced with usage of
LedgerTransaction. In particular Contract.verify and the Clauses API have been changed and now take a
LedgerTransaction as passed in parameter. The prinicpal consequence of this is that the types of the input and output
collections on the transaction object have changed, so it may be necessary to map down to the ContractState
sub-properties in existing code.
Added various query methods to LedgerTransaction to simplify querying of states and commands. In the same vain
Command is now parameterised on the CommandData field.
Kotlin utilities that we deemed useful enough to keep public have been moved out of net.corda.core.Utils and into
net.corda.core.utilities.KotlinUtils. The other utilities have been marked as internal.
Changes to Cordformation/ cordapp building:
Cordformation modifies the JAR task to make cordapps build as semi fat JARs containing all dependencies
except other cordapps and Corda core dependencies.Cordformation adds a corda and cordaRuntime configuration to projects which cordapp developers should
use to exclude core Corda JARs from being built into Cordapp fat JARs.database field in AbstractNode class has changed the type from org.jetbrains.exposed.sql.Database to
‘net.corda.node.utilities.CordaPersistence’ - no change is needed for the typical use
(i.e. services.database.transaction { code block } ) however a change is required when Database was explicitly declared
DigitalSignature.LegallyIdentifiable, previously used to identify a signer (e.g. in Oracles), has been removed.
One can use the public key to derive the corresponding identity.
Vault Query improvements and fixes:
FIX inconsistent behaviour: Vault Query defaults to UNCONSUMED in all QueryCriteria types
FIX serialization error: Vault Query over RPC when using custom attributes using VaultCustomQueryCriteria.
Aggregate function support: extended VaultCustomQueryCriteria and associated DSL to enable specification of Aggregate Functions (sum, max, min, avg, count) with, optional, group by clauses and sorting (on calculated aggregate)
Pagination simplification Pagination continues to be optional, but with following changes:
VaultQueryException to alert the API user to the need to specify a PageSpecification.
Internally, we no longer need to calculate a results count (thus eliminating an expensive SQL query) unless a PageSpecification is supplied (note: that a value of -1 is returned for total_results in this scenario).
Internally, we now use the AggregateFunction capability to perform the count.Additional Sort criteria: by StateRef (or constituents: txId, index)
Confidential identities API improvements
Following our first public beta in M12, this release continues the work on API stability and user friendliness. Apart from bug fixes and code refactoring, there are also significant improvements in the Vault Query and the Identity Service. More specifically:
The long awaited new Vault Query service makes its debut in this release and provides advanced vault query capabilities using criteria specifications (see QueryCriteria), sorting, and pagination. Criteria specifications enable selective filtering with and/or composition using multiple operator primitives on standard attributes stored in Corda internal vault tables (eg. vault_states, vault_fungible_states, vault_linear_states), and also on custom contract state schemas defined by CorDapp developers when modelling new contract types. Custom queries are specifiable using a simple but sophisticated builder DSL (see QueryCriteriaUtils). The new Vault Query service is usable by flows and by RPC clients alike via two simple API functions: queryBy() and trackBy(). The former provides point-in-time snapshot queries whilst the later supplements the snapshot with dynamic streaming of updates.
We have written a comprehensive Hello, World! tutorial, showing developers how to build a CorDapp from start to finish. The tutorial shows how the core elements of a CorDapp - states, contracts and flows - fit together to allow your node to handle new business processes. It also explains how you can use our contract and flow testing frameworks to massively reduce CorDapp development time.
Certificate checks have been enabled for much of the identity service. These are part of the confidential (anonymous) identities work, and ensure that parties are actually who they claim to be by checking their certificate path back to the network trust root (certificate authority).
To deal with anonymized keys, we've also implemented a deterministic key derivation function that combines logic from the HMAC-based Extract-and-Expand Key Derivation Function (HKDF) protocol and the BIP32 hardened parent-private-key -> child-private-key scheme. This function currently supports the following algorithms: ECDSA secp256K1, ECDSA secpR1 (NIST P-256) and EdDSA ed25519. We are now very close to fully supporting anonymous identities so as to increase privacy even against validating notaries.
We have further tightened the set of objects which Corda will attempt to serialise from the stack during flow checkpointing. As flows are arbitrary code in which it is convenient to do many things, we ended up pulling in a lot of objects that didn't make sense to put in a checkpoint, such as Thread and Connection. To minimize serialization cost and increase security by not allowing certain classes to be serialized, we now support class blacklisting that will return an IllegalStateException if such a class is encountered during a checkpoint. Blacklisting supports superclass and superinterface inheritance and always precedes @ CordaSerializable annotation checking.
We've also started working on improving user experience when searching, by adding a new RPC to support fuzzy matching of X.500 names.
One of our busiest releases, lots of changes that take us closer to API stability (for more detailed information about what has changed, see https://docs.corda.r3cev.com/changelog.html). In this release we focused mainly on making developers' lives easier. Taking into account feedback from numerous training courses and meet-ups, we decided to add CollectSignaturesFlow which factors out a lot of code which CorDapp developers needed to write to get their transactions signed.
The improvement is up to 150 fewer lines of code in each flow! To have your transaction signed by different parties, you need only now call a subflow which collects the parties' signatures for you.
Additionally we introduced classpath scanning to wire-up flows automatically. Writing CorDapps has been made simpler by removing boiler-plate code that was previously required when registering flows. Writing services such as oracles has also been simplified.
We made substantial RPC performance improvements (please note that this is separate to node performance, we are focusing on that area in future milestones):
Security of the key management service has been improved by removing support for extracting private keys, in order that it can support use of a hardware security module (HSM) for key storage. Instead it exposes functionality for signing data (typically transactions). The service now also supports multiple signature schemes (not just EdDSA).
We've added the beginnings of flow versioning. Nodes now reject flow requests if the initiating side is not using the same flow version. In a future milestone release will add the ability to support backwards compatibility.
As with the previous few releases we have continued work extending identity support. There are major changes to the Party class as part of confidential identities, and how parties and keys are stored in transaction state objects.
Added new Byzantine fault tolerant (BFT) decentralised notary demo, based on the BFT-SMaRT protocol
We continued to work on tools that enable diagnostics on the node. The newest addition to Corda Shell is flow watch command which lets the administrator see all flows currently running with result or error information as well as who is the flow initiator.
We have also started work on the strategic wire format (not integrated).