digital-asset/canton

This system is Canton, a distributed ledger platform that manages the lifecycle of digital assets and contracts through a modular architecture of participants, mediators, and sequencers. It provides a comprehensive runtime for executing Daml smart contracts, handling transaction ordering via Byzantine Fault Tolerant consensus, and exposing ledger state through gRPC and JSON APIs. The codebase encompasses the core language engine, cryptographic security primitives, and extensive tooling for administration, testing, and performance benchmarking.

39 changes.

This period focused on the development and release of Canton 3.7.0, introducing a declarative API for automatic node state synchronization and party replication protocols. It significantly expanded the administrative tooling with a new CLI framework, interactive console, and OpenTelemetry-based metrics infrastructure. The work also established a new HTTP JSON API, enhanced database schemas for both H2 and PostgreSQL, and added comprehensive Java bindings and integration testing capabilities.

96 changes.

This period focused on introducing Ledger API v2 with relaxed JSON decoding and new protobuf definitions, alongside the development of BFT ordering services in the synchronizer. It also established foundational infrastructure for security, observability, and resource management, supported by extensive test coverage for the new Daml LF engine and protocol continuity.

The transcode tool now includes a new \LfSchemaProcessor\ in the \daml-lf\ module that traverses Daml LF package signatures to extract and normalize schema definitions (templates, interfaces, choices, and types) into a generic descriptor format. To validate this processing, a comprehensive conformance test suite has been added in \test-conformance\, covering roundtrip serialization, primitive types, records, variants, enumerations, recursive structures, and keyword handling, along with a generator to produce corresponding Daml test definitions.

community/transcode/daml-lf, community/transcode/test-conformance · high confidence

Introduces a new ProtobufCodec implementation in the transcode module that converts between Ledger API gRPC values and internal dynamic representations. This codec supports all standard data types including records, variants, enumerations, lists, optionals, text maps, and generic maps, enabling Java-based services to correctly transcode Ledger API payloads.

(repo-wide) · high confidence

This change introduces new resource owners for managing Pekko lifecycle components, including ActorSystem, Materializer, Cancellable, and BoundedSourceQueue, allowing these resources to be acquired and released safely within the resource management framework. It also adds a factory trait to simplify the creation of these resource owners and includes a test suite verifying their correct behavior. Additionally, utility classes for timer-based tasks are added to support scheduled operations.

base/resources-pekko · high confidence

This change introduces a new experimental benchmark configuration for the sparse key-value journal that utilizes the \uint128\ PostgreSQL extension to store timestamps as 128-bit integers (\int16\). The update includes a Dockerfile to build the required extension, SQL scripts to define the schema and generate test data, and a suite of explain plans to benchmark point-in-time lookups, bulk queries, and pruning operations against PostgreSQL versions 14 and 17.

experiments · high confidence

The project now includes a Nix-based build environment. This introduces \nix/sources.nix\ and \nix/sources.json\ to manage dependencies via Niv, specifically pinning the \nixpkgs\ repository to the \nixpkgs-unstable\ branch. Additionally, a new derivation in \nix/tools/dpm/default.nix\ has been added to fetch and package the Digital Asset DPM tool (version 1.0.22) for supported Linux and Darwin architectures.

nix · high confidence

A new database migration (V998) has been added to the Canton H2 development reference schema. This migration creates a 'blocks' table containing an integer primary key 'id', a binary 'request' column, and a unique string 'uuid' column, establishing the storage structure for block data in the local development environment.

community/common/src/main/resources/db/migration/canton/h2/dev/reference, community/common/src/main/resources/db/migration/canton/postgres/dev/reference · high confidence

The development database migration now includes tables and views to support Party Replication Indexing. Specifically, it adds \par\_party\_replication\_indexing\ to track contract activation changes, \par\_party\_replication\_indexing\_watermarks\ to queue items for the indexer, and \par\_party\_replication\_indexed\_watermarks\ to track confirmed indexing for crash recovery. Human-readable views are also provided in the \debug\ schema to facilitate inspection of these tables.

community/common/src/main/resources/db/migration/canton/h2/dev, community/common/src/main/resources/db/migration/canton/postgres/dev · high confidence

A new \SharedConfigReaders\ object has been added to the ledger JSON API's pureconfig utilities, providing a \catchConvertError\ helper that wraps string-to-type conversion functions to standardize PureConfig failure reasons.

community/ledger/ledger-json-api/src/main/scala/com/digitalasset/canton/pureconfigutils · high confidence

This change introduces the release notes for Canton 3.7.0, detailing the removal of protocol version 34, new initialization logic for sequencers and mediators, key management operations bound to synchronizers, and a new API endpoint for synchronizer record time to offset conversion. It also adds configuration files for the development environment, including \.editorconfig\, \.envrc\ for Nix setup, \shell.nix\ with updated tooling, and \shared\_dependencies.json\ defining the project's library versions.

(repo-wide) · high confidence

This change introduces a comprehensive set of database migration scripts (V1\_1 through V7\_1) for the Canton H2 stable database. It establishes the initial schema with tables for DAML packages, DARs, cryptographic keys, contracts, and party metadata. Subsequent migrations add support for the Ledger API 3.0 (including command completions and event tracking), topology caching, and ACS commitment pruning. It also introduces traffic enforcement tables for usage tracking, reassignment contract storage, and generic topology events. The schema is further refined with performance indexes, hash-based lookups for transactions, and a redesigned ACS commitment system using running digests. Finally, it standardizes Pekko projection table naming to lowercase and removes deprecated party entry columns.

community/common/src/main/resources/db/migration/canton/h2/stable · high confidence

A new declarative API has been introduced for Canton participants and sequencers, allowing administrators to define the desired node state in configuration files. The system now automatically synchronizes the node's actual state with this desired state, handling the addition, update, and removal of resources such as synchronizer connections, identity providers, parties, users, and DARS for participants, as well as throughput caps for sequencers. This simplifies deployment and management by removing the need for manual imperative API calls to maintain consistency.

community · high confidence

The JSON API now exposes detailed operational metrics for HTTP and WebSocket traffic. HTTP metrics track request counts, latency, and the byte sizes of request and response payloads, while WebSocket metrics track the count and byte sizes of sent and received messages. These metrics are labeled with HTTP verb, path, host, status code, and service name, enabling users to monitor performance and traffic patterns of the JSON API endpoint.

