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

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

@@ -0,0 +1,134 @@
+// GENERATED by scripts/sync-native-wallet.mjs from kotlin/authon/src/main/kotlin/dev/authon/sdk/wallet/Proof.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.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonArray
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
+import java.nio.ByteBuffer
+import java.nio.CharBuffer
+import java.nio.charset.CharacterCodingException
+import java.nio.charset.CodingErrorAction
+
+/** P-256 device public key as the API stores it (JWK, base64url x/y without padding). */
+data class DevicePublicJwk(val x: String, val y: String) {
+    val kty: String get() = "EC"
+    val crv: String get() = "P-256"
+
+    fun toJson(): JsonObject = buildJsonObject {
+        put("kty", kty)
+        put("crv", crv)
+        put("x", x)
+        put("y", y)
+    }
+}
+
+/** Server-issued proof nonce (`expiresAt` in Unix seconds). */
+data class ProofNonce(val nonce: String, val expiresAt: Long)
+
+/** Wallet key proofs and reserved-message rules of `apps/wallet/src/proof.ts`. */
+internal object Proof {
+    const val DOMAIN_NAME = "Authon Wallet Proof"
+    const val DOMAIN_VERSION = "1"
+    private val RESERVED_PREFIXES = listOf("create:", "device:", "restore:")
+
+    fun canonicalJwk(jwk: DevicePublicJwk): String =
+        "{\"crv\":${json(jwk.crv)},\"kty\":${json(jwk.kty)},\"x\":${json(jwk.x)},\"y\":${json(jwk.y)}}"
+
+    fun devicePublicKeyHash(jwk: DevicePublicJwk): String = Bytes.toHex(Bytes.sha256(Bytes.utf8(canonicalJwk(jwk))))
+
+    private fun json(s: String): String = JsonPrimitive(s).toString()
+
+    private fun fields(vararg pairs: Pair<String, String>): JsonArray = buildJsonArray {
+        for ((name, type) in pairs) add(buildJsonObject { put("name", name); put("type", type) })
+    }
+
+    private val BOUND = arrayOf("nonce" to "string", "expiresAt" to "uint256")
+
+    private val TYPES: Map<String, JsonArray> = mapOf(
+        "CreateWallet" to fields("projectId" to "string", "userId" to "string", "deviceKeyHash" to "string", *BOUND),
+        "AddDevice" to fields("walletId" to "string", "shareVersion" to "uint256", "deviceKeyHash" to "string", *BOUND),
+        "RestoreWallet" to fields("walletId" to "string", "shareVersion" to "uint256", "deviceKeyHash" to "string", *BOUND),
+    )
+
+    fun typedData(primaryType: String, message: List<Pair<String, String>>, bound: ProofNonce): JsonObject = buildJsonObject {
+        put("domain", buildJsonObject { put("name", DOMAIN_NAME); put("version", DOMAIN_VERSION) })
+        put("types", buildJsonObject { put(primaryType, TYPES.getValue(primaryType)) })
+        put("primaryType", primaryType)
+        put(
+            "message",
+            buildJsonObject {
+                for ((k, v) in message) put(k, v)
+                put("nonce", bound.nonce)
+                put("expiresAt", bound.expiresAt.toString())
+            },
+        )
+    }
+
+    fun createTypedData(projectId: String, userId: String, deviceKey: DevicePublicJwk, bound: ProofNonce) =
+        typedData("CreateWallet", listOf("projectId" to projectId, "userId" to userId, "deviceKeyHash" to devicePublicKeyHash(deviceKey)), bound)
+
+    fun deviceTypedData(walletId: String, shareVersion: Int, deviceKey: DevicePublicJwk, bound: ProofNonce) =
+        typedData(
+            "AddDevice",
+            listOf("walletId" to walletId, "shareVersion" to shareVersion.toString(), "deviceKeyHash" to devicePublicKeyHash(deviceKey)),
+            bound,
+        )
+
+    /** shareVersion in the signed message is the current version + 1. */
+    fun restoreTypedData(walletId: String, currentShareVersion: Int, newDeviceKey: DevicePublicJwk, bound: ProofNonce) =
+        typedData(
+            "RestoreWallet",
+            listOf(
+                "walletId" to walletId,
+                "shareVersion" to (currentShareVersion + 1).toString(),
+                "deviceKeyHash" to devicePublicKeyHash(newDeviceKey),
+            ),
+            bound,
+        )
+
+    /** Proofs are always signed with account 0 of the wallet secret. */
+    fun sign(secret: ByteArray, typedData: JsonObject): String = HdWallet.account(secret, 0).signTypedData(typedData)
+
+    /** True for app text that looks like a (legacy) wallet proof. */
+    fun isReservedMessageText(text: String): Boolean {
+        var i = 0
+        while (i < text.length && (text[i].code <= 0x1f || text[i] == '' || isJsWhitespace(text[i]))) i++
+        val t = text.substring(i).lowercase()
+        return RESERVED_PREFIXES.any { t.startsWith(it) }
+    }
+
+    /** JavaScript `\s`: WhiteSpace and LineTerminator code points. */
+    private fun isJsWhitespace(c: Char): Boolean =
+        c == ' ' || c == '\t' || c == '\n' || c == '\u000b' || c == '\u000c' || c == '\r' || c == ' ' || c == ' ' ||
+            c in ' '..' ' || c == '
' || c == '
' || c == ' ' || c == ' ' || c == '　' ||
+            c == ''
+
+    /** Decodes a raw hex message as strict UTF-8; null when it is not valid UTF-8 or not hex. */
+    fun rawMessageText(hex: String): String? {
+        val bytes = Bytes.fromHexOrNull(hex) ?: return null
+        return try {
+            Charsets.UTF_8.newDecoder()
+                .onMalformedInput(CodingErrorAction.REPORT)
+                .onUnmappableCharacter(CodingErrorAction.REPORT)
+                .decode(ByteBuffer.wrap(bytes))
+                .let { stripBom(it) }
+        } catch (_: CharacterCodingException) {
+            null
+        }
+    }
+
+    // TextDecoder('utf-8') drops a leading BOM by default.
+    private fun stripBom(chars: CharBuffer): String {
+        val s = chars.toString()
+        return if (s.startsWith("")) s.substring(1) else s
+    }
+
+    fun isReservedTypedData(typedData: JsonObject): Boolean {
+        val name = ((typedData["domain"] as? JsonObject)?.get("name") as? JsonPrimitive)?.takeIf { it.isString }?.content
+            ?: return false
+        return name.trim().lowercase() == DOMAIN_NAME.lowercase()
+    }
+}

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

