@scalebun/react-native 1.10.6 → 1.11.0

package/android/src/main/java/com/scalebun/replaysdk/tracking/InteractionTracker.kt

@@ -9,6 +9,7 @@ import android.view.Window
 import android.view.WindowManager
 import java.lang.ref.WeakReference
 import java.util.WeakHashMap
+import java.util.UUID
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.modules.core.DeviceEventManagerModule
@@ -34,13 +35,10 @@ class InteractionTracker(private val reactContext: ReactApplicationContext) {
     private var touchDownX = 0f
     private var touchDownY = 0f
     private var touchDownTs = 0L
-    private var lastEmitTs = 0L
-    private val THROTTLE_MS = 150L
-    // Same-coordinate duplicate window — see handleTouchUp. Wider than THROTTLE_MS on purpose:
-    // it only ever suppresses a bit-identical re-delivery, never a real second tap.
-    private val SAME_COORD_WINDOW_MS = 500L
-    private var lastEmitRawX = Float.NaN
-    private var lastEmitRawY = Float.NaN
+    private var touchDownOccurredAt = 0L
+    private var touchInteractionId = ""
+    private var lastEmittedInteractionId = ""
+    private val processInteractionNonce = UUID.randomUUID().toString().take(8)
     private val mainHandler = Handler(Looper.getMainLooper())
 
     fun attach(activity: Activity) {
@@ -63,6 +61,9 @@ class InteractionTracker(private val reactContext: ReactApplicationContext) {
                         touchDownX = rawX
                         touchDownY = rawY
                         touchDownTs = ts
+                        val id = "ixn-a-$processInteractionNonce-$ts"
+                        if (id != touchInteractionId) touchDownOccurredAt = System.currentTimeMillis()
+                        touchInteractionId = id
                     },
                     onUp = { rawX, rawY, ts ->
                         handleTouchUp(rawX, rawY, ts, resolveCaptureView(window))
@@ -86,6 +87,9 @@ class InteractionTracker(private val reactContext: ReactApplicationContext) {
                         touchDownX = rawX
                         touchDownY = rawY
                         touchDownTs = ts
+                        val id = "ixn-a-$processInteractionNonce-$ts"
+                        if (id != touchInteractionId) touchDownOccurredAt = System.currentTimeMillis()
+                        touchInteractionId = id
                     },
                     onUp = { rawX, rawY, ts ->
                         val main = attachedWindow ?: return@DialogTouchObserver
@@ -137,21 +141,11 @@ class InteractionTracker(private val reactContext: ReactApplicationContext) {
             ReplayLogger.debug("Native touch up dropped: no usable capture view")
             return
         }
-        val now = System.currentTimeMillis()
-        if (now - lastEmitTs < THROTTLE_MS) return
-        // Same-coordinate suppression: the same UP can be re-delivered through more than one
-        // hooked window callback at gaps just past THROTTLE_MS (measured in production:
-        // identical sub-pixel coords 158–240ms apart, recorded as 2–3 taps for one press).
-        // Bit-identical float coordinates within half a second cannot be a second physical
-        // tap — a real double-tap lands on at least slightly different pixels — so this
-        // drops only machine duplicates. Distinct-coordinate taps still pass at THROTTLE_MS.
-        if (rawX == lastEmitRawX && rawY == lastEmitRawY && now - lastEmitTs < SAME_COORD_WINDOW_MS) {
-            lastEmitTs = now // keep a chained burst suppressed
-            return
-        }
-        lastEmitTs = now
-        lastEmitRawX = rawX
-        lastEmitRawY = rawY
+        // Window/dialog hooks can re-deliver one physical touch. The ACTION_DOWN identity is stable
+        // across those deliveries, unlike coordinates: two legitimate rapid taps may land on the
+        // exact same pixel and must both survive.
+        if (touchInteractionId.isNotEmpty() && touchInteractionId == lastEmittedInteractionId) return
+        lastEmittedInteractionId = touchInteractionId
 
         val durationMs = ts - touchDownTs
         val dx = rawX - touchDownX
@@ -215,6 +209,8 @@ class InteractionTracker(private val reactContext: ReactApplicationContext) {
             screenshotW = viewW,
             screenshotH = viewH,
             durationMs = durationMs,
+            interactionId = touchInteractionId,
+            occurredAt = touchDownOccurredAt,
             onDialogWindow = onDialogWindow
         )
     }
@@ -226,11 +222,16 @@ class InteractionTracker(private val reactContext: ReactApplicationContext) {
         normalizedEndX: Float, normalizedEndY: Float,
         screenshotW: Float, screenshotH: Float,
         durationMs: Long,
+        interactionId: String,
+        occurredAt: Long,
         onDialogWindow: Boolean = false
     ) {
         try {
             val params = Arguments.createMap().apply {
                 putString("gestureType", gestureType)
+                putString("interactionId", interactionId)
+                putInt("interactionProtocol", 1)
+                putDouble("occurredAt", occurredAt.toDouble())
                 putDouble("rawX", rawX.toDouble())
                 putDouble("rawY", rawY.toDouble())
                 putDouble("normalizedX", normalizedX.toDouble())
@@ -276,8 +277,8 @@ class InteractionTracker(private val reactContext: ReactApplicationContext) {
     fun reset() {
         lastInteractionMs = 0
         lastEmitTs = 0
-        lastEmitRawX = Float.NaN
-        lastEmitRawY = Float.NaN
+        touchInteractionId = ""
+        lastEmittedInteractionId = ""
         touchDownTs = 0
     }
 }

package/android/src/main/java/com/scalebun/rn/ota/ScaleBunOtaModule.kt

@@ -283,6 +283,81 @@ class ScaleBunOtaModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    /**
+     * Verify a detached ed25519 signature with PLATFORM crypto.
+     *
+     * Why native: the JS verifier lives inside the very bundle it protects, so
+     * one malicious bundle can neuter it for every update after. Platform
+     * crypto sits outside the bundle's reach. It also drops the runtime need
+     * for the optional @noble peers on Android 13+.
+     *
+     * Contract (mirrors the JS spec doc):
+     *   - inputs are lowercase hex, pre-validated by the JS caller
+     *   - the message is the RAW 32 BYTES of the bundle SHA-256 — the CLI
+     *     signs the digest bytes, not their hex text
+     *   - resolves 'valid' / 'invalid' / 'unavailable'; never rejects for a
+     *     wrong signature, and any unexpected throw resolves 'unavailable' so
+     *     machinery failure is distinguishable from a forged bundle
+     *
+     * Availability: `Signature.getInstance("Ed25519")` ships in Android's
+     * conscrypt from API 33. Below that the JCA lookup throws
+     * NoSuchAlgorithmException — reported as 'unavailable', and JS falls back
+     * to its own verifier. Checked by attempting the lookup rather than by
+     * SDK_INT, because the algorithm's presence is the fact that matters.
+     */
+    @ReactMethod
+    override fun verifyEd25519(
+        messageHex: String,
+        signatureHex: String,
+        publicKeyHex: String,
+        promise: Promise,
+    ) {
+        try {
+            val message = hexToBytes(messageHex)
+            val signature = hexToBytes(signatureHex)
+            val rawKey = hexToBytes(publicKeyHex)
+            if (message == null || signature == null || rawKey == null || rawKey.size != 32) {
+                // Malformed input from our own caller is not a forgery verdict.
+                promise.resolve("unavailable")
+                return
+            }
+
+            // JCA takes X.509 SubjectPublicKeyInfo, not raw key bytes: the
+            // 12-byte ed25519 SPKI prefix (OID 1.3.101.112) + the raw 32.
+            val spkiPrefix = byteArrayOf(
+                0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00,
+            )
+            val verifier = try {
+                java.security.Signature.getInstance("Ed25519")
+            } catch (_: java.security.NoSuchAlgorithmException) {
+                promise.resolve("unavailable") // API < 33
+                return
+            }
+            val key = java.security.KeyFactory.getInstance("Ed25519")
+                .generatePublic(java.security.spec.X509EncodedKeySpec(spkiPrefix + rawKey))
+
+            verifier.initVerify(key)
+            verifier.update(message)
+            promise.resolve(if (verifier.verify(signature)) "valid" else "invalid")
+        } catch (_: Throwable) {
+            // Fail toward "cannot check", never toward "checked out fine".
+            promise.resolve("unavailable")
+        }
+    }
+
+    /** Hex → bytes; null for odd length or a non-hex character. */
+    private fun hexToBytes(hex: String): ByteArray? {
+        if (hex.isEmpty() || hex.length % 2 != 0) return null
+        val out = ByteArray(hex.length / 2)
+        for (i in out.indices) {
+            val hi = Character.digit(hex[i * 2], 16)
+            val lo = Character.digit(hex[i * 2 + 1], 16)
+            if (hi < 0 || lo < 0) return null
+            out[i] = ((hi shl 4) or lo).toByte()
+        }
+        return out
+    }
+
     private fun sha256Hex(bytes: ByteArray): String {
         val digest = java.security.MessageDigest.getInstance("SHA-256")
         val hash = digest.digest(bytes)

package/android/src/oldarch/java/com/scalebun/rn/ota/ScaleBunOtaSpec.kt

@@ -28,4 +28,16 @@ abstract class ScaleBunOtaSpec(reactContext: ReactApplicationContext) :
     abstract fun markHealthy()
     abstract fun revertToPrevious(promise: Promise)
     abstract fun restartApp()
+
+    // Hand-maintained: this file does NOT regenerate from the JS spec. A method
+    // added to NativeScaleBunOta.ts that is missing here compiles green on New
+    // Arch and breaks EVERY old-arch consumer's build (the ScaleBunCrashModule
+    // incident). Non-null Strings to match the codegen base's signature, so the
+    // one concrete override compiles against either architecture.
+    abstract fun verifyEd25519(
+        messageHex: String,
+        signatureHex: String,
+        publicKeyHex: String,
+        promise: Promise,
+    )
 }