Skip to content

@canton-machine canton-machine released this Aug 11, 2021

Release of Canton 0.27.0

Canton 0.27.0 has been released on August 11, 2021. You can download the Community edition from our github release section. The Enterprise edition is available on Artifactory.
Please also consult the full documentation of this release.

Summary

This release adds new features and important stability improvements. The biggest
new feature is the support of Daml
Exceptions

in Canton! We improved the elastic deployment of horizontally scalable sequencer
nodes for performance and high availability. And many more stability and
internal improvements.

What’s New

Daml Exceptions

Canton now supports Daml
Exceptions
,
which have been added to Daml in previous versions to express the rollback of
parts of a transaction under failures.

Impact and Migration

Canton now only supports Daml-LF versions of 1.14 above. Please rebuild your
DARs using the Daml SDK 1.16.0 .

Horizontally Scalable Sequencers

We have improved the deployment of horizontally scalable
sequencers
,
in particular when deploying sequencer nodes in a dynamic environment. New
sequencer nodes can be deployed dynamically and they will replace failed
sequencer nodes and take over their shards. This is an enterprise-only feature.

Topology Management

We replaced a Daml-based package management workflow between participant nodes
with topology transactions, thereby reducing complexity and improving
performance. We also added commands to authorize the usage of a
package
.

Impact and Migration

The parameter waitUntilPackagesReady in package/Dar related commands has been
replaced by synchronizeVetting.

The command packages.upload has been removed, use either dars.upload or
ledger_api.packages.upload_dar instead.

Minor Improvements

  • If a participant crashes during pruning, the participant will log a warning after restart.
    The operator may then decide to prune again or to proceed with a partially pruned state.
  • The submissions sent to the sequencer are slightly smaller as messages with the same content and
    different recipient groups are now sent only once to the sequencer.
  • Hardening of our storage layer under failures and retries.
  • Added configuration validation to detect mistakes (shared storage
    configuration between nodes without replication enabled, correct storage configuration for HA nodes)

Compatibility

Dependency Version
Java Runtime OpenJDK 64-Bit Server VM 18.9 (build 11.0.12+7, mixed mode, sharing)
Daml SDK 1.16.0
Postgres postgres (PostgreSQL) 11.11 (Debian 11.11-1.pgdg90+1)
CCF 0.14.2
Ethereum besu/v20.10.4/linux-x86_64/oracle_openjdk-java-11
Fabric 2.2.2

What's Coming

We are currently working on

  • Oracle database support and performance
  • Improving stability and long-running behaviour.
  • Increase negative test coverage and improve our ability to deal with other outages.
  • Supporting large number of participants and parties with privacy.
  • Better error codes and fault documentation.
  • Support for causality enforcement.
Assets 4

@canton-machine canton-machine released this Jul 15, 2021

Release of Canton 0.26.0

Canton 0.26.0 has been released on July 15, 2021. You can download the Community edition from our github release section. The Enterprise edition is available on Artifactory.
Please also consult the full documentation of this release.

Summary

We've added a few important features to keep a participant node happy. First, we've added backpressure which will now ensure that a participant can not easily be overloaded by sending too many commands at once.
Then, we've cleaned up how the config includes work, ensuring a consistent order of which config option comes into effect if something has been configured twice.
And many more small changes to improve the user experience and stability of the system.

Please note that this version does not yet support Daml-LF 1.14 (Daml Exceptions).

What’s New

Simple Backpressure Support

Background

Up to now, if a participant receives more requests than it can handle within the participant response time out, most or all commands will timeout and therefore not be committed to the ledger.
Previously, the participant would have consumed a high amount of resources without achieving anything useful. This is now prevented using backpressure.

Specific Changes

We've added a command <participant-name>.resources.set_resource_limits that allows for imposing a limit on the number of dirty requests and the maximum rate of commands.
While one of these limits is attained or exceeded, the participant will reject any submission with GRPC status ABORTED. Most importantly, a submission will be rejected before it consumes a significant amount of resources.

The number of dirty requests covers requests initiated by the same participant as well as requests initiated by other participants. Compared to the maximum rate, it does more accurately reflect the load on the participant.
However, the maximum number of dirty requests alone does not protect the system from "bursts":
If an application submits a huge number of commands at once, the maximum number of dirty requests will likely be exceeded.
To protect a participant against "bursts", you should also configure a maximum rate.

