@novastera-oss/nitro-metamask 0.6.3 → 0.7.2

package/ios/metamask-ios-sdk/CommunicationLayer/DeeplinkCommLayer/DeeplinkClient.swift

@@ -0,0 +1,199 @@
+//
+//  DeeplinkClient.swift
+//  metamask-ios-sdk
+//
+
+import UIKit
+import Foundation
+
+public class DeeplinkClient: CommClient {
+
+    private let session: SessionManager
+    public var channelId: String = ""
+    let dappScheme: String
+    let urlOpener: URLOpener
+
+    public var appMetadata: AppMetadata?
+    public var trackEvent: ((Event, [String: Any]) -> Void)?
+    public var handleResponse: (([String: Any]) -> Void)?
+    public var onClientsTerminated: (() -> Void)?
+
+    let keyExchange: KeyExchange
+    let deeplinkManager: DeeplinkManager
+    private var isConnecting = false
+
+    public var sessionDuration: TimeInterval {
+        get {
+            session.sessionDuration
+        } set {
+            session.sessionDuration = newValue
+        }
+    }
+
+    public var requestJobs: [RequestJob] = []
+
+    public init(session: SessionManager,
+                keyExchange: KeyExchange,
+                deeplinkManager: DeeplinkManager,
+                dappScheme: String,
+                urlOpener: URLOpener = DefaultURLOpener()
+    ) {
+        self.session = session
+        self.keyExchange = keyExchange
+        self.deeplinkManager = deeplinkManager
+        self.dappScheme = dappScheme
+        self.urlOpener = urlOpener
+        setupClient()
+        setupCallbacks()
+    }
+
+    private func setupCallbacks() {
+        self.deeplinkManager.onReceiveMessage = handleMessage
+        self.deeplinkManager.decryptMessage = keyExchange.decryptMessage
+    }
+
+    private func setupClient() {
+        let sessionInfo = session.fetchSessionConfig()
+        channelId = sessionInfo.0.sessionId
+    }
+
+    public func clearSession() {
+        track(event: .disconnected)
+        session.clear()
+        setupClient()
+    }
+    
+    public func requestAuthorisation() {
+        
+    }
+
+    func sendMessage(_ message: String) {
+        let deeplink = "metamask://\(message)"
+        guard
+            let urlString = deeplink.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed),
+            let url = URL(string: urlString)
+        else { return }
+        
+        urlOpener.open(url)
+    }
+
+    public func handleUrl(_ url: URL) {
+        deeplinkManager.handleUrl(url)
+    }
+
+    func sendMessage(_ deeplink: Deeplink, options: [String: String]) {
+        switch deeplink {
+        case .connect(_, let channelId, let request):
+            let originatorInfo = originatorInfo().toJsonString()?.base64Encode() ?? ""
+            var message = "connect?scheme=\(dappScheme)&channelId=\(channelId)&comm=deeplinking&originatorInfo=\(originatorInfo)"
+            if let request = request {
+                message.append("&request=\(request)")
+            }
+            sendMessage(message)
+        case .mmsdk(let message, _, let channelId):
+            let account = options["account"] ?? ""
+            let chainId = options["chainId"] ?? ""
+            let message = "mmsdk?scheme=\(dappScheme)&message=\(message)&channelId=\(channelId ?? "")&account=\(account)@\(chainId)"
+            sendMessage(message)
+        }
+    }
+
+    public func connect(with request: String? = nil) {
+        track(event: .connectionRequest)
+        isConnecting = true
+
+        sendMessage(.connect(
+            pubkey: nil,
+            channelId: channelId,
+            request: request
+        ), options: [:])
+    }
+
+    public func track(event: Event) {
+        let parameters: [String: Any] = [
+            "id": channelId,
+            "commLayer": "deeplinking",
+            "sdkVersion": SDKInfo.version,
+            "url": appMetadata?.url ?? "",
+            "dappId": SDKInfo.bundleIdentifier ?? "N/A",
+            "title": appMetadata?.name ?? "",
+            "platform": SDKInfo.platform
+        ]
+
+        trackEvent?(event, parameters)
+    }
+    
+    public func disconnect() {
+        track(event: .disconnected)
+    }
+
+    public func terminateConnection() {
+        track(event: .disconnected)
+    }
+
+    public func addRequest(_ job: @escaping RequestJob) {
+        requestJobs.append(job)
+    }
+
+    public func runQueuedJobs() {
+        while !requestJobs.isEmpty {
+            let job = requestJobs.popLast()
+            job?()
+        }
+    }
+
+    public func sendMessage<T>(_ message: T, encrypt: Bool, options: [String: String]) {
+        guard let message = message as? String else {
+            Logging.error("DeeplinkClient:: Expected message to be String, got \(type(of: message))")
+            return
+        }
+        
+        let base64Encoded = message.base64Encode() ?? ""
+
+        let deeplink: Deeplink = .mmsdk(
+            message: base64Encoded,
+            pubkey: nil,
+            channelId: channelId
+        )
+        sendMessage(deeplink, options: options)
+    }
+
+    public func handleMessage(_ message: String) {
+        do {
+            guard let data = message.data(using: .utf8) else {
+                Logging.error("DeeplinkClient:: Cannot convert message to data: \(message)")
+                return
+            }
+
+            let json: [String: Any] = try JSONSerialization.jsonObject(
+                with: data,
+                options: []
+            )
+                as? [String: Any] ?? [:]
+
+            if json["type"] as? String == "terminate" {
+                disconnect()
+                Logging.log("Connection terminated")
+            } else if json["type"] as? String == "ready" {
+                Logging.log("DeeplinkClient:: Connection is ready")
+                runQueuedJobs()
+                return
+            }
+
+            guard let data = json["data"] as? [String: Any] else {
+                Logging.log("DeeplinkClient:: Ignoring response \(json)")
+                return
+            }
+            if
+                isConnecting,
+                data["accounts"] != nil,
+                data["chainId"] != nil {
+                isConnecting = false
+                track(event: .connected)
+            }
+            handleResponse?(data)
+        } catch {
+            Logging.error("DeeplinkClient:: Could not convert message to json. Message: \(message)\nError: \(error)")
+        }
+    }
+}

