New WebsocketProvider and Subscriptions implementation

Sources/web3swift/HookedFunctions/Web3+BrowserFunctions.swift

@@ -37,7 +37,7 @@ extension web3.BrowserFunctions {
 
     public func sign(_ personalMessage: Data, account: String, password: String = "web3swift") -> String? {
         do {
-            guard let keystoreManager = self.web3.provider.attachedKeystoreManager else {return nil}
+            guard let keystoreManager = self.web3.keystoreManager else {return nil}
             guard let from = EthereumAddress(account, ignoreChecksum: true) else {return nil}
             guard let signature = try Web3Signer.signPersonalMessage(personalMessage, keystore: keystoreManager, account: from, password: password) else {return nil}
             return signature.toHexString().addHexPrefix()
@@ -164,7 +164,7 @@ extension web3.BrowserFunctions {
         do {
             var transaction = trans
             guard let from = transactionOptions.from else {return nil}
-            guard let keystoreManager = self.web3.provider.attachedKeystoreManager else {return nil}
+            guard let keystoreManager = self.web3.keystoreManager else {return nil}
             guard let gasPricePolicy = transactionOptions.gasPrice else {return nil}
             guard let gasLimitPolicy = transactionOptions.gasLimit else {return nil}
             guard let noncePolicy = transactionOptions.nonce else {return nil}

Sources/web3swift/HookedFunctions/Web3+Wallet.swift

@@ -11,7 +11,7 @@ import BigInt
 extension web3.Web3Wallet {
 
     public func getAccounts() throws -> [EthereumAddress] {
-        guard let keystoreManager = self.web3.provider.attachedKeystoreManager else {
+        guard let keystoreManager = self.web3.keystoreManager else {
             throw Web3Error.walletError
         }
         guard let ethAddresses = keystoreManager.addresses else {
@@ -30,7 +30,7 @@ extension web3.Web3Wallet {
 
     public func signTX(transaction:inout EthereumTransaction, account: EthereumAddress, password: String = "web3swift") throws -> Bool {
         do {
-            guard let keystoreManager = self.web3.provider.attachedKeystoreManager else {
+            guard let keystoreManager = self.web3.keystoreManager else {
                 throw Web3Error.walletError
             }
             try Web3Signer.signTX(transaction: &transaction, keystore: keystoreManager, account: account, password: password)
@@ -53,7 +53,7 @@ extension web3.Web3Wallet {
 
     public func signPersonalMessage(_ personalMessage: Data, account: EthereumAddress, password: String = "web3swift") throws -> Data {
         do {
-            guard let keystoreManager = self.web3.provider.attachedKeystoreManager else
+            guard let keystoreManager = self.web3.keystoreManager else
             {
                 throw Web3Error.walletError
             }

Sources/web3swift/Promises/Promise+HttpProvider.swift

@@ -98,11 +98,21 @@ extension Web3HttpProvider {
         if request.method == nil {
             return Promise(error: Web3Error.nodeError(desc: "RPC method is nill"))
         }
-
+        guard ![.subscribe, .unsubscribe].contains(request.method!) else {
+            return Promise(error: Web3Error.inputError(desc: "Unsupported method \(request.method!)"))
+        }
         return Web3HttpProvider.post(request, providerURL: self.url, queue: queue, session: self.session)
     }
 
     public func sendAsync(_ requests: JSONRPCrequestBatch, queue: DispatchQueue = .main) -> Promise<JSONRPCresponseBatch> {
+        guard requests.requests.allSatisfy({
+            guard let method = $0.method else {
+                return true
+            }
+            return ![.subscribe, .unsubscribe].contains(method)
+        }) else {
+            return Promise(error: Web3Error.inputError(desc: "Unsupported method in requests"))
+        }
         return Web3HttpProvider.post(requests, providerURL: self.url, queue: queue, session: self.session)
     }
 }

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

@@ -0,0 +1,72 @@
+//
+//  Promise+Web3+Eth+Filters.swift
+//  
+//
+//  Created by Ostap Danylovych on 06.01.2022.
+//
+
+import Foundation
+import PromiseKit
+import BigInt
+
+public enum BlockNumber {
+    case pending
+    case latest
+    case earliest
+    case exact(BigUInt)
+
+    public var stringValue: String {
+        switch self {
+        case .pending:
+            return "pending"
+        case .latest:
+            return "latest"
+        case .earliest:
+            return "earliest"
+        case .exact(let number):
+            return String(number, radix: 16).addHexPrefix()
+        }
+    }
+}
+
+extension web3.Eth {
+    private func _dispatchRequest<T>(_ request: JSONRPCrequest) -> Promise<T> {
+        web3.dispatch(request).map(on: web3.requestDispatcher.queue) { response in
+            guard let value: T = 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 newFilterPromise(addresses: [EthereumAddress],
+                                 fromBlock: BlockNumber? = .latest,
+                                 toBlock: BlockNumber? = .latest,
+                                 topics: [String]) -> Promise<String> {
+        let addresses = addresses.map { $0.address.lowercased() }
+        return _dispatchRequest(JSONRPCRequestFabric.prepareRequest(.newFilter, parameters: [addresses, fromBlock?.stringValue, toBlock?.stringValue, topics]))
+    }
+
+    public func newBlockFilterPromise() -> Promise<String> {
+        return _dispatchRequest(JSONRPCRequestFabric.prepareRequest(.newBlockFilter, parameters: []))
+    }
+
+    public func newPendingTransactionFilterPromise() -> Promise<String> {
+        return _dispatchRequest(JSONRPCRequestFabric.prepareRequest(.newPendingTransactionFilter, parameters: []))
+    }
+
+    public func uninstallFilterPromise(filterID: String) -> Promise<Bool> {
+        return _dispatchRequest(JSONRPCRequestFabric.prepareRequest(.uninstallFilter, parameters: [filterID]))
+    }
+
+    public func getFilterChangesPromise(filterID: String) -> Promise<FilterChanges> {
+        return _dispatchRequest(JSONRPCRequestFabric.prepareRequest(.getFilterChanges, parameters: [filterID]))
+    }
+
+    public func getFilterLogsPromise(filterID: String) -> Promise<FilterChanges> {
+        return _dispatchRequest(JSONRPCRequestFabric.prepareRequest(.getFilterLogs, parameters: [filterID]))
+    }
+}

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

@@ -12,7 +12,7 @@ import PromiseKit
 extension web3.Eth {
     public func getAccountsPromise() -> Promise<[EthereumAddress]> {
         let queue = web3.requestDispatcher.queue
-        if (self.web3.provider.attachedKeystoreManager != nil) {
+        if (self.web3.keystoreManager != nil) {
             let promise = Promise<[EthereumAddress]>.pending()
             queue.async {
                 do {

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

@@ -38,7 +38,7 @@ extension web3.Eth {
             assembledTransaction = forAssemblyPipeline.0
             mergedOptions = forAssemblyPipeline.1
 
-            if self.web3.provider.attachedKeystoreManager == nil {
+            if self.web3.keystoreManager == nil {
                 guard let request = EthereumTransaction.createRequest(method: .sendTransaction, transaction: assembledTransaction, transactionOptions: mergedOptions) else
                 {
                     throw Web3Error.processingError(desc: "Failed to create a request to send transaction")
@@ -63,7 +63,7 @@ extension web3.Eth {
                 throw Web3Error.inputError(desc: "No 'from' field provided")
             }
             do {
-                try Web3Signer.signTX(transaction: &assembledTransaction, keystore: self.web3.provider.attachedKeystoreManager!, account: from, password: password)
+                try Web3Signer.signTX(transaction: &assembledTransaction, keystore: self.web3.keystoreManager!, account: from, password: password)
             } catch {
                 throw Web3Error.inputError(desc: "Failed to locally sign a transaction")
             }

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

@@ -13,7 +13,7 @@ extension web3.Personal {
     public func createAccountPromise(password:String = "web3swift") -> Promise<EthereumAddress> {
         let queue = web3.requestDispatcher.queue
         do {
-            if self.web3.provider.attachedKeystoreManager == nil {
+            if self.web3.keystoreManager == nil {
                 let request = JSONRPCRequestFabric.prepareRequest(.createAccount, parameters: [password])
                 return self.web3.dispatch(request).map(on: queue) {response in
                     guard let value: EthereumAddress = response.getValue() else {

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

@@ -14,7 +14,7 @@ extension web3.Personal {
     public func signPersonalMessagePromise(message: Data, from: EthereumAddress, password:String = "web3swift") -> Promise<Data> {
         let queue = web3.requestDispatcher.queue
         do {
-            if self.web3.provider.attachedKeystoreManager == nil {
+            if self.web3.keystoreManager == nil {
                 let hexData = message.toHexString().addHexPrefix()
                 let request = JSONRPCRequestFabric.prepareRequest(.personalSign, parameters: [from.address.lowercased(), hexData])
                 return self.web3.dispatch(request).map(on: queue) {response in
@@ -27,7 +27,7 @@ extension web3.Personal {
                     return value
                 }
             }
-            guard let signature = try Web3Signer.signPersonalMessage(message, keystore: self.web3.provider.attachedKeystoreManager!, account: from, password: password) else { throw Web3Error.inputError(desc: "Failed to locally sign a message") }
+            guard let signature = try Web3Signer.signPersonalMessage(message, keystore: self.web3.keystoreManager!, account: from, password: password) else { throw Web3Error.inputError(desc: "Failed to locally sign a message") }
             let returnPromise = Promise<Data>.pending()
             queue.async {
                 returnPromise.resolver.fulfill(signature)

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

@@ -19,7 +19,7 @@ extension web3.Personal {
     public func unlockAccountPromise(account: String, password:String = "web3swift", seconds: UInt64 = 300) -> Promise<Bool> {
         let queue = web3.requestDispatcher.queue
         do {
-            if self.web3.provider.attachedKeystoreManager == nil {
+            if self.web3.keystoreManager == nil {
                 let request = JSONRPCRequestFabric.prepareRequest(.unlockAccount, parameters: [account.lowercased(), password, seconds])
                 return self.web3.dispatch(request).map(on: queue) {response in
                     guard let value: Bool = response.getValue() else {

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

@@ -29,7 +29,7 @@ extension web3.TxPool {
         let rp = web3.dispatch(request)
         let queue = web3.requestDispatcher.queue
         return rp.map(on: queue ) { response in
-            guard let value: TxPoolStatus = response.result as? TxPoolStatus else {
+            guard let value: TxPoolStatus = response.getValue() else {
                 if response.error != nil {
                     throw Web3Error.nodeError(desc: response.error!.message)
                 }

Sources/web3swift/Web3/Web3+Eth+Websocket.swift

@@ -10,33 +10,39 @@ import BigInt
 import PromiseKit
 import Starscream
 
+public struct SubscribeOnLogsParams: Encodable {
+    public let address: [String]?
+    public let topics: [String]?
+}
 
 extension web3.Eth {
-
-    public func getWebsocketProvider(forDelegate delegate: Web3SocketDelegate) throws -> InfuraWebsocketProvider {
-        var infuraWSProvider: InfuraWebsocketProvider
-        if !(provider is InfuraWebsocketProvider) {
-            guard let infuraNetwork = provider.network else {
-                throw Web3Error.processingError(desc: "Wrong network")
-            }
-            guard let infuraProvider = InfuraWebsocketProvider(infuraNetwork, delegate: delegate, keystoreManager: provider.attachedKeystoreManager) else {
-                throw Web3Error.processingError(desc: "Wrong network")
-            }
-            infuraWSProvider = infuraProvider
-        } else {
-            infuraWSProvider = provider as! InfuraWebsocketProvider
+    private func _subscribe<R>(filter: SubscribeEventFilter,
+                              listener: @escaping Web3SubscriptionListener<R>) throws -> Subscription {
+        guard let provider = provider as? Web3SubscriptionProvider else {
+            throw Web3Error.processingError(desc: "Provider is not subscribable")
         }
-        infuraWSProvider.connectSocket()
-        return infuraWSProvider
+        return provider.subscribe(filter: filter, queue: web3.requestDispatcher.queue, listener: listener)
+    }
+
+    public func subscribeOnNewHeads(listener: @escaping Web3SubscriptionListener<BlockHeader>) throws -> Subscription {
+        try _subscribe(filter: .newHeads, listener: listener)
     }
 
-    public func getLatestPendingTransactions(forDelegate delegate: Web3SocketDelegate) throws {
-        let provider = try getWebsocketProvider(forDelegate: delegate)
-        try provider.setFilterAndGetChanges(method: .newPendingTransactionFilter)
+    public func subscribeOnLogs(addresses: [EthereumAddress]? = nil,
+                                topics: [String]? = nil,
+                                listener: @escaping Web3SubscriptionListener<EventLog>) throws -> Subscription {
+        let params = SubscribeOnLogsParams(address: addresses?.map { $0.address }, topics: topics)
+        return try _subscribe(filter: .logs(params: params), listener: listener)
     }
 
-    public func subscribeOnPendingTransactions(forDelegate delegate: Web3SocketDelegate) throws {
-        let provider = try getWebsocketProvider(forDelegate: delegate)
-        try provider.subscribeOnNewPendingTransactions()
+    public func subscribeOnNewPendingTransactions(listener: @escaping Web3SubscriptionListener<String>) throws -> Subscription {
+        try _subscribe(filter: .newPendingTransactions, listener: listener)
+    }
+
+    public func subscribeOnSyncing(listener: @escaping Web3SubscriptionListener<SyncingInfo>) throws -> Subscription {
+        guard provider.network != Networks.Kovan else {
+            throw Web3Error.inputError(desc: "Can't sync on Kovan")
+        }
+        return try _subscribe(filter: .syncing, listener: listener)
     }
 }

Sources/web3swift/Web3/Web3+HttpProvider.swift

@@ -13,23 +13,20 @@ public protocol Web3Provider {
     func sendAsync(_ request: JSONRPCrequest, queue: DispatchQueue) -> Promise<JSONRPCresponse>
     func sendAsync(_ requests: JSONRPCrequestBatch, queue: DispatchQueue) -> Promise<JSONRPCresponseBatch>
     var network: Networks? {get set}
-    var attachedKeystoreManager: KeystoreManager? {get set}
     var url: URL {get}
-    var session: URLSession {get}
 }
 
 
 /// The default http provider.
 public class Web3HttpProvider: Web3Provider {
     public var url: URL
     public var network: Networks?
-    public var attachedKeystoreManager: KeystoreManager? = nil
     public var session: URLSession = {() -> URLSession in
         let config = URLSessionConfiguration.default
         let urlSession = URLSession(configuration: config)
         return urlSession
     }()
-    public init?(_ httpProviderURL: URL, network net: Networks? = nil, keystoreManager manager: KeystoreManager? = nil) {
+    public init?(_ httpProviderURL: URL, network net: Networks? = nil) {
         do {
             guard httpProviderURL.scheme == "http" || httpProviderURL.scheme == "https" else {return nil}
             url = httpProviderURL
@@ -51,7 +48,6 @@ public class Web3HttpProvider: Web3Provider {
         } catch {
             return nil
         }
-        attachedKeystoreManager = manager
     }
 }