[Network] Refactor: #355 Relay client RPC

Package.swift

@@ -47,7 +47,7 @@ let package = Package(
             dependencies: ["WalletConnectUtils"]),
         .target(
             name: "WalletConnectUtils",
-            dependencies: ["Commons"]),
+            dependencies: ["Commons", "JSONRPC"]),
         .target(
             name: "JSONRPC",
             dependencies: ["Commons"]),
@@ -71,11 +71,11 @@ let package = Package(
             dependencies: ["WalletConnectKMS", "WalletConnectUtils", "TestingUtils"]),
         .target(
             name: "TestingUtils",
-            dependencies: ["WalletConnectUtils", "WalletConnectKMS"],
+            dependencies: ["WalletConnectUtils", "WalletConnectKMS", "JSONRPC"],
             path: "Tests/TestingUtils"),
         .testTarget(
             name: "WalletConnectUtilsTests",
-            dependencies: ["WalletConnectUtils"]),
+            dependencies: ["WalletConnectUtils", "TestingUtils"]),
         .testTarget(
             name: "JSONRPCTests",
             dependencies: ["JSONRPC", "TestingUtils"]),

Sources/Commons/Either.swift

@@ -63,3 +63,15 @@ extension Either: Codable where L: Codable, R: Codable {
         }
     }
 }
+
+extension Either: CustomStringConvertible {
+
+    public var description: String {
+        switch self {
+        case let .left(left):
+            return "\(left)"
+        case let .right(right):
+            return "\(right)"
+        }
+    }
+}

Sources/JSONRPC/RPCRequest.swift

@@ -72,11 +72,11 @@ public struct RPCRequest: Equatable {
 
 extension RPCRequest {
 
-    static func notification<C>(method: String, params: C) -> RPCRequest where C: Codable {
+    public static func notification<C>(method: String, params: C) -> RPCRequest where C: Codable {
         return RPCRequest(method: method, params: AnyCodable(params), id: nil)
     }
 
-    static func notification(method: String) -> RPCRequest {
+    public static func notification(method: String) -> RPCRequest {
         return RPCRequest(method: method, params: nil, id: nil)
     }
 

Sources/JSONRPC/RPCResponse.swift

@@ -19,14 +19,22 @@ public struct RPCResponse: Equatable {
         return nil
     }
 
-    private let outcome: Result<AnyCodable, JSONRPCError>
+    public let outcome: Result<AnyCodable, JSONRPCError>
 
     internal init(id: RPCID?, outcome: Result<AnyCodable, JSONRPCError>) {
         self.jsonrpc = "2.0"
         self.id = id
         self.outcome = outcome
     }
 
+    public init<C>(matchingRequest: RPCRequest, result: C) where C: Codable {
+        self.init(id: matchingRequest.id, outcome: .success(AnyCodable(result)))
+    }
+
+    public init(matchingRequest: RPCRequest, error: JSONRPCError) {
+        self.init(id: matchingRequest.id, outcome: .failure(error))
+    }
+
     public init<C>(id: Int, result: C) where C: Codable {
         self.init(id: RPCID(id), outcome: .success(AnyCodable(result)))
     }

Sources/WalletConnectRelay/RPC/Methods.swift

@@ -0,0 +1,65 @@
+struct Subscribe: RelayRPC {
+
+    struct Params: Codable {
+        let topic: String
+    }
+
+    let params: Params
+
+    var method: String {
+        "subscribe"
+    }
+}
+
+struct Unsubscribe: RelayRPC {
+
+    struct Params: Codable {
+        let id: String
+        let topic: String
+    }
+
+    let params: Params
+
+    var method: String {
+        "unsubscribe"
+    }
+}
+
+struct Publish: RelayRPC {
+
+    struct Params: Codable {
+        let topic: String
+        let message: String
+        let ttl: Int
+        let prompt: Bool?
+        let tag: Int?
+    }
+
+    let params: Params
+
+    var method: String {
+        "publish"
+    }
+}
+
+struct Subscription: RelayRPC {
+
+    struct Params: Codable {
+        struct Contents: Codable {
+            let topic: String
+            let message: String
+        }
+        let id: String
+        let data: Contents
+    }
+
+    let params: Params
+
+    var method: String {
+        "subscription"
+    }
+
+    init(id: String, topic: String, message: String) {
+        self.params = Params(id: id, data: Params.Contents(topic: topic, message: message))
+    }
+}

Sources/WalletConnectRelay/RPC/RPCMethod.swift

@@ -0,0 +1,5 @@
+protocol RPCMethod {
+    associatedtype Parameters
+    var method: String { get }
+    var params: Parameters { get }
+}

Sources/WalletConnectRelay/RPC/RelayRPC.swift

@@ -0,0 +1,38 @@
+import JSONRPC
+
+protocol RelayRPC: RPCMethod {}
+
+extension RelayRPC where Parameters: Codable {
+
+    var idGenerator: IdentifierGenerator {
+        return WalletConnectRPCID()
+    }
+
+    func wrapToIridium() -> PrefixDecorator<Self> {
+        return PrefixDecorator(rpcMethod: self, prefix: "iridium")
+    }
+
+    func wrapToIRN() -> PrefixDecorator<Self> {
+        return PrefixDecorator(rpcMethod: self, prefix: "irn")
+    }
+
+    func asRPCRequest() -> RPCRequest {
+        RPCRequest(method: self.method, params: self.params, idGenerator: self.idGenerator)
+    }
+}
+
+struct PrefixDecorator<T>: RelayRPC where T: RelayRPC {
+
+    typealias Parameters = T.Parameters
+
+    let rpcMethod: T
+    let prefix: String
+
+    var method: String {
+        "\(prefix)_\(rpcMethod.method)"
+    }
+
+    var params: Parameters {
+        rpcMethod.params
+    }
+}

Sources/WalletConnectRelay/RPC/WalletConnectRPCID.swift

@@ -0,0 +1,11 @@
+import Foundation
+import JSONRPC
+
+struct WalletConnectRPCID: IdentifierGenerator {
+
+    func next() -> RPCID {
+        let timestamp = Int64(Date().timeIntervalSince1970 * 1000) * 1000
+        let random = Int64.random(in: 0..<1000)
+        return .right(Int(timestamp + random))
+    }
+}