Mobile Integration

import UIKit
import WebKit

class CryptoWebController: UIViewController, WKUIDelegate, WKNavigationDelegate, WKScriptMessageHandler {

    // Private variables
    private var webView : WKWebView?
    private var cryptoAddress = ""
    private var fiatAmount = ""
    private var assetType = ""
    private var network = ""
    private var supportedTokens = ""
    private var clientToken = ""

    // Error response
    private let errorResponse = CryptoResponse(status: false, data: nil)

    // Public variables
    public var completion : ((CryptoResponse)->())?

    // Constants
    private enum CONSTANTS : String {
        case STATUS = "orderStatus"
        case SUCCESS = "order-success"
        case FAILURE = "order-fail"
        case TITLE = "Crypto ACH"
        case DISMISS = "Dismiss"
        case ALERT_TITLE = "Confirmation"
        case ALERT_MESSAGE = "Are you sure you want to dismiss?"
        case ACTION_YES = "Yes"
        case ACTION_NO = "No"
    }

    convenience init(withAddress address: String, fiatAmount: String, assetType: String, network: String, supportedTokens: String, clientToken: String) {
        self.init()
        self.cryptoAddress = address
        self.fiatAmount = fiatAmount
        self.assetType = assetType
        self.network = network
        self.supportedTokens = supportedTokens
        self.clientToken = clientToken
    }

    override func viewDidLoad() {
        super.viewDidLoad()

        self.title = CONSTANTS.TITLE.rawValue

        self.navigationItem.leftBarButtonItem = UIBarButtonItem(title: CONSTANTS.DISMISS.rawValue, style: .plain, target: self, action: #selector(dismissAction))

    }

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)

        guard let baseURL = URL(string:"https://crypto.sandbox.sardine.ai") else {
            return
        }

        let scheme = baseURL.scheme
        let host = baseURL.host
        let path = "/alpha/6ccfb278-5f94-44fe-bf33-4ea81325713b"
        let queryItems = [
            URLQueryItem(name: "address", value: cryptoAddress),
            URLQueryItem(name: "fiat_amount", value: fiatAmount),
            URLQueryItem(name: "asset_type", value: assetType),
            URLQueryItem(name: "network", value: network),
            URLQueryItem(name: "supported_tokens", value: supportedTokens),
            URLQueryItem(name: "client_token", value: clientToken),
            URLQueryItem(name: "plaid_redirect_url", value: "https://your-domain-here.com"),
        ]

        var urlComponents = URLComponents()
        urlComponents.scheme = scheme
        urlComponents.host = host
        urlComponents.path = path
        urlComponents.queryItems = queryItems

        guard let cryptoURL = urlComponents.url else {
            return
        }

        let cryptoRequest = URLRequest(url: cryptoURL)

        let preferences = WKPreferences()
        let contentController = WKUserContentController()
        preferences.javaScriptEnabled = true
        let source: String = """
            window.onload = function() {
                window.document.addEventListener("\(CONSTANTS.SUCCESS.rawValue)", function(data) {
                    const d = data.detail;
                    const v = d ? JSON.stringify(d) : "";
                    const val = '"' + `${v}` + '"';
                    window.webkit.messageHandlers.\(CONSTANTS.STATUS.rawValue).postMessage(`${val}`);
                });

                window.document.addEventListener("\(CONSTANTS.FAILURE.rawValue)", function(data) {
                    window.webkit.messageHandlers.\(CONSTANTS.STATUS.rawValue).postMessage("\(CONSTANTS.FAILURE.rawValue)");
                });
            }
            """
        let script: WKUserScript = WKUserScript(source: source, injectionTime: .atDocumentEnd, forMainFrameOnly: true)
        contentController.addUserScript(script)
        contentController.add(self, name: CONSTANTS.STATUS.rawValue)

        let configuration = WKWebViewConfiguration()
        configuration.preferences = preferences
        configuration.userContentController = contentController

        self.webView = WKWebView(frame: self.view.bounds, configuration: configuration)
        self.webView!.allowsBackForwardNavigationGestures = true
        self.webView!.uiDelegate = self
        self.webView!.navigationDelegate = self
        self.view = webView

        self.webView!.load(cryptoRequest)
    }

    func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
        completion?(errorResponse)
    }

    @objc private func dismissAction() {
        let alert = UIAlertController(title: CONSTANTS.ALERT_TITLE.rawValue, message: CONSTANTS.ALERT_MESSAGE.rawValue, preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: CONSTANTS.ACTION_YES.rawValue, style: .cancel, handler: { _ in
            self.navigationController?.dismiss(animated: true, completion: nil)
            self.completion?(self.errorResponse)
        }))
        alert.addAction(UIAlertAction(title: CONSTANTS.ACTION_NO.rawValue, style: .default, handler: nil))
        self.present(alert, animated: true, completion: nil)
    }

    func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
        switch message.name {
        case CONSTANTS.STATUS.rawValue:
            let isFailure = "\(message.body)" == CONSTANTS.FAILURE.rawValue
            if !isFailure {
                DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
                    self.navigationController?.dismiss(animated: true, completion: nil)

                    let stringValue = String("\(message.body)".dropFirst().dropLast())
                    var successResponse = CryptoResponse(status: true, data: nil)

                    guard let strData = stringValue.data(using: .utf8) else {
                        self.completion?(successResponse)
                        return
                    }

                    guard let d = try? JSONDecoder().decode(CryptoDetails.self, from: strData) else {
                        self.completion?(successResponse)
                        return
                    }
                    successResponse.data = d
                    self.completion?(successResponse)
                }
            }

        default:
            break
        }
    }
}

class CryptoManager {

    public class func initiateCheckout(withAddress address: String, fiatAmount: String, assetType: String, network: String, supportedTokens: String, clientToken: String, completion : @escaping ((CryptoResponse)->())) {
        DispatchQueue.main.async {
            let cryptoVC = CryptoWebController(withAddress: address, fiatAmount: String, assetType: String, network: String, supportedTokens: String, clientToken: String)
            cryptoVC.completion = completion
            let navigationVC = UINavigationController(rootViewController: cryptoVC)
            navigationVC.modalPresentationStyle = .fullScreen
            self.present(navigationVC, animated: true, completion: nil)
        }
    }
}