feature/ethereum-service

Package.swift

@@ -1,6 +1,5 @@
 // swift-tools-version:5.0
 // The swift-tools-version declares the minimum version of Swift required to build this package.
-
 import PackageDescription
 
 let package = Package(

Sources/Relayer/main.swift

@@ -1,6 +1,6 @@
 import Foundation
-import UB
 import RelayerFramework
+import UB
 
 let handler = Handler()
 
@@ -9,5 +9,18 @@ node.delegate = handler
 node.add(transport: CoreBluetoothTransport())
 
 // @todo handle CLI input, repl
+let service = EthereumService(url: URL(string: "https://rinkeby.infura.io/f7a08ae0242843f1b1cf480454a6bba5")!)
+
+
+//Get Balance
+let msg = Message(
+    proto: UBID(repeating: 1, count: 1),
+    recipient: Addr(repeating: 1, count: 1),
+    from: Addr(repeating: 1, count: 1),
+    origin: UBID(repeating: 1, count: 1),
+    message: "000F64928EcA02147075c7614A7d67B0C3Cb37D5DA".hexDecodedData()
+)
+
+service.handle(message: msg, node: node)
 
 RunLoop.current.run()

Sources/RelayerFramework/Extensions/Data+HexEncodedString.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+extension Data {
+    /// A hexadecimal string representation of the bytes.
+    func hexEncodedString() -> String {
+        let hexDigits = Array("0123456789abcdef".utf16)
+        var hexChars = [UTF16.CodeUnit]()
+        hexChars.reserveCapacity(count * 2)
+
+        for byte in self {
+            let (index1, index2) = Int(byte).quotientAndRemainder(dividingBy: 16)
+            hexChars.append(hexDigits[index1])
+            hexChars.append(hexDigits[index2])
+        }
+
+        return String(utf16CodeUnits: hexChars, count: hexChars.count)
+    }
+}

Sources/RelayerFramework/Extensions/String+HexDecodedData.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+extension String {
+    /// A data representation of the hexadecimal bytes in this string.
+    func hexDecodedData() -> Data {
+        // Get the UTF8 characters of this string
+        let chars = Array(utf8)
+
+        // Keep the bytes in an UInt8 array and later convert it to Data
+        var bytes = [UInt8]()
+        bytes.reserveCapacity(count / 2)
+
+        // It is a lot faster to use a lookup map instead of strtoul
+        let map: [UInt8] = [
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, // 01234567
+            0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 89:;<=>?
+            0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, // @ABCDEFG
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // HIJKLMNO
+        ]
+
+        // Grab two characters at a time, map them and turn it into a byte
+        for i in stride(from: 0, to: count, by: 2) {
+            let index1 = Int(chars[i] & 0x1F ^ 0x10)
+            let index2 = Int(chars[i + 1] & 0x1F ^ 0x10)
+            bytes.append(map[index1] << 4 | map[index2])
+        }
+
+        return Data(bytes)
+    }
+}

Sources/RelayerFramework/Handler.swift

@@ -7,18 +7,18 @@ public class Handler: UB.NodeDelegate {
     fileprivate var services = [UB.UBID: Service]()
 
     /// Initializes a new Handler.
-    public init() { }
+    public init() {}
 
     // @todo there probably should be more stuff here at one point.
 
     /// :nodoc:
-    public func node(_: Node, didReceiveMessage message: Message) {
+    public func node(_ node: Node, didReceiveMessage message: Message) {
         // @todo check if the message was just sent to us
         if message.proto.count == 0 {
             return
         }
 
         guard let service = services[message.proto] else { return }
-        service.handle(message: message)
+        service.handle(message: message, node: node)
     }
 }

Sources/RelayerFramework/Services/EthereumService.swift

@@ -0,0 +1,152 @@
+import Foundation
+import UB
+
+public class EthereumService: Service {
+    let url: URL
+
+    /// Initializes an Ethereum Service with a RPC HTTP url
+    public init(url: URL) {
+        self.url = url
+    }
+
+    // handle gets called when an Ethereum service is called.
+    public func handle(message: Message, node: Node) {
+        // The first btye of the message is the JSONRPC method
+        let methodID = message.message[0]
+
+        switch methodID {
+        case 0:
+            let address = "0x" + message.message[1 ..< message.message.count].hexEncodedString()
+            getBalance(address: address) { result in
+                switch result {
+                case let .success(balance):
+                    let messageResponse = Message(
+                        proto: UBID(repeating: 1, count: 1),
+                        recipient: message.origin,
+                        from: message.recipient,
+                        origin: message.recipient,
+                        message: balance
+                    )
+                    node.send(messageResponse)
+                case let .failure(error):
+                    print(error)
+                }
+            }
+        case 1:
+            let address = "0x" + message.message[1 ..< message.message.count].hexEncodedString()
+            getTransactionCount(address: address) { result in
+                switch result {
+                case let .success(nonce):
+                    let messageResponse = Message(
+                        proto: UBID(repeating: 1, count: 1),
+                        recipient: message.origin,
+                        from: message.recipient,
+                        origin: message.recipient,
+                        message: nonce
+                    )
+                    node.send(messageResponse)
+                case let .failure(error):
+                    print(error)
+                }
+            }
+        case 2:
+            let signedTransaction = "0x" + message.message[1 ..< message.message.count].hexEncodedString()
+            sendRawTransaction(signedTransaction: signedTransaction) { result in
+                switch result {
+                case let .success(balance):
+                    let messageResponse = Message(
+                        proto: UBID(repeating: 1, count: 1),
+                        recipient: message.origin,
+                        from: message.recipient,
+                        origin: message.recipient,
+                        message: balance
+                    )
+                    node.send(messageResponse)
+                case let .failure(error):
+                    print(error)
+                }
+            }
+            return
+        default:
+            print("default")
+            return
+        }
+    }
+
+    internal func httpRequest(request: URLRequest, completion: @escaping (Result<Data, Error>) -> Void) {
+        _ = URLSession.shared.dataTask(with: request) { data, _, error in
+            guard let data = data, error == nil else {
+                print(error?.localizedDescription ?? "No data")
+                completion(.failure(error!))
+                return
+            }
+            completion(.success(data))
+        }.resume()
+    }
+
+    internal func getBalance(address: String, completion: @escaping (Result<Data, Error>) -> Void) {
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        let payload: [String: Any] = [
+            "jsonrpc": "2.0",
+            "method": "eth_getBalance",
+            "params": [address, "latest"],
+            "id": 1
+        ]
+        let jsonPayload = try! JSONSerialization.data(withJSONObject: payload)
+        request.httpBody = jsonPayload
+
+        httpRequest(request: request) { result in
+            switch result {
+            case let .success(balance):
+                completion(.success(balance))
+            case let .failure(error):
+                completion(.failure(error))
+            }
+        }
+    }
+
+    internal func getTransactionCount(address: String, completion: @escaping (Result<Data, Error>) -> Void) {
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        let payload: [String: Any] = [
+            "jsonrpc": "2.0",
+            "method": "eth_getTransactionCount",
+            "params": [address, "latest"],
+            "id": 1
+        ]
+        let jsonPayload = try! JSONSerialization.data(withJSONObject: payload)
+        request.httpBody = jsonPayload
+
+        httpRequest(request: request) { result in
+            switch result {
+            case let .success(nonce):
+                completion(.success(nonce))
+            case let .failure(error):
+                completion(.failure(error))
+            }
+        }
+    }
+
+    internal func sendRawTransaction(signedTransaction: String, completion: @escaping (Result<Data, Error>) -> Void) {
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        let payload: [String: Any] = [
+            "jsonrpc": "2.0",
+            "method": "eth_sendRawTransaction",
+            "params": [signedTransaction],
+            "id": 1
+        ]
+        let jsonPayload = try! JSONSerialization.data(withJSONObject: payload)
+        request.httpBody = jsonPayload
+
+        httpRequest(request: request) { result in
+            switch result {
+            case let .success(txHash):
+                completion(.success(txHash))
+            case let .failure(error):
+                completion(.failure(error))
+            }
+        }
+    }
+}

Sources/RelayerFramework/Services/Service.swift

@@ -7,5 +7,5 @@ public protocol Service: AnyObject {
     ///
     /// - Parameters:
     ///     - message: The received message to handle.
-    func handle(message: UB.Message)
+    func handle(message: UB.Message, node: UB.Node)
 }

Tests/LinuxMain.swift

@@ -1,6 +1,5 @@
 import XCTest
 
-
 var tests = [XCTestCaseEntry]()
 
 XCTMain(tests)

Tests/RelayerFrameworkTests/RelayerFrameworkTests.swift

@@ -0,0 +1,27 @@
+@testable import RelayerFramework
+import XCTest
+
+final class RelayerFrameworkTests: XCTestCase {
+    func testGetBalance() {
+        let didFinish = self.expectation(description: #function)
+        let url: URL = URL(string: "https://rinkeby.infura.io/f7a08ae0242843f1b1cf480454a6bba5")!
+        let ethService = EthereumService(url: url)
+        var bal = ""
+        ethService.getBalance(address: "0x0F64928EcA02147075c7614A7d67B0C3Cb37D5DA") { result in
+            switch result {
+            case let .success(balance):
+                bal = String(data: balance, encoding: .utf8)!
+                didFinish.fulfill()
+            case let .failure(error):
+                print(error)
+            }
+        }
+
+        wait(for: [didFinish], timeout: 5)
+        XCTAssertEqual(bal, "{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":\"0x1a55734bf06dc800\"}")
+    }
+
+    static var allTests = [
+        ("testGetBalance", testGetBalance),
+    ]
+}

Tests/RelayerFrameworkTests/stubs/Transport.swift

@@ -0,0 +1,8 @@
+//
+//  Transport.swift
+//  Relayer
+//
+//  Created by Eric Tu on 9/25/19.
+//
+
+import Foundation

Tests/RelayerFrameworkTests/RelayerTests.swift → Tests/RelayerTests/RelayerTests.swift

@@ -1,7 +1,13 @@
 import class Foundation.Bundle
+import Relayer
 import XCTest
 
 final class RelayerTests: XCTestCase {
+    func testGetBalance() {
+        let url: URL = URL(string: "https://rinkeby.infura.io/f7a08ae0242843f1b1cf480454a6bba5")!
+        let ethService = Relayer.EthereumService(url: url)
+    }
+
 //    func testExample() throws {
 //        // This is an example of a functional test case.
 //        // Use XCTAssert and related functions to verify your tests produce the correct