Resource limits can only be changed if the server runs Canton enterprise. In the community edition, the server has a fixed limit of 10 transactions per second that cannot be changed.

Impact and Migration

The change has no impact on existing Canton deployments.

Config File Precedence

Background

Currently, if a key is defined twice in the Canton config, there are different conventions on which definition is taken.
If you define:

field = 1
field = 2

then Canton will assume field = 2. So the last definition "wins".

The same behavior occurs, if you define field in two different included files:

c1.conf:
field = 1

c2.conf
field = 2

main.conf:
include("c1.conf")
include("c2.conf")

Again, if Canton is started with main.conf, Canton will assume field = 2.

In contrast, if Canton has been started with --config c1.conf --config c2.conf, a previous Canton release will assume field = 1.

Specific Changes

When Canton is started with several configuration files (i.e., --config c1.conf ... -config cn.conf), then later definitions will override earlier definitions with the same key.
Consequently, the latest definition now always has the highest precedence, independently of whether definitions occur in the same file, in different included files or in different files loaded as separate --config parameters.

Impact and Migration

If you start Canton with several configuration files (i.e., --config c1.conf ... -config cn.conf), you should reverse the order of the --config parameters.
No action is required if the keys loaded by your config files are pairwise different.

Health Commands

We have improved the health commands. The health.status command is now present on all node types, not only on participant and domain as before.
Additionally, we've replaced the command identity.initialized with a set of new commands:

  • health.running to indicate that the node has started (but might not yet be initialized)
  • health.initialized to indicate that the node has been successfully initialized
  • health.wait_for_running and health.wait_for_initialized to wait for one of the above conditions.

Minor Improvements

  • We've removed the console command participant.pruning.find_safe_timestamp in favor of new command participant.pruning.find_safe_offset
  • We've renamed the config parameter my-remote-node.my-api.tls.cert-chain-file to my-remote-node.my-api.tls.trust-collection-file.

Security and Bugfixes

  • We resolved an issue that prevented a participant to connect to a domain that has the same unique identifier as the participant.
  • We've improved the validation of values saved in the Canton backend: all relevant strings (identifiers, aliases, party names etc.) are now enforced to have an upper limit of characters. This validation happens mainly on the server side: after Canton receives Api calls through the Ledger Api server or the Admin Api. This change prevents truncation errors when storing these strings in a database.

Compatibility

Dependency Version
Java Runtime OpenJDK 64-Bit Server VM 18.9 (build 11.0.11+9, mixed mode, sharing)
DAML SDK 1.15.0
Postgres postgres (PostgreSQL) 11.12 (Debian 11.12-1.pgdg90+1)
CCF 0.14.2
Ethereum besu/v20.10.4/linux-x86_64/oracle_openjdk-java-11
Fabric 2.2.2

What's Coming

We are currently working on

  • Support for DAML exceptions
  • Oracle database support
  • Improving stability and long-running behaviour.
  • Increase negative test coverage and improve our ability to deal with other outages.
  • Supporting large number of participants and parties with privacy.
  • Better error codes and fault documentation.
  • Support for causality enforcement.
Assets 4

@canton-machine canton-machine released this Jun 22, 2021

Release of Canton 0.25.0

Canton 0.25.0 has been released on June 22, 2021. You can download the Community edition from our github release section. The Enterprise edition is available on Artifactory.
Please also consult the full documentation of this release.

Summary

This release is an important step towards our general availability deadline, featuring improved
domain operational procedures, domain high availability and much better error reporting.

What’s New

Domain Entity Onboarding

We have been redesigning how domains are initialized and how new domain entities are
onboarded to a running system. Previously, the process was hard-coded and internal to Canton.
We now generalised this process and moved it into a set of console commands.

The new set of commands allows now to bootstrap a domain with multiple sequencers, add
new sequencers on the fly to a running domain, or add new mediators for high-availability
purposes.

A side benefit of the domain entity onboarding overhaul is that the Postgres and Oracle domain integrations
in the Enterprise release now support multiple sequencer processes, providing active-active domain
high availability.

Configuration Changes

There have been a few changes to how Canton can be configured:

We've discontinued the configuration parameter canton.<node-type>.<node-name>.storage.database-name as
it didn't work well across different database connectivity configurations.
Instead, use canton.<node-type>.<node-name>.storage.config.properties.database-name (postgres only) or
canton.<node-type>.<node-name>.storage.config.url to set the database name.
See the examples in 03-advanced-configuration for further information on how to set database names.

We've introduced a new config parameter canton.<node-type>.<node-name>.storage.max-connections.
It allows for setting the maximum number of db connection for that node. For participant
nodes, it will automatically split the specified number of connections between Canton,
ledger api server, and indexer.

The new parameter has lower precedence than the existing low-level parameter
canton.<node-type>.<node-name>.storage.config.num-threads; so if the low-level parameter has been defined in
existing deployments, the number of connections won't change.

Improved Error Reporting

Canton now increasingly provides error messages with error codes on failures. The error codes
are documented in the corresponding error code section of our manual.
Each error code contains information whether an error is fatal or retryable, which should allow
any application to automatically classify the errors accordingly.

In particular, the ledger Api command submission service will now report many errors synchronously with detailed error
messages. However, this is still a preview feature and we'll polish the experience according to the user
feedback we get.

Minor Improvements

  • We've added the utils.generate_daml_script_participants_conf macro to export participants config for Daml script.
    This should improve the user experience when using Daml script with Canton, as you can generate a Daml script
    input configuration from a Canton process.
  • We've extended pruning to the sequencer and mediator stores.
    You can now keep your domain tidy and remove archived data by invoking the pruning commands on the domain.

Security and Bugfixes

  • Eliminated a race condition when handling sequenced events from the domain that could crash a participant.

Compatibility

Dependency Version
Java Runtime OpenJDK 64-Bit Server VM 18.9 (build 11.0.11+9, mixed mode, sharing)
DAML SDK 1.14.0
Postgres postgres (PostgreSQL) 11.12 (Debian 11.12-1.pgdg90+1)
CCF 0.14.2
Ethereum besu/v20.10.4/linux-x86_64/oracle_openjdk-java-11
Fabric 2.2.2

What's Coming

We are currently working on

  • Oracle database support
  • Improving stability and long-running behaviour, in particular with pruning.
  • Increase negative test coverage and improve our ability to deal with other outages.
  • Supporting large number of participants and parties with privacy.
  • Better error codes and fault documentation.
  • Support for causality enforcement.
Assets 4

@canton-machine canton-machine released this May 17, 2021

Release of Canton 0.24.0

Canton 0.24.0 has been released on May 17, 2021. You can download the Community edition from our github release section. The Enterprise edition is available on Artifactory.
Please also consult the full documentation of this release.

Summary

This version focuses mostly on preview features. In particular, we have added initial support for participant
high-availability and Oracle storage backend support to our enterprise version. We've also made repair work with dirty
requests.

What’s New

Participant High Availability

You can now configure the enterprise version to run with replicated participants. This is only a preview feature.
Please consult the manual on how to configure it and how it works.

Repair with Dirty Requests

The repair commands allow you to recover from data corruption and system malfunction by manually adjusting your contract
stores, as described in our user manual.
Until now, repair was only able to work on quiet domains without in-flight requests. We have improved this such that repair can be used even on domains with in-flight processing.

Oracle Support

The storage driver now supports a new storage backend: Oracle databases. However, support is currently alpha only and only available in our Enterprise release.

Minor Improvements

  • Ability to configure max inbound message size on all APIs as described in our user manual.
  • Fixed a bug that prevented writing log messages to the log file after shutdown of Canton had been initiated.

Preview Features

  • You might have noticed our new section on error codes on our website. We are currently working on providing exhaustive documentation on errors and their resolution. However, we are in the process of this cleanup and not all errors are yet in the newly documented form.

Security and Bugfixes

  • There is no security or bugfix worth mentioning in this release.

Compatibility

Dependency Version
Java Runtime OpenJDK 64-Bit Server VM 18.9 (build 11.0.11+9, mixed mode, sharing)
DAML SDK 1.13.1
Postgres postgres (PostgreSQL) 11.12 (Debian 11.12-1.pgdg90+1)
CCF 0.14.2
Ethereum besu/v20.10.4/linux-x86_64/oracle_openjdk-java-11
Fabric 2.2.2

What's Coming

We are currently working on

  • Improving stability and long-running behaviour, in particular with pruning.
  • Increase negative test coverage and improve our ability to deal with other outages.
  • Supporting large number of participants and parties with privacy.
  • Better error codes and fault documentation.
  • Support for causality enforcement.