community/ledger/ledger-json-api/src/main/scala/com/digitalasset/canton/http/metrics · high confidence

Added a new \NonEmpty\ type in the \base/nonempty\ module that provides a nominal wrapper around Scala's immutable collections (List, Set, Map, etc.) to enforce non-emptiness at the type level. This change introduces factory methods (\apply\, \mk\) for construction, pattern matching support (\unapply\, \+-:\, \:-+\, \Singleton\), and specialized operations that preserve the non-empty invariant (e.g., \updated\, \incl\, \grouped1\). It also integrates with the Cats library by providing \Traverse\, \Functor\, \Foldable\, and \Reducible\ instances for \NonEmptyF\, allowing users to leverage functional programming patterns while ensuring collections are never empty.

base/nonempty · high confidence

This change adds the \docs-open\ module, which provides the infrastructure to automatically generate the Canton public documentation. It includes a Python-based preprocessing pipeline that converts RST source files into final HTML by replacing custom directives (such as \literalinclude\ and \snippet\) with actual code blocks and console references. The module also introduces a \console-reference.canton\ script that extracts live console commands, metrics, error codes, and protocol version mappings from the Canton codebase to keep the documentation up to date, alongside the necessary Sphinx configuration and build scripts.

docs-open · high confidence

The \base/contextualized-logging\ module now provides a new \ContextualizedLogger\ that automatically attaches structured key-value pairs to log messages via SLF4J markers, ensuring context is preserved across scopes and asynchronous boundaries. The library includes a \LoggingContext\ API for enriching logs with typed entries, \LeveledLogger\ wrappers for trace/debug/info/warn/error levels, and serializers (\JsonStringSerializer\, \LoggingValueSerializer\) to output context as JSON-compatible structures for structured logging frameworks like Logstash.

base/contextualized-logging · high confidence

Participants can now replicate a party's Active Contract Set (ACS) to another participant. This change adds the v30 protocol definitions for party and ACS replication (including status tracking, progress, and error handling), a Daml admin workflow implementing a propose-accept pattern for agreement on replication parameters, and the Scala infrastructure to bootstrap the replication services and manage lifecycle state during the replication process.

community/participant/src/main · high confidence

This change adds several new foundational libraries to the codebase. In base/crypto, it introduces MacPrototype, MessageDigestPrototype, and MessageSignaturePrototype to provide safe, cloneable wrappers around Java cryptographic primitives (HmacSHA256, SHA-256, KECCAK-256, and Secp256k1) as a workaround for JDK cloning issues, along with corresponding JMH benchmarks. In base/logging-entries, it defines a structured logging model with LoggingValue types (including truncation support) and LoggingEntries. In base/nameof, it adds Scala macros to retrieve qualified names of methods and members at compile time. In base/observability/tracing, it provides a thin OpenTelemetry abstraction for managing spans, events, and attributes. Finally, in base/resources-grpc and base/rs-grpc-pekko, it introduces resource lifecycle management for gRPC channels and servers, and implements a Pekko-based execution sequencer and pool for serializing runnable execution.

(repo-wide) · high confidence

This release adds a new set of Protocol Buffer definitions (version v30) for the Canton Admin API, establishing the schema for participant health, inspection, repair, and party management services. The new \StatusService\ provides endpoints for health dumps and log level configuration, while \ParticipantInspectionService\ exposes ledger offset lookups and ACS commitment details. \ParticipantRepairService\ introduces operations for ACS export/import, contract purging, and synchronizer migration, and \PartyManagementService\ defines the RPCs for online and offline party replication. These files define the contract surface for these administrative capabilities.

community/base · high confidence

Adds a new \com.daml.resources\ package in \base/resources/src/main\ that provides a \Resource\ abstraction for managing asynchronous lifecycles. This includes an \AbstractResourceOwner\ base class for acquiring resources, specific owners for \AutoCloseable\ objects, \ExecutorService\ instances (with deadlock prevention), and \Timer\ instances, as well as factory utilities (\ResourceFactories\, \ResourceOwnerFactories\) and a \ProgramResource\ helper for running applications with automatic teardown on failure.

base/resources/src/main · high confidence

The \base/errors\ module now provides a comprehensive, typed error system to replace ad-hoc error handling. This includes a new \BaseError\ interface and \ErrorCode\ hierarchy that standardizes how errors are defined, logged, and serialized to gRPC. Key additions include \ErrorCategory\ for categorizing errors by severity and retry behavior (e.g., \SecurityAlert\, \TransientServerFailure\), \BaseErrorLogger\ for consistent logging with correlation/trace IDs, and \SerializableErrorCodeComponents\ to ensure errors fit within gRPC metadata size limits. The framework also introduces \DecodedCantonError\ for deserializing errors received from other nodes, allowing clients to inspect error details like retry delays and associated resources programmatically.

base/errors · high confidence

The Canton application base now includes a dedicated \CommunityEnvironmentFactory\ that initializes the runtime environment with the standard node bootstrap factories for participants, sequencers, and mediators. This factory is backed by new core infrastructure files (\Environment.scala\ and \Nodes.scala\) that manage the lifecycle of these nodes, handle dynamic configuration updates, and set up metrics and tracing, providing the foundational environment setup for the community edition of the platform.

community/app-base/src/main/scala/com/digitalasset/canton/environment · high confidence

The ledger JSON API now includes a new \Circe\ utility object for handling JSON parsing errors, a \JsonProtocol\ object defining serialization and deserialization rules for internal HTTP types (such as \Party\, \StatusCode\, and various error details), and a \JsHealthService\ that exposes \/livez\ and \/readyz\ endpoints to check service liveness and readiness.

community/ledger/ledger-json-api/src/main/scala/com/digitalasset/canton/http/json · high confidence

This change introduces a new set of core data structures for the Daml LF transaction model, including \ApiCommand\ and \ReplayCommand\ types for handling API and replay inputs, \ExecutionMode\ and \InterpretationConfig\ for controlling interpretation, and \Limits\ for defining transaction constraints. It also adds supporting infrastructure such as \CostModel\ for resource accounting, \Hash\ and \HashUtils\ for cryptographic operations, \Authorization\ types for ledger authorization logic, and \BlindingInfo\ for privacy handling. Concurrently, the legacy \command.scala\ package is deprecated in favor of the new \ApiCommand\ types to align with version 2.1.0.

