@authon/react-native-wallet 0.0.0-stage → 0.4.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/Encodings.kt

@@ -0,0 +1,133 @@
+// GENERATED by scripts/sync-native-wallet.mjs from kotlin/authon/src/main/kotlin/dev/authon/sdk/wallet/Encodings.kt. Do not edit: change the source and run the script.
+package dev.authon.sdk.wallet
+
+import java.math.BigInteger
+
+/** Base58 (Bitcoin and XRP alphabets) and Base58Check with a double-SHA-256 checksum. */
+internal object Base58 {
+    const val BITCOIN = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+    const val XRP = "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz"
+    private val FIFTY_EIGHT = BigInteger.valueOf(58)
+
+    fun encode(data: ByteArray, alphabet: String = BITCOIN): String {
+        var n = BigInteger(1, data)
+        val out = StringBuilder()
+        while (n.signum() > 0) {
+            val (q, r) = n.divideAndRemainder(FIFTY_EIGHT)
+            out.append(alphabet[r.toInt()])
+            n = q
+        }
+        for (b in data) {
+            if (b.toInt() != 0) break
+            out.append(alphabet[0])
+        }
+        return out.reverse().toString()
+    }
+
+    fun decode(text: String, alphabet: String = BITCOIN): ByteArray {
+        var n = BigInteger.ZERO
+        for (c in text) {
+            val digit = alphabet.indexOf(c)
+            if (digit < 0) throw walletError(WalletErrorCode.INVALID_REQUEST, "invalid base58")
+            n = n.multiply(FIFTY_EIGHT).add(BigInteger.valueOf(digit.toLong()))
+        }
+        val body = n.toByteArray().let { if (it.size > 1 && it[0].toInt() == 0) it.copyOfRange(1, it.size) else it }
+        val zeros = text.takeWhile { it == alphabet[0] }.length
+        return ByteArray(zeros) + if (n.signum() == 0) ByteArray(0) else body
+    }
+
+    fun encodeCheck(payload: ByteArray, alphabet: String = BITCOIN): String {
+        val checksum = Bytes.sha256(Bytes.sha256(payload)).copyOf(4)
+        return encode(payload + checksum, alphabet)
+    }
+}
+
+/** Bech32 (BIP173) and Bech32m (BIP350) for segwit addresses. */
+internal object Bech32 {
+    private const val BECH32M_CONST = 0x2bc830a3
+    private const val CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+    private val GEN = intArrayOf(0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3)
+
+    private fun polymod(values: IntArray): Int {
+        var chk = 1
+        for (v in values) {
+            val top = chk ushr 25
+            chk = ((chk and 0x1ffffff) shl 5) xor v
+            for (i in 0 until 5) if ((top ushr i) and 1 == 1) chk = chk xor GEN[i]
+        }
+        return chk
+    }
+
+    private fun hrpExpand(hrp: String): IntArray =
+        IntArray(hrp.length) { hrp[it].code ushr 5 } + intArrayOf(0) + IntArray(hrp.length) { hrp[it].code and 31 }
+
+    fun encode(hrp: String, data: IntArray, bech32m: Boolean = false): String {
+        val values = hrpExpand(hrp) + data + IntArray(6)
+        val mod = polymod(values) xor (if (bech32m) BECH32M_CONST else 1)
+        val checksum = IntArray(6) { (mod ushr (5 * (5 - it))) and 31 }
+        return hrp + "1" + (data + checksum).joinToString("") { CHARSET[it].toString() }
+    }
+
+    /** True when [address] is a valid Bech32 string (checksum and charset); case must not be mixed. */
+    fun verify(address: String): Boolean {
+        if (address.lowercase() != address && address.uppercase() != address) return false
+        val s = address.lowercase()
+        val pos = s.lastIndexOf('1')
+        if (pos < 1 || pos + 7 > s.length || s.length > 90) return false
+        val data = s.substring(pos + 1).map { CHARSET.indexOf(it) }.toIntArray()
+        if (data.any { it < 0 }) return false
+        return polymod(hrpExpand(s.substring(0, pos)) + data) == 1
+    }
+
+    /** 8-bit bytes to 5-bit groups with padding (BIP173 convertbits). */
+    fun toWords(bytes: ByteArray): IntArray {
+        val out = ArrayList<Int>()
+        var acc = 0
+        var bits = 0
+        for (b in bytes) {
+            acc = (acc shl 8) or (b.toInt() and 0xff)
+            bits += 8
+            while (bits >= 5) {
+                bits -= 5
+                out += (acc ushr bits) and 31
+            }
+        }
+        if (bits > 0) out += (acc shl (5 - bits)) and 31
+        return out.toIntArray()
+    }
+
+    fun segwitV0(hrp: String, program: ByteArray): String = encode(hrp, intArrayOf(0) + toWords(program))
+
+    /** Segwit address for witness [version] (v0 bech32, v1+ bech32m). */
+    fun segwit(hrp: String, version: Int, program: ByteArray): String = encode(hrp, intArrayOf(version) + toWords(program), version > 0)
+
+    /** Decodes a segwit address of [hrp] to (version, program); null when it is not one. */
+    fun decodeSegwit(hrp: String, address: String): Pair<Int, ByteArray>? {
+        if (address.lowercase() != address && address.uppercase() != address) return null
+        val s = address.lowercase()
+        val pos = s.lastIndexOf('1')
+        if (pos < 1 || pos + 7 > s.length || s.length > 90 || s.substring(0, pos) != hrp) return null
+        val data = s.substring(pos + 1).map { CHARSET.indexOf(it) }.toIntArray()
+        if (data.any { it < 0 }) return null
+        val check = polymod(hrpExpand(hrp) + data)
+        val words = data.copyOfRange(0, data.size - 6)
+        if (words.isEmpty()) return null
+        val version = words[0]
+        if (version > 16 || check != (if (version == 0) 1 else BECH32M_CONST)) return null
+        var acc = 0
+        var bits = 0
+        val out = ArrayList<Byte>()
+        for (w in words.drop(1)) {
+            acc = (acc shl 5) or w
+            bits += 5
+            if (bits >= 8) {
+                bits -= 8
+                out += ((acc ushr bits) and 0xff).toByte()
+            }
+        }
+        if (bits >= 5 || (acc and ((1 shl bits) - 1)) != 0) return null
+        val program = out.toByteArray()
+        if (program.size < 2 || program.size > 40 || (version == 0 && program.size != 20 && program.size != 32)) return null
+        return version to program
+    }
+}

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,
+    )
+}