iOS / Swift Shield SDK

dependencies: [
    .package(url: "https://github.com/Akedly-Org/akedly-shield-swift", from: "1.1.0")
]

import AkedlyShield

// `enrollmentToken` comes from a successful OTP /verify (relayed by YOUR backend).
// For `result.verified` to be true here, that /verify call must also have passed
// returnTarget: { url: "myapp://akedly-passkey" }. Without it enrollment still succeeds,
// but this resolves verified:false / no_proof — treat it as advisory.
let passkey = AkedlyPasskey()
let result = await passkey.openPasskeyCeremony(token: enrollmentToken, callbackScheme: "myapp")
if result.verified {
    // The passkey now exists — it is proven on the next sign-in.
}

import AkedlyShield

// 1. Your backend clears the gate + starts the ceremony:
//    POST /api/v1.2/transactions/passkey/auth-options
//      { APIKey, pipelineID, verificationAddress: { phoneNumber }, powSolution?, turnstileToken?,
//        returnTarget: { url: "myapp://akedly-passkey" } }  // <-- REQUIRED for the resultToken
//    -> { data: { ceremonyToken, requestID } }   (or 404 NO_PASSKEY -> use OTP)
let auth = try await myBackend.startPasskeyAuth(phone)

// 2. Run the ceremony. `callbackScheme` is your app's URL scheme.
let passkey = AkedlyPasskey() // or AkedlyPasskey(ceremonyOrigin: "https://localhost:5174") for shared-cert QA
let result = await passkey.openPasskeyCeremony(token: auth.ceremonyToken, callbackScheme: "myapp")

if result.verified {
    // 3. Confirm offline on YOUR backend without waiting for polling/callback — see below.
    try await myBackend.completeSignIn(
        resultToken: result.resultToken!,
        expectedRequestID: auth.requestID
    )
} else if result.reason == "no_proof" {
    // The authentication may have SUCCEEDED and been billed — the relay just carried no proof.
    // Reconcile /result or the backend callback BEFORE starting OTP, or you charge twice.
    await reconcileThenMaybeOtp(auth.requestID)
} else {
    // result.reason: "closed" (cancel) | "busy" | "invalid_url" | "start_failed"
    //                | "failed" | <server code>
    await runOtpFallback()
}

import AuthenticationServices
import UIKit

// ASWebAuthenticationSession must be RETAINED for its lifetime (a local is deallocated before the
// callback) and, on iOS 13+, given a presentation anchor — then started. A stored property on a
// presentation-context provider is the minimal correct shape:
final class PasskeyLauncher: NSObject, ASWebAuthenticationPresentationContextProviding {
    private var session: ASWebAuthenticationSession?

    func start(ceremonyToken: String) {
        let url = URL(string: "https://auth.akedly.io/pk?token=\(ceremonyToken)&returnUrl=myapp://akedly-passkey")!
        let session = ASWebAuthenticationSession(url: url, callbackURLScheme: "myapp") { callbackURL, _ in
            guard let callbackURL else { return } // nil on user-cancel — fall back to OTP
            // callbackURL = myapp://akedly-passkey?verified=true&transactionId=…
            // (resultToken rides ONLY if your backend signed returnTarget into the ceremony token)
            let result = AkedlyPasskeyCeremony.parseResult(from: callbackURL) // or parse the query yourself
            _ = result
        }
        session.presentationContextProvider = self        // iOS 13+ requires an anchor
        session.prefersEphemeralWebBrowserSession = false // share the device passkey store
        self.session = session                            // retain until the callback fires
        session.start()                                   // actually open the ceremony
    }

    func presentationAnchor(for _: ASWebAuthenticationSession) -> ASPresentationAnchor {
        UIApplication.shared.connectedScenes
            .compactMap { $0 as? UIWindowScene }
            .first { $0.activationState == .foregroundActive }?
            .windows.first { $0.isKeyWindow } ?? ASPresentationAnchor()
    }
}

import SwiftUI
import AkedlyShield

// Calls YOUR backend proxy; see Quick Start for the Node.js server.
let backendUrl = "https://yourapp.com"

struct OTPView: View {
    let phoneNumber: String
    // Supply the same 4, 5, or 6 value configured by your backend.
    let otpLength: Int

    @State private var transactionReqID: String?
    @State private var otp = ""
    @State private var loading = false
    @State private var error: String?

    var body: some View {
        VStack(spacing: 20) {
            if transactionReqID == nil {
                Text("Send OTP to \(phoneNumber)")
                Button(loading ? "Sending..." : "Send OTP") {
                    Task { await sendOTP() }
                }
                .disabled(loading)
            } else {
                TextField("Enter \(otpLength)-digit OTP", text: $otp)
                    .keyboardType(.numberPad)
                    .textFieldStyle(.roundedBorder)
                Button(loading ? "Verifying..." : "Verify") {
                    Task { await verifyOTP() }
                }
                .disabled(loading || otp.count < otpLength)
            }
            if let error {
                Text(error).foregroundColor(.red)
            }
        }
        .padding()
    }

