Merge pull request #397 from WalletConnect/#377-auth-respond-service

[Auth] #395 Auth Request Subscriber

Sources/Auth/Services/Common/NetworkingInteractor.swift

@@ -1,10 +1,12 @@
 import Foundation
 import WalletConnectRelay
 import WalletConnectUtils
+import Combine
 import WalletConnectKMS
 import JSONRPC
 
 protocol NetworkInteracting {
+    var requestPublisher: AnyPublisher<RequestSubscriptionPayload, Never> {get}
     func subscribe(topic: String) async throws
     func request(_ request: RPCRequest, topic: String, envelopeType: Envelope.EnvelopeType) async throws
 }
@@ -20,6 +22,10 @@ class NetworkingInteractor: NetworkInteracting {
     private let relayClient: RelayClient
     private let serializer: Serializing
     private let rpcHistory: RPCHistory
+    var requestPublisher: AnyPublisher<RequestSubscriptionPayload, Never> {
+        requestPublisherSubject.eraseToAnyPublisher()
+    }
+    private let requestPublisherSubject = PassthroughSubject<RequestSubscriptionPayload, Never>()
 
     init(relayClient: RelayClient,
          serializer: Serializing,

Sources/Auth/Services/Common/SIWEMessageFormatter.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+protocol SIWEMessageFormatting {
+    func formatMessage(from request: AuthRequestParams) throws -> String
+}
+
+struct SIWEMessageFormatter: SIWEMessageFormatting {
+    func formatMessage(from request: AuthRequestParams) throws -> String {
+        fatalError("not implemented")
+    }
+}

Sources/Auth/Services/Wallet/AuthRequestSubscriber.swift

@@ -0,0 +1,38 @@
+import Combine
+import Foundation
+import WalletConnectUtils
+import JSONRPC
+
+class AuthRequestSubscriber {
+    private let networkingInteractor: NetworkInteracting
+    private let logger: ConsoleLogging
+    private var publishers = [AnyCancellable]()
+    private let messageFormatter: SIWEMessageFormatting
+    var onRequest: ((_ id: RPCID, _ message: String)->())?
+
+    init(networkingInteractor: NetworkInteracting,
+         logger: ConsoleLogging,
+         messageFormatter: SIWEMessageFormatting) {
+        self.networkingInteractor = networkingInteractor
+        self.logger = logger
+        self.messageFormatter = messageFormatter
+        subscribeForRequest()
+    }
+
+    private func subscribeForRequest() {
+        networkingInteractor.requestPublisher.sink { [unowned self] subscriptionPayload in
+            guard subscriptionPayload.request.method == "wc_authRequest" else { return }
+            guard let authRequest = try? subscriptionPayload.request.params?.get(AuthRequestParams.self) else {
+                logger.debug("Malformed auth request params")
+                return
+            }
+            do {
+                let message = try messageFormatter.formatMessage(from: authRequest)
+                guard let requestId = subscriptionPayload.request.id else { return }
+                onRequest?(requestId, message)
+            } catch {
+                logger.debug(error)
+            }
+        }.store(in: &publishers)
+    }
+}

Sources/Auth/Services/Wallet/AuthService.swift → Sources/Auth/Services/Wallet/AuthRespondService.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-actor AuthService {
+actor AuthRespondService {
     private let networkingInteractor: NetworkInteracting
 
     init(networkingInteractor: NetworkInteracting) {

Sources/Auth/Types/Cacao/CacaoHeader.swift

@@ -1,5 +1,5 @@
 import Foundation
 
-struct CacaoHeader {
+struct CacaoHeader: Codable, Equatable {
     let t: String
 }

Sources/Auth/Types/Cacao/CacaoPayload.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-struct CacaoPayload {
+struct CacaoPayload: Codable, Equatable {
     let iss: String
     let domain: String
     let aud: String

Sources/Auth/Types/Cacao/CacaoSignature.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-struct CacaoSignature {
+struct CacaoSignature: Codable, Equatable {
     let t: String
     let s: String
     let m: String

Sources/Auth/Types/ProtocolRPCParams/AuthResponseParams.swift

@@ -0,0 +1,13 @@
+
+import Foundation
+import WalletConnectUtils
+
+struct AuthResponseParams: Codable, Equatable {
+    let header: CacaoHeader
+    let payload: CacaoPayload
+    let signature: CacaoSignature
+
+    static var tag: Int {
+        return 3001
+    }
+}

Sources/Auth/Types/RequestSubscriptionPayload.swift

@@ -0,0 +1,7 @@
+import Foundation
+import JSONRPC
+
+struct RequestSubscriptionPayload: Codable {
+    let topic: String
+    let request: RPCRequest
+}

Sources/JSONRPC/RPCID.swift

@@ -1,6 +1,6 @@
 import Commons
 
-public typealias RPCID = Either<String, Int>
+public typealias RPCID = Either<String, Int64>
 
 public protocol IdentifierGenerator {
     func next() -> RPCID
@@ -9,6 +9,6 @@ public protocol IdentifierGenerator {
 struct IntIdentifierGenerator: IdentifierGenerator {
 
     func next() -> RPCID {
-        return RPCID(Int.random(in: Int.min...Int.max))
+        return RPCID(Int64.random(in: Int64.min...Int64.max))
     }
 }

Sources/JSONRPC/RPCRequest.swift

@@ -37,7 +37,7 @@ public struct RPCRequest: Equatable {
         try self.init(method: method, checkedParams: params, id: idGenerator.next())
     }
 
-    public init<C>(method: String, checkedParams params: C, id: Int) throws where C: Codable {
+    public init<C>(method: String, checkedParams params: C, id: Int64) throws where C: Codable {
         try self.init(method: method, checkedParams: params, id: .right(id))
     }
 
@@ -49,10 +49,14 @@ public struct RPCRequest: Equatable {
         self.init(method: method, params: AnyCodable(params), id: idGenerator.next())
     }
 
-    public init<C>(method: String, params: C, id: Int) where C: Codable {
+    public init<C>(method: String, params: C, id: Int64) where C: Codable {
         self.init(method: method, params: AnyCodable(params), id: .right(id))
     }
 
+    public init<C>(method: String, params: C, rpcid: RPCID) where C: Codable {
+        self.init(method: method, params: AnyCodable(params), id: rpcid)
+    }
+
     public init<C>(method: String, params: C, id: String) where C: Codable {
         self.init(method: method, params: AnyCodable(params), id: .left(id))
     }
@@ -61,7 +65,7 @@ public struct RPCRequest: Equatable {
         self.init(method: method, params: nil, id: idGenerator.next())
     }
 
-    public init(method: String, id: Int) {
+    public init(method: String, id: Int64) {
         self.init(method: method, params: nil, id: .right(id))
     }
 

Sources/JSONRPC/RPCResponse.swift

@@ -35,23 +35,23 @@ public struct RPCResponse: Equatable {
         self.init(id: matchingRequest.id, outcome: .failure(error))
     }
 
-    public init<C>(id: Int, result: C) where C: Codable {
+    public init<C>(id: Int64, result: C) where C: Codable {
         self.init(id: RPCID(id), outcome: .success(AnyCodable(result)))
     }
 
     public init<C>(id: String, result: C) where C: Codable {
         self.init(id: RPCID(id), outcome: .success(AnyCodable(result)))
     }
 
-    public init(id: Int, error: JSONRPCError) {
+    public init(id: Int64, error: JSONRPCError) {
         self.init(id: RPCID(id), outcome: .failure(error))
     }
 
     public init(id: String, error: JSONRPCError) {
         self.init(id: RPCID(id), outcome: .failure(error))
     }
 
-    public init(id: Int, errorCode: Int, message: String, associatedData: AnyCodable? = nil) {
+    public init(id: Int64, errorCode: Int, message: String, associatedData: AnyCodable? = nil) {
         self.init(id: RPCID(id), outcome: .failure(JSONRPCError(code: errorCode, message: message, data: associatedData)))
     }
 

Sources/WalletConnectRelay/RPC/WalletConnectRPCID.swift

@@ -6,6 +6,6 @@ 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))
+        return .right(Int64(timestamp + random))
     }
 }

Tests/AuthTests/AuthRequstSubscriberTests.swift

@@ -0,0 +1,42 @@
+import Foundation
+import XCTest
+@testable import Auth
+import WalletConnectUtils
+@testable import WalletConnectKMS
+@testable import TestingUtils
+import JSONRPC
+
+class AuthRequstSubscriberTests: XCTestCase {
+    var networkingInteractor: NetworkingInteractorMock!
+    var sut: AuthRequestSubscriber!
+    var messageFormatter: SIWEMessageFormatterMock!
+    let defaultTimeout: TimeInterval = 0.01
+
+    override func setUp() {
+        networkingInteractor = NetworkingInteractorMock()
+        messageFormatter = SIWEMessageFormatterMock()
+        sut = AuthRequestSubscriber(networkingInteractor: networkingInteractor,
+                                   logger: ConsoleLoggerMock(),
+                                   messageFormatter: messageFormatter)
+    }
+
+    func testSubscribeRequest() {
+        let expectedMessage = "Expected Message"
+        let expectedRequestId: RPCID = RPCID(1234)
+        let messageExpectation = expectation(description: "receives formatted message")
+        messageFormatter.formattedMessage = expectedMessage
+        var messageId: RPCID!
+        var message: String!
+        sut.onRequest = { id, formattedMessage in
+            messageId = id
+            message = formattedMessage
+            messageExpectation.fulfill()
+        }
+
+        networkingInteractor.requestPublisherSubject.send(RequestSubscriptionPayload.stub(id: expectedRequestId))
+
+        wait(for: [messageExpectation], timeout: defaultTimeout)
+        XCTAssertEqual(message, expectedMessage)
+        XCTAssertEqual(messageId, expectedRequestId)
+    }
+}

Tests/AuthTests/Mocks/NetworkingInteractorMock.swift

@@ -0,0 +1,16 @@
+import Foundation
+import Combine
+@testable import Auth
+
+struct NetworkingInteractorMock: NetworkInteracting {
+    let requestPublisherSubject = PassthroughSubject<RequestSubscriptionPayload, Never>()
+    var requestPublisher: AnyPublisher<RequestSubscriptionPayload, Never> {
+        requestPublisherSubject.eraseToAnyPublisher()
+    }
+
+    func subscribe(topic: String) async throws {
+
+    }
+
+
+}

Tests/AuthTests/Mocks/SIWEMessageFormatterMock.swift

@@ -0,0 +1,10 @@
+import Foundation
+@testable import Auth
+
+class SIWEMessageFormatterMock: SIWEMessageFormatting {
+    var formattedMessage: String!
+    func formatMessage(from request: AuthRequestParams) throws -> String {
+        return formattedMessage
+    }
+}
+

Tests/AuthTests/Stubs/RequestParams.swift

@@ -0,0 +1,8 @@
+import Foundation
+@testable import Auth
+
+extension RequestParams {
+    static func stub() -> RequestParams {
+        return RequestParams(domain: "", chainId: "", nonce: "", aud: "", nbf: nil, exp: nil, statement: nil, requestId: nil, resources: nil)
+    }
+}

Tests/AuthTests/Stubs/RequestSubscriptionPayload.swift

@@ -0,0 +1,16 @@
+import Foundation
+@testable import Auth
+import JSONRPC
+
+extension RequestSubscriptionPayload {
+    static func stub(id: RPCID) -> RequestSubscriptionPayload {
+        let appMetadata = AppMetadata(name: "", description: "", url: "", icons: [])
+        let requester = AuthRequestParams.Requester(publicKey: "", metadata: appMetadata)
+        let issueAt = ISO8601DateFormatter().string(from: Date())
+        let payload = AuthPayload(requestParams: RequestParams.stub(), iat: issueAt)
+        let params = AuthRequestParams(requester: requester, payloadParams: payload)
+        let request = RPCRequest(method: "wc_authRequest", params: params, rpcid: id)
+        return RequestSubscriptionPayload(topic: "", request: request)
+    }
+}
+

Tests/TestingUtils/Mocks/RPC.swift

@@ -6,7 +6,7 @@ public extension RPCRequest {
         RPCRequest(method: "method", params: EmptyCodable())
     }
 
-    static func stub(method: String, id: Int) -> RPCRequest {
+    static func stub(method: String, id: Int64) -> RPCRequest {
         RPCRequest(method: method, params: EmptyCodable(), id: id)
     }
 }