multiplePeers tests

Blockchain/Sources/Blockchain/Blockchain.swift

@@ -48,8 +48,7 @@ public final class Blockchain: ServiceBase, @unchecked Sendable {
             try await dataProvider.blockImported(block: block, state: state)
 
             publish(RuntimeEvents.BlockImported(block: block, state: state, parentState: parent))
-
-            logger.info("Block imported: #\(block.header.timeslot) \(block.hash)")
+            logger.debug(" Import block: #\(block.header.timeslot) \(block.hash)")
         }
     }
 

Blockchain/Sources/Blockchain/BlockchainDataProvider/BlockchainDataProvider.swift

@@ -53,7 +53,7 @@ public actor BlockchainDataProvider: Sendable {
             bestHead = HeadInfo(hash: block.hash, timeslot: block.header.timeslot, number: number)
         }
 
-        logger.debug("block imported: \(block.hash)")
+        logger.debug("Block imported: #\(bestHead.timeslot) \(block.hash)")
     }
 }
 

Blockchain/Sources/Blockchain/RuntimeProtocols/Accumulation.swift

@@ -319,7 +319,7 @@ extension Accumulation {
 
         let rightQueueItems = accumulationQueue.array[index...]
         let leftQueueItems = accumulationQueue.array[0 ..< index]
-        var allQueueItems = rightQueueItems.flatMap { $0 } + leftQueueItems.flatMap { $0 } + newQueueItems
+        var allQueueItems = rightQueueItems.flatMap(\.self) + leftQueueItems.flatMap(\.self) + newQueueItems
 
         editAccumulatedItems(items: &allQueueItems, accumulatedPackages: Set(zeroPrereqReports.map(\.packageSpecification.workPackageHash)))
 

Blockchain/Sources/Blockchain/RuntimeProtocols/Guaranteeing.swift

@@ -185,8 +185,8 @@ extension Guaranteeing {
         }
 
         let recentWorkPackageHashes: Set<Data32> = Set(recentHistory.items.flatMap(\.lookup.keys))
-        let accumulateHistoryReports = Set(accumulationHistory.array.flatMap { $0 })
-        let accumulateQueueReports = Set(accumulationQueue.array.flatMap { $0 }
+        let accumulateHistoryReports = Set(accumulationHistory.array.flatMap(\.self))
+        let accumulateQueueReports = Set(accumulationQueue.array.flatMap(\.self)
             .flatMap(\.workReport.refinementContext.prerequisiteWorkPackages))
         let pendingWorkReportHashes = Set(reports.array.flatMap { $0?.workReport.refinementContext.prerequisiteWorkPackages ?? [] })
         let pipelinedWorkReportHashes = recentWorkPackageHashes.union(accumulateHistoryReports).union(accumulateQueueReports)

Blockchain/Sources/Blockchain/VMInvocations/HostCall/HostCalls.swift

@@ -909,7 +909,7 @@ public class Invoke: HostCall {
         self.context = context
     }
 
-    public func _callImpl(config: ProtocolConfigRef, state: VMState) async throws {
+    public func _callImpl(config _: ProtocolConfigRef, state: VMState) async throws {
         let pvmIndex: UInt64 = state.readRegister(Registers.Index(raw: 7))
         let startAddr: UInt32 = state.readRegister(Registers.Index(raw: 8))
 

Node/.swiftpm/xcode/xcshareddata/xcschemes/Node.xcscheme

@@ -29,6 +29,18 @@
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       shouldUseLaunchSchemeArgsEnv = "YES"
       shouldAutocreateTestPlan = "YES">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "NodeTests"
+               BuildableName = "NodeTests"
+               BlueprintName = "NodeTests"
+               ReferencedContainer = "container:">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
    </TestAction>
    <LaunchAction
       buildConfiguration = "Debug"

Node/Tests/NodeTests/NodeTests.swift

@@ -6,21 +6,22 @@ import Utils
 @testable import Node
 
 final class NodeTests {
+    var dataBaseIndex: Int = 0;
+
     let path = {
         let tmpDir = FileManager.default.temporaryDirectory
         return tmpDir.appendingPathComponent("\(UUID().uuidString)")
     }()
 
-    func getDatabase(_ idx: Int) -> Database {
-        Database.rocksDB(path: path.appendingPathComponent("\(idx)"))
+    func getDatabase() -> Database {
+        dataBaseIndex += 1;
+        return Database.rocksDB(path: path.appendingPathComponent("\(dataBaseIndex)"))
     }
 
     deinit {
         try? FileManager.default.removeItem(at: path)
     }
-
-    @Test
-    func validatorNodeInMemory() async throws {
+    @Test func validatorNodeInMemory() async throws {
         let (nodes, scheduler) = try await Topology(
             nodes: [NodeDescription(isValidator: true)]
         ).build(genesis: .preset(.minimal))
@@ -32,7 +33,7 @@ final class NodeTests {
         let initialTimeslot = initialBestHead.timeslot
 
         // Advance time
-        for _ in 0 ..< 10 {
+        for _ in 0..<10 {
             await scheduler.advance(by: TimeInterval(validatorNode.blockchain.config.value.slotPeriodSeconds))
             await storeMiddlware.wait()
         }
@@ -49,10 +50,9 @@ final class NodeTests {
         #expect(try await validatorNode.blockchain.dataProvider.hasBlock(hash: newBestHead.hash))
     }
 
-    @Test
-    func validatorNodeRocksDB() async throws {
+    @Test func validatorNodeRocksDB() async throws {
         let (nodes, scheduler) = try await Topology(
-            nodes: [NodeDescription(isValidator: true, database: getDatabase(0))]
+            nodes: [NodeDescription(isValidator: true, database: getDatabase())]
         ).build(genesis: .preset(.minimal))
 
         let (validatorNode, storeMiddlware) = nodes[0]
@@ -62,7 +62,7 @@ final class NodeTests {
         let initialTimeslot = initialBestHead.timeslot
 
         // Advance time
-        for _ in 0 ..< 10 {
+        for _ in 0..<10 {
             await scheduler.advance(by: TimeInterval(validatorNode.blockchain.config.value.slotPeriodSeconds))
             await storeMiddlware.wait()
         }
@@ -79,13 +79,12 @@ final class NodeTests {
         #expect(try await validatorNode.blockchain.dataProvider.hasBlock(hash: newBestHead.hash))
     }
 
-    @Test
-    func sync() async throws {
+    @Test func sync() async throws {
         // Create validator and full node
         let (nodes, scheduler) = try await Topology(
             nodes: [
-                NodeDescription(isValidator: true, database: getDatabase(0)),
-                NodeDescription(devSeed: 1, database: getDatabase(1)),
+                NodeDescription(isValidator: true, database: getDatabase()),
+                NodeDescription(devSeed: 1, database: getDatabase()),
             ],
             connections: [(0, 1)]
         ).build(genesis: .preset(.minimal))
@@ -94,7 +93,7 @@ final class NodeTests {
         let (node, nodeStoreMiddlware) = nodes[1]
 
         // Advance time to produce blocks
-        for _ in 0 ..< 10 {
+        for _ in 0..<10 {
             await scheduler.advance(by: TimeInterval(validatorNode.blockchain.config.value.slotPeriodSeconds))
             await validatorStoreMiddlware.wait()
             await nodeStoreMiddlware.wait()
@@ -110,7 +109,7 @@ final class NodeTests {
         #expect(validatorBestHead.hash == nodeBestHead.hash)
 
         // Produce more blocks
-        for _ in 0 ..< 10 {
+        for _ in 0..<10 {
             await scheduler.advance(by: TimeInterval(validatorNode.blockchain.config.value.slotPeriodSeconds))
             await validatorStoreMiddlware.wait()
             await nodeStoreMiddlware.wait()
@@ -129,14 +128,13 @@ final class NodeTests {
         #expect(newValidatorBestHead.timeslot > validatorBestHead.timeslot)
     }
 
-    @Test
-    func multiplePeers() async throws {
+    @Test func multiplePeers() async throws {
         // Create multiple nodes
         let (nodes, scheduler) = try await Topology(
             nodes: [
-                NodeDescription(isValidator: true, database: getDatabase(0)),
-                NodeDescription(isValidator: true, devSeed: 1, database: getDatabase(1)),
-                NodeDescription(devSeed: 2, database: getDatabase(2)),
+                NodeDescription(isValidator: true, database: getDatabase()),
+                NodeDescription(isValidator: true, devSeed: 1, database: getDatabase()),
+                NodeDescription(devSeed: 2, database: getDatabase()),
                 NodeDescription(devSeed: 3, database: .inMemory),
             ],
             connections: [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3)]
@@ -147,30 +145,83 @@ final class NodeTests {
         let (node1, node1StoreMiddlware) = nodes[2]
         let (node2, node2StoreMiddlware) = nodes[3]
 
-        try await Task.sleep(for: .milliseconds(500))
+        try await Task.sleep(for: .milliseconds(nodes.count * 200))
 
         // Verify connections
         #expect(node1.network.peersCount == 2)
         #expect(node2.network.peersCount == 2)
 
         // Advance time and verify sync
-        for _ in 0 ..< 10 {
+        for _ in 0..<10 {
             await scheduler.advance(by: TimeInterval(validator1.blockchain.config.value.slotPeriodSeconds))
             await validator1StoreMiddlware.wait()
             await validator2StoreMiddlware.wait()
             await node1StoreMiddlware.wait()
             await node2StoreMiddlware.wait()
         }
 
-        try await Task.sleep(for: .milliseconds(1000))
+        try await Task.sleep(for: .milliseconds(nodes.count * 500))
 
         let validator1BestHead = await validator1.dataProvider.bestHead
         let validator2BestHead = await validator2.dataProvider.bestHead
         let node1BestHead = await node1.dataProvider.bestHead
         let node2BestHead = await node2.dataProvider.bestHead
-
         #expect(validator1BestHead.hash == node1BestHead.hash)
         #expect(validator1BestHead.hash == node2BestHead.hash)
         #expect(validator2BestHead.hash == node1BestHead.hash)
     }
+
+    @Test func moreMultiplePeers() async throws {
+        // Create multiple nodes
+        var nodeDescriptions: [NodeDescription] = [
+            NodeDescription(isValidator: true, database: getDatabase()),
+            NodeDescription(isValidator: true, devSeed: 1, database: getDatabase()),
+        ]
+
+        // Add 18 non-validator nodes
+        for i in 2...19 {
+            nodeDescriptions.append(NodeDescription(devSeed: UInt32(i), database: .inMemory))
+        }
+
+        let (nodes, scheduler) = try await Topology(
+            nodes: nodeDescriptions,
+            connections: (0..<20).flatMap { i in
+                (i + 1..<20).map { j in (i, j) }  // Fully connected topology
+            }
+        ).build(genesis: .preset(.minimal))
+
+        let (validator1, validator1StoreMiddlware) = nodes[0]
+        let (validator2, validator2StoreMiddlware) = nodes[1]
+
+        // Extract non-validator nodes and their middleware
+        let nonValidatorNodes = nodes[2...].map(\.self)
+
+        try await Task.sleep(for: .milliseconds(nodes.count * 100))
+        let (node1, _ ) = nonValidatorNodes[0]
+        let (node2, _ ) = nonValidatorNodes[1]
+        // Verify connections for a sample of non-validator nodes
+        #expect(node1.network.peersCount == 19)
+        #expect(node2.network.peersCount == 19)
+        // Advance time and verify sync
+        for _ in 0..<10 {
+            await scheduler.advance(by: TimeInterval(validator1.blockchain.config.value.slotPeriodSeconds))
+            await validator1StoreMiddlware.wait()
+            await validator2StoreMiddlware.wait()
+
+            for (_, middleware) in nonValidatorNodes {
+                await middleware.wait()
+            }
+        }
+
+        try await Task.sleep(for: .milliseconds(nodes.count * 500))
+
+        let validator1BestHead = await validator1.dataProvider.bestHead
+        let validator2BestHead = await validator2.dataProvider.bestHead
+
+        for (node, _) in nonValidatorNodes {
+            let nodeBestHead = await node.dataProvider.bestHead
+            #expect(validator1BestHead.hash == nodeBestHead.hash)
+            #expect(validator2BestHead.hash == nodeBestHead.hash)
+        }
+    }
 }

Node/Tests/NodeTests/Topology.swift

@@ -63,7 +63,8 @@ struct Topology {
         for (from, to) in connections {
             let fromNode = ret[from].0
             let toNode = ret[to].0
-            _ = try fromNode.network.network.connect(to: toNode.network.network.listenAddress(), role: .validator)
+            let conn = try fromNode.network.network.connect(to: toNode.network.network.listenAddress(), role: .validator)
+            try? await conn.ready()
         }
         return (ret, scheduler)
     }

Utils/Sources/Utils/Merklization/MMR.swift

@@ -34,7 +34,7 @@ public struct MMR: Sendable, Equatable, Codable {
             }
         }
 
-        let nonNilPeaks = peaks.compactMap { $0 }
+        let nonNilPeaks = peaks.compactMap(\.self)
         return helper(nonNilPeaks[...])
     }
 }