[main] Update 2026-01-20.22 (#427)

Reference commit: 6d8af8e330

Author: canton-machine

UNRELEASED.md

@@ -17,11 +17,21 @@ Template for a bigger topic
 
 #### Impact and Migration
 
+- JSON Ledger API OpenAPI/AsyncAPI spec corrections
+  - Fields not marked as required in the Ledger API `.proto` specification are now also optional in the OpenAPI/AsyncAPI specifications.
+    If your client code is using code generated using previous versions of these specifications, it may not compile or function correctly with the new version. To migrate:
+      - If you prefer not to update your code, continue using the previous specification versions as the JSON API server preserves backward compatibility.
+      - If you want to use new endpoints, features or leverage the new less strict spec, migrate to the new OpenAPI/AsyncAPI specifications as follows:
+        - Java clients: No changes are needed if you use the `OpenAPI Generator`. Otherwise, potentially optionality of fields should be handled appropriately for other code generators.
+        - TypeScript clients: Update your code to handle optional fields, using the `!` or `??` operators as appropriate.
+  - From Canton 3.5 onwards, OpenAPI/AsyncAPI specification files are suffixed with the Canton version (e.g., `openapi-3.5.0.yaml`).
+  - Canton 3.5 is compatible with OpenAPI specification files from version 3.4.0 to 3.5.0 (inclusive).
+
 ### Minor Improvements
+- Changed the path for `crypto.kms.session-signing-keys` (deprecated) to `crypto.session-signing-keys` so that session signing key configuration is no longer directly tied to a KMS. However, session signing keys can still only be enabled when using a KMS provider or when running with `non-standard-config=true`.
 - Added a new configuration parameter for session signing keys, `toleranceShiftDuration`, and updated `cutOffDuration` to allow a zero duration.
 - Ledger JSON Api changes:
-  - extra fields in JSON objects are no longer tolerated,
-  - All JSON values are optional by default upon decoding (this is not reflected in the openapi spec yet, but written comments should reflect the optionality),
+    - The Ledger JSON API server now enforces that only fields marked as required by the Ledger API OpenAPI/AsyncAPI specification are mandatory in request payloads.
 - ApiRequestLogger now also used by Ledger JSON Api. Changes:
     - Redundant Request TID removed from logs.
     - Additional CLI options added: `--log-access`, `--log-access-errors`...
@@ -49,6 +59,25 @@ For parties with signing keys both in `PartyToParticipant` and `PartyToKeyMappin
   ```
   canton.monitoring.tracing.tracer.exporter.type=otlp
   ```
+- On Ledger API interface subscriptions, the `CreatedEvent.interface_views` now returns the ID of the package containing
+  the interface implementation that was used to compute the specific interface view as `InterfaceView.implementation_package_id`.
+- *BREAKING* The Postgres configuration of the indexer is separated from the Postgres configuration of the lapi server
+  (`canton.participants.<participant>.ledger-api.postgres-data-source`).
+  The new parameter `canton.participants.<participant>.parameters.ledger-api-server.indexer.postgres-data-source` should
+  be used instead.
+- Added network timeout and client_connection_check_interval for db operations in the lapi server and indexer to avoid
+  hanging connections for Postgres (see PostgresDataSourceConfig). The defaults are 60 seconds network timeout and
+  5 seconds client_connection_check_interval for the lapi server, and 20 seconds network timeout and
+  5 seconds client_connection_check_interval for the indexer. These values can be configured via the new configuration parameters
+  `canton.participants.<participant>.ledger-api.postgres-data-source.network-timeout` for network timeout of the lapi
+  server and `canton.participants.<participant>.parameters.ledger-api-server.indexer.postgres-data-source.client-connection-check-interval`
+  for the client_connection_check_interval of the indexer.
+- We have changed the way that OffsetCheckpoints are populated to always generate at least one when an open-ended
+  updates or completions stream is requested. An OffsetCheckpoint can have offset equal to the exclusive start for which
+  the stream is requested. This ensures that checkpoints are visible even when there are no updates, and the stream was
+  requested to begin exclusively from the ledger end.
+
+* Additional metrics for the ACS commitment processor: `daml.participant.sync.commitments.last-incoming-received`, `daml.participant.sync.commitments.last-incoming-processed`, `daml.participant.sync.commitments.last-locally-completed`, and `daml.participant.sync.commitments.last-locally-checkpointed`.
 
 ### Preview Features
 - preview feature
@@ -120,3 +149,5 @@ Canton has been tested against the following versions of its dependencies:
 ## update to GRPC 1.77.0
 
 removes [CVE-2025-58057](https://github.com/advisories/GHSA-3p8m-j85q-pgmj) from security reports.
+
+

base/safe-proto/src/test/scala/com/daml/SafeProtoTest.scala

@@ -8,33 +8,42 @@ import org.scalatest.Inside
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.wordspec.AnyWordSpec
 
+// The test is designed to need less than 1Gb of Heap
 class SafeProtoTest extends AnyWordSpec with Inside with Matchers {
 
   private[this] def tuple(v: Value) =
     Value.newBuilder().setListValue(ListValue.newBuilder().addValues(v).addValues(v)).build()
 
-  private[this] val value0 = Value.newBuilder().setStringValue("a" * 1024 * 1024 * 1024).build()
-  assert(value0.getSerializedSize > 0)
-  private[this] val value1 = tuple(value0)
-  assert(value1.getSerializedSize < 0)
-  private[this] val value2 = tuple(value1)
-  assert(value2.getSerializedSize >= 0)
+  // We maximize structural sharing to limit the JVM heap memory usage.
+  // This allows us to create objects that would serialize to massive sizes (e.g. > 512MB or 4GB)
+  // without actually consuming that much RAM.
+  private[this] lazy val values =
+    LazyList.iterate(Value.newBuilder().setStringValue("a" * 1024).build())(tuple)
+
+  // values(19), and  values(20) are technically serializable, but their serialization requires over 500 MB of memory.
+  // We skip it to avoid excessive memory pressure on CI agents.
+  private[this] val value18 = values(18) // serialization needs a bit more than 256MB
+  assert(value18.getSerializedSize > 0)
+  private[this] val value21 = values(21) // serialization would need a bit more than 2GB
+  assert(value21.getSerializedSize < 0)
+  private[this] val value22 = values(22) // serialization would need a bit more than 4GB
+  assert(value22.getSerializedSize >= 0)
 
   "toByteString" should {
 
     "fail gracefully if the message to serialize exceeds 2GB" in {
-      SafeProto.toByteString(value0) shouldBe a[Right[?, ?]]
-      SafeProto.toByteString(value1) shouldBe a[Left[?, ?]]
-      SafeProto.toByteString(value2) shouldBe a[Left[?, ?]]
+      SafeProto.toByteString(value18) shouldBe a[Right[?, ?]]
+      SafeProto.toByteString(value21) shouldBe a[Left[?, ?]]
+      SafeProto.toByteString(value22) shouldBe a[Left[?, ?]]
     }
   }
 
   "toByteArray" should {
 
     "fail gracefully if the message to serialize exceeds 2GB" in {
-      SafeProto.toByteArray(value0) shouldBe a[Right[?, ?]]
-      SafeProto.toByteArray(value1) shouldBe a[Left[?, ?]]
-      SafeProto.toByteArray(value2) shouldBe a[Left[?, ?]]
+      SafeProto.toByteArray(value18) shouldBe a[Right[?, ?]]
+      SafeProto.toByteArray(value21) shouldBe a[Left[?, ?]]
+      SafeProto.toByteArray(value22) shouldBe a[Left[?, ?]]
     }
   }
 

base/util-external/src/main/scala/com/digitalasset/canton/config/RequireTypes.scala

@@ -269,6 +269,7 @@ object RequireTypes {
     lazy val one: PositiveInt = PositiveInt.tryCreate(1)
     lazy val two: PositiveInt = PositiveInt.tryCreate(2)
     lazy val three: PositiveInt = PositiveInt.tryCreate(3)
+    lazy val four: PositiveInt = PositiveInt.tryCreate(4)
     lazy val MaxValue: PositiveInt = PositiveInt.tryCreate(Int.MaxValue)
   }
 

base/util-external/src/main/scala/com/digitalasset/canton/util/Mutex.scala

@@ -13,8 +13,8 @@ import java.util.concurrent.locks.ReentrantLock
 class Mutex {
   private val lock = new ReentrantLock()
 
-  @deprecated("use harmonize, not synchronize", since = "3.4")
-  def synchronized[T](body: => T): T = sys.error("use harmonize to distinguish")
+  @deprecated("use exclusive, not synchronize", since = "3.4")
+  def synchronized[T](body: => T): T = sys.error("use exclusive to distinguish")
 
   def exclusive[T](f: => T): T = {
     def runAndUnlock() =
@@ -33,7 +33,6 @@ class Mutex {
       }
     }
   }
-
 }
 
 object Mutex {

buf.work.yaml

@@ -7,7 +7,10 @@ directories:
   - community/base/src/main/protobuf
   - community/synchronizer/src/main/protobuf
   - community/ledger-api-proto/src/main/protobuf
-  - community/lib/ledger-api-value/target/protobuf_external
   - community/ledger/ledger-api-core/src/main/protobuf
   - community/lib/google-common-protos-scala/target/protobuf_external
   - community/participant/src/main/protobuf
+  - community/daml-lf/snapshot/src/main/protobuf
+  - community/daml-lf/archive/src/main/protobuf
+  - community/daml-lf/transaction/src/main/protobuf
+  - community/daml-lf/ledger-api-value/src/main/protobuf

community-build.sbt

@@ -48,6 +48,14 @@ lazy val `kms-driver-testing` = CommunityProjects.`kms-driver-testing`
 lazy val `kms-driver-testing-lib` = CommunityProjects.`kms-driver-testing-lib`
 lazy val `aws-kms-driver` = CommunityProjects.`aws-kms-driver`
 lazy val `mock-kms-driver` = CommunityProjects.`mock-kms-driver`
+lazy val `transcode-schema` = CommunityProjects.`transcode-schema`
+lazy val `transcode-daml-lf` = CommunityProjects.`transcode-daml-lf`
+lazy val `transcode-codec-json` = CommunityProjects.`transcode-codec-json`
+lazy val `transcode-codec-proto-java` = CommunityProjects.`transcode-codec-proto-java`
+lazy val `transcode-codec-proto-scala` = CommunityProjects.`transcode-codec-proto-scala`
+lazy val `transcode-daml-examples` = CommunityProjects.`transcode-daml-examples`
+lazy val `transcode-test-conformance` = CommunityProjects.`transcode-test-conformance`
+lazy val `transcode-test-utils` = CommunityProjects.`transcode-test-utils`
 lazy val `ledger-api-core` = CommunityProjects.`ledger-api-core`
 lazy val `ledger-json-api` = CommunityProjects.`ledger-json-api`
 lazy val `ledger-json-client` = CommunityProjects.`ledger-json-client`
@@ -76,9 +84,9 @@ lazy val `resources-pekko` = DamlProjects.`resources-pekko`
 lazy val `resources-grpc` = DamlProjects.`resources-grpc`
 lazy val `ledger-resources` = DamlProjects.`ledger-resources`
 lazy val `timer-utils` = DamlProjects.`timer-utils`
-lazy val `crypto` = DamlProjects.`crypto`
+lazy val crypto = DamlProjects.crypto
 lazy val `safe-proto` = DamlProjects.`safe-proto`
-lazy val `nameof` = DamlProjects.`nameof`
+lazy val nameof = DamlProjects.nameof
 lazy val `testing-utils` = DamlProjects.`testing-utils`
 lazy val `grpc-test-utils` = DamlProjects.`grpc-test-utils`
 lazy val `rs-grpc-testing-utils` = DamlProjects.`rs-grpc-testing-utils`
@@ -93,6 +101,23 @@ lazy val `executors` = DamlProjects.`executors`
 lazy val `observability-metrics` = DamlProjects.`observability-metrics`
 lazy val `observability-tracing` = DamlProjects.`observability-tracing`
 lazy val `observability-pekko-http-metrics` = DamlProjects.`observability-pekko-http-metrics`
+lazy val `daml-lf-data` = DamlProjects.`daml-lf-data`
+lazy val `daml-lf-repl` = DamlProjects.`daml-lf-repl`
+lazy val `daml-lf-ide-ledger` = DamlProjects.`daml-lf-ide-ledger`
+lazy val `daml-lf-language` = DamlProjects.`daml-lf-language`
+lazy val `daml-lf-transaction` = DamlProjects.`daml-lf-transaction`
+lazy val `daml-lf-archive` = DamlProjects.`daml-lf-archive`
+lazy val `daml-lf-stable-packages` = DamlProjects.`daml-lf-stable-packages`
+lazy val `daml-lf-validation` = DamlProjects.`daml-lf-validation`
+lazy val `daml-lf-snapshot-proto` = DamlProjects.`daml-lf-snapshot-proto`
+lazy val `daml-lf-snapshot` = DamlProjects.`daml-lf-snapshot`
+lazy val `daml-lf-interpreter` = DamlProjects.`daml-lf-interpreter`
+lazy val `daml-lf-engine` = DamlProjects.`daml-lf-engine`
+lazy val `daml-lf-parser` = DamlProjects.`daml-lf-parser`
+lazy val `daml-lf-encoder` = DamlProjects.`daml-lf-encoder`
+lazy val `daml-lf-archive-encoder` = DamlProjects.`daml-lf-archive-encoder`
+lazy val `daml-lf-api-type-signature` = DamlProjects.`daml-lf-api-type-signature`
+lazy val `daml-lf-tests` = DamlProjects.`daml-lf-tests`
 
 lazy val root = (project in file("."))
   .disablePlugins(WartRemover)

community/app-base/src/main/scala/com/digitalasset/canton/admin/api/client/commands/SequencerBftAdminCommands.scala

@@ -12,6 +12,8 @@ import com.digitalasset.canton.sequencer.admin.v30.{
   GetOrderingTopologyResponse,
   GetPeerNetworkStatusRequest,
   GetPeerNetworkStatusResponse,
+  GetWriteReadinessRequest,
+  GetWriteReadinessResponse,
   RemovePeerEndpointRequest,
   RemovePeerEndpointResponse,
   SequencerBftAdministrationServiceGrpc,
@@ -21,6 +23,7 @@ import com.digitalasset.canton.sequencer.admin.v30.{
 import com.digitalasset.canton.synchronizer.sequencer.block.bftordering.admin.SequencerBftAdminData.{
   OrderingTopology,
   PeerNetworkStatus,
+  WriteReadiness,
   endpointIdToProto,
   endpointToProto,
 }
@@ -114,6 +117,28 @@ object SequencerBftAdminCommands {
       PeerNetworkStatus.fromProto(response)
   }
 
+  final case object GetWriteReadiness
+      extends BaseSequencerBftAdministrationCommand[
+        GetWriteReadinessRequest,
+        GetWriteReadinessResponse,
+        WriteReadiness,
+      ] {
+
+    override protected def createRequest(): Either[String, GetWriteReadinessRequest] =
+      Right(GetWriteReadinessRequest())
+
+    override protected def submitRequest(
+        service: SequencerBftAdministrationServiceStub,
+        request: GetWriteReadinessRequest,
+    ): Future[GetWriteReadinessResponse] =
+      service.getWriteReadiness(request)
+
+    override protected def handleResponse(
+        response: GetWriteReadinessResponse
+    ): Either[String, WriteReadiness] =
+      WriteReadiness.fromProto(response)
+  }
+
   final case class GetOrderingTopology()
       extends BaseSequencerBftAdministrationCommand[
         GetOrderingTopologyRequest,

community/app-base/src/main/scala/com/digitalasset/canton/admin/api/client/commands/TopologyAdminCommands.scala

@@ -660,16 +660,15 @@ object TopologyAdminCommands {
     }
 
     final case class LogicalUpgradeState(
-        observer: StreamObserver[LogicalUpgradeStateResponse]
+        store: Option[TopologyStoreId],
+        observer: StreamObserver[LogicalUpgradeStateResponse],
     ) extends BaseCommand[
           v30.LogicalUpgradeStateRequest,
           CancellableContext,
           CancellableContext,
         ] {
       override protected def createRequest(): Either[String, v30.LogicalUpgradeStateRequest] =
-        Right(
-          v30.LogicalUpgradeStateRequest()
-        )
+        Right(v30.LogicalUpgradeStateRequest(store.map(_.toProtoV30)))
 
       override protected def submitRequest(
           service: TopologyManagerReadServiceStub,

community/app-base/src/main/scala/com/digitalasset/canton/config/CantonConfig.scala

@@ -454,6 +454,7 @@ final case class CantonConfig(
         commitmentMismatchDebugging = participantParameters.commitmentMismatchDebugging,
         commitmentProcessorNrAcsChangesBehindToTriggerCatchUp =
           participantParameters.commitmentProcessorNrAcsChangesBehindToTriggerCatchUp,
+        commitmentReduceParallelism = participantParameters.commitmentReduceParallelism,
         autoSyncProtocolFeatureFlags = participantParameters.autoSyncProtocolFeatureFlags,
       )
     }
@@ -750,8 +751,21 @@ object CantonConfig {
         deriveReader[KmsConfig.Driver]
       implicit val kmsConfigReader: ConfigReader[KmsConfig] =
         deriveReader[KmsConfig]
-      implicit val cryptoReader: ConfigReader[CryptoConfig] =
-        deriveReader[CryptoConfig]
+      implicit val cryptoReader: ConfigReader[CryptoConfig] = {
+
+        implicit val deprecatedFields: DeprecatedFieldsFor[CryptoConfig] =
+          new DeprecatedFieldsFor[CryptoConfig] {
+            override def movedFields: List[DeprecatedConfigUtils.MovedConfigPath] = List(
+              DeprecatedConfigUtils.MovedConfigPath(
+                "kms.session-signing-keys",
+                since = "3.5.0",
+                to = Seq("session-signing-keys"),
+              )
+            )
+          }
+
+        deriveReader[CryptoConfig].applyDeprecations
+      }
     }
 
     lazy implicit final val sequencerTestingInterceptorReader