RPC to submit work package (#305)

* update chain handlers

* update workpackage test

* update swiftlint

* update  BuilderHandlers

* update NodeDataSourceTests

* delete unused function

* update workpackage message

Author: MacOMNI

Blockchain/Sources/Blockchain/Types/WorkPackage.swift

@@ -80,6 +80,16 @@ extension WorkPackage: Dummy {
     }
 }
 
+extension WorkPackage {
+    public func encode() throws -> Data {
+        try JamEncoder.encode(self)
+    }
+
+    public static func decode(data: Data, withConfig: ProtocolConfigRef) throws -> WorkPackage {
+        try JamDecoder.decode(WorkPackage.self, from: data, withConfig: withConfig)
+    }
+}
+
 extension WorkPackage {
     /// a: work-package’s implied authorizer, the hash of the concatenation of the authorization code
     /// and the parameterization

Blockchain/Tests/BlockchainTests/WorkPackageTests.swift

@@ -0,0 +1,15 @@
+import Foundation
+import Testing
+
+@testable import Blockchain
+
+struct WorkPackageTests {
+    @Test
+    func workPackageEncodeAndDecode() throws {
+        let workPackage = WorkPackage.dummy(config: .minimal)
+        let data = try workPackage.encode()
+        #expect(data.count > 0)
+        let wp = try WorkPackage.decode(data: data, withConfig: ProtocolConfigRef.minimal)
+        #expect(wp == workPackage)
+    }
+}

Node/Sources/Node/NetworkingProtocol/CommonEphemeral/WorkPackage.swift

@@ -18,3 +18,13 @@ public struct WorkPackageMessage: Codable, Sendable, Equatable, Hashable {
         self.extrinsics = extrinsics
     }
 }
+
+extension WorkPackageMessage {
+    public func encode() throws -> Data {
+        try JamEncoder.encode(self)
+    }
+
+    public static func decode(data: Data, withConfig: ProtocolConfigRef) throws -> WorkPackageMessage {
+        try JamDecoder.decode(WorkPackageMessage.self, from: data, withConfig: withConfig)
+    }
+}

Node/Sources/Node/NodeDataSource.swift

@@ -51,6 +51,20 @@ extension NodeDataSource: SystemDataSource {
     }
 }
 
