@authon/react-native-wallet 0.0.0-stage → 0.1.0

package/android/src/vendor/kotlin/dev/authon/sdk/wallet/Eip712.kt

@@ -0,0 +1,176 @@
+// GENERATED by scripts/sync-native-wallet.mjs from kotlin/authon/src/main/kotlin/dev/authon/sdk/wallet/Eip712.kt. Do not edit: change the source and run the script.
+package dev.authon.sdk.wallet
+
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.contentOrNull
+import org.web3j.crypto.Hash
+import org.web3j.crypto.Keys
+import java.math.BigInteger
+
+/**
+ * EIP-712 v4 hashing with viem's rules (hashTypedData): the EIP712Domain type is derived from the
+ * domain fields present unless the request supplies one, dependencies are sorted, arrays hash the
+ * concatenated element encodings, and signed integers are 256-bit two's complement. Keccak comes
+ * from web3j; only the encoding is assembled here.
+ */
+internal object Eip712 {
+    data class Field(val name: String, val type: String)
+
+    private val INT_TYPE = Regex("^(u?)int([0-9]*)$")
+    private val BYTES_N = Regex("^bytes([0-9]+)$")
+    private val ADDRESS = Regex("^0x[0-9a-fA-F]{40}$")
+    private val TWO_256: BigInteger = BigInteger.ONE.shiftLeft(256)
+
+    fun hashTypedData(typedData: JsonObject): ByteArray {
+        val domain = typedData["domain"] as? JsonObject ?: JsonObject(emptyMap())
+        val primaryType = (typedData["primaryType"] as? JsonPrimitive)?.contentOrNull
+            ?: throw invalid("primaryType missing")
+        val provided = parseTypes(typedData["types"] as? JsonObject ?: throw invalid("types missing"))
+        val types = LinkedHashMap<String, List<Field>>()
+        types["EIP712Domain"] = domainFields(domain)
+        types.putAll(provided)
+        val parts = mutableListOf(byteArrayOf(0x19, 0x01), hashStruct("EIP712Domain", domain, types))
+        if (primaryType != "EIP712Domain") {
+            val message = typedData["message"] as? JsonObject ?: throw invalid("message missing")
+            parts += hashStruct(primaryType, message, types)
+        }
+        return Hash.sha3(Bytes.concat(*parts.toTypedArray()))
+    }
+
+    fun parseTypes(obj: JsonObject): Map<String, List<Field>> = obj.mapValues { (name, fields) ->
+        (fields as? JsonArray ?: throw invalid("type $name must be an array")).map { f ->
+            val o = f as? JsonObject ?: throw invalid("field of $name must be an object")
+            Field(
+                (o["name"] as? JsonPrimitive)?.contentOrNull ?: throw invalid("field name missing in $name"),
+                (o["type"] as? JsonPrimitive)?.contentOrNull ?: throw invalid("field type missing in $name"),
+            )
+        }
+    }
+
+    /** viem getTypesForEIP712Domain. */
+    private fun domainFields(domain: JsonObject): List<Field> = buildList {
+        val name = domain["name"] as? JsonPrimitive
+        if (name != null && name.isString) add(Field("name", "string"))
+        val version = domain["version"] as? JsonPrimitive
+        if (version != null && truthy(version)) add(Field("version", "string"))
+        val chainId = domain["chainId"] as? JsonPrimitive
+        if (chainId != null && !chainId.isString && chainId.booleanOrNull == null && chainId.contentOrNull != null) {
+            add(Field("chainId", "uint256"))
+        }
+        val vc = domain["verifyingContract"] as? JsonPrimitive
+        if (vc != null && truthy(vc)) add(Field("verifyingContract", "address"))
+        val salt = domain["salt"] as? JsonPrimitive
+        if (salt != null && truthy(salt)) add(Field("salt", "bytes32"))
+    }
+
+    private fun truthy(p: JsonPrimitive): Boolean {
+        val c = p.contentOrNull ?: return false
+        if (p.isString) return c.isNotEmpty()
+        p.booleanOrNull?.let { return it }
+        return c.toBigDecimalOrNull()?.signum() != 0
+    }
+
+    fun encodeType(primaryType: String, types: Map<String, List<Field>>): String {
+        val deps = LinkedHashSet<String>()
+        findDependencies(primaryType, types, deps)
+        val ordered = listOf(primaryType) + deps.filter { it != primaryType }.sorted()
+        return ordered.joinToString("") { t ->
+            "$t(" + types.getValue(t).joinToString(",") { "${it.type} ${it.name}" } + ")"
+        }
+    }
+
+    private fun findDependencies(type: String, types: Map<String, List<Field>>, out: MutableSet<String>) {
+        val base = Regex("^\\w*").find(type)?.value ?: ""
+        if (base in out || types[base] == null) return
+        out += base
+        for (f in types.getValue(base)) findDependencies(f.type, types, out)
+    }
+
+    fun hashStruct(type: String, data: JsonObject, types: Map<String, List<Field>>): ByteArray {
+        val fields = types[type] ?: throw invalid("unknown type $type")
+        val parts = ArrayList<ByteArray>(fields.size + 1)
+        parts += Hash.sha3(Bytes.utf8(encodeType(type, types)))
+        for (f in fields) parts += encodeField(f.type, data[f.name], types)
+        return Hash.sha3(Bytes.concat(*parts.toTypedArray()))
+    }
+
+    private fun encodeField(type: String, value: JsonElement?, types: Map<String, List<Field>>): ByteArray {
+        if (types[type] != null) {
+            val obj = value as? JsonObject ?: throw invalid("$type value must be an object")
+            return hashStruct(type, obj, types)
+        }
+        if (type.endsWith("]")) {
+            val open = type.lastIndexOf('[')
+            val inner = type.substring(0, open)
+            val len = type.substring(open + 1, type.length - 1)
+            val arr = value as? JsonArray ?: throw invalid("$type value must be an array")
+            if (len.isNotEmpty() && len.toIntOrNull() != arr.size) throw invalid("$type expects $len elements")
+            return Hash.sha3(Bytes.concat(*arr.map { encodeField(inner, it, types) }.toTypedArray()))
+        }
+        val p = value as? JsonPrimitive ?: throw invalid("missing value for $type")
+        return when {
+            type == "string" -> {
+                if (!p.isString) throw invalid("string value expected")
+                Hash.sha3(Bytes.utf8(p.content))
+            }
+            type == "bytes" -> {
+                if (!p.isString) throw invalid("hex value expected")
+                Hash.sha3(Bytes.fromHexOrNull(p.content)?.takeIf { p.content.startsWith("0x") } ?: throw invalid("bytes must be 0x hex"))
+            }
+            type == "bool" -> {
+                val b = if (p.isString) null else p.booleanOrNull
+                word(if (b ?: throw invalid("boolean value expected")) BigInteger.ONE else BigInteger.ZERO)
+            }
+            type == "address" -> {
+                val a = p.contentOrNull?.takeIf { p.isString } ?: throw invalid("address expected")
+                word(BigInteger(1, Bytes.fromHex(checkAddress(a))))
+            }
+            INT_TYPE.matches(type) -> {
+                val m = INT_TYPE.find(type)!!
+                val signed = m.groupValues[1].isEmpty()
+                val bits = m.groupValues[2].ifEmpty { "256" }.toInt()
+                if (bits < 8 || bits > 256 || bits % 8 != 0) throw invalid("invalid integer type $type")
+                val v = JsValues.toBigIntOrNull(p) ?: throw invalid("integer value expected for $type")
+                val (min, max) = if (signed) {
+                    BigInteger.ONE.shiftLeft(bits - 1).negate() to BigInteger.ONE.shiftLeft(bits - 1).subtract(BigInteger.ONE)
+                } else {
+                    BigInteger.ZERO to BigInteger.ONE.shiftLeft(bits).subtract(BigInteger.ONE)
+                }
+                if (v < min || v > max) throw invalid("$type value out of range")
+                word(if (v.signum() < 0) v.add(TWO_256) else v)
+            }
+            BYTES_N.matches(type) -> {
+                val n = BYTES_N.find(type)!!.groupValues[1].toInt()
+                if (n < 1 || n > 32) throw invalid("invalid type $type")
+                val bytes = p.contentOrNull?.takeIf { p.isString && it.startsWith("0x") }?.let { Bytes.fromHexOrNull(it) }
+                    ?: throw invalid("$type must be 0x hex")
+                if (bytes.size != n) throw invalid("$type expects $n bytes")
+                bytes.copyOf(32)
+            }
+            else -> throw invalid("unsupported type $type")
+        }
+    }
+
+    /** viem isAddress (strict): mixed-case addresses must carry a valid EIP-55 checksum. */
+    fun checkAddress(address: String): String {
+        if (!ADDRESS.matches(address)) throw invalid("invalid address $address")
+        val body = address.substring(2)
+        val mixed = body.any { it.isUpperCase() } && body.any { it.isLowerCase() }
+        if (mixed && Keys.toChecksumAddress(address) != address) throw invalid("address checksum mismatch $address")
+        return address
+    }
+
+    private fun word(v: BigInteger): ByteArray {
+        val raw = v.toByteArray()
+        val out = ByteArray(32)
+        val src = if (raw.size > 32) raw.copyOfRange(raw.size - 32, raw.size) else raw
+        src.copyInto(out, 32 - src.size)
+        return out
+    }
+
+    private fun invalid(message: String) = walletError(WalletErrorCode.INVALID_REQUEST, message)
+}

