Update for network layer:

- `GetAccoung`
- `GetBalance`
- `GetBlockByHash`
- `GetBlockByNumber`

Author: yaroslavyaroslav

Sources/web3swift/API/Web3+APIMethod.swift

@@ -44,7 +44,7 @@ public enum APIRequest {
 
     case getCode(Address, BlockNumber)
     case getBlockByHash(Hash, Bool)
-    case getBlockByNumber(Hash, Bool)
+    case getBlockByNumber(BlockNumber, Bool)
 
     /// Returns fee history with a respect to given setup
     ///
@@ -99,6 +99,9 @@ extension APIRequest {
         switch self {
         case .blockNumber: return UInt.self
         case .getAccounts: return [EthereumAddress].self
+        case .getBalance: return BigUInt.self
+        case .getBlockByHash: return Block.self
+        case .getBlockByNumber: return Block.self
         case .feeHistory: return Web3.Oracle.FeeHistory.self
         default: return String.self
         }
@@ -115,43 +118,62 @@ extension APIRequest {
         switch self {
         case .gasPrice, .blockNumber, .getNetwork, .getAccounts, .estimateGas:
             return [RequestParameter]()
+
         case let .sendRawTransaction(hash):
             return [RequestParameter.string(hash)]
+
         case .sendTransaction(let transactionParameters):
             return [RequestParameter.transaction(transactionParameters)]
+
         case .getTransactionByHash(let hash):
             return [RequestParameter.string(hash)]
+
         case .getTransactionReceipt(let receipt):
             return [RequestParameter.string(receipt)]
+
         case .getLogs(let eventFilterParameters):
             return [RequestParameter.eventFilter(eventFilterParameters)]
+
         case .personalSign(let address, let data):
             // FIXME: Add second parameter
             return [RequestParameter.string(address)]
+
         case .call(let transactionParameters):
             return [RequestParameter.transaction(transactionParameters)]
+
         case .getTransactionCount(let address, let blockNumber):
             return [RequestParameter.string(address), RequestParameter.string(blockNumber.stringValue)]
+
         case .getBalance(let address, let blockNumber):
             return [RequestParameter.string(address), RequestParameter.string(blockNumber.stringValue)]
+
         case .getStorageAt(let address, let hash, let blockNumber):
             return [RequestParameter.string(address), RequestParameter.string(hash), RequestParameter.string(blockNumber.stringValue)]
+
         case .getCode(let address, let blockNumber):
             return [RequestParameter.string(address), RequestParameter.string(blockNumber.stringValue)]
+
         case .getBlockByHash(let hash, let bool):
             return [RequestParameter.string(hash), RequestParameter.bool(bool)]
-        case .getBlockByNumber(let hash, let bool):
-            return [RequestParameter.string(hash), RequestParameter.bool(bool)]
+
+        case .getBlockByNumber(let block, let bool):
+            return [RequestParameter.string(block.stringValue), RequestParameter.bool(bool)]
+
         case .feeHistory(let uInt, let blockNumber, let array):
             return [RequestParameter.string(uInt.hexString), RequestParameter.string(blockNumber.stringValue), RequestParameter.doubleArray(array)]
+
         case .createAccount(let string):
             return [RequestParameter]()
+
         case .unlockAccount(let address, let string, let optional):
             return [RequestParameter]()
+
         case .getTxPoolStatus:
             return [RequestParameter]()
+
         case .getTxPoolContent:
             return [RequestParameter]()
+
         case .getTxPoolInspect:
             return [RequestParameter]()
         }

Sources/web3swift/Promises/Promise+Web3+Eth+FeeHistory.swift

@@ -14,9 +14,7 @@ extension Web3.Oracle.FeeHistory: APIResultType { }
 extension web3.Eth {
     func feeHistory(blockCount: UInt, block: BlockNumber, percentiles:[Double]) async throws -> Web3.Oracle.FeeHistory {
         let requestCall: APIRequest = .feeHistory(blockCount, block, percentiles)
-
         let response: APIResponse<Web3.Oracle.FeeHistory> = try await APIRequest.sendRequest(with: web3.provider, for: requestCall)
-
         return response.result
     }
 }

Sources/web3swift/Promises/Promise+Web3+Eth+GetAccounts.swift

@@ -12,11 +12,7 @@ extension web3.Eth {
         guard self.web3.provider.attachedKeystoreManager == nil else {
             return try self.web3.wallet.getAccounts()
         }
-
-        let requestCall: APIRequest = .getAccounts
-
-        let response: APIResponse<[EthereumAddress]> = try await APIRequest.sendRequest(with: web3.provider, for: requestCall)
-
+        let response: APIResponse<[EthereumAddress]> = try await APIRequest.sendRequest(with: web3.provider, for: .getAccounts)
         return response.result
     }
 }

Sources/web3swift/Promises/Promise+Web3+Eth+GetBalance.swift

@@ -9,21 +9,13 @@ import Foundation
 import BigInt
 
 extension web3.Eth {
-    public func getBalance(for address: EthereumAddress, onBlock: String = "latest") async throws -> BigUInt {
-        let addr = address.address
-        return try await getBalance(address: addr, onBlock: onBlock)
+    public func getBalance(for address: EthereumAddress, onBlock: BlockNumber = .latest) async throws -> BigUInt {
+        try await getBalance(for: address.address, onBlock: onBlock)
     }
-    public func getBalance(address: String, onBlock: String = "latest") async throws -> BigUInt {
-        let request = JSONRPCRequestFabric.prepareRequest(.getBalance, parameters: [address.lowercased(), onBlock])
-        let response = try await web3.dispatch(request)
-
-        guard let value: BigUInt = response.getValue() else {
-            if response.error != nil {
-                throw Web3Error.nodeError(desc: response.error!.message)
-            }
-            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
-        }
-        return value
 
+    public func getBalance(for address: Address, onBlock: BlockNumber = .latest) async throws -> BigUInt {
+        let requestCall: APIRequest = .getBalance(address, onBlock)
+        let response: APIResponse<BigUInt> = try await APIRequest.sendRequest(with: web3.provider, for: requestCall)
+        return response.result
     }
 }

Sources/web3swift/Promises/Promise+Web3+Eth+GetBlockByHash.swift

@@ -9,22 +9,14 @@ import BigInt
 
 
 extension web3.Eth {
-    public func block(for hash: Data, fullTransactions: Bool = false) async throws -> Block {
+    public func block(by hash: Data, fullTransactions: Bool = false) async throws -> Block {
         let hashString = hash.toHexString().addHexPrefix()
-        return try await block(for: hashString, fullTransactions: fullTransactions)
+        return try await block(by: hashString, fullTransactions: fullTransactions)
     }
 
-    public func block(for hash: String, fullTransactions: Bool = false) async throws -> Block {
-        let request = JSONRPCRequestFabric.prepareRequest(.getBlockByHash, parameters: [hash, fullTransactions])
-        let response = try await web3.dispatch(request)
-
-        guard let value: Block = response.getValue() else {
-            if response.error != nil {
-                throw Web3Error.nodeError(desc: response.error!.message)
-            }
-            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
-        }
-        return value
-
+    public func block(by hash: String, fullTransactions: Bool = false) async throws -> Block {
+        let requestCall: APIRequest = .getBlockByHash(hash, fullTransactions)
+        let response: APIResponse<Block> = try await APIRequest.sendRequest(with: self.provider, for: requestCall)
+        return response.result
     }
 }

Sources/web3swift/Promises/Promise+Web3+Eth+GetBlockByNumber.swift

@@ -9,27 +9,14 @@ import BigInt
 
 
 extension web3.Eth {
-    public func blockBy(number: UInt, fullTransactions: Bool = false) async throws -> Block {
-        let block = String(number, radix: 16).addHexPrefix()
-        return try await blockBy(number: block, fullTransactions: fullTransactions)
+    public func block(by number: UInt, fullTransactions: Bool = false) async throws -> Block {
+        let blockNumber = BlockNumber.exact(number)
+        return try await block(by: blockNumber, fullTransactions: fullTransactions)
     }
 
-    public func blockBy(number: BigUInt, fullTransactions: Bool = false) async throws -> Block {
-        let block = String(number, radix: 16).addHexPrefix()
-        return try await blockBy(number: block, fullTransactions: fullTransactions)
-    }
-
-    public func blockBy(number: String, fullTransactions: Bool = false) async throws -> Block {
-        let request = JSONRPCRequestFabric.prepareRequest(.getBlockByNumber, parameters: [number, fullTransactions])
-        let response = try await web3.dispatch(request)
-
-        guard let value: Block = response.getValue() else {
-            if response.error != nil {
-                throw Web3Error.nodeError(desc: response.error!.message)
-            }
-            throw Web3Error.nodeError(desc: "Invalid value from Ethereum node")
-        }
-        return value
-
+    public func block(by number: BlockNumber, fullTransactions: Bool = false) async throws -> Block {
+        let requestCall: APIRequest = .getBlockByNumber(number, fullTransactions)
+        let response: APIResponse<Block> = try await APIRequest.sendRequest(with: self.provider, for: requestCall)
+        return response.result
     }
 }