GuaranteeingService refactor (#300)

* guaranteeing service refactor

* update test

Author: xlc

Blockchain/Sources/Blockchain/RuntimeProtocols/RuntimeEvents.swift

@@ -52,23 +52,19 @@ public enum RuntimeEvents {
         public let block: BlockRef
     }
 
-    // New WorkPackagesReceived by Guaranteeing Service
+    // When a work package is recived via CE133
     public struct WorkPackagesReceived: Event {
-        public let items: [WorkPackageRef]
+        public let item: WorkPackageRef
     }
 
-    // WorkPackages Finalize by WorkPackages Service
-    public struct WorkPackagesFinalized: Event {
-        public let items: [WorkPackageRef]
+    // When a work package bundle is ready to shared via CE134
+    public struct WorkPackageBundleReady: Event {
+        public let bundle: WorkPackageBundle
     }
 
-    // New WorkReportGenerated by Guaranteeing Service
+    // When a work report is generated and ready to be distrubuted via CE135
     public struct WorkReportGenerated: Event {
-        public let items: [WorkReport]
-    }
-
-    // New GuaranteeGenerated by Guaranteeing Service
-    public struct GuaranteeGenerated: Event {
-        public let items: [WorkPackageRef]
+        public let item: WorkReport
+        public let signature: Ed25519Signature
     }
 }

Blockchain/Sources/Blockchain/Validator/DevKeyStore.swift

@@ -28,6 +28,10 @@ public final class DevKeyStore: KeyStore {
         await keystore.get(type, publicKey: publicKey)
     }
 
+    public func getAll<K: KeyType>(_ type: K.Type) async -> [K.SecretKey] {
+        await keystore.getAll(type)
+    }
+
     @discardableResult
     public func addDevKeys(seed: UInt32) async throws -> KeySet {
         var seedData = Data(repeating: 0, count: 32)

Blockchain/Sources/Blockchain/Validator/ExtrinsicPools/WorkPackagePoolService.swift

@@ -4,10 +4,7 @@ import TracingUtils
 import Utils
 
 public enum GuaranteeingServiceError: Error {
-    case invalidValidatorIndex
-    case customValidatorNotFound
     case noAuthorizerHash
-    case invalidCoreIndex
     case invalidExports
 }
 
@@ -17,83 +14,106 @@ struct GuaranteeingRefineInvocation: RefineInvocation {}
 public final class GuaranteeingService: ServiceBase2, @unchecked Sendable {
     private let dataProvider: BlockchainDataProvider
     private let keystore: KeyStore
-    private let runtime: Runtime
-    private let safroleTicketPool: SafroleTicketPoolService
-    private let workPackagePool: WorkPackagePoolService
-    private let guarantees: ThreadSafeContainer<[RuntimeEvents.GuaranteeGenerated]> = .init([])
-    private let authorizationFunction: GuaranteeingAuthorizationFunction
     private let dataAvailability: DataAvailability
-    private let refineInvocation: GuaranteeingRefineInvocation
+
+    private let authorizationFunction: IsAuthorizedFunction
+    private let refineInvocation: RefineInvocation
+
+    let signingKey: ThreadSafeContainer<(ValidatorIndex, Ed25519.SecretKey)?> = .init(nil)
 
     public init(
         config: ProtocolConfigRef,
         eventBus: EventBus,
         scheduler: Scheduler,
         dataProvider: BlockchainDataProvider,
         keystore: KeyStore,
-        runtime: Runtime,
-        safroleTicketPool: SafroleTicketPoolService,
         dataStore: DataStore
     ) async {
         self.dataProvider = dataProvider
         self.keystore = keystore
-        self.runtime = runtime
-        self.safroleTicketPool = safroleTicketPool
-        authorizationFunction = GuaranteeingAuthorizationFunction()
-        refineInvocation = GuaranteeingRefineInvocation()
-        workPackagePool = await WorkPackagePoolService(config: config, dataProvider: dataProvider, eventBus: eventBus)
         dataAvailability = await DataAvailability(
             config: config,
             eventBus: eventBus,
             scheduler: scheduler,
             dataProvider: dataProvider,
             dataStore: dataStore
         )
+
+        authorizationFunction = GuaranteeingAuthorizationFunction()
+        refineInvocation = GuaranteeingRefineInvocation()
+
         super.init(id: "GuaranteeingService", config: config, eventBus: eventBus, scheduler: scheduler)
 
-        await subscribe(RuntimeEvents.GuaranteeGenerated.self, id: "GuaranteeingService.GuaranteeGenerated") { [weak self] event in
-            try await self?.onGuaranteeGenerated(event: event)
+        await subscribe(RuntimeEvents.WorkPackagesReceived.self, id: "GuaranteeingService.WorkPackagesReceived") { [weak self] event in
+            try await self?.on(workPackagesReceived: event)
         }
     }
 
-    public func on(genesis _: StateRef) async {
-        await onGuaranteeing()
+    public func onSyncCompleted() async {
+        let nowTimeslot = timeProvider.getTime().timeToTimeslot(config: config)
+        let epoch = nowTimeslot.timeslotToEpochIndex(config: config)
+        await onBeforeEpoch(epoch: epoch)
+
+        scheduleForNextEpoch("GuaranteeingService.scheduleForNextEpoch") { [weak self] epoch in
+            await self?.onBeforeEpoch(epoch: epoch)
+        }
     }
 
-    public func scheduleGuaranteeTasks() async throws {
-        let state = try await dataProvider.getState(hash: dataProvider.bestHead.hash)
-        let header = try await dataProvider.getHeader(hash: dataProvider.bestHead.hash)
-        let authorIndex = header.value.authorIndex
-        let authorKey = try Ed25519.PublicKey(from: state.value.currentValidators[Int(authorIndex)].ed25519)
-        let key = await keystore.get(Ed25519.self, publicKey: authorKey)
-        if key == nil {
-            throw GuaranteeingServiceError.customValidatorNotFound
+    private func onBeforeEpoch(epoch: EpochIndex) async {
+        await withSpan("GuaranteeingService.onBeforeEpoch", logger: logger) { _ in
+            let state = try await dataProvider.getState(hash: dataProvider.bestHead.hash)
+            let timeslot = epoch.epochToTimeslotIndex(config: config)
+            // simulate next block to determine the correct current validators
+            // this is more accurate than just using nextValidators from current state
+            let res = try state.value.updateSafrole(
+                config: config,
+                slot: timeslot,
+                entropy: Data32(),
+                offenders: [],
+                extrinsics: .dummy(config: config)
+            )
+            let validators = res.state.currentValidators
+
+            let keys = await keystore.getAll(Ed25519.self)
+            var result: (ValidatorIndex, Ed25519.SecretKey)?
+            for key in keys {
+                if let idx = validators.array.firstIndex(where: { $0.ed25519 == key.publicKey.data }) {
+                    result = (ValidatorIndex(idx), key)
+                    break
+                }
+            }
+
+            signingKey.value = result
+        }
+    }
+
+    private func on(workPackagesReceived event: RuntimeEvents.WorkPackagesReceived) async throws {
+        try await refine(package: event.item)
+    }
+
+    private func refine(package: WorkPackageRef) async throws {
+        guard let (validatorIndex, signingKey) = signingKey.value else {
+            logger.debug("not in current validator set, skipping refine")
+            return
         }
+
+        let state = try await dataProvider.getState(hash: dataProvider.bestHead.hash)
+
+        // TODO: check for edge cases such as epoch end
         let currentCoreAssignment = state.value.getCoreAssignment(
             config: config,
             randomness: state.value.entropyPool.t2,
-            timeslot: state.value.timeslot
+            timeslot: state.value.timeslot + 1
         )
-        guard authorIndex < ValidatorIndex(currentCoreAssignment.count) else {
-            logger.error("AuthorIndex not found")
-            throw GuaranteeingServiceError.invalidValidatorIndex
-        }
-        let coreIndex = currentCoreAssignment[Int(authorIndex)]
-        guard coreIndex < CoreIndex(config.value.totalNumberOfCores) else {
-            throw GuaranteeingServiceError.invalidCoreIndex
+        guard let coreIndex = currentCoreAssignment[safe: Int(validatorIndex)] else {
+            try throwUnreachable("invalid validator index/core assignment")
         }
 
-        let workPackages = await workPackagePool.getPendingPackages()
-        for workPackage in workPackages {
-            if try validate(workPackage: workPackage) {
-                let workReport = try await createWorkReport(for: workPackage, coreIndex: coreIndex)
-                let event = RuntimeEvents.WorkReportGenerated(items: [workReport])
-                publish(event)
-                break
-            } else {
-                logger.error("WorkPackage validation failed")
-            }
-        }
+        let workReport = try await createWorkReport(for: package, coreIndex: coreIndex)
+        let payload = SigningContext.guarantee + workReport.hash().data
+        let signature = try signingKey.sign(message: payload)
+        let event = RuntimeEvents.WorkReportGenerated(item: workReport, signature: signature)
+        publish(event)
     }
 
     // workpackage -> workresult -> workreport
@@ -122,9 +142,6 @@ public final class GuaranteeingService: ServiceBase2, @unchecked Sendable {
             }
 
             for (i, item) in workPackage.value.workItems.enumerated() {
-                // TODO: generated by the work-package builder.
-                let extrinsicDataBlobs = [Data]()
-
                 // RefineInvocation invoke up data to workresult
                 let refineRes = try await refineInvocation
                     .invoke(
@@ -191,19 +208,4 @@ public final class GuaranteeingService: ServiceBase2, @unchecked Sendable {
             throw error
         }
     }
-
-    private func validate(workPackage _: WorkPackageRef) throws -> Bool {
-        // TODO: Add validate func
-        true
-    }
-
-    private func onGuaranteeing() async {
-        await withSpan("GuaranteeingService.onGuaranteeing", logger: logger) { _ in
-            try await scheduleGuaranteeTasks()
-        }
-    }
-
-    private func onGuaranteeGenerated(event: RuntimeEvents.GuaranteeGenerated) async throws {
-        guarantees.write { $0.append(event) }
-    }
 }

Blockchain/Sources/Blockchain/Validator/GuaranteeingService.swift

@@ -17,48 +17,26 @@ struct GuaranteeingServiceTests {
             keysCount: keysCount
         )
 
-        let SafroleTicketPoolService = await SafroleTicketPoolService(
-            config: config,
-            dataProvider: services.dataProvider,
-            eventBus: services.eventBus
-        )
-
-        let runtime = Runtime(config: config)
-
         let guaranteeingService = await GuaranteeingService(
             config: config,
             eventBus: services.eventBus,
             scheduler: services.scheduler,
             dataProvider: services.dataProvider,
             keystore: services.keystore,
-            runtime: runtime,
-            safroleTicketPool: SafroleTicketPoolService,
             dataStore: services.dataStore
         )
         return (services, guaranteeingService)
     }
 
     @Test func onGenesis() async throws {
-        let (services, validatorService) = try await setup()
-        let genesisState = services.genesisState
-        let storeMiddleware = services.storeMiddleware
-        let scheduler = services.scheduler
+        let (_, guaranteeingService) = try await setup(keysCount: 1)
+
+        await guaranteeingService.onSyncCompleted()
+
+        let publicKey = try DevKeyStore.getDevKey(seed: 0).ed25519
+        let signingKey = guaranteeingService.signingKey.value!
 
-        var allWorkPackages = [WorkPackageRef]()
-        for _ in 0 ..< services.config.value.totalNumberOfCores {
-            let workpackage = WorkPackage(
-                authorizationToken: Data(),
-                authorizationServiceIndex: 0,
-                authorizationCodeHash: Data32.random(),
-                parameterizationBlob: Data(),
-                context: RefinementContext.dummy(config: services.config),
-                workItems: try! ConfigLimitedSizeArray(config: services.config, defaultValue: WorkItem.dummy(config: services.config))
-            )
-            allWorkPackages.append(workpackage.asRef())
-        }
-        await services.eventBus.publish(RuntimeEvents.WorkPackagesReceived(items: allWorkPackages))
-        await validatorService.on(genesis: genesisState)
-        await storeMiddleware.wait()
-        #expect(scheduler.taskCount == 1)
+        #expect(signingKey.0 == 0)
+        #expect(signingKey.1.publicKey == publicKey)
     }
 }