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

package/dist/factories.js

@@ -0,0 +1,73 @@
+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 { TransportLibp2p, } 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 = [
+    "/p2p-circuit",
+    "/webrtc",
+];
+/**
+ * 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) {
+    // 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;
+}
+//# sourceMappingURL=factories.js.map

package/dist/factories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.js","sourceRoot":"","sources":["../src/factories.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGtD,OAAO,EACL,eAAe,GAEhB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAkB;IACnD,cAAc;IACd,SAAS;CACV,CAAC;AAsCF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,OAA0B;IACzD,mEAAmE;IACnE,kBAAkB;IAClB,MAAM,UAAU,GACd,OAAO,CAAC,aAAa;QACrB,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;YAClC,IAAI,EAAE,GAAG;SACV,CAAC,CAAC,CAAC;IACN,MAAM,UAAU,GAAG,MAAM,YAAY,CAAC;QACpC,oEAAoE;QACpE,wEAAwE;QACxE,KAAK,EAAE,KAAK;QACZ,UAAU,EAAE;YACV,MAAM,CAAC,EAAE,gBAAgB,EAAE,EAAE,UAAU,EAAE,EAAE,CAAC;YAC5C,YAAY,EAAE;YACd,qBAAqB,EAAE;SACxB;QACD,oBAAoB,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;QAC3D,YAAY,EAAE,CAAC,KAAK,EAAE,CAAC;QACvB,QAAQ,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE;QAClC,eAAe,EAAE,OAAO,CAAC,eAAe;QACxC,SAAS,EAAE;YACT,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,sBAAsB;SAChD;KACF,CAAC,CAAC;IACH,MAAM,SAAS,GAAG,IAAI,eAAe,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC3D,MAAM,UAAU,CAAC,KAAK,EAAE,CAAC;IACzB,uEAAuE;IACvE,6DAA6D;IAC7D,IAAI,OAAO,CAAC,eAAe,EAAE,MAAM,EAAE,CAAC;QACpC,SAAS,CAAC,eAAe,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+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";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,uBAAuB,EACvB,wBAAwB,EACxB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,oBAAoB,GAC1B,MAAM,gCAAgC,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./factories.js";
+export { TransportLibp2p, CURRENT_ACCESS_PROTOCOL, CURRENT_AGENTS_PROTOCOL, CURRENT_MESSAGE_PROTOCOL, } from "@peerkit/transport-libp2p-core";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,uBAAuB,EACvB,wBAAwB,GAIzB,MAAM,gCAAgC,CAAC"}

package/dist/polyfills.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Runtime polyfills required by libp2p when running on React Native (Hermes).
+ *
+ * Side-effect import from the app entry, **before any other import**:
+ *
+ * ```ts
+ * import "@peerkit/transport-libp2p-react-native/polyfills";
+ * ```
+ *
+ * Order matters:
+ *  1. `react-native-get-random-values` — patches `globalThis.crypto.getRandomValues`.
+ *     Must run first so anything that touches RNG during module init (peer-id,
+ *     noise key generation) observes the JSI implementation.
+ *  2. `react-native-quick-crypto` `install()` — installs the JSI-backed
+ *     `globalThis.crypto.subtle` (Ed25519, X25519, AES-GCM, ChaCha20-Poly1305,
+ *     HMAC, SHA-256) used by `@chainsafe/libp2p-noise`.
+ *  3. `react-native-webrtc` `registerGlobals()` — defines the global
+ *     `RTCPeerConnection`, `RTCSessionDescription`, etc. used by
+ *     `@libp2p/webrtc`, followed by `installWebRtcCertificatePolyfill()` which
+ *     adds the static `RTCPeerConnection.generateCertificate` method the
+ *     webrtc-direct dialer needs but `react-native-webrtc` does not provide
+ *     (see `webrtc-certificate-polyfill`), and
+ *     `installDataChannelEarlyMessagePolyfill()` which recovers the first
+ *     inbound datachannel message `react-native-webrtc` drops during connection
+ *     setup, otherwise mobile-to-mobile stream handshakes hang (see
+ *     `datachannel-early-message-polyfill`).
+ *
+ * It also installs the WHATWG `Event` / `EventTarget` / `CustomEvent` globals
+ * that Hermes lacks but libp2p extends at module-evaluation time (see
+ * `event-target-polyfill`), plus the `TextEncoder` / `TextDecoder` globals that
+ * `uint8arrays` constructs at module-evaluation time (see `text-codec-polyfill`).
+ * Those steps are order-independent relative to the three above.
+ *
+ * Consumers must also configure Metro to map bare Node imports (`crypto`,
+ * `stream`, `buffer`, `events`) to their React Native equivalents and enable
+ * `@babel/plugin-transform-private-methods` (loose) so libp2p's ES2022
+ * private fields parse under Hermes. See the package README for the full
+ * Metro / Babel configuration.
+ */
+import "react-native-get-random-values";
+//# sourceMappingURL=polyfills.d.ts.map

