@minip2p/react-native 0.7.1 → 0.7.2

package/src/adapter.ts

@@ -1,11 +1,6 @@
 /* oxlint-disable class-methods-use-this, complexity, func-style, max-classes-per-file, no-use-before-define -- The adapter keeps its contract-complete native endpoint and public SDK subclass together, and uses hoisted conversion helpers. */
 
-import {
-  BackpressureError,
-  MessageTooLargeError,
-  Minip2pBase,
-  NotPermittedError,
-} from "@minip2p/core";
+import { Minip2pBase, StreamClosedError } from "@minip2p/core";
 import type {
   Bytes,
   ConnectionInfo,
@@ -15,7 +10,11 @@ import type {
   Reachability,
   RelayReservationInfo,
 } from "@minip2p/core";
-import { P2pEvent_Tags, resolveEndpointConfig } from "@minip2p/core/backend";
+import {
+  P2pEvent_Tags,
+  resolveEndpointConfig,
+  typedFfiError,
+} from "@minip2p/core/backend";
 import type {
   BackendConnectTarget,
   Minip2pBackend,
@@ -28,7 +27,6 @@ import type {
 import { EventDrain } from "./event-drain";
 import {
   ConnectTarget,
-  FfiError_Tags,
   P2pEndpoint,
   circuitAddress as nativeCircuitAddress,
   generateSecretKey as nativeGenerateSecretKey,
@@ -153,10 +151,13 @@ class ReactNativeBackend implements Minip2pBackend {
     if (info === undefined) {
       return undefined;
     }
-    const connId = this.#connectionIds.toPublic(info.connId);
-    return info.remoteAddr === undefined
-      ? { connId }
-      : { connId, remoteAddr: info.remoteAddr };
+    return {
+      connId: this.#connectionIds.toPublic(info.connId),
+      ...(info.remoteAddr !== undefined && { remoteAddr: info.remoteAddr }),
+      ...(info.readyProtocols !== undefined && {
+        readyProtocols: info.readyProtocols,
+      }),
+    };
   }
 
   circuitAddress(relayAddress: string, peerId: string): string {
@@ -211,34 +212,49 @@ class ReactNativeBackend implements Minip2pBackend {
     };
   }
 
-  sendStream(peerId: string, streamId: number, data: Uint8Array): void {
+  sendStream(
+    peerId: string,
+    connId: number,
+    streamId: number,
+    data: Uint8Array
+  ): void {
     translateErrors(() => {
       this.#endpoint.sendStream(
         peerId,
+        this.#connectionIds.toNative(connId),
         numberToU64(streamId, "streamId"),
         toArrayBuffer(data)
       );
     });
   }
 
-  closeStreamWrite(peerId: string, streamId: number): void {
+  closeStreamWrite(peerId: string, connId: number, streamId: number): void {
     translateErrors(() => {
       this.#endpoint.closeStreamWrite(
         peerId,
+        this.#connectionIds.toNative(connId),
         numberToU64(streamId, "streamId")
       );
     });
   }
 
-  resetStream(peerId: string, streamId: number): void {
+  resetStream(peerId: string, connId: number, streamId: number): void {
     translateErrors(() => {
-      this.#endpoint.resetStream(peerId, numberToU64(streamId, "streamId"));
+      this.#endpoint.resetStream(
+        peerId,
+        this.#connectionIds.toNative(connId),
+        numberToU64(streamId, "streamId")
+      );
     });
   }
 
-  abandonStream(peerId: string, streamId: number): void {
+  abandonStream(peerId: string, connId: number, streamId: number): void {
     translateErrors(() => {
-      this.#endpoint.abandonStream(peerId, numberToU64(streamId, "streamId"));
+      this.#endpoint.abandonStream(
+        peerId,
+        this.#connectionIds.toNative(connId),
+        numberToU64(streamId, "streamId")
+      );
     });
   }
 
@@ -308,12 +324,13 @@ export function circuitAddress(relayAddress: string, peerId: string): string {
  * Native connection IDs span the full `u64` range, so they cannot round-trip
  * through a JavaScript `number`. Each endpoint owns one map so a native ID
  * resolves to the same public ID in events and synchronous results. An entry
- * is released once its `ConnectionClosed` event is normalized, which bounds
- * the map by live connections. Public numbers come from a counter that never
- * repeats, so an event arriving after the release gets a fresh number instead
- * of aliasing a live connection. Stream and connect-attempt IDs are not
- * mapped because they round-trip into native calls, and native allocates
- * them well inside the safe integer range.
+ * is released once its `ConnectionClosed`, or the `ConnectionReplaced` that
+ * retires it, is normalized, which bounds the map by live connections. Public
+ * numbers come from a counter that never repeats, so an event arriving after
+ * the release gets a fresh number instead of aliasing a live connection.
+ * Stream operations map the public ID back to native. Stream and
+ * connect-attempt IDs are not mapped because native allocates them well
+ * inside the safe integer range.
  */
 class ConnectionIdMap {
   readonly #publicByNative = new Map<bigint, number>();
@@ -332,6 +349,20 @@ class ConnectionIdMap {
     return publicId;
   }
 
+  /**
+   * The native ID behind a public one. Stream operations pass it back so
+   * native rejects a stream whose connection it already replaced. A released
+   * connection throws `StreamClosedError`: its stream operation can run after
+   * the release but before the SDK dispatches the ending event.
+   */
+  toNative(publicId: number): bigint {
+    const native = this.#nativeByPublic.get(publicId);
+    if (native === undefined) {
+      throw new StreamClosedError("The stream's connection ended");
+    }
+    return native;
+  }
+
   release(publicId: number): void {
     const native = this.#nativeByPublic.get(publicId);
     if (native !== undefined) {
@@ -354,6 +385,8 @@ function normalizeEvent(
   ) as P2pEvent;
   if (normalized.tag === P2pEvent_Tags.ConnectionClosed) {
     connectionIds.release(normalized.inner.connId);
+  } else if (normalized.tag === P2pEvent_Tags.ConnectionReplaced) {
+    connectionIds.release(normalized.inner.oldConnId);
   }
   return normalized;
 }
@@ -372,10 +405,17 @@ function normalizeReservation(
   return normalizeBigInts(reservation) as RelayReservationInfo;
 }
 
+/** Event fields carrying a native connection ID. */
+const CONNECTION_ID_KEYS: ReadonlySet<string> = new Set([
+  "connId",
+  "oldConnId",
+  "newConnId",
+]);
+
 /**
- * Converts native `bigint` fields to numbers. `connId` fields go through the
- * endpoint's connection map when one is supplied; every other `u64` keeps the
- * checked conversion.
+ * Converts native `bigint` fields to numbers. Connection ID fields go through
+ * the endpoint's connection map when one is supplied; every other `u64` keeps
+ * the checked conversion.
  */
 function normalizeBigInts(
   value: unknown,
@@ -383,7 +423,9 @@ function normalizeBigInts(
   key?: string
 ): unknown {
   if (typeof value === "bigint") {
-    return key === "connId" && connectionIds !== undefined
+    return key !== undefined &&
+      CONNECTION_ID_KEYS.has(key) &&
+      connectionIds !== undefined
       ? connectionIds.toPublic(value)
       : u64ToNumber(value, "native u64");
   }
@@ -434,27 +476,16 @@ function translateErrors<T>(operation: () => T): T {
   try {
     return operation();
   } catch (error) {
-    const tag = getErrorTag(error);
-    switch (tag) {
-      case FfiError_Tags.Backpressure: {
-        throw new BackpressureError();
-      }
-      case FfiError_Tags.MessageTooLarge: {
-        throw new MessageTooLargeError();
-      }
-      case FfiError_Tags.NotPermitted: {
-        throw new NotPermittedError(getErrorDetail(error));
-      }
-      default: {
-        throw error;
-      }
-    }
+    throw typedFfiError(getErrorTag(error), getErrorDetail(error)) ?? error;
   }
 }
 
-function getErrorTag(error: unknown): FfiError_Tags | undefined {
-  return typeof error === "object" && error !== null && "tag" in error
-    ? (error.tag as FfiError_Tags)
+function getErrorTag(error: unknown): string | undefined {
+  return typeof error === "object" &&
+    error !== null &&
+    "tag" in error &&
+    typeof error.tag === "string"
+    ? error.tag
     : undefined;
 }
 

package/src/generated/minip2p_ffi-ffi.ts

@@ -76,11 +76,11 @@ interface NativeModuleInterface {
     ubrn_uniffi_minip2p_ffi_fn_func_generate_secret_key(uniffi_out_err: UniffiRustCallStatus): Uint8Array;
     ubrn_uniffi_minip2p_ffi_fn_func_peer_id_from_secret_key(secretKey: Uint8Array, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
     ubrn_uniffi_minip2p_ffi_fn_constructor_p2pendpoint_new(secretKey: Uint8Array, config: Uint8Array, uniffi_out_err: UniffiRustCallStatus): bigint;
-    ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_abandon_stream(uniffiSelf: bigint, peerId: Uint8Array, streamId: bigint, uniffi_out_err: UniffiRustCallStatus): void;
+    ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_abandon_stream(uniffiSelf: bigint, peerId: Uint8Array, connId: bigint, streamId: bigint, uniffi_out_err: UniffiRustCallStatus): void;
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_active_reservation(uniffiSelf: bigint, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_add_protocol(uniffiSelf: bigint, protocolId: Uint8Array, uniffi_out_err: UniffiRustCallStatus): void;
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_cancel_connect(uniffiSelf: bigint, id: bigint, uniffi_out_err: UniffiRustCallStatus): void;
-    ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_close_stream_write(uniffiSelf: bigint, peerId: Uint8Array, streamId: bigint, uniffi_out_err: UniffiRustCallStatus): void;
+    ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_close_stream_write(uniffiSelf: bigint, peerId: Uint8Array, connId: bigint, streamId: bigint, uniffi_out_err: UniffiRustCallStatus): void;
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_connect(uniffiSelf: bigint, target: Uint8Array, uniffi_out_err: UniffiRustCallStatus): bigint;
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_connected_peers(uniffiSelf: bigint, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_connection_info(uniffiSelf: bigint, peerId: Uint8Array, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
@@ -98,8 +98,8 @@ interface NativeModuleInterface {
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_ping(uniffiSelf: bigint, peerId: Uint8Array, uniffi_out_err: UniffiRustCallStatus): void;
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_publish(uniffiSelf: bigint, topic: Uint8Array, data: Uint8Array, uniffi_out_err: UniffiRustCallStatus): void;
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_reachability(uniffiSelf: bigint, uniffi_out_err: UniffiRustCallStatus): Uint8Array;
-    ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_reset_stream(uniffiSelf: bigint, peerId: Uint8Array, streamId: bigint, uniffi_out_err: UniffiRustCallStatus): void;
-    ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_send_stream(uniffiSelf: bigint, peerId: Uint8Array, streamId: bigint, data: Uint8Array, uniffi_out_err: UniffiRustCallStatus): void;
+    ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_reset_stream(uniffiSelf: bigint, peerId: Uint8Array, connId: bigint, streamId: bigint, uniffi_out_err: UniffiRustCallStatus): void;
+    ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_send_stream(uniffiSelf: bigint, peerId: Uint8Array, connId: bigint, streamId: bigint, data: Uint8Array, uniffi_out_err: UniffiRustCallStatus): void;
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_set_active(uniffiSelf: bigint, active: number, uniffi_out_err: UniffiRustCallStatus): void;
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_start(uniffiSelf: bigint, doorbell: bigint, uniffi_out_err: UniffiRustCallStatus): void;
     ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_stop(uniffiSelf: bigint, uniffi_out_err: UniffiRustCallStatus): void;