package/android/src/vendor/kotlin/dev/authon/sdk/wallet/EvmAccount.kt

@@ -0,0 +1,45 @@
+// GENERATED by scripts/sync-native-wallet.mjs from kotlin/authon/src/main/kotlin/dev/authon/sdk/wallet/EvmAccount.kt. Do not edit: change the source and run the script.
+package dev.authon.sdk.wallet
+
+import kotlinx.serialization.json.JsonObject
+import org.web3j.crypto.ECKeyPair
+import org.web3j.crypto.Hash
+import org.web3j.crypto.Keys
+import org.web3j.crypto.Sign
+
+/**
+ * secp256k1 account backed by web3j (RFC 6979 deterministic, low-s), producing the same bytes as
+ * viem's privateKeyToAccount: signatures are r||s||v with v = 27/28.
+ * web3j keeps the key as a BigInteger, which cannot be wiped; the object is short-lived.
+ */
+internal class EvmAccount(privateKey: ByteArray) {
+    private val keyPair: ECKeyPair = ECKeyPair.create(privateKey)
+
+    val address: String = Keys.toChecksumAddress(Keys.getAddress(keyPair.publicKey))
+
+    class Signature(val r: ByteArray, val s: ByteArray, val yParity: Int) {
+        fun toHex(): String = "0x" + Bytes.toHex(Bytes.concat(r, s, byteArrayOf((27 + yParity).toByte())))
+    }
+
+    fun signDigest(digest: ByteArray): Signature {
+        require(digest.size == 32) { "digest must be 32 bytes" }
+        val sig = Sign.signMessage(digest, keyPair, false)
+        val v = sig.v[0].toInt() and 0xff
+        return Signature(sig.r, sig.s, v - 27)
+    }
+
+    /** personal_sign (EIP-191 version 0x45) over raw bytes. */
+    fun signMessage(message: ByteArray): String = signDigest(personalMessageHash(message)).toHex()
+
+    fun signTypedData(typedData: JsonObject): String = signDigest(Eip712.hashTypedData(typedData)).toHex()
+
+    fun signTransaction(tx: EvmTransaction): String {
+        val sig = signDigest(Hash.sha3(tx.serialize(null)))
+        return "0x" + Bytes.toHex(tx.serialize(sig))
+    }
+
+    companion object {
+        fun personalMessageHash(message: ByteArray): ByteArray =
+            Hash.sha3(Bytes.concat(Bytes.utf8("\u0019Ethereum Signed Message:\n${message.size}"), message))
+    }
+}

