Prompt Your LLM: iOS / Swift

I need to integrate Akedly Shield V1.2 OTP authentication into my iOS application.

## Architecture: keep APIKey on the backend

APIKey and pipelineID are credentials. They MUST NOT be compiled into an iOS app bundle — bundles can be inspected and anything inside is public.
My backend exposes three thin proxy routes that the iOS app will call:
  GET  /auth/akedly/challenge
  POST /auth/akedly/send            body: { phoneNumber, powSolution, turnstileToken? }
  POST /auth/akedly/verify          body: { transactionReqID, otp }

The Swift code you generate must ONLY call these three routes.
Never reference APIKey or pipelineID in Swift. Never call api.akedly.io from the client.

## Reference backend (Node.js / Express) — drop in if I don't have one yet

import express from 'express';

const app = express();
app.use(express.json());
// Optional: only needed if you want per-end-user-IP rate limiting (drop
// this line and the x-end-user-ip header below if you don't). Makes req.ip
// the real client IP behind Cloudflare / Vercel / AWS ALB / Nginx.
app.set('trust proxy', 1);

app.get('/auth/akedly/challenge', async (_req, res) => {
  const r = await fetch(
    `https://api.akedly.io/api/v1.2/transactions/challenge` +
    `?APIKey=${process.env.AKEDLY_API_KEY}` +
    `&pipelineID=${process.env.AKEDLY_PIPELINE_ID}`
  );
  res.status(r.status).json(await r.json());
});

app.post('/auth/akedly/send', async (req, res) => {
  const { phoneNumber, powSolution, turnstileToken } = req.body;
  const r = await fetch('https://api.akedly.io/api/v1.2/transactions/send', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'x-end-user-ip': req.ip },
    body: JSON.stringify({
      APIKey: process.env.AKEDLY_API_KEY,
      pipelineID: process.env.AKEDLY_PIPELINE_ID,
      verificationAddress: { phoneNumber },
      powSolution,
      turnstileToken,
    }),
  });
  res.status(r.status).json(await r.json());
});

app.post('/auth/akedly/verify', async (req, res) => {
  const { transactionReqID, otp } = req.body;
  const r = await fetch('https://api.akedly.io/api/v1.2/transactions/verify', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ transactionReqID, otp }),
  });
  res.status(r.status).json(await r.json());
});

## Challenge response shape (what iOS receives from /auth/akedly/challenge)

{ status, data: { challenge, difficulty, challengeToken, challengeRequired, turnstile: { required, siteKey } } }

## Frontend flow

1. GET {backendUrl}/auth/akedly/challenge
2. Solve PoW on-device: `let nonce = await solvePow(challenge: challenge, difficulty: difficulty)`
   Algorithm: SHA256(challenge + ":" + nonce) must start with `difficulty` leading hex zeros.
3. If turnstile.required: `let token = try await AkedlyTurnstile().getToken(siteKey: siteKey)`
4. POST {backendUrl}/auth/akedly/send   body: { phoneNumber, powSolution: { challengeToken, nonce }, turnstileToken? }
   Response: { status, data: { transactionReqID } }
5. POST {backendUrl}/auth/akedly/verify   body: { transactionReqID, otp: "123456" }

## SDK: AkedlyShield (v1.0.0)

Install via SPM: https://github.com/Akedly-Org/akedly-shield-swift (from: "1.0.0")
Requires iOS 13+ (CryptoKit)

Key functions:
- solvePow(challenge: String, difficulty: Int) async -> Int (background thread via Task.detached)
- solvePowSync(challenge: String, difficulty: Int) -> Int (blocking, use on background queue only)
- AkedlyTurnstile(bridgeDomain: String = "turnstile.akedly.io")
  .getToken(siteKey: String) async throws -> String (hidden WKWebView)

## Requirements

Please generate a complete integration with:
- SwiftUI view with the full OTP flow that ONLY talks to my backend
- URLSession for the three backend calls
- Async/await throughout
- Error handling and loading states
- Phone number input and OTP verification UI
- A top-level `let backendUrl = "https://yourapp.com"` the user can change
- Clean Swift concurrency patterns
- No APIKey and no pipelineID anywhere in Swift code