Guardian Approval

// On your secure server. Call this AFTER /initiate-transfer or /initiate-send returns.
// It returns the final approval state, or null if the response was 200/201 (no gate).
async function handleInitiateResponse(initiateResponse, transactionId) {
  // 200/201 → no guardian needed. Proceed with normal verify flow.
  if (initiateResponse.status !== 202) return null;

  const body = await initiateResponse.json();
  if (body.status !== 'pending_guardian_approval') return null;

  const expiresAt = new Date(body.guardian_approval.expires_at);
  const pollUrl = `https://invo.network${body.guardian_approval.poll_endpoint}`;

  while (Date.now() < expiresAt.getTime()) {
    await new Promise(r => setTimeout(r, 7000)); // 7s cadence (within 5-10s recommended)

    const statusRes = await fetch(pollUrl, {
      headers: { 'X-Game-Secret-Key': process.env.INVO_SDK_KEY },
    });
    const statusBody = await statusRes.json();
    const state = statusBody.approval?.state;

    if (state === 'approved')  return 'approved';
    if (state === 'rejected')  return 'rejected';
    if (state === 'expired')   return 'expired';
    // state === 'pending' → keep polling
  }

  return 'expired'; // safety net
}

// Wiring it into your transfer flow:
async function startTransfer(payload) {
  const initRes = await fetch('https://invo.network/api/transfers/initiate-transfer', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-Game-Secret-Key': process.env.INVO_SDK_KEY,
    },
    body: JSON.stringify(payload),
  });

  const body = await initRes.json();
  const transactionId = body.transaction_id;

  // Notify your client immediately so it can show "waiting for parent" UI.
  if (initRes.status === 202) {
    notifyClient(transactionId, { phase: 'pending_guardian', expires_at: body.guardian_approval.expires_at });

    const finalState = await handleInitiateResponse(initRes, transactionId);
    if (finalState === 'rejected' || finalState === 'expired') {
      notifyClient(transactionId, { phase: 'guardian_terminal', state: finalState });
      return;
    }
    notifyClient(transactionId, { phase: 'guardian_approved' });
  }

  // Approved (or no gate) → proceed with the standard SMS PIN flow.
  // /verify-sms can now be called normally; it will succeed.
}

// MUST run on your secure server, not the Unity client.
// Call after InitiateTransfer returns and you've parsed the response.

public IEnumerator PollGuardianApproval(string transactionId, DateTime expiresAt,
    Action<string> onApproved,
    Action<string> onTerminal /* "rejected" | "expired" */)
{
    string url = 
quot;https://invo.network/api/transactions/{transactionId}/approval-status";

    while (DateTime.UtcNow < expiresAt)
    {
        yield return new WaitForSeconds(7f); // 7s cadence

        using (UnityWebRequest req = UnityWebRequest.Get(url))
        {
            req.SetRequestHeader("X-Game-Secret-Key", "your_game_secret_key_here");
            yield return req.SendWebRequest();

            if (req.result != UnityWebRequest.Result.Success) continue; // network blip; keep polling

            // Parse: {"status":"ok","approval":{"state":"pending"|"approved"|"rejected"|"expired",...}}
            var body = JsonUtility.FromJson<ApprovalStatusResponse>(req.downloadHandler.text);
            string state = body.approval.state;

            if (state == "approved")              { onApproved?.Invoke(transactionId); yield break; }
            if (state == "rejected" || state == "expired") { onTerminal?.Invoke(state);  yield break; }
            // state == "pending" → keep polling
        }
    }
    onTerminal?.Invoke("expired"); // safety net
}

[Serializable] public class ApprovalStatusResponse {
    public string status;
    public ApprovalRow approval;
}
[Serializable] public class ApprovalRow {
    public string approval_id;
    public string transaction_id;
    public string state;
    public string expires_at;
    public string decided_at;
    public string decision_source;
    public string action_description;
}

// MUST run on your secure server. Schedule a recurring HTTP poll until
// terminal state or expiry.

