@derec-alliance/react-native 0.0.2 → 0.0.4

package/README.md

@@ -58,6 +58,24 @@ release build already includes whatever native modules are linked in.
 
 ---
 
+## Protocol schema
+
+The package ships the DeRec `.proto` schema under `schema/` so you can
+generate code for any language without a `lib-derec` checkout:
+
+- `schema/proto/` — the 18 schema files, flat. Every import is a bare
+  filename, so a single include root resolves the whole closure:
+  `protoc --proto_path=node_modules/@derec-alliance/react-native/schema/proto node_modules/@derec-alliance/react-native/schema/proto/*.proto`
+- `schema/derec_descriptor.bin` — the same closure precompiled, well-known
+  types included. Needs no include path at all. Compiled with
+  `--include_source_info`, so code generated from it keeps the protocol's doc
+  comments instead of emitting bare type declarations.
+
+The schema is versioned with the package: `vX.Y.Z` carries exactly the schema
+`vX.Y.Z` was built from.
+
+---
+
 ## Quickstart: pairing two devices
 
 `DeRecProtocol` is the orchestrator: it owns protocol state, drives flows to
@@ -121,7 +139,7 @@ declared in `src/types.ts`:
 - **`UserSecretStore`** — the most recent user-facing secret snapshot per
   `secretId`, used to auto-publish to newly paired peers.
 - **`StateStore`** — in-flight orchestrator bookkeeping (pending
-  verifications, recoveries, unpairs, sharing rounds, sync checks) so a
+  verifications, recoveries, unpairs, sharing rounds, replica discoveries) so a
   multi-round flow survives an app restart.
 - **`Transport`** — outbound delivery. `send(endpoint, message)` posts a
   wire-format envelope to a peer; it is a mailbox, not a request/response
@@ -131,6 +149,32 @@ Every method is `async` and keyed by decimal-string ids — see the next
 section for why that differs from `DeRecProtocol`'s own methods. Full field-
 level contracts are documented as TSDoc on each interface in `src/types.ts`.
 
+### Filtered listings
+
+`listHelpers` and `listReplicas` receive a filter object — `ids`, `status`,
+`role` and `exclude`, where every empty value means "do not restrict on this",
+so an all-empty filter selects everything. `exclude` is applied last,
+overriding `ids`. Ids are decimal strings, like every other `u64` here.
+
+**Apply it in your query.** That is the point: a `WHERE` clause or a
+key-condition expression instead of transferring rows the caller will discard.
+That transfer costs bandwidth everywhere, and on a metered backing such as
+DynamoDB, which bills by bytes read, it costs money.
+
+**A store that ignores it is slow, not wrong.** The library re-applies the
+filter to every listing before acting on it and drops anything the filter
+excluded.
+
+**That is a one-way guarantee, not a validation of your store.** Dropping rows
+enforces an upper bound; it cannot recover a row you omitted. A store that
+returns *fewer* rows than the filter selects is still wrong, in a way nothing
+in the library can detect — the protocol simply fails to act. Applying the
+filter faithfully is still your job.
+
+The backstop matters here in particular: TypeScript accepts a function of fewer
+parameters where more are declared, so a store written before the filter
+existed still satisfies this interface and compiles without a diagnostic.
+
 ---
 
 ## Threading model
@@ -171,7 +215,7 @@ after whatever is in flight.
 
 ## Known differences from `@derec-alliance/nodejs`
 
-**`setCommunicationInfo()` and `setOwnTransport()` return a `Promise`.**
+**`setCommunicationInfo()`, `setOwnTransport()` and `setOwnTransports()` return a `Promise`.**
 `@derec-alliance/nodejs` declares both `void`. Here they must not run on the
 JavaScript thread: the underlying FFI setter takes the same handle lock a
 running flow holds across its store callbacks, and those callbacks block the

package/cpp/Primitives.cpp

@@ -263,7 +263,7 @@ jsi::Value readTraceId(jsi::Runtime& rt,
 }
 
 /// `create_contact_message(channelId: bigint, contactMode: number,
