Add TxPool and getLog implementation

- Temporary disabled getting Network within Web3HttpProvider init.
-

Author: yaroslavyaroslav

Sources/web3swift/API/APIMethod.swift

@@ -117,14 +117,14 @@ extension APIRequest {
         case .estimateGas: return BigUInt.self
         case .call: return Data.self
         // FIXME: Not checked
-        case .getNetwork: return UInt.self
+        case .getNetwork: return Int.self
         case .personalSign: return Data.self
+        case .getTxPoolStatus: return TxPoolStatus.self
+        case .getTxPoolContent: return TxPoolContent.self
 
         // FIXME: Not implemented
         case .getLogs: return String.self
         case .getStorageAt: return String.self
-        case .getTxPoolStatus: return String.self
-        case .getTxPoolContent: return String.self
         case .getTxPoolInspect: return String.self
         }
     }
@@ -138,7 +138,7 @@ extension APIRequest {
 
     var parameters: [RequestParameter] {
         switch self {
-        case .gasPrice, .blockNumber, .getNetwork, .getAccounts:
+        case .gasPrice, .blockNumber, .getNetwork, .getAccounts, .getTxPoolStatus, .getTxPoolContent, .getTxPoolInspect:
             return [RequestParameter]()
 
         case .estimateGas(let transactionParameters, let blockNumber):
@@ -192,15 +192,6 @@ extension APIRequest {
 
         case .unlockAccount(let address, let string, let uInt):
             return [RequestParameter.string(address), RequestParameter.string(string), RequestParameter.uint(uInt ?? 0)]
-
-        case .getTxPoolStatus:
-            return [RequestParameter]()
-
-        case .getTxPoolContent:
-            return [RequestParameter]()
-
-        case .getTxPoolInspect:
-            return [RequestParameter]()
         }
     }
 

Sources/web3swift/EthereumAPICalls/Promise+Web3+TxPool.swift

@@ -0,0 +1,35 @@
+//  web3swift
+//
+//  Created by Alex Vlasov.
+//  Copyright © 2018 Alex Vlasov. All rights reserved.
+//
+
+import Foundation
+import BigInt
+
+
+extension web3.TxPool {
+//    public func txPoolInspect() async throws -> [String: [String: [String: String]]] {
+//        let request = JSONRPCRequestFabric.prepareRequest(.getTxPoolInspect, parameters: [])
+//        let response = try await web3.dispatch(request)
+//
+//        guard let value: [String: [String: [String: 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 txPoolStatus() async throws -> TxPoolStatus {
+        let response: APIResponse<TxPoolStatus> = try await APIRequest.sendRequest(with: provider, for: .getTxPoolStatus)
+        return response.result
+    }
+
+    public func txPoolContent() async throws -> TxPoolContent {
+        let response: APIResponse<TxPoolContent> = try await APIRequest.sendRequest(with: provider, for: .getTxPoolContent)
+        return response.result
+    }
+}

Sources/web3swift/EthereumAPICalls/TxPool.swift

@@ -28,10 +28,10 @@ extension web3.web3contract {
          *Parses the block for events matching the EventParser settings.*
 
          - parameters:
-            - blockNumber: Ethereum network block number
+         - blockNumber: Ethereum network block number
 
          - returns:
-            - Result object
+         - Result object
 
          - important: This call is synchronous
 
@@ -45,10 +45,10 @@ extension web3.web3contract {
          *Parses the block for events matching the EventParser settings.*
 
          - parameters:
-            - block: Native web3swift block object
+         - block: Native web3swift block object
 
          - returns:
-            - Result object
+         - Result object
 
          - important: This call is synchronous
 
@@ -62,10 +62,10 @@ extension web3.web3contract {
          *Parses the transaction for events matching the EventParser settings.*
 
          - parameters:
-            - hash: Transaction hash
+         - hash: Transaction hash
 
          - returns:
-            - Result object
+         - Result object
 
          - important: This call is synchronous
 
@@ -79,10 +79,10 @@ extension web3.web3contract {
          *Parses the transaction for events matching the EventParser settings.*
 
          - parameters:
-            - transaction: web3swift native EthereumTransaction object
+         - transaction: web3swift native EthereumTransaction object
 
          - returns:
-            - Result object
+         - Result object
 
          - important: This call is synchronous
 
@@ -174,65 +174,49 @@ extension web3.web3contract.EventParser {
 }
 
 extension web3.web3contract {
-
     /**
      *Fetches events by doing a lookup on "indexed" parameters of the event. Smart-contract developer can make some of event values "indexed" for such fast queries.*
 
      - parameters:
-         - eventName: Event name, should be present in ABI interface of the contract
-         - filter: EventFilter object setting the block limits for query
-         - joinWithReceipts: Bool indicating whether TransactionReceipt should be fetched separately for every matched transaction
+     - eventName: Event name, should be present in ABI interface of the contract
+     - filter: EventFilter object setting the block limits for query
+     - joinWithReceipts: Bool indicating whether TransactionReceipt should be fetched separately for every matched transaction
 
      - returns:
-        - Result object
+     - Result object
 
      - important: This call is synchronous
 
      */
     public func getIndexedEvents(eventName: String?, filter: EventFilter, joinWithReceipts: Bool = false) async throws -> [EventParserResultProtocol] {
-        let result = try await self.getIndexedEventsPromise(eventName: eventName, filter: filter, joinWithReceipts: joinWithReceipts)
-        return result
-    }
-}
-
-extension web3.web3contract {
-    public func getIndexedEventsPromise(eventName: String?, filter: EventFilter, joinWithReceipts: Bool = false) async throws -> [EventParserResultProtocol] {
-
-            let rawContract = self.contract
-            guard let preEncoding = encodeTopicToGetLogs(contract: rawContract, eventName: eventName, filter: filter) else {
-                throw Web3Error.processingError(desc: "Failed to encode topic for request")
-            }
-
-            if eventName != nil {
-                guard let _ = rawContract.events[eventName!] else {
-                    throw Web3Error.processingError(desc: "No such event in a contract")
-                }
-            }
-            let request = JSONRPCRequestFabric.prepareRequest(.getLogs, parameters: [preEncoding])
-            let response = try await self.web3.dispatch(request)
+        let rawContract = self.contract
+        guard let preEncoding = encodeTopicToGetLogs(contract: rawContract, eventName: eventName, filter: filter) else {
+            throw Web3Error.processingError(desc: "Failed to encode topic for request")
+        }
 
-            guard let allLogs: [EventLog] = response.getValue() else {
-                if response.error != nil {
-                    throw Web3Error.nodeError(desc: response.error!.message)
-                }
-                throw Web3Error.nodeError(desc: "Empty or malformed response")
+        if eventName != nil {
+            guard let _ = rawContract.events[eventName!] else {
+                throw Web3Error.processingError(desc: "No such event in a contract")
             }
+        }
 
+        // FIXME: This could not worked at all.
+        let request: APIRequest = .getLogs(preEncoding)
+        let response: APIResponse<[EventLog]> = try await APIRequest.sendRequest(with: self.web3.provider, for: request)
 
-            let decodedLogs = allLogs.compactMap { (log) -> EventParserResult? in
-                let (n, d) = self.contract.parseEvent(log)
-                guard let evName = n, let evData = d else {return nil}
-                var res = EventParserResult(eventName: evName, transactionReceipt: nil, contractAddress: log.address, decodedResult: evData)
-                res.eventLog = log
-                return res
-            }
+        let decodedLogs = response.result.compactMap { (log) -> EventParserResult? in
+            let (n, d) = self.contract.parseEvent(log)
+            guard let evName = n, let evData = d else {return nil}
+            var res = EventParserResult(eventName: evName, transactionReceipt: nil, contractAddress: log.address, decodedResult: evData)
+            res.eventLog = log
+            return res
+        }
             .filter{ res in res.eventLog != nil || (res.eventName == eventName && eventName != nil)}
 
 
-            if (!joinWithReceipts) {
-                return decodedLogs as [EventParserResultProtocol]
-            }
-
+        if (!joinWithReceipts) {
+            return decodedLogs as [EventParserResultProtocol]
+        }
 
         return await withTaskGroup(of: EventParserResultProtocol.self, returning: [EventParserResultProtocol].self) { group -> [EventParserResultProtocol] in
 
@@ -252,7 +236,6 @@ extension web3.web3contract {
             }
 
             return collected
-
         }
     }
 }

Sources/web3swift/Web3/Web3+EventParser.swift

@@ -10,8 +10,8 @@ import BigInt
 
 /// Providers abstraction for custom providers (websockets, other custom private key managers). At the moment should not be used.
 public protocol Web3Provider {
-    func sendAsync(_ request: JSONRPCrequest) async throws -> JSONRPCresponse
-    func sendAsync(_ requests: JSONRPCrequestBatch) async throws -> JSONRPCresponseBatch
+//    func sendAsync(_ request: JSONRPCrequest) async throws -> JSONRPCresponse
+//    func sendAsync(_ requests: JSONRPCrequestBatch) async throws -> JSONRPCresponseBatch
     var network: Networks? {get set}
     var attachedKeystoreManager: KeystoreManager? {get set}
     var url: URL {get}
@@ -28,66 +28,44 @@ public class Web3HttpProvider: Web3Provider {
         let urlSession = URLSession(configuration: config)
         return urlSession
     }()
-    public init?(_ httpProviderURL: URL, network net: Networks? = nil, keystoreManager manager: KeystoreManager? = nil) async {
-        do {
-            guard httpProviderURL.scheme == "http" || httpProviderURL.scheme == "https" else {
-                return nil
-            }
-            url = httpProviderURL
-            if net == nil {
-                let request = JSONRPCRequestFabric.prepareRequest(.getNetwork, parameters: [])
-                let response: JSONRPCresponse = try await Web3HttpProvider.post(request, providerURL: httpProviderURL, session: session)
-                if response.error != nil {
-                    if response.message != nil {
-                        print(response.message!)
-                    }
-                    return nil
-                }
-                guard let result: String = response.getValue(), let intNetworkNumber = Int(result) else {return nil}
-                network = Networks.fromInt(intNetworkNumber)
-                if network == nil {
-                    return nil
-                }
-            } else {
-                network = net
-            }
-        } catch {
-            return nil
-        }
+    public init?(_ httpProviderURL: URL, network net: Networks, keystoreManager manager: KeystoreManager? = nil) {
+        guard httpProviderURL.scheme == "http" || httpProviderURL.scheme == "https" else { return nil }
+        url = httpProviderURL
+        network = net
         attachedKeystoreManager = manager
     }
 
-    fileprivate static func dataFrom(session: URLSession, request urlRequest: URLRequest) async throws -> Data{
-        let (data, _) = try await session.data(for: urlRequest)
-        return data
-    }
-
-    static func post<T: Decodable, U: Encodable>(_ request: U, providerURL: URL, session: URLSession) async throws -> T {
-        let requestData = try JSONEncoder().encode(request)
-        var urlRequest = URLRequest(url: providerURL, cachePolicy: .reloadIgnoringCacheData)
-        urlRequest.httpMethod = "POST"
-        urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
-        urlRequest.setValue("application/json", forHTTPHeaderField: "Accept")
-        urlRequest.httpBody = requestData
-
-        let data = try await dataFrom(session: session, request: urlRequest)
-
-        let parsedResponse = try JSONDecoder().decode(T.self, from: data)
-
-        if let response = parsedResponse as? JSONRPCresponse, response.error != nil {
-            throw Web3Error.nodeError(desc: "Received an error message from node\n" + String(describing: response.error!))
-        }
-        return parsedResponse
-
-    }
-
-    public func sendAsync(_ request: JSONRPCrequest) async throws -> JSONRPCresponse {
-        guard request.method != nil else {
-            throw Web3Error.nodeError(desc: "RPC method is nill")
-        }
-
-        return try await Web3HttpProvider.post(request, providerURL: self.url, session: self.session)
-    }
+//    fileprivate static func dataFrom(session: URLSession, request urlRequest: URLRequest) async throws -> Data{
+//        let (data, _) = try await session.data(for: urlRequest)
+//        return data
+//    }
+//
+//    static func post<T: Decodable, U: Encodable>(_ request: U, providerURL: URL, session: URLSession) async throws -> T {
+//        let requestData = try JSONEncoder().encode(request)
+//        var urlRequest = URLRequest(url: providerURL, cachePolicy: .reloadIgnoringCacheData)
+//        urlRequest.httpMethod = "POST"
+//        urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
+//        urlRequest.setValue("application/json", forHTTPHeaderField: "Accept")
+//        urlRequest.httpBody = requestData
+//
+//        let data = try await dataFrom(session: session, request: urlRequest)
+//
+//        let parsedResponse = try JSONDecoder().decode(T.self, from: data)
+//
+//        if let response = parsedResponse as? JSONRPCresponse, response.error != nil {
+//            throw Web3Error.nodeError(desc: "Received an error message from node\n" + String(describing: response.error!))
+//        }
+//        return parsedResponse
+//
+//    }
+//
+//    public func sendAsync(_ request: JSONRPCrequest) async throws -> JSONRPCresponse {
+//        guard request.method != nil else {
+//            throw Web3Error.nodeError(desc: "RPC method is nill")
+//        }
+//
+//        return try await Web3HttpProvider.post(request, providerURL: self.url, session: self.session)
+//    }
 
 //    public func sendAsync(_ requests: JSONRPCrequestBatch) async throws -> JSONRPCresponseBatch {
 //        return try await Web3HttpProvider.post(requests, providerURL: self.url, session: self.session)