package/ios/metamask-ios-sdk/CommunicationLayer/DeeplinkCommLayer/DeeplinkManager.swift

@@ -0,0 +1,83 @@
+//
+//  DeeplinkManager.swift
+//  metamask-ios-sdk
+//
+
+import UIKit
+import Foundation
+
+public class DeeplinkManager {
+    public var onReceiveMessage: ((String) -> Void)?
+    var decryptMessage: ((String) throws -> String?)?
+
+    public init(onReceiveMessage: ( (String) -> Void)? = nil, decryptMessage: ( (String) -> String?)? = nil) {
+        self.onReceiveMessage = onReceiveMessage
+        self.decryptMessage = decryptMessage
+    }
+
+    public func handleUrl(_ url: URL) {
+        handleUrl(url.absoluteString)
+    }
+
+    public func handleUrl(_ url: String) {
+        let deeplink = getDeeplink(url)
+
+        switch deeplink {
+        case .mmsdk(let message, _, _):
+            let base64Decoded = message.base64Decode() ?? ""
+
+            onReceiveMessage?(base64Decoded)
+
+        default:
+            Logging.error("DeeplinkManager:: ignoring url \(url)")
+        }
+    }
+
+    public func getDeeplink(_ link: String) -> Deeplink? {
+
+        guard let url = URL(string: link) else {
+            Logging.error("DeeplinkManager:: Deeplink has invalid url")
+            return nil
+        }
+
+        guard url.scheme != nil else {
+            Logging.error("DeeplinkManager:: Deeplink is missing scheme")
+            return nil
+        }
+
+        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: true) else {
+            Logging.error("DeeplinkManager:: Deeplink missing components")
+            return nil
+        }
+
+        guard let action = components.host else {
+            Logging.error("DeeplinkManager:: Deeplink missing action")
+            return nil
+        }
+
+        let pubkey = components.queryItems?.first(where: { $0.name == "pubkey" })?.value
+
+        if action == Deeplink.connect {
+            guard let channelId: String = components.queryItems?.first(where: { $0.name == "channelId" })?.value else {
+                Logging.error("DeeplinkManager:: Connect step missing channelId")
+                return nil
+            }
+
+            let request = components.queryItems?.first(where: { $0.name == "request" })?.value
+
+            return .connect(pubkey: pubkey, channelId: channelId, request: request)
+
+        } else if action == Deeplink.mmsdk {
+            guard let message = components.queryItems?.first(where: { $0.name == "message" })?.value else {
+                Logging.error("DeeplinkManager:: Deeplink missing message")
+                return nil
+            }
+
+            let channelId = components.queryItems?.first(where: { $0.name == "channelId" })?.value
+
+            return .mmsdk(message: message, pubkey: pubkey, channelId: channelId)
+        }
+
+        return nil
+    }
+}

