@peerbit/stream 5.0.17 → 5.1.0

package/dist/src/index.js

@@ -17,11 +17,14 @@ import { computeSeekAckRouteUpdate, shouldAcknowledgeDataMessage, } from "./core
 import { logger } from "./logger.js";
 import { pushableLanes } from "./pushable-lanes.js";
 import { MAX_ROUTE_DISTANCE, Routes } from "./routes.js";
+import { resolveInjectedRustCore, } from "./rust-core.js";
 import { BandwidthTracker } from "./stats.js";
 import { waitForEvent } from "./wait-for-event.js";
 export { logger };
 const warn = logger.newScope("warn");
 export { BandwidthTracker }; // might be useful for others
+export { Routes, } from "./routes.js";
+export { RUST_CORE_GLOBAL_KEY, } from "./rust-core.js";
 const getErrorName = (e) => e?.name ?? e?.constructor?.name;
 export const dontThrowIfDeliveryError = (e) => {
     const errorName = getErrorName(e);
@@ -174,6 +177,7 @@ export class PeerStreams extends TypedEventEmitter {
     seekedOnce;
     usedBandWidthTracker;
     outboundQueue;
+    lanesFactory;
     // Unified outbound streams list (during grace may contain >1; after pruning length==1)
     outboundStreams = [];
     // Public debug exposure of current raw outbound streams (during grace may contain >1)
@@ -216,17 +220,28 @@ export class PeerStreams extends TypedEventEmitter {
         const existing = this.outboundStreams.find((c) => c.raw === raw);
         if (existing)
             return existing;
-        const pushableInst = pushableLanes({
-            lanes: PRIORITY_LANES,
-            maxBufferedBytes: this.outboundQueue?.maxBufferedBytes,
-            overflow: "throw",
-            onBufferSize: () => {
-                this.dispatchEvent(new CustomEvent("queue:outbound"));
-            },
-            onPush: (val) => {
-                candidate.bytesDelivered += val.byteLength;
-            },
-        });
+        const pushableInst = this.lanesFactory
+            ? this.lanesFactory({
+                lanes: PRIORITY_LANES,
+                maxBufferedBytes: this.outboundQueue?.maxBufferedBytes,
+                onBufferSize: () => {
+                    this.dispatchEvent(new CustomEvent("queue:outbound"));
+                },
+                onPush: (val) => {
+                    candidate.bytesDelivered += val.byteLength;
+                },
+            })
+            : pushableLanes({
+                lanes: PRIORITY_LANES,
+                maxBufferedBytes: this.outboundQueue?.maxBufferedBytes,
+                overflow: "throw",
+                onBufferSize: () => {
+                    this.dispatchEvent(new CustomEvent("queue:outbound"));
+                },
+                onPush: (val) => {
+                    candidate.bytesDelivered += val.byteLength;
+                },
+            });
         const candidate = {
             raw,
             pushable: pushableInst,
@@ -306,6 +321,7 @@ export class PeerStreams extends TypedEventEmitter {
         this.usedBandWidthTracker = new BandwidthTracker(10);
         this.usedBandWidthTracker.start();
         this.outboundQueue = init.outboundQueue;
+        this.lanesFactory = init.lanesFactory;
     }
     /**
      * Do we have a connection to read from?
@@ -602,6 +618,34 @@ export class PeerStreams extends TypedEventEmitter {
         }
         this._pruneInboundInactive();
     }
+    detachInboundStream(record, reason = new AbortError("Inbound stream ended"), options) {
+        const index = this.inboundStreams.indexOf(record);
+        if (index === -1)
+            return false;
+        this.inboundStreams.splice(index, 1);
+        try {
+            record.abortController.abort(reason);
+        }
+        catch { }
+        if (options?.closeRaw !== false) {
+            try {
+                record.raw.abort?.(reason);
+            }
+            catch { }
+            void Promise.resolve(record.raw.close?.()).catch(() => { });
+        }
+        if (this.rawInboundStream === record.raw) {
+            const next = this.inboundStreams[0];
+            this.rawInboundStream = next?.raw;
+            this.inboundStream = next?.iterable;
+        }
+        if (this.inboundStreams.length <= 1 && this._inboundPruneTimer) {
+            clearTimeout(this._inboundPruneTimer);
+            this._inboundPruneTimer = undefined;
+        }
+        this.dispatchEvent(new CustomEvent("stream:inbound"));
+        return true;
+    }
     /**
      * Attach a raw outbound stream and setup a write stream
      */
@@ -763,6 +807,10 @@ export class PeerStreams extends TypedEventEmitter {
         this.inboundStreams = [];
     }
 }
+const NATIVE_WIRE_RECORD_WORDS = 4;
+const NATIVE_WIRE_FLAG_DECODE_OK = 0x01;
+const NATIVE_WIRE_VERIFY_VERIFIED = 1;
+const NATIVE_WIRE_VERIFY_UNSUPPORTED = 2;
 const sharedRoutingByPrivateKey = new WeakMap();
 export class DirectStream extends TypedEventEmitter {
     components;
@@ -810,6 +858,32 @@ export class DirectStream extends TypedEventEmitter {
     totalOutboundQueueWaiters = new Set();
     sharedRoutingKey;
     sharedRoutingState;
+    nativeWire;
+    rustCore;
+    rustSeenCache;
+    pendingNativeWireFrames = [];
+    nativeWireFlushScheduled = false;
+    /**
+     * Always-on counters recording where per-frame wire work executed. Tests
+     * and benchmarks use them to prove the native path leaves no per-message
+     * JS decode/verify work on the hot path. `tsEnvelopeDecodes` counts the
+     * TS envelope object materializations (`Message.from`); on the native
+     * path that object only feeds the routing state machine and app-facing
+     * events, holding the payload as a zero-copy view, while decode
+     * validation and signature verification stay native.
+     */
+    wireCounters = {
+        /** Frames decoded and signature-verified by the native wire module. */
+        nativeFrames: 0,
+        /** Frames where the native decode failed and the TS path took over. */
+        nativeFallbackFrames: 0,
+        /** Frames processed without a native wire module (pure TS path). */
+        tsFrames: 0,
+        /** TS-side signature verifications (not pre-seeded by native decode). */
+        tsSignatureVerifies: 0,
+        /** TS envelope object materializations (`Message.from`). */
+        tsEnvelopeDecodes: 0,
+    };
     // for sequential creation of outbound streams
     outboundInflightQueue;
     seekTimeout;
@@ -820,7 +894,14 @@ export class DirectStream extends TypedEventEmitter {
     constructor(components, multicodecs, options) {
         super();
         this.components = components;
-        const { canRelayMessage = true, messageProcessingConcurrency = 10, maxInboundStreams, maxOutboundStreams, connectionManager, seekTimeout = SEEK_DELIVERY_TIMEOUT, routeMaxRetentionPeriod = ROUTE_MAX_RETANTION_PERIOD, routeCacheMaxFromEntries, routeCacheMaxTargetsPerFrom, routeCacheMaxRelaysPerTarget, sharedRouting = true, seenCacheMax = 1e6, seenCacheTtlMs = 10 * 60 * 1e3, inboundIdleTimeout, outboundQueue, } = options || {};
+        const { canRelayMessage = true, messageProcessingConcurrency = 10, maxInboundStreams, maxOutboundStreams, connectionManager, seekTimeout = SEEK_DELIVERY_TIMEOUT, routeMaxRetentionPeriod = ROUTE_MAX_RETANTION_PERIOD, routeCacheMaxFromEntries, routeCacheMaxTargetsPerFrom, routeCacheMaxRelaysPerTarget, sharedRouting = true, seenCacheMax = 1e6, seenCacheTtlMs = 10 * 60 * 1e3, inboundIdleTimeout, outboundQueue, nativeWire, rustCore, } = options || {};
+        this.rustCore =
+            rustCore === false ? undefined : (rustCore ?? resolveInjectedRustCore());
+        this.nativeWire = nativeWire ?? this.rustCore?.nativeWire;
+        this.rustSeenCache = this.rustCore?.createSeenCache({
+            max: Math.max(1, Math.floor(seenCacheMax)),
+            ttl: Math.max(1, Math.floor(seenCacheTtlMs)),
+        });
         const signKey = getKeypairFromPrivateKey(components.privateKey);
         this.seekTimeout = seekTimeout;
         this.sign = (bytes) => signKey.sign(bytes, PreHash.SHA_256);
@@ -918,6 +999,25 @@ export class DirectStream extends TypedEventEmitter {
             })
             : undefined;
     }
+    createRoutes(signal) {
+        if (this.rustCore) {
+            return this.rustCore.createRoutes({
+                me: this.publicKeyHash,
+                routeMaxRetentionPeriod: this.routeMaxRetentionPeriod,
+                signal,
+                maxFromEntries: this.routeCacheMaxFromEntries,
+                maxTargetsPerFrom: this.routeCacheMaxTargetsPerFrom,
+                maxRelaysPerTarget: this.routeCacheMaxRelaysPerTarget,
+            });
+        }
+        return new Routes(this.publicKeyHash, {
+            routeMaxRetentionPeriod: this.routeMaxRetentionPeriod,
+            signal,
+            maxFromEntries: this.routeCacheMaxFromEntries,
+            maxTargetsPerFrom: this.routeCacheMaxTargetsPerFrom,
+            maxRelaysPerTarget: this.routeCacheMaxRelaysPerTarget,
+        });
+    }
     pruneConnectionsToLimits() {
         if (this.pruneToLimitsInFlight) {
             return this.pruneToLimitsInFlight;
@@ -1019,13 +1119,7 @@ export class DirectStream extends TypedEventEmitter {
                 state = {
                     session: Date.now(),
                     controller,
-                    routes: new Routes(this.publicKeyHash, {
-                        routeMaxRetentionPeriod: this.routeMaxRetentionPeriod,
-                        signal: controller.signal,
-                        maxFromEntries: this.routeCacheMaxFromEntries,
-                        maxTargetsPerFrom: this.routeCacheMaxTargetsPerFrom,
-                        maxRelaysPerTarget: this.routeCacheMaxRelaysPerTarget,
-                    }),
+                    routes: this.createRoutes(controller.signal),
                     refs: 0,
                 };
                 sharedRoutingByPrivateKey.set(key, state);
@@ -1041,13 +1135,7 @@ export class DirectStream extends TypedEventEmitter {
         }
         else {
             this.session = Date.now();
-            this.routes = new Routes(this.publicKeyHash, {
-                routeMaxRetentionPeriod: this.routeMaxRetentionPeriod,
-                signal: this.closeController.signal,
-                maxFromEntries: this.routeCacheMaxFromEntries,
-                maxTargetsPerFrom: this.routeCacheMaxTargetsPerFrom,
-                maxRelaysPerTarget: this.routeCacheMaxRelaysPerTarget,
-            });
+            this.routes = this.createRoutes(this.closeController.signal);
         }
         this.started = true;
         this.stopping = false;
@@ -1188,6 +1276,11 @@ export class DirectStream extends TypedEventEmitter {
         this.queue.clear();
         this.peers.clear();
         this.seenCache.clear();
+        this.rustSeenCache?.clear();
+        for (const pending of this.pendingNativeWireFrames) {
+            pending.done.resolve();
+        }
+        this.pendingNativeWireFrames = [];
         // When routing is shared across co-located protocols, only clear once the last
         // instance stops. Otherwise we'd wipe routes still in use by other services.
         if (!sharedState) {
@@ -1267,16 +1360,22 @@ export class DirectStream extends TypedEventEmitter {
                 return;
             }
             try {
-                stream = await connection.newStream(this.multicodecs, {
-                    // TODO this property seems necessary, together with waitFor isReadable when making sure two peers are conencted before talking.
-                    // research whether we can do without this so we can push data without beeing able to send
-                    // more info here https://github.com/libp2p/js-libp2p/issues/2321
-                    negotiateFully: true,
-                    signal: anySignal([
-                        this.closeController.signal,
-                        ...(opts?.signal ? [opts.signal] : []),
-                    ]),
-                });
+                const streamSignal = anySignal([
+                    this.closeController.signal,
+                    ...(opts?.signal ? [opts.signal] : []),
+                ]);
+                try {
+                    stream = await connection.newStream(this.multicodecs, {
+                        // TODO this property seems necessary, together with waitFor isReadable when making sure two peers are conencted before talking.
+                        // research whether we can do without this so we can push data without beeing able to send
+                        // more info here https://github.com/libp2p/js-libp2p/issues/2321
+                        negotiateFully: true,
+                        signal: streamSignal,
+                    });
+                }
+                finally {
+                    streamSignal.clear?.();
+                }
                 if (stream.protocol == null) {
                     stream.abort(new Error("Stream was not multiplexed"));
                     return;
@@ -1458,6 +1557,9 @@ export class DirectStream extends TypedEventEmitter {
             protocol,
             connId,
             outboundQueue: this.outboundQueueOptions,
+            lanesFactory: this.rustCore
+                ? (init) => this.rustCore.createLanes(init)
+                : undefined,
         });
         this.peers.set(publicKeyHash, peerStreams);
         this.updateSession(publicKey, -1);
@@ -1507,6 +1609,7 @@ export class DirectStream extends TypedEventEmitter {
      * Responsible for processing each RPC message received by other peers.
      */
     async processMessages(peerId, record, peerStreams) {
+        let failed = false;
         try {
             for await (const data of record.iterable) {
                 const now = Date.now();
@@ -1516,6 +1619,7 @@ export class DirectStream extends TypedEventEmitter {
             }
         }
         catch (err) {
+            failed = true;
             if (err?.code === "ERR_STREAM_RESET") {
                 // only send stream reset messages to info
                 logger("Failed processing messages to id: " +
@@ -1531,6 +1635,12 @@ export class DirectStream extends TypedEventEmitter {
             }
             this.onPeerDisconnected(peerStreams.peerId);
         }
+        finally {
+            const removed = peerStreams.detachInboundStream(record, new AbortError("Inbound stream reader ended"), { closeRaw: failed });
+            if (removed && !failed && !peerStreams.isReadable) {
+                void this.onPeerDisconnected(peerStreams.peerId).catch(logError);
+            }
+        }
     }
     /**
      * Handles an rpc request from a peer
@@ -1538,10 +1648,31 @@ export class DirectStream extends TypedEventEmitter {
     async processRpc(from, peerStreams, message) {
         // logger.trace("rpc from " + from + ", " + this.peerIdStr);
         if (message.length > 0) {
+            if (this.nativeWire) {
+                // Batch frames arriving within the same tick so decode +
+                // signature verification happen in one native call. The
+                // returned promise still resolves only after this frame's
+                // processMessage turn completes (the TS-path contract).
+                const done = pDefer();
+                this.pendingNativeWireFrames.push({
+                    from,
+                    peerStreams,
+                    bytes: message,
+                    done,
+                });
+                if (!this.nativeWireFlushScheduled) {
+                    this.nativeWireFlushScheduled = true;
+                    queueMicrotask(() => this.flushNativeWireFrames());
+                }
+                await done.promise;
+                return true;
+            }
+            this.wireCounters.tsFrames++;
             let decodedMessage;
             let priority = 0;
             try {
                 decodedMessage = Message.from(message);
+                this.wireCounters.tsEnvelopeDecodes++;
                 priority = decodedMessage.header.priority ?? 0;
             }
             catch {
@@ -1562,7 +1693,115 @@ export class DirectStream extends TypedEventEmitter {
         }
         return true;
     }
-    async modifySeenCache(message, getIdFn = getMsgId) {
+    /**
+     * Drain the frames collected by processRpc() through the native wire
+     * module: one batched decode+verify call, then the usual per-message
+     * pipeline with the TS message object pre-seeded with the native
+     * verification result. Any native failure falls back to the pure TS
+     * path for that frame, so semantics never diverge.
+     */
+    flushNativeWireFrames() {
+        this.nativeWireFlushScheduled = false;
+        const pending = this.pendingNativeWireFrames;
+        if (pending.length === 0) {
+            return;
+        }
+        this.pendingNativeWireFrames = [];
+        let records;
+        if (this.nativeWire) {
+            try {
+                records = this.nativeWire.decodeAndVerifyBatch(pending.map((frame) => frame.bytes.subarray()), Date.now());
+                if (records.length !== pending.length * NATIVE_WIRE_RECORD_WORDS) {
+                    records = undefined;
+                }
+            }
+            catch (error) {
+                logger("Native wire batch decode failed, falling back to TS path: " +
+                    error?.message);
+                records = undefined;
+            }
+        }
+        for (let i = 0; i < pending.length; i++) {
+            const { from, peerStreams, bytes, done } = pending[i];
+            const base = i * NATIVE_WIRE_RECORD_WORDS;
+            const word0 = records ? records[base] : 0;
+            const decodeOk = records != null && (word0 & NATIVE_WIRE_FLAG_DECODE_OK) !== 0;
+            const verifyStatus = (word0 >>> 16) & 0xff;
+            if (decodeOk && verifyStatus !== NATIVE_WIRE_VERIFY_UNSUPPORTED) {
+                this.wireCounters.nativeFrames++;
+            }
+            else {
+                this.wireCounters.nativeFallbackFrames++;
+            }
+            let decodedMessage;
+            let priority = 0;
+            try {
+                decodedMessage = Message.from(bytes);
+                this.wireCounters.tsEnvelopeDecodes++;
+                priority = decodedMessage.header.priority ?? 0;
+            }
+            catch {
+                // Best-effort peek, same as the TS path: processMessage()
+                // performs the authoritative decode and logs invalid frames.
+            }
+            if (decodedMessage &&
+                decodeOk &&
+                verifyStatus !== NATIVE_WIRE_VERIFY_UNSUPPORTED) {
+                // Seed the memoized verification result; verify(true) in the
+                // dispatch path (verifyAndProcess) short-circuits on it.
+                decodedMessage._verified =
+                    verifyStatus === NATIVE_WIRE_VERIFY_VERIFIED;
+            }
+            this.queue
+                .add(async () => {
+                try {
+                    await this.processMessage(from, peerStreams, bytes, decodedMessage);
+                }
+                catch (err) {
+                    logger.error(err);
+                }
+            }, { priority })
+                .catch(logError)
+                .finally(() => done.resolve());
+        }
+    }
+    /**
+     * Native decode+verify for an envelope frame that arrived outside the
+     * inbound stream path (e.g. nested inside another protocol's payload).
+     * Seeds the memoized verification result so `verify(true)`
+     * short-circuits; on any native failure the TS verification path stays
+     * authoritative.
+     */
+    seedNativeWireVerification(message, frame) {
+        if (!this.nativeWire || message._verified != null) {
+            return;
+        }
+        try {
+            const records = this.nativeWire.decodeAndVerifyBatch([frame instanceof Uint8Array ? frame : frame.subarray()], Date.now());
+            if (records.length !== NATIVE_WIRE_RECORD_WORDS) {
+                return;
+            }
+            const word0 = records[0];
+            if ((word0 & NATIVE_WIRE_FLAG_DECODE_OK) === 0) {
+                this.wireCounters.nativeFallbackFrames++;
+                return;
+            }
+            const verifyStatus = (word0 >>> 16) & 0xff;
+            if (verifyStatus === NATIVE_WIRE_VERIFY_UNSUPPORTED) {
+                this.wireCounters.nativeFallbackFrames++;
+                return;
+            }
+            this.wireCounters.nativeFrames++;
+            message._verified = verifyStatus === NATIVE_WIRE_VERIFY_VERIFIED;
+        }
+        catch {
+            // TS verification stays authoritative
+        }
+    }
+    async modifySeenCache(message, getIdFn = getMsgId, seenKeyKind = 0) {
+        if (this.rustSeenCache) {
+            return this.rustSeenCache.modify(message instanceof Uint8Array ? message : message.subarray(), seenKeyKind);
+        }
         const msgId = await getIdFn(message);
         const seen = this.seenCache.get(msgId);
         this.seenCache.add(msgId, seen ? seen + 1 : 1);
@@ -1578,7 +1817,10 @@ export class DirectStream extends TypedEventEmitter {
         // Ensure the message is valid before processing it
         let message = decodedMessage;
         try {
-            message ??= Message.from(msg);
+            if (message == null) {
+                message = Message.from(msg);
+                this.wireCounters.tsEnvelopeDecodes++;
+            }
         }
         catch (error) {
             warn(error, "Failed to decode message frame from", from.hashcode());
@@ -1608,6 +1850,17 @@ export class DirectStream extends TypedEventEmitter {
         }
     }
     shouldIgnore(message, seenBefore) {
+        if (this.rustCore) {
+            const mode = message.header.mode;
+            return this.rustCore.decisions.shouldIgnoreData({
+                seenBefore,
+                acknowledgedMode: isAcknowledgedDeliveryMode(mode),
+                redundancy: isAcknowledgedDeliveryMode(mode) ? mode.redundancy : 0,
+                hops: getDeliveryHopTrace(mode),
+                me: this.publicKeyHash,
+                signedBySelf: message.header.signatures?.publicKeys.some((x) => x.equals(this.publicKey)) ?? false,
+            });
+        }
         if (isAcknowledgedDeliveryMode(message.header.mode)) {
             if (hasDeliveryHop(message.header.mode, this.publicKeyHash)) {
                 return true;
@@ -1670,6 +1923,9 @@ export class DirectStream extends TypedEventEmitter {
         }
     }
     async verifyAndProcess(message) {
+        if (message._verified == null) {
+            this.wireCounters.tsSignatureVerifies++;
+        }
         const verified = await message.verify(true);
         if (!verified) {
             return false;
@@ -1689,11 +1945,18 @@ export class DirectStream extends TypedEventEmitter {
             const isRecipient = message.header.mode instanceof AcknowledgeAnyWhere
                 ? true
                 : message.header.mode.to.includes(this.publicKeyHash);
-            if (!shouldAcknowledgeDataMessage({
-                isRecipient,
-                seenBefore,
-                redundancy: message.header.mode.redundancy,
-            })) {
+            const shouldAcknowledge = this.rustCore
+                ? this.rustCore.decisions.shouldAcknowledge({
+                    isRecipient,
+                    seenBefore,
+                    redundancy: message.header.mode.redundancy,
+                })
+                : shouldAcknowledgeDataMessage({
+                    isRecipient,
+                    seenBefore,
+                    redundancy: message.header.mode.redundancy,
+                });
+            if (!shouldAcknowledge) {
                 return;
             }
             const signers = [...getDeliveryHopTrace(message.header.mode)];
@@ -1728,7 +1991,7 @@ export class DirectStream extends TypedEventEmitter {
     async onAck(publicKey, peerStream, messageBytes, message) {
         const seenBefore = await this.modifySeenCache(messageBytes instanceof Uint8Array
             ? messageBytes
-            : messageBytes.subarray(), (bytes) => sha256Base64(bytes instanceof Uint8Array ? bytes : bytes.subarray()));
+            : messageBytes.subarray(), (bytes) => sha256Base64(bytes instanceof Uint8Array ? bytes : bytes.subarray()), 1);
         if (seenBefore > 0) {
             logger.trace("Received message already seen of type: " + message.constructor.name);
             return false;
@@ -1738,8 +2001,17 @@ export class DirectStream extends TypedEventEmitter {
             return false;
         }
         const messageIdString = toBase64(message.messageIdToAcknowledge);
-        const myIndex = message.header.mode.trace.findIndex((x) => x === this.publicKeyHash);
-        const next = message.header.mode.trace[myIndex - 1];
+        let myIndex;
+        let next;
+        if (this.rustCore) {
+            const hop = this.rustCore.decisions.ackNextHop(message.header.mode.trace, this.publicKeyHash);
+            myIndex = hop.myIndex;
+            next = hop.next;
+        }
+        else {
+            myIndex = message.header.mode.trace.findIndex((x) => x === this.publicKeyHash);
+            next = message.header.mode.trace[myIndex - 1];
+        }
         const nextStream = next ? this.peers.get(next) : undefined;
         this._ackCallbacks
             .get(messageIdString)
@@ -2141,15 +2413,25 @@ export class DirectStream extends TypedEventEmitter {
                 if (message.header.mode instanceof AcknowledgeDelivery ||
                     message.header.mode instanceof AcknowledgeAnyWhere) {
                     const upstreamHash = messageFrom?.publicKey.hashcode();
-                    const routeUpdate = computeSeekAckRouteUpdate({
-                        current: this.publicKeyHash,
-                        upstream: upstreamHash,
-                        downstream: messageThrough.publicKey.hashcode(),
-                        target: messageTargetHash,
-                        // Route "distance" is based on recipient-seen order (0 = fastest). This is relied upon by
-                        // `Routes.getFanout(...)` which uses `distance < redundancy` to select redundant next-hops.
-                        distance: seenCounter,
-                    });
+                    // Route "distance" is based on recipient-seen order (0 = fastest). This is relied upon by
+                    // `Routes.getFanout(...)` which uses `distance < redundancy` to select redundant next-hops.
+                    const routeUpdate = this.rustCore
+                        ? {
+                            ...this.rustCore.decisions.seekAckRouteUpdate({
+                                current: this.publicKeyHash,
+                                upstream: upstreamHash,
+                                downstream: messageThrough.publicKey.hashcode(),
+                            }),
+                            target: messageTargetHash,
+                            distance: seenCounter,
+                        }
+                        : computeSeekAckRouteUpdate({
+                            current: this.publicKeyHash,
+                            upstream: upstreamHash,
+                            downstream: messageThrough.publicKey.hashcode(),
+                            target: messageTargetHash,
+                            distance: seenCounter,
+                        });
                     this.addRouteConnection(routeUpdate.from, routeUpdate.neighbour, messageTarget, routeUpdate.distance, session, Number(ack.header.session));
                 }
                 if (messageToSet.has(messageTargetHash)) {
@@ -2251,14 +2533,26 @@ export class DirectStream extends TypedEventEmitter {
                         if (!isRelayed &&
                             message.header.mode instanceof AcknowledgeDelivery &&
                             usedNeighbours.size < message.header.mode.redundancy) {
-                            for (const [neighbour, stream] of this.peers) {
-                                if (usedNeighbours.size >= message.header.mode.redundancy) {
-                                    break;
+                            if (this.rustCore) {
+                                const probes = this.rustCore.decisions.selectRedundancyProbes([...this.peers.keys()], [...usedNeighbours], message.header.mode.redundancy);
+                                for (const neighbour of probes) {
+                                    const stream = this.peers.get(neighbour);
+                                    if (!stream)
+                                        continue;
+                                    usedNeighbours.add(neighbour);
+                                    promises.push(this.waitForPeerWrite(stream, bytes, message.header.priority, signal));
+                                }
+                            }
+                            else {
+                                for (const [neighbour, stream] of this.peers) {
+                                    if (usedNeighbours.size >= message.header.mode.redundancy) {
+                                        break;
+                                    }
+                                    if (usedNeighbours.has(neighbour))
+                                        continue;
+                                    usedNeighbours.add(neighbour);
+                                    promises.push(this.waitForPeerWrite(stream, bytes, message.header.priority, signal));
                                 }
-                                if (usedNeighbours.has(neighbour))
-                                    continue;
-                                usedNeighbours.add(neighbour);
-                                promises.push(this.waitForPeerWrite(stream, bytes, message.header.priority, signal));
                             }
                         }
                         await Promise.all(promises);
@@ -2272,17 +2566,22 @@ export class DirectStream extends TypedEventEmitter {
                     if (isRelayed && message.header.mode instanceof SilentDelivery) {
                         const promises = [];
                         const originalTo = message.header.mode.to;
-                        for (const recipient of originalTo) {
-                            if (recipient === this.publicKeyHash)
-                                continue;
-                            if (recipient === from.hashcode())
-                                continue; // never send back to previous hop
+                        const recipients = this.rustCore
+                            ? this.rustCore.decisions.filterSilentRelayRecipients(originalTo, this.publicKeyHash, from.hashcode(), [...this.peers.keys()], getDeliveryHopTrace(message.header.mode))
+                            : undefined;
+                        for (const recipient of recipients ?? originalTo) {
+                            if (!recipients) {
+                                if (recipient === this.publicKeyHash)
+                                    continue;
+                                if (recipient === from.hashcode())
+                                    continue; // never send back to previous hop
+                                if (hasDeliveryHop(message.header.mode, recipient)) {
+                                    continue; // recipient already signed/seen this message
+                                }
+                            }
                             const stream = this.peers.get(recipient);
                             if (!stream)
                                 continue;
-                            if (hasDeliveryHop(message.header.mode, recipient)) {
-                                continue; // recipient already signed/seen this message
-                            }
                             message.header.mode.to = [recipient];
                             promises.push(this.waitForPeerWrite(stream, message.bytes(), message.header.priority, signal));
                         }
@@ -2306,19 +2605,29 @@ export class DirectStream extends TypedEventEmitter {
             }
             let sentOnce = false;
             const promises = [];
-            for (const stream of peers.values()) {
-                const id = stream;
-                // Dont sent back to the sender
-                if (id.publicKey.equals(from)) {
-                    continue;
+            if (this.rustCore) {
+                const candidates = [...peers.values()];
+                const kept = this.rustCore.decisions.filterFloodTargets(candidates.map((stream) => stream.publicKey.hashcode()), from.hashcode(), message.header.signatures?.publicKeys.map((x) => x.hashcode()) ?? [], getDeliveryHopTrace(message.header.mode));
+                for (const index of kept) {
+                    sentOnce = true;
+                    promises.push(this.waitForPeerWrite(candidates[index], bytes, message.header.priority, signal));
                 }
-                // Dont send message back to any peer already present in the path.
-                if (message.header.signatures?.publicKeys.find((x) => x.equals(id.publicKey)) ||
-                    hasDeliveryHop(message.header.mode, id.publicKey.hashcode())) {
-                    continue;
+            }
+            else {
+                for (const stream of peers.values()) {
+                    const id = stream;
+                    // Dont sent back to the sender
+                    if (id.publicKey.equals(from)) {
+                        continue;
+                    }
+                    // Dont send message back to any peer already present in the path.
+                    if (message.header.signatures?.publicKeys.find((x) => x.equals(id.publicKey)) ||
+                        hasDeliveryHop(message.header.mode, id.publicKey.hashcode())) {
+                        continue;
+                    }
+                    sentOnce = true;
+                    promises.push(this.waitForPeerWrite(id, bytes, message.header.priority, signal));
                 }
-                sentOnce = true;
-                promises.push(this.waitForPeerWrite(id, bytes, message.header.priority, signal));
             }
             await Promise.all(promises);
             startDeliveryTimeout?.();