Assets 4

@canton-machine canton-machine released this Apr 15, 2021

Release of Canton 0.23.0

Canton 0.23.0 has been released on April 15, 2021. You can download the Community edition from our github release section. The Enterprise edition is available on Artifactory.
Please also consult the full documentation of this release.

Summary

This is a new and exciting release with quite a few improvements around production readiness.
We are now following the Daml release schedule and pin ourselves to the public Daml releases, we've added span reporting, various performance and scale improvements, reworked how logging is configured, and we improved our pruning capabilities.

What’s New

New Release Cadence

Before, Canton was using Daml snapshot releases as a dependency, releasing independently of the official Daml release. We have now adopted the official Daml connect monthly release cadence (the second Wednesday after the first Monday in a month).
Of course, patch releases for bug fixes will be delivered outside of this release cycle.

Tracing and Span Reporting

The Canton tracing capabilities have been extended. It is now possible to have the traces being reported to tracing services such as Jaeger or Zipkin.
Please consult the monitoring section of the user manual on how to enable this feature.

BREAKING: As part of this change, we've renamed the configuration parameter canton.monitoring.trace-context-propagation to canton.monitoring.tracing.propagation.

Performance Improvements

There were a number of performance and scale improvements. We've added pre-fetching for contracts and contract keys during conflict detection, to avoid database access in a sequential bottleneck.
Related to this, we also introduced cache eviction such that conflict detection does not have to keep all active contracts and assigned keys in memory.
Furthermore, we have optimized the transaction footprint in the synchronization protocol, saving on bandwidth and disk usage.
Finally, we have entirely modified the sequencer database schema, making it ready for high-availability setups and higher performance.

Logging Improvements

BREAKING: We have extended and changed the command line arguments you can use to configure how Canton should be logging.
In particular, you can now flexibly adjust the logging method, level and output format (text or JSON) such that you always get the ideal logging format for the way you run Canton.
As an example, in a container setup, you could use --log-profile=container to modify the log-output to leverage the container system's logging capture method.
Please consult the user manual on logging for insights.

Minor Improvements

  • We have changed the default value of canton.parameters.participant.party-change-notification.type to via-domain.
    Before, the setting was eager. This setting controls when a party should appear on the ledger API party management endpoint as existing.
    The via-domain setting will ensure that the party will only appear on the ledger API server once the party is actually permissioned on at least one domain.
    This is a small change, but helps to avoid a race condition in automated testing when a party would appear as permissioned despite the fact that it has been only registered locally on the participant.
  • The participant.parties.enable command now allows to synchronise on additional participants within the same console session.
    Using the parameter synchronizeParticipants: Seq, you can now ensure in your local setups that all mentioned participants learnt about a new party before the call finishes. Again, this helps to avoid race conditions in your (and our) scripts.
  • We have added a maxWaitPeriod parameter to utils.retry_until_true(timeout: JDuration, maxWaitPeriod: JDuration) such that users can now specify a maximum wait period before a condition is retried again.

Preview Features

  • We have now completed sequencer authentication support for external sequencers, and we have also removed the option to disable authentication.
  • Participant pruning (an enterprise feature) has now become more efficient and easier to use: We've added the pruning.get_offset_by_time helper command that helps you identify a pruning offset based on a specified timestamp. The reason for the distinction between pruning by offset or timestamp is that pruning by timestamp is not precise, while pruning by offset is hard to use. Therefore, you can now have both, a convenient method to find the offset, and the precise method to know exactly what you prune.

Security and Bugfixes

  • Fixed a bug which prevented the recovery of a domain that crashed or got turned off in the first few seconds after being started.

Compatibility

Dependency Version
Java Runtime OpenJDK 64-Bit Server VM 18.9 (build 11.0.10+9, mixed mode, sharing)
DAML SDK 1.12.0
Postgres postgres (PostgreSQL) 11.11 (Debian 11.11-1.pgdg90+1)
CCF 0.14.2
Ethereum besu/v20.10.4/linux-x86_64/oracle_openjdk-java-11
Fabric 2.2.2

What's Coming

We are currently working on the following topics:

