Removing treatment of local divulgence blinding info (#4424)

In a committed transaction (i.e. a transaction with only absolute
contract ids), local divulgence is a non-concept.
Therefore local divulgences don't need to be treated and all code
related to it can be removed.

This also removes some duplication between InMemoryLedger and SqlLedger.

CHANGELOG_BEGIN
CHANGELOG_END

ledger/sandbox/src/main/scala/com/digitalasset/platform/apiserver/CommandExecutorImpl.scala

@@ -50,7 +50,7 @@ class CommandExecutorImpl(engine: Engine, getPackage: PackageId => Future[Option
       .map { submission =>
         (for {
           updateTx <- submission
-          blindingInfo <- Blinding
+          _ <- Blinding
             .checkAuthorizationAndBlind(updateTx, Set(submitter))
         } yield
           (

ledger/sandbox/src/main/scala/com/digitalasset/platform/indexer/JdbcIndexer.scala

@@ -283,11 +283,8 @@ class JdbcIndexer private[indexer] (
             EventIdFormatter.fromTransactionId(transactionId, nodeId) -> parties
         }
 
-        val mappedLocalDivulgence = blindingInfo.localDivulgence.map {
+        // local blinding info only contains values on transactions with relative contractIds.
-          case (nodeId, parties) =>
+        // this does not happen here (see type of transaction: GenTransaction.WithTxValue[NodeId, Value.AbsoluteContractId])
-            EventIdFormatter.fromTransactionId(transactionId, nodeId) -> parties
-        }
-
         assert(blindingInfo.localDivulgence.isEmpty)
 
         val pt = PersistenceEntry.Transaction(
@@ -300,11 +297,9 @@ class JdbcIndexer private[indexer] (
             transactionMeta.ledgerEffectiveTime.toInstant,
             recordTime.toInstant,
             transaction
-              .resolveRelCid(EventIdFormatter.makeAbs(transactionId))
               .mapNodeId(EventIdFormatter.fromTransactionId(transactionId, _)),
             mappedDisclosure
           ),
-          mappedLocalDivulgence,
           blindingInfo.globalDivulgence,
           divulgedContracts.map(c => c.contractId -> c.contractInst)
         )

ledger/sandbox/src/main/scala/com/digitalasset/platform/sandbox/stores/InMemoryActiveLedgerState.scala

@@ -161,7 +161,6 @@ case class InMemoryActiveLedgerState(
       submitter: Option[Party],
       transaction: GenTransaction.WithTxValue[EventId, AbsoluteContractId],
       disclosure: Relation[EventId, Party],
-      localDivulgence: Relation[EventId, Party],
       globalDivulgence: Relation[AbsoluteContractId, Party],
       referencedContracts: List[(Value.AbsoluteContractId, AbsoluteContractInst)]
   ): Either[Set[SequencingError], InMemoryActiveLedgerState] =
@@ -172,7 +171,6 @@ case class InMemoryActiveLedgerState(
       submitter,
       transaction,
       disclosure,
-      localDivulgence,
       globalDivulgence,
       referencedContracts)
 

ledger/sandbox/src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/Ledger.scala

@@ -7,8 +7,16 @@ import java.time.Instant
 
 import com.daml.ledger.participant.state.v1._
 import com.digitalasset.daml.lf.data.Ref.Party
+import com.digitalasset.daml.lf.data.Relation.Relation
 import com.digitalasset.daml.lf.data.Time.Timestamp
+import com.digitalasset.daml.lf.engine.Blinding
+import com.digitalasset.daml.lf.transaction.GenTransaction
+import com.digitalasset.daml.lf.transaction.Transaction.NodeId
+import com.digitalasset.daml.lf.value.Value
+import com.digitalasset.daml.lf.value.Value.AbsoluteContractId
 import com.digitalasset.daml_lf_dev.DamlLf.Archive
+import com.digitalasset.ledger.EventId
+import com.digitalasset.platform.events.EventIdFormatter
 import com.digitalasset.platform.store.ReadOnlyLedger
 
 import scala.concurrent.Future
@@ -46,3 +54,39 @@ trait Ledger extends ReadOnlyLedger {
   ): Future[SubmissionResult]
 
 }
+
+object Ledger {
+
+  type TransactionForIndex =
+    GenTransaction[EventId, AbsoluteContractId, Value.VersionedValue[AbsoluteContractId]]
+  type DisclosureForIndex = Map[EventId, Set[Party]]
+  type GlobalDivulgence = Relation[AbsoluteContractId, Party]
+
+  def convertToCommittedTransaction(transactionId: TransactionId, transaction: SubmittedTransaction)
+    : (TransactionForIndex, DisclosureForIndex, GlobalDivulgence) = {
+
+    // First we "commit" the transaction by converting all relative contractIds to absolute ones
+    val committedTransaction: GenTransaction.WithTxValue[NodeId, AbsoluteContractId] =
+      transaction.resolveRelCid(EventIdFormatter.makeAbs(transactionId))
+
+    // here we just need to align the type for blinding
+    val blindingInfo = Blinding.blind(committedTransaction)
+
+    // At this point there should be no local-divulgences
+    assert(
+      blindingInfo.localDivulgence.isEmpty,
+      s"Encountered non-empty local divulgence. This is a bug! [transactionId={$transactionId}, blindingInfo={${blindingInfo.localDivulgence}}"
+    )
+
+    // convert LF NodeId to Index EventId
+    val disclosureForIndex: Map[EventId, Set[Party]] = blindingInfo.disclosure.map {
+      case (nodeId, parties) =>
+        EventIdFormatter.fromTransactionId(transactionId, nodeId) -> parties
+    }
+
+    val transactionForIndex: TransactionForIndex =
+      committedTransaction.mapNodeId(EventIdFormatter.fromTransactionId(transactionId, _))
+
+    (transactionForIndex, disclosureForIndex, blindingInfo.globalDivulgence)
+  }
+}

ledger/sandbox/src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/ScenarioLoader.scala

@@ -246,7 +246,6 @@ object ScenarioLoader {
           Some(richTransaction.committer),
           tx,
           mappedExplicitDisclosure,
-          mappedLocalImplicitDisclosure,
           mappedGlobalImplicitDisclosure,
           List.empty
         ) match {

ledger/sandbox/src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/inmemory/InMemoryLedger.scala

@@ -18,7 +18,6 @@ import com.daml.ledger.participant.state.v1.{
 import com.digitalasset.api.util.TimeProvider
 import com.digitalasset.daml.lf.data.Ref.{LedgerString, PackageId, Party}
 import com.digitalasset.daml.lf.data.{ImmArray, Time}
-import com.digitalasset.daml.lf.engine.Blinding
 import com.digitalasset.daml.lf.language.Ast
 import com.digitalasset.daml.lf.transaction.Node
 import com.digitalasset.daml.lf.value.Value.AbsoluteContractId
@@ -32,7 +31,6 @@ import com.digitalasset.ledger.api.domain.{
   TransactionId
 }
 import com.digitalasset.ledger.api.health.{HealthStatus, Healthy}
-import com.digitalasset.platform.events.EventIdFormatter
 import com.digitalasset.platform.packages.InMemoryPackageStore
 import com.digitalasset.platform.participant.util.EventFilter.TemplateAwareFilter
 import com.digitalasset.platform.sandbox.stores.InMemoryActiveLedgerState
@@ -156,7 +154,7 @@ class InMemoryLedger(
     )
 
   private def handleSuccessfulTx(
-      trId: LedgerString,
+      transactionId: LedgerString,
       submitterInfo: SubmitterInfo,
       transactionMeta: TransactionMeta,
       transaction: SubmittedTransaction): Unit = {
@@ -170,31 +168,18 @@ class InMemoryLedger(
         RejectionReason.TimedOut(
           s"RecordTime $recordTime is after MaxiumRecordTime ${submitterInfo.maxRecordTime}"))
     } else {
-
+      val (transactionForIndex, disclosureForIndex, globalDivulgence) =
-      val blindingInfo = Blinding.blind(transaction)
+        Ledger.convertToCommittedTransaction(transactionId, transaction)
-      val mappedDisclosure = blindingInfo.disclosure.map {
-        case (nodeId, v) => EventIdFormatter.fromTransactionId(trId, nodeId) -> v
-      }
-      val mappedLocalDivulgence = blindingInfo.localDivulgence.map {
-        case (nodeId, v) => EventIdFormatter.fromTransactionId(trId, nodeId) -> v
-      }
-      val mappedGlobalDivulgence = blindingInfo.globalDivulgence
-
-      val mappedTx =
-        transaction
-          .resolveRelCid(EventIdFormatter.makeAbs(trId))
-          .mapNodeId(EventIdFormatter.fromTransactionId(trId, _))
       // 5b. modify the ActiveContracts, while checking that we do not have double
       // spends or timing issues
       val acsRes = acs.addTransaction(
         transactionMeta.ledgerEffectiveTime.toInstant,
-        trId,
+        transactionId,
         transactionMeta.workflowId,
         Some(submitterInfo.submitter),
-        mappedTx,
+        transactionForIndex,
-        mappedDisclosure,
+        disclosureForIndex,
-        mappedLocalDivulgence,
+        globalDivulgence,
-        mappedGlobalDivulgence,
         List.empty
       )
       acsRes match {
@@ -204,22 +189,17 @@ class InMemoryLedger(
             RejectionReason.Inconsistent(s"Reason: ${err.mkString("[", ", ", "]")}"))
         case Right(newAcs) =>
           acs = newAcs
-          val recordBlinding =
-            blindingInfo.disclosure.map {
-              case (nid, parties) =>
-                (EventIdFormatter.fromTransactionId(trId, nid), parties)
-            }
           val entry = LedgerEntry
             .Transaction(
               Some(submitterInfo.commandId),
-              trId,
+              transactionId,
               Some(submitterInfo.applicationId),
               Some(submitterInfo.submitter),
               transactionMeta.workflowId,
               transactionMeta.ledgerEffectiveTime.toInstant,
               recordTime,
-              mappedTx,
+              transactionForIndex,
-              recordBlinding
+              disclosureForIndex
             )
           entries.publish(InMemoryLedgerEntry(entry))
           ()

ledger/sandbox/src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/sql/SqlLedger.scala

@@ -15,14 +15,11 @@ import com.daml.ledger.participant.state.v1._
 import com.digitalasset.api.util.TimeProvider
 import com.digitalasset.daml.lf.data.Ref.Party
 import com.digitalasset.daml.lf.data.{ImmArray, Ref, Time}
-import com.digitalasset.daml.lf.engine.Blinding
-import com.digitalasset.daml.lf.value.Value.{AbsoluteContractId, ContractId}
 import com.digitalasset.daml_lf_dev.DamlLf.Archive
 import com.digitalasset.dec.{DirectExecutionContext => DEC}
 import com.digitalasset.ledger.api.domain.{LedgerId, PartyDetails, RejectionReason}
 import com.digitalasset.ledger.api.health.HealthStatus
 import com.digitalasset.logging.{ContextualizedLogger, LoggingContext}
-import com.digitalasset.platform.events.EventIdFormatter
 import com.digitalasset.platform.packages.InMemoryPackageStore
 import com.digitalasset.platform.sandbox.LedgerIdGenerator
 import com.digitalasset.platform.sandbox.stores.InMemoryActiveLedgerState
@@ -39,6 +36,7 @@ import com.digitalasset.platform.store.entries.{LedgerEntry, PackageLedgerEntry,
 import com.digitalasset.platform.store.{BaseLedger, DbType, FlywayMigrations, PersistenceEntry}
 import com.digitalasset.resources.ResourceOwner
 import scalaz.syntax.tag._
+import akka.stream.scaladsl.GraphDSL.Implicits._
 
 import scala.collection.immutable
 import scala.collection.immutable.Queue
@@ -143,7 +141,6 @@ private final class SqlLedger(
     val mergedSources =
       Source.fromGraph(GraphDSL.create(checkpointQueue, persistenceQueue)(_ -> _) {
         implicit b => (checkpointSource, persistenceSource) =>
-          import akka.stream.scaladsl.GraphDSL.Implicits._
           val merge = b.add(MergePreferred[Offsets => Future[Unit]](1))
 
           checkpointSource ~> merge.preferred
@@ -208,24 +205,9 @@ private final class SqlLedger(
       transaction: SubmittedTransaction): Future[SubmissionResult] =
     enqueue { offsets =>
       val transactionId = Ref.LedgerString.fromLong(offsets.offset)
-      val toAbsCoid: ContractId => AbsoluteContractId =
-        EventIdFormatter.makeAbsCoid(transactionId)
 
-      val mappedTx = transaction
+      val (transactionForIndex, disclosureForIndex, globalDivulgence) =
-        .resolveRelCid(EventIdFormatter.makeAbs(transactionId))
+        Ledger.convertToCommittedTransaction(transactionId, transaction)
-        .mapNodeId(EventIdFormatter.fromTransactionId(transactionId, _))
-
-      val blindingInfo = Blinding.blind(transaction)
-
-      val mappedDisclosure = blindingInfo.disclosure
-        .map {
-          case (nodeId, parties) =>
-            EventIdFormatter.fromTransactionId(transactionId, nodeId) -> parties
-        }
-
-      val mappedLocalDivulgence = blindingInfo.localDivulgence.map {
-        case (k, v) => EventIdFormatter.fromTransactionId(transactionId, k) -> v
-      }
 
       val recordTime = timeProvider.getCurrentTime
       val entry = if (recordTime.isAfter(submitterInfo.maxRecordTime.toInstant)) {
@@ -252,11 +234,10 @@ private final class SqlLedger(
             transactionMeta.workflowId,
             transactionMeta.ledgerEffectiveTime.toInstant,
             recordTime,
-            mappedTx,
+            transactionForIndex,
-            mappedDisclosure
+            disclosureForIndex
           ),
-          mappedLocalDivulgence,
+          globalDivulgence,
-          blindingInfo.globalDivulgence,
           List.empty
         )
       }

ledger/sandbox/src/main/scala/com/digitalasset/platform/store/ActiveLedgerStateManager.scala

@@ -72,7 +72,6 @@ class ActiveLedgerStateManager[ALS <: ActiveLedgerState[ALS]](initialState: => A
       submitter: Option[Party],
       transaction: GenTransaction.WithTxValue[EventId, AbsoluteContractId],
       disclosure: Relation[EventId, Party],
-      localDivulgence: Relation[EventId, Party],
       globalDivulgence: Relation[AbsoluteContractId, Party],
       divulgedContracts: List[(Value.AbsoluteContractId, AbsoluteContractInst)])
     : Either[Set[SequencingError], ALS] = {
@@ -133,12 +132,6 @@ class ActiveLedgerStateManager[ALS <: ActiveLedgerState[ALS]](initialState: => A
                   .union(nc.stakeholders)
                   .union(nc.key.map(_.maintainers).getOrElse(Set.empty))
                 val absCoid = EventIdFormatter.makeAbsCoid(transactionId)(nc.coid)
-                val withoutStakeHolders = localDivulgence
-                  .getOrElse(nodeId, Set.empty) diff nc.stakeholders
-                val withStakeHolders = localDivulgence
-                  .getOrElse(nodeId, Set.empty)
-
-                assert(withoutStakeHolders == withStakeHolders)
 
                 val activeContract = ActiveContract(
                   id = absCoid,
@@ -148,12 +141,9 @@ class ActiveLedgerStateManager[ALS <: ActiveLedgerState[ALS]](initialState: => A
                   workflowId = workflowId,
                   contract = nc.coinst.resolveRelCid(EventIdFormatter.makeAbs(transactionId)),
                   witnesses = disclosure(nodeId),
-                  // we need to `getOrElse` here because the `Nid` might include absolute
+                  // The divulgences field used to be filled with data coming from the `localDivulgence` field of the blinding info.
-                  // contract ids, and those are never present in the local disclosure.
+                  // But this field is always empty in transactions with only absolute contract ids.
-                  divulgences = (localDivulgence
+                  divulgences = Map.empty,
-                    .getOrElse(nodeId, Set.empty) diff nc.stakeholders).toList
-                    .map(p => p -> transactionId)
-                    .toMap,
                   key =
                     nc.key.map(_.assertNoCid(coid => s"Contract ID $coid found in contract key")),
                   signatories = nc.signatories,

ledger/sandbox/src/main/scala/com/digitalasset/platform/store/PersistenceEntry.scala

@@ -7,7 +7,6 @@ import com.daml.ledger.participant.state.v1.AbsoluteContractInst
 import com.digitalasset.daml.lf.data.Ref.Party
 import com.digitalasset.daml.lf.data.Relation.Relation
 import com.digitalasset.daml.lf.value.Value.AbsoluteContractId
-import com.digitalasset.ledger.EventId
 import com.digitalasset.platform.store.entries.LedgerEntry
 
 /**
@@ -24,7 +23,6 @@ object PersistenceEntry {
 
   final case class Transaction(
       entry: LedgerEntry.Transaction,
-      localDivulgence: Relation[EventId, Party],
       globalDivulgence: Relation[AbsoluteContractId, Party],
       divulgedContracts: List[(AbsoluteContractId, AbsoluteContractInst)]
   ) extends PersistenceEntry

ledger/sandbox/src/main/scala/com/digitalasset/platform/store/dao/JdbcLedgerDao.scala

@@ -617,55 +617,12 @@ private class JdbcLedgerDao(
         )
       }
 
-      // Part 3: insert divulgences into the 'contract_divulgences' table
+      // Part 3: formerly: insert divulgences into the 'contract_divulgences' table
-      val hasNonLocalDivulgence =
+      assert(
-        contracts.exists(c => c.divulgences.exists(d => d._2 != c.transactionId))
+        contracts.forall(_.divulgences.isEmpty),
-      if (hasNonLocalDivulgence) {
+        "Encountered non-empty local divulgence. This is a bug!")
-        // There is at least one contract that was divulged to some party after it was commited.
+      // when storing contracts, the `divulgences` field is only used to store local divulgences.
-        // This happens when writing contracts produced by the scenario loader.
+      // since local divulgences in a committed transaction are non-existent, there is nothing to do here.
-        // Since we only have the transaction IDs when the contract was divulged, we need to look up the corresponding
-        // ledger offsets.
-        val namedDivulgenceParams = contracts
-          .flatMap(
-            c =>
-              c.divulgences.map(
-                w =>
-                  Seq[NamedParameter](
-                    "contract_id" -> c.id.coid,
-                    "party" -> w._1,
-                    "transaction_id" -> w._2
-                ))
-          )
-          .toArray
-
-        if (!namedDivulgenceParams.isEmpty) {
-          executeBatchSql(
-            queries.SQL_BATCH_INSERT_DIVULGENCES_FROM_TRANSACTION_ID,
-            namedDivulgenceParams
-          )
-        }
-      } else {
-        val namedDivulgenceParams = contracts
-          .flatMap(
-            c =>
-              c.divulgences.map(
-                w =>
-                  Seq[NamedParameter](
-                    "contract_id" -> c.id.coid,
-                    "party" -> w._1,
-                    "ledger_offset" -> offset,
-                    "transaction_id" -> c.transactionId
-                ))
-          )
-          .toArray
-
-        if (!namedDivulgenceParams.isEmpty) {
-          executeBatchSql(
-            queries.SQL_BATCH_INSERT_DIVULGENCES,
-            namedDivulgenceParams
-          )
-        }
-      }
 
       // Part 4: insert key maintainers into the 'contract_key_maintainers' table
       val namedKeyMaintainerParams = contracts
@@ -763,7 +720,6 @@ private class JdbcLedgerDao(
       offset: Long,
       submitter: Option[Party],
       tx: Transaction,
-      localDivulgence: Relation[EventId, Party],
       globalDivulgence: Relation[AbsoluteContractId, Party],
       divulgedContracts: List[(Value.AbsoluteContractId, AbsoluteContractInst)])(
       implicit connection: Connection): Option[RejectionReason] = tx match {
@@ -850,7 +806,6 @@ private class JdbcLedgerDao(
         submitter,
         transaction,
         disclosure,
-        localDivulgence,
         globalDivulgence,
         divulgedContracts
       )
@@ -952,11 +907,7 @@ private class JdbcLedgerDao(
 
     def insertEntry(le: PersistenceEntry)(implicit conn: Connection): PersistenceResponse =
       le match {
-        case PersistenceEntry.Transaction(
+        case PersistenceEntry.Transaction(tx, globalDivulgence, divulgedContracts) =>
-            tx,
-            localDivulgence,
-            globalDivulgence,
-            divulgedContracts) =>
           Try {
             storeTransaction(offset, tx, txBytes)
 
@@ -967,7 +918,6 @@ private class JdbcLedgerDao(
               offset,
               tx.submittingParty,
               tx,
-              localDivulgence,
               globalDivulgence,
               divulgedContracts)
               .flatMap { rejectionReason =>

ledger/sandbox/src/main/scala/db/migration/postgres/V2_1__Rebuild_Acs.scala

@@ -22,7 +22,7 @@ import com.digitalasset.daml.lf.value.Value
 import com.digitalasset.daml.lf.value.Value.{AbsoluteContractId, ContractId}
 import com.digitalasset.ledger.api.domain.RejectionReason
 import com.digitalasset.ledger.api.domain.RejectionReason._
-import com.digitalasset.ledger.{ApplicationId, CommandId, EventId, WorkflowId}
+import com.digitalasset.ledger.{ApplicationId, CommandId, WorkflowId}
 import com.digitalasset.platform.events.EventIdFormatter
 import com.digitalasset.platform.store.Contract.ActiveContract
 import com.digitalasset.platform.store.Conversions._
@@ -325,7 +325,6 @@ class V2_1__Rebuild_Acs extends BaseJavaMigration {
   private def updateActiveContractSet(
       offset: Long,
       tx: LedgerEntry.Transaction,
-      localDivulgence: Relation[EventId, Party],
       globalDivulgence: Relation[AbsoluteContractId, Party])(
       implicit connection: Connection): Unit = tx match {
     case LedgerEntry.Transaction(
@@ -404,7 +403,6 @@ class V2_1__Rebuild_Acs extends BaseJavaMigration {
         tx.submittingParty,
         transaction,
         mappedDisclosure,
-        localDivulgence,
         globalDivulgence,
         List.empty
       )
@@ -704,15 +702,8 @@ class V2_1__Rebuild_Acs extends BaseJavaMigration {
               .mapNodeId(EventIdFormatter.split(_).get.nodeId)
 
             val blindingInfo = Blinding.blind(unmappedTx)
-            val mappedLocalDivulgence = blindingInfo.localDivulgence.map {
-              case (k, v) => EventIdFormatter.fromTransactionId(tx.transactionId, k) -> v
-            }
 
-            updateActiveContractSet(
+            updateActiveContractSet(offset, tx, blindingInfo.globalDivulgence)
-              offset,
-              tx,
-              mappedLocalDivulgence,
-              blindingInfo.globalDivulgence)
           })
       }
     })

ledger/sandbox/src/test/suite/scala/com/digitalasset/platform/store/dao/JdbcLedgerDaoSpec.scala

@@ -193,7 +193,6 @@ class JdbcLedgerDaoSpec
           externalOffset,
           PersistenceEntry.Transaction(
             transaction,
-            Map.empty,
             Map(
               absCid -> Set(
                 Ref.Party.assertFromString("Alice"),
@@ -498,7 +497,7 @@ class JdbcLedgerDaoSpec
           offset,
           offset + 1,
           None,
-          PersistenceEntry.Transaction(transaction, Map.empty, Map.empty, List.empty))
+          PersistenceEntry.Transaction(transaction, Map.empty, List.empty))
         entry <- ledgerDao.lookupLedgerEntry(offset)
         endingOffset <- ledgerDao.lookupLedgerEnd()
       } yield {
@@ -555,7 +554,7 @@ class JdbcLedgerDaoSpec
           offset,
           offset + 1,
           None,
-          PersistenceEntry.Transaction(transaction, Map.empty, Map.empty, List.empty))
+          PersistenceEntry.Transaction(transaction, Map.empty, List.empty))
         entry <- ledgerDao.lookupLedgerEntry(offset)
         endingOffset <- ledgerDao.lookupLedgerEnd()
       } yield {
@@ -644,7 +643,7 @@ class JdbcLedgerDaoSpec
             offset,
             offset + 1,
             None,
-            PersistenceEntry.Transaction(t, Map.empty, Map.empty, List.empty))
+            PersistenceEntry.Transaction(t, Map.empty, List.empty))
           .map(_ => ())
       }
 
@@ -656,7 +655,7 @@ class JdbcLedgerDaoSpec
             offset,
             offset + 1,
             None,
-            PersistenceEntry.Transaction(t, Map.empty, Map.empty, List.empty))
+            PersistenceEntry.Transaction(t, Map.empty, List.empty))
           .map(_ => ())
       }
 
@@ -805,7 +804,6 @@ class JdbcLedgerDaoSpec
           Map((s"event$id": EventId) -> Set(party))
         ),
         Map.empty,
-        Map.empty,
         List.empty
       )
 
@@ -848,7 +846,6 @@ class JdbcLedgerDaoSpec
           Map((s"event$id": EventId) -> Set(party))
         ),
         Map.empty,
-        Map.empty,
         List.empty
       )
 
@@ -879,7 +876,6 @@ class JdbcLedgerDaoSpec
           Map((s"event$id": EventId) -> Set(party))
         ),
         Map.empty,
-        Map.empty,
         List.empty
       )
 
@@ -910,7 +906,6 @@ class JdbcLedgerDaoSpec
           Map((s"event$id": EventId) -> Set(party))
         ),
         Map.empty,
-        Map.empty,
         List.empty
       )