react-native-update 10.48.3 → 10.49.0

package/android/src/main/java/cn/reactnative/modules/update/UpdateModuleImpl.java

@@ -191,6 +191,17 @@ public class UpdateModuleImpl {
         });
     }
 
+    public static void getBundleHash(final UpdateContext updateContext, final Promise promise) {
+        // Threading lives in UpdateContext (download executor); resolve is
+        // thread-safe. Never rejects — empty string means "unknown".
+        updateContext.getBundleHash(new UpdateContext.BundleHashListener() {
+            @Override
+            public void onBundleHash(String hash) {
+                promise.resolve(hash);
+            }
+        });
+    }
+
     public static void resetToPackagedBundle(
         final UpdateContext updateContext,
         final Promise promise

package/android/src/newarch/cn/reactnative/modules/update/UpdateModule.java

@@ -73,6 +73,11 @@ public class UpdateModule extends NativePushySpec {
         UpdateModuleImpl.markSuccess(updateContext, promise);
     }
 
+    @Override
+    public void getBundleHash(Promise promise) {
+        UpdateModuleImpl.getBundleHash(updateContext, promise);
+    }
+
     @Override
     public void resetToPackagedBundle(Promise promise) {
         UpdateModuleImpl.resetToPackagedBundle(updateContext, promise);

package/android/src/oldarch/cn/reactnative/modules/update/UpdateModule.java

@@ -75,6 +75,11 @@ public class UpdateModule extends ReactContextBaseJavaModule {
         UpdateModuleImpl.markSuccess(updateContext);
     }
 
+    @ReactMethod
+    public void getBundleHash(Promise promise) {
+        UpdateModuleImpl.getBundleHash(updateContext, promise);
+    }
+
     @ReactMethod
     public void resetToPackagedBundle(Promise promise) {
         UpdateModuleImpl.resetToPackagedBundle(updateContext, promise);

package/cpp/patch_core/digest.cpp

@@ -0,0 +1,177 @@
+#include "digest.h"
+
+#include <cstdio>
+#include <cstring>
+
+namespace pushy {
+namespace digest {
+
+namespace {
+
+// FIPS 180-4 SHA-256 round constants.
+constexpr uint32_t kRoundConstants[64] = {
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+};
+
+inline uint32_t RotateRight(uint32_t value, uint32_t bits) {
+  return (value >> bits) | (value << (32 - bits));
+}
+
+}  // namespace
+
+Sha256::Sha256() {
+  state_[0] = 0x6a09e667;
+  state_[1] = 0xbb67ae85;
+  state_[2] = 0x3c6ef372;
+  state_[3] = 0xa54ff53a;
+  state_[4] = 0x510e527f;
+  state_[5] = 0x9b05688c;
+  state_[6] = 0x1f83d9ab;
+  state_[7] = 0x5be0cd19;
+}
+
+void Sha256::ProcessBlock(const uint8_t* block) {
+  uint32_t w[64];
+  for (int i = 0; i < 16; i++) {
+    w[i] = (static_cast<uint32_t>(block[i * 4]) << 24) |
+           (static_cast<uint32_t>(block[i * 4 + 1]) << 16) |
+           (static_cast<uint32_t>(block[i * 4 + 2]) << 8) |
+           static_cast<uint32_t>(block[i * 4 + 3]);
+  }
+  for (int i = 16; i < 64; i++) {
+    const uint32_t s0 = RotateRight(w[i - 15], 7) ^ RotateRight(w[i - 15], 18) ^
+                        (w[i - 15] >> 3);
+    const uint32_t s1 = RotateRight(w[i - 2], 17) ^ RotateRight(w[i - 2], 19) ^
+                        (w[i - 2] >> 10);
+    w[i] = w[i - 16] + s0 + w[i - 7] + s1;
+  }
+
+  uint32_t a = state_[0];
+  uint32_t b = state_[1];
+  uint32_t c = state_[2];
+  uint32_t d = state_[3];
+  uint32_t e = state_[4];
+  uint32_t f = state_[5];
+  uint32_t g = state_[6];
+  uint32_t h = state_[7];
+
+  for (int i = 0; i < 64; i++) {
+    const uint32_t s1 =
+        RotateRight(e, 6) ^ RotateRight(e, 11) ^ RotateRight(e, 25);
+    const uint32_t ch = (e & f) ^ (~e & g);
+    const uint32_t temp1 = h + s1 + ch + kRoundConstants[i] + w[i];
+    const uint32_t s0 =
+        RotateRight(a, 2) ^ RotateRight(a, 13) ^ RotateRight(a, 22);
+    const uint32_t maj = (a & b) ^ (a & c) ^ (b & c);
+    const uint32_t temp2 = s0 + maj;
+
+    h = g;
+    g = f;
+    f = e;
+    e = d + temp1;
+    d = c;
+    c = b;
+    b = a;
+    a = temp1 + temp2;
+  }
+
+  state_[0] += a;
+  state_[1] += b;
+  state_[2] += c;
+  state_[3] += d;
+  state_[4] += e;
+  state_[5] += f;
+  state_[6] += g;
+  state_[7] += h;
+}
+
+void Sha256::Update(const uint8_t* data, size_t length) {
+  total_length_ += length;
+
+  if (buffer_length_ > 0) {
+    const size_t fill = 64 - buffer_length_;
+    const size_t take = length < fill ? length : fill;
+    std::memcpy(buffer_ + buffer_length_, data, take);
+    buffer_length_ += take;
+    data += take;
+    length -= take;
+    if (buffer_length_ < 64) {
+      return;
+    }
+    ProcessBlock(buffer_);
+    buffer_length_ = 0;
+  }
+
+  while (length >= 64) {
+    ProcessBlock(data);
+    data += 64;
+    length -= 64;
+  }
+
+  if (length > 0) {
+    std::memcpy(buffer_, data, length);
+    buffer_length_ = length;
+  }
+}
+
+std::string Sha256::HexDigest() {
+  // Padding: 0x80, zeros, then the 64-bit big-endian bit length.
+  const uint64_t bit_length = total_length_ * 8;
+  const uint8_t pad_byte = 0x80;
+  Update(&pad_byte, 1);
+  const uint8_t zero = 0x00;
+  // total_length_ is mutated by the padding updates; the final length field is
+  // captured above, so this loop only needs to reach the 56-byte boundary.
+  while (buffer_length_ != 56) {
+    Update(&zero, 1);
+  }
+  uint8_t length_bytes[8];
+  for (int i = 0; i < 8; i++) {
+    length_bytes[i] = static_cast<uint8_t>(bit_length >> (56 - i * 8));
+  }
+  Update(length_bytes, 8);
+
+  static const char kHex[] = "0123456789abcdef";
+  std::string out;
+  out.reserve(64);
+  for (int i = 0; i < 8; i++) {
+    for (int shift = 24; shift >= 0; shift -= 8) {
+      const uint8_t byte = static_cast<uint8_t>(state_[i] >> shift);
+      out.push_back(kHex[byte >> 4]);
+      out.push_back(kHex[byte & 0x0f]);
+    }
+  }
+  return out;
+}
+
+std::string Sha256File(const std::string& path) {
+  std::FILE* file = std::fopen(path.c_str(), "rb");
+  if (file == nullptr) {
+    return std::string();
+  }
+  Sha256 hasher;
+  uint8_t buffer[64 * 1024];
+  size_t read = 0;
+  while ((read = std::fread(buffer, 1, sizeof(buffer), file)) > 0) {
+    hasher.Update(buffer, read);
+  }
+  const bool failed = std::ferror(file) != 0;
+  std::fclose(file);
+  if (failed) {
+    return std::string();
+  }
+  return hasher.HexDigest();
+}
+
+}  // namespace digest
+}  // namespace pushy

package/cpp/patch_core/digest.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace pushy {
+namespace digest {
+
+// Streaming SHA-256 (FIPS 180-4). Used for bundleHash (the identity of the
+// bundle embedded in the binary) and, later, download artifact verification
+// (IO-6). Streaming because Android/Harmony read the bundle from the package
+// (AssetManager / rawfile) rather than from a plain file.
+//
+// Android intentionally does NOT use this implementation: librnupdate.so is a
+// prebuilt artifact, so the Java layer hashes with java.security.MessageDigest
+// instead. The NIST vectors in the tests anchor both implementations to the
+// same standard.
+class Sha256 {
+ public:
+  Sha256();
+
+  void Update(const uint8_t* data, size_t length);
+
+  // Finalizes and returns the lowercase hex digest. The instance must not be
+  // reused afterwards.
+  std::string HexDigest();
+
+ private:
+  void ProcessBlock(const uint8_t* block);
+
+  uint32_t state_[8];
+  uint64_t total_length_ = 0;
+  uint8_t buffer_[64];
+  size_t buffer_length_ = 0;
+};
+
+// Hashes a file on disk (streaming, bounded memory). Returns the lowercase hex
+// digest, or an empty string if the file cannot be read.
+std::string Sha256File(const std::string& path);
+
+}  // namespace digest
+}  // namespace pushy

package/cpp/patch_core/tests/patch_core_test.cpp

@@ -1,4 +1,5 @@
 #include "../archive_patch_core.h"
+#include "../digest.h"
 #include "../patch_core.h"
 #include "../state_core.h"
 
@@ -747,6 +748,72 @@ void TestStateCoreSwitchToSameVersion() {
   Expect(!switched.first_time_ok, "first_time_ok should be false");
 }
 
+// NIST FIPS 180-4 vectors. These anchor the C++ implementation (iOS/Harmony)
+// and, by transitivity, Android's java.security.MessageDigest and the CLI's
+// node:crypto to the same standard — the bundleHash produced on any of them
+// must be byte-identical for the same input.
+void TestSha256KnownVectors() {
+  {
+    pushy::digest::Sha256 hasher;
+    ExpectEq(
+        hasher.HexDigest(),
+        "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256 of empty input");
+  }
+  {
+    pushy::digest::Sha256 hasher;
+    const char* input = "abc";
+    hasher.Update(reinterpret_cast<const uint8_t*>(input), 3);
+    ExpectEq(
+        hasher.HexDigest(),
+        "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+        "sha256 of \"abc\"");
+  }
+  {
+    pushy::digest::Sha256 hasher;
+    const std::string input =
+        "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
+    hasher.Update(
+        reinterpret_cast<const uint8_t*>(input.data()), input.size());
+    ExpectEq(
+        hasher.HexDigest(),
+        "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1",
+        "sha256 of NIST two-block message");
+  }
+}
+
+void TestSha256StreamingMatchesOneShot() {
+  // One million 'a' (NIST long vector), fed in deliberately awkward chunk
+  // sizes to cross every buffer boundary case in Update.
+  const std::string chunk(4096 + 37, 'a');
+  size_t remaining = 1000000;
+  pushy::digest::Sha256 hasher;
+  while (remaining > 0) {
+    const size_t take = remaining < chunk.size() ? remaining : chunk.size();
+    hasher.Update(reinterpret_cast<const uint8_t*>(chunk.data()), take);
+    remaining -= take;
+  }
+  ExpectEq(
+      hasher.HexDigest(),
+      "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0",
+      "sha256 of one million 'a' fed in odd-sized chunks");
+}
+
+void TestSha256File() {
+  TempDir temp;
+  const std::string dir = temp.path;
+  const std::string path = dir + "/input.bin";
+  WriteFile(path, "abc");
+  ExpectEq(
+      pushy::digest::Sha256File(path),
+      "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+      "Sha256File over a small file");
+  ExpectEq(
+      pushy::digest::Sha256File(dir + "/missing.bin"),
+      "",
+      "Sha256File over a missing file returns empty");
+}
+
 }  // namespace
 
 int main(int argc, char** argv) {
@@ -778,6 +845,9 @@ int main(int argc, char** argv) {
       {"StateCoreRollbackToEmptyVersion", TestStateCoreRollbackToEmptyVersion},
       {"StateCoreResolveLaunchNoCurrentVersion", TestStateCoreResolveLaunchNoCurrentVersion},
       {"StateCoreSwitchToSameVersion", TestStateCoreSwitchToSameVersion},
+      {"Sha256KnownVectors", TestSha256KnownVectors},
+      {"Sha256StreamingMatchesOneShot", TestSha256StreamingMatchesOneShot},
+      {"Sha256File", TestSha256File},
   };
 
   int failures = 0;

package/harmony/pushy/src/main/cpp/CMakeLists.txt

@@ -27,6 +27,7 @@ set(LZMA_DIR ${ANDROID_JNI_DIR}/lzma)
 set(HDP_SOURCES
      ${CMAKE_CURRENT_SOURCE_DIR}/pushy.cpp
      ${PATCH_CORE_DIR}/archive_patch_core.cpp
+     ${PATCH_CORE_DIR}/digest.cpp
      ${PATCH_CORE_DIR}/hbc_transform.cpp
      ${PATCH_CORE_DIR}/hbc_transform_wire.cpp
      ${PATCH_CORE_DIR}/patch_core.cpp

package/harmony/pushy/src/main/cpp/pushy.cpp

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "archive_patch_core.h"
+#include "digest.h"
 #include "hbc_transform_wire.h"
 #include "patch_core.h"
 #include "state_core.h"
@@ -890,6 +891,51 @@ bool ExportFunction(
 }  // namespace
 
 
+// sha256(Uint8Array | ArrayBuffer) -> 小写 hex。同步：bundleHash 的输入是
+// rawfile 里的 bundle(已整体读入内存,与 pdiff 的读法一致),哈希本身毫秒级。
+static napi_value Sha256Hex(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1] = {nullptr};
+  if (!GetArgCount(env, info, &argc, args) || argc < 1) {
+    ThrowError(env, "sha256Hex: missing data argument");
+    return nullptr;
+  }
+
+  void* data = nullptr;
+  size_t length = 0;
+  bool is_typedarray = false;
+  napi_is_typedarray(env, args[0], &is_typedarray);
+  if (is_typedarray) {
+    napi_typedarray_type type;
+    napi_value arraybuffer = nullptr;
+    size_t offset = 0;
+    if (napi_get_typedarray_info(
+            env, args[0], &type, &length, &data, &arraybuffer, &offset) !=
+        napi_ok) {
+      ThrowError(env, "sha256Hex: cannot read typed array");
+      return nullptr;
+    }
+  } else {
+    bool is_arraybuffer = false;
+    napi_is_arraybuffer(env, args[0], &is_arraybuffer);
+    if (!is_arraybuffer ||
+        napi_get_arraybuffer_info(env, args[0], &data, &length) != napi_ok) {
+      ThrowError(env, "sha256Hex: expected Uint8Array or ArrayBuffer");
+      return nullptr;
+    }
+  }
+
+  pushy::digest::Sha256 hasher;
+  if (length > 0) {
+    hasher.Update(static_cast<const uint8_t*>(data), length);
+  }
+  const std::string hex = hasher.HexDigest();
+
+  napi_value result = nullptr;
+  napi_create_string_utf8(env, hex.c_str(), hex.size(), &result);
+  return result;
+}
+
 // 原生 patch 内核可消费的 diff 轨道版本(2 = hdiffv2 轨道)
 static napi_value GetSupportedDiffVersion(napi_env env, napi_callback_info) {
   napi_value result = nullptr;
@@ -907,6 +953,7 @@ napi_value Init(napi_env env, napi_value exports) {
       !ExportFunction(env, exports, "buildCopyGroups", BuildCopyGroups) ||
       !ExportFunction(env, exports, "applyPatchFromFileSource", ApplyPatchFromFileSource) ||
       !ExportFunction(env, exports, "cleanupOldEntries", CleanupOldEntries) ||
+      !ExportFunction(env, exports, "sha256Hex", Sha256Hex) ||
       !ExportFunction(env, exports, "getSupportedDiffVersion", GetSupportedDiffVersion)) {
     return nullptr;
   }

package/harmony/pushy/src/main/ets/NativePatchCore.ts

@@ -80,6 +80,8 @@ interface NativePatchCoreBindings {
     keepPrevious: string,
     maxAgeDays: number,
   ): Promise<void>;
+  /** sha256(小写 hex)。同步:输入是已在内存的 rawfile bundle,哈希毫秒级 */
+  sha256Hex(data: Uint8Array): string;
   /** 原生 patch 内核可消费的 diff 轨道版本(2 = hdiffv2 轨道) */
   getSupportedDiffVersion(): number;
 }

package/harmony/pushy/src/main/ets/PushyTurboModule.ts

@@ -233,6 +233,17 @@ export class PushyTurboModule extends UITurboModule {
     }
   }
 
+  async getBundleHash(): Promise<string> {
+    logger.debug(TAG, ',call getBundleHash');
+    try {
+      return this.context.getBundleHash();
+    } catch (error) {
+      // 空串 = "未知",服务端回退 buildTime 启发式;该方法永不 reject。
+      logger.error(TAG, `getBundleHash failed: ${getErrorMessage(error)}`);
+      return '';
+    }
+  }
+
   async resetToPackagedBundle(): Promise<void> {
     logger.debug(TAG, ',call resetToPackagedBundle');
     try {

package/harmony/pushy/src/main/ets/UpdateContext.ts

@@ -632,4 +632,58 @@ export class UpdateContext {
   public getIsUsingBundleUrl(): boolean {
     return UpdateContext.isUsingBundleUrl;
   }
+
+  // bundleHash 缓存:"<packageVersion>|<updateTime>|<sha256hex>"。键标识当前
+  // 安装的二进制,每次(覆盖)安装 updateTime 都会变,每个安装只算一次。
+  private static readonly KEY_BUNDLE_HASH_CACHE = 'bundleHashCache';
+
+  private getBundleUpdateTime(): number {
+    try {
+      const bundleInfo = bundleManager.getBundleInfoForSelfSync(
+        this.getBundleFlags(),
+      );
+      return bundleInfo?.updateTime ?? 0;
+    } catch (error) {
+      console.error('Failed to get bundle update time:', error);
+      return 0;
+    }
+  }
+
+  /**
+   * bundleHash = 二进制内嵌 JS bundle 的 sha256 —— 标识二进制本身,与当前运行
+   * 的热更版本无关。哈希对象与 pdiff 的源读取完全一致:rawfile 的
+   * bundle.harmony.js(DownloadTask.doPatchFromApp 同一读法)。懒计算 + 缓存;
+   * 永不失败——空串表示"未知",服务端回退 buildTime 启发式。
+   */
+  public async getBundleHash(): Promise<string> {
+    if (UpdateContext.DEBUG) {
+      // debug 下 bundle 由 metro 提供,与 dev 删 buildTime 的行为对齐。
+      return '';
+    }
+    const cachePrefix = `${this.getPackageVersion()}|${this.getBundleUpdateTime()}|`;
+    const cached = this.readString(UpdateContext.KEY_BUNDLE_HASH_CACHE);
+    if (cached.startsWith(cachePrefix)) {
+      return cached.slice(cachePrefix.length);
+    }
+    let hash = '';
+    try {
+      // 异步读:TurboModule 跑在 UI 线程,同步读几 MB 会卡主线程一次。C++
+      // 哈希本身毫秒级,同步无妨。
+      const content =
+        await this.context.resourceManager.getRawFileContent('bundle.harmony.js');
+      hash = NativePatchCore.sha256Hex(content);
+    } catch (error) {
+      // rawfile 缺 bundle(未打包 release bundle)是合法的"未知",不是错误。
+      console.info('Cannot hash embedded bundle:', error);
+      return '';
+    }
+    if (hash) {
+      this.preferences.putSync(
+        UpdateContext.KEY_BUNDLE_HASH_CACHE,
+        cachePrefix + hash,
+      );
+      this.flushPreferences('cache bundle hash');
+    }
+    return hash;
+  }
 }

package/ios/RCTPushy/RCTPushy.mm

@@ -2,6 +2,7 @@
 #import "RCTPushyDownloader.h"
 #import "ZipArchive.h"
 #include "../../cpp/patch_core/archive_patch_core.h"
+#include "../../cpp/patch_core/digest.h"
 #include "../../cpp/patch_core/hbc_transform_wire.h"
 #include "../../cpp/patch_core/error_codes.h"
 #include "../../cpp/patch_core/patch_core.h"
@@ -32,6 +33,10 @@ static NSString *const keyHashInfo = @"REACTNATIVECN_PUSHY_HASH_";
 static NSString *const keyFirstLoadMarked = @"REACTNATIVECN_PUSHY_FIRSTLOADMARKED_KEY";
 static NSString *const keyRolledBackMarked = @"REACTNATIVECN_PUSHY_ROLLEDBACKMARKED_KEY";
 static NSString *const KeyPackageUpdatedMarked = @"REACTNATIVECN_PUSHY_ISPACKAGEUPDATEDMARKED_KEY";
+// bundleHash cache: "<cacheKey>|<sha256hex>" where cacheKey identifies the
+// installed binary (packageVersion + embedded bundle size + mtime). Recomputed
+// only when the key changes, i.e. once per install.
+static NSString *const keyBundleHashCache = @"REACTNATIVECN_PUSHY_BUNDLEHASH_KEY";
 static NSString *const PushyErrorDomain = @"cn.reactnative.pushy";
 
 // file def
@@ -512,6 +517,56 @@ RCT_EXPORT_METHOD(restartApp:(RCTPromiseResolveBlock)resolve
     resolve(@true);
 }
 
+RCT_EXPORT_METHOD(getBundleHash:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    // bundleHash = sha256 of the bundle embedded in the binary — the identity
+    // of the binary itself, not of whatever hot update is currently running.
+    // It must hash exactly the bytes pdiff patches from (binaryBundleURL, the
+    // pdiff fromBundle). Lazily computed once per install, cached in defaults.
+    // Never rejects: an empty string means "unknown" and the server falls back
+    // to the buildTime heuristic.
+#if DEBUG
+    // Metro serves the bundle in debug; the embedded file (if any) is not what
+    // is running. Mirrors the dev behaviour of buildTime.
+    resolve(@"");
+#else
+    dispatch_async(_fileQueue, ^{
+        NSString *path = [[RCTPushy binaryBundleURL] path];
+        if (path == nil) {
+            resolve(@"");
+            return;
+        }
+        NSDictionary *attributes =
+            [[NSFileManager defaultManager] attributesOfItemAtPath:path error:nil];
+        if (attributes == nil) {
+            resolve(@"");
+            return;
+        }
+        NSString *cacheKey = [NSString stringWithFormat:@"%@|%llu|%.0f",
+            [RCTPushy packageVersion],
+            attributes.fileSize,
+            [attributes.fileModificationDate timeIntervalSince1970]];
+
+        NSUserDefaults *defaults = PushyDefaults();
+        NSString *cached = [defaults stringForKey:keyBundleHashCache];
+        NSString *cachedPrefix = [cacheKey stringByAppendingString:@"|"];
+        if ([cached hasPrefix:cachedPrefix]) {
+            resolve([cached substringFromIndex:cachedPrefix.length]);
+            return;
+        }
+
+        NSString *hash = PushyFromStdString(
+            pushy::digest::Sha256File(PushyToStdString(path))) ?: @"";
+        if (hash.length > 0) {
+            [defaults setObject:[cachedPrefix stringByAppendingString:hash]
+                         forKey:keyBundleHashCache];
+        }
+        resolve(hash);
+    });
+#endif
+}
+
 RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
                                     rejecter:(RCTPromiseRejectBlock)reject)
 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update",
-  "version": "10.48.3",
+  "version": "10.49.0",
   "description": "react-native hot update",
   "main": "src/index",
   "types": "src/index.ts",

package/react-native-update.podspec

@@ -111,6 +111,7 @@ Pod::Spec.new do |s|
   s.subspec 'RCTPushy' do |ss|
     ss.source_files = ['ios/RCTPushy/*.{h,m,mm}',
                        'cpp/patch_core/archive_patch_core.{h,cpp}',
+                       'cpp/patch_core/digest.{h,cpp}',
                        'cpp/patch_core/hbc_transform.{h,cpp}',
                        'cpp/patch_core/hbc_transform_wire.{h,cpp}',
                        'cpp/patch_core/patch_core.{h,cpp}',

package/src/NativePushy.ts

@@ -20,6 +20,12 @@ export interface Spec extends TurboModule {
   restartApp(): Promise<void>;
   setNeedUpdate(options: { hash: string }): Promise<void>;
   markSuccess(): Promise<void>;
+  /**
+   * sha256 of the JS bundle embedded in the binary (the pdiff source), lazily
+   * computed and cached natively. Resolves to an empty string when unknown
+   * (debug build, no embedded bundle, hash failure) — never rejects.
+   */
+  getBundleHash(): Promise<string>;
   resetToPackagedBundle(): Promise<void>;
   downloadPatchFromPpk(options: {
     updateUrl: string;