community/daml-lf/transaction/src/main/scala · high confidence

This change introduces a new HTTP-based JSON API for the Canton ledger, implemented in the \com.digitalasset.canton.http\ package. It provides a new \HttpService\ and \HttpApiServer\ that expose ledger operations via standard HTTP/JSON endpoints (backed by Pekko HTTP) alongside the existing gRPC interface. Key capabilities include a configurable request timeout mechanism via the \Request-Timeout\ header, a dedicated health check service (\HealthService\) for readiness probes, and structured error handling that maps gRPC status codes to appropriate HTTP responses. The API is configured via \JsonApiConfig\, supporting options for TLS, path prefixes, and websocket settings.

community/ledger/ledger-json-api/src/main/scala/com/digitalasset/canton/http · high confidence

The community/ledger-api-proto area now provides the complete set of Protocol Buffer definitions for Ledger API v2, including a new buf.yaml build configuration and a comprehensive README.md detailing the migration from v1. This release introduces significant API changes: the TransactionService is replaced by the UpdateService to unify transaction and reassignment streams, the StateService consolidates ledger state endpoints, and deprecated services like LedgerIdentityService and LedgerConfigurationService are removed. New capabilities include the CommandSubmissionService.SubmitReassignment endpoint for contract reassignment, StateService.GetConnectedSynchronizers for topology visibility, and a suite of admin services (IdentityProviderConfig, PartyManagement, UserManagement, PackageManagement, ParticipantPruning) for runtime configuration and lifecycle management.

community/ledger-api-proto · high confidence

This change introduces a new set of Dockerfiles, configuration files, and build scripts for the Canton base image, participant, sequencer, and mediator. It provides a standardized way to build, tag, and publish Canton Docker images, including support for local development and CI/CD pipelines. The base image includes necessary configurations for logging, monitoring, and storage, while the participant, sequencer, and mediator images are configured with specific ports and application settings. Additionally, integration tests and a ping test suite are included to validate the Docker images.

docker · high confidence

This change introduces a new Scala-based command framework for the Canton admin CLI (cantonctl), located in \community/app-base/src/main/scala/com/digitalasset/canton/admin/api/client/commands\. It defines a generic \AdminCommand\ and \GrpcAdminCommand\ trait structure to standardize how administrative operations are constructed, submitted via gRPC, and their responses handled, including support for various timeout strategies (bounded, unbounded, server-enforced) and streamed responses. The diff also adds concrete command implementations for managing Participants, Mediators, and Sequencers, covering operations such as package management, party management, user management, traffic control, pruning, and BFT peer administration. Additionally, it includes helper utilities like \AutoDetectSynchronizerHelper\ for automatically selecting synchronizers and \LedgerApiTypeWrappers\ to simplify access to Ledger API types.

community/app-base/src/main/scala/com/digitalasset/canton/admin/api/client/commands · high confidence

The Canton console now includes a new interactive REPL environment powered by Ammonite, featuring configurable caching (file-based or in-memory), color output, and verbose logging options. It introduces a structured command result system (\ConsoleCommandResult\) with specific error codes for timeouts and node states, and adds a health administration module that generates comprehensive diagnostic dumps of participant, sequencer, and mediator statuses. The console also supports feature-flagged commands (Stable, Preview, Repair, Testing) and provides utilities for running gRPC admin commands with configurable timeouts and retry logic.

community/app-base/src/main/scala/com/digitalasset/canton/console · high confidence

This release introduces several new foundational components for the Canton platform. It adds a \CantonOnly\ object to expose specific Daml-LF transaction internals to Canton, supporting upstream API refactoring. A new gRPC-based pruning scheduler (\GrpcPruningScheduler\) is provided to manage data retention schedules via the admin API. Node initialization and identity management are enhanced with new \InitConfig\ and \IdentityConfig\ classes, allowing for manual, automatic, or config-based node identification. Configuration handling is improved with utilities for deprecating and moving config paths (\DeprecatedConfigUtils\) and lower-casing storage config types. Additionally, new sequencer connection clients (\SequencerConnectClient\, \GrpcSequencerConnectClient\) handle bootstrapping and handshakes, while \SequencerBasedRegisterTopologyTransactionHandle\ manages topology transaction broadcasts. The release also includes new configuration structures for node monitoring (\NodeMonitoringConfig\), default port management (\ConfigDefaults\), and crypto utilities like \Blake2xb\ and \CryptoHandshakeValidator\.

community/common/src/main/scala · high confidence

A new \CantonExamples\ library has been added to the \community/common\ source tree, providing a collection of Daml templates and scripts designed to demonstrate various interaction patterns. The library includes core financial templates like \Iou\ (with transfer and sharing capabilities), \Swap\ (for exchanging IOUs with rate validation), and \LockIou\ (for assigning beneficiaries). It also features service-oriented examples such as \Paint\ and \SafePaint\ (modeling house-painting offers and secure acceptance workflows), \Cycle\ (demonstrating recursive contract creation), \Divulgence\ (showing information disclosure scripts), and \TrailingNone\ (testing optional value handling). These examples serve as reference implementations for building and testing Daml applications on Canton.

community/common/src/main/daml · high confidence

The Ledger JSON API now includes a new set of utility objects in the \com.digitalasset.canton.http.util\ package to support HTTP request handling. \GrpcHttpErrorCodes\ provides mappings between gRPC status codes and Pekko HTTP status codes, including a specific variant for the JSON API and support for sttp status codes. \ErrorOps\ adds extension methods to lift error values into different effect types using \Show\ instances. \FutureUtil\ offers helpers to convert between Scala \Future\s and \EitherT\ monads. \Logging\ introduces tagging mechanisms (\InstanceUUID\ and \RequestID\) to inject unique correlation IDs into logging contexts for better traceability. \ClientUtil\ provides a simple method for generating unique IDs.

community/ledger/ledger-json-api/src/main/scala/com/digitalasset/canton/http/util · high confidence

