Rpc refactor

.vscode/launch.json

@@ -41,6 +41,24 @@
             "name": "Release Cli (Cli)",
             "program": "${workspaceFolder:boka}/Cli/.build/release/Cli",
             "preLaunchTask": "swift: Build Release Cli (Cli)"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "args": [],
+            "cwd": "${workspaceFolder:boka}/Tools",
+            "name": "Debug Tools (Tools)",
+            "program": "${workspaceFolder:boka}/Tools/.build/debug/Tools",
+            "preLaunchTask": "swift: Build Debug Tools (Tools)"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "args": [],
+            "cwd": "${workspaceFolder:boka}/Tools",
+            "name": "Release Tools (Tools)",
+            "program": "${workspaceFolder:boka}/Tools/.build/release/Tools",
+            "preLaunchTask": "swift: Build Release Tools (Tools)"
         }
     ]
-}
+}

RPC/Sources/RPC/Handlers/AllHandlers.swift

@@ -0,0 +1,14 @@
+public enum AllHandlers {
+    public static let handlers: [any RPCHandler.Type] =
+        ChainHandlers.handlers +
+        SystemHandlers.handlers +
+        TelemetryHandlers.handlers +
+        RPCHandlers.handlers
+
+    public static func getHandlers(source: ChainDataSource & SystemDataSource & TelemetryDataSource) -> [any RPCHandler] {
+        ChainHandlers.getHandlers(source: source) +
+            SystemHandlers.getHandlers(source: source) +
+            TelemetryHandlers.getHandlers(source: source) +
+            RPCHandlers.getHandlers(source: handlers)
+    }
+}

RPC/Sources/RPC/Handlers/ChainHandlers.swift

@@ -2,26 +2,33 @@
 import Foundation
 import Utils
 
