[main] Update 2025-12-30.22 (#419)

Reference commit: e7c5d269dc

Author: canton-machine

UNRELEASED.md

@@ -42,6 +42,12 @@ For parties with signing keys both in `PartyToParticipant` and `PartyToKeyMappin
   an optional argument, as well as `filter-party`.
 - Protect the admin participant from self lock-out. It is now impossible for an admin to remove own admin rights or
   delete itself.
+- *BREAKING* The default OTLP gRPC port that the Canton connects to in order to export the traces has been changed from
+  4318 to 4317. This aligns the default configuration of Canton with the default configuration of the OpenTelemetry
+  Collector. This change affects only the users who have configured an OTLP trace export through
+  ```
+  canton.monitoring.tracing.tracer.exporter.type=otlp
+  ```
 
 ### Preview Features
 - preview feature

base/concurrent/src/main/scala/com/daml/concurrent/ExecutionContextOf.scala

@@ -0,0 +1,18 @@
+// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.daml.concurrent
+
+import scala.concurrent as sc
+
+sealed abstract class ExecutionContextOf {
+  type T[+P] <: sc.ExecutionContext
+  private[concurrent] def subst[F[_], P](fe: F[sc.ExecutionContext]): F[T[P]]
+}
+
+object ExecutionContextOf {
+  val Instance: ExecutionContextOf = new ExecutionContextOf {
+    type T[+P] = sc.ExecutionContext
+    override private[concurrent] def subst[F[_], P](fe: F[sc.ExecutionContext]) = fe
+  }
+}

base/concurrent/src/main/scala/com/daml/concurrent/FutureOf.scala

@@ -0,0 +1,169 @@
+// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.daml.concurrent
+
+import scalaz.std.scalaFuture.*
+import scalaz.{Catchable, Cobind, Isomorphism, Leibniz, MonadError, Nondeterminism, Semigroup}
+
+import scala.concurrent as sc
+import scala.language.implicitConversions
+import scala.util.Try
+
+import Isomorphism.<~>
+import Leibniz.===
+
+sealed abstract class FutureOf {
+
+  /** We don't use [[scala.concurrent.Future]] as the upper bound because it has methods that
+    * collide with the versions we want to use, i.e. those that preserve the phantom `EC` type
+    * parameter. By contrast, [[scala.concurrent.Awaitable]] has only the `ready` and `result`
+    * methods, which are mostly useless.
+    */
+  type T[-EC, +A] <: sc.Awaitable[A]
+  private[concurrent] def subst[F[_[+_]], EC](ff: F[sc.Future]): F[T[EC, +*]]
+}
+
+/** Instances and methods for `FutureOf`. You should not import these; instead, enable
+  * `-Xsource:2.13` and they will always be available without import.
+  */
+object FutureOf {
+  val Instance: FutureOf = new FutureOf {
+    type T[-EC, +A] = sc.Future[A]
+    override private[concurrent] def subst[F[_[+_]], EC](ff: F[sc.Future]) = ff
+  }
+
+  type ScalazF[F[+_]] = Nondeterminism[F]
+    with Cobind[F]
+    with MonadError[F, Throwable]
+    with Catchable[F]
+
+  implicit def `future Instance`[EC: ExecutionContext]: ScalazF[Future[EC, +*]] =
+    Instance.subst[ScalazF, EC](implicitly)
+
+  implicit def `future Semigroup`[A: Semigroup, EC: ExecutionContext]: Semigroup[Future[EC, A]] = {
+    type K[T[+_]] = Semigroup[T[A]]
+    Instance.subst[K, EC](implicitly)
+  }
+
+  implicit def `future is any type`[A]: sc.Future[A] === Future[Any, A] =
+    Instance.subst[Lambda[`t[+_]` => sc.Future[A] === t[A]], Any](Leibniz.refl)
+
+  /** A [[scala.concurrent.Future]] converts to our [[Future]] with any choice of EC type. */
+  implicit def `future is any`[A](sf: sc.Future[A]): Future[Any, A] =
+    `future is any type`(sf)
+
+  private[this] def unsubstF[Arr[_, +_], A, B](f: A Arr Future[Nothing, B]): A Arr sc.Future[B] = {
+    type K[T[+_]] = (A Arr T[B]) => A Arr sc.Future[B]
+    (Instance.subst[K, Nothing](identity))(f)
+  }
+
+  def swapExecutionContext[L, R]: Future[L, *] <~> Future[R, *] =
+    Instance.subst[Lambda[`t[+_]` => t <~> Future[R, *]], L](
+      Instance.subst[Lambda[`t[+_]` => sc.Future <~> t], R](implicitly[sc.Future <~> sc.Future])
+    )
+
+  /** Common methods like `map` and `flatMap` are not provided directly; instead, import the
+    * appropriate Scalaz syntax for these; `scalaz.syntax.bind._` will give you `map`, `flatMap`,
+    * and most other common choices. Only exotic Future-specific combinators are provided here.
+    */
+  implicit final class Ops[-EC, +A](private val self: Future[EC, A]) extends AnyVal {
+
+    /** `.require[NEC]` is a friendly alias for `: Future[NEC, A]`. */
+    def require[NEC <: EC]: Future[NEC, A] = self
+
+    def transform[B](f: Try[A] => Try[B])(implicit ec: ExecutionContext[EC]): Future[EC, B] =
+      self.removeExecutionContext transform f
+
+    // The rule of thumb is "EC determines what happens next". So `recoverWith`
+    // doesn't let the Future returned by pf control what EC it uses to *call* pf,
+    // because that happens "before".  Same with `transformWith`.  By contrast,
+    // zipWith's f gets called "after" the two futures feeding it arguments, so
+    // we allow both futures control over the EC used to invoke f.
+
+    def transformWith[LEC <: EC, B](f: Try[A] => Future[LEC, B])(implicit
+        ec: ExecutionContext[EC]
+    ): Future[LEC, B] =
+      self.removeExecutionContext transformWith unsubstF(f)
+
+    def collect[B](pf: A PartialFunction B)(implicit ec: ExecutionContext[EC]): Future[EC, B] =
+      self.removeExecutionContext collect pf
+
+    def failed: Future[EC, Throwable] = self.removeExecutionContext.failed
+
+    def fallbackTo[LEC <: EC, B >: A](that: Future[LEC, B]): Future[LEC, B] =
+      self.removeExecutionContext fallbackTo that.removeExecutionContext
+
+    def filter(p: A => Boolean)(implicit ec: ExecutionContext[EC]): Future[EC, A] =
+      self.removeExecutionContext filter p
+
+    def withFilter(p: A => Boolean)(implicit ec: ExecutionContext[EC]): Future[EC, A] =
+      self.removeExecutionContext withFilter p
+
+    def recover[B >: A](pf: Throwable PartialFunction B)(implicit
+        ec: ExecutionContext[EC]
+    ): Future[EC, B] =
+      self.removeExecutionContext recover pf
+
+    def recoverWith[LEC <: EC, B >: A](pf: Throwable PartialFunction Future[LEC, B])(implicit
+        ec: ExecutionContext[EC]
+    ): Future[EC, B] =
+      self.removeExecutionContext recoverWith unsubstF(pf)
+
+    def transform[B](s: A => B, f: Throwable => Throwable)(implicit
+        ec: ExecutionContext[EC]
+    ): Future[EC, B] =
+      self.removeExecutionContext.transform(s, f)
+
+    def foreach[U](f: A => U)(implicit ec: ExecutionContext[EC]): Unit =
+      self.removeExecutionContext foreach f
+
+    def andThen[U](pf: Try[A] PartialFunction U)(implicit ec: ExecutionContext[EC]): Future[EC, A] =
+      self.removeExecutionContext andThen pf
+
+    def onComplete[U](f: Try[A] => U)(implicit ec: ExecutionContext[EC]): Unit =
+      self.removeExecutionContext onComplete f
+
+    def zip[LEC <: EC, B](that: Future[LEC, B]): Future[LEC, (A, B)] = {
+      type K[T[+_]] = (T[A], T[B]) => T[(A, B)]
+      Instance.subst[K, LEC](_ zip _)(self, that)
+    }
+
+    def zipWith[LEC <: EC, B, C](
+        that: Future[LEC, B]
+    )(f: (A, B) => C)(implicit ec: ExecutionContext[LEC]): Future[LEC, C] = {
+      type K[T[+_]] = (T[A], T[B]) => T[C]
+      Instance.subst[K, LEC](_.zipWith(_)(f))(self, that)
+    }
+  }
+
+  /** Operations that don't refer to an ExecutionContext. */
+  implicit final class NonEcOps[+A](private val self: Future[Nothing, A]) extends AnyVal {
+
+    /** Switch execution contexts for later operations. This is not necessary if `NEC <: EC`, as the
+      * future will simply widen in those cases, or you can use `require` instead, which implies
+      * more safety.
+      */
+    def changeExecutionContext[NEC]: Future[NEC, A] =
+      swapExecutionContext[Nothing, NEC].to(self)
+
+    /** The "unsafe" conversion to Future. Does nothing itself, but removes the control on which
+      * [[scala.concurrent.ExecutionContext]] is used for later operations.
+      */
+    def removeExecutionContext: sc.Future[A] =
+      self.changeExecutionContext[Any].asScala
+
+    def isCompleted: Boolean = self.removeExecutionContext.isCompleted
+
+    def value: Option[Try[A]] = self.removeExecutionContext.value
+  }
+
+  /** Operations safe if the Future is set to any ExecutionContext. */
+  implicit final class AnyOps[+A](private val self: Future[Any, A]) extends AnyVal {
+
+    /** The "safe" conversion to Future. `EC = Any` already means "use any ExecutionContext", so
+      * there is little harm in restating that by referring directly to [[scala.concurrent.Future]].
+      */
+    def asScala: sc.Future[A] = `future is any type`[A].flip(self)
+  }
+}

base/concurrent/src/main/scala/com/daml/concurrent/package.scala

@@ -0,0 +1,112 @@
+// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.daml
+
+import scalaz.Id.Id
+
+import scala.concurrent as sc
+import scala.util.Try
+
+/** A compatible layer for `scala.concurrent` with extra type parameters to control
+  * `ExecutionContext`s. Deliberately uses the same names as the equivalent concepts in
+  * `scala.concurrent`.
+  *
+  * The trouble with [[scala.concurrent.ExecutionContext]] is that it is used incoherently. This
+  * leads to the problems described in
+  * https://failex.blogspot.com/2020/05/global-typeclass-coherence-principles-3.html . The extension
+  * layer in this package adds a phantom type parameter to `ExecutionContext` and related types, so
+  * that types can be used to discriminate between ExecutionContexts at compile-time, and so Futures
+  * can declare which ExecutionContext their operations are in.
+  *
+  * For Scala 2.12, you must pass `-Xsource:2.13` to scalac for methods and conversions to be
+  * automatically found. You must also `import scalaz.syntax.bind._` or similar for Future methods
+  * like `map`, `flatMap`, and so on.
+  *
+  * There are no constraints on the `EC` type variable; you need only declare types you wish to use
+  * for it that are sufficient for describing the domains in which you want ExecutionContexts to be
+  * discriminated. These types will never be instantiated, so you can simply declare that they
+  * exist. They can be totally separate, or have subtyping relationships; any subtyping
+  * relationships they have will be reflected in equivalent subtyping relationships between the
+  * resulting `ExecutionContext`s; if you declare `sealed trait Elephant extends Animal`, then
+  * automatically `ExecutionContext[Elephant] <: ExecutionContext[Animal]` with scalac preferring
+  * the former when available (because it is "more specific"). They can even be singleton types, so
+  * you might use `x.type` to suggest that the context is associated with the exact value of the `x`
+  * variable.
+  *
+  * If you want to, say, refer to both [[scala.concurrent.Future]] and [[concurrent.Future]] in the
+  * same file, we recommend importing *the containing package* with an alias rather than renaming
+  * each individual class you import. For example,
+  *
+  * {{{
+  *   import com.daml.concurrent._
+  *   import scala.{concurrent => sc}
+  *   // OR
+  *   import scala.concurrent._
+  *   import com.daml.{concurrent => dc}
+  * }}}
+  *
+  * The exact name isn't important, but you should pick a short one that is sufficiently suggestive
+  * for you.
+  *
+  * You should always be able to remove the substring `Of.Instance.T` from any inferred type; we
+  * strongly suggest doing this for clarity.
+  *
+  * Demonstrations of the typing behavior can be found in FutureSpec and ExecutionContextSpec. This
+  * library has no interesting runtime characteristics; you should think of it as exactly like
+  * `scala.concurrent` in that regard.
+  */
+package object concurrent {
+
+  /** Like [[scala.concurrent.Future]] but with an extra type parameter indicating which
+    * [[ExecutionContext]] should be used for `map`, `flatMap` and other operations.
+    */
+  type Future[-EC, +A] = FutureOf.Instance.T[EC, A]
+
+  /** A subtype of [[scala.concurrent.ExecutionContext]], more specific as `P` gets more specific.
+    */
+  type ExecutionContext[+P] = ExecutionContextOf.Instance.T[P]
+}
+
+// keeping the companions with the same-named type aliases in same file
+package concurrent {
+
+  import java.util.concurrent.ExecutorService
+
+  object Future {
+
+    /** {{{
+      *  Future[MyECTag] { expr }
+      * }}}
+      *
+      * returns `Future[MyECTag, E]` where `E` is `expr`'s inferred type and
+      * `ExecutionContext[MyECTag]` is required implicitly.
+      */
+    def apply[EC]: apply[EC] =
+      new apply(())
+
+    @scala.annotation.nowarn("msg=dubious usage of method hashCode with unit value")
+    final class apply[EC](private val ignore: Unit) extends AnyVal {
+      def apply[A](body: => A)(implicit ec: ExecutionContext[EC]): Future[EC, A] =
+        sc.Future(body)(ec)
+    }
+
+    def fromTry[EC, A](result: Try[A]): Future[EC, A] =
+      sc.Future.fromTry(result)
+  }
+
+  object ExecutionContext {
+
+    /** Explicitly tag an [[scala.concurrent.ExecutionContext]], or replace the tag on an
+      * [[ExecutionContext]].
+      */
+    def apply[EC](ec: sc.ExecutionContext): ExecutionContext[EC] =
+      ExecutionContextOf.Instance.subst[Id, EC](ec)
+
+    def fromExecutorService[EC](e: ExecutorService): ExecutionContext[EC] =
+      apply(sc.ExecutionContext.fromExecutorService(e))
+
+    val parasitic: ExecutionContext[Nothing] =
+      ExecutionContext(sc.ExecutionContext.parasitic)
+  }
+}