The ledger JSON API introduces a new v2 interface that adds endpoints for contract lookups, event queries by contract ID, identity provider configuration management, Daml definition retrieval, and interactive command submission. To support JavaScript clients, the API now uses a relaxed JSON codec that automatically fills missing fields with sensible defaults (e.g., empty sequences, null options, zeroed scalars), emulating optional proto field behavior. Additionally, the API now serves OpenAPI and AsyncAPI documentation at the /docs path, generated from the new endpoint definitions.

community/ledger/ledger-json-api/src/main/scala/com/digitalasset/canton/http/json/v2 · high confidence

Added \JsonCodec\ and \JsonStringCodec\ in the \codec-json\ module to serialize and deserialize Ledger API data types to and from JSON, supporting options to encode numeric and int64 values as strings to preserve precision, and to handle trailing nulls in records. Added \ProtobufCodec\ in the \codec-proto-scala\ module to convert between Ledger API gRPC values and internal dynamic values, with configurable strictness for missing required fields. Both codecs cover records, variants, enumerations, lists, optionals, text maps, and generic maps, and are accompanied by comprehensive test suites validating encoding, decoding, and error handling for malformed inputs.

community/transcode/codec-json, community/transcode/codec-proto-scala · high confidence

This change introduces a new \daml-jwt\ library for handling JSON Web Tokens, including support for signing (HMAC256, RSA256, ECDSA, EdDSA) and verifying tokens with configurable timestamp leeway, as well as parsing standard and party-specific JWT payloads. It also adds \grpc-utils\ components, specifically \AuthCallCredentials\ for attaching Bearer tokens to gRPC calls and \GrpcStatus\ utilities for mapping and handling gRPC status codes and metadata.

base/daml-jwt · high confidence

The Java API data package now includes a comprehensive set of new model classes to represent ledger interactions. This adds data structures for contract lifecycle events, including ActiveContract, ArchivedEvent, AssignedEvent, and AssignCommand, alongside core command types like CreateCommand, ExerciseCommand, and CreateAndExerciseCommand. It also introduces support for command submission via CommandsSubmission, completion tracking through Completion and CompletionStreamRequest/Response, and synchronizer management with ConnectedSynchronizer. These classes provide serialization (toProto/fromProto) and equality checks, enabling users to construct, send, and interpret ledger commands and state updates in the Java binding.

community/bindings-java/src/main/java/com/daml/ledger/javaapi/data · high confidence

Canton now uses OpenTelemetry for metrics collection, introducing a new registry system that pre-registers histogram buckets for participants, mediators, and sequencers. Users can now export metrics via four reporters: Prometheus (HTTP server), OTLP (gRPC or HTTP with optional OAuth2 client credentials authentication), CSV files, and logging. The system also supports filtering metrics by qualification (errors, latency, saturation, traffic) and includes a mechanism to generate documentation for all available metrics.

community/app-base/src/main/scala/com/digitalasset/canton/metrics · high confidence

The rs-grpc-bridge module introduces a new Reactive Streams (RS) to gRPC bridge implementation. This includes a \ClientPublisher\ for server-streaming RPCs that defers execution until subscription, and a \ServerSubscriber\ for handling server-side streams. Both components rely on a new \ExecutionSequencer\ infrastructure (including \SingleThreadExecutionSequencer\ and \SingleThreadExecutionSequencerPool\) to ensure thread-safe, sequential processing of gRPC events. The bridge also features \BufferingResponseObserver\, \BufferingSubscription\, and event buffers (\UpstreamEventBuffer\, \DownstreamEventBuffer\) to manage backpressure and buffer events when the gRPC transport and RS subscriber are not yet synchronized. Tests verify the correctness of these components against the Reactive Streams TCK.

base/rs-grpc-bridge · high confidence

The scalatest-utils module now includes new traits to enhance testing capabilities. FlatSpecCheckLaws and WordSpecCheckLaws provide improved integration with Scalacheck properties, offering better test reporting for law-based checks in AnyFlatSpec and AnyWordSpec suites respectively. Additionally, ScalatestEssentials introduces a unified test base that combines ScalaFutures with increased default patience settings (5-second timeout, 20ms interval) and Mockito support, addressing issues with default timeouts being too low for unit tests, particularly in CI environments.

base/scalatest-utils · high confidence

Added a new \daml-tls\ module that introduces secure-by-default TLS settings for server and client connections. The module enforces a minimum TLS protocol version of 1.2, disables the legacy SSLv2Hello protocol, and provides a configurable list of modern cipher suites (including TLS 1.3 and strong TLS 1.2 options). It also adds support for OCSP certificate revocation checking and exposes CLI flags (\--pem\, \--crt\, \--cacrt\, \--tls\) to configure TLS parameters via command-line arguments.

base/daml-tls/src/main · high confidence

This change introduces a complete 'transfer' (XFER) performance testing workflow alongside the existing DvP model, enabling horizontal scalability testing via batched asset transfers. It adds Docker Compose configurations and build scripts to orchestrate master, participant, and synchronizer pods with dedicated PostgreSQL databases, along with a full observability stack (Prometheus, Grafana, and node/postgres exporters) pre-configured with dashboards for monitoring JVM garbage collection, Postgres QPS, and database stats during these tests.

performance · high confidence

The admin API client now includes a comprehensive set of new data classes in the \com.digitalasset.canton.admin.api.client.data\ package to represent node and component status. This introduces \CantonStatus\ for aggregating sequencer, mediator, and participant states, alongside specific status models like \ParticipantStatus\, \MediatorStatus\, and \SequencerConnection\ that parse v30 protobuf responses. It also adds \ComponentStatus\ and \ComponentHealthState\ to track individual component health (Ok, Degraded, Failed, Fatal) and \RegisteredSynchronizer\ to manage synchronizer connection states. These models enable the console to display detailed, structured health information for all connected nodes and their internal components.

community/app-base/src/main/scala/com/digitalasset/canton/admin/api/client/data · high confidence

The scripts directory now includes a new \backport.scala\ tool that automates cherry-picking commits across multiple branches by reading repository paths from a \canton\_repo\_paths\ file. Additionally, a comprehensive set of nightly performance testing scripts and configurations has been added under \scripts/canton-testing/\, including environment settings, server configurations for sequencers, mediators, and participants, and deployment scripts for automated execution and metrics reporting to Datadog and Slack.

scripts · high confidence