package/dist/polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyfills.d.ts","sourceRoot":"","sources":["../src/polyfills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,gCAAgC,CAAC"}

package/dist/polyfills.js

@@ -0,0 +1,67 @@
+/**
+ * Runtime polyfills required by libp2p when running on React Native (Hermes).
+ *
+ * Side-effect import from the app entry, **before any other import**:
+ *
+ * ```ts
+ * import "@peerkit/transport-libp2p-react-native/polyfills";
+ * ```
+ *
+ * Order matters:
+ *  1. `react-native-get-random-values` — patches `globalThis.crypto.getRandomValues`.
+ *     Must run first so anything that touches RNG during module init (peer-id,
+ *     noise key generation) observes the JSI implementation.
+ *  2. `react-native-quick-crypto` `install()` — installs the JSI-backed
+ *     `globalThis.crypto.subtle` (Ed25519, X25519, AES-GCM, ChaCha20-Poly1305,
+ *     HMAC, SHA-256) used by `@chainsafe/libp2p-noise`.
+ *  3. `react-native-webrtc` `registerGlobals()` — defines the global
+ *     `RTCPeerConnection`, `RTCSessionDescription`, etc. used by
+ *     `@libp2p/webrtc`, followed by `installWebRtcCertificatePolyfill()` which
+ *     adds the static `RTCPeerConnection.generateCertificate` method the
+ *     webrtc-direct dialer needs but `react-native-webrtc` does not provide
+ *     (see `webrtc-certificate-polyfill`), and
+ *     `installDataChannelEarlyMessagePolyfill()` which recovers the first
+ *     inbound datachannel message `react-native-webrtc` drops during connection
+ *     setup, otherwise mobile-to-mobile stream handshakes hang (see
+ *     `datachannel-early-message-polyfill`).
+ *
+ * It also installs the WHATWG `Event` / `EventTarget` / `CustomEvent` globals
+ * that Hermes lacks but libp2p extends at module-evaluation time (see
+ * `event-target-polyfill`), plus the `TextEncoder` / `TextDecoder` globals that
+ * `uint8arrays` constructs at module-evaluation time (see `text-codec-polyfill`).
+ * Those steps are order-independent relative to the three above.
+ *
+ * Consumers must also configure Metro to map bare Node imports (`crypto`,
+ * `stream`, `buffer`, `events`) to their React Native equivalents and enable
+ * `@babel/plugin-transform-private-methods` (loose) so libp2p's ES2022
+ * private fields parse under Hermes. See the package README for the full
+ * Metro / Babel configuration.
+ */
+import "react-native-get-random-values";
+import { Buffer } from "buffer";
+import process from "process";
+import { install as installQuickCrypto } from "react-native-quick-crypto";
+import { registerGlobals as registerWebRtcGlobals } from "react-native-webrtc";
+import { installDataChannelEarlyMessagePolyfill } from "./datachannel-early-message-polyfill.js";
+import { installEventTargetPolyfill } from "./event-target-polyfill.js";
+import { installTextCodecPolyfill } from "./text-codec-polyfill.js";
+import { installWebRtcCertificatePolyfill } from "./webrtc-certificate-polyfill.js";
+import { installWebSocketBufferedAmountPolyfill } from "./websocket-buffered-amount-polyfill.js";
+// Buffer + process must live on globalThis: some libp2p dependencies reach for these as globals
+// rather than as ES module imports. Metro's `extraNodeModules` only rewrites
+// bare imports — code that touches `globalThis.Buffer` or
+// `globalThis.process.nextTick` directly relies on this assignment.
+const globalScope = globalThis;
+globalScope.Buffer ??= Buffer;
+globalScope.process ??= process;
+installEventTargetPolyfill();
+installTextCodecPolyfill();
+installWebSocketBufferedAmountPolyfill();
+installQuickCrypto();
+registerWebRtcGlobals();
+// Must run after `registerWebRtcGlobals()`: both patch the global
+// `RTCPeerConnection` that step installs (the early-message polyfill also probes
+// it for the `RTCDataChannel` prototype).
+installWebRtcCertificatePolyfill();
+installDataChannelEarlyMessagePolyfill();
+//# sourceMappingURL=polyfills.js.map

