Corda V1.0

• Java 8 serializable lambdas now work property with Kryo during check-pointing.

• String constants have been marked as const type in Kotlin, eliminating cases where functions of the form
  get<constant name>() were created for the Java API. These can now be referenced by their name directly.

• FlowLogic communication has been extensively rewritten to use functions on FlowSession as the base for communication
  between nodes.

  • Calls to send(), receive() and sendAndReceive() on FlowLogic should be replaced with calls
    to the function of the same name on FlowSession. Note that the replacement functions do not take in a destination
    parameter, as this is defined in the session.
  • Initiated flows now take in a FlowSession instead of Party in their constructor. If you need to access the
    counterparty identity, it is in the counterparty property of the flow session.

• Added X509EdDSAEngine to intercept and rewrite EdDSA public keys wrapped in X509Key instances. This corrects an issue
  with verifying certificate paths loaded from a Java Keystore where they contain EdDSA keys.

• Confidential identities are now complete:

  • The identity negotiation flow is now called SwapIdentitiesFlow, renamed from TransactionKeyFlow.
  • generateSpend() now creates a new confidential identity for the change address rather than using the identity of the
    input state owner.
  • Please see the documentation :doc:key-concepts-identity and :doc:api-identity for more details.

• Remove the legacy web front end from the SIMM demo.

• NodeInfo and NetworkMapCache changes:

  • Removed NodeInfo::legalIdentity in preparation for handling of multiple identities. We left list of NodeInfo::legalIdentitiesAndCerts,
    the first identity still plays a special role of main node identity.
  • We no longer support advertising services in network map. Removed NodeInfo::advertisedServices, serviceIdentities
    and notaryIdentity.
  • Removed service methods from NetworkMapCache: partyNodes, networkMapNodes, notaryNodes, regulatorNodes,
    getNodesWithService, getPeersWithService, getRecommended, getNodesByAdvertisedServiceIdentityKey, getAnyNotary,
    notaryNode, getAnyServiceOfType. To get all known NodeInfos call allNodes.
  • In preparation for NetworkMapService redesign and distributing notaries through NetworkParameters we added
    NetworkMapCache::notaryIdentities list to enable to lookup for notary parties known to the network. Related CordaRPCOps::notaryIdentities
    was introduced. Other special nodes parties like Oracles or Regulators need to be specified directly in CorDapp or flow.
  • Moved ServiceType and ServiceInfo to net.corda.nodeapi package as services are only required on node startup.

• Adding enum support to the class carpenter

• ContractState::contract has been moved TransactionState::contract and it's type has changed to String in order to
  support dynamic classloading of contract and contract constraints.

• CorDapps that contain contracts are now automatically loaded into the attachment storage - for CorDapp developers this
  now means that contracts should be stored in separate JARs to flows, services and utilities to avoid large JARs being
  auto imported to the attachment store.

• About half of the code in test-utils has been moved to a new module node-driver,
  and the test scope modules are now located in a testing directory.

• CordaPluginRegistry has been renamed to SerializationWhitelist and moved to the net.corda.core.serialization
  package. The API for whitelisting types that can't be annotated was slightly simplified. This class used to contain
  many things, but as we switched to annotations and classpath scanning over time it hollowed out until this was
  the only functionality left. You also need to rename your services resource file to the new class name.
  An associated property on MockNode was renamed from testPluginRegistries to testSerializationWhitelists.

• Contract Upgrades: deprecated RPC authorisation / deauthorisation API calls in favour of equivalent flows in ContractUpgradeFlow.
  Implemented contract upgrade persistence using JDBC backed persistent map.

• Vault query common attributes (state status and contract state types) are now handled correctly when using composite
  criteria specifications. State status is overridable. Contract states types are aggregatable.

• Cash selection algorithm is now pluggable (with H2 being the default implementation)

• Removed usage of Requery ORM library (repalced with JPA/Hibernate)

• Vault Query performance improvement (replaced expensive per query SQL statement to obtain concrete state types
  with single query on start-up followed by dynamic updates using vault state observable))

• Vault Query fix: filter by multiple issuer names in FungibleAssetQueryCriteria

• Following deprecated methods have been removed:

  • In DataFeed
    • first and current, replaced by snapshot
    • second and future, replaced by updates
  • In CordaRPCOps
    • stateMachinesAndUpdates, replaced by stateMachinesFeed
    • verifiedTransactions, replaced by verifiedTransactionsFeed
    • stateMachineRecordedTransactionMapping, replaced by stateMachineRecordedTransactionMappingFeed
    • networkMapUpdates, replaced by networkMapFeed

