@peerkit/transport-libp2p-react-native 0.1.0-alpha.13

package/dist/websocket-buffered-amount-polyfill.js

@@ -0,0 +1,41 @@
+/**
+ * Make React Native's `WebSocket` report a numeric `bufferedAmount`.
+ *
+ * React Native declares `bufferedAmount` on its `WebSocket` but never assigns
+ * it, so it reads as `undefined`. `@libp2p/websockets` drives write backpressure
+ * off that value, and the `undefined` comparisons leave every write parked
+ * waiting for a `drain` that never fires, hanging the connection.
+ *
+ * React Native hands every frame straight to the native socket with no
+ * JS-visible send buffer to measure, so `0` ("fully flushed") is the correct,
+ * backpressure-free answer. A prototype accessor returns `0` for reads and
+ * swallows React Native's `undefined` field initialization with a no-op setter,
+ * so no shadowing own property is left on the instance.
+ */
+/**
+ * Install the `bufferedAmount` accessor on the global `WebSocket` prototype.
+ * Idempotent, and a no-op when the runtime already exposes a real getter (e.g.
+ * a browser or Node polyfill) or provides no `WebSocket` at all (e.g. tests).
+ */
+export function installWebSocketBufferedAmountPolyfill() {
+    const scope = globalThis;
+    const prototype = scope.WebSocket?.prototype;
+    if (prototype == null) {
+        return;
+    }
+    const existing = Object.getOwnPropertyDescriptor(prototype, "bufferedAmount");
+    if (existing?.get != null) {
+        return;
+    }
+    Object.defineProperty(prototype, "bufferedAmount", {
+        configurable: true,
+        get() {
+            return 0;
+        },
+        set() {
+            // Swallow React Native's `undefined` field initialization so it cannot
+            // create an own property that shadows this accessor.
+        },
+    });
+}
+//# sourceMappingURL=websocket-buffered-amount-polyfill.js.map

package/dist/websocket-buffered-amount-polyfill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-buffered-amount-polyfill.js","sourceRoot":"","sources":["../src/websocket-buffered-amount-polyfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH;;;;GAIG;AACH,MAAM,UAAU,sCAAsC;IACpD,MAAM,KAAK,GAAG,UAA2C,CAAC;IAC1D,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC;IAC7C,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;QACtB,OAAO;IACT,CAAC;IACD,MAAM,QAAQ,GAAG,MAAM,CAAC,wBAAwB,CAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAC9E,IAAI,QAAQ,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC;QAC1B,OAAO;IACT,CAAC;IACD,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,gBAAgB,EAAE;QACjD,YAAY,EAAE,IAAI;QAClB,GAAG;YACD,OAAO,CAAC,CAAC;QACX,CAAC;QACD,GAAG;YACD,uEAAuE;YACvE,qDAAqD;QACvD,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@peerkit/transport-libp2p-react-native",
+  "version": "0.1.0-alpha.13",
+  "description": "React Native libp2p transport for peerkit",
+  "keywords": [
+    "peerkit",
+    "transport",
+    "libp2p",
+    "react-native",
+    "p2p"
+  ],
+  "author": "Holochain Dev Team <devcore@holochain.org>",
+  "license": "CAL-1.0",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "bugs": {
+    "url": "https://github.com/holochain/peerkit/issues"
+  },
+  "homepage": "https://github.com/holochain/peerkit#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/holochain/peerkit.git"
+  },
+  "type": "module",
+  "sideEffects": [
+    "./dist/polyfills.js",
+    "./src/polyfills.ts"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./polyfills": {
+      "types": "./dist/polyfills.d.ts",
+      "import": "./dist/polyfills.js"
+    },
+    "./quick-crypto-noise": {
+      "types": "./dist/quick-crypto-noise.d.ts",
+      "import": "./dist/quick-crypto-noise.js"
+    }
+  },
+  "scripts": {
+    "test": "vitest --run"
+  },
+  "dependencies": {
+    "@chainsafe/libp2p-noise": "^17.0.0",
+    "@chainsafe/libp2p-yamux": "^8.0.1",
+    "@libp2p/circuit-relay-v2": "^4.2.3",
+    "@libp2p/identify": "^4.1.0",
+    "@libp2p/webrtc": "^6.0.23",
+    "@peerkit/api": "^0.1.0-alpha.13",
+    "@peerkit/transport-libp2p-core": "^0.1.0-alpha.13",
+    "libp2p": "^3.2.0"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.81.0",
+    "react-native-get-random-values": "^2.0.0",
+    "react-native-quick-crypto": "^1.1.3",
+    "react-native-webrtc": "^124.0.7"
+  },
+  "peerDependenciesMeta": {
+    "react-native": {
+      "optional": true
+    },
+    "react-native-get-random-values": {
+      "optional": true
+    },
+    "react-native-quick-crypto": {
+      "optional": true
+    },
+    "react-native-webrtc": {
+      "optional": true
+    }
+  }
+}