-///   transportProtocol: ArrayBuffer, hasNonce: number, nonce: bigint)
+///   transportProtocols: ArrayBuffer, hasNonce: number, nonce: bigint)
 ///   -> { contact_wire_bytes, secret_key_material }`
 jsi::Value createContactMessage(jsi::Runtime& rt,
                                 const jsi::Value&,
@@ -272,11 +272,11 @@ jsi::Value createContactMessage(jsi::Runtime& rt,
   requireArgs(rt, "create_contact_message", count, 5);
   uint64_t channelId = asU64(rt, args[0]);
   auto contactMode = static_cast<int32_t>(args[1].asNumber());
-  ByteView transportProtocol = asBytes(rt, args[2]);
+  ByteView transportProtocols = asBytes(rt, args[2]);
   auto hasNonce = static_cast<uint32_t>(args[3].asNumber());
   uint64_t nonce = asU64(rt, args[4]);
   CreateContactMessageResult result = create_contact_message(
-      channelId, contactMode, transportProtocol.ptr, transportProtocol.len,
+      channelId, contactMode, transportProtocols.ptr, transportProtocols.len,
       hasNonce, nonce);
   if (result.error.code != 0) {
     throwDeRecError(rt, result.error);
@@ -379,7 +379,7 @@ jsi::Value encodeMessageJson(jsi::Runtime& rt,
   return toArrayBuffer(rt, bytes.data(), bytes.size());
 }
 
-/// `produce_pair_request_message(senderKind: number, transportProtocol:
+/// `produce_pair_request_message(senderKind: number, transportProtocols:
 ///   ArrayBuffer, contactMessage: ArrayBuffer, communicationInfo:
 ///   ArrayBuffer|null, parameterRange: ArrayBuffer|null) ->
 ///   { request_wire_bytes, initiator_contact_message_wire_bytes,
@@ -390,12 +390,12 @@ jsi::Value producePairRequestMessage(jsi::Runtime& rt,
                                      size_t count) {
   requireArgs(rt, "produce_pair_request_message", count, 5);
   auto senderKind = static_cast<int32_t>(args[0].asNumber());
-  ByteView transportProtocol = asBytes(rt, args[1]);
+  ByteView transportProtocols = asBytes(rt, args[1]);
   ByteView contactMessage = asBytes(rt, args[2]);
   ByteView communicationInfo = asBytes(rt, args[3]);
   ByteView parameterRange = asBytes(rt, args[4]);
   ProducePairRequestMessageResult result = produce_pair_request_message(
-      senderKind, transportProtocol.ptr, transportProtocol.len,
+      senderKind, transportProtocols.ptr, transportProtocols.len,
       contactMessage.ptr, contactMessage.len, communicationInfo.ptr,
       communicationInfo.len, parameterRange.ptr, parameterRange.len);
   if (result.error.code != 0) {
@@ -440,35 +440,41 @@ jsi::Value extractPairRequest(jsi::Runtime& rt,
 
 /// `produce_pair_response_message(channelId: bigint, requestProto:
 ///   ArrayBuffer, secretKeyMaterial: ArrayBuffer, communicationInfo:
-///   ArrayBuffer|null, parameterRange: ArrayBuffer|null) ->
-///   { response_wire_bytes, peer_transport_protocol, shared_key, channel_id }`
+///   ArrayBuffer|null, parameterRange: ArrayBuffer|null,
+///   unsafeConnection: boolean) ->
+///   { response_wire_bytes, peer_transports, shared_key, channel_id }`
+///
+/// `peer_transports` is a length-delimited sequence of encoded
+/// `TransportProtocol` messages — every endpoint the requester advertised,
+/// in its own order, filtered to those the library will record. It crosses
+/// this seam framed; the TypeScript layer decodes it.
 jsi::Value producePairResponseMessage(jsi::Runtime& rt,
                                       const jsi::Value&,
                                       const jsi::Value* args,
                                       size_t count) {
-  requireArgs(rt, "produce_pair_response_message", count, 5);
+  requireArgs(rt, "produce_pair_response_message", count, 6);
   uint64_t channelId = asU64(rt, args[0]);
   ByteView requestProto = asBytes(rt, args[1]);
   ByteView secretKeyMaterial = asBytes(rt, args[2]);
   ByteView communicationInfo = asBytes(rt, args[3]);
   ByteView parameterRange = asBytes(rt, args[4]);
+  uint32_t unsafeConnection = args[5].asBool() ? 1u : 0u;
   ProducePairResponseMessageResult result = produce_pair_response_message(
       channelId, requestProto.ptr, requestProto.len, secretKeyMaterial.ptr,
       secretKeyMaterial.len, communicationInfo.ptr, communicationInfo.len,
-      parameterRange.ptr, parameterRange.len);
+      parameterRange.ptr, parameterRange.len, unsafeConnection);
   if (result.error.code != 0) {
     throwDeRecError(rt, result.error);
   }
   std::vector<uint8_t> responseBytes = takeBuffer(result.response_wire_bytes);
-  std::vector<uint8_t> peerTransportProtocol =
-      takeBuffer(result.peer_transport_protocol);
+  std::vector<uint8_t> peerTransports = takeBuffer(result.peer_transports);
   std::vector<uint8_t> sharedKey = takeBuffer(result.shared_key);
   auto payload = jsi::Object(rt);
   payload.setProperty(rt, "response_wire_bytes",
                       toArrayBuffer(rt, responseBytes.data(), responseBytes.size()));
   payload.setProperty(
-      rt, "peer_transport_protocol",
-      toArrayBuffer(rt, peerTransportProtocol.data(), peerTransportProtocol.size()));
+      rt, "peer_transports",
+      toArrayBuffer(rt, peerTransports.data(), peerTransports.size()));
   payload.setProperty(rt, "shared_key",
                       toArrayBuffer(rt, sharedKey.data(), sharedKey.size()));
   payload.setProperty(rt, "channel_id",
@@ -525,17 +531,20 @@ jsi::Value processPairResponseMessage(jsi::Runtime& rt,
   return jsi::Value(rt, payload);
 }
 
-/// `produce_pre_pair_request_message(transportProtocol: ArrayBuffer,
+/// `produce_pre_pair_request_message(transportProtocols: ArrayBuffer,
 ///   contactMessage: ArrayBuffer) -> ArrayBuffer`
+///
+/// `transportProtocols` is a length-delimited sequence of encoded
+/// `TransportProtocol` messages in the scanner's preference order.
 jsi::Value producePrePairRequestMessage(jsi::Runtime& rt,
                                         const jsi::Value&,
                                         const jsi::Value* args,
                                         size_t count) {
   requireArgs(rt, "produce_pre_pair_request_message", count, 2);
-  ByteView transportProtocol = asBytes(rt, args[0]);
+  ByteView transportProtocols = asBytes(rt, args[0]);
   ByteView contactMessage = asBytes(rt, args[1]);
   ProducePrePairRequestMessageResult result = produce_pre_pair_request_message(
-      transportProtocol.ptr, transportProtocol.len, contactMessage.ptr,
+      transportProtocols.ptr, transportProtocols.len, contactMessage.ptr,
       contactMessage.len);
   if (result.error.code != 0) {
     throwDeRecError(rt, result.error);
@@ -1145,7 +1154,7 @@ void installPrimitives(jsi::Runtime& rt, jsi::Object& host) {
   bind(rt, host, "encode_message_json", 2, encodeMessageJson);
   bind(rt, host, "produce_pair_request_message", 5, producePairRequestMessage);
   bind(rt, host, "extract_pair_request", 2, extractPairRequest);
-  bind(rt, host, "produce_pair_response_message", 5, producePairResponseMessage);
+  bind(rt, host, "produce_pair_response_message", 7, producePairResponseMessage);
   bind(rt, host, "extract_pair_response", 2, extractPairResponse);
   bind(rt, host, "process_pair_response_message", 3, processPairResponseMessage);
   bind(rt, host, "produce_pre_pair_request_message", 2,

package/cpp/ProtocolHost.cpp

@@ -320,9 +320,45 @@ jsi::Value ProtocolHost::get(jsi::Runtime& rt, const jsi::PropNameID& name) {
           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
+  // would otherwise have to marshal field by field.
+  if (prop == "setOwnTransports") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 1,
+        [this](jsi::Runtime& rt2, const jsi::Value&, const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          requireArgs(rt2, "setOwnTransports", count, 1);
+          ByteView view = asBytes(rt2, args[0]);
+          std::vector<uint8_t> transports(view.ptr, view.ptr + view.len);
+          DeRecProtocolHandle* handle = handle_;
+
+          auto body = [handle,
+                       transports = std::move(transports)]() -> std::vector<uint8_t> {
+            DeRecError error = derec_protocol_set_own_transports(
+                handle, transports.data(), transports.size());
             if (error.code != DEREC_CODE_OK) {
               throw FfiFailure(error);
             }
@@ -597,6 +633,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",
       "createContact",  "start",                 "process",
       "tick",           "accept",                "reject",
       "getFingerprint", "verifyFingerprint",     "removeExpiredChannels",

package/cpp/StoreCallbacks.cpp

@@ -4,6 +4,7 @@
 #include "StoreCallbacks.h"
 
 #include <cstring>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -577,19 +578,31 @@ extern "C" int32_t channelStoreRemove(void* userData, uint64_t secretId, uint64_
   return result.code;
 }
 
-/// `ChannelStore.listHelpers(secretId) -> Uint8Array | null`
-extern "C" int32_t channelStoreListHelpers(void* userData, uint64_t secretId, uint8_t** outPtr,
-                                            size_t* outLen) {
+/// `ChannelStore.listHelpers(secretId, filter) -> Uint8Array | null`
+///
+/// `filter` arrives as JSON and is handed to JavaScript as a plain object —
+/// see `ChannelFilter` in the SDK's types. The buffer is owned by the core and
+/// valid only for this call, so it is parsed before the promise is awaited.
+extern "C" int32_t channelStoreListHelpers(void* userData, uint64_t secretId, const uint8_t* filter,
+                                            size_t filterLen, uint8_t** outPtr, size_t* outLen) {
   auto* self = static_cast<StoreBindings*>(userData);
   // Kept alive past this call so the lambda handed to `callSync` — which the
   // JavaScript CallInvoker's queue may still be holding after this object's
   // owner has released its own reference — has somewhere safe to run.
   auto keepAlive = self->shared_from_this();
-  CallResult result = keepAlive->bridge().callSync([keepAlive, secretId](std::function<void(CallResult)> settle) {
+  std::vector<uint8_t> filterJson(filter, filter + filterLen);
+  CallResult result = keepAlive->bridge().callSync([keepAlive, secretId, filterJson](std::function<void(CallResult)> settle) {
     jsi::Runtime& rt = keepAlive->runtime();
     auto store = keepAlive->channelStore();
     auto method = store->getPropertyAsFunction(rt, "listHelpers");
-    jsi::Value promise = method.callWithThis(rt, *store, idVal(rt, secretId));
+    // Ids arrive as decimal strings — the core encodes them that way because
+    // `JSON.parse` cannot hold a u64; see `encode_filter` in
+    // `interop/ffi/protocol/stores.rs`.
+    jsi::Value filterVal = filterJson.empty()
+                               ? jsi::Value(jsi::Object(rt))
+                               : jsonParseUtf8(rt, filterJson.data(), filterJson.size());
+    jsi::Value promise =
+        method.callWithThis(rt, *store, idVal(rt, secretId), std::move(filterVal));
     keepAlive->settleFromPromise(rt, std::move(promise), std::move(settle), toCallResult);
   });
   if (result.code == 0) {
@@ -603,19 +616,31 @@ extern "C" int32_t channelStoreListHelpers(void* userData, uint64_t secretId, ui
   return result.code;
 }
 
-/// `ChannelStore.listReplicas(secretId) -> Uint8Array | null`
-extern "C" int32_t channelStoreListReplicas(void* userData, uint64_t secretId, uint8_t** outPtr,
-                                             size_t* outLen) {
+/// `ChannelStore.listReplicas(secretId, filter) -> Uint8Array | null`
+///
+/// `filter` arrives as JSON and is handed to JavaScript as a plain object —
+/// see `ChannelFilter` in the SDK's types. The buffer is owned by the core and
+/// valid only for this call, so it is parsed before the promise is awaited.
+extern "C" int32_t channelStoreListReplicas(void* userData, uint64_t secretId, const uint8_t* filter,
+                                            size_t filterLen, uint8_t** outPtr, size_t* outLen) {
   auto* self = static_cast<StoreBindings*>(userData);
   // Kept alive past this call so the lambda handed to `callSync` — which the
   // JavaScript CallInvoker's queue may still be holding after this object's
   // owner has released its own reference — has somewhere safe to run.
   auto keepAlive = self->shared_from_this();
-  CallResult result = keepAlive->bridge().callSync([keepAlive, secretId](std::function<void(CallResult)> settle) {
+  std::vector<uint8_t> filterJson(filter, filter + filterLen);
+  CallResult result = keepAlive->bridge().callSync([keepAlive, secretId, filterJson](std::function<void(CallResult)> settle) {
     jsi::Runtime& rt = keepAlive->runtime();
     auto store = keepAlive->channelStore();
     auto method = store->getPropertyAsFunction(rt, "listReplicas");
-    jsi::Value promise = method.callWithThis(rt, *store, idVal(rt, secretId));
+    // Ids arrive as decimal strings — the core encodes them that way because
+    // `JSON.parse` cannot hold a u64; see `encode_filter` in
+    // `interop/ffi/protocol/stores.rs`.
+    jsi::Value filterVal = filterJson.empty()
+                               ? jsi::Value(jsi::Object(rt))
+                               : jsonParseUtf8(rt, filterJson.data(), filterJson.size());
+    jsi::Value promise =
+        method.callWithThis(rt, *store, idVal(rt, secretId), std::move(filterVal));
     keepAlive->settleFromPromise(rt, std::move(promise), std::move(settle), toCallResult);
   });
   if (result.code == 0) {
@@ -1073,27 +1098,110 @@ extern "C" int32_t stateStoreLoadAll(void* userData, uint64_t secretId, uint32_t
 /// is reported rather than guessed at.
 std::string protocolToString(int32_t protocol) { return protocol == 0 ? "https" : "unknown"; }
 
-/// `Transport.send(endpoint, message) -> void`
-extern "C" int32_t transportSend(void* userData, const uint8_t* uriPtr, size_t uriLen, int32_t protocol,
+/// Minimal reader for an encoded `TransportProtocol`: field 1 is the URI
+/// (length-delimited string), field 2 the protocol discriminant (varint).
+/// Hand-rolled rather than linking a protobuf runtime into the JSI layer for
+/// two fields; unknown fields are skipped so a newer library stays readable.
+static std::optional<std::pair<std::string, int32_t>> decodeTransportProtocol(
+    const uint8_t* data, size_t len) {
+  std::string uri;
+  int32_t protocol = 0;
+  size_t i = 0;
+
+  auto readVarint = [&](uint64_t& out) -> bool {
+    out = 0;
+    int shift = 0;
+    while (i < len) {
+      uint8_t b = data[i++];
+      out |= static_cast<uint64_t>(b & 0x7F) << shift;
+      if ((b & 0x80) == 0) return true;
+      shift += 7;
+      if (shift > 63) return false;
+    }
+    return false;
+  };
+
+  while (i < len) {
+    uint64_t tag = 0;
+    if (!readVarint(tag)) return std::nullopt;
+    uint32_t field = static_cast<uint32_t>(tag >> 3);
+    uint32_t wire = static_cast<uint32_t>(tag & 0x7);
+
+    if (field == 1 && wire == 2) {
+      uint64_t size = 0;
+      if (!readVarint(size) || i + size > len) return std::nullopt;
+      uri.assign(reinterpret_cast<const char*>(data + i), size);
+      i += size;
+    } else if (field == 2 && wire == 0) {
+      uint64_t value = 0;
+      if (!readVarint(value)) return std::nullopt;
+      protocol = static_cast<int32_t>(value);
+    } else if (wire == 0) {
+      uint64_t skip = 0;
+      if (!readVarint(skip)) return std::nullopt;
+    } else if (wire == 2) {
+      uint64_t size = 0;
+      if (!readVarint(size) || i + size > len) return std::nullopt;
+      i += size;
+    } else {
+      return std::nullopt;
+    }
+  }
+  return std::make_pair(uri, protocol);
+}
+
+/// `Transport.send(endpoints, message) -> void`
+///
+/// `endpoints` is every address the peer advertised, in the peer's order,
+/// already filtered to those the library will record. The library does not
+/// rank them: which to dial, and whether to fall back, is the JavaScript
+/// implementation's choice. Delivery to any one of them is success.
+extern "C" int32_t transportSend(void* userData, const uint8_t* endpointsPtr, size_t endpointsLen,
                                   const uint8_t* bytes, size_t len) {
   auto* self = static_cast<StoreBindings*>(userData);
   // Kept alive past this call so the lambda handed to `callSync` — which the
   // JavaScript CallInvoker's queue may still be holding after this object's
   // owner has released its own reference — has somewhere safe to run.
   auto keepAlive = self->shared_from_this();
-  std::string uri(reinterpret_cast<const char*>(uriPtr), uriLen);
+
+  // Length-delimited TransportProtocol sequence: each entry preceded by its
+  // protobuf varint byte length.
+  std::vector<std::pair<std::string, int32_t>> endpoints;
+  size_t offset = 0;
+  while (offset < endpointsLen) {
+    uint64_t size = 0;
+    int shift = 0;
+    while (offset < endpointsLen) {
+      uint8_t b = endpointsPtr[offset++];
+      size |= static_cast<uint64_t>(b & 0x7F) << shift;
+      if ((b & 0x80) == 0) break;
+      shift += 7;
+    }
+    if (offset + size > endpointsLen) return -1;
+    auto parsed = decodeTransportProtocol(endpointsPtr + offset, size);
+    if (!parsed) return -1;
+    endpoints.push_back(*parsed);
+    offset += size;
+  }
+
   std::vector<uint8_t> message(bytes, bytes + len);
-  CallResult result = keepAlive->bridge().callSync([keepAlive, uri, protocol,
+  CallResult result = keepAlive->bridge().callSync([keepAlive, endpoints,
                                                 message](std::function<void(CallResult)> settle) {
     jsi::Runtime& rt = keepAlive->runtime();
     auto store = keepAlive->transportStore();
     auto method = store->getPropertyAsFunction(rt, "send");
-    jsi::Object endpoint(rt);
-    endpoint.setProperty(rt, "protocol",
-                          jsi::Value(rt, jsi::String::createFromUtf8(rt, protocolToString(protocol))));
-    endpoint.setProperty(rt, "uri", jsi::Value(rt, jsi::String::createFromUtf8(rt, uri)));
+    jsi::Array endpointsJs(rt, endpoints.size());
+    for (size_t i = 0; i < endpoints.size(); ++i) {
+      jsi::Object endpoint(rt);
+      endpoint.setProperty(rt, "protocol",
+                            jsi::Value(rt, jsi::String::createFromUtf8(
+                                               rt, protocolToString(endpoints[i].second))));
+      endpoint.setProperty(rt, "uri",
+                            jsi::Value(rt, jsi::String::createFromUtf8(rt, endpoints[i].first)));
+      endpointsJs.setValueAtIndex(rt, i, endpoint);
+    }
     jsi::Value promise =
-        method.callWithThis(rt, *store, jsi::Value(rt, endpoint), toUint8ArrayVal(rt, message));
+        method.callWithThis(rt, *store, jsi::Value(rt, endpointsJs), toUint8ArrayVal(rt, message));
     keepAlive->settleFromPromise(rt, std::move(promise), std::move(settle), toVoidResult);
   });
   return result.code;