Canton Enterprise

  • High availability for participant and sequencer.
  • Moving the domain service into a distributed setup.
  • Adding Oracle support.
  • Higher throughput, better vertical scalability and lower resource usage.

Community and Enterprise

  • Improving stability and long-running behaviour, in particular with pruning.
  • Increase negative test coverage and improve our ability to deal with other outages.
  • Supporting large number of participants and parties with privacy.
  • Better error codes and fault documentation.
  • Support for causality enforcement.
Assets 4

@canton-machine canton-machine released this Mar 9, 2021

Release of Canton 0.22.0

Canton 0.22.0 has been released on March 09, 2021. You can download the Community edition from our github release section. The Enterprise edition is available on Artifactory.
Please also consult the full documentation of this release.

Summary

This release comes with a set of improvements, such as faster commitment computation, better error messages and a preview on how to migrate Daml ledger data from any Daml ledger into Canton.

What’s New

Incremental ACS commitment computation

BREAKING: Canton participants exchange regular commitments to their shared active contract sets (ACSs), with the frequency as specified by the "reconciliation interval" domain parameter.
We have greatly sped up the computation of these commitments and decreased its memory consumption for most usage patterns.
The commitment processor was previously keeping a running snapshot of the ACS in memory, traversing the snapshot whenever computing commitments.
With large ACS sizes (millions of contracts or more), the computation could take minutes or more.
The new computation mechanism is incremental and uses so-called homomorphic hashing.
It can support thousands of contract state changes per second, regardless of the total ACS size.
The memory usage is linear in the count of the different stakeholder sets in the ACS (allocating around 2kb per stakeholder set).

Better Error Messages for Invalid Configurations

We have improved error messages resulting from invalid Canton configuration files. Before, errors in configurations might have been shown as exceptions. Now, you should be able to observe just the error and its location, providing you with better means to troubleshoot your configuration mistakes.
Additionally, if loading of the configuration from multiple files fails, Canton will write exactly how the config file it attempted to load looked like to a file to help you troubleshoot your problems.

How To Migrate To Canton or Between Major Canton Versions

We have now documented how to use the "repair commands" to import non-Canton Daml ledgers into Canton and how to preserve your data across major versions updates of Canton. See the Operational Processes section in the user manual for a how-to guide.

Multiple Metric Outputs

Previously, metrics could only be written to one output source. Now, it is possible to configure several metric reports (e.g. Graphite and CSV) at the same time.
We also added new filters for metrics, such that metric reporters allow for reporting only selected metrics.
There was also a minor breaking change, where we renamed the file property of CSV reporter configuration to directory.

Contract IDs and their Seeding

We have changed how Canton creates contract IDs to commit to the Daml LF value contents of the contract rather than their serialization.
Furthermore, you can now control the source of randomness used to seed the contract IDs using the configuration parameter canton.parameters.participant.contract-id-seeding.
By default, this is configured to use strong seeding. However, in some containerized setups such as continuous integration testing environments, the lack of sufficient entropy might cause the system to fail to startup with a timeout warning in the ledger API server. In such cases, you might want to use testing-weak and testing-static configurations instead.

Preview Features

We have added a new pruning command prune_internal that allows pruning internal participant ledger data more aggressively than transactions and completions visible via the ledger API.

Security and Bugfixes

We've fixed a bug where multiple consecutive repair commands for the same contract were failing.

Compatibility

Dependency Version
Java Runtime OpenJDK 64-Bit Server VM 18.9 (build 11.0.8+10, mixed mode)
DAML SDK 1.11.0-snapshot.20210303.6421.0.145ddaa8
Postgres postgres (PostgreSQL) 11.10 (Debian 11.10-1.pgdg90+1)
CCF 0.14.2
Ethereum besu/v20.10.0/linux-x86_64/oracle_openjdk-java-11
Fabric 2.2.2

What's Coming

We are currently working on the following topics:

Canton Enterprise

  • High availability for participant and sequencer.
  • Moving the domain service into a distributed setup.
  • Adding Oracle support.
  • Higher throughputs, better vertical scalability and lower resource usage.

Community and Enterprise

  • Improving stability and long-running behaviour, in particular with pruning.
  • Increase negative test coverage and improve our ability to deal with other outages.
Assets 4

@canton-machine canton-machine released this Feb 23, 2021

Release of Canton 0.21.0

Canton 0.21.0 has been released on February 23, 2021. You can download the Community edition from our github release section. Please also consult the full documentation of this release.

