Update for network layer:

- `GetCode`
- `GetTransactionCount`
- `GetTransactionReceipt`
- `CreateAccount`
- `UnlockAccount`

Author: yaroslavyaroslav

Sources/web3swift/API/HexDecodableProtocols.swift

@@ -13,6 +13,8 @@ extension Array: APIResultType where Element: APIResultType { }
 
 extension String: APIResultType { }
 
+extension Bool: APIResultType { }
+
 /// This is utility protocol for decoding API Responses
 ///
 /// You better not use it in any other part of a bit of code except `APIResponse<T>` decoding.

Sources/web3swift/API/Web3+APIMethod.swift

@@ -27,7 +27,7 @@ public enum APIRequest {
     case sendRawTransaction(Hash)
     case sendTransaction(TransactionParameters)
     case getTransactionByHash(Hash)
-    case getTransactionReceipt(Receipt)
+    case getTransactionReceipt(Hash)
     case getLogs(EventFilterParameters)
     case personalSign(Address, Data)
     case call(TransactionParameters)
@@ -105,6 +105,10 @@ extension APIRequest {
         case .gasPrice: return BigUInt.self
         case .feeHistory: return Web3.Oracle.FeeHistory.self
         case .getTransactionCount: return UInt.self
+        case .getCode: return Hash.self
+        case .getTransactionReceipt: return TransactionReceipt.self
+        case .createAccount: return EthereumAddress.self
+        case .unlockAccount: return Bool.self
         default: return String.self
         }
     }
@@ -225,6 +229,8 @@ extension APIRequest {
         guard let httpResponse = response as? HTTPURLResponse,
                200 ..< 400 ~= httpResponse.statusCode else { throw Web3Error.connectionError }
 
+        /// This bit of code is purposed to work with literal types that comes in Response in hexString type.
+        /// Currently it's just any kind of Integers like `(U)Int`, `Big(U)Int`.
         if Result.self == UInt.self || Result.self == Int.self || Result.self == BigInt.self || Result.self == BigUInt.self {
             /// This types for sure conformed with `LiteralInitiableFromString`
             // FIXME: Make appropriate error

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

@@ -10,7 +10,7 @@ import BigInt
 
 extension web3.Eth {
     public func block(by hash: Data, fullTransactions: Bool = false) async throws -> Block {
-        try await block(by: hashString.toHexString().addHexPrefix(), fullTransactions: fullTransactions)
+        try await block(by: hash.toHexString().addHexPrefix(), fullTransactions: fullTransactions)
     }
 
     public func block(by hash: String, fullTransactions: Bool = false) async throws -> Block {

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

@@ -10,21 +10,13 @@ import Foundation
 import BigInt
 
 extension web3.Eth {
-    public func code(for address: EthereumAddress, onBlock: String = "latest") async throws -> String {
-        let addr = address.address
-        return try await code(for : addr, onBlock: onBlock)
+    public func code(for address: EthereumAddress, onBlock: BlockNumber) async throws -> Hash {
+        try await code(for : address.address, onBlock: onBlock)
     }
-    public func code(for address: String, onBlock: String = "latest") async throws -> String {
-        let request = JSONRPCRequestFabric.prepareRequest(.getCode, parameters: [address.lowercased(), onBlock])
-        let response = try await web3.dispatch(request)
-
-        guard let value: String = 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 code(for address: Address, onBlock: BlockNumber) async throws -> Hash {
+        let requestCall: APIRequest = .getCode(address, onBlock)
+        let response: APIResponse<Hash> = try await APIRequest.sendRequest(with: self.provider, for: requestCall)
+        return response.result
     }
 }

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

@@ -14,7 +14,7 @@ extension web3.Eth {
 
     public func getTransactionCount(address: Address, onBlock: BlockNumber) async throws -> UInt {
         let requestCall: APIRequest = .getTransactionCount(address, onBlock)
-        let response: APIResponse<UInt> = APIRequest.sendRequest(with: self.provider, for: requestCall)
+        let response: APIResponse<UInt> = try await APIRequest.sendRequest(with: self.provider, for: requestCall)
         return response.result
     }
 }

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

@@ -7,24 +7,16 @@
 import Foundation
 import BigInt
 
+extension TransactionReceipt: APIResultType { }
 
 extension web3.Eth {
     public func transactionReceipt(_ txhash: Data) async throws -> TransactionReceipt {
-        let hashString = txhash.toHexString().addHexPrefix()
-        return try await self.transactionReceipt(hashString)
+        try await self.transactionReceipt(txhash.toHexString().addHexPrefix())
     }
 
-    public func transactionReceipt(_ txhash: String) async throws -> TransactionReceipt {
-        let request = JSONRPCRequestFabric.prepareRequest(.getTransactionReceipt, parameters: [txhash])
-        let response = try await web3.dispatch(request)
-
-        guard let value: TransactionReceipt = 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 transactionReceipt(_ txhash: Hash) async throws -> TransactionReceipt {
+        let requestCall: APIRequest = .getTransactionReceipt(txhash)
+        let response: APIResponse<TransactionReceipt> = try await APIRequest.sendRequest(with: self.provider, for: requestCall)
+        return response.result
     }
 }

Sources/web3swift/Promises/Promise+Web3+Personal+CreateAccount.swift

@@ -10,21 +10,12 @@ import BigInt
 
 extension web3.Personal {
     public func createAccount(password: String = "web3swift") async throws -> EthereumAddress {
-
         guard self.web3.provider.attachedKeystoreManager == nil else {
             throw Web3Error.inputError(desc: "Creating account in a local keystore with this method is not supported")
         }
 
-        let request = JSONRPCRequestFabric.prepareRequest(.createAccount, parameters: [password])
-        let response = try await self.web3.dispatch(request)
-
-        guard let value: EthereumAddress = 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
-
+        let requestCall: APIRequest = .createAccount(password)
+        let response: APIResponse<EthereumAddress> = try await APIRequest.sendRequest(with: self.provider, for: requestCall)
+        return response.result
     }
 }

Sources/web3swift/Promises/Promise+Web3+Personal+UnlockAccount.swift

@@ -10,29 +10,16 @@ import BigInt
 
 extension web3.Personal {
     public func unlock(account: EthereumAddress, password: String = "web3swift", seconds: UInt = 300) async throws -> Bool {
-        let addr = account.address
-        return try await unlock(account: addr, password: password, seconds: seconds)
+        try await unlock(account: account.address, password: password, seconds: seconds)
     }
 
-    public func unlock(account: String, password: String = "web3swift", seconds: UInt = 300) async throws -> Bool {
-
+    public func unlock(account: Address, password: String = "web3swift", seconds: UInt = 300) async throws -> Bool {
         guard self.web3.provider.attachedKeystoreManager == nil else {
             throw Web3Error.inputError(desc: "Can not unlock a local keystore")
         }
 
-        let parameters: [APIRequestParameterType] = [account.lowercased(), password, seconds]
-
-        let request = JSONRPCRequestFabric.prepareRequest(.unlockAccount, parameters: parameters)
-
-        let response = try await self.web3.dispatch(request)
-
-        guard let value: Bool = 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
-
+        let requestCall: APIRequest = .unlockAccount(account, password, seconds)
+        let response: APIResponse<Bool> = try await APIRequest.sendRequest(with: self.provider, for: requestCall)
+        return response.result
     }
 }