package/dist/polyfills.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyfills.js","sourceRoot":"","sources":["../src/polyfills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,gCAAgC,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,OAAO,MAAM,SAAS,CAAC;AAC9B,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,EAAE,eAAe,IAAI,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EAAE,sCAAsC,EAAE,MAAM,yCAAyC,CAAC;AACjG,OAAO,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,gCAAgC,EAAE,MAAM,kCAAkC,CAAC;AACpF,OAAO,EAAE,sCAAsC,EAAE,MAAM,yCAAyC,CAAC;AAEjG,gGAAgG;AAChG,6EAA6E;AAC7E,0DAA0D;AAC1D,oEAAoE;AACpE,MAAM,WAAW,GAAG,UAGnB,CAAC;AACF,WAAW,CAAC,MAAM,KAAK,MAAM,CAAC;AAC9B,WAAW,CAAC,OAAO,KAAK,OAAO,CAAC;AAEhC,0BAA0B,EAAE,CAAC;AAC7B,wBAAwB,EAAE,CAAC;AAC3B,sCAAsC,EAAE,CAAC;AACzC,kBAAkB,EAAE,CAAC;AACrB,qBAAqB,EAAE,CAAC;AACxB,kEAAkE;AAClE,iFAAiF;AACjF,0CAA0C;AAC1C,gCAAgC,EAAE,CAAC;AACnC,sCAAsC,EAAE,CAAC"}

package/dist/quick-crypto-noise.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `ICryptoInterface` implementation backed by `react-native-quick-crypto`,
+ * intended to be passed to `noise({ crypto: quickCryptoNoise })` on React
+ * Native. JSI-backed primitives are noticeably faster than the pure-JS Noise
+ * defaults on Hermes, which matters for handshake latency and bulk transfer.
+ *
+ * Only the primitives that have a usable synchronous quick-crypto mapping are
+ * overridden:
+ *
+ *  - `hashSHA256` — `createHash('sha256')`
+ *  - `getHKDF` — RFC 5869 HKDF built on `createHmac('sha256', ...)`
+ *  - `chaCha20Poly1305Encrypt` / `chaCha20Poly1305Decrypt` —
+ *    `createCipheriv` / `createDecipheriv` with the `chacha20-poly1305`
+ *    AEAD, 16-byte authentication tag appended to / split from the
+ *    ciphertext per the Noise specification.
+ *
+ * X25519 key generation and shared-secret derivation are delegated to
+ * `pureJsCrypto` because the quick-crypto X25519 API is asynchronous
+ * (subtle-style) whereas `ICryptoInterface` requires synchronous methods.
+ * The pure-JS X25519 implementation is fast enough that JSI offers little
+ * practical gain.
+ *
+ * This module pulls in `react-native-quick-crypto` at import time and must
+ * therefore only be imported in a React Native bundle. It is exposed via the
+ * dedicated `./quick-crypto-noise` subexport so the package's main entry
+ * remains free of React Native-only side effects.
+ */
+import { type ICryptoInterface } from "@chainsafe/libp2p-noise";
+/**
+ * Quick-crypto-backed Noise crypto. Inherits synchronous X25519 operations
+ * from `pureJsCrypto`; overrides SHA-256, HKDF, and ChaCha20-Poly1305 with
+ * JSI-backed implementations.
+ */
+export declare const quickCryptoNoise: ICryptoInterface;
+//# sourceMappingURL=quick-crypto-noise.d.ts.map