Summary

We have been quiet for a few weeks, but here is our latest advancement that comes with many small user facing changes and some significant performance and efficiency improvements under the hood.

What’s New

Improved Interaction with the Ledger

BREAKING: You can now submit multi-party commands via the ledger API and the Canton console. This is a breaking change that required us to modify the signature of participant.ledger_api.commands.submit, submit_flat, and submit_async commands. They now accept multiple "actAs" submitters rather than a single submitter party.

There are also new console commands participant.ledger_api.transactions.subscribe_flat and participant.ledger_api.transactions.subscribe_trees. These commands allow for directly subscribing to the transaction stream.

BREAKING: We've also generalized the existing commands flat and trees to take a set of parties instead of a single party, leading to a minor break in the console commands.

Better Documentation

The documentation now includes anchor tags to specific commands/metrics, which is great for pointing other users to some specific command.

Also, we've improved the user experience of the console documentation in the case when more complex return types are used. These return types are now linked to their appropriate scaladocs page.

Finally, we've improved the ethereum sequencer demo example and corrected the docker repository used.

Console Improvements

We've improved the behaviour of the console commands. Commands with an explicit timeout will no longer timeout early due to gRPC console timeouts. And console commands with potentially large outputs now allow the option to limit the returned results.

Performance Improvements

We have done quite a few performance improvements in the recent past. You might notice a higher transaction throughput when running higher loads, but the result is highly dependent on the workflow you are using.

Additionally, we have improved the pruning performance quite a bit, ensuring that we can prune substantially faster than we can add new transactions.

Finally, reconnecting a participant to an idle domain (no transactions or transfers involving the participant) was previously slow, as we replayed from the last transaction. This has been fixed now.

Other Minor Improvements

  • Sandbox mode: You can start Canton with a --sandbox flag. This will use a default sandbox configuration, automatically starting a participant that is connected to a local domain using in-memory stores.
  • The Graphite Metrics reporter now prefixes all metrics by default with hostname.

Preview Features

  • You can now use the daml 1.11 language preview features such as Choice Observers.

Security and Bugfixes

  • Fixed a crash recovery bug in which participant-level events (such as the publishing of DAML packages) would republish following pruning and participant restart.
  • Preventing pruning of data that may be needed for crash recovery.
  • The reconciliation checks now pick up correctly changes from repair requests.
  • Eliminated several race conditions in crash recovery (in particular when recovering from a crash during crash recovery)

Compatibility

Dependency Version
Java Runtime OpenJDK 64-Bit Server VM 18.9 (build 11.0.10+9, mixed mode, sharing)
DAML SDK 1.11.0-snapshot.20210217.6338.0.ba6ba901
Postgres postgres (PostgreSQL) 11.10 (Debian 11.10-1.pgdg90+1)
CCF 0.14.2
Ethereum besu/v20.10.0/linux-x86_64/oracle_openjdk-java-11
Fabric 2.2.2

What's Coming

We are currently working on

  • High availability for Canton Enterprise.
  • Improving stability and long-running behaviour, in particular with pruning.
  • Increase negative test coverage and improve our ability to deal with other outages.
  • Moving the domain service into a distributed setup.
  • We are working on adding Oracle support.
Assets 4

@canton-machine canton-machine released this Dec 3, 2020

Release of Canton 0.20.0

Canton 0.20.0 has been released on December 03, 2020. You can download the Community edition from our github release section. Please also consult the full documentation of this release.

Summary

This release contains a few bug fixes addressing issues arising in long-running systems.
Additionally, we've added and improved a few preview features in Canton Enterprise. First, we've added a cache to the Ethereum driver in order to avoid rehydration from the underlying ledger upon restart and to avoid storing the state in memory. Second, we've added initial high-availability support for the mediator.

What’s New

Console Command Change

The signature of the command $participant.domains.modify was changed from (config: DomainConnectionConfig) to (alias: DomainAlias, modifier: DomainConnectionConfig => DomainConnectionConfig). This makes changing domain connection configurations more convenient.

Minor Improvements to the Docker Deployment

The Docker deployment in deployment/docker now creates log files for troubleshooting and allows to define the exposed ports using environment variables. As a result, you can now run multiple docker-compose based deployments on the same docker host without conflicts.