    func sendOTP() async {
        loading = true
        error = nil
        do {
            let url = URL(string: "\(backendUrl)/auth/akedly/challenge")!
            let (data, _) = try await URLSession.shared.data(from: url)
            let json = try JSONSerialization.jsonObject(with: data) as! [String: Any]
            let d = json["data"] as! [String: Any]

            var powSolution: [String: Any]?
            if d["challengeRequired"] as? Bool == true,
               let challenge = d["challenge"] as? String,
               let difficulty = d["difficulty"] as? Int,
               let challengeToken = d["challengeToken"] as? String {
                let nonce = await solvePow(challenge: challenge, difficulty: difficulty)
                powSolution = ["challengeToken": challengeToken, "nonce": nonce]
            }

            var turnstileToken: String?
            if let ts = d["turnstile"] as? [String: Any],
               ts["required"] as? Bool == true {
                turnstileToken = try await AkedlyTurnstile()
                    .getToken(siteKey: ts["siteKey"] as! String)
            }

            var request = URLRequest(url: URL(string: "\(backendUrl)/auth/akedly/send")!)
            request.httpMethod = "POST"
            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
            var body: [String: Any] = ["phoneNumber": phoneNumber]
            if let solution = powSolution { body["powSolution"] = solution }
            if let token = turnstileToken { body["turnstileToken"] = token }
            request.httpBody = try JSONSerialization.data(withJSONObject: body)

            let (resData, _) = try await URLSession.shared.data(for: request)
            let result = try JSONSerialization.jsonObject(with: resData) as! [String: Any]
            transactionReqID = (result["data"] as? [String: Any])?["transactionReqID"] as? String
        } catch {
            self.error = error.localizedDescription
        }
        loading = false
    }

    func verifyOTP() async {
        loading = true
        error = nil
        do {
            var request = URLRequest(url: URL(string: "\(backendUrl)/auth/akedly/verify")!)
            request.httpMethod = "POST"
            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
            request.httpBody = try JSONSerialization.data(withJSONObject: ["transactionReqID": transactionReqID!, "otp": otp])
            let (data, _) = try await URLSession.shared.data(for: request)
            let result = try JSONSerialization.jsonObject(with: data) as! [String: Any]
            if result["status"] as? String == "success" {
                // Handle success
            } else {
                self.error = "Invalid OTP"
            }
        } catch {
            self.error = error.localizedDescription
        }
        loading = false
    }
}

import UIKit
import AkedlyShield

// Calls YOUR backend proxy; see Quick Start for the Node.js server.
let backendUrl = "https://yourapp.com"

class OTPViewController: UIViewController {
    var phoneNumber: String = ""

    private var transactionReqID: String?

    func sendOTP() {
        Task {
            do {
                let url = URL(string: "\(backendUrl)/auth/akedly/challenge")!
                let (data, _) = try await URLSession.shared.data(from: url)
                let json = try JSONSerialization.jsonObject(with: data) as! [String: Any]
                let d = json["data"] as! [String: Any]

                var powSolution: [String: Any]?
                if d["challengeRequired"] as? Bool == true,
                   let challenge = d["challenge"] as? String,
                   let difficulty = d["difficulty"] as? Int,
                   let challengeToken = d["challengeToken"] as? String {
                    let nonce = await solvePow(challenge: challenge, difficulty: difficulty)
                    powSolution = ["challengeToken": challengeToken, "nonce": nonce]
                }

                var body: [String: Any] = ["phoneNumber": phoneNumber]
                if let solution = powSolution { body["powSolution"] = solution }

                if let ts = d["turnstile"] as? [String: Any],
                   ts["required"] as? Bool == true {
                    let token = try await AkedlyTurnstile()
                        .getToken(siteKey: ts["siteKey"] as! String)
                    body["turnstileToken"] = token
                }

                var request = URLRequest(url: URL(string: "\(backendUrl)/auth/akedly/send")!)
                request.httpMethod = "POST"
                request.setValue("application/json", forHTTPHeaderField: "Content-Type")
                request.httpBody = try JSONSerialization.data(withJSONObject: body)

                let (resData, _) = try await URLSession.shared.data(for: request)
                let result = try JSONSerialization.jsonObject(with: resData) as! [String: Any]
                transactionReqID = (result["data"] as? [String: Any])?["transactionReqID"] as? String
            } catch {
                print("Error: \(error)")
            }
        }
    }

    func verifyOTP(_ otp: String) {
        guard let transactionReqID else { return }
        Task {
            var request = URLRequest(url: URL(string: "\(backendUrl)/auth/akedly/verify")!)
            request.httpMethod = "POST"
            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
            request.httpBody = try JSONSerialization.data(withJSONObject: ["transactionReqID": transactionReqID, "otp": otp])
            let (data, _) = try await URLSession.shared.data(for: request)
            let result = try JSONSerialization.jsonObject(with: data) as! [String: Any]
            if result["status"] as? String == "success" {
                // Handle success
            }
        }
    }
}