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

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