Sandbox classic: Emulate legacy contract ID scheme (#5929)

CHANGELOG_BEGIN CHANGELOG_END
digital-asset · May 13, 2020 · 021f4af · 021f4af
1 parent b954361
commit 021f4af
Show file tree

Hide file tree

Showing 9 changed files with 130 additions and 33 deletions.
diff --git a/ledger/sandbox/src/main/scala/com/digitalasset/platform/sandbox/SandboxServer.scala b/ledger/sandbox/src/main/scala/com/digitalasset/platform/sandbox/SandboxServer.scala
@@ -21,6 +21,11 @@ import com.daml.ledger.participant.state.v1.metrics.TimedWriteService
 import com.daml.ledger.participant.state.v1.{ParticipantId, SeedService}
 import com.daml.lf.data.{ImmArray, Ref}
 import com.daml.lf.engine.Engine
+import com.daml.lf.transaction.{
+  LegacyTransactionCommitter,
+  StandardTransactionCommitter,
+  TransactionCommitter
+}
 import com.daml.logging.LoggingContext.newLoggingContext
 import com.daml.logging.{ContextualizedLogger, LoggingContext}
 import com.daml.metrics.Metrics
@@ -126,7 +131,7 @@ final class SandboxServer(
   val participantId: ParticipantId = Ref.ParticipantId.assertFromString("sandbox-participant")
 
   private val authService: AuthService = config.authService.getOrElse(AuthServiceWildcard)
-  private val seedingService = config.seeding.map(SeedService(_))
+  private val seedingService = SeedService(config.seeding.getOrElse(SeedService.Seeding.Weak))
 
   // We store a Future rather than a Resource to avoid keeping old resources around after a reset.
   // It's package-private so we can test that we drop the reference properly in ResetServiceIT.
@@ -154,11 +159,11 @@ final class SandboxServer(
       _.reset(
         (materializer, metrics, packageStore, port) =>
           buildAndStartApiServer(
-            materializer,
-            metrics,
-            packageStore,
-            SqlStartMode.AlwaysReset,
-            Some(port),
+            materializer = materializer,
+            metrics = metrics,
+            packageStore = packageStore,
+            startMode = SqlStartMode.AlwaysReset,
+            currentPort = Some(port),
         )))
 
     // Wait for the services to be closed, so we can guarantee that future API calls after finishing
@@ -194,7 +199,7 @@ final class SandboxServer(
             packageStore,
             engine.compiledPackages(),
             scenario,
-            seedingService.map(_.nextSeed()),
+            seedingService.nextSeed(),
           )
         (acs, records, Some(ledgerTime))
     }
@@ -224,6 +229,10 @@ final class SandboxServer(
           (ts, Some(ts))
       }
 
+    val transactionCommitter =
+      config.seeding
+        .fold[TransactionCommitter](LegacyTransactionCommitter)(_ => StandardTransactionCommitter)
+
     val (ledgerType, indexAndWriteServiceResourceOwner) = config.jdbcUrl match {
       case Some(jdbcUrl) =>
         "postgres" -> SandboxIndexAndWriteService.postgres(
@@ -236,6 +245,7 @@ final class SandboxServer(
           ledgerEntries,
           startMode,
           config.commandConfig.maxParallelSubmissions,
+          transactionCommitter,
           packageStore,
           config.eventsPageSize,
           metrics,
@@ -249,6 +259,7 @@ final class SandboxServer(
           timeProvider,
           acs,
           ledgerEntries,
+          transactionCommitter,
           packageStore,
           metrics,
         )
@@ -290,7 +301,7 @@ final class SandboxServer(
         optTimeServiceBackend = timeServiceBackendO,
         metrics = metrics,
         healthChecks = healthChecks,
-        seedService = seedingService,
+        seedService = Some(seedingService),
       )(materializer, executionSequencerFactory, logCtx)
         .map(_.withServices(List(resetService)))
       apiServer <- new LedgerApiServer(

diff --git a/...src/main/scala/com/digitalasset/platform/sandbox/stores/SandboxIndexAndWriteService.scala b/...src/main/scala/com/digitalasset/platform/sandbox/stores/SandboxIndexAndWriteService.scala
@@ -22,6 +22,7 @@ import com.daml.ledger.participant.state.v1.{
 import com.daml.ledger.participant.state.{v1 => ParticipantState}
 import com.daml.lf.data.Ref.Party
 import com.daml.lf.data.{ImmArray, Time}
+import com.daml.lf.transaction.TransactionCommitter
 import com.daml.logging.LoggingContext
 import com.daml.metrics.Metrics
 import com.daml.platform.common.LedgerIdMode
@@ -60,6 +61,7 @@ object SandboxIndexAndWriteService {
       ledgerEntries: ImmArray[LedgerEntryOrBump],
       startMode: SqlStartMode,
       queueDepth: Int,
+      transactionCommitter: TransactionCommitter,
       templateStore: InMemoryPackageStore,
       eventsPageSize: Int,
       metrics: Metrics,
@@ -75,6 +77,7 @@ object SandboxIndexAndWriteService {
         packages = templateStore,
         initialLedgerEntries = ledgerEntries,
         queueDepth = queueDepth,
+        transactionCommitter = transactionCommitter,
         startMode = startMode,
         eventsPageSize = eventsPageSize,
         metrics = metrics,
@@ -89,6 +92,7 @@ object SandboxIndexAndWriteService {
       timeProvider: TimeProvider,
       acs: InMemoryActiveLedgerState,
       ledgerEntries: ImmArray[LedgerEntryOrBump],
+      transactionCommitter: TransactionCommitter,
       templateStore: InMemoryPackageStore,
       metrics: Metrics,
   )(implicit mat: Materializer): ResourceOwner[IndexAndWriteService] = {
@@ -98,6 +102,7 @@ object SandboxIndexAndWriteService {
         participantId,
         timeProvider,
         acs,
+        transactionCommitter,
         templateStore,
         ledgerEntries,
       )

diff --git a/ledger/sandbox/src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/Ledger.scala b/ledger/sandbox/src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/Ledger.scala
@@ -10,8 +10,7 @@ import com.daml.lf.data.Ref.Party
 import com.daml.lf.data.Relation.Relation
 import com.daml.lf.data.Time.Timestamp
 import com.daml.lf.engine.Blinding
-import com.daml.lf.transaction.GenTransaction
-import com.daml.lf.transaction.Transaction.NodeId
+import com.daml.lf.transaction.{GenTransaction, TransactionCommitter}
 import com.daml.lf.value.Value
 import com.daml.lf.value.Value.AbsoluteContractId
 import com.daml.daml_lf_dev.DamlLf.Archive
@@ -60,12 +59,14 @@ object Ledger {
   type DisclosureForIndex = Map[EventId, Set[Party]]
   type GlobalDivulgence = Relation[AbsoluteContractId, Party]
 
-  def convertToCommittedTransaction(transactionId: TransactionId, transaction: SubmittedTransaction)
-    : (TransactionForIndex, DisclosureForIndex, GlobalDivulgence) = {
+  def convertToCommittedTransaction(
+      committer: TransactionCommitter,
+      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))
+    val committedTransaction = committer.commitTransaction(transactionId, transaction)
 
     // here we just need to align the type for blinding
     val blindingInfo = Blinding.blind(committedTransaction)

diff --git a/...ndbox/src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/ScenarioLoader.scala b/...ndbox/src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/ScenarioLoader.scala
@@ -57,7 +57,7 @@ object ScenarioLoader {
       packages: InMemoryPackageStore,
       compiledPackages: CompiledPackages,
       scenario: String,
-      submissionSeed: Option[crypto.Hash],
+      submissionSeed: crypto.Hash,
   ): (InMemoryActiveLedgerState, ImmArray[LedgerEntryOrBump], Instant) = {
     val (scenarioLedger, scenarioRef) =
       buildScenarioLedger(packages, compiledPackages, scenario, submissionSeed)
@@ -114,7 +114,7 @@ object ScenarioLoader {
       packages: InMemoryPackageStore,
       compiledPackages: CompiledPackages,
       scenario: String,
-      submissionSeed: Option[crypto.Hash],
+      submissionSeed: crypto.Hash,
   ): (L.Ledger, Ref.DefinitionRef) = {
     val scenarioQualName = getScenarioQualifiedName(packages, scenario)
     val candidateScenarios = getCandidateScenarios(packages, scenarioQualName)
@@ -138,9 +138,9 @@ object ScenarioLoader {
   private def getSpeedyMachine(
       scenarioExpr: Ast.Expr,
       compiledPackages: CompiledPackages,
-      submissionSeed: Option[crypto.Hash],
+      submissionSeed: crypto.Hash,
   ): Speedy.Machine =
-    Speedy.Machine.newBuilder(compiledPackages, Time.Timestamp.now(), submissionSeed) match {
+    Speedy.Machine.newBuilder(compiledPackages, Time.Timestamp.now(), Some(submissionSeed)) match {
       case Left(err) => throw new RuntimeException(s"Could not build speedy machine: $err")
       case Right(build) => build(scenarioExpr)
     }

diff --git a/...src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/TransactionCommitter.scala b/...src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/TransactionCommitter.scala
@@ -0,0 +1,63 @@
+// Copyright (c) 2020 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.daml.lf.transaction
+
+import com.daml.ledger.participant.state.v1.{CommittedTransaction, SubmittedTransaction}
+import com.daml.lf.data.Ref
+import com.daml.lf.value.Value
+
+// Convert a SubmittedTransaction to CommittedTransaction
+abstract class TransactionCommitter {
+  def commitTransaction(
+      transactionId: Ref.LedgerString,
+      transaction: SubmittedTransaction
+  ): CommittedTransaction
+}
+
+// Standard committer using Contract ID V1
+object StandardTransactionCommitter extends TransactionCommitter {
+  override def commitTransaction(
+      transactionId: Ref.LedgerString,
+      transaction: SubmittedTransaction
+  ): CommittedTransaction =
+    transaction.assertNoRelCid(_ => "Unexpected relative contract ID")
+}
+
+// Committer emulating Contract ID legacy scheme
+object LegacyTransactionCommitter extends TransactionCommitter {
+
+  def commitTransaction(
+      transactionId: Ref.LedgerString,
+      transaction: SubmittedTransaction,
+  ): CommittedTransaction = {
+
+    val prefix = "#" + transactionId + ":"
+
+    type AbsCoid = Value.AbsoluteContractId
+    val contractMap: AbsCoid => AbsCoid =
+      transaction.localContracts
+        .collect[(AbsCoid, AbsCoid), Map[AbsCoid, AbsCoid]] {
+          case (acoid: AbsCoid, nid) =>
+            acoid ->
+              Value.AbsoluteContractId.V0(
+                Ref.ContractIdString.assertFromString(prefix + nid.index.toString))
+        }
+        .withDefault(identity)
+
+    val contractMapping: Transaction.TContractId => Value.AbsoluteContractId = {
+      case acoid: Value.AbsoluteContractId =>
+        contractMap(acoid)
+      case _: Value.RelativeContractId =>
+        throw new RuntimeException("Unexpected relative contract ID")
+    }
+
+    GenTransaction.map3(
+      identity[Transaction.NodeId],
+      contractMapping,
+      Value.VersionedValue.map1(contractMapping)
+    )(transaction)
+
+  }
+
+}
diff --git a/.../main/scala/com/digitalasset/platform/sandbox/stores/ledger/inmemory/InMemoryLedger.scala b/.../main/scala/com/digitalasset/platform/sandbox/stores/ledger/inmemory/InMemoryLedger.scala
@@ -24,7 +24,7 @@ import com.daml.api.util.TimeProvider
 import com.daml.lf.data.Ref.{LedgerString, PackageId, Party}
 import com.daml.lf.data.{ImmArray, Ref, Time}
 import com.daml.lf.language.Ast
-import com.daml.lf.transaction.Node
+import com.daml.lf.transaction.{Node, TransactionCommitter}
 import com.daml.lf.value.Value
 import com.daml.lf.value.Value.{AbsoluteContractId, ContractInst}
 import com.daml.daml_lf_dev.DamlLf.Archive
@@ -90,6 +90,7 @@ class InMemoryLedger(
     participantId: ParticipantId,
     timeProvider: TimeProvider,
     acs0: InMemoryActiveLedgerState,
+    transactionCommitter: TransactionCommitter,
     packageStoreInit: InMemoryPackageStore,
     ledgerEntries: ImmArray[LedgerEntryOrBump],
 ) extends Ledger {
@@ -305,7 +306,12 @@ class InMemoryLedger(
         reason => handleError(submitterInfo, RejectionReason.InvalidLedgerTime(reason)),
         _ => {
           val (transactionForIndex, disclosureForIndex, globalDivulgence) =
-            Ledger.convertToCommittedTransaction(transactionId, transaction)
+            Ledger
+              .convertToCommittedTransaction(
+                transactionCommitter,
+                transactionId,
+                transaction,
+              )
           val acsRes = acs.addTransaction(
             transactionMeta.ledgerEffectiveTime.toInstant,
             transactionId,

diff --git a/...andbox/src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/sql/SqlLedger.scala b/...andbox/src/main/scala/com/digitalasset/platform/sandbox/stores/ledger/sql/SqlLedger.scala
@@ -19,12 +19,12 @@ import com.daml.ledger.participant.state.index.v2.PackageDetails
 import com.daml.ledger.participant.state.v1._
 import com.daml.lf.data.Ref.Party
 import com.daml.lf.data.{ImmArray, Time}
+import com.daml.lf.transaction.TransactionCommitter
 import com.daml.logging.{ContextualizedLogger, LoggingContext}
 import com.daml.metrics.Metrics
 import com.daml.platform.ApiOffset.ApiOffsetConverter
 import com.daml.platform.common.{LedgerIdMismatchException, LedgerIdMode}
 import com.daml.platform.configuration.ServerRole
-import com.daml.platform.events.EventIdFormatter
 import com.daml.platform.packages.InMemoryPackageStore
 import com.daml.platform.sandbox.LedgerIdGenerator
 import com.daml.platform.sandbox.stores.InMemoryActiveLedgerState
@@ -56,6 +56,7 @@ object SqlLedger {
       packages: InMemoryPackageStore,
       initialLedgerEntries: ImmArray[LedgerEntryOrBump],
       queueDepth: Int,
+      transactionCommitter: TransactionCommitter,
       startMode: SqlStartMode = SqlStartMode.ContinueIfExists,
       eventsPageSize: Int,
       metrics: Metrics,
@@ -74,6 +75,7 @@ object SqlLedger {
             packages,
             initialLedgerEntries,
             queueDepth,
+            transactionCommitter,
         ))
     } yield ledger
 }
@@ -87,6 +89,7 @@ private final class SqlLedger(
     timeProvider: TimeProvider,
     packages: InMemoryPackageStore,
     queueDepth: Int,
+    transactionCommitter: TransactionCommitter,
 )(implicit mat: Materializer, logCtx: LoggingContext)
     extends BaseLedger(ledgerId, headAtInitialization, ledgerDao)
     with Ledger {
@@ -171,7 +174,8 @@ private final class SqlLedger(
   override def publishTransaction(
       submitterInfo: SubmitterInfo,
       transactionMeta: TransactionMeta,
-      transaction: SubmittedTransaction): Future[SubmissionResult] =
+      transaction: SubmittedTransaction,
+  ): Future[SubmissionResult] =
     enqueue { offset =>
       val transactionId = offset.toApiString
 
@@ -195,7 +199,7 @@ private final class SqlLedger(
               recordTime,
               transactionMeta.ledgerEffectiveTime.toInstant,
               offset,
-              transaction.resolveRelCid(EventIdFormatter.makeAbs(transactionId)),
+              transactionCommitter.commitTransaction(transactionId, transaction),
               Nil,
           )
         )
@@ -353,6 +357,7 @@ private final class SqlLedgerFactory(ledgerDao: LedgerDao)(implicit logCtx: Logg
       packages: InMemoryPackageStore,
       initialLedgerEntries: ImmArray[LedgerEntryOrBump],
       queueDepth: Int,
+      transactionCommitter: TransactionCommitter,
   )(implicit mat: Materializer): Future[SqlLedger] = {
     implicit val ec: ExecutionContext = DEC
 
@@ -394,6 +399,7 @@ private final class SqlLedgerFactory(ledgerDao: LedgerDao)(implicit logCtx: Logg
         timeProvider,
         packages,
         queueDepth,
+        transactionCommitter,
       )
   }