Adjust to changes

[ci]

Signed-off-by: Moritz Kiefer <moritz.kiefer@purelyfunctional.org>

Author: cocreature

apps/common/src/main/scala/org/lfdecentralizedtrust/splice/environment/LsuTopologyAdminConnection.scala

@@ -46,11 +46,12 @@ trait LsuTopologyAdminConnection {
         protocolVersion = None,
       ),
       sequencerId.filterString,
+      filterSuccessorPhysicalSynchronizerId = "",
     )
   ).map(_.headOption.map(r => TopologyResult(r.context, r.item)))
 
   def ensureSequencerSuccessor(
-      synchronizerId: SynchronizerId,
+      synchronizerId: PhysicalSynchronizerId,
       sequencerId: SequencerId,
       connection: GrpcConnection,
   )(implicit
@@ -61,7 +62,7 @@ trait LsuTopologyAdminConnection {
       RetryFor.Automation,
       s"sequencer_successor_$sequencerId",
       s"sequencer successor for $sequencerId is published with connection $connection",
-      lookupSequencerSuccessors(synchronizerId, sequencerId).map { result =>
+      lookupSequencerSuccessors(synchronizerId.logical, sequencerId).map { result =>
         result.filter(_.mapping.connection == connection).toRight(result)
       },
       (previous: Option[TopologyResult[LsuSequencerConnectionSuccessor]]) => {

apps/sv/src/main/scala/org/lfdecentralizedtrust/splice/sv/lsu/LogicalSynchronizerUpgradeTrigger.scala

@@ -218,7 +218,7 @@ class LogicalSynchronizerUpgradeTrigger(
         sequencerId <- currentSynchronizerNode.sequencerAdminConnection.getSequencerId
         _ <-
           currentSynchronizerNode.sequencerAdminConnection.ensureSequencerSuccessor(
-            psid.logical,
+            psid,
             sequencerId = sequencerId,
             connection = successorConnection,
           )

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

@@ -470,6 +470,7 @@ object TopologyAdminCommands {
     final case class ListLsuSequencerConnectionSuccessor(
         query: BaseQuery,
         filterSequencerId: String,
+        filterSuccessorPhysicalSynchronizerId: String,
     ) extends BaseCommand[
           v30.ListLsuSequencerConnectionSuccessorRequest,
           v30.ListLsuSequencerConnectionSuccessorResponse,
@@ -482,6 +483,7 @@ object TopologyAdminCommands {
           new ListLsuSequencerConnectionSuccessorRequest(
             baseQuery = Some(query.toProtoV1),
             filterSequencerId = filterSequencerId,
+            filterSuccessorPhysicalSynchronizerId = filterSuccessorPhysicalSynchronizerId,
           )
         )
 

canton/community/app-base/src/main/scala/com/digitalasset/canton/console/commands/TopologyAdministrationGroup.scala

@@ -3700,7 +3700,7 @@ class TopologyAdministrationGroup(
       def propose_successor(
           sequencerId: SequencerId,
           endpoints: NonEmpty[Seq[URI]],
-          synchronizerId: SynchronizerId,
+          synchronizerId: PhysicalSynchronizerId,
           customTrustCertificates: Option[ByteString] = None,
           store: Option[TopologyStoreId] = None,
           mustFullyAuthorize: Boolean = false,
@@ -3747,6 +3747,7 @@ class TopologyAdministrationGroup(
           operation: Option[TopologyChangeOp] = Some(TopologyChangeOp.Replace),
           filterSequencerId: String = "",
           filterSigningKey: String = "",
+          filterSuccessorPhysicalSynchronizerId: String = "",
       ): Seq[ListLsuSequencerConnectionSuccessorResult] = consoleEnvironment.run {
         adminCommand(
           TopologyAdminCommands.Read.ListLsuSequencerConnectionSuccessor(
@@ -3758,7 +3759,8 @@ class TopologyAdministrationGroup(
               filterSigningKey,
               None,
             ),
-            filterSequencerId,
+            filterSequencerId = filterSequencerId,
+            filterSuccessorPhysicalSynchronizerId = filterSuccessorPhysicalSynchronizerId,
           )
         )
       }

canton/community/base/src/main/protobuf/com/digitalasset/canton/protocol/v30/topology.proto

@@ -375,26 +375,20 @@ message LsuAnnouncement {
 
 // a sequencer can announce its connections on the successor synchronizer
 // authorization: whoever controls the sequencer
-// UNIQUE(sequencer_id, synchronizer_id)
+// UNIQUE(sequencer_id, successor_physical_synchronizer_id.logical)
 message LsuSequencerConnectionSuccessor {
   // the sequencer id
   string sequencer_id = 1;
-  // to synchronizer id
-  string synchronizer_id = 2;
+  // the physical synchronizer id of the successor synchronizer
+  string successor_physical_synchronizer_id = 2;
   // the connection details with which members can connect to the sequencer on the successor synchronizer
   SequencerConnection connection = 3;
 
   message SequencerConnection {
-    oneof connection_type {
-      Grpc grpc = 1;
-    }
-
-    message Grpc {
-      // connection information to sequencer (http[s]://<host>:<port>")
-      // all endpoints must agree on using HTTPS or HTTP
-      repeated string endpoints = 1;
-      optional bytes custom_trust_certificates = 2;
-    }
+    // connection information to sequencer (http[s]://<host>:<port>")
+    // all endpoints must agree on using HTTPS or HTTP
+    repeated string endpoints = 1;
+    optional bytes custom_trust_certificates = 2;
   }
 }
 

canton/community/base/src/main/protobuf/com/digitalasset/canton/topology/admin/v30/topology_manager_read_service.proto

@@ -256,6 +256,7 @@ message ListLsuAnnouncementResponse {
 message ListLsuSequencerConnectionSuccessorRequest {
   BaseQuery base_query = 1;
   string filter_sequencer_id = 2;
+  string filter_successor_physical_synchronizer_id = 3;
 }
 
 message ListLsuSequencerConnectionSuccessorResponse {

canton/community/base/src/main/scala/com/digitalasset/canton/topology/client/StoreBasedTopologySnapshot.scala

@@ -197,7 +197,7 @@ class StoreBasedTopologySnapshot(
       traceContext: TraceContext
   ): FutureUnlessShutdown[Map[SequencerId, LsuSequencerConnectionSuccessor]] =
     findTransactionsByType(
-      types = Seq(TopologyMapping.Code.SequencerConnectionSuccessor)
+      types = Seq(TopologyMapping.Code.LsuSequencerConnectionSuccessor)
     ).map(txs =>
       txs
         .collectOfMapping[LsuSequencerConnectionSuccessor]

canton/community/base/src/main/scala/com/digitalasset/canton/topology/client/WriteThroughCacheTopologySnapshot.scala

@@ -227,7 +227,7 @@ class WriteThroughCacheTopologySnapshot(
         FutureUnlessShutdown.pure(StoredTopologyTransactions.empty[TopologyChangeOp.Replace])
       )(sequencersNE =>
         findTransactionsByUids(
-          types = Seq(TopologyMapping.Code.SequencerConnectionSuccessor),
+          types = Seq(TopologyMapping.Code.LsuSequencerConnectionSuccessor),
           filterUid = sequencersNE,
         )
       )

canton/community/base/src/main/scala/com/digitalasset/canton/topology/transaction/TopologyMapping.scala

@@ -196,7 +196,7 @@ object TopologyMapping {
         extends Code("ptk", v30Code.TOPOLOGY_MAPPING_CODE_PARTY_TO_KEY_MAPPING)
 
     case object LsuAnnouncement extends Code("lsu", v30Code.TOPOLOGY_MAPPING_CODE_LSU_ANNOUNCEMENT)
-    case object SequencerConnectionSuccessor
+    case object LsuSequencerConnectionSuccessor
         extends Code("scs", v30Code.TOPOLOGY_MAPPING_CODE_SEQUENCER_CONNECTION_SUCCESSOR)
 
     val all: Seq[Code] = Seq(
@@ -214,15 +214,15 @@ object TopologyMapping {
       SequencingDynamicParametersState,
       PartyToKeyMapping,
       LsuAnnouncement,
-      SequencerConnectionSuccessor,
+      LsuSequencerConnectionSuccessor,
     )
 
     val lsuMappings: Set[Code] =
-      Set[Code](Code.LsuAnnouncement, Code.SequencerConnectionSuccessor)
+      Set[Code](Code.LsuAnnouncement, Code.LsuSequencerConnectionSuccessor)
 
     // Note: we keep the effective LSU announcement even after the upgrade has happened
     val lsuMappingsExcludedFromUpgrade: NonEmpty[Set[Code]] =
-      NonEmpty(Set, Code.SequencerConnectionSuccessor: Code)
+      NonEmpty(Set, Code.LsuSequencerConnectionSuccessor: Code)
 
     val mappingsIncludedInUpgrade: Set[Code] = all.toSet -- lsuMappingsExcludedFromUpgrade
 
@@ -409,7 +409,7 @@ object TopologyMapping {
 
     code match {
       // Promote level for LSU-related activity to at least INFO.
-      case Code.LsuAnnouncement | Code.SequencerConnectionSuccessor =>
+      case Code.LsuAnnouncement | Code.LsuSequencerConnectionSuccessor =>
         maxLevel(default, Level.INFO)
       case _ => default
     }
@@ -2337,58 +2337,58 @@ final case class GrpcConnection(
 ) {
   def toProtoV30: v30.LsuSequencerConnectionSuccessor.SequencerConnection =
     v30.LsuSequencerConnectionSuccessor.SequencerConnection(
-      v30.LsuSequencerConnectionSuccessor.SequencerConnection.ConnectionType.Grpc(
-        v30.LsuSequencerConnectionSuccessor.SequencerConnection.Grpc(
-          endpoints = endpoints.map(_.toURI(transportSecurity).toString),
-          customTrustCertificates = customTrustCertificates,
-        )
-      )
+      endpoints = endpoints.map(_.toURI(transportSecurity).toString),
+      customTrustCertificates = customTrustCertificates,
     )
 }
 
 object GrpcConnection {
-  def fromProtoV30(
-      value: v30.LsuSequencerConnectionSuccessor.SequencerConnection
+  def fromProtoPrimitives(
+      endpointsP: Seq[String],
+      customTrustCertificates: Option[ByteString],
   ): ParsingResult[GrpcConnection] = for {
-    grpc <- value.connectionType.grpc.toRight(FieldNotSet("grpc"))
     uris <- ProtoConverter.parseRequiredNonEmpty(
       (s: String) =>
         UrlValidator
           .validate(s)
           .leftMap(err => ValueDeserializationError("endpoints", err.message)),
       "endpoints",
-      grpc.endpoints,
+      endpointsP,
     )
     endpointsAndTls <- Endpoint
       .fromUris(uris)
       .leftMap(err => ValueConversionError("endpoints", err))
     (endpoints, useTls) = endpointsAndTls
 
-  } yield GrpcConnection(endpoints, useTls, grpc.customTrustCertificates)
+  } yield GrpcConnection(endpoints, useTls, customTrustCertificates)
 
+  def fromProtoV30(
+      value: v30.LsuSequencerConnectionSuccessor.SequencerConnection
+  ): ParsingResult[GrpcConnection] =
+    fromProtoPrimitives(value.endpoints, value.customTrustCertificates)
 }
 
 final case class LsuSequencerConnectionSuccessor(
     sequencerId: SequencerId,
-    synchronizerId: SynchronizerId,
+    successorPsid: PhysicalSynchronizerId,
     connection: GrpcConnection,
 ) extends TopologyMapping {
   override def companion: TopologyMappingCompanion = LsuSequencerConnectionSuccessor
   override protected def pretty: Pretty[LsuSequencerConnectionSuccessor] = prettyOfClass(
     param("sequencerId", _.sequencerId),
-    param("synchronizerId", _.synchronizerId),
+    param("successorPsid", _.successorPsid),
     param("connection", _.connection.endpoints.forgetNE.map(_.toString.unquoted)),
     paramIfDefined("tls", x => Option.when(x.connection.transportSecurity)("enabled".unquoted)),
   )
   override def namespace: Namespace = sequencerId.namespace
 
   override def maybeUid: Option[UniqueIdentifier] = Some(sequencerId.uid)
-  override def referencedUids: Set[UniqueIdentifier] = Set(sequencerId.uid, synchronizerId.uid)
+  override def referencedUids: Set[UniqueIdentifier] = Set(sequencerId.uid, successorPsid.uid)
   override def requiredAuth(
       previous: Option[TopologyTransaction[TopologyChangeOp, TopologyMapping]]
   ): RequiredAuth = RequiredNamespaces(Set(namespace))
 
-  override def restrictedToSynchronizer: Option[SynchronizerId] = Some(synchronizerId)
+  override def restrictedToSynchronizer: Option[SynchronizerId] = Some(successorPsid.logical)
 
   def toGrpcSequencerConnection(alias: SequencerAlias): GrpcSequencerConnection =
     GrpcSequencerConnection(
@@ -2401,7 +2401,7 @@ final case class LsuSequencerConnectionSuccessor(
 
   def toProto: v30.LsuSequencerConnectionSuccessor = v30.LsuSequencerConnectionSuccessor(
     sequencerId = sequencerId.toProtoPrimitive,
-    synchronizerId = synchronizerId.toProtoPrimitive,
+    successorPhysicalSynchronizerId = successorPsid.toProtoPrimitive,
     connection = Some(connection.toProtoV30),
   )
 
@@ -2412,12 +2412,12 @@ final case class LsuSequencerConnectionSuccessor(
   )
 
   override def uniqueKey: MappingHash =
-    LsuSequencerConnectionSuccessor.uniqueKey(sequencerId, synchronizerId)
+    LsuSequencerConnectionSuccessor.uniqueKey(sequencerId, successorPsid.logical)
 }
 
 object LsuSequencerConnectionSuccessor extends TopologyMappingCompanion {
 
-  override def code: Code = Code.SequencerConnectionSuccessor
+  override def code: Code = Code.LsuSequencerConnectionSuccessor
   def uniqueKey(sequencerId: SequencerId, synchronizerId: SynchronizerId): MappingHash =
     TopologyMapping.buildUniqueKey(code)(
       _.addString(sequencerId.uid.toProtoPrimitive).addString(synchronizerId.toProtoPrimitive)
@@ -2428,9 +2428,9 @@ object LsuSequencerConnectionSuccessor extends TopologyMappingCompanion {
   ): ParsingResult[LsuSequencerConnectionSuccessor] =
     for {
       sequencerId <- SequencerId.fromProtoPrimitive(value.sequencerId, "sequencer_id")
-      currentSynchronizer <- SynchronizerId.fromProtoPrimitive(
-        value.synchronizerId,
-        "synchronizer_id",
+      successorPsid <- PhysicalSynchronizerId.fromProtoPrimitive(
+        value.successorPhysicalSynchronizerId,
+        "successor_physical_synchronizer_id",
       )
       connection <- ProtoConverter.parseRequired(
         GrpcConnection.fromProtoV30,
@@ -2439,7 +2439,7 @@ object LsuSequencerConnectionSuccessor extends TopologyMappingCompanion {
       )
     } yield LsuSequencerConnectionSuccessor(
       sequencerId,
-      currentSynchronizer,
+      successorPsid,
       connection,
     )
 }

canton/community/participant/src/main/scala/com/digitalasset/canton/participant/topology/SequencerConnectionSuccessorListener.scala

@@ -64,7 +64,7 @@ class SequencerConnectionSuccessorListener(
       transactions: Seq[GenericSignedTopologyTransaction],
   )(implicit traceContext: TraceContext): FutureUnlessShutdown[Unit] =
     Monad[FutureUnlessShutdown].whenA(
-      transactions.exists(_.mapping.code == Code.SequencerConnectionSuccessor)
+      transactions.exists(_.mapping.code == Code.LsuSequencerConnectionSuccessor)
     )(checkAndCreateSynchronizerConfig(effectiveTimestamp.value.immediateSuccessor))
 
   private def checkAndCreateSynchronizerConfig(