@@ -0,0 +1,106 @@
+// GENERATED by scripts/sync-native-wallet.mjs from kotlin/authon/src/main/kotlin/dev/authon/sdk/wallet/Shamir.kt. Do not edit: change the source and run the script.
+package dev.authon.sdk.wallet
+
+import java.security.SecureRandom
+
+/**
+ * Port of the `shamir-secret-sharing` JS library used by the web frame: GF(2^8) with the
+ * same tables, a share is `y bytes || x` (x in the last byte). [combine] is deterministic and
+ * byte-identical to the library; [split] draws its coefficients and coordinates from SecureRandom.
+ */
+internal object Shamir {
+    private val random = SecureRandom()
+
+    private fun add(a: Int, b: Int): Int = a xor b
+
+    private fun div(a: Int, b: Int): Int {
+        require(b != 0) { "cannot divide by zero" }
+        val diff = (GfTables.LOG[a] - GfTables.LOG[b] + 255) % 255
+        return if (a == 0) 0 else GfTables.EXP[diff]
+    }
+
+    private fun mult(a: Int, b: Int): Int {
+        val sum = (GfTables.LOG[a] + GfTables.LOG[b]) % 255
+        return if (a == 0 || b == 0) 0 else GfTables.EXP[sum]
+    }
+
+    private fun interpolate(xs: IntArray, ys: IntArray, x: Int): Int {
+        var result = 0
+        for (i in xs.indices) {
+            var basis = 1
+            for (j in xs.indices) {
+                if (i == j) continue
+                basis = mult(basis, div(add(x, xs[j]), add(xs[i], xs[j])))
+            }
+            result = add(result, mult(ys[i], basis))
+        }
+        return result
+    }
+
+    private fun evaluate(coefficients: IntArray, x: Int, degree: Int): Int {
+        require(x != 0) { "cannot evaluate secret polynomial at zero" }
+        var result = coefficients[degree]
+        for (i in degree - 1 downTo 0) result = add(mult(result, x), coefficients[i])
+        return result
+    }
+
+    private fun newCoordinates(): IntArray {
+        val coordinates = IntArray(255) { it + 1 }
+        val randomIndices = ByteArray(255).also { random.nextBytes(it) }
+        for (i in 0 until 255) {
+            val j = (randomIndices[i].toInt() and 0xff) % 255
+            val tmp = coordinates[i]
+            coordinates[i] = coordinates[j]
+            coordinates[j] = tmp
+        }
+        return coordinates
+    }
+
+    fun split(secret: ByteArray, shares: Int, threshold: Int): List<ByteArray> {
+        require(secret.isNotEmpty()) { "secret cannot be empty" }
+        require(shares in 2..255) { "shares must be at least 2 and at most 255" }
+        require(threshold in 2..255) { "threshold must be at least 2 and at most 255" }
+        require(shares >= threshold) { "shares cannot be less than threshold" }
+        val xs = newCoordinates()
+        val result = List(shares) { i -> ByteArray(secret.size + 1).also { it[secret.size] = xs[i].toByte() } }
+        val degree = threshold - 1
+        val coefficients = IntArray(degree + 1)
+        val randomCoefficients = ByteArray(degree)
+        try {
+            for (i in secret.indices) {
+                coefficients[0] = secret[i].toInt() and 0xff
+                random.nextBytes(randomCoefficients)
+                for (k in 0 until degree) coefficients[k + 1] = randomCoefficients[k].toInt() and 0xff
+                for (j in 0 until shares) result[j][i] = evaluate(coefficients, xs[j], degree).toByte()
+            }
+        } finally {
+            coefficients.fill(0)
+            randomCoefficients.fill(0)
+        }
+        return result
+    }
+
+    fun combine(shares: List<ByteArray>): ByteArray {
+        require(shares.size in 2..255) { "shares must have at least 2 and at most 255 elements" }
+        val shareLength = shares[0].size
+        for (s in shares) {
+            require(s.size >= 2) { "each share must be at least 2 bytes" }
+            require(s.size == shareLength) { "all shares must have the same byte length" }
+        }
+        val xs = IntArray(shares.size)
+        val seen = HashSet<Int>()
+        for (i in shares.indices) {
+            val x = shares[i][shareLength - 1].toInt() and 0xff
+            require(seen.add(x)) { "shares must contain unique values but a duplicate was found" }
+            xs[i] = x
+        }
+        val secret = ByteArray(shareLength - 1)
+        val ys = IntArray(shares.size)
+        for (i in secret.indices) {
+            for (j in shares.indices) ys[j] = shares[j][i].toInt() and 0xff
+            secret[i] = interpolate(xs, ys, 0).toByte()
+        }
+        ys.fill(0)
+        return secret
+    }
+}

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