package/android/src/vendor/kotlin/dev/authon/sdk/wallet/EvmTransaction.kt

@@ -0,0 +1,180 @@
+// GENERATED by scripts/sync-native-wallet.mjs from kotlin/authon/src/main/kotlin/dev/authon/sdk/wallet/EvmTransaction.kt. Do not edit: change the source and run the script.
+package dev.authon.sdk.wallet
+
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.contentOrNull
+import org.web3j.rlp.RlpEncoder
+import org.web3j.rlp.RlpList
+import org.web3j.rlp.RlpString
+import org.web3j.rlp.RlpType
+import java.math.BigInteger
+
+/**
+ * EVM transaction in the frame's input shape (parseTransaction + viem), serialized exactly like
+ * viem's serializeTransaction for legacy (EIP-155), EIP-2930 and EIP-1559, including contract
+ * creation. RLP comes from web3j.
+ */
+internal class EvmTransaction(
+    val type: Type,
+    val chainId: Long,
+    val nonce: Long?,
+    val gas: BigInteger?,
+    val gasPrice: BigInteger?,
+    val maxFeePerGas: BigInteger?,
+    val maxPriorityFeePerGas: BigInteger?,
+    /** Null for a contract creation. */
+    val to: String?,
+    val value: BigInteger?,
+    val data: ByteArray,
+    val accessList: List<AccessListEntry>,
+    /** The parsed request as the approval summary sees it. */
+    val fields: JsonObject,
+) {
+    enum class Type { LEGACY, EIP2930, EIP1559 }
+
+    class AccessListEntry(val address: String, val storageKeys: List<ByteArray>)
+
+    fun serialize(signature: EvmAccount.Signature?): ByteArray {
+        val items = ArrayList<RlpType>()
+        fun num(v: BigInteger?) = RlpString.create(v ?: BigInteger.ZERO)
+        fun numL(v: Long?) = RlpString.create(BigInteger.valueOf(v ?: 0L))
+        val toItem = RlpString.create(to?.let { Bytes.fromHex(it) } ?: ByteArray(0))
+        val accessItems: RlpType = RlpList(
+            accessList.map { e ->
+                RlpList(RlpString.create(Bytes.fromHex(e.address)), RlpList(e.storageKeys.map { RlpString.create(it) }))
+            },
+        )
+        when (type) {
+            Type.LEGACY -> {
+                items += listOf(numL(nonce), num(gasPrice), num(gas), toItem, num(value), RlpString.create(data))
+                if (signature != null) {
+                    val v = if (chainId > 0) {
+                        BigInteger.valueOf(chainId).multiply(BigInteger.TWO).add(BigInteger.valueOf(35L + signature.yParity))
+                    } else {
+                        BigInteger.valueOf(27L + signature.yParity)
+                    }
+                    items += listOf(RlpString.create(v), sigInt(signature.r), sigInt(signature.s))
+                } else if (chainId > 0) {
+                    items += listOf(numL(chainId), RlpString.create(ByteArray(0)), RlpString.create(ByteArray(0)))
+                }
+                return RlpEncoder.encode(RlpList(items))
+            }
+            Type.EIP2930 -> {
+                items += listOf(numL(chainId), numL(nonce), num(gasPrice), num(gas), toItem, num(value), RlpString.create(data), accessItems)
+            }
+            Type.EIP1559 -> {
+                items += listOf(
+                    numL(chainId), numL(nonce), num(maxPriorityFeePerGas), num(maxFeePerGas), num(gas), toItem, num(value),
+                    RlpString.create(data), accessItems,
+                )
+            }
+        }
+        if (signature != null) {
+            items += listOf(RlpString.create(BigInteger.valueOf(signature.yParity.toLong())), sigInt(signature.r), sigInt(signature.s))
+        }
+        val prefix: Byte = if (type == Type.EIP2930) 0x01 else 0x02
+        return byteArrayOf(prefix) + RlpEncoder.encode(RlpList(items))
+    }
+
+    private fun sigInt(bytes: ByteArray) = RlpString.create(BigInteger(1, bytes))
+
+    companion object {
+        private val BIGINT_FIELDS = listOf("value", "gas", "gasPrice", "maxFeePerGas", "maxPriorityFeePerGas", "maxFeePerBlobGas")
+        private val NUMBER_FIELDS = listOf("nonce", "chainId")
+        private val MAX_UINT256: BigInteger = BigInteger.ONE.shiftLeft(256).subtract(BigInteger.ONE)
+
+        /** The frame's parseTransaction followed by viem's type inference and assertions. */
+        fun parse(input: JsonObject): EvmTransaction {
+            val tx = LinkedHashMap<String, JsonElement>(input)
+            val big = HashMap<String, BigInteger>()
+            for (f in BIGINT_FIELDS + NUMBER_FIELDS) {
+                val raw = tx[f] ?: continue
+                if (raw is JsonNull) continue
+                val v = JsValues.toBigIntOrNull(raw) ?: throw invalid("transaction numeric field invalid")
+                big[f] = v
+                tx[f] = JsonPrimitive(v)
+            }
+            val chainIdBig = big["chainId"] ?: throw invalid("chainId required")
+            val chainId = chainIdBig.toLong()
+            val nonce = big["nonce"]?.toLong()
+
+            val explicit = (tx["type"] as? JsonPrimitive)?.contentOrNull
+            val type = when (explicit) {
+                null -> when {
+                    big["maxFeePerBlobGas"] != null || tx["blobs"].present() || tx["blobVersionedHashes"].present() ->
+                        throw walletError(WalletErrorCode.UNSUPPORTED_TYPE, "blob transactions are not supported")
+                    tx["authorizationList"].present() ->
+                        throw walletError(WalletErrorCode.UNSUPPORTED_TYPE, "EIP-7702 transactions are not supported")
+                    big["maxFeePerGas"] != null || big["maxPriorityFeePerGas"] != null -> Type.EIP1559
+                    big["gasPrice"] != null -> if (tx["accessList"].present()) Type.EIP2930 else Type.LEGACY
+                    else -> throw invalid("cannot infer the transaction type")
+                }
+                "legacy", "0x0" -> Type.LEGACY
+                "eip2930", "0x1" -> Type.EIP2930
+                "eip1559", "0x2" -> Type.EIP1559
+                else -> throw walletError(WalletErrorCode.UNSUPPORTED_TYPE, "transaction type $explicit is not supported")
+            }
+
+            val toRaw = tx["to"]
+            val to = when {
+                toRaw == null || toRaw is JsonNull -> null
+                toRaw is JsonPrimitive && toRaw.isString && toRaw.content.isEmpty() -> null
+                toRaw is JsonPrimitive && toRaw.isString -> Eip712.checkAddress(toRaw.content)
+                else -> throw invalid("to must be an address")
+            }
+            val dataRaw = tx["data"]
+            val data = when {
+                dataRaw == null || dataRaw is JsonNull -> ByteArray(0)
+                dataRaw is JsonPrimitive && dataRaw.isString && dataRaw.content.startsWith("0x") ->
+                    Bytes.fromHexOrNull(dataRaw.content) ?: throw invalid("data must be hex")
+                else -> throw invalid("data must be 0x hex")
+            }
+            val accessList = parseAccessList(tx["accessList"])
+
+            val gasPrice = big["gasPrice"]
+            val maxFee = big["maxFeePerGas"]
+            val maxTip = big["maxPriorityFeePerGas"]
+            if (chainId <= 0 && type != Type.LEGACY) throw invalid("invalid chainId")
+            if (type == Type.LEGACY && tx["chainId"] != null && chainId <= 0) throw invalid("invalid chainId")
+            when (type) {
+                Type.LEGACY, Type.EIP2930 -> {
+                    if (maxFee != null || maxTip != null) throw invalid("maxFeePerGas/maxPriorityFeePerGas are not valid for this type")
+                    if (gasPrice != null && gasPrice > MAX_UINT256) throw invalid("gasPrice too high")
+                }
+                Type.EIP1559 -> {
+                    if (maxFee != null && maxFee > MAX_UINT256) throw invalid("maxFeePerGas too high")
+                    if (maxTip != null && maxFee != null && maxTip > maxFee) throw invalid("maxPriorityFeePerGas above maxFeePerGas")
+                }
+            }
+            for ((k, v) in big) if (v.signum() < 0) throw invalid("$k must not be negative")
+            if (type == Type.LEGACY && accessList.isNotEmpty()) throw invalid("accessList is not valid for legacy transactions")
+
+            return EvmTransaction(
+                type, chainId, nonce, big["gas"], gasPrice, maxFee, maxTip, to, big["value"], data, accessList, JsonObject(tx),
+            )
+        }
+
+        private fun parseAccessList(raw: JsonElement?): List<AccessListEntry> {
+            if (raw == null || raw is JsonNull) return emptyList()
+            val arr = raw as? JsonArray ?: throw invalid("accessList must be an array")
+            return arr.map { item ->
+                val o = item as? JsonObject ?: throw invalid("accessList entry must be an object")
+                val address = (o["address"] as? JsonPrimitive)?.contentOrNull ?: throw invalid("accessList address missing")
+                val keys = (o["storageKeys"] as? JsonArray ?: JsonArray(emptyList())).map { k ->
+                    val hex = (k as? JsonPrimitive)?.contentOrNull ?: throw invalid("storage key must be hex")
+                    if (hex.length != 66) throw invalid("storage key must be 32 bytes")
+                    Bytes.fromHexOrNull(hex) ?: throw invalid("storage key must be hex")
+                }
+                AccessListEntry(Eip712.checkAddress(address), keys)
+            }
+        }
+
+        private fun JsonElement?.present(): Boolean = this != null && this !is JsonNull
+
+        private fun invalid(message: String) = walletError(WalletErrorCode.INVALID_REQUEST, message)
+    }
+}