• Due to security concerns and the need to remove the concept of state relevancy (which isn't needed in Corda),
  ResolveTransactionsFlow has been made internal. Instead merge the receipt of the SignedTransaction and the subsequent
  sub-flow call to ResolveTransactionsFlow with a single call to ReceiveTransactionFlow. The flow running on the counterparty
  must use SendTransactionFlow at the correct place. There is also ReceiveStateAndRefFlow and SendStateAndRefFlow for
  dealing with StateAndRefs.

• Vault query soft locking enhancements and deprecations

  • removed original VaultService ``softLockedStates` query mechanism.
  • introduced improved SoftLockingCondition filterable attribute in VaultQueryCriteria to enable specification
    of different soft locking retrieval behaviours (exclusive of soft locked states, soft locked states only, specified
    by set of lock ids)

• Trader demo now issues cash and commercial paper directly from the bank node, rather than the seller node self-issuing
  commercial paper but labelling it as if issued by the bank.

• Merged handling of well known and confidential identities in the identity service. Registration now takes in an identity
  (either type) plus supporting certificate path, and de-anonymisation simply returns the issuing identity where known.
  If you specifically need well known identities, use the network map, which is the authoritative source of current well
  known identities.

• Currency-related API in net.corda.core.contracts.ContractsDSL has moved to ```net.corda.finance.CurrencyUtils`.

• Remove IssuerFlow as it allowed nodes to request arbitrary amounts of cash to be issued from any remote node. Use
  CashIssueFlow instead.

• Some utility/extension functions (sumOrThrow, sumOrNull, sumOrZero on Amount and Commodity)
  have moved to be static methods on the classes themselves. This improves the API for Java users who no longer
  have to see or known about file-level FooKt style classes generated by the Kotlin compile, but means that IntelliJ
  no longer auto-suggests these extension functions in completion unless you add import lines for them yourself
  (this is Kotlin IDE bug KT-15286).

• :finance module now acting as a CorDapp with regard to flow registration, schemas and serializable types.

• WebServerPluginRegistry now has a customizeJSONSerialization which can be overridden to extend the REST JSON
  serializers. In particular the IRS demos must now register the BusinessCalendar serializers.

• Moved :finance gradle project files into a net.corda.finance package namespace.
  This may require adjusting imports of Cash flow references and also of StartFlow permission in gradle.build files.

• Removed the concept of relevancy from LinearState. The ContractState's relevancy to the vault can be determined
  by the flow context, the vault will process any transaction from a flow which is not derived from transaction resolution verification.

• Removed the tolerance attribute from TimeWindowChecker and thus, there is no extra tolerance on the notary side anymore.

• The FungibleAsset interface has been made simpler. The Commands grouping interface
  that included the Move, Issue and Exit interfaces have all been removed, while the move function has
  been renamed to withNewOwnerAndAmount to be consistent with the withNewOwner function of the OwnableState.

• The IssueCommand interface has been removed from Structures, because, due to the introduction of nonces per
  transaction component, the issue command does not need a nonce anymore and it does not require any other attributes.

• As a consequence of the above and the simpler FungibleAsset format, fungible assets like Cash now use
  class Issue : TypeOnlyCommandData(), because it's only its presence (Issue) that matters.

• A new PrivacySalt transaction component is introduced, which is now an attribute in TraversableTransaction and
  inherently in WireTransaction.

• A new nonces: List<SecureHash> feature has been added to FilteredLeaves.

• Due to the nonces and PrivacySalt introduction, new functions have been added to MerkleTransaction:
  fun <T : Any> serializedHash(x: T, privacySalt: PrivacySalt?, index: Int): SecureHash
fun <T : Any> serializedHash(x: T, nonce: SecureHash): SecureHash
fun computeNonce(privacySalt: PrivacySalt, index: Int).

• A new SignatureMetadata data class is introduced with two attributes, platformVersion: Int and
  schemeNumberID: Int (the signature scheme used).

• As part of the metadata support in signatures, a new data class SignableData(val txId: SecureHash, val signatureMetadata: SignatureMetadata)
  is introduced, which represents the object actually signed.

• The unused MetaData and SignatureType in crypto package have been removed.

• The class TransactionSignature(bytes: ByteArray, val by: PublicKey, val signatureMetadata: SignatureMetadata): DigitalSignature(bytes)
  class is now utilised Vs the old DigitalSignature.WithKey for Corda transaction signatures. Practically, it takes
  the signatureMetadata as an extra input, in order to support signing both the transaction and the extra metadata.

• To reflect changes in the signing process, the Crypto object is now equipped with the:
  fun doSign(keyPair: KeyPair, signableData: SignableData): TransactionSignature and
  fun doVerify(txId: SecureHash, transactionSignature: TransactionSignature): Boolean functions.

• ``SerializationCustomization.addToWhitelist()` now accepts multiple classes via varargs.

• Two functions to easily sign a FilteredTransaction have been added to ServiceHub:
  createSignature(filteredTransaction: FilteredTransaction, publicKey: PublicKey) and
  createSignature(filteredTransaction: FilteredTransaction) to sign with the legal identity key.

• A new helper method buildFilteredTransaction(filtering: Predicate<Any>) is added to SignedTransaction to
  directly build a FilteredTransaction using provided filtering functions, without first accessing the
  tx: WireTransaction.

• Test type NodeHandle now has method stop(): CordaFuture<Unit> that terminates the referenced node.

• Fixed some issues in IRS demo:

  • Fixed leg and floating leg notional amounts were not displayed for created deals neither in single nor in list view.
  • Parties were not displayed for created deals in single view.
  • Non-default notional amounts caused the creation of new deals to fail.

.. warning:: Renamed configuration property key basedir to baseDirectory. This will require updating existing configuration files.

• Removed deprecated parts of the API.

• Removed PluginServiceHub. Replace with ServiceHub for @CordaService constructors.

• X509CertificateHolder has been removed from the public API, replaced by java.security.X509Certificate.

• Moved CityDatabase out of core and into finance

• All of the serializedHash and computeNonce functions have been removed from MerkleTransaction.
  The serializedHash(x: T) and computeNonce were moved to CryptoUtils.

• Two overloaded methods componentHash(opaqueBytes: OpaqueBytes, privacySalt: PrivacySalt, componentGroupIndex: Int, internalIndex: Int): SecureHash and componentHash(nonce: SecureHash, opaqueBytes: OpaqueBytes): SecureHash have
  been added to CryptoUtils. Similarly to computeNonce, they internally use SHA256d for nonce and leaf hash
  computations.

• The verify(node: PartialTree, usedHashes: MutableList<SecureHash>): SecureHash in PartialMerkleTree has been
  renamed to rootAndUsedHashes and is now public, as it is required in the verify function of FilteredTransaction.

• TraversableTransaction is now an abstract class extending CoreTransaction. WireTransaction and
  FilteredTransaction now extend TraversableTransaction.

• Two classes, ComponentGroup(open val groupIndex: Int, open val components: List<OpaqueBytes>) and
  FilteredComponentGroup(override val groupIndex: Int, override val components: List<OpaqueBytes>, val nonces: List<SecureHash>, val partialMerkleTree: PartialMerkleTree): ComponentGroup(groupIndex, components)
  have been added, which are properties of the WireTransaction and FilteredTransaction, respectively.

• checkAllComponentsVisible(componentGroupEnum: ComponentGroupEnum) is added to FilteredTransaction, a new
  function to check if all components are visible in a specific component-group.

• To allow for backwards compatibility, WireTransaction and FilteredTransaction have new fields and
  constructors: WireTransaction(componentGroups: List<ComponentGroup>, privacySalt: PrivacySalt = PrivacySalt()),
  FilteredTransaction private constructor(id: SecureHash,filteredComponentGroups: List<FilteredComponentGroup>, groupHashes: List<SecureHash>. FilteredTransaction is still built via
  ``buildFilteredTransaction(wtx: WireTransaction, filtering: Predicate).

• FilteredLeaves class have been removed and as a result we can directly call the components from
  FilteredTransaction, such as ftx.inputs Vs the old ftx.filteredLeaves.inputs.

• A new ComponentGroupEnum is added with the following enum items: INPUTS_GROUP, OUTPUTS_GROUP,
  COMMANDS_GROUP, ATTACHMENTS_GROUP, NOTARY_GROUP, TIMEWINDOW_GROUP.

• ContractUpgradeFlow.Initiator has been renamed to ContractUpgradeFlow.Initiate

• @RPCSinceVersion, RPCException and PermissionException have moved to net.corda.client.rpc.