package/dist/quick-crypto-noise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quick-crypto-noise.d.ts","sourceRoot":"","sources":["../src/quick-crypto-noise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAgB,KAAK,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AA0F9E;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAM9B,CAAC"}

package/dist/quick-crypto-noise.js

@@ -0,0 +1,105 @@
+/**
+ * `ICryptoInterface` implementation backed by `react-native-quick-crypto`,
+ * intended to be passed to `noise({ crypto: quickCryptoNoise })` on React
+ * Native. JSI-backed primitives are noticeably faster than the pure-JS Noise
+ * defaults on Hermes, which matters for handshake latency and bulk transfer.
+ *
+ * Only the primitives that have a usable synchronous quick-crypto mapping are
+ * overridden:
+ *
+ *  - `hashSHA256` — `createHash('sha256')`
+ *  - `getHKDF` — RFC 5869 HKDF built on `createHmac('sha256', ...)`
+ *  - `chaCha20Poly1305Encrypt` / `chaCha20Poly1305Decrypt` —
+ *    `createCipheriv` / `createDecipheriv` with the `chacha20-poly1305`
+ *    AEAD, 16-byte authentication tag appended to / split from the
+ *    ciphertext per the Noise specification.
+ *
+ * X25519 key generation and shared-secret derivation are delegated to
+ * `pureJsCrypto` because the quick-crypto X25519 API is asynchronous
+ * (subtle-style) whereas `ICryptoInterface` requires synchronous methods.
+ * The pure-JS X25519 implementation is fast enough that JSI offers little
+ * practical gain.
+ *
+ * This module pulls in `react-native-quick-crypto` at import time and must
+ * therefore only be imported in a React Native bundle. It is exposed via the
+ * dedicated `./quick-crypto-noise` subexport so the package's main entry
+ * remains free of React Native-only side effects.
+ */
+import { pureJsCrypto } from "@chainsafe/libp2p-noise";
+import QuickCrypto from "react-native-quick-crypto";
+const TAG_LENGTH = 16;
+function toBytes(data) {
+    // `Uint8ArrayList.subarray()` returns a contiguous Uint8Array view, which
+    // is what quick-crypto's Node-compatible API expects.
+    return data instanceof Uint8Array ? data : data.subarray();
+}
+function hashSHA256(data) {
+    return QuickCrypto.createHash("sha256").update(toBytes(data)).digest();
+}
+function hmacSHA256(key, data) {
+    return QuickCrypto.createHmac("sha256", key).update(data).digest();
+}
+function getHKDF(ck, ikm) {
+    // RFC 5869 HKDF with SHA-256, three 32-byte outputs as required by the
+    // Noise specification. Extract step: PRK = HMAC(ck, ikm). Expand step:
+    // outN = HMAC(PRK, outN-1 || counter), starting from an empty previous
+    // block.
+    const prk = hmacSHA256(ck, ikm);
+    const out1 = hmacSHA256(prk, new Uint8Array([0x01]));
+    const out2Input = new Uint8Array(out1.length + 1);
+    out2Input.set(out1, 0);
+    out2Input[out1.length] = 0x02;
+    const out2 = hmacSHA256(prk, out2Input);
+    const out3Input = new Uint8Array(out2.length + 1);
+    out3Input.set(out2, 0);
+    out3Input[out2.length] = 0x03;
+    const out3 = hmacSHA256(prk, out3Input);
+    return [out1, out2, out3];
+}
+function chaCha20Poly1305Encrypt(plaintext, nonce, ad, k) {
+    const cipher = QuickCrypto.createCipheriv("chacha20-poly1305", k, nonce, {
+        authTagLength: TAG_LENGTH,
+    });
+    cipher.setAAD(ad);
+    const head = cipher.update(toBytes(plaintext));
+    const tail = cipher.final();
+    const tag = cipher.getAuthTag();
+    // Noise wire format: ciphertext || tag (16 bytes).
+    const out = new Uint8Array(head.length + tail.length + tag.length);
+    out.set(head, 0);
+    out.set(tail, head.length);
+    out.set(tag, head.length + tail.length);
+    return out;
+}
+function chaCha20Poly1305Decrypt(ciphertext, nonce, ad, k) {
+    const bytes = toBytes(ciphertext);
+    if (bytes.length < TAG_LENGTH) {
+        throw new Error("ChaCha20-Poly1305 ciphertext shorter than tag length");
+    }
+    const ct = bytes.subarray(0, bytes.length - TAG_LENGTH);
+    const tag = bytes.subarray(bytes.length - TAG_LENGTH);
+    const decipher = QuickCrypto.createDecipheriv("chacha20-poly1305", k, nonce, {
+        authTagLength: TAG_LENGTH,
+    });
+    decipher.setAAD(ad);
+    decipher.setAuthTag(tag);
+    const head = decipher.update(ct);
+    const tail = decipher.final();
+    const out = new Uint8Array(head.length + tail.length);
+    out.set(head, 0);
+    out.set(tail, head.length);
+    return out;
+}
+/**
+ * Quick-crypto-backed Noise crypto. Inherits synchronous X25519 operations
+ * from `pureJsCrypto`; overrides SHA-256, HKDF, and ChaCha20-Poly1305 with
+ * JSI-backed implementations.
+ */
+export const quickCryptoNoise = {
+    ...pureJsCrypto,
+    hashSHA256,
+    getHKDF,
+    chaCha20Poly1305Encrypt,
+    chaCha20Poly1305Decrypt,
+};
+//# sourceMappingURL=quick-crypto-noise.js.map