package/android/src/vendor/kotlin/dev/authon/sdk/wallet/GfTables.kt

@@ -0,0 +1,44 @@
+// GENERATED by scripts/sync-native-wallet.mjs from kotlin/authon/src/main/kotlin/dev/authon/sdk/wallet/GfTables.kt. Do not edit: change the source and run the script.
+package dev.authon.sdk.wallet
+
+// GF(2^8) tables of the shamir-secret-sharing JS library (polynomial x^8+x^4+x^3+x+1, generator 0xe5),
+// copied verbatim so combine/split/deriveShare produce the same bytes as the web frame.
+internal object GfTables {
+    val LOG: IntArray = intArrayOf(
+        0x00, 0xff, 0xc8, 0x08, 0x91, 0x10, 0xd0, 0x36, 0x5a, 0x3e, 0xd8, 0x43, 0x99, 0x77, 0xfe, 0x18,
+        0x23, 0x20, 0x07, 0x70, 0xa1, 0x6c, 0x0c, 0x7f, 0x62, 0x8b, 0x40, 0x46, 0xc7, 0x4b, 0xe0, 0x0e,
+        0xeb, 0x16, 0xe8, 0xad, 0xcf, 0xcd, 0x39, 0x53, 0x6a, 0x27, 0x35, 0x93, 0xd4, 0x4e, 0x48, 0xc3,
+        0x2b, 0x79, 0x54, 0x28, 0x09, 0x78, 0x0f, 0x21, 0x90, 0x87, 0x14, 0x2a, 0xa9, 0x9c, 0xd6, 0x74,
+        0xb4, 0x7c, 0xde, 0xed, 0xb1, 0x86, 0x76, 0xa4, 0x98, 0xe2, 0x96, 0x8f, 0x02, 0x32, 0x1c, 0xc1,
+        0x33, 0xee, 0xef, 0x81, 0xfd, 0x30, 0x5c, 0x13, 0x9d, 0x29, 0x17, 0xc4, 0x11, 0x44, 0x8c, 0x80,
+        0xf3, 0x73, 0x42, 0x1e, 0x1d, 0xb5, 0xf0, 0x12, 0xd1, 0x5b, 0x41, 0xa2, 0xd7, 0x2c, 0xe9, 0xd5,
+        0x59, 0xcb, 0x50, 0xa8, 0xdc, 0xfc, 0xf2, 0x56, 0x72, 0xa6, 0x65, 0x2f, 0x9f, 0x9b, 0x3d, 0xba,
+        0x7d, 0xc2, 0x45, 0x82, 0xa7, 0x57, 0xb6, 0xa3, 0x7a, 0x75, 0x4f, 0xae, 0x3f, 0x37, 0x6d, 0x47,
+        0x61, 0xbe, 0xab, 0xd3, 0x5f, 0xb0, 0x58, 0xaf, 0xca, 0x5e, 0xfa, 0x85, 0xe4, 0x4d, 0x8a, 0x05,
+        0xfb, 0x60, 0xb7, 0x7b, 0xb8, 0x26, 0x4a, 0x67, 0xc6, 0x1a, 0xf8, 0x69, 0x25, 0xb3, 0xdb, 0xbd,
+        0x66, 0xdd, 0xf1, 0xd2, 0xdf, 0x03, 0x8d, 0x34, 0xd9, 0x92, 0x0d, 0x63, 0x55, 0xaa, 0x49, 0xec,
+        0xbc, 0x95, 0x3c, 0x84, 0x0b, 0xf5, 0xe6, 0xe7, 0xe5, 0xac, 0x7e, 0x6e, 0xb9, 0xf9, 0xda, 0x8e,
+        0x9a, 0xc9, 0x24, 0xe1, 0x0a, 0x15, 0x6b, 0x3a, 0xa0, 0x51, 0xf4, 0xea, 0xb2, 0x97, 0x9e, 0x5d,
+        0x22, 0x88, 0x94, 0xce, 0x19, 0x01, 0x71, 0x4c, 0xa5, 0xe3, 0xc5, 0x31, 0xbb, 0xcc, 0x1f, 0x2d,
+        0x3b, 0x52, 0x6f, 0xf6, 0x2e, 0x89, 0xf7, 0xc0, 0x68, 0x1b, 0x64, 0x04, 0x06, 0xbf, 0x83, 0x38,
+    )
+
+    val EXP: IntArray = intArrayOf(
+        0x01, 0xe5, 0x4c, 0xb5, 0xfb, 0x9f, 0xfc, 0x12, 0x03, 0x34, 0xd4, 0xc4, 0x16, 0xba, 0x1f, 0x36,
+        0x05, 0x5c, 0x67, 0x57, 0x3a, 0xd5, 0x21, 0x5a, 0x0f, 0xe4, 0xa9, 0xf9, 0x4e, 0x64, 0x63, 0xee,
+        0x11, 0x37, 0xe0, 0x10, 0xd2, 0xac, 0xa5, 0x29, 0x33, 0x59, 0x3b, 0x30, 0x6d, 0xef, 0xf4, 0x7b,
+        0x55, 0xeb, 0x4d, 0x50, 0xb7, 0x2a, 0x07, 0x8d, 0xff, 0x26, 0xd7, 0xf0, 0xc2, 0x7e, 0x09, 0x8c,
+        0x1a, 0x6a, 0x62, 0x0b, 0x5d, 0x82, 0x1b, 0x8f, 0x2e, 0xbe, 0xa6, 0x1d, 0xe7, 0x9d, 0x2d, 0x8a,
+        0x72, 0xd9, 0xf1, 0x27, 0x32, 0xbc, 0x77, 0x85, 0x96, 0x70, 0x08, 0x69, 0x56, 0xdf, 0x99, 0x94,
+        0xa1, 0x90, 0x18, 0xbb, 0xfa, 0x7a, 0xb0, 0xa7, 0xf8, 0xab, 0x28, 0xd6, 0x15, 0x8e, 0xcb, 0xf2,
+        0x13, 0xe6, 0x78, 0x61, 0x3f, 0x89, 0x46, 0x0d, 0x35, 0x31, 0x88, 0xa3, 0x41, 0x80, 0xca, 0x17,
+        0x5f, 0x53, 0x83, 0xfe, 0xc3, 0x9b, 0x45, 0x39, 0xe1, 0xf5, 0x9e, 0x19, 0x5e, 0xb6, 0xcf, 0x4b,
+        0x38, 0x04, 0xb9, 0x2b, 0xe2, 0xc1, 0x4a, 0xdd, 0x48, 0x0c, 0xd0, 0x7d, 0x3d, 0x58, 0xde, 0x7c,
+        0xd8, 0x14, 0x6b, 0x87, 0x47, 0xe8, 0x79, 0x84, 0x73, 0x3c, 0xbd, 0x92, 0xc9, 0x23, 0x8b, 0x97,
+        0x95, 0x44, 0xdc, 0xad, 0x40, 0x65, 0x86, 0xa2, 0xa4, 0xcc, 0x7f, 0xec, 0xc0, 0xaf, 0x91, 0xfd,
+        0xf7, 0x4f, 0x81, 0x2f, 0x5b, 0xea, 0xa8, 0x1c, 0x02, 0xd1, 0x98, 0x71, 0xed, 0x25, 0xe3, 0x24,
+        0x06, 0x68, 0xb3, 0x93, 0x2c, 0x6f, 0x3e, 0x6c, 0x0a, 0xb8, 0xce, 0xae, 0x74, 0xb1, 0x42, 0xb4,
+        0x1e, 0xd3, 0x49, 0xe9, 0x9c, 0xc8, 0xc6, 0xc7, 0x22, 0x6e, 0xdb, 0x20, 0xbf, 0x43, 0x51, 0x52,
+        0x66, 0xb2, 0x76, 0x60, 0xda, 0xc5, 0xf3, 0xf6, 0xaa, 0xcd, 0x9a, 0xa0, 0x75, 0x54, 0x0e, 0x01,
+    )
+}

