Merge pull request #350 from WalletConnect/develop

[Release] Develop -> Main v2-rc0

Example/DApp/ Accounts/AccountsViewController.swift

@@ -53,7 +53,7 @@ final class AccountsViewController: UIViewController, UITableViewDataSource, UIT
     private func disconnect() {
         Task {
             do {
-                try await Sign.instance.disconnect(topic: session.topic, reason: Reason(code: 0, message: "disconnect"))
+                try await Sign.instance.disconnect(topic: session.topic)
                 DispatchQueue.main.async { [weak self] in
                     self?.onDisconnect?()
                 }

Example/ExampleApp/Wallet/WalletViewController.swift

@@ -166,7 +166,7 @@ extension WalletViewController: UITableViewDataSource, UITableViewDelegate {
             let item = sessionItems[indexPath.row]
             Task {
                 do {
-                    try await Sign.instance.disconnect(topic: item.topic, reason: Reason(code: 0, message: "disconnect"))
+                    try await Sign.instance.disconnect(topic: item.topic)
                     DispatchQueue.main.async { [weak self] in
                         self?.sessionItems.remove(at: indexPath.row)
                         tableView.deleteRows(at: [indexPath], with: .automatic)

Example/IntegrationTests/Chat/ChatTests.swift

@@ -7,8 +7,8 @@ import WalletConnectRelay
 import Combine
 
 final class ChatTests: XCTestCase {
-    var invitee: Chat!
-    var inviter: Chat!
+    var invitee: ChatClient!
+    var inviter: ChatClient!
     var registry: KeyValueRegistry!
     private var publishers = [AnyCancellable]()
 
@@ -37,37 +37,40 @@ final class ChatTests: XCTestCase {
         return
     }
 
-    func makeClient(prefix: String) -> Chat {
+    func makeClient(prefix: String) -> ChatClient {
         let logger = ConsoleLogger(suffix: prefix, loggingLevel: .debug)
         let relayHost = "relay.walletconnect.com"
         let projectId = "8ba9ee138960775e5231b70cc5ef1c3a"
         let keychain = KeychainStorageMock()
         let relayClient = RelayClient(relayHost: relayHost, projectId: projectId, keychainStorage: keychain, socketFactory: SocketFactory(), logger: logger)
-        return Chat(registry: registry, relayClient: relayClient, kms: KeyManagementService(keychain: keychain), logger: logger, keyValueStorage: RuntimeKeyValueStorage())
+        return ChatClient(registry: registry, relayClient: relayClient, kms: KeyManagementService(keychain: keychain), logger: logger, keyValueStorage: RuntimeKeyValueStorage())
     }
 
     func testInvite() async {
-//        await waitClientsConnected()
-//        let inviteExpectation = expectation(description: "invitation expectation")
-//        let account = Account(chainIdentifier: "eip155:1", address: "0x3627523167367216556273151")!
-//        let pubKey = try! await invitee.register(account: account)
-//        try! await inviter.invite(publicKey: pubKey, openingMessage: "")
-//        invitee.invitePublisher.sink { _ in
-//            inviteExpectation.fulfill()
-//        }.store(in: &publishers)
-//        wait(for: [inviteExpectation], timeout: 4)
+        await waitClientsConnected()
+        let inviteExpectation = expectation(description: "invitation expectation")
+        let inviteeAccount = Account(chainIdentifier: "eip155:1", address: "0x3627523167367216556273151")!
+        let inviterAccount = Account(chainIdentifier: "eip155:1", address: "0x36275231673672234423f")!
+        let pubKey = try! await invitee.register(account: inviteeAccount)
+        try! await inviter.invite(publicKey: pubKey, peerAccount: inviteeAccount, openingMessage: "", account: inviterAccount)
+        invitee.invitePublisher.sink { _ in
+            inviteExpectation.fulfill()
+        }.store(in: &publishers)
+        wait(for: [inviteExpectation], timeout: 4)
     }
 
-    func testAcceptAndCreateNewThread() async {
+//    func testAcceptAndCreateNewThread() async {
 //        await waitClientsConnected()
 //        let newThreadInviterExpectation = expectation(description: "new thread on inviting client expectation")
 //        let newThreadinviteeExpectation = expectation(description: "new thread on invitee client expectation")
-//        let account = Account(chainIdentifier: "eip155:1", address: "0x3627523167367216556273151")!
-//        let pubKey = try! await invitee.register(account: account)
-//        try! await inviter.invite(publicKey: pubKey, openingMessage: "opening message")
+//        let inviteeAccount = Account(chainIdentifier: "eip155:1", address: "0x3627523167367216556273151")!
+//        let inviterAccount = Account(chainIdentifier: "eip155:1", address: "0x36275231673672234423f")!
+//        let pubKey = try! await invitee.register(account: inviteeAccount)
 //
-//        invitee.invitePublisher.sink { [unowned self] inviteEnvelope in
-//            Task {try! await invitee.accept(inviteId: inviteEnvelope.pubKey)}
+//        try! await inviter.invite(publicKey: pubKey, peerAccount: inviteeAccount, openingMessage: "opening message", account: inviterAccount)
+//
+//        invitee.invitePublisher.sink { [unowned self] invite in
+//            Task {try! await invitee.accept(inviteId: invite.id)}
 //        }.store(in: &publishers)
 //
 //        invitee.newThreadPublisher.sink { _ in
@@ -79,5 +82,38 @@ final class ChatTests: XCTestCase {
 //        }.store(in: &publishers)
 //
 //        wait(for: [newThreadinviteeExpectation, newThreadInviterExpectation], timeout: 4)
-    }
+//    }
+//
+//    func testMessage() async {
+//        await waitClientsConnected()
+//        let messageExpectation = expectation(description: "message received")
+//        messageExpectation.expectedFulfillmentCount = 2
+//        let message = "message"
+//        let inviteeAccount = Account(chainIdentifier: "eip155:1", address: "0x3627523167367216556273151")!
+//        let inviterAccount = Account(chainIdentifier: "eip155:1", address: "0x36275231673672234423f")!
+//        let pubKey = try! await invitee.register(account: inviteeAccount)
+//        try! await inviter.invite(publicKey: pubKey, peerAccount: inviteeAccount, openingMessage: "opening message", account: inviterAccount)
+//
+//        invitee.invitePublisher.sink { [unowned self] invite in
+//            Task {try! await invitee.accept(inviteId: invite.id)}
+//        }.store(in: &publishers)
+//
+//        invitee.newThreadPublisher.sink { [unowned self] thread in
+//            Task {try! await invitee.message(topic: thread.topic, message: message)}
+//        }.store(in: &publishers)
+//
+//        inviter.newThreadPublisher.sink { [unowned self] thread in
+//            Task {try! await inviter.message(topic: thread.topic, message: message)}
+//        }.store(in: &publishers)
+//
+//        inviter.messagePublisher.sink { _ in
+//            messageExpectation.fulfill()
+//        }.store(in: &publishers)
+//
+//        invitee.messagePublisher.sink { _ in
+//            messageExpectation.fulfill()
+//        }.store(in: &publishers)
+//
+//        wait(for: [messageExpectation], timeout: 35)
+//    }
 }

Example/IntegrationTests/Chat/RegistryTests.swift

@@ -0,0 +1,18 @@
+import XCTest
+import WalletConnectRelay
+import WalletConnectKMS
+import WalletConnectUtils
+@testable import Chat
+
+final class RegistryTests: XCTestCase {
+
+    func testRegistry() async throws {
+        let client = HTTPClient(host: "keys.walletconnect.com")
+        let registry = KeyserverRegistryProvider(client: client)
+        let account = Account("eip155:1:" + Data.randomBytes(count: 16).toHexString())!
+        let pubKey = SigningPrivateKey().publicKey.hexRepresentation
+        try await registry.register(account: account, pubKey: pubKey)
+        let resolvedKey = try await registry.resolve(account: account)
+        XCTAssertEqual(resolvedKey, pubKey)
+    }
+}

Example/IntegrationTests/Relay/RelayClientEndToEndTests.swift

@@ -22,6 +22,7 @@ final class RelayClientEndToEndTests: XCTestCase {
         )
         let urlFactory = RelayUrlFactory(socketAuthenticator: socketAuthenticator)
         let socket = WebSocket(url: urlFactory.create(host: relayHost, projectId: projectId))
+
         let logger = ConsoleLogger()
         let dispatcher = Dispatcher(socket: socket, socketConnectionHandler: ManualSocketConnectionHandler(socket: socket), logger: logger)
         return RelayClient(dispatcher: dispatcher, logger: logger, keyValueStorage: RuntimeKeyValueStorage())
@@ -75,15 +76,15 @@ final class RelayClientEndToEndTests: XCTestCase {
             expectationB.fulfill()
         }
         relayA.socketConnectionStatusPublisher.sink {  _ in
-            relayA.publish(topic: randomTopic, payload: payloadA, tag: .unknown, onNetworkAcknowledge: { error in
+            relayA.publish(topic: randomTopic, payload: payloadA, tag: 0, onNetworkAcknowledge: { error in
                 XCTAssertNil(error)
             })
             relayA.subscribe(topic: randomTopic) { error in
                 XCTAssertNil(error)
             }
         }.store(in: &publishers)
         relayB.socketConnectionStatusPublisher.sink {  _ in
-            relayB.publish(topic: randomTopic, payload: payloadB, tag: .unknown, onNetworkAcknowledge: { error in
+            relayB.publish(topic: randomTopic, payload: payloadB, tag: 0, onNetworkAcknowledge: { error in
                 XCTAssertNil(error)
             })
             relayB.subscribe(topic: randomTopic) { error in

Example/IntegrationTests/Sign/SignClientTests.swift

@@ -112,22 +112,49 @@ final class SignClientTests: XCTestCase {
         }
         wait(for: [sessionRejectExpectation], timeout: defaultTimeout)
     }
-//
-//    func testNewPairingPing() async {
-//        let responderReceivesPingResponseExpectation = expectation(description: "Responder receives ping response")
-//        await waitClientsConnected()
-//
-//        let uri = try! await proposer.client.connect(requiredNamespaces: [:])!
-//
-//        try! await responder.client.pair(uri: uri)
-//        let pairing = responder.client.getSettledPairings().first!
-//        responder.client.ping(topic: pairing.topic) { response in
-//            XCTAssertTrue(response.isSuccess)
-//            responderReceivesPingResponseExpectation.fulfill()
-//        }
-//        wait(for: [responderReceivesPingResponseExpectation], timeout: defaultTimeout)
-//    }
-//
+
+    func testSessionDelete() async throws {
+        let dapp = proposer!
+        let wallet = responder!
+        let sessionDeleteExpectation = expectation(description: "Wallet expects session to be deleted")
+        let requiredNamespaces = ProposalNamespace.stubRequired()
+        let sessionNamespaces = SessionNamespace.make(toRespond: requiredNamespaces)
+
+        wallet.onSessionProposal = { proposal in
+            Task(priority: .high) {
+                do { try await wallet.client.approve(proposalId: proposal.id, namespaces: sessionNamespaces) } catch { XCTFail("\(error)") }
+            }
+        }
+        dapp.onSessionSettled = { settledSession in
+            Task(priority: .high) {
+                try await dapp.client.disconnect(topic: settledSession.topic)
+            }
+        }
+        wallet.onSessionDelete = {
+            sessionDeleteExpectation.fulfill()
+        }
+
+        let uri = try await dapp.client.connect(requiredNamespaces: requiredNamespaces)
+        try await wallet.client.pair(uri: uri!)
+        wait(for: [sessionDeleteExpectation], timeout: defaultTimeout)
+    }
+
+    func testNewPairingPing() async throws {
+        let dapp = proposer!
+        let wallet = responder!
+        let pongResponseExpectation = expectation(description: "Ping sender receives a pong response")
+
+        let uri = try await dapp.client.connect(requiredNamespaces: ProposalNamespace.stubRequired())!
+        try await wallet.client.pair(uri: uri)
+
+        let pairing = wallet.client.getSettledPairings().first!
+        wallet.client.ping(topic: pairing.topic) { result in
+            if case .failure = result { XCTFail() }
+            pongResponseExpectation.fulfill()
+        }
+        wait(for: [pongResponseExpectation], timeout: defaultTimeout)
+    }
+
 //
 //    func testNewSessionOnExistingPairing() async {
 //        await waitClientsConnected()
@@ -159,24 +186,6 @@ final class SignClientTests: XCTestCase {
 //        wait(for: [proposerSettlesSessionExpectation, responderSettlesSessionExpectation], timeout: defaultTimeout)
 //    }
 //
-//    func testDeleteSession() async {
-//        await waitClientsConnected()
-//        let sessionDeleteExpectation = expectation(description: "Responder is notified on session deletion")
-//        let uri = try! await proposer.client.connect(namespaces: [Namespace.stub()])!
-//        _ = try! await responder.client.pair(uri: uri)
-//        responder.onSessionProposal = {[unowned self]  proposal in
-//            try? self.responder.client.approve(proposalId: proposal.id, accounts: [], namespaces: [])
-//        }
-//        proposer.onSessionSettled = {[unowned self]  settledSession in
-//            Task {
-//                try await self.proposer.client.disconnect(topic: settledSession.topic, reason: Reason(code: 5900, message: "User disconnected session"))
-//            }
-//        }
-//        responder.onSessionDelete = {
-//            sessionDeleteExpectation.fulfill()
-//        }
-//        wait(for: [sessionDeleteExpectation], timeout: defaultTimeout)
-//    }
 //
 //    func testProposerRequestSessionRequest() async {
 //        await waitClientsConnected()

Example/Showcase/Classes/ApplicationLayer/AppDelegate.swift

@@ -0,0 +1,20 @@
+import UIKit
+
+@main
+class AppDelegate: UIResponder, UIApplicationDelegate {
+
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+        // Override point for customization after application launch.
+        return true
+    }
+
+    // MARK: UISceneSession Lifecycle
+
+    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
+        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
+    }
+
+    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
+
+    }
+}

Example/Showcase/Classes/ApplicationLayer/Application.swift

@@ -0,0 +1,17 @@
+import Foundation
+import Chat
+
+final class Application {
+
+    let chatService: ChatService = {
+        return ChatService(client: ChatFactory.create())
+    }()
+
+    lazy var accountStorage: AccountStorage = {
+        return AccountStorage(defaults: .standard)
+    }()
+
+    lazy var registerService: RegisterService = {
+        return RegisterService(chatService: chatService)
+    }()
+}

Example/Showcase/Classes/ApplicationLayer/Configurator/AppearanceConfigurator.swift

@@ -0,0 +1,19 @@
+import UIKit
+
+struct AppearanceConfigurator: Configurator {
+
+    func configure() {
+        let appearance = UINavigationBarAppearance()
+        appearance.backgroundColor = .w_background
+        appearance.shadowColor = .clear
+        appearance.titleTextAttributes = [
+            .foregroundColor: UIColor.w_foreground
+        ]
+
+        UINavigationBar.appearance().standardAppearance = appearance
+        UINavigationBar.appearance().scrollEdgeAppearance = appearance
+        UINavigationBar.appearance().compactAppearance = appearance
+
+        UIApplication.currentWindow.overrideUserInterfaceStyle = .dark
+    }
+}

Example/Showcase/Classes/ApplicationLayer/Configurator/ApplicationConfigurator.swift

@@ -0,0 +1,16 @@
+import Combine
+
+struct ApplicationConfigurator: Configurator {
+
+    private var publishers = Set<AnyCancellable>()
+
+    private let app: Application
+
+    init(app: Application) {
+        self.app = app
+    }
+
+    func configure() {
+        WelcomeModule.create(app: app).present()
+    }
+}

Example/Showcase/Classes/ApplicationLayer/Configurator/Configurator.swift

@@ -0,0 +1,9 @@
+protocol Configurator {
+    func configure()
+}
+
+extension Array where Element == Configurator {
+    func configure() {
+        forEach { $0.configure() }
+    }
+}

Example/Showcase/Classes/ApplicationLayer/Configurator/MigrationConfigurator.swift

@@ -0,0 +1,12 @@
+struct MigrationConfigurator: Configurator {
+
+    let app: Application
+
+    init(app: Application) {
+        self.app = app
+    }
+
+    func configure() {
+
+    }
+}

Example/Showcase/Classes/ApplicationLayer/Configurator/ThirdPartyConfigurator.swift

@@ -0,0 +1,6 @@
+struct ThirdPartyConfigurator: Configurator {
+
+    func configure() {
+
+    }
+}

Example/Showcase/Classes/ApplicationLayer/SceneDelegate.swift

@@ -0,0 +1,26 @@
+import UIKit
+
+class SceneDelegate: UIResponder, UIWindowSceneDelegate {
+
+    var window: UIWindow?
+
+    private let app = Application()
+
+    private var configurators: [Configurator] {
+        return [
+            MigrationConfigurator(app: app),
+            ApplicationConfigurator(app: app),
+            AppearanceConfigurator(),
+            ThirdPartyConfigurator()
+        ]
+    }
+
+    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
+        guard let windowScene = (scene as? UIWindowScene) else { return }
+
+        window = UIWindow(windowScene: windowScene)
+        window?.makeKeyAndVisible()
+
+        configurators.configure()
+    }
+}