WalletConnect Pay SDK - Swift

dependencies: [
    .package(url: "https://github.com/reown-com/reown-swift", from: "2.4.0")
]

.target(
    name: "YourApp",
    dependencies: ["WalletConnectPay"]
)

import WalletConnectPay

func application(_ application: UIApplication, didFinishLaunchingWithOptions...) {
    // Option 1: With appId (recommended for wallets)
    WalletConnectPay.configure(
        appId: "your-wcp-id",
        logging: true
    )
    
    // Option 2: With API key
    WalletConnectPay.configure(
        apiKey: "your-pay-api-key"
    )
}

func isPaymentLink(_ string: String) -> Bool {
    let lower = string.lowercased()
    return lower.contains("pay.") ||
           lower.contains("pay=") ||
           lower.contains("pay_")
}

// Deep link opened from outside your app (SceneDelegate or AppDelegate)
func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    guard let url = URLContexts.first?.url else { return }
    if isPaymentLink(url.absoluteString) {
        startPaymentFlow(paymentLink: url.absoluteString)
    }
}

// QR code payload
func handleScannedQR(_ content: String) {
    if isPaymentLink(content) {
        startPaymentFlow(paymentLink: content)
    }
}

import WebKit
import SwiftUI

struct PayDataCollectionWebView: UIViewRepresentable {
    let url: URL
    let onComplete: () -> Void
    let onError: (String) -> Void

    func makeCoordinator() -> Coordinator {
        Coordinator(onComplete: onComplete, onError: onError)
    }

    func makeUIView(context: Context) -> WKWebView {
        let config = WKWebViewConfiguration()
        config.userContentController.add(
            context.coordinator,
            name: "payDataCollectionComplete"
        )

        let webView = WKWebView(frame: .zero, configuration: config)
        webView.navigationDelegate = context.coordinator
        webView.load(URLRequest(url: url))
        return webView
    }

    func updateUIView(_ uiView: WKWebView, context: Context) {}

    class Coordinator: NSObject, WKScriptMessageHandler, WKNavigationDelegate {
        let onComplete: () -> Void
        let onError: (String) -> Void

        init(onComplete: @escaping () -> Void, onError: @escaping (String) -> Void) {
            self.onComplete = onComplete
            self.onError = onError
        }

        func userContentController(
            _ userContentController: WKUserContentController,
            didReceive message: WKScriptMessage
        ) {
            guard let body = message.body as? String,
                  let data = body.data(using: .utf8),
                  let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
                  let type = json["type"] as? String else { return }

            DispatchQueue.main.async {
                switch type {
                case "IC_COMPLETE":
                    self.onComplete()
                case "IC_ERROR":
                    let error = json["error"] as? String ?? "Unknown error"
                    self.onError(error)
                default:
                    break
                }
            }
        }

        func webView(
            _ webView: WKWebView,
            decidePolicyFor navigationAction: WKNavigationAction,
            decisionHandler: @escaping (WKNavigationActionPolicy) -> Void
        ) {
            guard let url = navigationAction.request.url else {
                decisionHandler(.allow)
                return
            }
            // Open external links (T&C, Privacy Policy) in Safari
            if let host = url.host, !host.contains("pay.walletconnect.com") {
                UIApplication.shared.open(url)
                decisionHandler(.cancel)
                return
            }
            decisionHandler(.allow)
        }
    }
}

func buildFormUrl(
    baseUrl: String,
    prefillData: [String: String] = [:],
    theme: String? = nil,            // "light" or "dark"
    themeVariables: String? = nil    // base64url string exported from the Pay Dashboard
) -> String {
    guard var components = URLComponents(string: baseUrl) else { return baseUrl }
    var queryItems = components.queryItems ?? []
    if !prefillData.isEmpty,
       let jsonData = try? JSONSerialization.data(withJSONObject: prefillData) {
        // base64url: URL-safe, no padding
        let prefill = jsonData.base64EncodedString()
            .replacingOccurrences(of: "+", with: "-")
            .replacingOccurrences(of: "/", with: "_")
            .replacingOccurrences(of: "=", with: "")
        queryItems.append(URLQueryItem(name: "prefill", value: prefill))
    }
    if let theme = theme {
        queryItems.append(URLQueryItem(name: "theme", value: theme))
    }
    if let themeVariables = themeVariables {
        queryItems.append(URLQueryItem(name: "themeVariables", value: themeVariables))
    }
    components.queryItems = queryItems
    return components.string ?? baseUrl
}

import WalletConnectPay

class PaymentManager {
    