package/android/src/vendor/kotlin/dev/authon/sdk/wallet/HdWallet.kt

@@ -0,0 +1,130 @@
+// GENERATED by scripts/sync-native-wallet.mjs from kotlin/authon/src/main/kotlin/dev/authon/sdk/wallet/HdWallet.kt. Do not edit: change the source and run the script.
+package dev.authon.sdk.wallet
+
+import org.web3j.crypto.Bip32ECKeyPair
+import org.web3j.crypto.MnemonicUtils
+import org.web3j.utils.Numeric
+
+/**
+ * The shared secret is BIP39 entropy (16 bytes = 12 words); keys are m/44'/60'/0'/0/{index}.
+ * A 32-byte secret is a raw secp256k1 key from before HD wallets and has only account 0.
+ * Same rules as `apps/wallet/src/shares.ts`.
+ */
+internal object HdWallet {
+    const val HD_ENTROPY_BYTES = 16
+    const val MAX_ACCOUNT_INDEX: Long = 0x7fffffff
+
+    private const val H = Bip32ECKeyPair.HARDENED_BIT
+    private val ACCOUNT_PARENT = intArrayOf(44 or H, 60 or H, 0 or H, 0)
+
+    fun evmPath(index: Long): String = "m/44'/60'/0'/0/$index"
+
+    fun generateSecret(): ByteArray = Bytes.randomBytes(HD_ENTROPY_BYTES)
+
+    fun isHdSecret(secret: ByteArray): Boolean = secret.size == HD_ENTROPY_BYTES
+
+    fun isAccountIndex(index: Long): Boolean = index in 0..MAX_ACCOUNT_INDEX
+
+    fun mnemonicOf(entropy: ByteArray): String = MnemonicUtils.generateMnemonic(entropy)
+
+    /** BIP39 seed (PBKDF2-HMAC-SHA512, 2048 rounds, salt "mnemonic"). Callers wipe it. */
+    fun seedOf(entropy: ByteArray): ByteArray = MnemonicUtils.generateSeed(mnemonicOf(entropy), "")
+
+    private fun accountParent(secret: ByteArray): Bip32ECKeyPair {
+        val seed = seedOf(secret)
+        try {
+            return Bip32ECKeyPair.deriveKeyPair(Bip32ECKeyPair.generateKeyPair(seed), ACCOUNT_PARENT)
+        } finally {
+            seed.fill(0)
+        }
+    }
+
+    /** The EVM private key at account [index]. Callers wipe the result. */
+    fun privateKey(secret: ByteArray, index: Long = 0): ByteArray {
+        if (!isAccountIndex(index)) throw IllegalArgumentException("invalid account index")
+        if (secret.size == 32) {
+            if (index != 0L) throw walletError(WalletErrorCode.ACCOUNT_UNAVAILABLE, "this wallet has only account 0")
+            return secret.copyOf()
+        }
+        if (!isHdSecret(secret)) throw walletError(WalletErrorCode.INTERNAL, "unsupported wallet secret")
+        val node = Bip32ECKeyPair.deriveKeyPair(accountParent(secret), intArrayOf(index.toInt()))
+        return Numeric.toBytesPadded(node.privateKey, 32)
+    }
+
+    fun account(secret: ByteArray, index: Long = 0): EvmAccount {
+        val key = privateKey(secret, index)
+        try {
+            return EvmAccount(key)
+        } finally {
+            key.fill(0)
+        }
+    }
+
+    fun address(secret: ByteArray, index: Long = 0): String = account(secret, index).address
+
+    /** Addresses of accounts start..start+count-1; the seed is derived once for the range. */
+    fun addresses(secret: ByteArray, start: Long, count: Int): List<String> {
+        if (!isAccountIndex(start) || count < 1 || !isAccountIndex(start + count - 1)) {
+            throw IllegalArgumentException("invalid account range")
+        }
+        if (secret.size == 32) {
+            if (start != 0L || count != 1) throw walletError(WalletErrorCode.ACCOUNT_UNAVAILABLE, "this wallet has only account 0")
+            return listOf(address(secret, 0))
+        }
+        if (!isHdSecret(secret)) throw walletError(WalletErrorCode.INTERNAL, "unsupported wallet secret")
+        val parent = accountParent(secret)
+        return (0 until count).map { i ->
+            val node = Bip32ECKeyPair.deriveKeyPair(parent, intArrayOf((start + i).toInt()))
+            val key = Numeric.toBytesPadded(node.privateKey, 32)
+            try {
+                EvmAccount(key).address
+            } finally {
+                key.fill(0)
+            }
+        }
+    }
+
+    class SplitShares(val device: ByteArray, val company: ByteArray, val backup: ByteArray?) {
+        fun wipe() = Bytes.wipe(device, company, backup)
+    }
+
+    fun splitUnprotected(secret: ByteArray): SplitShares {
+        val s = Shamir.split(secret, 2, 2)
+        return SplitShares(s[0], s[1], null)
+    }
+
+    fun splitProtected(secret: ByteArray): SplitShares {
+        val s = Shamir.split(secret, 3, 2)
+        return SplitShares(s[0], s[1], s[2])
+    }
+
+    fun assemble(a: ByteArray, b: ByteArray): ByteArray = Shamir.combine(listOf(a, b))
+
+    /**
+     * One more share on the same 2-of-n polynomial as [a] and [b] (see shares.ts deriveShare):
+     * shifting both x coordinates by x3 and interpolating at zero yields f(x3).
+     */
+    fun deriveShare(a: ByteArray, b: ByteArray, pickX: () -> Int = ::randomX): ByteArray {
+        if (a.size != b.size || a.size < 2) throw IllegalArgumentException("share length mismatch")
+        val xa = a[a.size - 1].toInt() and 0xff
+        val xb = b[b.size - 1].toInt() and 0xff
+        var x3 = 0
+        while (x3 == 0 || x3 == xa || x3 == xb) x3 = pickX() and 0xff
+        val shiftedA = a.copyOf()
+        val shiftedB = b.copyOf()
+        shiftedA[a.size - 1] = (xa xor x3).toByte()
+        shiftedB[b.size - 1] = (xb xor x3).toByte()
+        try {
+            val y = Shamir.combine(listOf(shiftedA, shiftedB))
+            val share = ByteArray(a.size)
+            y.copyInto(share)
+            share[a.size - 1] = x3.toByte()
+            y.fill(0)
+            return share
+        } finally {
+            Bytes.wipe(shiftedA, shiftedB)
+        }
+    }
+
+    private fun randomX(): Int = Bytes.randomBytes(1)[0].toInt() and 0xff
+}