package/dist/quick-crypto-noise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quick-crypto-noise.js","sourceRoot":"","sources":["../src/quick-crypto-noise.ts"],"names":[],"mappings":"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"}

package/dist/text-codec-polyfill.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A `TextEncoder` / `TextDecoder` polyfill for the React Native Hermes engine.
+ *
+ * Hermes ships neither global, yet libp2p reaches for them at
+ * module-evaluation time: `uint8arrays` (a transitive dependency of nearly
+ * every libp2p package) constructs `new TextEncoder()` / `new TextDecoder()`
+ * to convert between UTF-8 strings and byte arrays for peer ids, multiaddrs,
+ * and protocol names. Without these globals the bundle red-screens with
+ * `Property 'TextDecoder' doesn't exist` before any application code runs.
+ *
+ * Only UTF-8 is implemented — the single encoding libp2p uses through these
+ * APIs. The conversion is delegated to `Buffer` (already a required shim, see
+ * `polyfills`), which provides a spec-correct UTF-8 implementation including
+ * surrogate-pair handling and replacement of malformed sequences. Owning a
+ * thin wrapper here, rather than pulling in a third-party text-encoding
+ * package, keeps the polyfill surface small and dependency-free.
+ */
+/**
+ * Install `TextEncoder` and `TextDecoder` on the global scope if the runtime
+ * does not already provide them. Idempotent and safe to call more than once;
+ * on a runtime that ships its own implementations (e.g. Node in tests) this is
+ * a no-op.
+ */
+export declare function installTextCodecPolyfill(): void;
+//# sourceMappingURL=text-codec-polyfill.d.ts.map

package/dist/text-codec-polyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-codec-polyfill.d.ts","sourceRoot":"","sources":["../src/text-codec-polyfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAwFH;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C"}

