update RPC ChainHandler (#268)

* add more rpc test

* update getBlock

* update chainHandle tests

* update chainhandles

* update datasource

* update chainHandlers

* update chainhandler test

* update swiftlint

* update system handlers

* update TelemetryHandlers tests

* update statehandler

* update swiftlint

* update NodeDataSource

* update node test

* update tests

* update chainhandler

* Update RPC/Sources/RPC/Handlers/ChainHandlers.swift

Co-authored-by: Xiliang Chen <xlchen1291@gmail.com>

* update chainhandler

---------

Co-authored-by: Xiliang Chen <xlchen1291@gmail.com>

Author: MacOMNI

Blockchain/Sources/Blockchain/BlockchainDataProvider/BlockchainDataProvider.swift

@@ -98,6 +98,18 @@ extension BlockchainDataProvider {
         try await dataProvider.getBlockHash(byNumber: number)
     }
 
+    public func getFinalizedHead() async throws -> Data32? {
+        try await dataProvider.getFinalizedHead()
+    }
+
+    public func getKeys(prefix: Data32, count: UInt32, startKey: Data32?, blockHash: Data32?) async throws -> [String] {
+        try await dataProvider.getKeys(prefix: prefix, count: count, startKey: startKey, blockHash: blockHash)
+    }
+
+    public func getStorage(key: Data32, blockHash: Data32?) async throws -> [String] {
+        try await dataProvider.getStorage(key: key, blockHash: blockHash)
+    }
+
     // add forks of finalized head is not allowed
     public func add(block: BlockRef) async throws {
         logger.debug("adding block: \(block.hash)")

Blockchain/Sources/Blockchain/BlockchainDataProvider/BlockchainDataProviderProtocol.swift

@@ -14,8 +14,13 @@ public protocol BlockchainDataProviderProtocol: Sendable {
     func getState(hash: Data32) async throws -> StateRef?
 
     func getFinalizedHead() async throws -> Data32?
+
     func getHeads() async throws -> Set<Data32>
 
+    func getKeys(prefix: Data32, count: UInt32, startKey: Data32?, blockHash: Data32?) async throws -> [String]
+
+    func getStorage(key: Data32, blockHash: Data32?) async throws -> [String]
+
     /// return empty set if not found
     func getBlockHash(byTimeslot timeslot: TimeslotIndex) async throws -> Set<Data32>
     /// return empty set if not found

Blockchain/Sources/Blockchain/BlockchainDataProvider/InMemoryDataProvider.swift

@@ -22,6 +22,25 @@ public actor InMemoryDataProvider {
 }
 
 extension InMemoryDataProvider: BlockchainDataProviderProtocol {
+    public func getKeys(prefix: Data32, count: UInt32, startKey: Data32?, blockHash: Data32?) async throws -> [String] {
+        guard let stateRef = try getState(hash: blockHash ?? genesisBlockHash) else {
+            return []
+        }
+
+        return try await stateRef.value.backend.getKeys(prefix, startKey, count).map { $0.key.toHexString() }
+    }
+
+    public func getStorage(key: Data32, blockHash: Data32?) async throws -> [String] {
+        guard let stateRef = try getState(hash: blockHash ?? genesisBlockHash) else {
+            return []
+        }
+
+        guard let value = try await stateRef.value.backend.readRaw(key) else {
+            throw StateBackendError.missingState(key: key)
+        }
+        return [value.toHexString()]
+    }
+
     public func hasBlock(hash: Data32) -> Bool {
         blockByHash[hash] != nil
     }

Blockchain/Sources/Blockchain/Config/ProtocolConfig+Preset.swift

@@ -1,5 +1,18 @@
 import Utils
 
+extension ProtocolConfig {
+    private static let presetMapping: [String: ProtocolConfig] = [
+        "minimal": ProtocolConfigRef.minimal.value,
+        "dev": ProtocolConfigRef.dev.value,
+        "tiny": ProtocolConfigRef.tiny.value,
+        "mainnet": ProtocolConfigRef.mainnet.value,
+    ]
+
+    public func presetName() -> String? {
+        ProtocolConfig.presetMapping.first(where: { $0.value == self })?.key
+    }
+}
+
 extension Ref where T == ProtocolConfig {
     // TODO: pick some good numbers for dev env
     public static let minimal = Ref(ProtocolConfig(

Blockchain/Sources/Blockchain/State/StateBackend.swift

@@ -38,6 +38,10 @@ public final class StateBackend: Sendable {
         throw StateBackendError.missingState(key: key)
     }
 
+    public func getKeys(_ prefix: Data32, _ startKey: Data32?, _ limit: UInt32?) async throws -> [(key: Data, value: Data)] {
+        try await impl.readAll(prefix: prefix.data, startKey: startKey?.data, limit: limit)
+    }
+
     public func batchRead(_ keys: [any StateKey]) async throws -> [(key: any StateKey, value: (Codable & Sendable)?)] {
         var ret = [(key: any StateKey, value: (Codable & Sendable)?)]()
         ret.reserveCapacity(keys.count)

Database/Sources/Database/RocksDBBackend.swift

@@ -72,6 +72,31 @@ public final class RocksDBBackend: Sendable {
 }
 
 extension RocksDBBackend: BlockchainDataProviderProtocol {
+    public func getKeys(prefix: Data32, count: UInt32, startKey: Data32?, blockHash: Data32?) async throws -> [String] {
+        logger.trace("""
+        getKeys() prefix: \(prefix), count: \(count),
+        startKey: \(String(describing: startKey)), blockHash: \(String(describing: blockHash))
+        """)
+
+        guard let stateRef = try await getState(hash: blockHash ?? genesisBlockHash) else {
+            return []
+        }
+        return try await stateRef.value.backend.getKeys(prefix, startKey, count).map { $0.key.toHexString() }
+    }
+
+    public func getStorage(key: Data32, blockHash: Data32?) async throws -> [String] {
+        logger.trace("getStorage() key: \(key), blockHash: \(String(describing: blockHash))")
+
+        guard let stateRef = try await getState(hash: blockHash ?? genesisBlockHash) else {
+            return []
+        }
+
+        guard let value = try await stateRef.value.backend.readRaw(key) else {
+            throw StateBackendError.missingState(key: key)
+        }
+        return [value.toHexString()]
+    }
+
     public func hasBlock(hash: Data32) async throws -> Bool {
         try blocks.exists(key: hash)
     }

Node/Sources/Node/NetworkingProtocol/Network.swift

@@ -92,6 +92,10 @@ public final class Network: Sendable {
     public var peersCount: Int {
         peer.peersCount
     }
+
+    public var networkKey: String {
+        peer.publicKey.description
+    }
 }
 
 struct HandlerDef: StreamHandler {

Node/Sources/Node/NodeDataSource.swift

@@ -22,9 +22,46 @@ public final class NodeDataSource: Sendable {
     }
 }
 
-extension NodeDataSource: SystemDataSource {}
+extension NodeDataSource: SystemDataSource {
+    public func getProperties() async throws -> JSON {
+        // TODO: Get a custom set of properties as a JSON object, defined in the chain spec
+        JSON.array([])
+    }
+
+    public func getChainName() async throws -> String {
+        blockchain.config.value.presetName() ?? ""
+    }
+
+    public func getNodeRoles() async throws -> [String] {
+        // TODO: Returns the roles the node is running as.
+        []
+    }
+
+    public func getVersion() async throws -> String {
+        // TODO: From spec or config
+        "0.0.1"
+    }
+
+    public func getHealth() async throws -> Bool {
+        // TODO: Check health status
+        true
+    }
+
+    public func getImplementation() async throws -> String {
+        name
+    }
+}
 
 extension NodeDataSource: ChainDataSource {
+    public func getKeys(prefix: Data32, count: UInt32, startKey: Data32?, blockHash: Data32?) async throws -> [String] {
+        // TODO:
+        try await chainDataProvider.getKeys(prefix: prefix, count: count, startKey: startKey, blockHash: blockHash)
+    }
+
+    public func getStorage(key: Data32, blockHash: Utils.Data32?) async throws -> [String] {
+        try await chainDataProvider.getStorage(key: key, blockHash: blockHash)
+    }
+
     public func getBestBlock() async throws -> BlockRef {
         try await chainDataProvider.getBlock(hash: chainDataProvider.bestHead.hash)
     }
@@ -37,6 +74,18 @@ extension NodeDataSource: ChainDataSource {
         let state = try await chainDataProvider.getState(hash: blockHash)
         return try await state.value.read(key: key)
     }
+
+    public func getBlockHash(byTimeslot timeslot: TimeslotIndex) async throws -> Set<Data32> {
+        try await chainDataProvider.getBlockHash(byTimeslot: timeslot)
+    }
+
+    public func getHeader(hash: Data32) async throws -> HeaderRef? {
+        try await chainDataProvider.getHeader(hash: hash)
+    }
+
+    public func getFinalizedHead() async throws -> Data32? {
+        try await chainDataProvider.getFinalizedHead()
+    }
 }
 
 extension NodeDataSource: TelemetryDataSource {
@@ -47,4 +96,8 @@ extension NodeDataSource: TelemetryDataSource {
     public func getPeersCount() async throws -> Int {
         networkManager.peersCount
     }
+
+    public func getNetworkKey() async throws -> String {
+        networkManager.network.networkKey
+    }
 }

Node/Tests/NodeTests/NodeTests.swift

@@ -1,4 +1,5 @@
 import Blockchain
+import Database
 import Foundation
 import Testing
 import Utils
@@ -79,6 +80,10 @@ final class NodeTests {
         // Verify block was produced
         #expect(newTimeslot > initialTimeslot)
         #expect(try await validatorNode.blockchain.dataProvider.hasBlock(hash: newBestHead.hash))
+        #expect(try await validatorNode.blockchain.dataProvider.getKeys(prefix: Data32(), count: 0, startKey: nil, blockHash: nil).isEmpty)
+        await #expect(throws: StateBackendError.self) {
+            _ = try await validatorNode.blockchain.dataProvider.getStorage(key: Data32.random(), blockHash: nil)
+        }
     }
 
     @Test func sync() async throws {

Node/Tests/NodeTests/Topology.swift

@@ -25,8 +25,6 @@ struct Topology {
     }
 
     func build(genesis: Genesis) async throws -> ([(Node, StoreMiddleware)], MockScheduler) {
-        // setupTestLogger()
-
         let timeProvider = MockTimeProvider(time: 1000)
         let scheduler = MockScheduler(timeProvider: timeProvider)
         var ret: [(Node, StoreMiddleware)] = []