@onekeyfe/react-native-range-downloader 3.0.81-alpha.2 → 3.0.81-alpha.4

package/android/src/main/java/com/margelo/nitro/reactnativerangedownloader/ReactNativeRangeDownloader.kt

@@ -9,6 +9,9 @@ import java.io.File
 import java.security.MessageDigest
 import java.util.concurrent.CopyOnWriteArrayList
 import java.util.concurrent.atomic.AtomicLong
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 
 // P1: Nitro adapter for the Android concurrent multi-range downloader.
 //
@@ -34,6 +37,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
 
   private val listeners = CopyOnWriteArrayList<Listener>()
   private val nextListenerId = AtomicLong(1)
+  private val firmwareArtifactScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
   // Active downloads keyed by "channel|taskId" so cancel/discardArtifacts can
   // flip the abort flag + stop the worker pool BEFORE deleting files, instead of
@@ -278,7 +282,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun downloadFirmwareArtifact(
     params: FirmwareArtifactDownloadParams,
   ): Promise<FirmwareArtifactReceipt> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       val artifact = FirmwareArtifactStore.download(params)
       FirmwareArtifactReceipt(
         artifactRef = artifact.artifactRef,
@@ -291,7 +295,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun cancelFirmwareArtifactDownloads(
     params: FirmwareArtifactCancelParams,
   ): Promise<Unit> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactStore.cancelDownloads(params.transactionId)
     }
   }
@@ -299,7 +303,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun discardFirmwareArtifact(
     params: FirmwareArtifactRefParams,
   ): Promise<Unit> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactStore.discard(params.artifactRef)
     }
   }
@@ -307,7 +311,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun openFirmwareArtifact(
     params: FirmwareArtifactRefParams,
   ): Promise<FirmwareArtifactReaderInfo> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       val (readerId, size) = FirmwareArtifactStore.open(params.artifactRef)
       FirmwareArtifactReaderInfo(readerId = readerId, size = size.toDouble())
     }
@@ -316,7 +320,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun readFirmwareArtifact(
     params: FirmwareArtifactReaderReadParams,
   ): Promise<ArrayBuffer> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       require(
         params.offset.isFinite() &&
           params.offset >= 0 &&
@@ -340,7 +344,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun closeFirmwareArtifact(
     params: FirmwareArtifactReaderCloseParams,
   ): Promise<Unit> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactStore.close(params.readerId)
     }
   }
@@ -348,7 +352,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun materializeFirmwareArchive(
     params: FirmwareArchiveMaterializeParams,
   ): Promise<FirmwareArchiveMaterializeResult> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       val artifacts = FirmwareArtifactStore.materializeArchive(
         params.leaseRef,
         params.archiveArtifactRef,
@@ -372,7 +376,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun createFirmwareArtifactLease(
     params: FirmwareArtifactLeaseCreateParams,
   ): Promise<FirmwareArtifactLease> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactLease(
         leaseRef = FirmwareArtifactStore.createLease(params.transactionId),
       )
@@ -382,7 +386,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun retainFirmwareArtifact(
     params: FirmwareArtifactLeaseRetainParams,
   ): Promise<Unit> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactStore.retain(params.leaseRef, params.artifactRef)
     }
   }