package/dist/text-codec-polyfill.js

@@ -0,0 +1,79 @@
+/**
+ * A `TextEncoder` / `TextDecoder` polyfill for the React Native Hermes engine.
+ *
+ * Hermes ships neither global, yet libp2p reaches for them at
+ * module-evaluation time: `uint8arrays` (a transitive dependency of nearly
+ * every libp2p package) constructs `new TextEncoder()` / `new TextDecoder()`
+ * to convert between UTF-8 strings and byte arrays for peer ids, multiaddrs,
+ * and protocol names. Without these globals the bundle red-screens with
+ * `Property 'TextDecoder' doesn't exist` before any application code runs.
+ *
+ * Only UTF-8 is implemented — the single encoding libp2p uses through these
+ * APIs. The conversion is delegated to `Buffer` (already a required shim, see
+ * `polyfills`), which provides a spec-correct UTF-8 implementation including
+ * surrogate-pair handling and replacement of malformed sequences. Owning a
+ * thin wrapper here, rather than pulling in a third-party text-encoding
+ * package, keeps the polyfill surface small and dependency-free.
+ */
+import { Buffer } from "buffer";
+const UTF8_ENCODING = "utf-8";
+// The WHATWG labels that all denote UTF-8. A `TextDecoder` constructed with any
+// other label must throw, matching browser behavior and surfacing accidental
+// non-UTF-8 usage rather than silently misdecoding.
+const UTF8_LABELS = new Set([
+    "utf-8",
+    "utf8",
+    "unicode-1-1-utf-8",
+]);
+const bufferFactory = Buffer;
+/** WHATWG `TextEncoder`, UTF-8 only. */
+class PolyfillTextEncoder {
+    get encoding() {
+        return UTF8_ENCODING;
+    }
+    encode(input = "") {
+        return new Uint8Array(bufferFactory.from(input, "utf8"));
+    }
+}
+/**
+ * WHATWG `TextDecoder`, UTF-8 only.
+ *
+ * `fatal` and `ignoreBOM` are accepted and reflected as readonly properties for
+ * API-shape compatibility, but not honored: `Buffer.toString('utf8')` always
+ * replaces malformed sequences (`fatal: false`) and never strips a BOM. libp2p
+ * constructs decoders with default options, so this is sufficient — a caller
+ * relying on `fatal`/`ignoreBOM` semantics is out of this polyfill's scope.
+ */
+class PolyfillTextDecoder {
+    encoding = UTF8_ENCODING;
+    fatal;
+    ignoreBOM;
+    constructor(label = UTF8_ENCODING, options = {}) {
+        if (!UTF8_LABELS.has(label.toLowerCase())) {
+            throw new RangeError(`Unsupported encoding: ${label}. Only UTF-8 is supported.`);
+        }
+        this.fatal = options.fatal ?? false;
+        this.ignoreBOM = options.ignoreBOM ?? false;
+    }
+    decode(input) {
+        if (input == null) {
+            return "";
+        }
+        const bytes = ArrayBuffer.isView(input)
+            ? bufferFactory.from(input.buffer, input.byteOffset, input.byteLength)
+            : bufferFactory.from(input);
+        return bytes.toString("utf8");
+    }
+}
+/**
+ * Install `TextEncoder` and `TextDecoder` on the global scope if the runtime
+ * does not already provide them. Idempotent and safe to call more than once;
+ * on a runtime that ships its own implementations (e.g. Node in tests) this is
+ * a no-op.
+ */
+export function installTextCodecPolyfill() {
+    const codecScope = globalThis;
+    codecScope.TextEncoder ??= PolyfillTextEncoder;
+    codecScope.TextDecoder ??= PolyfillTextDecoder;
+}
+//# sourceMappingURL=text-codec-polyfill.js.map