package/src/datachannel-early-message-polyfill.ts

@@ -0,0 +1,176 @@
+/**
+ * Buffers the earliest message(s) arriving on a freshly opened inbound
+ * (in-band) datachannel and replays them once the JS `RTCDataChannel` object
+ * and its listener exist.
+ *
+ * On `react-native-webrtc`, the channel-open announcement and inbound message
+ * events can reach JS out of order during connection setup: a message for a
+ * newly opened inbound channel may arrive before the corresponding
+ * `RTCDataChannel` object is created, leaving no listener to receive it. This
+ * polyfill captures such early messages by `reactTag` and delivers them when
+ * the listener is attached.
+ *
+ * Pre-negotiated channels (`createDataChannel` with `negotiated: true, id: 0`
+ * on both ends) are unaffected: their JS object and listener exist before any
+ * data arrives.
+ */
+
+import { Buffer } from "buffer";
+import { NativeEventEmitter, NativeModules } from "react-native";
+
+interface NativeReceiveMessageEvent {
+  reactTag: string;
+  type?: string;
+  data: string;
+}
+
+interface NativeStateChangeEvent {
+  reactTag: string;
+  state?: string;
+}
+
+// The subset of a `react-native-webrtc` RTCDataChannel instance this relies on.
+interface ReactNativeDataChannel {
+  _reactTag: string;
+}
+
+interface MessageEventLike {
+  data: ArrayBuffer;
+}
+
+type MessageHandler = (event: MessageEventLike) => unknown;
+
+interface DataChannelProbeHost {
+  createDataChannel(label: string): object;
+  close(): void;
+}
+
+type RTCPeerConnectionConstructor = new () => DataChannelProbeHost;
+
+const PROBE_CHANNEL_LABEL = "peerkit-early-message-probe";
+const INSTALLED_FLAG = "__peerkitDataChannelEarlyMessagePatched";
+
+/**
+ * Decode a base64 datachannel payload to an exactly sized `ArrayBuffer`,
+ * matching how `react-native-webrtc` surfaces binary messages
+ * (`event.data.byteLength` must equal the message length).
+ */
+function base64ToArrayBuffer(base64: string): ArrayBuffer {
+  const view = Buffer.from(base64, "base64") as unknown as {
+    buffer: ArrayBuffer;
+    byteOffset: number;
+    byteLength: number;
+  };
+  return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+}
+
+/**
+ * Capture the shared `RTCDataChannel` prototype. The class is not exported, so a
+ * throwaway peer connection mints a probe channel and its prototype is read off
+ * the instance. Returns `null` if a peer connection cannot be created.
+ */
+function captureDataChannelPrototype(
+  RTCPeerConnectionCtor: RTCPeerConnectionConstructor,
+): object | null {
+  let probeConnection: DataChannelProbeHost | undefined;
+  try {
+    probeConnection = new RTCPeerConnectionCtor();
+    const channel = probeConnection.createDataChannel(PROBE_CHANNEL_LABEL);
+    return Object.getPrototypeOf(channel) as object;
+  } catch {
+    return null;
+  } finally {
+    probeConnection?.close();
+  }
+}
+
+/**
+ * Install the early-message recovery. Idempotent, and a no-op when the WebRTC
+ * native module or the global `RTCPeerConnection` is absent (`registerGlobals()`
+ * has not run, or under tests).
+ */
+export function installDataChannelEarlyMessagePolyfill(): void {
+  const webRtcModule = NativeModules.WebRTCModule;
+  const scope = globalThis as {
+    RTCPeerConnection?: RTCPeerConnectionConstructor;
+  };
+  const RTCPeerConnectionCtor = scope.RTCPeerConnection;
+  if (webRtcModule == null || RTCPeerConnectionCtor == null) {
+    return;
+  }
+
+  const prototype = captureDataChannelPrototype(RTCPeerConnectionCtor) as
+    | (Record<string, unknown> & object)
+    | null;
+  if (prototype == null || prototype[INSTALLED_FLAG] === true) {
+    return;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(prototype, "onmessage");
+  if (descriptor?.get == null || descriptor.set == null) {
+    return;
+  }
+
+  // Early messages buffered per datachannel reactTag, awaiting a consumer.
+  const buffered = new Map<string, ArrayBuffer[]>();
+  // reactTags whose consumer has attached. Their live messages are delivered by
+  // react-native-webrtc's own path, so the duplicate seen here is ignored.
+  const consumed = new Set<string>();
+
+  const emitter = new NativeEventEmitter(webRtcModule);
+  emitter.addListener("dataChannelReceiveMessage", (raw) => {
+    const event = raw as NativeReceiveMessageEvent;
+    // libp2p only sends binary frames; ignore everything else.
+    if (event.type !== "binary" || consumed.has(event.reactTag)) {
+      return;
+    }
+    const payload = base64ToArrayBuffer(event.data);
+    const existing = buffered.get(event.reactTag);
+    if (existing) {
+      existing.push(payload);
+    } else {
+      buffered.set(event.reactTag, [payload]);
+    }
+  });
+  emitter.addListener("dataChannelStateChanged", (raw) => {
+    const event = raw as NativeStateChangeEvent;
+    if (event.state === "closed") {
+      buffered.delete(event.reactTag);
+      consumed.delete(event.reactTag);
+    }
+  });
+
+  const originalGet = descriptor.get;
+  const originalSet = descriptor.set;
+  Object.defineProperty(prototype, "onmessage", {
+    configurable: true,
+    enumerable: descriptor.enumerable ?? false,
+    get(this: ReactNativeDataChannel): unknown {
+      return originalGet.call(this);
+    },
+    set(this: ReactNativeDataChannel, handler: MessageHandler | null): void {
+      originalSet.call(this, handler);
+      if (handler == null) {
+        return;
+      }
+      const reactTag = this._reactTag;
+      // From now on react-native-webrtc delivers live messages to this handler;
+      // mark the channel so the duplicate copies seen here are dropped.
+      consumed.add(reactTag);
+      const pending = buffered.get(reactTag);
+      if (pending == null) {
+        return;
+      }
+      buffered.delete(reactTag);
+      for (const data of pending) {
+        handler({ data });
+      }
+    },
+  });
+
+  Object.defineProperty(prototype, INSTALLED_FLAG, {
+    value: true,
+    enumerable: false,
+    writable: false,
+    configurable: true,
+  });
+}

package/src/event-target-polyfill.ts

@@ -0,0 +1,268 @@
+/**
+ * A self-contained WHATWG `Event` / `EventTarget` / `CustomEvent` polyfill for
+ * the React Native Hermes engine.
+ *
+ * React Native's `setUpDOM` polyfills a handful of DOM globals (`DOMRect`,
+ * `Node`, `Element`, ...) but **not** the event classes, and Hermes ships none
+ * of them. libp2p depends on all three at module-evaluation time:
+ *
+ *  - `@libp2p/interface` declares `class StreamMessageEvent extends Event`.
+ *  - `main-event`'s `TypedEventEmitter extends EventTarget` and dispatches
+ *    `new CustomEvent(type, { detail })`.
+ *
+ * Without these globals the bundle red-screens with
+ * `Property 'Event' doesn't exist` before any application code runs.
+ *
+ * This is a hand-rolled implementation rather than a dependency on
+ * `event-target-shim` on purpose: the shim's type definitions expose `Event`
+ * only as an interface (not a constructor value), and its dispatcher wraps
+ * foreign event objects in a copy — which breaks the `instanceof` checks and
+ * subclass fields (e.g. `StreamMessageEvent.data`) that libp2p relies on.
+ * Owning both `Event` and `EventTarget` here guarantees the exact event
+ * instance is delivered to every listener.
+ */
+
+interface EventInitLike {
+  readonly bubbles?: boolean;
+  readonly cancelable?: boolean;
+  readonly composed?: boolean;
+}
+
+interface CustomEventInitLike<T> extends EventInitLike {
+  readonly detail?: T;
+}
+
+interface EventListenerOptions {
+  readonly capture?: boolean;
+}
+
+interface AddEventListenerOptions extends EventListenerOptions {
+  readonly once?: boolean;
+  readonly passive?: boolean;
+  readonly signal?: AbortSignalLike;
+}
+
+/**
+ * The minimal `AbortSignal` surface honoured by `addEventListener`'s `signal`
+ * option. libp2p frequently scopes listeners to an abort signal, so a listener
+ * registered with an already-aborted signal must never fire, and one tied to a
+ * live signal must be removed when it aborts.
+ */
+interface AbortSignalLike {
+  readonly aborted: boolean;
+  addEventListener(type: "abort", listener: () => void): void;
+}
+
+type EventListenerCallback =
+  | ((event: PolyfillEvent) => void)
+  | { handleEvent(event: PolyfillEvent): void };
+
+interface RegisteredListener {
+  readonly callback: EventListenerCallback;
+  readonly once: boolean;
+}
+
+function normalizeAddOptions(
+  options?: boolean | AddEventListenerOptions,
+): AddEventListenerOptions {
+  if (typeof options === "boolean") {
+    return { capture: options };
+  }
+  return options ?? {};
+}
+
+/** WHATWG `Event`. */
+class PolyfillEvent {
+  static readonly NONE = 0;
+  static readonly CAPTURING_PHASE = 1;
+  static readonly AT_TARGET = 2;
+  static readonly BUBBLING_PHASE = 3;
+
+  readonly type: string;
+  readonly bubbles: boolean;
+  readonly cancelable: boolean;
+  readonly composed: boolean;
+  readonly timeStamp = 0;
+  readonly isTrusted = false;
+  readonly eventPhase = PolyfillEvent.NONE;
+
+  private targetInternal: PolyfillEventTarget | null = null;
+  private currentTargetInternal: PolyfillEventTarget | null = null;
+  private defaultPreventedInternal = false;
+  private propagationStopped = false;
+  private immediatePropagationStopped = false;
+
+  constructor(type: string, eventInitDict?: EventInitLike) {
+    this.type = type;
+    this.bubbles = eventInitDict?.bubbles ?? false;
+    this.cancelable = eventInitDict?.cancelable ?? false;
+    this.composed = eventInitDict?.composed ?? false;
+  }
+
+  get target(): PolyfillEventTarget | null {
+    return this.targetInternal;
+  }
+
+  get srcElement(): PolyfillEventTarget | null {
+    return this.targetInternal;
+  }
+
+  get currentTarget(): PolyfillEventTarget | null {
+    return this.currentTargetInternal;
+  }
+
+  get defaultPrevented(): boolean {
+    return this.defaultPreventedInternal;
+  }
+
+  preventDefault(): void {
+    if (this.cancelable) {
+      this.defaultPreventedInternal = true;
+    }
+  }
+
+  stopPropagation(): void {
+    this.propagationStopped = true;
+  }
+
+  stopImmediatePropagation(): void {
+    this.propagationStopped = true;
+    this.immediatePropagationStopped = true;
+  }
+
+  composedPath(): PolyfillEventTarget[] {
+    return this.currentTargetInternal == null
+      ? []
+      : [this.currentTargetInternal];
+  }
+
+  // The following methods are polyfill-internal: `PolyfillEventTarget` uses them
+  // to drive dispatch state across the class boundary (TypeScript `private`
+  // members are not reachable from another class).
+
+  /** @internal */
+  beginDispatch(target: PolyfillEventTarget): void {
+    this.targetInternal = target;
+    this.currentTargetInternal = target;
+  }
+
+  /** @internal */
+  endDispatch(): void {
+    this.currentTargetInternal = null;
+  }
+
+  /** @internal */
+  get immediatePropagationWasStopped(): boolean {
+    return this.immediatePropagationStopped;
+  }
+}
+
+/** WHATWG `CustomEvent`. */
+class PolyfillCustomEvent<T = unknown> extends PolyfillEvent {
+  readonly detail: T | null;
+
+  constructor(type: string, eventInitDict?: CustomEventInitLike<T>) {
+    super(type, eventInitDict);
+    this.detail = eventInitDict?.detail ?? null;
+  }
+}
+
+/** WHATWG `EventTarget`. */
+class PolyfillEventTarget {
+  private readonly listenerMap = new Map<string, RegisteredListener[]>();
+
+  addEventListener(
+    type: string,
+    callback: EventListenerCallback | null,
+    options?: boolean | AddEventListenerOptions,
+  ): void {
+    if (callback == null) {
+      return;
+    }
+    const opts = normalizeAddOptions(options);
+    const signal = opts.signal;
+    if (signal?.aborted === true) {
+      return;
+    }
+    const list = this.listenerMap.get(type) ?? [];
+    // Per spec a (callback, capture) pair is registered at most once.
+    if (list.some((entry) => entry.callback === callback)) {
+      return;
+    }
+    list.push({ callback, once: opts.once ?? false });
+    this.listenerMap.set(type, list);
+    if (signal != null) {
+      signal.addEventListener("abort", () => {
+        this.removeEventListener(type, callback);
+      });
+    }
+  }
+
+  removeEventListener(
+    type: string,
+    callback: EventListenerCallback | null,
+    _options?: boolean | EventListenerOptions,
+  ): void {
+    if (callback == null) {
+      return;
+    }
+    const list = this.listenerMap.get(type);
+    if (list == null) {
+      return;
+    }
+    const index = list.findIndex((entry) => entry.callback === callback);
+    if (index >= 0) {
+      list.splice(index, 1);
+    }
+  }
+
+  dispatchEvent(event: PolyfillEvent): boolean {
+    event.beginDispatch(this);
+    // Snapshot the list: a listener may add or remove listeners mid-dispatch.
+    const list = this.listenerMap.get(event.type);
+    if (list != null) {
+      for (const entry of [...list]) {
+        if (entry.once) {
+          this.removeEventListener(event.type, entry.callback);
+        }
+        const { callback } = entry;
+        if (typeof callback === "function") {
+          callback(event);
+        } else {
+          callback.handleEvent(event);
+        }
+        if (event.immediatePropagationWasStopped) {
+          break;
+        }
+      }
+    }
+    event.endDispatch();
+    return !event.defaultPrevented;
+  }
+}
+
+/**
+ * Install `Event`, `EventTarget`, and `CustomEvent` on the global scope,
+ * overwriting any implementation the runtime already provides.
+ *
+ * The overwrite is deliberate, not defensive. React Native's own global `Event`
+ * exposes read-only/non-configurable members (`type`, the phase constants) that
+ * libp2p's event subclasses redeclare as class fields, which throws at
+ * construction on Hermes. {@link PolyfillEvent} declares them as writable,
+ * configurable fields, so the three globals are replaced outright (not `??=`d)
+ * to guarantee a single, subclass-safe hierarchy for libp2p's `instanceof`
+ * checks and `EventTarget` dispatch.
+ *
+ * Runs once from the polyfills entry, before any libp2p module evaluates. Safe
+ * to call more than once.
+ */
+export function installEventTargetPolyfill(): void {
+  const eventScope = globalThis as {
+    Event?: unknown;
+    EventTarget?: unknown;
+    CustomEvent?: unknown;
+  };
+  eventScope.Event = PolyfillEvent;
+  eventScope.EventTarget = PolyfillEventTarget;
+  eventScope.CustomEvent = PolyfillCustomEvent;
+}

package/src/factories.ts

@@ -0,0 +1,116 @@
+import { noise } from "@chainsafe/libp2p-noise";
+import { yamux } from "@chainsafe/libp2p-yamux";
+import { circuitRelayTransport } from "@libp2p/circuit-relay-v2";
+import { identify } from "@libp2p/identify";
+import { webRTC, webRTCDirect } from "@libp2p/webrtc";
+import type { ConnectionGater } from "@libp2p/interface";
+import type { NodeAddress, RelayDialAddress } from "@peerkit/api";
+import {
+  TransportLibp2p,
+  type NodeOptions,
+} from "@peerkit/transport-libp2p-core";
+import { createLibp2p } from "libp2p";
+import { quickCryptoNoise } from "./quick-crypto-noise.js";
+
+/**
+ * Default libp2p listen addresses for a React Native peerkit node.
+ *
+ * Mobile peers cannot accept inbound direct TCP/UDP (CGNAT, no listen socket
+ * survives backgrounding on iOS / Android), so reachability is always
+ * relay-mediated: `/p2p-circuit` advertises a reservation on a connected
+ * relay, `/webrtc` advertises that the peer can be upgraded to a direct
+ * WebRTC connection through the relay-coordinated SDP exchange.
+ */
+export const defaultNodeListenAddrs: NodeAddress[] = [
+  "/p2p-circuit",
+  "/webrtc",
+];
+
+/**
+ * React Native-specific options accepted by {@link createNode}, on top of the
+ * platform-agnostic {@link NodeOptions}.
+ */
+export interface CreateNodeOptions extends NodeOptions {
+  /**
+   * Listening addresses.
+   *
+   * Defaults to {@link defaultNodeListenAddrs}.
+   */
+  addrs?: string[];
+  /**
+   * Relay multiaddrs to dial at startup. Required on mobile — without an
+   * active relay reservation the peer is unreachable. The transport invokes
+   * {@link NodeOptions.connectedToRelayCallback} once the dialable circuit
+   * address has been received.
+   */
+  bootstrapRelays?: RelayDialAddress[];
+  /**
+   * List of ICE server URLs needed for establishing direct connections.
+   */
+  iceServerUrls?: string[];
+  /**
+   * Overrides libp2p's connection gater.
+   *
+   * On React Native libp2p applies its browser gater, which refuses to dial
+   * private/LAN addresses. A production deployment behind a public relay never
+   * hits this, but development and demo setups that target a LAN relay or LAN
+   * peers must supply a gater that permits those dials
+   * (e.g. `{ denyDialMultiaddr: async () => false }`).
+   *
+   * Left undefined, libp2p keeps its secure-by-default browser gater.
+   */
+  connectionGater?: ConnectionGater;
+}
+
+/**
+ * Build a React Native peerkit transport. Configures libp2p with WebRTC +
+ * WebRTC Direct + circuit-relay-v2 client + noise + yamux + identify.
+ *
+ * Noise is wired with `quickCryptoNoise`, the JSI-backed `ICryptoInterface`
+ * from `./quick-crypto-noise`, so SHA-256, HKDF, and ChaCha20-Poly1305 are
+ * offloaded to `react-native-quick-crypto`. X25519 stays on pure JS because
+ * `ICryptoInterface` is synchronous and quick-crypto's X25519 surface is not.
+ *
+ * Crypto primitives, RNG and the WebRTC globals come from runtime polyfills
+ * — the consumer must import `@peerkit/transport-libp2p-react-native/polyfills`
+ * once from the app entry before this factory runs.
+ *
+ * Handles all three peerkit protocols (access, agents, messages). DCUtR is
+ * deliberately not registered: mobile cannot listen on TCP/QUIC, so there is
+ * no relayed connection that can be upgraded by hole-punching; WebRTC ICE
+ * provides the only viable direct-connection path on mobile.
+ */
+export async function createNode(options: CreateNodeOptions) {
+  // Build array of ICE servers if provided or leave undefined to use
+  // libp2p default.
+  const iceServers =
+    options.iceServerUrls &&
+    options.iceServerUrls.map((url) => ({
+      urls: url,
+    }));
+  const libp2pNode = await createLibp2p({
+    // Defer listening so TransportLibp2p can register protocol handlers
+    // (including /peerkit/access/v1) before any inbound connection arrives.
+    start: false,
+    transports: [
+      webRTC({ rtcConfiguration: { iceServers } }),
+      webRTCDirect(),
+      circuitRelayTransport(),
+    ],
+    connectionEncrypters: [noise({ crypto: quickCryptoNoise })],
+    streamMuxers: [yamux()],
+    services: { identify: identify() },
+    connectionGater: options.connectionGater,
+    addresses: {
+      listen: options.addrs ?? defaultNodeListenAddrs,
+    },
+  });
+  const transport = new TransportLibp2p(libp2pNode, options);
+  await libp2pNode.start();
+  // Connect to all provided relays. Fire-and-forget: the transport calls
+  // connectedToRelayCallback on successful connect to a relay.
+  if (options.bootstrapRelays?.length) {
+    transport.connectToRelays(options.bootstrapRelays);
+  }
+  return transport;
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from "./factories.js";
+export {
+  TransportLibp2p,
+  CURRENT_ACCESS_PROTOCOL,
+  CURRENT_AGENTS_PROTOCOL,
+  CURRENT_MESSAGE_PROTOCOL,
+  type NodeOptions,
+  type RelayOptions,
+  type TransportOptionsBase,
+} from "@peerkit/transport-libp2p-core";