+extension NodeDataSource: BuilderDataSource {
+    public func submitWorkPackage(data: Data) async throws -> Bool {
+        let workPackageMessage = try WorkPackageMessage.decode(data: data, withConfig: blockchain.config)
+        // TODO: get guarantor from state etc.
+        blockchain.publish(event: RuntimeEvents
+            .WorkPackagesReceived(
+                coreIndex: workPackageMessage.coreIndex,
+                workPackage: workPackageMessage.workPackage.asRef(),
+                extrinsics: workPackageMessage.extrinsics
+            ))
+        return true
+    }
+}
+
 extension NodeDataSource: ChainDataSource {
     public func getKeys(prefix: Data32, count: UInt32, startKey: Data32?, blockHash: Data32?) async throws -> [String] {
         try await chainDataProvider.getKeys(prefix: prefix, count: count, startKey: startKey, blockHash: blockHash)

Node/Tests/NodeTests/NodeDataSourceTests.swift

@@ -0,0 +1,26 @@
+import Blockchain
+import Foundation
+import Testing
+import Utils
+
+@testable import Node
+
+struct NodeDataSourceTests {
+    var dataSource: NodeDataSource!
+    var networkManager: NetworkManagerTests!
+    init() async throws {
+        networkManager = try! await NetworkManagerTests()
+        dataSource = await NodeDataSource(
+            blockchain: networkManager.services.blockchain,
+            chainDataProvider: networkManager.services.dataProvider,
+            networkManager: networkManager.networkManager,
+            name: "submitWorkPackage"
+        )
+    }
+
+    @Test func submitWorkPackage() async throws {
+        let workPackage = WorkPackage.dummy(config: networkManager.services.config)
+        let workPackageMessage = WorkPackageMessage(coreIndex: 0, workPackage: workPackage, extrinsics: [])
+        #expect(try await dataSource.submitWorkPackage(data: workPackageMessage.encode()) == true)
+    }
+}

Node/Tests/NodeTests/WorkPackageTests.swift

@@ -0,0 +1,17 @@
+import Blockchain
+import Foundation
+import Testing
+
+@testable import Node
+
+struct WorkPackageTests {
+    @Test
+    func workPackageEncodeAndDecode() throws {
+        let workPackage = WorkPackage.dummy(config: .minimal)
+        let workPackageMessage = WorkPackageMessage(coreIndex: 0, workPackage: workPackage, extrinsics: [])
+        let data = try workPackageMessage.encode()
+        #expect(data.count > 0)
+        let message = try WorkPackageMessage.decode(data: data, withConfig: ProtocolConfigRef.minimal)
+        #expect(workPackageMessage == message)
+    }
+}

RPC/Sources/RPC/DataSource/DataSource.swift

@@ -22,10 +22,14 @@ public protocol ChainDataSource: Sendable {
     func getStorage(key: Data32, blockHash: Data32?) async throws -> [String]
 }
 
+public protocol BuilderDataSource: Sendable {
+    func submitWorkPackage(data: Data) async throws -> Bool
+}
+
 public protocol TelemetryDataSource: Sendable {
     func name() async throws -> String
     func getPeersCount() async throws -> Int
     func getNetworkKey() async throws -> String
 }
 
-public typealias DataSource = ChainDataSource & SystemDataSource & TelemetryDataSource
+public typealias DataSource = BuilderDataSource & ChainDataSource & SystemDataSource & TelemetryDataSource

RPC/Sources/RPC/Handlers/AllHandlers.swift

@@ -4,13 +4,17 @@ public enum AllHandlers {
         SystemHandlers.handlers +
         StateHandlers.handlers +
         TelemetryHandlers.handlers +
-        RPCHandlers.handlers
+        RPCHandlers.handlers +
+        BuilderHandlers.handlers
 
-    public static func getHandlers(source: ChainDataSource & SystemDataSource & TelemetryDataSource) -> [any RPCHandler] {
+    public static func getHandlers(source: ChainDataSource & SystemDataSource & TelemetryDataSource & BuilderDataSource)
+        -> [any RPCHandler]
+    {
         var handlers = ChainHandlers.getHandlers(source: source)
         handlers.append(contentsOf: SystemHandlers.getHandlers(source: source))
         handlers.append(contentsOf: StateHandlers.getHandlers(source: source))
         handlers.append(contentsOf: TelemetryHandlers.getHandlers(source: source))
+        handlers.append(contentsOf: BuilderHandlers.getHandlers(source: source))
         handlers.append(contentsOf: RPCHandlers.getHandlers(source: Self.handlers))
         return handlers
     }

RPC/Sources/RPC/Handlers/BuilderHandlers.swift

@@ -0,0 +1,35 @@
+import Blockchain
+import Codec
+import Foundation
+import Utils
+
+public enum BuilderHandlers {
+    public static let handlers: [any RPCHandler.Type] = [
+        SubmitWorkPackage.self,
+    ]
+
+    public static func getHandlers(source: BuilderDataSource) -> [any RPCHandler] {
+        [
+            SubmitWorkPackage(source: source),
+        ]
+    }
+
+    public struct SubmitWorkPackage: RPCHandler {
+        public typealias Request = Request1<Data>
+        public typealias Response = Bool
+
+        public static var method: String { "builder_submitWorkPackage" }
+        public static var requestNames: [String] { ["workPackage"] }
+        public static var summary: String? { "Send the work package to other connected nodes" }
+
+        private let source: BuilderDataSource
+
+        init(source: BuilderDataSource) {
+            self.source = source
+        }
+
+        public func handle(request: Request) async throws -> Response? {
+            try await source.submitWorkPackage(data: request.value)
+        }
+    }
+}

RPC/Tests/RPCTests/BuilderHandlersTests.swift

@@ -0,0 +1,51 @@
+import Blockchain
+@testable import RPC
+import Testing
+import TracingUtils
+@testable import Utils
+import Vapor
+import XCTVapor
+
+public final class DummyBuildDataSource: Sendable {
+    public let chainDataProvider: BlockchainDataProvider
+    public init(
+        chainDataProvider: BlockchainDataProvider
+    ) {
+        self.chainDataProvider = chainDataProvider
+    }
+}
+
+extension DummyBuildDataSource: BuilderDataSource {
+    public func submitWorkPackage(data _: Data) async throws -> Bool {
+        true
+    }
+}
+
+final class BuilderRPCControllerTests {
+    var app: Application!
+    var dataProvider: BlockchainDataProvider!
+
+    func setUp() async throws {
+        app = try await Application.make(.testing)
+        let (genesisState, genesisBlock) = try! State.devGenesis(config: .minimal)
+        dataProvider = try! await BlockchainDataProvider(InMemoryDataProvider(genesisState: genesisState, genesisBlock: genesisBlock))
+        let rpcController = JSONRPCController(handlers: BuilderHandlers
+            .getHandlers(source: DummyBuildDataSource(chainDataProvider: dataProvider)))
+        try app.register(collection: rpcController)
+    }
+
+    @Test func submitWorkPackage() async throws {
+        try await setUp()
+        let hashHex = await dataProvider.bestHead.hash.toHexString()
+        let params = JSON.array([.string(hashHex)])
+        let req = JSONRequest(jsonrpc: "2.0", method: "builder_submitWorkPackage", params: params, id: 0)
+        var buffer = ByteBuffer()
+        try buffer.writeJSONEncodable(req)
+        try await app.test(.POST, "/", headers: ["Content-Type": "application/json"], body: buffer) { res async in
+            #expect(res.status == .ok)
+            let resp = try! res.content.decode(JSONResponse.self, using: JSONDecoder())
+            #expect((resp.result!.value as! Utils.JSON).bool == true)
+        }
+        try await app.asyncShutdown()
+    }
+}