package/dist/text-codec-polyfill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-codec-polyfill.js","sourceRoot":"","sources":["../src/text-codec-polyfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,aAAa,GAAG,OAAO,CAAC;AAE9B,gFAAgF;AAChF,6EAA6E;AAC7E,oDAAoD;AACpD,MAAM,WAAW,GAAwB,IAAI,GAAG,CAAC;IAC/C,OAAO;IACP,MAAM;IACN,mBAAmB;CACpB,CAAC,CAAC;AAwBH,MAAM,aAAa,GAAG,MAAkC,CAAC;AAEzD,wCAAwC;AACxC,MAAM,mBAAmB;IACvB,IAAI,QAAQ;QACV,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,MAAM,CAAC,QAAgB,EAAE;QACvB,OAAO,IAAI,UAAU,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3D,CAAC;CACF;AAED;;;;;;;;GAQG;AACH,MAAM,mBAAmB;IACd,QAAQ,GAAG,aAAa,CAAC;IACzB,KAAK,CAAU;IACf,SAAS,CAAU;IAE5B,YACE,QAAgB,aAAa,EAC7B,UAAkC,EAAE;QAEpC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;YAC1C,MAAM,IAAI,UAAU,CAClB,yBAAyB,KAAK,4BAA4B,CAC3D,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,KAAK,CAAC;QACpC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC;IAC9C,CAAC;IAED,MAAM,CAAC,KAAqC;QAC1C,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;YAClB,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC;YACrC,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC;YACtE,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9B,OAAO,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB;IACtC,MAAM,UAAU,GAAG,UAGlB,CAAC;IACF,UAAU,CAAC,WAAW,KAAK,mBAAmB,CAAC;IAC/C,UAAU,CAAC,WAAW,KAAK,mBAAmB,CAAC;AACjD,CAAC"}

package/dist/webrtc-certificate-polyfill.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Give React Native's `RTCPeerConnection` the static `generateCertificate`
+ * method that `@libp2p/webrtc`'s webrtc-direct dialer requires.
+ *
+ * Metro selects the browser build of `@libp2p/webrtc` on React Native. Its
+ * dialer creates the peer connection like this:
+ *
+ * ```js
+ * const certificate = await RTCPeerConnection.generateCertificate({
+ *   name: "ECDSA",
+ *   namedCurve: "P-256",
+ * });
+ * new RTCPeerConnection({ certificates: [certificate] });
+ * ```
+ *
+ * `react-native-webrtc` (v124) implements neither the static
+ * `generateCertificate` method nor the `certificates` constructor option — it
+ * always generates its own DTLS certificate natively — so the dialer throws
+ * `RTCPeerConnection.generateCertificate is not a function`.
+ *
+ * Supplying a specific certificate is unnecessary for webrtc-direct. The dialer
+ * reads its own fingerprint back out of the generated local SDP
+ * (`getFingerprintFromSdp(peerConnection.localDescription.sdp)`) and binds it
+ * into the Noise prologue, so the certificate the native layer produces is the
+ * one that actually gets authenticated. We only need the call to resolve: the
+ * returned value is forwarded as the `certificates` option, which
+ * `react-native-webrtc` does not read, so a plain placeholder object that the
+ * native bridge can serialize is sufficient.
+ */
+/**
+ * Install the static `generateCertificate` method on the global
+ * `RTCPeerConnection`. Idempotent, and a no-op when the global is absent
+ * (`registerGlobals()` has not run, or under tests) or already provides the
+ * method (a browser, or a future `react-native-webrtc` release).
+ */
+export declare function installWebRtcCertificatePolyfill(): void;
+//# sourceMappingURL=webrtc-certificate-polyfill.d.ts.map

package/dist/webrtc-certificate-polyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webrtc-certificate-polyfill.d.ts","sourceRoot":"","sources":["../src/webrtc-certificate-polyfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAQH;;;;;GAKG;AACH,wBAAgB,gCAAgC,IAAI,IAAI,CAiBvD"}

package/dist/webrtc-certificate-polyfill.js

