a basic telemetry rpc

Networking/Sources/Networking/Peer.swift

@@ -157,6 +157,11 @@ public final class Peer<Handler: StreamHandler>: Sendable {
             }
         }
     }
+
+    // there should be only one connection per peer
+    public func getPeersCount() -> Int {
+        impl.connections.value.byId.values.count
+    }
 }
 
 final class PeerImpl<Handler: StreamHandler>: Sendable {

Node/Sources/Node/NetworkingProtocol/Network.swift

@@ -77,6 +77,10 @@ public final class Network: Sendable {
     public func listenAddress() throws -> NetAddr {
         try peer.listenAddress()
     }
+
+    public func getPeersCount() -> Int {
+        peer.getPeersCount()
+    }
 }
 
 struct HandlerDef: StreamHandler {

Node/Sources/Node/NetworkingProtocol/NetworkManager.swift

@@ -104,6 +104,10 @@ public final class NetworkManager: Sendable {
             )
         }
     }
+
+    public func getPeersCount() -> Int {
+        network.getPeersCount()
+    }
 }
 
 struct HandlerImpl: NetworkProtocolHandler {

Node/Sources/Node/Node.swift

@@ -55,8 +55,10 @@ public class Node {
             devPeers: Set(config.peers)
         )
 
+        let nodeDataSource = NodeDataSource(blockchain: blockchain, chainDataProvider: dataProvider, networkManager: network)
+
         rpcServer = try config.rpc.map {
-            try Server(config: $0, source: blockchain)
+            try Server(config: $0, source: nodeDataSource)
         }
     }
 

Node/Sources/Node/NodeDataSource.swift

@@ -0,0 +1,35 @@
+import Blockchain
+import RPC
+import Utils
+
+public final class NodeDataSource: DataSource {
+    public let blockchain: Blockchain
+    public let chainDataProvider: BlockchainDataProvider
+    public let networkManager: NetworkManager
+
+    public init(blockchain: Blockchain, chainDataProvider: BlockchainDataProvider, networkManager: NetworkManager) {
+        self.blockchain = blockchain
+        self.chainDataProvider = chainDataProvider
+        self.networkManager = networkManager
+    }
+
+    public func importBlock(_ block: BlockRef) async throws {
+        try await blockchain.importBlock(block)
+    }
+
+    public func getBestBlock() async throws -> BlockRef {
+        try await chainDataProvider.getBlock(hash: chainDataProvider.bestHead.hash)
+    }
+
+    public func getBlock(hash: Data32) async throws -> BlockRef? {
+        try await chainDataProvider.getBlock(hash: hash)
+    }
+
+    public func getState(hash: Data32) async throws -> StateRef? {
+        try await chainDataProvider.getState(hash: hash)
+    }
+
+    public func getPeersCount() async throws -> Int {
+        networkManager.getPeersCount()
+    }
+}

Node/Sources/Node/ValidatorNode.swift

@@ -20,8 +20,8 @@ public class ValidatorNode: Node {
             dataProvider: dataProvider
         )
 
-        let genesisState = try await blockchain.getState(hash: blockchain.dataProvider.genesisBlockHash)
+        let genesisState = try await dataProvider.getState(hash: blockchain.dataProvider.genesisBlockHash)
 
-        await validator.on(genesis: genesisState!)
+        await validator.on(genesis: genesisState)
     }
 }

RPC/Sources/RPC/DataSource/DataSource.swift

@@ -4,6 +4,7 @@ import Utils
 public protocol DataSource: Sendable {
     func getBestBlock() async throws -> BlockRef
     func getBlock(hash: Data32) async throws -> BlockRef?
-
     func importBlock(_: BlockRef) async throws
+    func getState(hash: Data32) async throws -> StateRef?
+    func getPeersCount() async throws -> Int
 }

RPC/Sources/RPC/Handlers/ChainHandler.swift

@@ -10,6 +10,7 @@ struct ChainHandler {
 
         return [
             "chain_getBlock": handler.getBlock,
+            "chain_getState": handler.getState,
         ]
     }
 
@@ -20,10 +21,33 @@ struct ChainHandler {
                 throw JSONError(code: -32602, message: "Invalid block hash")
             }
             let block = try await source.getBlock(hash: data32)
-            return block.map { ["hash": $0.hash.description, "parentHash": $0.header.parentHash.description] }
+            return block
         } else {
             let block = try await source.getBestBlock()
-            return ["hash": block.hash.description, "parentHash": block.header.parentHash.description]
+            return block
+        }
+    }
+
+    func getState(request: JSONRequest) async throws -> any Encodable {
+        let hash = request.params?["hash"] as? String
+        if let hash {
+            guard let data = Data(fromHexString: hash), let data32 = Data32(data) else {
+                throw JSONError(code: -32602, message: "Invalid block hash")
+            }
+            let state = try await source.getState(hash: data32)
+            // return state root for now
+            return [
+                "stateRoot": state?.stateRoot.description,
+                "blockHash": hash.description,
+            ]
+        } else {
+            // return best block state by default
+            let block = try await source.getBestBlock()
+            let state = try await source.getState(hash: block.hash)
+            return [
+                "stateRoot": state?.stateRoot.description,
+                "blockHash": block.hash.description,
+            ]
         }
     }
 }

RPC/Sources/RPC/Handlers/SystemHandler.swift

@@ -4,10 +4,15 @@ struct SystemHandler {
 
         return [
             "system_health": handler.health,
+            "system_name": handler.name,
         ]
     }
 
     func health(request _: JSONRequest) async throws -> any Encodable {
         true
     }
+
+    func name(request _: JSONRequest) async throws -> any Encodable {
+        "Boka"
+    }
 }

RPC/Sources/RPC/Handlers/TelemetryHandler.swift

@@ -0,0 +1,26 @@
+import Blockchain
+import Foundation
+import Utils
+
+struct TelemetryHandler {
+    let source: DataSource
+
+    static func getHandlers(source: DataSource) -> [String: JSONRPCHandler] {
+        let handler = TelemetryHandler(source: source)
+
+        return [
+            "telemetry_getUpdate": handler.getUpdate,
+        ]
+    }
+
+    func getUpdate(request _: JSONRequest) async throws -> any Encodable {
+        let block = try await source.getBestBlock()
+        let peerCount = try await source.getPeersCount()
+        return [
+            "name": "Boka",
+            "chainHead": block.header.timeslot.description,
+            "blockHash": block.hash.description,
+            "peerCount": peerCount.description,
+        ]
+    }
+}

RPC/Sources/RPC/Server.swift

@@ -29,6 +29,7 @@ public class Server {
 
         var handlers: [String: JSONRPCHandler] = SystemHandler.getHandlers()
         handlers.merge(ChainHandler.getHandlers(source: source)) { _, new in new }
+        handlers.merge(TelemetryHandler.getHandlers(source: source)) { _, new in new }
 
         // Register routes
         let rpcController = JSONRPCController(handlers: handlers)