[main] Update 2025-04-08.23 (#310)

Reference commit: 793e625a78

Co-authored-by: Canton <canton@digitalasset.com>

Author: canton-machine

UNRELEASED.md

@@ -3,6 +3,36 @@
 Canton CANTON_VERSION has been released on RELEASE_DATE. You can download the Daml Open Source edition from the Daml Connect [Github Release Section](https://github.com/digital-asset/daml/releases/tag/vCANTON_VERSION). The Enterprise edition is available on [Artifactory](https://digitalasset.jfrog.io/artifactory/canton-enterprise/canton-enterprise-CANTON_VERSION.zip).
 Please also consult the [full documentation of this release](https://docs.daml.com/CANTON_VERSION/canton/about.html).
 
+## Until 2025-04-08 (Exclusive)
+- Json API: http response status codes are based on the corresponding gRPC errors where applicable.
+- Json API: `/v2/users` and `/v2/parties` now support paging
+- Json API: Updated openapi.yaml to correctly represent Timestamps as strings in the JSON API schema
+- The package vetting ledger-effective-time boundaries change to validFrom being inclusive and validUntil being exclusive
+  whereas previously validFrom was exclusive and validUntil was inclusive.
+
+### Ledger API topology transaction to represent addition for (party, participant)
+- The ParticipantAuthorizationAdded message was added to express the inception of a party in a participant.
+- The TopologyEvent message was extended to include the ParticipantAuthorizationAdded.
+- The lapi_events_party_to_participant table was extended by one column the participant_permission_type which holds the
+  state of the participant authorization (Added, Changed, Revoked)
+- The JSON api and the java bindings have changed accordingly to accommodate the changes.
+
+
+## Until 2025-04-05 (Exclusive)
+### Breaking: New External Signing Hashing Scheme
+**BREAKING CHANGE**
+The hashing algorithm for externally signed transactions has been changed in a minor but backward-incompatible way.
+
+- There is a new `interfaceId` field in the `Fetch` node of the transaction that now is part of the hash.
+- The hashing scheme version (now being V2) is now part of the hash
+
+See the [hashing algorithm documentation](https://docs.digitalasset-staging.com/build/3.3/explanations/external-signing/external_signing_hashing_algorithm#fetch) for the updated version.
+The hash provided as part of the `PrepareSubmissionResponse` is updated to the new algorithm as well.
+This updated algorithm is supported under a new `V2` hashing scheme version.
+Support for `V1` has been dropped and will not be supported in Canton 3.3 onward.
+This is relevant for applications that re-compute the hash client-side.
+Such applications must update their implementation in order to use the interactive submission service on Canton 3.3.
+
 ## Until 2025-04-04 (Exclusive)
 ### ACS Export and Import
 The ACS export and import now use an ACS snapshot containing LAPI active contracts, as opposed to the Canton internal
@@ -40,6 +70,13 @@ implementation).
   its method to `ActiveContactOld#fromFile`
 - Renamed the current `import_acs_from_file` repair macro to `import_acs_old_from_file`. And deprecation of
   `import_acs_old_from_file`.
+- Authorization service configuration of the ledger api and admin api is validated. No two services can define
+  the same target scope or audience.
+- Ledger API will now give the `DAML_FAILURE` error instead of the `UNHANDLED_EXCEPTION` error when exceptions are
+  thrown from daml.
+    - Details: This new error structure includes an `error_id` in the `ErrorInfoDetail` metadata, of the form
+      `UNHANDLED_EXCEPTION/Module.Name:ExceptionName` for legacy exceptions, and fully user defined for `failWithStatus`
+      exceptions. Please migrate to `failWithStatus` over daml exceptions before Daml 3.4.
 
 ## Until 2025-03-27 (Exclusive)
 ### Reassignment Batching
@@ -50,6 +87,18 @@ implementation).
 - UnassignedEvent messages now additionally contain an offset and a node_id.
 - For the detailed list of changed Ledger API proto messages please see docs-open/src/sphinx/reference/lapi-migration-guide.rst
 
+## Until 2025-03-26 (Exclusive)
+- Added GetUpdateByOffset and GetUpdateById rpc methods in the ledger api that extend and will replace the existing
+GetTransactionByOffset and GetTransactionById so that one will be able to look up an update by its offset or id.
+- Towards this, the GetUpdateByOffsetRequest and GetUpdateByIdRequest messages were added. Both contain the update
+format to shape the update in its final form. Look at docs-open/src/sphinx/reference/lapi-migration-guide.rst on how
+use the added messages over the GetTransactionByOffsetRequest and GetTransactionByIdRequest.
+- The GetUpdateResponse is the response of both methods that contains the update which can be one of:
+  - a transaction
+  - a reassignment
+  - a topology transaction
+- The java bindings and json api were also extended to include the above changes.
+
 ## Until 2025-03-25 (Exclusive)
 - `_recordId` removed from Daml records in Json API
 - Removed `default-close-delay` from `ws-config` (websocket config) in `http-service` configuration (close delay is no longer necessary).

base/errors/src/main/scala/com/digitalasset/base/error/Alarm.scala

@@ -24,19 +24,19 @@ trait BaseAlarm extends BaseError {
     super.context ++ BaseError.extractContext(this)
 
   /** Report the alarm to the logger. */
-  def report()(implicit logger: ContextualizedErrorLogger): Unit = logWithContext()
+  def report()(implicit logger: BaseErrorLogger): Unit = logWithContext()
 
   /** Reports the alarm to the logger.
     *
     * @return
     *   this alarm
     */
-  def reported()(implicit logger: ContextualizedErrorLogger): this.type = {
+  def reported()(implicit logger: BaseErrorLogger): this.type = {
     report()
     this
   }
 
-  def asGrpcError(implicit logger: ContextualizedErrorLogger): StatusRuntimeException =
+  def asGrpcError(implicit logger: BaseErrorLogger): StatusRuntimeException =
     ErrorCode.asGrpcError(this)(logger)
 }
 

base/errors/src/main/scala/com/digitalasset/base/error/BaseError.scala

@@ -50,7 +50,7 @@ trait BaseError extends LocationMixin {
   def resources: Seq[(ErrorResource, String)] = Seq()
 
   def logWithContext(extra: Map[String, String] = Map())(implicit
-      contextualizedErrorLogger: ContextualizedErrorLogger
+      contextualizedErrorLogger: BaseErrorLogger
   ): Unit =
     contextualizedErrorLogger.logError(this, extra)
 
@@ -68,7 +68,7 @@ trait BaseError extends LocationMixin {
   def definiteAnswerO: Option[Boolean] = None
 
   def rpcStatus()(implicit
-      loggingContext: ContextualizedErrorLogger
+      loggingContext: BaseErrorLogger
   ): com.google.rpc.status.Status =
     ProtoStatus.fromJavaProto(ErrorCode.asGrpcStatus(this))
 

…/digitalasset/base/error/NoLogging.scala …alasset/base/error/BaseErrorLogger.scalabase/errors/src/main/scala/com/digitalasset/base/error/NoLogging.scala renamed to base/errors/src/main/scala/com/digitalasset/base/error/BaseErrorLogger.scala base/errors/src/main/scala/com/digitalasset/base/error/NoLogging.scala renamed to base/errors/src/main/scala/com/digitalasset/base/error/BaseErrorLogger.scala

@@ -3,20 +3,25 @@
 
 package com.digitalasset.base.error
 
-object NoLogging extends NoLogging(properties = Map.empty, correlationId = None, traceId = None) {}
+trait BaseErrorLogger {
+  def logError(err: BaseError, extra: Map[String, String]): Unit
+  def correlationId: Option[String]
+  def traceId: Option[String]
+  def properties: Map[String, String]
 
-class NoLogging(
+  // Error construction warnings/errors
+  def warn(message: String): Unit
+  def error(message: String, throwable: Throwable): Unit
+}
+object NoBaseLogging
+    extends NoBaseLogging(properties = Map.empty, correlationId = None, traceId = None) {}
+
+class NoBaseLogging(
     val properties: Map[String, String],
     val correlationId: Option[String],
     val traceId: Option[String] = None,
-) extends ContextualizedErrorLogger {
+) extends BaseErrorLogger {
   override def logError(err: BaseError, extra: Map[String, String]): Unit = ()
-  override def info(message: String): Unit = ()
-  override def info(message: String, throwable: Throwable): Unit = ()
   override def warn(message: String): Unit = ()
-  override def warn(message: String, throwable: Throwable): Unit = ()
-  override def error(message: String): Unit = ()
   override def error(message: String, throwable: Throwable): Unit = ()
-
-  override def withContext[A](context: Map[String, String])(body: => A): A = body
 }

base/errors/src/main/scala/com/digitalasset/base/error/ContextualizedErrorLogger.scala

@@ -12,14 +12,16 @@ abstract class ContextualizedDamlError(
     extraContext: Map[String, Any] = Map(),
 )(implicit
     override val code: ErrorCode,
-    val logger: ContextualizedErrorLogger,
+    val logger: BaseErrorLogger,
 ) extends BaseError
     with RpcError
     with LogOnCreation {
 
   // Automatically log the error on generation
   override def logOnCreation: Boolean = true
 
+  def logError(): Unit = logWithContext()(logger)
+
   def asGrpcStatus: Status =
     ErrorCode.asGrpcStatus(this)(logger)
 
@@ -44,7 +46,7 @@ class DamlErrorWithDefiniteAnswer(
     extraContext: Map[String, Any] = Map(),
 )(implicit
     override val code: ErrorCode,
-    loggingContext: ContextualizedErrorLogger,
+    loggingContext: BaseErrorLogger,
 ) extends ContextualizedDamlError(
       cause = cause,
       throwableO = throwableO,

base/errors/src/main/scala/com/digitalasset/base/error/DamlError.scala

@@ -146,7 +146,7 @@ object ErrorCode {
   val MaxErrorContentBytes = 4096
 
   def asGrpcError(err: BaseError)(implicit
-      loggingContext: ContextualizedErrorLogger
+      loggingContext: BaseErrorLogger
   ): StatusRuntimeException = {
     val status = asGrpcStatus(err)(loggingContext)
     // Builder methods for metadata are not exposed, so going route via creating an exception
@@ -160,11 +160,11 @@ object ErrorCode {
     }
   }
 
-  def asGrpcStatus(err: BaseError)(implicit loggingContext: ContextualizedErrorLogger): Status =
+  def asGrpcStatus(err: BaseError)(implicit loggingContext: BaseErrorLogger): Status =
     asGrpcStatus(err, MaxErrorContentBytes)
 
   private[error] def asGrpcStatus(err: BaseError, maxSerializedErrorSize: Int)(implicit
-      loggingContext: ContextualizedErrorLogger
+      loggingContext: BaseErrorLogger
   ): Status =
     try
       SerializableErrorCodeComponents(

base/errors/src/main/scala/com/digitalasset/base/error/ErrorCode.scala

@@ -17,6 +17,7 @@ object ErrorResource {
   lazy val ContractKey: ErrorResource = ErrorResource("CONTRACT_KEY")
   lazy val ContractArg: ErrorResource = ErrorResource("CONTRACT_ARG")
   lazy val TransactionId: ErrorResource = ErrorResource("TRANSACTION_ID")
+  lazy val UpdateId: ErrorResource = ErrorResource("UPDATE_ID")
   lazy val DalfPackage: ErrorResource = ErrorResource("PACKAGE")
   lazy val TemplateId: ErrorResource = ErrorResource("TEMPLATE_ID")
   lazy val InterfaceId: ErrorResource = ErrorResource("INTERFACE_ID")
@@ -61,6 +62,7 @@ object ErrorResource {
     SynchronizerId,
     TemplateId,
     TransactionId,
+    UpdateId,
     User,
   )
 

base/errors/src/main/scala/com/digitalasset/base/error/ErrorResource.scala

@@ -5,17 +5,9 @@ package com.digitalasset.base.error
 
 /** Trait to log on creation */
 trait LogOnCreation {
-
-  self: BaseError =>
-
-  implicit def logger: ContextualizedErrorLogger
-
   def logOnCreation: Boolean = true
-
-  def logError(): Unit = logWithContext()(logger)
-
+  def logError(): Unit
   if (logOnCreation) {
     logError()
   }
-
 }

base/errors/src/main/scala/com/digitalasset/base/error/LogOnCreation.scala

@@ -33,7 +33,7 @@ object SerializableErrorCodeComponents {
 
   def apply(
       errorCode: ErrorCode,
-      loggingContext: ContextualizedErrorLogger,
+      loggingContext: BaseErrorLogger,
       rawTraceId: Option[String],
       rawCorrelationId: Option[String],
       // Next parameters are by-name to avoid unnecessary computation if the error is security sensitive
@@ -68,7 +68,7 @@ object SerializableErrorCodeComponents {
   private[error] def validateTraceIdAndCorrelationId(
       rawTraceId: Option[String],
       rawCorrelationId: Option[String],
-  )(implicit loggingContext: ContextualizedErrorLogger) = {
+  )(implicit loggingContext: BaseErrorLogger) = {
     val traceId = rawTraceId.map(tId =>
       truncateString(
         tId,
@@ -105,7 +105,7 @@ private[error] final case class SecuritySensitiveErrorCodeComponents(
     grpcStatusCode: Option[Code],
     traceId: Option[String],
     correlationId: Option[String],
-)(logger: ContextualizedErrorLogger)
+)(logger: BaseErrorLogger)
     extends SerializableErrorCodeComponents {
 
   override def toStatusProto(maxSizeBytes: Int): com.google.rpc.Status =
@@ -140,7 +140,7 @@ private[error] final case class NonSecuritySensitiveErrorCodeComponents(
     errorResources: Seq[(ErrorResource, String)],
     contextMap: Map[String, String],
     retryableInfo: Option[FiniteDuration],
-)(loggingContext: ContextualizedErrorLogger)
+)(loggingContext: BaseErrorLogger)
     extends SerializableErrorCodeComponents {
 
   /** Truncates and serializes the self-service error components into a [[com.google.rpc.Status]].