package/android/src/vendor/kotlin/dev/authon/sdk/wallet/Http.kt

@@ -0,0 +1,82 @@
+// GENERATED by scripts/sync-native-wallet.mjs from kotlin/authon/src/main/kotlin/dev/authon/sdk/wallet/Http.kt. Do not edit: change the source and run the script.
+package dev.authon.sdk.wallet
+
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.Response
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+internal class HttpResult(val status: Int, val text: String) {
+    val ok: Boolean get() = status in 200..299
+
+    /** The body as a JSON object; `{}` when it is empty or not an object (like the frame's `asRecord`). */
+    val json: JsonObject by lazy {
+        if (text.isBlank()) {
+            JsonObject(emptyMap())
+        } else {
+            runCatching { Json.parseToJsonElement(text) as? JsonObject }.getOrNull() ?: JsonObject(emptyMap())
+        }
+    }
+}
+
+/** Keep in sync with `version` in authon/build.gradle.kts. */
+internal const val SDK_VERSION = "0.1.0"
+
+/** HTTP helper shared by the wallet and the auth core; lives here so the wallet package stands alone. */
+internal object Http {
+    private val JSON_MEDIA = "application/json".toMediaType()
+
+    val defaultClient: OkHttpClient by lazy {
+        OkHttpClient.Builder()
+            .connectTimeout(15, TimeUnit.SECONDS)
+            .readTimeout(30, TimeUnit.SECONDS)
+            .writeTimeout(30, TimeUnit.SECONDS)
+            .followRedirects(false)
+            .build()
+    }
+
+    fun userAgent(): String = "authon-android/$SDK_VERSION"
+
+    fun request(
+        url: String,
+        method: String,
+        headers: Map<String, String>,
+        body: JsonElement?,
+    ): Request {
+        val builder = Request.Builder().url(url)
+        for ((k, v) in headers) builder.header(k, v)
+        val payload = body?.toString()?.toRequestBody(JSON_MEDIA)
+        builder.method(method, payload ?: if (method == "POST" || method == "PUT" || method == "PATCH") ByteArray(0).toRequestBody(null) else null)
+        return builder.build()
+    }
+
+    /** Executes the call; throws IOException on network failure. Cancelling the coroutine cancels the call. */
+    suspend fun execute(client: OkHttpClient, request: Request): HttpResult =
+        suspendCancellableCoroutine { cont ->
+            val call = client.newCall(request)
+            cont.invokeOnCancellation { call.cancel() }
+            call.enqueue(
+                object : Callback {
+                    override fun onFailure(call: Call, e: IOException) {
+                        if (cont.isActive) cont.resumeWithException(e)
+                    }
+
+                    override fun onResponse(call: Call, response: Response) {
+                        val result = response.use { HttpResult(it.code, it.body?.string() ?: "") }
+                        if (cont.isActive) cont.resume(result)
+                    }
+                },
+            )
+        }
+}