void AYourGameMode::PollGuardianApproval(const FString& TransactionId, const FDateTime& ExpiresAt)
{
    if (FDateTime::UtcNow() >= ExpiresAt)
    {
        OnGuardianTerminal(TransactionId, TEXT("expired"));
        return;
    }

    FString Url = FString::Printf(
        TEXT("https://invo.network/api/transactions/%s/approval-status"),
        *TransactionId);

    TSharedRef<IHttpRequest> Req = FHttpModule::Get().CreateRequest();
    Req->SetURL(Url);
    Req->SetVerb("GET");
    Req->SetHeader("X-Game-Secret-Key", "your_game_secret_key_here");

    Req->OnProcessRequestComplete().BindLambda(
        [this, TransactionId, ExpiresAt](FHttpRequestPtr R, FHttpResponsePtr Resp, bool bOk) {
            if (!bOk || !Resp.IsValid()) {
                // network blip; reschedule
                GetWorld()->GetTimerManager().SetTimer(PollHandle,
                    FTimerDelegate::CreateUObject(this, &AYourGameMode::PollGuardianApproval, TransactionId, ExpiresAt),
                    7.0f, false);
                return;
            }

            TSharedPtr<FJsonObject> Body;
            TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(Resp->GetContentAsString());
            FJsonSerializer::Deserialize(Reader, Body);

            FString State = Body->GetObjectField("approval")->GetStringField("state");
            if (State == "approved")               { OnGuardianApproved(TransactionId); return; }
            if (State == "rejected" || State == "expired") { OnGuardianTerminal(TransactionId, State); return; }

            // pending → reschedule another poll in 7s
            GetWorld()->GetTimerManager().SetTimer(PollHandle,
                FTimerDelegate::CreateUObject(this, &AYourGameMode::PollGuardianApproval, TransactionId, ExpiresAt),
                7.0f, false);
        });

    Req->ProcessRequest();
}

# MUST run on your secure server.
# Returns "approved", "rejected", or "expired".

func poll_guardian_approval(transaction_id: String, expires_at_iso: String) -> String:
    var expires_at_unix = Time.get_unix_time_from_datetime_string(expires_at_iso)
    var url = "https://invo.network/api/transactions/%s/approval-status" % transaction_id
    var headers = ["X-Game-Secret-Key: your_game_secret_key_here"]

    while Time.get_unix_time_from_system() < expires_at_unix:
        await get_tree().create_timer(7.0).timeout

        var req = HTTPRequest.new()
        add_child(req)
        var err = req.request(url, headers, HTTPClient.METHOD_GET)
        if err != OK:
            req.queue_free()
            continue

        var result = await req.request_completed
        var body_str = result[3].get_string_from_utf8()
        var body = JSON.parse_string(body_str)
        req.queue_free()

        var state = body.get("approval", {}).get("state", "")
        if state == "approved":
            return "approved"
        if state == "rejected" or state == "expired":
            return state
        # state == "pending" → keep polling

    return "expired"

// /verify-sms can return:
//   200 → success, transfer proceeds
//   202 + GUARDIAN_APPROVAL_PENDING → guardian still hasn't replied; same call works once approved
//   410 + GUARDIAN_APPROVAL_REJECTED | GUARDIAN_APPROVAL_EXPIRED → terminal
//   400/4xx → existing PIN errors (wrong code, expired PIN, etc.) — handle as today

const verifyRes = await fetch('https://invo.network/api/transfers/verify-sms', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', 'X-Game-Secret-Key': SDK_KEY },
  body: JSON.stringify({ transaction_id: txnId, sms_pin: pin }),
});

if (verifyRes.status === 200) {
  // success — show claim instructions, etc.
} else if (verifyRes.status === 202) {
  // guardian still pending — start polling /approval-status if not already
} else if (verifyRes.status === 410) {
  const body = await verifyRes.json();
  // body.error_code is GUARDIAN_APPROVAL_REJECTED or GUARDIAN_APPROVAL_EXPIRED
  // Show terminal message; user must re-initiate with a fresh client_request_id
} else {
  // existing 400-class PIN errors
}