This change introduces several new base libraries to the platform. In base/executors, it adds InstrumentedExecutors and NamedExecutionContextExecutorService, allowing users to create named, instrumented thread pools (work-stealing, fixed, and cached) with custom error reporting and logging. It also provides DirectExecutionContext for synchronous task execution and utilities for handling closing/cancellation exceptions. In base/ledger-resources, it introduces a ResourceContext and ResourceOwner framework, enabling structured resource lifecycle management tied to an execution context, with support for Pekko and gRPC resource factories. Finally, base/scala-utils adds helper utilities including ExceptionOps for throwable descriptions, Statement.discard to suppress linter warnings on side-effect expressions, ImplicitPreference for managing implicit resolution priority, NeverEqualsOverride to disable equality for classes with non-comparable fields, and BatchingExecutorCanton to expose Scala's BatchingExecutor.

base/executors · high confidence

The base/util-external module introduces several new foundational types and utilities. Configuration handling is enhanced with ConfidentialConfigWriter for masking sensitive data, a Password wrapper for KeyStoreConfig that prevents secrets from appearing in logs, and a PemFileOrString trait allowing PEM data to be specified either as a file path or an inline string. RequireTypes adds a validated Port type (0–65535) with PureConfig support, a NonNegativeNumeric type with arithmetic and subtraction logic, and a Dynamic port constant. Additional utilities include a BytesUnit class for human-readable byte formatting, a Mutex implementation with lock inflation and ForkJoinPool integration, a TimeProvider trait, a VersionUtil for parsing semantic versions, a DiscardOps implicit class, and a JarResourceUtils helper for extracting resources in tests.

base/util-external · high confidence

The console now exposes a structured set of administration command groups for managing mediators, participants, and parties. This includes mediator-specific commands for time synchronization, pruning, and health inspection; participant commands for DAR package management, traffic control, and health status; and party administration commands for listing, enabling, and managing external parties. These groups provide a unified interface for operators to inspect node health, manage data retention, and configure party relationships directly from the console.

community/app-base/src/main/scala/com/digitalasset/canton/console/commands · high confidence