    func processPayment(
        paymentLink: String,
        walletAddress: String,
        signer: YourSignerProtocol
    ) async throws {
        
        // 1. Get payment options
        let accounts = [
            "eip155:1:\(walletAddress)",
            "eip155:137:\(walletAddress)",
            "eip155:8453:\(walletAddress)"
        ]
        
        let optionsResponse = try await WalletConnectPay.instance.getPaymentOptions(
            paymentLink: paymentLink,
            accounts: accounts
        )
        
        guard !optionsResponse.options.isEmpty else {
            throw PaymentError.noOptionsAvailable
        }
        
        // 2. Let user select an option (simplified - use first option)
        let selectedOption = optionsResponse.options[0]

        // 3. Collect data via WebView if required (before fetching actions)
        if let collectData = selectedOption.collectData, let url = collectData.url {
            // Show WebView and wait for IC_COMPLETE message
            try await showDataCollectionWebView(url: url)
        }

        // 4. Get required actions
        let actions = try await WalletConnectPay.instance.getRequiredPaymentActions(
            paymentId: optionsResponse.paymentId,
            optionId: selectedOption.id
        )
        
        // 5. Sign all actions
        var data: [String] = []
        for action in actions {
            let signature = try await signAction(
                action: action,
                walletAddress: walletAddress,
                signer: signer
            )
            data.append(signature)
        }

        // 6. Confirm payment
        let result = try await WalletConnectPay.instance.confirmPayment(
            paymentId: optionsResponse.paymentId,
            optionId: selectedOption.id,
            data: data
        )
        
        switch result.status {
        case .succeeded:
            break // Success
        case .cancelled:
            throw PaymentError.paymentCancelled
        default:
            throw PaymentError.paymentFailed(result.status)
        }
    }

    private func signAction(
        action: Action,
        walletAddress: String,
        signer: YourSignerProtocol
    ) async throws -> String {
        let rpc = action.walletRpc

        switch rpc.method {
        case "eth_signTypedData_v4":
            guard let paramsData = rpc.params.data(using: .utf8),
                  let params = try JSONSerialization.jsonObject(with: paramsData) as? [Any],
                  params.count >= 2,
                  let typedDataJson = params[1] as? String else {
                throw PaymentError.invalidParams
            }
            return try await signer.signTypedData(
                data: typedDataJson,
                address: walletAddress
            )
        case "eth_sendTransaction":
            return try await signer.sendTransaction(
                params: rpc.params,
                chainId: rpc.chainId
            )
        case "personal_sign":
            return try await signer.personalSign(
                params: rpc.params,
                address: walletAddress
            )
        default:
            throw PaymentError.unsupportedMethod(rpc.method)
        }
    }
}

struct PaymentOptionsResponse {
    let paymentId: String              // Unique payment identifier
    let info: PaymentInfo?             // Merchant and amount details
    let options: [PaymentOption]       // Available payment methods
    let collectData: CollectDataAction? // Required user data fields (travel rule)
    let resultInfo: PaymentResultInfo? // Transaction result details (present when payment already completed)
}

struct PaymentResultInfo {
    let txId: String                   // Transaction ID
    let optionAmount: PayAmount        // Token amount details
}

struct PaymentInfo {
    let status: PaymentStatus          // Current payment status
    let amount: PayAmount              // Requested payment amount
    let expiresAt: Int64               // Expiration timestamp
    let merchant: MerchantInfo         // Merchant details
    let buyer: BuyerInfo?              // Buyer info if available
}

struct PaymentOption {
    let id: String                     // Option identifier
    let amount: PayAmount              // Amount in this asset
    let etaS: Int64                    // Estimated time to complete (seconds)
    let actions: [Action]              // Required signing actions
    let collectData: CollectDataAction? // Per-option data collection (nil if not required)
}

struct PayAmount {
    let unit: String                   // Asset unit (e.g., "USDC")
    let value: String                  // Raw value in smallest unit
    let display: AmountDisplay         // Human-readable display info
}

struct AmountDisplay {
    let assetSymbol: String            // Token symbol (e.g., "USDC")
    let assetName: String              // Token name (e.g., "USD Coin")
    let decimals: Int64                // Token decimals
    let iconUrl: String?               // Token icon URL
    let networkName: String?           // Network name (e.g., "Base")
}

struct Action {
    let walletRpc: WalletRpcAction     // RPC call to sign
}

struct WalletRpcAction {
    let chainId: String                // Chain ID (e.g., "eip155:8453")
    let method: String                 // RPC method (e.g., "eth_signTypedData_v4", "eth_sendTransaction")
    let params: String                 // JSON-encoded parameters
}

struct CollectDataAction {
    let url: String                    // WebView URL for data collection
    let schema: String?                // JSON schema describing required fields
}

struct ConfirmPaymentResultResponse {
    let status: PaymentStatus          // Final payment status
    let isFinal: Bool                  // Whether status is final
    let pollInMs: Int64?               // Suggested poll interval
    let info: PaymentResultInfo?       // Transaction result details (present on success)
}

enum PaymentStatus {
    case requiresAction                // Additional action needed
    case processing                    // Payment in progress
    case succeeded                     // Payment completed
    case failed                        // Payment failed
    case expired                       // Payment expired
    case cancelled                     // Payment cancelled by user
}