iOS

import ZktlsSDK

// Yours: what your backend returns after it creates the run.
struct IssuedRun: Decodable {
    let packId: String
    let resultUrl: String
    let accessToken: String
}

func treeConfig(for run: IssuedRun) async throws -> TreeRunConfig {
    let trustBundle = try await fetchText(Cr3d.trustBundleUrl)     // yours: a plain HTTPS GET
    let policyBundle = try await fetchText(Cr3d.policyBundleUrl)
    return TreeRunConfig(
        baseUrl: Cr3d.baseUrl,
        appCredential: Cr3d.appCredential,
        userIdHash: sha256Hex(currentUserId),                       // yours: never the raw id
        idempotencyKey: UUID().uuidString,                          // new for every run
        clientRegion: userCountry ?? "",                            // ISO 3166-1 alpha-2, or "" if unknown
        networkKey: "default",
        platformId: run.packId,
        trustBundleJson: trustBundle,
        trustBundleUrl: Cr3d.trustBundleUrl,
        trustOperatorKey: Cr3d.trustOperatorKey,
        policyBundleJson: policyBundle,
        policyBundleDigest: Cr3d.policyBundleDigest,
        relyingPartyNonceHex: "",
        resultUrl: run.resultUrl,
        resultToken: run.accessToken,
        paramsJson: "")                                             // a check's params as JSON text, or ""
}

import UIKit
import ZktlsSDK

final class VerifyViewController: UIViewController {
    private var client: ZktlsClient?

    func verify(platformId: Int) async {
        guard client == nil else { return }                          // one run at a time
        let client = ZktlsClient()                                    // a new client for every run
        self.client = client
        defer { self.client = nil }

        let lifecycle = ZkTlsLifecycle(host: UIApplication.shared, handle: client.lifecycleHandle)
        lifecycle.onExpiry = { client.cancel() }                      // iOS ended the background time
        defer { lifecycle.end() }                                     // every path, including failure
        await client.onProgress { phase, percent in
            if phase == .attesting { lifecycle.begin() }              // keeps the hand-off alive if the user leaves
            Task { @MainActor in /* update your progress view */ }
        }

        do {
            let run = try await backend.createSdkRun(platformId: platformId)   // yours
            let config = try await treeConfig(for: run)
            let host = TreeWebViewHost(presentingFrom: self, disclosure: disclosure)
            let summary = try await client.runTree(config: config, host: host)
            if summary.handedOff {
                show("You can close the app. We'll let you know when it's done.")
            } else if summary.succeeded && summary.delivered {
                show("Verified.")
            } else {
                show("Not verified. Please try again.")              // summary.error says why
            }
        } catch let e as SdkError {
            show(message(for: e))                                     // see Errors; never retry automatically
        } catch {
            show("Something went wrong. Please try again.")
        }
    }

    func cancelTapped() { client?.cancel() }
}

let disclosure = TreeDisclosure(
    title: "Connect your account",
    message: "We'll open the platform's own sign-in page. You sign in there yourself, and we never see "
        + "your password. Then we read the data this verification needs from your account.",
    accept: "Continue",
    decline: "Not now")