The admin API client now includes new data models in the \com.digitalasset.canton.admin.api.client.data.crypto\ package to represent cryptographic capabilities. These changes introduce \CryptoKeyFormat\ to define key serialization formats (DER X.509 SPKI, DER PKCS\#8, DER, Raw, Symbolic), \RequiredEncryptionSpecs\ to specify supported asymmetric/hybrid encryption algorithms (ECIES-HMAC256-AES128-CBC, RSA-OAEP-SHA256) and key schemes (EC-P256, RSA-2048) as well as symmetric schemes (AES-128-GCM), \RequiredSigningSpecs\ to define signing key schemes (EC-Curve25519, EC-P256, EC-P384, EC-Secp256k1, ML-DSA-65) and algorithm schemes (Ed25519, EC-DSA-SHA256, EC-DSA-SHA384, ML-DSA-65), and \HashAlgorithm\ to specify supported hash functions (SHA-256).

community/app-base/src/main/scala/com/digitalasset/canton/admin/api/client/data/crypto · high confidence

This change introduces two new command-line utilities in the ledger-api-tools module. The indexer benchmark tool (Config.scala, IndexerBenchmark.scala, IndexerBenchmarkResult.scala) allows users to measure indexer performance by processing state updates, configurable via command-line options for parallelism, batch sizes, and JDBC URLs, and reports detailed metrics including updates per second and latency histograms. Additionally, a new authentication tool (Main.scala) enables generating signed JWT access tokens and JWKS (JSON Web Key Sets) for the Daml ledger API, supporting RSA key management and token customization (issuer, user ID, expiration). A standard Logback configuration (indexer-benchmark-logback.xml) is also added to support logging for the benchmark tool.

community/ledger/ledger-api-tools · high confidence

Added a comprehensive set of configuration files and Scala test utilities to support integration testing. The new configs define single and multi-synchronizer topologies, including specific participant and synchronizer settings (ports, storage, TLS, keep-alive), and enable testing-specific features like repair commands and message payload logging. The Scala code introduces a base integration test framework with environment lifecycle management, concurrent execution limiting, console output recording and assertion helpers, and utilities for verifying ACS digest consistency across participants.

community/integration-testing · high confidence

This change introduces foundational components for the Canton ledger API, including new Protobuf definitions for ACS continuation and page tokens, core API traits for submission ID generation and proxy resource management, and utilities for extracting trace identifiers from ledger messages. It also adds a comprehensive JWT-based authentication service for party validation and a mechanism for ongoing stream authorization that checks user rights and token expiry. Additionally, a new Scala-based documentation generator is included to automatically produce error code and category inventories for the website.

community/ledger/ledger-api-core/src/main · high confidence

The \base/observability/metrics\ module introduces a comprehensive metrics instrumentation library built on OpenTelemetry. It provides ready-to-use metric definitions for key system areas: cache performance (hits, misses, evictions), database operations (wait, execution, translation, compression, commit, and query timers), and executor service health (thread pool sizes, active threads, task counts). The library also includes utilities for tracking asynchronous operations via \Timed\ and \Tracked\ helpers, an \InstrumentedGraph\ for monitoring Akka stream queues, and a \HealthMetrics\ component for registering component health status gauges. Configuration is handled via \MetricsConfig\ for filtering metrics by name and qualification, and the API supports both real OpenTelemetry backends and a \NoOp\ factory for testing.

base/observability/metrics/src/main · high confidence

Added a new \base/ports\ library providing utilities to find, lock, and persist free TCP ports for testing purposes. The \FreePort\ object finds available ports outside the OS dynamic range to avoid collisions, while \LockedFreePort\ and \PortLock\ implement a cooperative file-locking scheme to prevent race conditions when multiple processes request ports. \PortFiles\ allows writing port numbers to disk with automatic cleanup, and the \Port\ type validates port numbers within the valid range (0–65535).

base/ports · high confidence

This change introduces the Protobuf schema definitions for the Daml-LF transaction and value models. The \transaction.proto\ file defines the structure of ledger updates, including \Transaction\, \Node\ (covering \Create\, \Fetch\, \Exercise\, \Rollback\, and \QueryByKey\ operations), and \FatContractInstance\. It specifically adds support for external calls by introducing the \ExternalCallResult\ message and including \external\_call\_results\ in the \Exercise\ node, enabling deterministic replay of extension service interactions. The \value.proto\ file defines the serializable universe of Daml-LF values, supporting literals (booleans, integers, dates, timestamps, numerics, parties, text), native data structures (Option, List, Map, TextMap), and user-defined types (Record, Variant, Enum).

community/daml-lf/transaction/src/main/protobuf · high confidence

This change introduces a comprehensive set of new Protocol Buffer definitions in the synchronizer module, establishing the API contracts for Mediator administration (including pruning, initialization, and verdict inspection), Sequencer administration (covering traffic control, throughput caps, snapshots, and BFT-specific pruning and peer management), and the BFT ordering protocol itself (defining availability, consensus, and state transfer messages). These files define the gRPC services and message structures that enable administrators to manage mediator and sequencer lifecycle, configure pruning schedules, monitor traffic and peer network status, and facilitate the underlying Byzantine Fault Tolerant ordering consensus.

community/synchronizer/src/main · high confidence

The release directory now includes a comprehensive set of scripts to automate the Canton release process. This includes \propose.sh\ for orchestrating release branches and pull requests, \update\_dependabot.py\ to synchronize Dependabot configuration with supported release lines, and \tag-new-releases.sh\ for automatic tagging. Supporting utilities handle version updates (\update-version.sh\), metrics collection (\download-metrics.sh\), and release validation (\verify-authorized-release.sh\). A new \supported-release-lines.txt\ manifest serves as the source of truth for active release lines, and a \RELEASE-NOTES-TEMPLATE.md\ standardizes release documentation.

release · high confidence

The build system introduces several new sbt plugins and configuration files to standardize code quality and streamline development. BufPlugin adds tasks to format, lint, and check Protobuf files, including a custom check to prevent the use of google.protobuf.Value wrappers. CantonScalafmtPlugin extends the build to format and verify .canton script files using scalafmt, handling special masking for '@' annotations. DamlLfPlugin and DamlLfVersion centralize the generation of DAR files for various Language Framework versions and define the supported version ranges. DamlPlugin consolidates Daml-specific build tasks, including parallel DAR building and code generation. BuildCommon aggregates these settings and defines global commands like 'lint' and 'format' to run all checks. Additionally, ComponentTestDamlGenerator provides a utility for creating test projects with specific Daml templates.

project · high confidence

A new StringValidator has been added to the base validation library to ensure strings are safe for storage in Postgres and safe for display. It rejects NUL characters, unpaired UTF-16 surrogates, and non-whitespace control characters (like ESC or BEL), while allowing standard whitespace (tab, newline, carriage return). This prevents data corruption during roundtrips and issues with pretty-printing or rendering, and ensures error messages do not echo potentially sensitive or malformed content.

base/validation · high confidence

Added new Scala source files to the test-evidence generator module to support structured extraction and CSV export of test results. This includes a ScalaTest adapter to discover test suites and handle ignored tests, a generic support object for processing test tags, and specific data models (TestEntry) for Security and Reliability tests. Additionally, a CSV encoder is provided to flatten these test entries into structured CSV output, enabling better tracking and reporting of security properties and reliability scenarios.

base/test-evidence/generator · high confidence

Added a suite of testing utilities to the \base/testing-utils\ module to support development and verification. This includes a \BufferingLogger\ and \SuppressingLoggerDispatcher\ for capturing and filtering log output, an \InMemoryMetricsFactory\ with \MetricValues\ for inspecting metric state in tests, and a \GrpcServer\ trait with helper classes like \StreamConsumer\, \FiniteStreamObserver\, and \SizeBoundObserver\ for managing in-process gRPC server lifecycles and stream interactions. Additionally, a \HelloService\ reference implementation and associated Protobuf definitions are provided to facilitate compatibility checks for gRPC adapters.

base/testing-utils/src/main · high confidence

The CircleCI setup has been restructured to support self-hosted runners and improved cache management. The monolithic config.yml is now generated from modular fragments in the .circleci/config directory using a new build-config.sh script. The pipeline now utilizes Azure Storage for caching compiled classes and SBT dependencies, with keys that account for dependency changes to prevent stale cache hits. Additionally, the configuration defines specific Docker executors for various resource classes (small, medium, large, etc.) and integrates with Datadog for test reporting and metrics.

.circleci · high confidence

New repeatable Flyway migration files have been added to configure default table settings for both H2 and Postgres databases. These migrations ensure that specific database-level configurations, such as auto-vacuum and analyze settings, are applied idempotently to maintain optimal database performance and stability.

_community/common/src/main/resources/db/migration/canton/h2/table\_settings, community/common/src/main/resources/db/migration/canton/postgres/table\settings · high confidence

A new shell script, \recompute-sha256sums.sh\, has been added to the Canton database migration resources. This tool allows developers to regenerate SHA-256 checksum files for existing SQL and Scala migration scripts, a process intended primarily for correcting typos in comments within frozen migration files to ensure deployment integrity.

community/common/src/main/resources/db/migration/canton · high confidence

The repository now includes a \.hooks\ directory containing pre-commit and pre-push scripts that enforce development workflow rules. The pre-commit hook prevents direct commits to local \main\ or \master\ branches, while the pre-push hook blocks pushes to remote \main\ or \master\ branches to ensure changes go through proper review processes. Additionally, a pre-commit hook for Scala files automatically runs \scalafmt\ on staged Scala and SBT files to maintain consistent code formatting.

.hooks · high confidence

The Daml LF engine has been replaced with a new implementation located in the \com.digitalasset.daml.lf.engine\ package. This update introduces a new \Engine\ class that handles command interpretation and transaction submission via a \Result\-based suspension model for external lookups (packages, contracts, keys, and external calls). It adds a thread-safe \ConcurrentCompiledPackages\ manager for shared package compilation, a \Blinding\ module for transaction visibility and party-specific divulgence, and a \ScriptEngine\ for running pure DAML scripts. Configuration is now managed via \EngineConfig\, which controls language versions, authorization checks, profiling, and snapshotting, while \Error\ and \Event\ types define the new error reporting and event emission structures for the engine.

community/daml-lf/engine/src/main/scala/com/digitalasset/daml/lf/engine · high confidence

The Java bindings codegen runtime has been refactored to introduce a new \ValueDecoder\ API for decoding contract payloads and choice arguments, replacing the legacy \fromValue\ function to better handle unknown trailing fields. The \ContractCompanion\ now exposes this decoder and supports JSON decoding via \fromJson\. Additionally, new base classes \ByKey\ and \CreateAnd\ have been added to standardize the generation of \ExerciseByKeyCommand\ and \CreateAndExerciseCommand\ for exercising choices by key or creating and exercising in a single step, while \ContractDecoder\ now supports fallback lookup by package name to handle template version mismatches.

community/bindings-java/src/main/java/com/daml/ledger/javaapi/data/codegen · high confidence

The CI infrastructure now includes dedicated Dockerfiles for the Canton build environment and a PostgreSQL 17 instance for query statistics. The Canton build image installs Nix (v2.24.12) and configures the environment for reproducible builds, while the query-stats image installs PostgreSQL 17 with the pg\_store\_plans extension for performance monitoring. Supporting scripts automate the building, tagging, and pushing of these images to Docker Hub, and update the CircleCI configuration to use the new image tags.

.ci · high confidence

The Canton configuration system now includes a dedicated validation layer and structured error reporting. A new \ConfigValidations\ object enforces cross-field constraints at startup, such as ensuring at least one node is defined, validating database access consistency, checking protocol version compatibility, and verifying that extension service ports and retry delays are correctly configured. Additionally, \ConfigErrors\ provides structured, user-friendly error messages for common issues like missing files, invalid HOCON syntax, or substitution failures, while \CantonConfigDeprecations\ manages the migration of legacy configuration paths (e.g., moving \kms.session-signing-keys\ to \session-signing-keys\ and deprecating \use-new-connection-pool\) to guide users through version upgrades.

community/app-base/src/main/scala/com/digitalasset/canton/config · high confidence

This release introduces a series of database migrations for the PostgreSQL backend, starting with the initial schema (V1.1) that establishes core tables for DAML packages, DARs, cryptographic keys, contracts, and party metadata. Subsequent migrations add debug views (V1.2, V2.1) to simplify querying and introspection of internal state, and introduce the Ledger API 3.0 schema (V2.0) with tables for command completions, contract activation/deactivation events, and pruning candidates. The update also includes performance optimizations such as new indexes for topology caching (V3.0) and ACS commitment pruning (V4.0), adds traffic cost tracking to LAPI completions and events (V4.2, V4.3), and implements DABFT partitioning for ordered block data (V5.2).

community/common/src/main/resources/db/migration/canton/postgres/stable · high confidence

The Speedy interpreter now enforces authorization rules for create, fetch, lookup-by-key, and exercise operations via a new AuthorizationChecker component, and introduces a transaction normalization pass (NormalizeRollbacks) to standardize rollback node structures. Additionally, the interpreter gains a cost model for pricing builtins and expressions, a closure conversion phase for the compiler pipeline, and support for external call results in the transaction model.

community/daml-lf/interpreter/src/main/scala/com/digitalasset/daml/lf/speedy · high confidence

7 commits adding/updating tests in community/ledger/ledger-json-api/src/test/resources/daml-definitions-service-test-resources; Added DAML test suites for engine validation; Added Daml script tests for common ledger features; Added Daml test scenarios for ledger semantics and contract keys; Added Daml test scripts for snapshot replay and time manipulation; Added Daml upgrade integration test scenarios; Added Daml-LF encoder for testing purposes; Added JMH benchmarks for string interning initialization and update performance; Added LF 2.3 script tests for contract keys and exception semantics; Added LF parser testing library for Daml-LF AST; Added LF test suites for exceptions, interfaces, and contract keys; Added Ledger API conformance test infrastructure for gRPC and JSON APIs; Added Scala property-based tests for Java API data models; Added ScalaTest support for structured test evidence tagging; Added conformance tests for Ledger API backwards compatibility; Added conformance tests for specific Ledger API configuration variations; Added engine test coverage for authorization, blinding, and transaction integrity; Added integration tests for Daml Script execution; Added integration tests for ledger-api-bench-tool submission workflows; Added integration tests for the Daml LF upgrades matrix; Added model-based integration tests for IDE ledger and Canton runtime; Added model-based testing infrastructure for generating and validating Canton scenarios; Added participant test infrastructure and conformance examples; Added property-based test generators for Daml LF values; Added property-based tests for JSON API type mappings; Added protocol continuity conformance tests for Ledger API compatibility; Added snapshot replay and extraction integration tests; Added snapshot replay benchmarking and profiling tools; Added test certificate generation script and pre-generated TLS assets; Added test coverage for Canton JSON API v2; Added test coverage for DAR/DALF archive reading and decoding; Added test coverage for LF data types and utilities; Added test coverage for Pekko gRPC adapter, metrics instrumentation, and resource management; Added test fixtures for DamlDefinitionsService and JSON encoding across LF versions 2.1 and 2.3; Added test infrastructure and test coverage for ledger-api-core authentication and API components; Added test infrastructure and unit tests for the BFT block sequencer; Added test infrastructure for resource ownership; Added test infrastructure for sequencing protocol and external KMS; Added test utilities for constructing Daml LF transactions; Added tests for BFT orderer pruning and partition management; Added tests for DAML LF language validation and versioning; Added tests for Java JSON encoding and decoding logic; Added tests for LF crypto hashing stability and encoding; Added tests for LF interpreter stability, authorization, and performance; Added tests for LF transaction validation and state machine logic; Added tests for LF value serialization and ContractId construction; Added tests for P2P network output and endpoint storage modules; Added tests for PrimitiveValueDecoders record validation; Added tests for external call behavior in LF 2.4 staging; Added tests for interface type signatures and NonEmpty collection utilities; Added tests for latest protocol continuity conformance; Added tests for performance driver components; Added tests for script submission error handling; Added tests for the Daml LF encoder archive generation; Added tests for the ReferenceInterpreter; Added tests for the ledger API benchmark tool; Added tests for transaction validator limits; Added unit tests for BFT ordering consensus components; Added unit tests for BFT state transfer and catch-up logic; Added unit tests for metrics context merging and OpenTelemetry attribute conversion; Added unit tests for the Daml LF upgrade matrix; Added upgrade-check tests for parallel validation of Daml schema changes; Added validation test suite for DAML LF; Expanded LF encoder test coverage for Daml-LF 2.x; New test infrastructure and conformance suites for KMS and Sequencer drivers; Updated test certificate chain for ledger-json-api.

The example applications for interactive submission and multi-synchronizer scenarios now specify pinned versions for Python packages (cryptography, grpcio-tools, protobuf) and TypeScript libraries (openapi-typescript, typescript, openapi-fetch, etc.), ensuring consistent environments for these demos. Additionally, the project introduces a pyproject.toml to configure the Ruff linter and pytest for the scripts directory, standardizing code formatting and test collection for Python utilities.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 68 → 61 (-7.1)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 98 → 50 (-47.9)
• Architecture 89 → 90 (+1.0)
• Maturity 76 → 79 (+2.3)
• Readiness 73 → 68 (-4.3)
• Security 57 → 65 (+8.4)
• Performance 80 (new)

• Documentation: no installation or build instructions (docs-open/README.md)
• Documentation: no usage examples (docs-open/README.md)
• No direct assertions: testBool (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• No direct assertions: testBool (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfEncodersTest.java)
• No direct assertions: testBoolErrors (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• No direct assertions: testContractId (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• No direct assertions: testContractId (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfEncodersTest.java)
• No direct assertions: testContractIdErrors (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• No direct assertions: testDate (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• No direct assertions: testDate (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfEncodersTest.java)
• No direct assertions: testDateErrors (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• No direct assertions: testEnum (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• No direct assertions: testEnum (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfEncodersTest.java)
• No direct assertions: testEnumErrors (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• No direct assertions: testGenMap (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• No direct assertions: testGenMap (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfEncodersTest.java)
• No direct assertions: testGenMapErrors (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• No direct assertions: testInt64 (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• No direct assertions: testInt64 (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfEncodersTest.java)
• No direct assertions: testInt64Errors (community/bindings-java/src/test/java/com/daml/ledger/javaapi/data/codegen/json/JsonLfDecodersTest.java)
• …and 135 more

• ACSReader.doStreamActiveContracts (cognitive 25) (community/ledger/ledger-api-core/src/main/scala/com/digitalasset/canton/platform/store/dao/events/ACSReader.scala)
• ACSReader.doStreamActiveContracts (cyclomatic 22) (community/ledger/ledger-api-core/src/main/scala/com/digitalasset/canton/platform/store/dao/events/ACSReader.scala)
• AbstractMessageProcessor.registerRequestWithTimeout (cognitive 22) (community/participant/src/main/scala/com/digitalasset/canton/participant/protocol/AbstractMessageProcessor.scala)
• AcsCommitmentProcessor.checkMatchAndMarkSafeOrFixDuringCatchUp (cognitive 99) (community/participant/src/main/scala/com/digitalasset/canton/participant/pruning/AcsCommitmentProcessor.scala)
• AcsCommitmentProcessor.checkMatchAndMarkSafeOrFixDuringCatchUp (cyclomatic 17) (community/participant/src/main/scala/com/digitalasset/canton/participant/pruning/AcsCommitmentProcessor.scala)
• AcsCommitmentProcessor.matches (cognitive 18) (community/participant/src/main/scala/com/digitalasset/canton/participant/pruning/AcsCommitmentProcessor.scala)
• AcsCommitmentProcessor.publishTickInternal (cognitive 249) (community/participant/src/main/scala/com/digitalasset/canton/participant/pruning/AcsCommitmentProcessor.scala)
• AcsCommitmentProcessor.publishTickInternal (cyclomatic 49) (community/participant/src/main/scala/com/digitalasset/canton/participant/pruning/AcsCommitmentProcessor.scala)
• AcsCommitmentProcessor.reinitializeCommitments (cognitive 27) (community/participant/src/main/scala/com/digitalasset/canton/participant/pruning/AcsCommitmentProcessor.scala)
• AcsCommitmentProcessor.sendCommitmentMessages (cognitive 30) (community/participant/src/main/scala/com/digitalasset/canton/participant/pruning/AcsCommitmentProcessor.scala)
• AcsCommitmentProcessor.sendCommitmentMessages (cyclomatic 19) (community/participant/src/main/scala/com/digitalasset/canton/participant/pruning/AcsCommitmentProcessor.scala)
• AcsCommitmentProcessor.sendCommitmentMessagesInCatchUpInterval (cognitive 24) (community/participant/src/main/scala/com/digitalasset/canton/participant/pruning/AcsCommitmentProcessor.scala)
• AcsCommitmentProcessor.sendCommitmentMessagesInCatchUpInterval (cyclomatic 16) (community/participant/src/main/scala/com/digitalasset/canton/participant/pruning/AcsCommitmentProcessor.scala)
• AcsCommitmentProcessor.stakeholderCommitmentsPerParticipant (cognitive 20) (community/participant/src/main/scala/com/digitalasset/canton/participant/pruning/AcsCommitmentProcessor.scala)
• AcsCommitmentSenderImpl.processCommitmentsUpTo (cognitive 22) (community/participant/src/main/scala/com/digitalasset/canton/participant/commitment/AcsCommitmentSender.scala)
• AcsCommitmentSenderImpl.sendSingleBatch (cognitive 52) (community/participant/src/main/scala/com/digitalasset/canton/participant/commitment/AcsCommitmentSender.scala)
• AcsCommitmentSenderImpl.sendSingleBatch (cyclomatic 18) (community/participant/src/main/scala/com/digitalasset/canton/participant/commitment/AcsCommitmentSender.scala)
• AcsCommitmentSummary.fromProtoV32 (cognitive 28) (community/base/src/main/scala/com/digitalasset/canton/protocol/messages/AcsCommitmentSummary.scala)
• AcsDigestConsistencyChecker.verifyParticipantsAcsDigestConsistency (cognitive 16) (community/integration-testing/src/main/scala/com/digitalasset/canton/integration/AcsDigestConsistencyChecker.scala)
• AcsDigestStore.checkReplacesInvariant (cognitive 17) (community/participant/src/main/scala/com/digitalasset/canton/participant/store/AcsDigestStore.scala)
• …and 1506 more

• 2 commits — 2 feature/other, 0 fixes

• community/ledger — 1 commit
• community/participant — 1 commit

• change: [main] Update 2026-09-22.22 (#674)
• change: [main] Update 2026-09-30.14 (#679)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

digital-asset/canton was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.