package/ios/metamask-ios-sdk/CommunicationLayer/DeeplinkCommLayer/String.swift

@@ -0,0 +1,48 @@
+//
+//  String.swift
+//  metamask-ios-sdk
+
+import Foundation
+
+extension String {
+    func trimEscapingChars() -> Self {
+        var unescapedString = replacingOccurrences(of: #"\""#, with: "\"")
+        if unescapedString.hasPrefix("\"") && unescapedString.hasSuffix("\"") {
+            unescapedString.removeFirst()
+            unescapedString.removeLast()
+        }
+        return unescapedString
+    }
+}
+
+func json(from value: Any) -> String? {
+    // Recursive function to decode nested JSON strings
+    func decodeNestedJson(_ value: Any) -> Any {
+        if let arrayValue = value as? [Any] {
+            // If it's an array, recursively decode each element
+            return arrayValue.map { decodeNestedJson($0) }
+        } else if let dictValue = value as? [String: Any] {
+            // If it's a dictionary, recursively decode each value
+            var decodedDict = [String: Any]()
+            for (key, value) in dictValue {
+                decodedDict[key] = decodeNestedJson(value)
+            }
+            return decodedDict
+        } else {
+            // If it's neither a string, array, nor dictionary, return the value as is
+            return value
+        }
+    }
+
+    // Decode any nested JSON strings recursively in the input dictionary
+    let decodedJsonObject = decodeNestedJson(value)
+
+    // Step 3: Convert the cleaned dictionary back to a JSON string
+    guard let cleanedJsonData = try? JSONSerialization.data(withJSONObject: decodedJsonObject, options: []),
+          let cleanedJsonString = String(data: cleanedJsonData, encoding: .utf8) else {
+        Logging.error("Failed to serialize cleaned JSON dictionary")
+        return nil
+    }
+
+    return cleanedJsonString
+}

package/ios/metamask-ios-sdk/CommunicationLayer/DeeplinkCommLayer/URLOpener.swift

@@ -0,0 +1,19 @@
+//
+//  URLOpener.swift
+//
+
+import UIKit
+
+public protocol URLOpener {
+    func open(_ url: URL)
+}
+
+public class DefaultURLOpener: URLOpener {
+    public init() {}
+    
+    public func open(_ url: URL) {
+        DispatchQueue.main.async {
+            UIApplication.shared.open(url)
+        }
+    }
+}

package/ios/metamask-ios-sdk/CommunicationLayer/SocketClient.swift

@@ -0,0 +1,27 @@
+//
+//  SocketClient.swift
+//  metamask-ios-sdk
+//
+//  Stub — socket transport is not used. Exists only so `is SocketClient` type checks compile.
+//
+
+import Foundation
+
+/// Stub class. Socket transport is not supported; only deeplink transport is used.
+public final class SocketClient: CommClient {
+    public var channelId: String = ""
+    public var handleResponse: (([String: Any]) -> Void)?
+    public var trackEvent: ((Event, [String: Any]) -> Void)?
+    public var onClientsTerminated: (() -> Void)?
+    public var appMetadata: AppMetadata?
+    public var sessionDuration: TimeInterval = 0
+    public var networkUrl: String = ""
+    public var useDeeplinks: Bool = false
+
+    public func connect(with request: String?) { fatalError("SocketClient not supported") }
+    public func disconnect() { fatalError("SocketClient not supported") }
+    public func clearSession() { fatalError("SocketClient not supported") }
+    public func requestAuthorisation() { fatalError("SocketClient not supported") }
+    public func addRequest(_ job: @escaping RequestJob) { fatalError("SocketClient not supported") }
+    public func sendMessage<T: Codable>(_ message: T, encrypt: Bool, options: [String: String]) { fatalError("SocketClient not supported") }
+}

package/ios/metamask-ios-sdk/Crypto/Crypto.swift

@@ -0,0 +1,72 @@
+import Ecies
+import Foundation
+
+public protocol Crypto {
+    /// Generates keypair and returns the asymmetric private key
+    /// - Returns: Asymmetric private key
+    static func generatePrivateKey() -> String
+
+    /// Computes public key from given private key
+    /// - Parameter privateKey: Sender's private key
+    /// - Returns: Public key
+    static func publicKey(from privateKey: String) throws -> String
+
+    /// Encrypts plain text using provided public key
+    /// - Parameters:
+    ///   - message: Plain text to encrypt
+    ///   - publicKey: Sender public key
+    /// - Returns: Encrypted text
+    static func encrypt(_ message: String, publicKey: String) throws -> String
+
+    /// Decrypts base64 encoded cipher text to plain text using provided private key
+    /// - Parameters:
+    ///   - message: base64 encoded cipher text to decrypt
+    ///   - privateKey: Receiever's private key
+    /// - Returns: Decryted plain text
+    static func decrypt(_ message: String, privateKey: String) throws -> String
+}
+
+public enum CryptoError: Error {
+    case encryptionFailure
+    case decryptionFailure
+    case publicKeyGenerationFailure
+}
+
+/// Encryption module using ECIES encryption standard
+public enum Ecies: Crypto {
+    public static func generatePrivateKey() -> String {
+        String(cString: ecies_generate_secret_key())
+    }
+
+    public static func publicKey(from privateKey: String) throws -> String {
+        let privateKey: NSString = privateKey as NSString
+        let privateKeyBytes = UnsafeMutablePointer(mutating: privateKey.utf8String)
+        guard let pubKeyCString = ecies_public_key_from(privateKeyBytes) else {
+            throw CryptoError.publicKeyGenerationFailure
+        }
+        return String(cString: pubKeyCString)
+    }
+
+    public static func encrypt(_ message: String, publicKey: String) throws -> String {
+        let message: NSString = message as NSString
+        let publicKey: NSString = publicKey as NSString
+        let messageBytes = UnsafeMutablePointer(mutating: message.utf8String)
+        let publicKeyBytes = UnsafeMutablePointer(mutating: publicKey.utf8String)
+
+        guard let encryptedText = ecies_encrypt(publicKeyBytes, messageBytes) else {
+            throw CryptoError.encryptionFailure
+        }
+        return String(cString: encryptedText)
+    }
+
+    public static func decrypt(_ message: String, privateKey: String) throws -> String {
+        let message: NSString = message as NSString
+        let privateKey: NSString = privateKey as NSString
+        let messageBytes = UnsafeMutablePointer(mutating: message.utf8String)
+        let privateKeyBytes = UnsafeMutablePointer(mutating: privateKey.utf8String)
+        guard let decryptedText = ecies_decrypt(privateKeyBytes, messageBytes) else {
+            throw CryptoError.decryptionFailure
+        }
+        return String(cString: decryptedText)
+    }
+}

package/ios/metamask-ios-sdk/Crypto/Encoding.swift

@@ -0,0 +1,15 @@
+import Foundation
+
+public extension String {
+    // Encode a string to base64
+    func base64Encode() -> String? {
+        guard let data = data(using: .utf8) else { return nil }
+        return data.base64EncodedString()
+    }
+
+    // Decode a base64 string to original string
+    func base64Decode() -> String? {
+        guard let data = Data(base64Encoded: self) else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+}

package/ios/metamask-ios-sdk/Crypto/KeyExchange.swift

@@ -0,0 +1,236 @@
+//
+//  KeyExchange.swift
+//
+
+import Foundation
+
+public enum KeyExchangeType: String, Mappable {
+    case start = "key_handshake_start"
+    case ack = "key_handshake_ACK"
+    case syn = "key_handshake_SYN"
+    case synack = "key_handshake_SYNACK"
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        let status = try? container.decode(String.self)
+        switch status {
+        case "key_handshake_start": self = .start
+        case "key_handshake_ACK": self = .ack
+        case "key_handshake_SYN": self = .syn
+        case "key_handshake_SYNACK": self = .synack
+        default:
+            self = .ack
+        }
+    }
+}
+
+public enum KeyExchangeError: Error {
+    case keysNotExchanged
+    case encodingError
+}
+
+public struct KeyExchangeMessage: CodableData, Mappable {
+    public let type: KeyExchangeType
+    public let pubkey: String?
+    public var v: Int?
+    public var clientType: String? = "dapp"
+
+    public init(type: KeyExchangeType, pubkey: String?, v: Int? = 2, clientType: String? = "dapp") {
+        self.type = type
+        self.pubkey = pubkey
+        self.clientType = clientType
+        self.v = v
+    }
+
+    // Custom initializer for decoding
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        type = try container.decode(KeyExchangeType.self, forKey: .type)
+        pubkey = try container.decodeIfPresent(String.self, forKey: .pubkey)
+        v = try container.decodeIfPresent(Int.self, forKey: .v) ?? 2
+        clientType = try container.decodeIfPresent(String.self, forKey: .clientType) ?? "dapp"
+    }
+
+    // Custom method for encoding
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(type, forKey: .type)
+        try container.encode(pubkey, forKey: .pubkey)
+        try container.encode(v, forKey: .v)
+        try container.encode(clientType, forKey: .clientType)
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case type
+        case pubkey
+        case v
+        case clientType
+    }
+}
+/*
+ A module for handling key exchange between client and server
+ The key exchange sequence is defined as:
+ syn -> synack -> ack
+ */
+
+public class KeyExchange {
+    private var privateKey: String
+    public var pubkey: String
+    public private(set) var theirPublicKey: String?
+
+    private let storage: SecureStore
+    private let encyption: Crypto.Type
+    var keysExchanged: Bool = false
+    var isKeysExchangedViaV2Protocol: Bool = false
+    private let privateKeyStorageKey = "MM_SDK_PRIV_KEY"
+    private let theirPubliKeyStorageKey = "MM_SDK_THEIR_PUB_KEY"
+
+    public init(encryption: Crypto.Type = Ecies.self, storage: SecureStore) {
+        self.storage = storage
+        self.encyption = encryption
+
+        if let storedPrivateKey = storage.string(for: privateKeyStorageKey) {
+            Logging.log("KeyExchange:: using stored private key")
+            self.privateKey = storedPrivateKey
+            
+            if let theirPubKey = storage.string(for: theirPubliKeyStorageKey) {
+                self.theirPublicKey = theirPubKey
+                
+                // wallet already has keys
+                keysExchanged = true
+                isKeysExchangedViaV2Protocol = true
+            }
+        } else {
+            Logging.log("KeyExchange:: generating new private key")
+            privateKey = encyption.generatePrivateKey()
+        }
+        
+        do {
+            pubkey = try encyption.publicKey(from: privateKey)
+        } catch {
+            pubkey = ""
+        }
+    }
+
+    public func reset() {
+        keysExchanged = false
+        theirPublicKey = nil
+        privateKey = ""
+        isKeysExchangedViaV2Protocol = false
+        
+        storage.deleteData(for: privateKeyStorageKey)
+        storage.deleteData(for: theirPubliKeyStorageKey)
+        privateKey = encyption.generatePrivateKey()
+        
+        do {
+            pubkey = try encyption.publicKey(from: privateKey)
+        } catch {
+            pubkey = ""
+        }
+    }
+
+    public func nextMessage(_ message: KeyExchangeMessage) -> KeyExchangeMessage? {
+        if message.type == .start {
+            keysExchanged = false
+        }
+
+        if 
+            let publicKey = message.pubkey,
+            !publicKey.isEmpty {
+            // inline: store their public key
+            theirPublicKey = publicKey
+            keysExchanged = true
+            storage.save(string: publicKey, key: theirPubliKeyStorageKey)
+            storage.save(string: privateKey, key: privateKeyStorageKey)
+            
+            if message.v == 2 {
+                self.storage.save(string: privateKey, key: privateKeyStorageKey)
+                self.storage.save(string: publicKey, key: theirPubliKeyStorageKey)
+                isKeysExchangedViaV2Protocol = true
+            }
+        }
+
+        guard let nextStep = nextStep(message.type) else {
+            return nil
+        }
+
+        return KeyExchangeMessage(
+            type: nextStep,
+            pubkey: pubkey
+        )
+    }
+
+    public func nextStep(_ step: KeyExchangeType) -> KeyExchangeType? {
+        switch step {
+        case .start: return .syn
+        case .syn: return .synack
+        case .synack: return .ack
+        case .ack: return nil
+        }
+    }
+
+    public func message(type: KeyExchangeType) -> KeyExchangeMessage {
+        KeyExchangeMessage(
+            type: type,
+            pubkey: pubkey
+        )
+    }
+
+    public static func isHandshakeRestartMessage(_ message: [String: Any]) -> Bool {
+        guard
+            let message = message["message"] as? [String: Any],
+            let type = message["type"] as? String,
+            let exchangeType = KeyExchangeType(rawValue: type),
+            exchangeType == .start
+        else { return false }
+        return true
+    }
+
+    public func encryptMessage<T: Codable>(_ message: T) throws -> String {
+        guard let theirPublicKey = theirPublicKey else {
+            throw KeyExchangeError.keysNotExchanged
+        }
+
+        guard let encodedData = try? JSONEncoder().encode(message) else {
+            throw KeyExchangeError.encodingError
+        }
+
+        guard let jsonString = String(
+            data: encodedData,
+            encoding: .utf8
+        ) else {
+            throw KeyExchangeError.encodingError
+        }
+
+        return try encyption.encrypt(
+            jsonString,
+            publicKey: theirPublicKey
+        )
+    }
+
+    public func encrypt(_ message: String) throws -> String {
+        guard let theirPublicKey = theirPublicKey else {
+            throw KeyExchangeError.keysNotExchanged
+        }
+
+        return try encyption.encrypt(
+            message,
+            publicKey: theirPublicKey
+        )
+    }
+
+    public func decryptMessage(_ message: String) throws -> String {
+        guard theirPublicKey != nil else {
+            throw KeyExchangeError.keysNotExchanged
+        }
+
+        return try encyption.decrypt(
+            message,
+            privateKey: privateKey
+        ).trimEscapingChars()
+    }
+}
+
+extension KeyExchange {
+    static let live = Dependencies.shared.keyExchange
+}