@derec-alliance/react-native 0.0.5 → 0.0.7

package/cpp/ProtocolHost.cpp

@@ -26,7 +26,16 @@ namespace {
 /// failure.
 struct FfiFailure {
   explicit FfiFailure(DeRecError e) : error(e) {}
+  FfiFailure(DeRecError e, std::vector<uint8_t> channelIdsJson)
+      : error(e), conflictingChannelIdsJson(std::move(channelIdsJson)) {}
+  FfiFailure(DeRecError e, ProcessFailureDetails details)
+      : error(e), process(std::move(details)) {}
   DeRecError error;
+  /// `restore`'s JSON array of colliding channel ids, empty for every other
+  /// failure. Carried as raw bytes: parsing needs the runtime.
+  std::vector<uint8_t> conflictingChannelIdsJson;
+  /// `process`'s events and failing channel, empty for every other failure.
+  ProcessFailureDetails process;
 };
 
 constexpr const char* kReentrancyMessage =
@@ -170,10 +179,14 @@ jsi::Value ProtocolHost::runAsync(
               bool failed = false;
               bool unknownFailure = false;
               DeRecError capturedError{};
+              std::vector<uint8_t> capturedChannelIdsJson;
+              ProcessFailureDetails capturedProcess;
               try {
                 bytes = body();
-              } catch (const FfiFailure& failure) {
+              } catch (FfiFailure& failure) {
                 capturedError = failure.error;
+                capturedChannelIdsJson = std::move(failure.conflictingChannelIdsJson);
+                capturedProcess = std::move(failure.process);
                 failed = true;
               } catch (...) {
                 // Anything other than `FfiFailure` — `std::bad_alloc` from
@@ -198,7 +211,11 @@ jsi::Value ProtocolHost::runAsync(
 
               invoker->invokeAsync([state, runtime, resolve, reject, convert,
                                     bytes = std::move(bytes), failed,
-                                    unknownFailure, capturedError]() mutable {
+                                    unknownFailure, capturedError,
+                                    capturedChannelIdsJson =
+                                        std::move(capturedChannelIdsJson),
+                                    capturedProcess =
+                                        std::move(capturedProcess)]() mutable {
                 if (state->runtimeInvalidated.load()) {
                   // Queued before the runtime was torn down, reached only
                   // afterwards. Every JSI call below — including the ones the
@@ -212,7 +229,8 @@ jsi::Value ProtocolHost::runAsync(
                     // Reuses the exact error shape every synchronous FFI
                     // wrapper throws, rather than inventing a second one for
                     // the asynchronous path.
-                    throwDeRecError(jsRt, capturedError);
+                    throwDeRecError(jsRt, capturedError, capturedChannelIdsJson,
+                                    capturedProcess);
                   }
                   if (unknownFailure) {
                     throw jsi::JSError(jsRt, "DeRec: an unexpected native error occurred");
@@ -269,9 +287,8 @@ jsi::Value ProtocolHost::get(jsi::Runtime& rt, const jsi::PropNameID& name) {
                size_t) -> jsi::Value { return hostSecretId(rt2, secretId_); });
   }
 
-  // `setCommunicationInfo` and `setOwnTransport` return a Promise, unlike
-  // `@derec-alliance/nodejs` where both are synchronous. They must not run on
-  // the JavaScript thread: `derec_protocol_set_*` takes the same handle mutex
+  // `setCommunicationInfo` and `setOwnTransports` return a Promise, as in
+  // `@derec-alliance/nodejs`. They must not run on the JavaScript thread: `derec_protocol_set_*` takes the same handle mutex
   // that `derec_protocol_process`/`start`/`restore` hold for the whole
   // duration of a flow, including across store callbacks that park the worker
   // waiting on the JavaScript thread. Calling the setter synchronously would
@@ -281,9 +298,7 @@ jsi::Value ProtocolHost::get(jsi::Runtime& rt, const jsi::PropNameID& name) {
   // callback into a backend failure. The nodejs SDK is WASM and
   // single-threaded, so the hazard cannot arise there. Queuing onto the
   // serial worker instead orders the setter behind any in-flight flow, and
-  // returning a Promise keeps a caller that ignores the result — which is how
-  // nodejs code calls these — source-compatible, while letting a failure
-  // surface as a rejection rather than being swallowed.
+  // a failure surfaces as a rejection rather than being swallowed.
   if (prop == "setCommunicationInfo") {
     return jsi::Function::createFromHostFunction(
         rt, name, 1,
@@ -309,38 +324,6 @@ jsi::Value ProtocolHost::get(jsi::Runtime& rt, const jsi::PropNameID& name) {
         });
   }
 
-  if (prop == "setOwnTransport") {
-    return jsi::Function::createFromHostFunction(
-        rt, name, 2,
-        [this](jsi::Runtime& rt2, const jsi::Value&, const jsi::Value* args,
-               size_t count) -> jsi::Value {
-          requireArgs(rt2, "setOwnTransport", count, 2);
-          std::string uri = args[0].asString(rt2).utf8(rt2);
-          auto protocol = static_cast<int32_t>(args[1].asNumber());
-          DeRecProtocolHandle* handle = handle_;
-
-          auto body = [handle, uri, protocol]() -> std::vector<uint8_t> {
-// This binding *is* the deprecated single-endpoint path, so it calls the
-// deprecated export on purpose — the same reason the Rust side carries
-// `#[allow(deprecated)]` on its compatibility paths. Both go at 0.0.5.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-            DeRecError error = derec_protocol_set_own_transport(
-                handle, reinterpret_cast<const uint8_t*>(uri.data()), uri.size(),
-                protocol);
-#pragma GCC diagnostic pop
-            if (error.code != DEREC_CODE_OK) {
-              throw FfiFailure(error);
-            }
-            return {};
-          };
-          auto convert = [](jsi::Runtime&, std::vector<uint8_t>&) {
-            return jsi::Value::undefined();
-          };
-          return runAsync(rt2, std::move(body), std::move(convert));
-        });
-  }
-
   // Takes the endpoint list already JSON-encoded, the same way
   // `setCommunicationInfo` takes its map: the FFI parses JSON on the other
   // side, so encoding in JavaScript keeps this bridge free of a shape it
@@ -433,12 +416,16 @@ jsi::Value ProtocolHost::get(jsi::Runtime& rt, const jsi::PropNameID& name) {
 
           auto body = [handle,
                       message = std::move(message)]() -> std::vector<uint8_t> {
-            DeRecProtocolEventsResult result =
+            DeRecProtocolProcessResult result =
                 derec_protocol_process(handle, message.data(), message.size());
+            std::vector<uint8_t> events = takeBuffer(result.events_json);
             if (result.error.code != DEREC_CODE_OK) {
-              throw FfiFailure(result.error);
+              throw FfiFailure(result.error,
+                               ProcessFailureDetails{std::move(events),
+                                                     result.has_channel_id,
+                                                     result.channel_id});
             }
-            return takeBuffer(result.events_json);
+            return events;
           };
           return runAsync(rt2, std::move(body), bytesToArrayBuffer);
         });
@@ -599,12 +586,14 @@ jsi::Value ProtocolHost::get(jsi::Runtime& rt, const jsi::PropNameID& name) {
 
           auto body = [handle,
                       params = std::move(params)]() -> std::vector<uint8_t> {
-            DeRecProtocolEventsResult result =
+            DeRecProtocolRestoreResult result =
                 derec_protocol_restore(handle, params.data(), params.size());
-            if (result.error.code != DEREC_CODE_OK) {
-              throw FfiFailure(result.error);
+            RestoreOutcome outcome = takeRestoreResult(result);
+            if (outcome.error.code != DEREC_CODE_OK) {
+              throw FfiFailure(outcome.error,
+                               std::move(outcome.conflictingChannelIdsJson));
             }
-            return takeBuffer(result.events_json);
+            return std::move(outcome.events);
           };
           return runAsync(rt2, std::move(body), bytesToArrayBuffer);
         });
@@ -632,8 +621,7 @@ jsi::Value ProtocolHost::get(jsi::Runtime& rt, const jsi::PropNameID& name) {
 
 std::vector<jsi::PropNameID> ProtocolHost::getPropertyNames(jsi::Runtime& rt) {
   const char* names[] = {
-      "secretId",       "setCommunicationInfo",  "setOwnTransport",
-      "setOwnTransports",
+      "secretId",       "setCommunicationInfo",  "setOwnTransports",
       "createContact",  "start",                 "process",
       "tick",           "accept",                "reject",
       "getFingerprint", "verifyFingerprint",     "removeExpiredChannels",