Android / Kotlin Shield SDK

dependencyResolutionManagement {
    repositories {
        mavenCentral()
        google()
        maven { url = uri("https://jitpack.io") }
    }
}

dependencies {
    implementation("com.github.Akedly-Org:akedly-shield-kotlin:1.1.0")
}

git clone https://github.com/Akedly-Org/akedly-shield-kotlin.git

include(":akedly-shield")
project(":akedly-shield").projectDir = file("../akedly-shield-kotlin")

dependencies {
    implementation(project(":akedly-shield"))
}

import com.akedly.shield.AkedlyPasskey

// verify.data.enrollmentToken came back from your /verify proxy. For the enrollment RESULT to
// carry a resultToken, that /verify call must also have passed
//   "returnTarget": { "url": "myapp://akedly-passkey" }
// Without it the passkey is still created, but the redirect is token-stripped and the SDK
// reports verified:false / no_proof — treat the enroll result as advisory in that case.
val enrollmentToken = verify.getJSONObject("data").optString("enrollmentToken")
if (enrollmentToken.isNotEmpty()) {
    // Launch the hosted ceremony; the result returns to your redirect Activity (below).
    AkedlyPasskey.launch(context, enrollmentToken, callbackScheme = "myapp")
}

import com.akedly.shield.AkedlyPasskey

// Your backend → POST /transactions/passkey/auth-options
//   { APIKey, pipelineID, verificationAddress: { phoneNumber }, powSolution?, turnstileToken?,
//     returnTarget: { url: "myapp://akedly-passkey" } }   // <-- REQUIRED for the resultToken
//   → { data: { ceremonyToken, requestID } }
val auth = myBackend.startPasskeyAuth(phone) ?: return fallbackToOtp() // 404 NO_PASSKEY
myAuthStore.expectedPasskeyRequestID = auth.requestID

AkedlyPasskey.launch(context, auth.ceremonyToken, callbackScheme = "myapp")
// for QA against a local ceremony origin:
// AkedlyPasskey.launch(context, auth.ceremonyToken, "myapp", ceremonyOrigin = "https://localhost:5174")

val data = intent?.data ?: run { finish(); return } // null when launched without a deep link
val result = AkedlyPasskey.parseResult(data)
if (!result.verified) {
    if (result.reason == "no_proof") {
        reconcilePasskeyResult(result.transactionId)
    } else {
        fallbackToOtp()
    }
}

https://auth.akedly.io/pk?token=&returnUrl=myapp://akedly-passkey
   -> redirects to: myapp://akedly-passkey?verified=true&transactionId=…
      (resultToken ONLY if your backend signed returnTarget into the ceremony token)

import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import com.akedly.shield.*
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.json.JSONObject
import java.net.URL

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

@Composable
fun OTPScreen(
    phoneNumber: String,
    // Supply the same 4, 5, or 6 value configured by your backend.
    otpLength: Int,
    onSuccess: () -> Unit
) {
    val context = LocalContext.current
    val scope = rememberCoroutineScope()
    var transactionReqID by remember { mutableStateOf<String?>(null) }
    var otp by remember { mutableStateOf("") }
    var loading by remember { mutableStateOf(false) }
    var error by remember { mutableStateOf<String?>(null) }

    Column(
        modifier = Modifier.fillMaxWidth().padding(16.dp),
        verticalArrangement = Arrangement.spacedBy(16.dp)
    ) {
        if (transactionReqID == null) {
            Text("Send OTP to $phoneNumber")
            Button(
                onClick = {
                    scope.launch {
                        loading = true
                        error = null
                        try {
                            val json = withContext(Dispatchers.IO) {
                                URL("$BACKEND_URL/auth/akedly/challenge").readText()
                            }
                            val data = JSONObject(json).getJSONObject("data")

                            var powSolution: JSONObject? = null
                            if (data.optBoolean("challengeRequired", false)) {
                                val nonce = solvePow(
                                    data.getString("challenge"),
                                    data.getInt("difficulty")
                                )
                                powSolution = JSONObject().apply {
                                    put("challengeToken", data.getString("challengeToken"))
                                    put("nonce", nonce)
                                }
                            }

                            var turnstileToken: String? = null
                            val ts = data.optJSONObject("turnstile")
                            if (ts?.optBoolean("required") == true) {
                                turnstileToken = withContext(Dispatchers.Main) {
                                    AkedlyTurnstile(context).getToken(ts.getString("siteKey"))
                                }
                            }

                            val body = JSONObject().apply {
                                put("phoneNumber", phoneNumber)
                                powSolution?.let { put("powSolution", it) }
                                turnstileToken?.let { put("turnstileToken", it) }
                            }

                            // POST body to "$BACKEND_URL/auth/akedly/send"
                            // transactionReqID = result.data.transactionReqID
                        } catch (e: Exception) {
                            error = e.message
                        }
                        loading = false
                    }
                },
                enabled = !loading
            ) {
                Text(if (loading) "Sending..." else "Send OTP")
            }
        } else {
            OutlinedTextField(
                value = otp,
                onValueChange = { if (it.length <= otpLength) otp = it },
                label = { Text("Enter OTP") }
            )
            Button(
                onClick = {
                    scope.launch {
                        loading = true
                        error = null
                        // POST to "$BACKEND_URL/auth/akedly/verify" with { transactionReqID, otp }
                        // On success: onSuccess()
                        loading = false
                    }
                },
                enabled = !loading && otp.length >= otpLength
            ) {
                Text(if (loading) "Verifying..." else "Verify")
            }
        }

        error?.let {
            Text(it, color = MaterialTheme.colorScheme.error)
        }
    }
}

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.akedly.shield.*
import kotlinx.coroutines.*

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

class OTPActivity : AppCompatActivity() {
    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
    private var transactionReqID: String? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // setContentView(R.layout.activity_otp)

        // sendButton.setOnClickListener { sendOTP() }
        // verifyButton.setOnClickListener { verifyOTP() }
    }

    private fun sendOTP() {
        scope.launch {
            val json = withContext(Dispatchers.IO) {
                java.net.URL("$BACKEND_URL/auth/akedly/challenge").readText()
            }
            val data = org.json.JSONObject(json).getJSONObject("data")

            var powSolution: JSONObject? = null
            if (data.optBoolean("challengeRequired", false)) {
                val nonce = solvePow(
                    data.getString("challenge"),
                    data.getInt("difficulty")
                )
                powSolution = JSONObject().apply {
                    put("challengeToken", data.getString("challengeToken"))
                    put("nonce", nonce)
                }
            }

            var turnstileToken: String? = null
            val ts = data.optJSONObject("turnstile")
            if (ts?.optBoolean("required") == true) {
                turnstileToken = AkedlyTurnstile(this@OTPActivity)
                    .getToken(ts.getString("siteKey"))
            }

            // POST to "$BACKEND_URL/auth/akedly/send" with { phoneNumber, powSolution?, turnstileToken? }
            // Save transactionReqID from response: result.data.transactionReqID
        }
    }

    private fun verifyOTP() {
        val otp = "" // Get from EditText
        scope.launch {
            // POST to "$BACKEND_URL/auth/akedly/verify" with { transactionReqID, otp }
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        scope.cancel()
    }
}