diff --git a/Sources/web3swift/Browser/BrowserViewController.swift b/Sources/web3swift/Browser/BrowserViewController.swift index 90ea08d13..31cb42dbf 100644 --- a/Sources/web3swift/Browser/BrowserViewController.swift +++ b/Sources/web3swift/Browser/BrowserViewController.swift @@ -35,12 +35,18 @@ open class BrowserViewController: UIViewController { return webView }() + private var bundle: Bundle { + Bundle(for: BrowserViewController.self) + } + lazy var config: WKWebViewConfiguration = { let config = WKWebViewConfiguration() - + var js = "" - - if let filepath = Bundle.main.path(forResource: "browser.min", ofType: "js") { + + let bundleURL = bundle.bundleURL.appendingPathComponent("Browser.bundle") + if let scripteBundle = Bundle(url: bundleURL), + let filepath = scripteBundle.path(forResource: "browser.min", ofType: "js") { do { js += try String(contentsOfFile: filepath) NSLog("Loaded browser.js") diff --git a/Sources/web3swift/Promises/Promise+HttpProvider.swift b/Sources/web3swift/Promises/Promise+HttpProvider.swift index 94b1b5a50..6a8451034 100755 --- a/Sources/web3swift/Promises/Promise+HttpProvider.swift +++ b/Sources/web3swift/Promises/Promise+HttpProvider.swift @@ -9,6 +9,39 @@ import PromiseKit extension Web3HttpProvider { + public static func postRaw(_ request: JSONRPCEncodablerequest, providerURL: URL, queue: DispatchQueue = .main, session: URLSession) -> Promise { + let rp = Promise.pending() + var task: URLSessionTask? = nil + queue.async { + do { + let encoder = JSONEncoder() + let requestData = try encoder.encode(request) + var urlRequest = URLRequest(url: providerURL, cachePolicy: URLRequest.CachePolicy.reloadIgnoringCacheData) + urlRequest.httpMethod = "POST" + urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type") + urlRequest.setValue("application/json", forHTTPHeaderField: "Accept") + urlRequest.httpBody = requestData + task = session.dataTask(with: urlRequest){ (data, response, error) in + guard error == nil else { + rp.resolver.reject(error!) + return + } + guard data != nil else { + rp.resolver.reject(Web3Error.nodeError(desc: "Node response is empty")) + return + } + rp.resolver.fulfill(data!) + } + task?.resume() + } catch { + rp.resolver.reject(error) + } + } + return rp.promise.ensure(on: queue) { + task = nil + } + } + static func post(_ request: JSONRPCrequest, providerURL: URL, queue: DispatchQueue = .main, session: URLSession) -> Promise { let rp = Promise.pending() var task: URLSessionTask? = nil diff --git a/Sources/web3swift/Promises/Promise+Web3+Eth+SendRawTransaction.swift b/Sources/web3swift/Promises/Promise+Web3+Eth+SendRawTransaction.swift index 7aa3b83a6..382d6c3b2 100755 --- a/Sources/web3swift/Promises/Promise+Web3+Eth+SendRawTransaction.swift +++ b/Sources/web3swift/Promises/Promise+Web3+Eth+SendRawTransaction.swift @@ -17,28 +17,51 @@ extension web3.Eth { return sendRawTransactionPromise(deserializedTX) } - public func sendRawTransactionPromise(_ transaction: EthereumTransaction) -> Promise{ + public func sendRawTransactionPromise(_ transaction: EthereumTransaction ,_ transactionEncodeData: Data? = nil) -> Promise{ // print(transaction) let queue = web3.requestDispatcher.queue do { - guard let request = EthereumTransaction.createRawTransaction(transaction: transaction) else { - throw Web3Error.processingError(desc: "Transaction is invalid") - } - let rp = web3.dispatch(request) - return rp.map(on: queue ) { response in - guard let value: String = response.getValue() else { - if response.error != nil { - throw Web3Error.nodeError(desc: response.error!.message) + + if transactionEncodeData != nil { + guard let request = EthereumTransaction.createRawTransaction(transaction: transaction , transactionEncodeData: transactionEncodeData) else { + throw Web3Error.processingError(desc: "Transaction is invalid") + } + let rp = web3.dispatch(request) + return rp.map(on: queue ) { response in + 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") + } + let result = TransactionSendingResult(transaction: transaction, hash: value) + for hook in self.web3.postSubmissionHooks { + hook.queue.async { + hook.function(result) + } } - throw Web3Error.nodeError(desc: "Invalid value from Ethereum node") + return result } - let result = TransactionSendingResult(transaction: transaction, hash: value) - for hook in self.web3.postSubmissionHooks { - hook.queue.async { - hook.function(result) + } else { + guard let request = EthereumTransaction.createRawTransaction(transaction: transaction) else { + throw Web3Error.processingError(desc: "Transaction is invalid") + } + let rp = web3.dispatch(request) + return rp.map(on: queue ) { response in + 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") + } + let result = TransactionSendingResult(transaction: transaction, hash: value) + for hook in self.web3.postSubmissionHooks { + hook.queue.async { + hook.function(result) + } } + return result } - return result } } catch { let returnPromise = Promise.pending() diff --git a/Sources/web3swift/Transaction/EthereumTransaction.swift b/Sources/web3swift/Transaction/EthereumTransaction.swift index d799d3ab7..684d6bb36 100755 --- a/Sources/web3swift/Transaction/EthereumTransaction.swift +++ b/Sources/web3swift/Transaction/EthereumTransaction.swift @@ -70,7 +70,6 @@ public struct EthereumTransaction: CustomStringConvertible { self.to = to } - public init (nonce: BigUInt, gasPrice: BigUInt, gasLimit: BigUInt, to: EthereumAddress, value: BigUInt, data: Data, v: BigUInt, r: BigUInt, s: BigUInt) { self.nonce = nonce self.gasPrice = gasPrice @@ -177,8 +176,8 @@ public struct EthereumTransaction: CustomStringConvertible { return RLP.encode(fields) } } else { - let fields = [self.nonce, self.gasPrice, self.gasLimit, self.to.addressData, self.value!, self.data, self.v, self.r, self.s] as [AnyObject] - return RLP.encode(fields) + let fields = [self.nonce, self.gasPrice, self.gasLimit, self.to.addressData, self.value!, self.data, self.v, self.r, self.s] as [AnyObject] + return RLP.encode(fields) } } @@ -276,17 +275,28 @@ public struct EthereumTransaction: CustomStringConvertible { return request } - static func createRawTransaction(transaction: EthereumTransaction) -> JSONRPCrequest? { - guard transaction.sender != nil else {return nil} - guard let encodedData = transaction.encode() else {return nil} - let hex = encodedData.toHexString().addHexPrefix().lowercased() - var request = JSONRPCrequest() - request.method = JSONRPCmethod.sendRawTransaction - let params = [hex] as Array - let pars = JSONRPCparams(params: params) - request.params = pars - if !request.isValid {return nil} - return request + static func createRawTransaction(transaction: EthereumTransaction, transactionEncodeData: Data? = nil) -> JSONRPCrequest? { + if transactionEncodeData != nil { + let hex = transactionEncodeData!.toHexString().addHexPrefix().lowercased() + var request = JSONRPCrequest() + request.method = JSONRPCmethod.sendRawTransaction + let params = [hex] as Array + let pars = JSONRPCparams(params: params) + request.params = pars + if !request.isValid {return nil} + return request + } else { + guard transaction.sender != nil else {return nil} + guard let encodedData = transaction.encode() else {return nil} + let hex = encodedData.toHexString().addHexPrefix().lowercased() + var request = JSONRPCrequest() + request.method = JSONRPCmethod.sendRawTransaction + let params = [hex] as Array + let pars = JSONRPCparams(params: params) + request.params = pars + if !request.isValid {return nil} + return request + } } } diff --git a/Sources/web3swift/Utils/ENS/ENS.swift b/Sources/web3swift/Utils/ENS/ENS.swift index ec8af0c23..c97200229 100755 --- a/Sources/web3swift/Utils/ENS/ENS.swift +++ b/Sources/web3swift/Utils/ENS/ENS.swift @@ -118,12 +118,12 @@ public class ENS { guard let resolver = try? self.registry.getResolver(forDomain: node) else { throw Web3Error.processingError(desc: "Failed to get resolver for domain") } - guard let isNameSupports = try? resolver.supportsInterface(interfaceID: Resolver.InterfaceName.name.hash()) else { - throw Web3Error.processingError(desc: "Resolver don't support interface with this ID") - } - guard isNameSupports else { - throw Web3Error.processingError(desc: "Name isn't supported") - } +// guard let isNameSupports = try? resolver.supportsInterface(interfaceID: Resolver.InterfaceName.name.hash()) else { +// throw Web3Error.processingError(desc: "Resolver don't support interface with this ID") +// } +// guard isNameSupports else { +// throw Web3Error.processingError(desc: "Name isn't supported") +// } guard let name = try? resolver.getCanonicalName(forNode: node) else { throw Web3Error.processingError(desc: "Can't get name") } diff --git a/Sources/web3swift/Web3/Web3+Eth.swift b/Sources/web3swift/Web3/Web3+Eth.swift index 134791c1d..f151ebdc8 100755 --- a/Sources/web3swift/Web3/Web3+Eth.swift +++ b/Sources/web3swift/Web3/Web3+Eth.swift @@ -55,8 +55,8 @@ extension web3.Eth { /// This function is synchronous! /// /// Returns the Result object that indicates either success of failure. - public func sendRawTransaction(_ transaction: EthereumTransaction) throws -> TransactionSendingResult { - let result = try self.sendRawTransactionPromise(transaction).wait() + public func sendRawTransaction(_ transaction: EthereumTransaction, _ transactionEncodeData: Data? = nil) throws -> TransactionSendingResult { + let result = try self.sendRawTransactionPromise(transaction,transactionEncodeData).wait() return result } diff --git a/Sources/web3swift/Web3/Web3+JSONRPC.swift b/Sources/web3swift/Web3/Web3+JSONRPC.swift index 283ecbaf6..d1cf2f6df 100755 --- a/Sources/web3swift/Web3/Web3+JSONRPC.swift +++ b/Sources/web3swift/Web3/Web3+JSONRPC.swift @@ -8,6 +8,18 @@ import Foundation import BigInt //import EthereumAddress +public struct JSONRPCEncodablerequest: Encodable { + public var jsonrpc: String = "2.0" + public var method: JSONRPCmethod? + public var params: T? + public var id: UInt64 = Counter.increment() + + public init(method: JSONRPCmethod, params: T?) { + self.method = method + self.params = params + } +} + /// Global counter object to enumerate JSON RPC requests. public struct Counter { public static var counter = UInt64(1)