@@ -390,13 +394,13 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun releaseFirmwareArtifactLease(
     params: FirmwareArtifactLeaseReleaseParams,
   ): Promise<Unit> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactStore.releaseLease(params.leaseRef, params.disposition)
     }
   }
 
   override fun sweepFirmwareArtifactOrphans(): Promise<FirmwareArtifactSweepResult> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       val (deletedFiles, deletedBytes) = FirmwareArtifactStore.sweepOrphans()
       FirmwareArtifactSweepResult(
         deletedFiles = deletedFiles.toDouble(),

package/ios/FirmwareArtifactStore.swift

@@ -56,7 +56,100 @@ private struct StagedFirmwareArchiveEntry {
   let stagingURL: URL
 }
 
-private final class FirmwareArtifactRedirectDelegate: NSObject, URLSessionTaskDelegate {
+private final class FirmwareArtifactStreamDelegate: NSObject, URLSessionDataDelegate {
+  private let partialURL: URL
+  private let hostname: String
+  private let resumeOffset: Int64
+  private let expectedSize: Int64
+  private let maxBytes: Int64
+  private let isCancelled: () -> Bool
+  private let stateLock = NSLock()
+  private var continuation: CheckedContinuation<Void, Error>?
+  private var dataTask: URLSessionDataTask?
+  private var cancellationRequested = false
+  private var completed = false
+  private var responseAccepted = false
+  private var handle: FileHandle?
+  private var written: Int64 = 0
+
+  init(
+    partialURL: URL,
+    hostname: String,
+    resumeOffset: Int64,
+    expectedSize: Int64,
+    maxBytes: Int64,
+    isCancelled: @escaping () -> Bool
+  ) {
+    self.partialURL = partialURL
+    self.hostname = hostname
+    self.resumeOffset = resumeOffset
+    self.expectedSize = expectedSize
+    self.maxBytes = maxBytes
+    self.isCancelled = isCancelled
+  }
+
+  func run(session: URLSession, request: URLRequest) async throws {
+    try await withTaskCancellationHandler {
+      try await withCheckedThrowingContinuation {
+        (continuation: CheckedContinuation<Void, Error>) in
+        let task = session.dataTask(with: request)
+        stateLock.lock()
+        if cancellationRequested || completed {
+          stateLock.unlock()
+          task.cancel()
+          continuation.resume(throwing: CancellationError())
+          return
+        }
+        self.continuation = continuation
+        dataTask = task
+        stateLock.unlock()
+        task.resume()
+      }
+    } onCancel: {
+      self.cancel()
+    }
+  }
+
+  private func cancel() {
+    stateLock.lock()
+    cancellationRequested = true
+    let task = dataTask
+    stateLock.unlock()
+    task?.cancel()
+  }
+
+  private func finish(_ result: Result<Void, Error>) {
+    stateLock.lock()
+    guard !completed else {
+      stateLock.unlock()
+      return
+    }
+    completed = true
+    let continuation = continuation
+    self.continuation = nil
+    dataTask = nil
+    let handle = handle
+    self.handle = nil
+    stateLock.unlock()
+
+    try? handle?.close()
+    continuation?.resume(with: result)
+  }
+
+  private func reject(
+    _ dataTask: URLSessionDataTask,
+    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void,
+    message: String
+  ) {
+    completionHandler(.cancel)
+    fail(dataTask, message: message)
+  }
+
+  private func fail(_ task: URLSessionTask, message: String) {
+    task.cancel()
+    finish(.failure(FirmwareArtifactStoreError.downloadFailed(message)))
+  }
+
   func urlSession(
     _ session: URLSession,
     task: URLSessionTask,
@@ -65,6 +158,192 @@ private final class FirmwareArtifactRedirectDelegate: NSObject, URLSessionTaskDe
     completionHandler: @escaping (URLRequest?) -> Void
   ) {
     completionHandler(nil)
+    fail(
+      task,
+      message:
+        "ARTIFACT_REDIRECT_REJECTED: firmware response changed canonical identity"
+    )
+  }
+
+  func urlSession(
+    _ session: URLSession,
+    dataTask: URLSessionDataTask,
+    didReceive response: URLResponse,
+    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void
+  ) {
+    guard !isCancelled() else {
+      reject(
+        dataTask,
+        completionHandler: completionHandler,
+        message: "ARTIFACT_CANCELLED: firmware artifact download was cancelled"
+      )
+      return
+    }
+    guard let httpResponse = response as? HTTPURLResponse else {
+      reject(
+        dataTask,
+        completionHandler: completionHandler,
+        message: "Firmware response is not HTTP"
+      )
+      return
+    }
+    guard
+      let responseURL = httpResponse.url,
+      responseURL.scheme?.lowercased() == "https",
+      responseURL.host?.lowercased() == hostname.lowercased(),
+      responseURL.port == nil || responseURL.port == 443
+    else {
+      reject(
+        dataTask,
+        completionHandler: completionHandler,
+        message:
+          "ARTIFACT_REDIRECT_REJECTED: firmware response changed canonical identity"
+      )
+      return
+    }
+    guard httpResponse.statusCode == 200 || httpResponse.statusCode == 206 else {
+      reject(
+        dataTask,
+        completionHandler: completionHandler,
+        message:
+          "ARTIFACT_HTTP_\(httpResponse.statusCode): firmware request failed"
+      )
+      return
+    }
+
+    let append = resumeOffset > 0 && httpResponse.statusCode == 206
+    if httpResponse.statusCode == 206 {
+      guard
+        let contentRange = httpResponse.value(
+          forHTTPHeaderField: "Content-Range"
+        ),
+        firmwareArtifactContentRangeIsValid(
+          contentRange,
+          expectedStart: append ? resumeOffset : 0,
+          expectedTotal: expectedSize
+        )
+      else {
+        reject(
+          dataTask,
+          completionHandler: completionHandler,
+          message:
+            "ARTIFACT_PROTOCOL_INVALID: firmware resume Content-Range is invalid"
+        )
+        return
+      }
+    }
+
+    let baseOffset = append ? resumeOffset : 0
+    guard
+      firmwareArtifactResponseFits(
+        expectedContentLength: httpResponse.expectedContentLength,
+        baseOffset: baseOffset,
+        maxBytes: maxBytes
+      )
+    else {
+      reject(
+        dataTask,
+        completionHandler: completionHandler,
+        message:
+          "ARTIFACT_PROTOCOL_INVALID: firmware artifact exceeds maxBytes"
+      )
+      return
+    }
+
+    do {
+      let handle = try FileHandle(forWritingTo: partialURL)
+      if append {
+        try handle.seekToEnd()
+      } else {
+        try handle.truncate(atOffset: 0)
+      }
+      self.handle = handle
+      written = baseOffset
+      responseAccepted = true
+      completionHandler(.allow)
+    } catch {
+      reject(
+        dataTask,
+        completionHandler: completionHandler,
+        message:
+          "ARTIFACT_NETWORK_FAILED: firmware partial file could not be opened"
+      )
+    }
+  }
+
+  func urlSession(
+    _ session: URLSession,
+    dataTask: URLSessionDataTask,
+    didReceive data: Data
+  ) {
+    guard responseAccepted, let handle else {
+      fail(
+        dataTask,
+        message:
+          "ARTIFACT_PROTOCOL_INVALID: firmware response stream was not accepted"
+      )
+      return
+    }
+    guard !isCancelled() else {
+      fail(
+        dataTask,
+        message: "ARTIFACT_CANCELLED: firmware artifact download was cancelled"
+      )
+      return
+    }
+    guard
+      firmwareArtifactResponseFits(
+        expectedContentLength: Int64(data.count),
+        baseOffset: written,
+        maxBytes: maxBytes
+      )
+    else {
+      fail(
+        dataTask,
+        message:
+          "ARTIFACT_PROTOCOL_INVALID: firmware artifact exceeds maxBytes"
+      )
+      return
+    }
+    do {
+      try handle.write(contentsOf: data)
+      written += Int64(data.count)
+    } catch {
+      fail(
+        dataTask,
+        message:
+          "ARTIFACT_NETWORK_FAILED: firmware response stream could not be persisted"
+      )
+    }
+  }
+
+  func urlSession(
+    _ session: URLSession,
+    task: URLSessionTask,
+    didCompleteWithError error: Error?
+  ) {
+    if let error {
+      finish(.failure(error))
+      return
+    }
+    guard responseAccepted, let handle else {
+      finish(
+        .failure(FirmwareArtifactStoreError.downloadFailed(
+          "ARTIFACT_PROTOCOL_INVALID: firmware response stream was not accepted"
+        ))
+      )
+      return
+    }
+    do {
+      try handle.synchronize()
+      finish(.success(()))
+    } catch {
+      finish(
+        .failure(FirmwareArtifactStoreError.downloadFailed(
+          "ARTIFACT_NETWORK_FAILED: firmware partial file could not be synchronized"
+        ))
+      )
+    }
   }
 }
 
@@ -219,7 +498,11 @@ final class FirmwareArtifactStore {
       transactionId: params.transactionId,
       artifactRef: "fw:\(expectedSha256)"
     )
-    let key = "\(expectedSha256):\(Int64(params.expectedSize))"
+    let key = firmwareArtifactDownloadKey(
+      transactionId: params.transactionId,
+      expectedSize: Int64(params.expectedSize),
+      expectedSha256: expectedSha256
+    )
     markDownloadActive(expectedSha256, delta: 1)
     do {
       let artifact = try await downloadCoordinator.run(
@@ -282,7 +565,11 @@ final class FirmwareArtifactStore {
     }
 
     let partialURL = rootURL.appendingPathComponent(
-      "\(expectedSha256).\(params.taskId).partial",
+      firmwareArtifactPartialFileName(
+        transactionId: params.transactionId,
+        taskId: params.taskId,
+        expectedSha256: expectedSha256
+      ),
       isDirectory: false
     )
     if !fileManager.fileExists(atPath: partialURL.path) {
@@ -913,6 +1200,29 @@ final class FirmwareArtifactStore {
     _ params: FirmwareArtifactDownloadParams,
     partialURL: URL,
     resumeOffset: Int64
+  ) async throws {
+    do {
+      try await FirmwareArtifactWallClockDeadline.run(
+        timeoutSeconds:
+          params.overallDeadlineSeconds ?? Self.defaultDownloadDeadline
+      ) { [self] in
+        try await streamDownloadWithinDeadline(
+          params,
+          partialURL: partialURL,
+          resumeOffset: resumeOffset
+        )
+      }
+    } catch FirmwareArtifactDeadlineError.exceeded {
+      throw FirmwareArtifactStoreError.downloadFailed(
+        "ARTIFACT_DEADLINE_EXCEEDED: firmware download exceeded its deadline"
+      )
+    }
+  }
+
+  private func streamDownloadWithinDeadline(
+    _ params: FirmwareArtifactDownloadParams,
+    partialURL: URL,
+    resumeOffset: Int64
   ) async throws {
     guard let url = URL(string: params.url), let hostname = url.host else {
       throw FirmwareArtifactStoreError.invalidInput("Invalid firmware URL")
@@ -926,19 +1236,30 @@ final class FirmwareArtifactStore {
       request.setValue("bytes=\(resumeOffset)-", forHTTPHeaderField: "Range")
     }
 
+    let streamDelegate = FirmwareArtifactStreamDelegate(
+      partialURL: partialURL,
+      hostname: hostname,
+      resumeOffset: resumeOffset,
+      expectedSize: Int64(params.expectedSize),
+      maxBytes: Int64(params.maxBytes),
+      isCancelled: { [weak self] in
+        Task.isCancelled ||
+          self?.isTransactionCancelled(params.transactionId) == true
+      }
+    )
     let pinnedSession: SniConnectPinnedSession?
     if params.routeType == "pinnedIp" {
       pinnedSession = try SniConnectPinnedTransport.makeSession(
           hostname: hostname,
-          ip: params.resolvedIp!
+          ip: params.resolvedIp!,
+          dataDelegate: streamDelegate
         )
     } else {
       pinnedSession = nil
     }
-    let domainDelegate = FirmwareArtifactRedirectDelegate()
     let session = pinnedSession?.session ?? URLSession(
       configuration: .ephemeral,
-      delegate: domainDelegate,
+      delegate: streamDelegate,
       delegateQueue: nil
     )
     defer {
@@ -949,76 +1270,8 @@ final class FirmwareArtifactStore {
       }
     }
 
-    let bytes: URLSession.AsyncBytes
-    let response: URLResponse
     do {
-      (bytes, response) = try await session.bytes(for: request)
-    } catch {
-      if isCancellationError(
-        error,
-        transactionId: params.transactionId
-      ) {
-        throw FirmwareArtifactStoreError.downloadFailed(
-          "ARTIFACT_CANCELLED: firmware artifact download was cancelled"
-        )
-      }
-      if isFirmwareArtifactTLSError(error) {
-        throw FirmwareArtifactStoreError.downloadFailed(
-          "ARTIFACT_TLS_FAILED: firmware TLS validation failed"
-        )
-      }
-      throw FirmwareArtifactStoreError.downloadFailed(
-        "ARTIFACT_NETWORK_FAILED: firmware request failed"
-      )
-    }
-    guard let httpResponse = response as? HTTPURLResponse else {
-      throw FirmwareArtifactStoreError.downloadFailed("Firmware response is not HTTP")
-    }
-    guard httpResponse.statusCode == 200 || httpResponse.statusCode == 206 else {
-      throw FirmwareArtifactStoreError.downloadFailed(
-        "ARTIFACT_HTTP_\(httpResponse.statusCode): firmware request failed"
-      )
-    }
-    let append = resumeOffset > 0 && httpResponse.statusCode == 206
-    if httpResponse.statusCode == 206 {
-      guard
-        let contentRange = httpResponse.value(forHTTPHeaderField: "Content-Range"),
-        validateContentRange(
-          contentRange,
-          expectedStart: append ? resumeOffset : 0,
-          expectedTotal: Int64(params.expectedSize)
-        )
-      else {
-        throw FirmwareArtifactStoreError.downloadFailed(
-          "ARTIFACT_PROTOCOL_INVALID: firmware resume Content-Range is invalid"
-        )
-      }
-    }
-    let handle = try FileHandle(forWritingTo: partialURL)
-    defer { try? handle.close() }
-    if append {
-      try handle.seekToEnd()
-    } else {
-      try handle.truncate(atOffset: 0)
-    }
-
-    var written = append ? resumeOffset : 0
-    var buffer = Data()
-    buffer.reserveCapacity(64 * 1024)
-    do {
-      for try await byte in bytes {
-        buffer.append(byte)
-        if buffer.count >= 64 * 1024 {
-          written += Int64(buffer.count)
-          guard written <= Int64(params.maxBytes) else {
-            throw FirmwareArtifactStoreError.downloadFailed(
-              "ARTIFACT_PROTOCOL_INVALID: firmware artifact exceeds maxBytes"
-            )
-          }
-          try handle.write(contentsOf: buffer)
-          buffer.removeAll(keepingCapacity: true)
-        }
-      }
+      try await streamDelegate.run(session: session, request: request)
     } catch let error as FirmwareArtifactStoreError {
       throw error
     } catch {
@@ -1036,19 +1289,9 @@ final class FirmwareArtifactStore {
         )
       }
       throw FirmwareArtifactStoreError.downloadFailed(
-        "ARTIFACT_NETWORK_FAILED: firmware response stream failed"
+        "ARTIFACT_NETWORK_FAILED: firmware request failed"
       )
     }
-    if !buffer.isEmpty {
-      written += Int64(buffer.count)
-      guard written <= Int64(params.maxBytes) else {
-        throw FirmwareArtifactStoreError.downloadFailed(
-          "ARTIFACT_PROTOCOL_INVALID: firmware artifact exceeds maxBytes"
-        )
-      }
-      try handle.write(contentsOf: buffer)
-    }
-    try handle.synchronize()
     try rejectIfCancelled(transactionId: params.transactionId)
   }
 
@@ -1079,34 +1322,6 @@ final class FirmwareArtifactStore {
       nsError.code == NSURLErrorCancelled
   }
 
-  private func validateContentRange(
-    _ value: String,
-    expectedStart: Int64,
-    expectedTotal: Int64
-  ) -> Bool {
-    let pattern = #"^bytes ([0-9]+)-([0-9]+)/([0-9]+)$"#
-    guard
-      let expression = try? NSRegularExpression(pattern: pattern),
-      let match = expression.firstMatch(
-        in: value.lowercased(),
-        range: NSRange(value.startIndex..., in: value)
-      ),
-      match.range.location != NSNotFound,
-      let startRange = Range(match.range(at: 1), in: value),
-      let endRange = Range(match.range(at: 2), in: value),
-      let totalRange = Range(match.range(at: 3), in: value),
-      let start = Int64(value[startRange]),
-      let end = Int64(value[endRange]),
-      let total = Int64(value[totalRange])
-    else {
-      return false
-    }
-    return start == expectedStart &&
-      end >= start &&
-      end < total &&
-      total == expectedTotal
-  }
-
   private func validateStoredArtifact(
     fileURL: URL,
     expectedSize: Int64,

package/ios/RangeDownloadLogic.swift

@@ -1,6 +1,126 @@
 import Foundation
 import CommonCrypto
 
+enum FirmwareArtifactDeadlineError: Error {
+  case exceeded
+}
+
+enum FirmwareArtifactWallClockDeadline {
+  static func run<T>(
+    timeoutSeconds: TimeInterval,
+    operation: @escaping @Sendable () async throws -> T
+  ) async throws -> T {
+    let timeoutNanoseconds = UInt64(max(0.001, timeoutSeconds) * 1_000_000_000.0)
+    return try await withThrowingTaskGroup(of: T.self) { group in
+      group.addTask {
+        try await operation()
+      }
+      group.addTask {
+        try await Task.sleep(nanoseconds: timeoutNanoseconds)
+        throw FirmwareArtifactDeadlineError.exceeded
+      }
+      defer { group.cancelAll() }
+      guard let result = try await group.next() else {
+        throw FirmwareArtifactDeadlineError.exceeded
+      }
+      return result
+    }
+  }
+}
+
+func firmwareArtifactDownloadKey(
+  transactionId: String,
+  expectedSize: Int64,
+  expectedSha256: String
+) -> String {
+  "\(transactionId)|\(expectedSize)|\(expectedSha256)"
+}
+
+func firmwareArtifactPartialFileName(
+  transactionId: String,
+  taskId: String,
+  expectedSha256: String
+) -> String {
+  let transactionData = Data(transactionId.utf8)
+  var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+  transactionData.withUnsafeBytes {
+    _ = CC_SHA256($0.baseAddress, CC_LONG(transactionData.count), &hash)
+  }
+  let transactionToken = hash
+    .prefix(8)
+    .map { String(format: "%02x", $0) }
+    .joined()
+  return "\(expectedSha256).\(taskId).\(transactionToken).partial"
+}
+
+func firmwareArtifactContentRangeIsValid(
+  _ value: String,
+  expectedStart: Int64,
+  expectedTotal: Int64
+) -> Bool {
+  guard value.lowercased().hasPrefix("bytes ") else {
+    return false
+  }
+  guard
+    let bounds = RangeDownloadLogic.parseContentRangeBounds(value),
+    let total = RangeDownloadLogic.parseContentRangeTotal(value)
+  else {
+    return false
+  }
+  return bounds.start == expectedStart &&
+    bounds.end >= bounds.start &&
+    bounds.end < total &&
+    total == expectedTotal
+}
+
+func firmwareArtifactResponseFits(
+  expectedContentLength: Int64,
+  baseOffset: Int64,
+  maxBytes: Int64
+) -> Bool {
+  guard baseOffset >= 0, baseOffset <= maxBytes else {
+    return false
+  }
+  return expectedContentLength < 0 ||
+    expectedContentLength <= maxBytes - baseOffset
+}
+
+enum FirmwareBackgroundDownloadError: LocalizedError, CustomStringConvertible {
+  case cancelled
+  case invalidTask
+  case deadlineExceeded
+  case redirectRejected
+  case responseRejected
+  case sizeRejected
+  case tlsRejected
+  case transferFailed
+
+  var errorDescription: String? {
+    switch self {
+    case .cancelled:
+      return "ARTIFACT_CANCELLED: firmware background download was cancelled"
+    case .invalidTask:
+      return "ARTIFACT_PROTOCOL_INVALID: firmware background task is invalid"
+    case .deadlineExceeded:
+      return "ARTIFACT_DEADLINE_EXCEEDED: firmware download exceeded its deadline"
+    case .redirectRejected:
+      return "ARTIFACT_REDIRECT_REJECTED: firmware redirect changed canonical identity"
+    case .responseRejected:
+      return "ARTIFACT_PROTOCOL_INVALID: firmware response is invalid"
+    case .sizeRejected:
+      return "ARTIFACT_PROTOCOL_INVALID: firmware artifact size is invalid"
+    case .tlsRejected:
+      return "ARTIFACT_TLS_FAILED: firmware TLS validation failed"
+    case .transferFailed:
+      return "ARTIFACT_NETWORK_FAILED: firmware background transfer failed"
+    }
+  }
+
+  var description: String {
+    errorDescription ?? "ARTIFACT_NETWORK_FAILED: firmware background transfer failed"
+  }
+}
+
 // MARK: - Dependency-free RangeDownloader logic (OCDS §4 / §5)
 //
 // This file holds the DETERMINISTIC, dependency-light pieces of the range

package/ios/ReactNativeRangeDownloader.swift

@@ -323,49 +323,22 @@ private struct FirmwareBackgroundTaskDescriptor: Codable, Equatable {
   let deadlineAt: TimeInterval
 
   var key: String {
-    "\(expectedSize)|\(expectedSha256)"
+    firmwareArtifactDownloadKey(
+      transactionId: transactionId,
+      expectedSize: expectedSize,
+      expectedSha256: expectedSha256
+    )
   }
 
-  func hasSameArtifactIdentity(
+  func hasSameDownloadIdentity(
     as other: FirmwareBackgroundTaskDescriptor
   ) -> Bool {
-    expectedSize == other.expectedSize &&
+    transactionId == other.transactionId &&
+      expectedSize == other.expectedSize &&
       expectedSha256 == other.expectedSha256
   }
 }
 
-private enum FirmwareBackgroundDownloadError: LocalizedError {
-  case cancelled
-  case invalidTask
-  case deadlineExceeded
-  case redirectRejected
-  case responseRejected
-  case sizeRejected
-  case tlsRejected
-  case transferFailed
-
-  var errorDescription: String? {
-    switch self {
-    case .cancelled:
-      return "ARTIFACT_CANCELLED: firmware background download was cancelled"
-    case .invalidTask:
-      return "ARTIFACT_PROTOCOL_INVALID: firmware background task is invalid"
-    case .deadlineExceeded:
-      return "ARTIFACT_DEADLINE_EXCEEDED: firmware download exceeded its deadline"
-    case .redirectRejected:
-      return "ARTIFACT_REDIRECT_REJECTED: firmware redirect changed canonical identity"
-    case .responseRejected:
-      return "ARTIFACT_PROTOCOL_INVALID: firmware response is invalid"
-    case .sizeRejected:
-      return "ARTIFACT_PROTOCOL_INVALID: firmware artifact size is invalid"
-    case .tlsRejected:
-      return "ARTIFACT_TLS_FAILED: firmware TLS validation failed"
-    case .transferFailed:
-      return "ARTIFACT_NETWORK_FAILED: firmware background transfer failed"
-    }
-  }
-}
-
 public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
 
   public static let shared = RangeDownloader()
@@ -836,9 +809,12 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
       else {
         continue
       }
-      if candidate.hasSameArtifactIdentity(as: descriptor) {
+      if candidate.hasSameDownloadIdentity(as: descriptor) {
         matchingTaskFound = true
-      } else if candidate.taskId == descriptor.taskId {
+      } else if
+        candidate.transactionId == descriptor.transactionId &&
+        candidate.taskId == descriptor.taskId
+      {
         task.cancel()
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-range-downloader",
-  "version": "3.0.81-alpha.2",
+  "version": "3.0.81-alpha.4",
   "description": "react-native-range-downloader",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -88,7 +88,7 @@
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
-    "@onekeyfe/react-native-sni-connect": "3.0.81-alpha.2",
+    "@onekeyfe/react-native-sni-connect": "3.0.81-alpha.4",
     "react": "*",
     "react-native": "*",
     "react-native-nitro-modules": "0.33.2"