@@ -0,0 +1,53 @@
+/**
+ * Give React Native's `RTCPeerConnection` the static `generateCertificate`
+ * method that `@libp2p/webrtc`'s webrtc-direct dialer requires.
+ *
+ * Metro selects the browser build of `@libp2p/webrtc` on React Native. Its
+ * dialer creates the peer connection like this:
+ *
+ * ```js
+ * const certificate = await RTCPeerConnection.generateCertificate({
+ *   name: "ECDSA",
+ *   namedCurve: "P-256",
+ * });
+ * new RTCPeerConnection({ certificates: [certificate] });
+ * ```
+ *
+ * `react-native-webrtc` (v124) implements neither the static
+ * `generateCertificate` method nor the `certificates` constructor option — it
+ * always generates its own DTLS certificate natively — so the dialer throws
+ * `RTCPeerConnection.generateCertificate is not a function`.
+ *
+ * Supplying a specific certificate is unnecessary for webrtc-direct. The dialer
+ * reads its own fingerprint back out of the generated local SDP
+ * (`getFingerprintFromSdp(peerConnection.localDescription.sdp)`) and binds it
+ * into the Noise prologue, so the certificate the native layer produces is the
+ * one that actually gets authenticated. We only need the call to resolve: the
+ * returned value is forwarded as the `certificates` option, which
+ * `react-native-webrtc` does not read, so a plain placeholder object that the
+ * native bridge can serialize is sufficient.
+ */
+const CERTIFICATE_TTL_MS = 365 * 24 * 60 * 60 * 1000;
+/**
+ * Install the static `generateCertificate` method on the global
+ * `RTCPeerConnection`. Idempotent, and a no-op when the global is absent
+ * (`registerGlobals()` has not run, or under tests) or already provides the
+ * method (a browser, or a future `react-native-webrtc` release).
+ */
+export function installWebRtcCertificatePolyfill() {
+    const scope = globalThis;
+    const peerConnection = scope.RTCPeerConnection;
+    if (peerConnection == null) {
+        return;
+    }
+    if (typeof peerConnection.generateCertificate === "function") {
+        return;
+    }
+    peerConnection.generateCertificate = () => {
+        // react-native-webrtc generates its own DTLS certificate natively; libp2p
+        // reads the resulting fingerprint from the SDP rather than from this
+        // object, so a serializable placeholder is enough to satisfy the dialer.
+        return Promise.resolve({ expires: Date.now() + CERTIFICATE_TTL_MS });
+    };
+}
+//# sourceMappingURL=webrtc-certificate-polyfill.js.map

package/dist/webrtc-certificate-polyfill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webrtc-certificate-polyfill.js","sourceRoot":"","sources":["../src/webrtc-certificate-polyfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAMH,MAAM,kBAAkB,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAErD;;;;;GAKG;AACH,MAAM,UAAU,gCAAgC;IAC9C,MAAM,KAAK,GAAG,UAEb,CAAC;IACF,MAAM,cAAc,GAAG,KAAK,CAAC,iBAAiB,CAAC;IAC/C,IAAI,cAAc,IAAI,IAAI,EAAE,CAAC;QAC3B,OAAO;IACT,CAAC;IACD,IAAI,OAAO,cAAc,CAAC,mBAAmB,KAAK,UAAU,EAAE,CAAC;QAC7D,OAAO;IACT,CAAC;IACD,cAAc,CAAC,mBAAmB,GAAG,GAAqB,EAAE;QAC1D,0EAA0E;QAC1E,qEAAqE;QACrE,yEAAyE;QACzE,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,kBAAkB,EAAE,CAAC,CAAC;IACvE,CAAC,CAAC;AACJ,CAAC"}

package/dist/websocket-buffered-amount-polyfill.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 declare function installWebSocketBufferedAmountPolyfill(): void;
+//# sourceMappingURL=websocket-buffered-amount-polyfill.d.ts.map

package/dist/websocket-buffered-amount-polyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-buffered-amount-polyfill.d.ts","sourceRoot":"","sources":["../src/websocket-buffered-amount-polyfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH;;;;GAIG;AACH,wBAAgB,sCAAsC,IAAI,IAAI,CAoB7D"}