fix: add Ouroboros Genesis support for Cardano Node 10.5.1+

Implement support for Cardano Node 10.5.1 which uses Ouroboros Genesis consensus protocol.
This replaces bootstrap peers with big ledger peer snapshots for better decentralization.

Changes:
- Add PeerSnapshotService to load peers from Genesis peer snapshot files
- Create model classes for BigLedgerPool, PeerSnapshotConfig, and Relay
- Update TopologyConfigServiceImpl to use peer snapshots with bootstrap fallback
- Add support for domain, IPv4, IPv6, and address relay formats
- Update mainnet, preprod, and preview topology.json to use peer-snapshot.json
- Add comprehensive unit tests (16 test cases) using mainnet peer snapshot
- Keep devkit with bootstrap peers for backward compatibility

The implementation maintains dynamic peer discovery priority:
1. Try dynamically discovered peers from yaci-indexer (when enabled)
2. Fallback to static peers from peer-snapshot.json (Genesis mode)
3. Fallback to bootstrap peers (legacy mode)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Mateusz Czeladka

api/src/main/java/org/cardanofoundation/rosetta/api/network/model/BigLedgerPool.java

@@ -0,0 +1,27 @@
+package org.cardanofoundation.rosetta.api.network.model;
+
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class BigLedgerPool {
+  @JsonProperty("accumulatedStake")
+  private Double accumulatedStake;
+
+  @JsonProperty("relativeStake")
+  private Double relativeStake;
+
+  @JsonProperty("relays")
+  private List<Relay> relays;
+}

api/src/main/java/org/cardanofoundation/rosetta/api/network/model/PeerSnapshotConfig.java

@@ -0,0 +1,21 @@
+package org.cardanofoundation.rosetta.api.network.model;
+
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class PeerSnapshotConfig {
+  @JsonProperty("bigLedgerPools")
+  private List<BigLedgerPool> bigLedgerPools;
+}

api/src/main/java/org/cardanofoundation/rosetta/api/network/model/Relay.java

@@ -0,0 +1,25 @@
+package org.cardanofoundation.rosetta.api.network.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class Relay {
+  @JsonProperty("domain")
+  private String domain;
+
+  @JsonProperty("port")
+  private Integer port;
+
+  @JsonProperty("address")
+  private String address;
+}

api/src/main/java/org/cardanofoundation/rosetta/api/network/model/TopologyConfig.java

@@ -19,10 +19,13 @@
 public class TopologyConfig {
   @JsonProperty("Producers")
   private List<Producer> producers;
-  
+
   @JsonProperty("publicRoots")
   private List<PublicRoot> publicRoots;
-  
+
   @JsonProperty("bootstrapPeers")
   private List<BootstrapPeer> bootstrapPeers;
+
+  @JsonProperty("peerSnapshotFile")
+  private String peerSnapshotFile;
 }

api/src/main/java/org/cardanofoundation/rosetta/api/network/service/PeerSnapshotService.java

@@ -0,0 +1,22 @@
+package org.cardanofoundation.rosetta.api.network.service;
+
+import jakarta.validation.constraints.NotNull;
+import java.util.List;
+import org.openapitools.client.model.Peer;
+
+/**
+ * Service for loading peers from Cardano Node Genesis mode peer snapshot files.
+ * This is used with Cardano Node 10.5.1+ which uses Ouroboros Genesis consensus.
+ */
+public interface PeerSnapshotService {
+
+  /**
+   * Load peers from a peer snapshot file.
+   * The file path is resolved relative to the provided base directory.
+   *
+   * @param peerSnapshotFile the peer snapshot file name (e.g., "peer-snapshot.json")
+   * @param baseDirectory the base directory to resolve the file path from
+   * @return list of peers extracted from the snapshot, or empty list if file doesn't exist or parsing fails
+   */
+  List<Peer> loadPeersFromSnapshot(@NotNull String peerSnapshotFile, @NotNull String baseDirectory);
+}

api/src/main/java/org/cardanofoundation/rosetta/api/network/service/PeerSnapshotServiceImpl.java