Preview Features

  • Enterprise only: We've added initial support for mediator high availability. The enterprise version now supports adding several Mediators to a Domain and failing over the active Mediator role between them. This is currently just a preview feature and disabled by default. We expect to improve the failover time within the coming weeks.
  • Enterprise only: The Ethereum driver now caches the state in a separate database in order to avoid rehydration from the ledger on a restart.

Security and Bugfixes

  • Security: We have fixed a security related issue in the nonce generation in sequencer authentication challenge-response protocol by using a more appropriate random number generator.
  • The domain router did not consider informee information sufficiently when deciding onto which domain to send a multi-domain transaction. As a result, transactions that could otherwise succeed, bounced.
  • The processing of identity state updates was not resilient to crashes and could leave the system corrupt upon a crash in the wrong moment.
  • The postgres-driver sequencer event log was missing an index, leading to a startup-time that increased linearly with the number of events.
  • There was a race conditions in conflict detection that could have lead to rejected transactions and participant crashes in rare cases.

Compatibility

Dependency Version
Java Runtime OpenJDK 64-Bit Server VM 18.9 (build 11.0.9.1+1, mixed mode)
DAML SDK 1.8.0-snapshot.20201124.5709.0.dabd55d0
Postgres postgres (PostgreSQL) 11.10 (Debian 11.10-1.pgdg90+1)
CCF 0.14.2
Ethereum besu/v20.10.0/linux-x86_64/oracle_openjdk-java-11
Fabric 2.2.1

What's Coming

We are currently working on

  • High availability for Canton Enterprise.
  • Improving stability and long-running behaviour, in particular with pruning.
  • Increase negative test coverage and improve our ability to deal with other outages.
  • Cross-domain transactions.
  • Moving the domain service into a distributed setup.
  • Adding Oracle support.
Assets 4

@canton-machine canton-machine released this Nov 13, 2020

Release of Canton 0.19.1

Canton 0.19.1 has been released on November 13, 2020. You can download the Community edition from our github release section. Please also consult the full documentation of this release.

Summary

This release follows quickly our previous release. The community edition now includes a demo docker compose deployment.
The enterprise edition adds now two new interesting preview features: An Ethereum driver and a Fabric driver.

What’s New

Docker Compose Based Deployment

In the release artefact, there is a new sub-directory deployment/docker. There you can find a docker compose example deployment for your demo projects. Checkout the included README.md.

Multi-reader multi-writer Ethereum sequencing

Enterprise only The enterprise edition now includes a preview Ethereum driver which can run with several Ethereum sequencers, all of which may read and write from the same underlying ledger.
While it should work in theory with other Ethereum variants, we are testing it with Besu. Checkout the example in examples/e03-ethereum-sequencer.

Multi-reader multi-writer Fabric sequencing

Enterprise only We also integrated the Hyperledger Fabric driver into the Enterprise bundle.
Though, the driver was already present in the previous release, but now we added a new tutorial for how to use it. You can find it in examples/e01-fabric-domain.

Security and Bugfixes

  • There was a bug in the domain router, where informee information was not included in the routing analysis.
  • Another bug was fixed that could cause loss of data in the event of a sudden crash.

Compatibility

Dependency Version
Java Runtime OpenJDK 64-Bit Server VM 18.9 (build 11.0.9+11, mixed mode)
DAML SDK 1.7.0-snapshot.20201103.5565.0.e75d42dd
Postgres postgres (PostgreSQL) 11.8 (Debian 11.8-1.pgdg90+1)
CCF 0.14.2
Ethereum besu/v20.10.0/linux-x86_64/oracle_openjdk-java-11
Fabric 2.2.1

What's Coming

We are currently working on

  • High availability for Canton Enterprise.
  • Improving stability and long-running behaviour, in particular with pruning.
  • Increase negative test coverage and improve our ability to deal with other outages.
  • Cross-domain transactions.
Assets 4

@canton-machine canton-machine released this Nov 5, 2020

Release of Canton 0.19.0

Canton 0.19.0 has been released on November 05, 2020. You can download the Community edition from our github release section. Please also consult the full documentation of this release.

Summary

This is quite a large release, including many exciting changes such as unique contract keys for single domains, microservices and parallel processing.

What’s New

Community and Enterprise Edition