@@ -0,0 +1,335 @@
+// GENERATED by scripts/sync-native-wallet.mjs from kotlin/authon/src/main/kotlin/dev/authon/sdk/wallet/SignSummary.kt. Do not edit: change the source and run the script.
+package dev.authon.sdk.wallet
+
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.contentOrNull
+import org.web3j.crypto.Hash
+import org.web3j.crypto.Keys
+import java.math.BigDecimal
+import java.math.BigInteger
+
+data class SignRow(val label: String, val value: String, val mono: Boolean = false)
+
+enum class SignRisk { LOW, HIGH }
+
+/**
+ * Human-readable description of a signing request, built by the SDK from the exact payload that
+ * will be signed (same rules as `apps/wallet/src/summary.ts`).
+ */
+data class SignSummary(
+    val kind: Kind,
+    val title: String,
+    val rows: List<SignRow>,
+    /** The complete text that is signed, never shortened. */
+    val body: String? = null,
+    val warnings: List<String>,
+    /** HIGH: moves value or grants spending. */
+    val risk: SignRisk,
+) {
+    enum class Kind { MESSAGE, TYPED_DATA, TRANSACTION }
+}
+
+internal object Summaries {
+    /** Longest text the approval shows; longer requests are refused instead of shown partially. */
+    const val MAX_SIGN_TEXT = 16_384
+
+    private data class Chain(val name: String, val symbol: String)
+
+    private val CHAINS = mapOf(
+        1L to Chain("Ethereum", "ETH"),
+        10L to Chain("Optimism", "ETH"),
+        56L to Chain("BNB Smart Chain", "BNB"),
+        137L to Chain("Polygon", "POL"),
+        8453L to Chain("Base", "ETH"),
+        42161L to Chain("Arbitrum One", "ETH"),
+        43114L to Chain("Avalanche C-Chain", "AVAX"),
+        80002L to Chain("Polygon Amoy (testnet)", "POL"),
+        84532L to Chain("Base Sepolia (testnet)", "ETH"),
+        11155111L to Chain("Sepolia (testnet)", "ETH"),
+    )
+
+    fun chainLabel(chainId: Long?): String {
+        if (chainId == null) return "Unknown network"
+        val c = CHAINS[chainId]
+        return if (c != null) "${c.name} ($chainId)" else "Chain $chainId"
+    }
+
+    private fun nativeSymbol(chainId: Long?): String = chainId?.let { CHAINS[it]?.symbol } ?: "native token"
+
+    private val MAX_UINT256: BigInteger = BigInteger.ONE.shiftLeft(256).subtract(BigInteger.ONE)
+    private val UNLIMITED_THRESHOLD: BigInteger = BigInteger.ONE.shiftLeft(255)
+    private const val PERMIT2 = "0x000000000022d473030f116ddee9f6b43ac78ba3"
+    private val ADDRESS = Regex("^0x[0-9a-fA-F]{40}$")
+    @OptIn(kotlinx.serialization.ExperimentalSerializationApi::class)
+    private val prettyJson = Json { prettyPrint = true; prettyPrintIndent = "  " }
+
+    private fun requireShowable(text: String): String {
+        if (text.length > MAX_SIGN_TEXT) {
+            throw walletError(
+                WalletErrorCode.MESSAGE_TOO_LARGE,
+                "the request has ${text.length} characters; at most $MAX_SIGN_TEXT can be shown",
+            )
+        }
+        return text
+    }
+
+    private fun addr(value: Any?): String {
+        val s = when (value) {
+            is JsonPrimitive -> value.contentOrNull
+            else -> value?.toString()
+        } ?: "undefined"
+        return if (ADDRESS.matches(s)) Keys.toChecksumAddress(s) else s
+    }
+
+    private fun amountText(value: BigInteger, unlimitedLabel: String = "Unlimited"): String =
+        if (value >= UNLIMITED_THRESHOLD) {
+            "$unlimitedLabel (${if (value == MAX_UINT256) "max uint256" else value.toString()})"
+        } else {
+            value.toString()
+        }
+
+    private fun toBigInt(value: JsonElement?): BigInteger? {
+        if (value == null || value !is JsonPrimitive) return null
+        if (value.isString && value.content.isEmpty()) return null
+        return JsValues.toBigIntOrNull(value)
+    }
+
+    private fun toChainId(value: JsonElement?): Long? = toBigInt(value)?.toLong()
+
+    /** viem formatUnits. */
+    fun formatUnits(value: BigInteger, decimals: Int): String {
+        val d = BigDecimal(value).movePointLeft(decimals).stripTrailingZeros()
+        return if (d.signum() == 0) "0" else d.toPlainString()
+    }
+
+    sealed class Message {
+        data class Text(val text: String) : Message()
+        data class Raw(val hex: String) : Message()
+    }
+
+    fun message(message: Message): SignSummary = when (message) {
+        is Message.Text -> SignSummary(SignSummary.Kind.MESSAGE, "Sign message", emptyList(), requireShowable(message.text), emptyList(), SignRisk.LOW)
+        is Message.Raw -> {
+            val text = Proof.rawMessageText(message.hex)
+            val printable = text != null && !Regex("[\\u0000-\\u0008\\u000e-\\u001f\\u007f]").containsMatchIn(text)
+            SignSummary(
+                SignSummary.Kind.MESSAGE,
+                "Sign message",
+                if (printable) emptyList() else listOf(SignRow("Format", "Raw bytes (not readable text)")),
+                requireShowable(if (printable) text!! else message.hex),
+                if (printable) emptyList() else listOf("This message is not readable text. Only sign it if you trust this site."),
+                SignRisk.LOW,
+            )
+        }
+    }
+
+    private val PERMIT_TYPES = setOf(
+        "Permit", "PermitSingle", "PermitBatch", "PermitTransferFrom", "PermitBatchTransferFrom",
+        "PermitWitnessTransferFrom", "PermitBatchWitnessTransferFrom", "PermitForAll",
+    )
+    private val SPENDING_TYPES = setOf(
+        "OrderComponents", "Order", "BulkOrder", "OrderParameters", "ForwardRequest", "MetaTransaction", "SafeTx", "Delegation", "Approval",
+    )
+    private val SPENDING_KEYS = setOf("spender", "operator", "delegate", "delegatee", "approved", "allowance", "allowed")
+
+    private fun grantsSpending(message: JsonElement): Boolean {
+        var budget = 2000
+        fun walk(v: JsonElement, depth: Int): Boolean {
+            if (--budget < 0 || depth > 12) return true
+            if (v is JsonArray) return v.any { walk(it, depth + 1) }
+            if (v !is JsonObject) return false
+            val entries = v.entries.map { (k, x) -> k.lowercase() to x }
+            val keys = entries.map { it.first }
+            if (keys.any { it in SPENDING_KEYS }) return true
+            val hasCall = entries.any { (k, x) ->
+                (k == "data" || k == "calldata") && x is JsonPrimitive && x.isString && x.content != "0x" && x.content != ""
+            }
+            val hasTarget = "to" in keys || "recipient" in keys
+            val hasValue = "value" in keys || "amount" in keys
+            if (hasCall || (hasTarget && hasValue)) return true
+            return v.values.any { walk(it, depth + 1) }
+        }
+        return walk(message, 0)
+    }
+
+    private fun JsonElement?.obj(): JsonObject? = this as? JsonObject
+
+    private fun JsonElement?.str(): String? = (this as? JsonPrimitive)?.takeIf { it.isString }?.content
+
+    fun typedData(td: JsonObject): SignSummary {
+        val domain = td["domain"].obj() ?: JsonObject(emptyMap())
+        val primaryType = (td["primaryType"] as? JsonPrimitive)?.contentOrNull ?: ""
+        val message = td["message"].obj() ?: JsonObject(emptyMap())
+        val rows = mutableListOf<SignRow>()
+        domain["name"].str()?.let { rows += SignRow("App or contract", it) }
+        toChainId(domain["chainId"])?.let { rows += SignRow("Network", chainLabel(it)) }
+        domain["verifyingContract"].str()?.let { rows += SignRow("Contract", addr(it), mono = true) }
+        rows += SignRow("Type", primaryType.ifEmpty { "unknown" })
+
+        val warnings = mutableListOf<String>()
+        val verifying = domain["verifyingContract"].str()?.lowercase() ?: ""
+        val isPermit2 = domain["name"].str() == "Permit2" || verifying == PERMIT2
+        val details = message["details"].obj()
+        if (primaryType in PERMIT_TYPES || isPermit2) {
+            warnings += "This is a token permit. Signing it lets the spender move your tokens without another confirmation."
+            val spender = message["spender"] ?: details?.get("spender")
+            if (spender != null) rows += SignRow("Spender", addr(spender), mono = true)
+            val amount = toBigInt(message["value"]) ?: toBigInt(message["amount"]) ?: toBigInt(details?.get("amount"))
+                ?: toBigInt(message["permitted"].obj()?.get("amount"))
+            if (amount != null) rows += SignRow("Amount (token units)", amountText(amount))
+            if (amount != null && amount >= UNLIMITED_THRESHOLD) warnings += "The permitted amount is unlimited."
+            val deadline = toBigInt(message["deadline"]) ?: toBigInt(message["sigDeadline"]) ?: toBigInt(message["expiry"])
+            if (deadline != null) rows += SignRow("Valid until", deadline.toString())
+        } else if (message["spender"] != null || message["operator"] != null) {
+            warnings += "This signature may give another address access to your assets."
+        }
+        val permit = primaryType in PERMIT_TYPES || isPermit2
+        val high = permit || primaryType in SPENDING_TYPES || grantsSpending(message)
+        if (high && warnings.isEmpty()) warnings += "This signature may let another address move your assets or act for you."
+        return SignSummary(
+            SignSummary.Kind.TYPED_DATA, "Sign data", rows, requireShowable(prettyJson.encodeToString(JsonElement.serializer(), message)),
+            warnings, if (high) SignRisk.HIGH else SignRisk.LOW,
+        )
+    }
+
+    private class AbiFn(val name: String, val types: List<String>) {
+        val selector: String = Bytes.toHex(Hash.sha3(Bytes.utf8("$name(${types.joinToString(",")})")).copyOf(4))
+    }
+
+    private val ERC_FUNCTIONS = listOf(
+        AbiFn("transfer", listOf("address", "uint256")),
+        AbiFn("approve", listOf("address", "uint256")),
+        AbiFn("transferFrom", listOf("address", "address", "uint256")),
+        AbiFn("increaseAllowance", listOf("address", "uint256")),
+        AbiFn("setApprovalForAll", listOf("address", "bool")),
+        AbiFn("permit", listOf("address", "address", "uint256", "uint256", "uint8", "bytes32", "bytes32")),
+        AbiFn("approve", listOf("address", "address", "uint160", "uint48")),
+    )
+
+    private sealed class AbiValue {
+        data class Address(val value: String) : AbiValue()
+        data class UInt(val value: BigInteger) : AbiValue()
+        data class Bool(val value: Boolean) : AbiValue()
+        data class Word(val hex: String) : AbiValue()
+    }
+
+    /** decodeFunctionData for the static-argument ERC functions above; null when it does not decode. */
+    private fun decodeCall(data: ByteArray): Pair<AbiFn, List<AbiValue>>? {
+        if (data.size < 4) return null
+        val selector = Bytes.toHex(data.copyOf(4))
+        val fn = ERC_FUNCTIONS.firstOrNull { it.selector == selector } ?: return null
+        if (data.size < 4 + 32 * fn.types.size) return null
+        val args = fn.types.mapIndexed { i, type ->
+            val word = data.copyOfRange(4 + 32 * i, 4 + 32 * (i + 1))
+            val n = BigInteger(1, word)
+            when (type) {
+                "address" -> AbiValue.Address(Keys.toChecksumAddress("0x" + Bytes.toHex(word.copyOfRange(12, 32))))
+                "bool" -> {
+                    if (n > BigInteger.ONE) return null
+                    AbiValue.Bool(n == BigInteger.ONE)
+                }
+                "bytes32" -> AbiValue.Word("0x" + Bytes.toHex(word))
+                else -> {
+                    val bits = type.removePrefix("uint").toInt()
+                    if (n.bitLength() > bits) return null
+                    AbiValue.UInt(n)
+                }
+            }
+        }
+        return fn to args
+    }
+
+    private fun AbiValue.text(): String = when (this) {
+        is AbiValue.Address -> value
+        is AbiValue.UInt -> value.toString()
+        is AbiValue.Bool -> value.toString()
+        is AbiValue.Word -> hex
+    }
+
+    private fun AbiValue.uint(): BigInteger = (this as AbiValue.UInt).value
+
+    fun transaction(tx: JsonObject): SignSummary {
+        val chainId = toChainId(tx["chainId"])
+        val rows = mutableListOf(SignRow("Network", chainLabel(chainId)))
+        val warnings = mutableListOf<String>()
+        val to = tx["to"].str()?.takeIf { it.isNotEmpty() }
+        if (to != null) {
+            rows += SignRow("To", addr(to), mono = true)
+        } else {
+            rows += SignRow("To", "New contract (deployment)")
+            warnings += "This transaction deploys a contract."
+        }
+        val value = toBigInt(tx["value"]) ?: BigInteger.ZERO
+        rows += SignRow("Amount", "${formatUnits(value, 18)} ${nativeSymbol(chainId)}")
+        val gas = toBigInt(tx["gas"])
+        val maxFee = toBigInt(tx["maxFeePerGas"]) ?: toBigInt(tx["gasPrice"])
+        if (gas != null && maxFee != null) {
+            rows += SignRow("Max network fee", "${formatUnits(gas.multiply(maxFee), 18)} ${nativeSymbol(chainId)}")
+        }
+        val data = tx["data"].str() ?: tx["input"].str() ?: "0x"
+        if (data.isNotEmpty() && data != "0x") {
+            val decoded = Bytes.fromHexOrNull(data)?.let { decodeCall(it) }
+            if (decoded == null) {
+                rows += SignRow("Action", "Contract call (${data.take(10)})", mono = true)
+                rows += SignRow("Data", "${maxOf(0, (data.length - 2) / 2)} bytes")
+            } else {
+                val (fn, a) = decoded
+                when (fn.name) {
+                    "transfer" -> {
+                        rows += SignRow("Action", "Token transfer")
+                        rows += SignRow("Token", addr(to), mono = true)
+                        rows += SignRow("Recipient", a[0].text(), mono = true)
+                        rows += SignRow("Amount (token units)", a[1].text())
+                    }
+                    "transferFrom" -> {
+                        rows += SignRow("Action", "Token transfer from another address")
+                        rows += SignRow("From", a[0].text(), mono = true)
+                        rows += SignRow("Recipient", a[1].text(), mono = true)
+                        rows += SignRow("Amount (token units)", a[2].text())
+                    }
+                    "approve" -> {
+                        if (a.size == 4) {
+                            rows += SignRow("Action", "Permit2 allowance")
+                            rows += SignRow("Token", a[0].text(), mono = true)
+                            rows += SignRow("Spender", a[1].text(), mono = true)
+                            rows += SignRow("Amount (token units)", amountText(a[2].uint()))
+                        } else {
+                            rows += SignRow("Action", "Token approval")
+                            rows += SignRow("Token", addr(to), mono = true)
+                            rows += SignRow("Spender", a[0].text(), mono = true)
+                            rows += SignRow("Amount (token units)", amountText(a[1].uint()))
+                            if (a[1].uint() >= UNLIMITED_THRESHOLD) warnings += "The approved amount is unlimited."
+                        }
+                        warnings += "This lets the spender move your tokens later without asking again."
+                    }
+                    "increaseAllowance" -> {
+                        rows += SignRow("Action", "Increase token allowance")
+                        rows += SignRow("Spender", a[0].text(), mono = true)
+                        rows += SignRow("Added (token units)", amountText(a[1].uint()))
+                        warnings += "This lets the spender move more of your tokens without asking again."
+                    }
+                    "setApprovalForAll" -> {
+                        val approved = (a[1] as AbiValue.Bool).value
+                        rows += SignRow("Action", if (approved) "Approve all NFTs in a collection" else "Remove collection approval")
+                        rows += SignRow("Operator", a[0].text(), mono = true)
+                        if (approved) warnings += "The operator could transfer every item you own in this collection."
+                    }
+                    "permit" -> {
+                        rows += SignRow("Action", "Token permit")
+                        rows += SignRow("Token", addr(to), mono = true)
+                        rows += SignRow("Spender", a[1].text(), mono = true)
+                        rows += SignRow("Amount (token units)", amountText(a[2].uint()))
+                        warnings += "This lets the spender move your tokens later without asking again."
+                    }
+                }
+            }
+        }
+        if (chainId == null) warnings += "The network is not specified."
+        val risk = if (value.signum() > 0 || (data.isNotEmpty() && data != "0x") || to == null) SignRisk.HIGH else SignRisk.LOW
+        return SignSummary(SignSummary.Kind.TRANSACTION, "Approve transaction", rows, null, warnings, risk)
+    }
+}