@@ -0,0 +1,100 @@
+package org.cardanofoundation.rosetta.api.network.service;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.validation.constraints.NotNull;
+import lombok.extern.slf4j.Slf4j;
+import org.cardanofoundation.rosetta.api.network.model.PeerSnapshotConfig;
+import org.cardanofoundation.rosetta.api.network.model.Relay;
+import org.cardanofoundation.rosetta.common.util.FileUtils;
+import org.openapitools.client.model.Peer;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Implementation of PeerSnapshotService for loading peers from Genesis mode peer snapshot files.
+ * Cardano Node 10.5.1+ uses Ouroboros Genesis which requires peer snapshots instead of bootstrap peers.
+ */
+@Service
+@Slf4j
+public class PeerSnapshotServiceImpl implements PeerSnapshotService {
+
+  @Override
+  public List<Peer> loadPeersFromSnapshot(@NotNull String peerSnapshotFile, @NotNull String baseDirectory) {
+    try {
+      Path snapshotPath = resolveSnapshotPath(peerSnapshotFile, baseDirectory);
+      String snapshotFilePath = snapshotPath.toString();
+
+      log.debug("[loadPeersFromSnapshot] Loading peer snapshot from: {}", snapshotFilePath);
+
+      if (!new File(snapshotFilePath).exists()) {
+        log.warn("[loadPeersFromSnapshot] Peer snapshot file not found: {}", snapshotFilePath);
+        return new ArrayList<>();
+      }
+
+      PeerSnapshotConfig peerSnapshot = parsePeerSnapshot(snapshotFilePath);
+
+      if (peerSnapshot == null || peerSnapshot.getBigLedgerPools() == null) {
+        log.warn("[loadPeersFromSnapshot] Peer snapshot is empty or invalid");
+        return new ArrayList<>();
+      }
+
+      List<Peer> peers = extractPeersFromSnapshot(peerSnapshot);
+
+      log.info("[loadPeersFromSnapshot] Extracted {} relays from {} big ledger pools",
+          peers.size(), peerSnapshot.getBigLedgerPools().size());
+
+      return peers;
+
+    } catch (IOException e) {
+      log.error("[loadPeersFromSnapshot] Failed to load peer snapshot from: {}", peerSnapshotFile, e);
+      return new ArrayList<>();
+    }
+  }
+
+  private Path resolveSnapshotPath(String peerSnapshotFile, String baseDirectory) {
+    Path basePath = Paths.get(baseDirectory);
+    return basePath.resolve(peerSnapshotFile);
+  }
+
+  private PeerSnapshotConfig parsePeerSnapshot(String snapshotFilePath) throws IOException {
+    ObjectMapper mapper = new ObjectMapper();
+    String content = FileUtils.fileReader(snapshotFilePath);
+    return mapper.readValue(content, PeerSnapshotConfig.class);
+  }
+
+  private List<Peer> extractPeersFromSnapshot(PeerSnapshotConfig peerSnapshot) {
+    return peerSnapshot.getBigLedgerPools().stream()
+        .flatMap(pool -> pool.getRelays().stream())
+        .map(this::mapRelayToPeer)
+        .toList();
+  }
+
+  @NotNull
+  private Peer mapRelayToPeer(@NotNull Relay relay) {
+    String address;
+    String type;
+
+    if (relay.getDomain() != null) {
+      address = relay.getDomain();
+      type = "domain";
+    } else {
+      address = relay.getAddress();
+      type = isIpv6(address) ? "IPv6" : "IPv4";
+    }
+
+    address = "%s:%d".formatted(address, relay.getPort());
+
+    return new Peer(address, Map.of("type", type));
+  }
+
+  private boolean isIpv6(String address) {
+    return address.contains(":");
+  }
+}

api/src/main/java/org/cardanofoundation/rosetta/api/network/service/TopologyConfigServiceImpl.java

@@ -15,6 +15,7 @@
 
 import javax.annotation.PostConstruct;
 import java.io.IOException;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -25,6 +26,7 @@
 public class TopologyConfigServiceImpl implements TopologyConfigService {
 
   private final YaciHttpGateway yaciHttpGateway;
+  private final PeerSnapshotService peerSnapshotService;
 
   @Value("${cardano.rosetta.TOPOLOGY_FILEPATH}")
   private String topologyFilepath;
@@ -55,18 +57,31 @@ public List<Peer> getStaticPeers() {
   }
 
   public List<Peer> getPeerFromConfig(TopologyConfig topologyConfig) {
-    log.info("[getPeersFromConfig] Looking for bootstrap peers from topologyFile");
+    log.info("[getPeersFromConfig] Looking for peers from topology configuration");
 
     if (topologyConfig == null) {
       log.warn("Topology config is null");
       return new ArrayList<>();
     }
 
-    // Only read bootstrap peers now
+    // For Genesis mode (Cardano Node 10.5.1+), try peer snapshot first
+    String peerSnapshotFile = topologyConfig.getPeerSnapshotFile();
+    if (peerSnapshotFile != null && !peerSnapshotFile.isEmpty()) {
+      log.info("[getPeersFromConfig] Peer snapshot file configured: {}", peerSnapshotFile);
+      String baseDirectory = Paths.get(topologyFilepath).getParent().toString();
+      List<Peer> peersFromSnapshot = peerSnapshotService.loadPeersFromSnapshot(peerSnapshotFile, baseDirectory);
+      if (!peersFromSnapshot.isEmpty()) {
+        log.info("[getPeersFromConfig] Loaded {} peers from peer snapshot", peersFromSnapshot.size());
+        return peersFromSnapshot;
+      }
+      log.warn("[getPeersFromConfig] Failed to load peers from snapshot, falling back to bootstrap peers");
+    }
+
+    // Fallback to bootstrap peers for backward compatibility
     List<BootstrapPeer> bootstrapPeers = topologyConfig.getBootstrapPeers();
-    
+
     if (bootstrapPeers == null || bootstrapPeers.isEmpty()) {
-      log.warn("No bootstrap peers found in topology config");
+      log.warn("No bootstrap peers or peer snapshot found in topology config");
       return new ArrayList<>();
     }