Canton now comes in two editions: A free Community edition and a commercial Enterprise edition.
The Enterprise edition extends the Community edition with additional features. At the same time, the Community edition is fully functional and wire-compatible with the Enterprise edition.

Contract Key Uniqueness in Canton

Canton now supports a mode with unique-contract-keys (UCK) mode where contract key uniqueness is enforced.
A domain can now be configured to support UCK, but such domains are not interoperable and composeable with other domains.
If a participant connects to a UCK domain, then it may not connect to any other domain (UCK or non-UCK) during its entire lifetime.
Refer to the contract key manual for details.

Metrics

Previously, Canton supported Kamon based metrics. We have changed the underlying metrics library and adopted
Dropwizard. The available metrics are documented in our new Monitoring section in the manual.

Preview Support for PCS Manipulation

If something can go wrong, it will go wrong at some point in time. Therefore, we have been adding a new set of commands to a new group named repair. These commands are powerful and dangerous, but they can be used to recover a broken system. Scenarios where these commands will become useful are recovering from a broken domain, recovering a compromised participant or domain, migrating parties, data-continuity across major version changes and to migrate from other DAML based ledgers to Canton.
So far, we have implemented the following commands:

  • participant.repair.add admin command to allow for manual creation of contracts such as those exported from other participants.
  • participant.repair.change_domain admin command to allow for manual moving of contracts across domains for scenarios such as domain recovery.
  • participant.repair.purge admin command to allow for manual archival of a contract.

The commands are just the first step here, but they enable the principal capability to implement all of above procedures. The commands right now are turned off by default and are preview at this point in time. We'll document in upcoming releases how exactly they can be used in various scenarios. The first documentation is how to recover participants from a permanently lost or broken domain. Refer to the manual for a how-to guide.

Parallel Transaction Processing

Enterprise only: The Enterprise edition now supports parallel transaction processing, leading to a nice performance gain. You don't have to do anything to enable this except using the Enterprise version.

Microservice Support

Enterprise only: Mediators and Sequencers can now be run independently from the main Domain node.
This allows to distribute these processes over multiple hosts and is a preparation step for subsequent high-availability configurations.

Minor Improvements

  • The contract metadata in the protocol messages have been improved to include every stakeholder only once, leading to smaller message sizes.
  • The preference "canton.monitoring.size-limit-of-grpc-messages-in-log" has been renamed to "canton.monitoring.log-message-payloads" and has been changed to type boolean.
  • The configuration section on Canton parameters has been reorganised. Instead of a single group for a diverse set of parameters, we now feature distinct sections for monitoring and process control.
  • The action description and the view participant data have been merged into a single leaf of the Merkle tree for transactions to, leading to smaller message sizes.

Breaking Protocol Changes

  • The Sequencer API has been updated to include send request receipts in the sequenced event stream rather than return synchronously in the response.
    This benefits Sequencer implementations where the order of events is not known until they are observed when read (particularly the blockchain based Ethereum and Fabric Sequencers).
  • UTC Timestamps are now stored in databases as longs in microseconds relative to EPOCH to avoid issues with time zones.
  • The VIP policy requires only one VIP participant to confirm each transaction view rather than all VIP stakeholders.

Preview Features

  • The "pruning.prune_by_time" command is now called "pruning.prune" and has been modified to accept an offset rather than a timestamp and no longer produces a return result.

Security and Bugfixes

  • There was a bug where transient contracts which were created in a proper subview and were archived in the core of a root view could be double-spent. This has been fixed.
  • There was a bug where the continuous pruning query corrupted the contract journal. This is fixed now.
  • There is a bug in the Java libraries that can lead to the ForkJoinPool closing threads prematurely and therefore leading to deadlocks. We have added a workaround for this issue.

Compatibility

Dependency Version
Java Runtime OpenJDK 64-Bit Server VM 18.9 (build 11.0.9+11, mixed mode)
DAML SDK 1.7.0-snapshot.20201103.5565.0.e75d42dd
Postgres postgres (PostgreSQL) 11.9 (Debian 11.9-1.pgdg90+1)

What's Coming

We are currently working on

  • Adding Fabric and Ethereum drivers to Canton Enterprise.
  • Mediator high availability for Canton Enterprise.
  • Improving stability and long-running behaviour, in particular with pruning.
  • Increase negative test coverage and improve our ability to deal with other outages.
  • Cross-domain transactions.
Assets 4