-enum ChainHandlers {
-    static func getHandlers(source: ChainDataSource) -> [any RPCHandler] {
+public enum ChainHandlers {
+    public static let handlers: [any RPCHandler.Type] = [
+        GetBlock.self,
+    ]
+
+    public static func getHandlers(source: ChainDataSource) -> [any RPCHandler] {
         [
             GetBlock(source: source),
         ]
     }
 
-    struct GetBlock: RPCHandler {
-        var method: String { "chain_getBlock" }
-        typealias Request = Data32?
-        typealias Response = BlockRef?
+    public struct GetBlock: RPCHandler {
+        public typealias Request = Request1<Data32?>
+        public typealias Response = BlockRef?
+        public typealias DataSource = ChainDataSource
+
+        public static var method: String { "chain_getBlock" }
+        public static var summary: String? { "Get block by hash. If hash is not provided, returns the best block." }
 
         private let source: ChainDataSource
 
         init(source: ChainDataSource) {
             self.source = source
         }
 
-        func handle(request: Request) async throws -> Response? {
-            if let hash = request {
+        public func handle(request: Request) async throws -> Response? {
+            if let hash = request.value {
                 try await source.getBlock(hash: hash)
             } else {
                 try await source.getBestBlock()

RPC/Sources/RPC/Handlers/RPCHandlers.swift

@@ -1,24 +1,29 @@
 import Utils
 
-enum RPCHandlers {
-    static func getHandlers(source: [any RPCHandler]) -> [any RPCHandler] {
-        [
-            Methods(source: source),
-        ]
+public enum RPCHandlers {
+    public static let handlers: [any RPCHandler.Type] = [
+        Methods.self,
+    ]
+
+    public static func getHandlers(source: [any RPCHandler.Type]) -> [any RPCHandler] {
+        [Methods(source: source)]
     }
 
-    struct Methods: RPCHandler {
-        var method: String { "rpc_methods" }
-        typealias Request = VoidRequest
-        typealias Response = [String]
+    public struct Methods: RPCHandler {
+        public typealias Request = VoidRequest
+        public typealias Response = [String]
+        public typealias DataSource = [any RPCHandler.Type]
+
+        public static var method: String { "rpc_methods" }
+        public static var summary: String? { "Returns a list of available RPC methods." }
 
         private let methods: [String]
 
-        init(source: [any RPCHandler]) {
-            methods = source.map(\.method)
+        init(source: [any RPCHandler.Type]) {
+            methods = source.map { h in h.method }
         }
 
-        func handle(request _: Request) async throws -> Response? {
+        public func handle(request _: Request) async throws -> Response? {
             methods
         }
     }

RPC/Sources/RPC/Handlers/SystemHandlers.swift

@@ -1,29 +1,50 @@
 import Utils
 
-enum SystemHandlers {
-    static func getHandlers(source _: SystemDataSource) -> [any RPCHandler] {
+public enum SystemHandlers {
+    public static let handlers: [any RPCHandler.Type] = [
+        Health.self,
+        Version.self,
+    ]
+
+    public static func getHandlers(source _: SystemDataSource) -> [any RPCHandler] {
         [
             Health(),
             Version(),
         ]
     }
 
-    struct Health: RPCHandler {
-        var method: String { "system_health" }
-        typealias Request = VoidRequest
-        typealias Response = Bool
+    public struct Health: RPCHandler {
+        public typealias Request = VoidRequest
+        public typealias Response = Bool
+
+        public static var method: String { "system_health" }
+        public static var summary: String? { "Returns true if the node is healthy." }
 
-        func handle(request _: Request) async throws -> Response? {
+        public func handle(request _: Request) async throws -> Response? {
             true
         }
     }
 
-    struct Version: RPCHandler {
-        var method: String { "system_version" }
-        typealias Request = VoidRequest
-        typealias Response = String
+    public struct Implementation: RPCHandler {
+        public typealias Request = VoidRequest
+        public typealias Response = String
+
+        public static var method: String { "system_implementation" }
+        public static var summary: String? { "Returns the implementation name of the node." }
+
+        public func handle(request _: Request) async throws -> Response? {
+            "Boka"
+        }
+    }
+
+    public struct Version: RPCHandler {
+        public typealias Request = VoidRequest
+        public typealias Response = String
+
+        public static var method: String { "system_version" }
+        public static var summary: String? { "Returns the version of the node." }
 
-        func handle(request _: Request) async throws -> Response? {
+        public func handle(request _: Request) async throws -> Response? {
             "0.0.1"
         }
     }

RPC/Sources/RPC/Handlers/TelemetryHandlers.swift

@@ -2,49 +2,57 @@
 import Foundation
 import Utils
 
-enum TelemetryHandlers {
-    static func getHandlers(source: TelemetryDataSource & ChainDataSource) -> [any RPCHandler] {
+public enum TelemetryHandlers {
+    public static let handlers: [any RPCHandler.Type] = [
+        GetUpdate.self,
+        Name.self,
+    ]
+
+    public static func getHandlers(source: TelemetryDataSource & ChainDataSource) -> [any RPCHandler] {
         [
             GetUpdate(source: source),
             Name(source: source),
         ]
     }
 
-    struct GetUpdate: RPCHandler {
-        var method: String { "telemetry_getUpdate" }
-        typealias Request = VoidRequest
-        typealias Response = [String: String]
+    public struct GetUpdate: RPCHandler {
+        public typealias Request = VoidRequest
+        public typealias Response = [String: String]
+
+        public static var method: String { "telemetry_getUpdate" }
+        public static var summary: String? { "Returns the latest telemetry update." }
 
         private let source: TelemetryDataSource & ChainDataSource
 
         init(source: TelemetryDataSource & ChainDataSource) {
             self.source = source
         }
 
-        func handle(request _: Request) async throws -> Response? {
+        public func handle(request _: Request) async throws -> Response? {
             let block = try await source.getBestBlock()
             let peerCount = try await source.getPeersCount()
-            return try await [
-                "name": source.name(),
+            return [
                 "chainHead": block.header.timeslot.description,
                 "blockHash": block.hash.description,
                 "peerCount": peerCount.description,
             ]
         }
     }
 
-    struct Name: RPCHandler {
-        var method: String { "telemetry_name" }
-        typealias Request = VoidRequest
-        typealias Response = String
+    public struct Name: RPCHandler {
+        public typealias Request = VoidRequest
+        public typealias Response = String
+
+        public static var method: String { "telemetry_name" }
+        public static var summary: String? { "Returns the name of the node." }
 
         private let source: TelemetryDataSource
 
         init(source: TelemetryDataSource) {
             self.source = source
         }
 
-        func handle(request _: Request) async throws -> Response? {
+        public func handle(request _: Request) async throws -> Response? {
             try await source.name()
         }
     }

RPC/Sources/RPC/JSONRPC/FromJSON.swift

@@ -6,21 +6,21 @@
     case unexpectedJSON
 }
 
-protocol FromJSON {
+public protocol FromJSON {
     init(from: JSON?) throws
 }
 
-enum VoidRequest: FromJSON {
+public enum VoidRequest: FromJSON {
     case void
 
-    init(from _: JSON?) throws {
+    public init(from _: JSON?) throws {
         // ignore
         self = .void
     }
 }
 
 extension Optional: FromJSON where Wrapped: FromJSON {
-    init(from json: JSON?) throws {
+    public init(from json: JSON?) throws {
         guard let json else {
             self = .none
             return
@@ -35,7 +35,7 @@
 }
 
 extension BinaryInteger where Self: FromJSON {
-    init(from json: JSON?) throws {
+    public init(from json: JSON?) throws {
         guard let json else {
             throw FromJSONError.null
         }
@@ -60,7 +60,7 @@
 extension UInt: FromJSON {}
 
 extension Data: FromJSON {
-    init(from json: JSON?) throws {
+    public init(from json: JSON?) throws {
         guard let json else {
             throw FromJSONError.null
         }
@@ -73,14 +73,14 @@
     }
 }
 
-extension Data32: FromJSON {
-    init(from json: JSON?) throws {
+extension FixedSizeData: FromJSON {
+    public init(from json: JSON?) throws {
         guard let json else {
             throw FromJSONError.null
         }
         switch json {
         case let .string(str):
-            self = try Data32(fromHexString: str).unwrap()
+            self = try FixedSizeData(fromHexString: str).unwrap()
         default:
             throw FromJSONError.unexpectedJSON
         }

RPC/Sources/RPC/JSONRPC/JSONRPC.swift

@@ -1,41 +1,41 @@
 import Utils
 import Vapor
 
-struct JSONRequest: Content {
-    let jsonrpc: String
-    let method: String
-    let params: JSON?
-    let id: JSON
+public struct JSONRequest: Content {
+    public let jsonrpc: String
+    public let method: String
+    public let params: JSON?
+    public let id: JSON
 }
 
-struct JSONResponse: Content {
-    let jsonrpc: String
-    let result: AnyCodable?
-    let error: JSONError?
-    let id: JSON?
+public struct JSONResponse: Content {
+    public let jsonrpc: String
+    public let result: AnyCodable?
+    public let error: JSONError?
+    public let id: JSON?
 
-    init(id: JSON?, result: (any Encodable)?) {
+    public init(id: JSON?, result: (any Encodable)?) {
         jsonrpc = "2.0"
         self.result = result.map(AnyCodable.init)
         error = nil
         self.id = id
     }
 
-    init(id: JSON?, error: JSONError) {
+    public init(id: JSON?, error: JSONError) {
         jsonrpc = "2.0"
         result = nil
         self.error = error
         self.id = id
     }
 }
 
-struct JSONError: Content, Error {
+public struct JSONError: Content, Error {
     let code: Int
     let message: String
 }
 
 extension JSONError {
-    static func methodNotFound(_ method: String) -> JSONError {
+    public static func methodNotFound(_ method: String) -> JSONError {
         JSONError(code: -32601, message: "Method not found: \(method)")
     }
 }

RPC/Sources/RPC/JSONRPC/JSONRPCController.swift

@@ -13,10 +13,11 @@
     init(handlers: [any RPCHandler]) {
         var dict = [String: any RPCHandler]()
         for handler in handlers {
-            if dict.keys.contains(handler.method) {
-                logger.warning("Duplicated handler: \(handler.method)")
+            let method = type(of: handler).method
+            if dict.keys.contains(method) {
+                logger.warning("Duplicated handler: \(method)")
             }
-            dict[handler.method] = handler
+            dict[method] = handler
         }
         self.handlers = dict