@peerbit/shared-log 4.0.6 → 4.0.8

package/lib/esm/index.js

@@ -14,7 +14,7 @@ import { Program } from "@peerbit/program";
 import { BinaryWriter, BorshError, field, variant } from "@dao-xyz/borsh";
 import { AccessError, sha256, sha256Base64Sync } from "@peerbit/crypto";
 import { logger as loggerFn } from "@peerbit/logger";
-import { ExchangeHeadsMessage, RequestIHave, ResponseIHave, createExchangeHeadsMessage } from "./exchange-heads.js";
+import { ExchangeHeadsMessage, RequestIPrune, ResponseIPrune, createExchangeHeadsMessage } from "./exchange-heads.js";
 import { AbortError, waitFor } from "@peerbit/time";
 import { Observer, Replicator, Role } from "./role.js";
 import { AbsoluteReplicas, ReplicationError, RequestRoleMessage, ResponseRoleMessage, decodeReplicas, encodeReplicas, hashToUniformNumber, maxReplicas } from "./replication.js";
@@ -22,12 +22,13 @@ import pDefer from "p-defer";
 import { Cache } from "@peerbit/cache";
 import { CustomEvent } from "@libp2p/interface";
 import yallist from "yallist";
-import { AcknowledgeDelivery, SilentDelivery } from "@peerbit/stream-interface";
+import { AcknowledgeDelivery, SeekDelivery, SilentDelivery } from "@peerbit/stream-interface";
 import { AnyBlockStore, RemoteBlocks } from "@peerbit/blocks";
 import { BlocksMessage } from "./blocks.js";
 import debounce from "p-debounce";
 import { PIDReplicationController } from "./pid.js";
 export * from "./replication.js";
+import PQueue from "p-queue";
 export { Observer, Replicator, Role };
 export const logger = loggerFn({ module: "shared-log" });
 const groupByGid = async (entries) => {
@@ -56,7 +57,7 @@ const isAdaptiveReplicatorOption = (options) => {
 export const DEFAULT_MIN_REPLICAS = 2;
 export const WAIT_FOR_REPLICATOR_TIMEOUT = 9000;
 export const WAIT_FOR_ROLE_MATURITY = 5000;
-const REBALANCE_DEBOUNCE_INTERAVAL = 50;
+const REBALANCE_DEBOUNCE_INTERAVAL = 30;
 let SharedLog = class SharedLog extends Program {
     log;
     rpc;
@@ -92,6 +93,10 @@ let SharedLog = class SharedLog extends Program {
     get totalParticipation() {
         return this._totalParticipation;
     }
+    setupRebalanceDebounceFunction() {
+        this.rebalanceParticipationDebounced = debounce(() => this.rebalanceParticipation(), Math.max(REBALANCE_DEBOUNCE_INTERAVAL, (this.getReplicatorsSorted()?.length || 0) *
+            REBALANCE_DEBOUNCE_INTERAVAL));
+    }
     setupRole(options) {
         this.rebalanceParticipationDebounced = undefined;
         const setupDebouncedRebalancing = (options) => {
@@ -99,8 +104,7 @@ let SharedLog = class SharedLog extends Program {
                 targetMemoryLimit: options?.limits?.memory,
                 errorFunction: options?.error
             });
-            this.rebalanceParticipationDebounced = debounce(() => this.rebalanceParticipation(), REBALANCE_DEBOUNCE_INTERAVAL // TODO make dynamic
-            );
+            this.setupRebalanceDebounceFunction();
         };
         if (options instanceof Observer || options instanceof Replicator) {
             throw new Error("Unsupported role option type");
@@ -134,14 +138,20 @@ let SharedLog = class SharedLog extends Program {
         // setup the initial role
         if (this._roleOptions instanceof Replicator ||
             this._roleOptions instanceof Observer) {
-            this._role = this._roleOptions; // Fixed
+            this._role = this._roleOptions;
         }
         else {
-            this._role = new Replicator({
-                // initial role in a dynamic setup
-                factor: 1,
-                timestamp: BigInt(+new Date())
-            });
+            if (this._roleOptions.limits) {
+                this._role = new Replicator({
+                    // initial role in a dynamic setup
+                    factor: 1
+                });
+            }
+            else {
+                this._role = new Replicator({
+                    factor: 1
+                });
+            }
         }
         return this._role;
     }
@@ -156,9 +166,13 @@ let SharedLog = class SharedLog extends Program {
             this._loadedOnce = true;
         }
         await this.rpc.subscribe();
-        await this.rpc.send(new ResponseRoleMessage(role));
-        if (onRoleChange && changed) {
-            this.onRoleChange(undefined, this._role, this.node.identity.publicKey);
+        await this.rpc.send(new ResponseRoleMessage({ role: this._role }), {
+            mode: new SeekDelivery({
+                redundancy: 1
+            })
+        });
+        if (onRoleChange && changed !== "none") {
+            this.onRoleChange(this._role, this.node.identity.publicKey);
         }
         return changed;
     }
@@ -217,7 +231,9 @@ let SharedLog = class SharedLog extends Program {
         this.remoteBlocks = new RemoteBlocks({
             local: localBlocks,
             publish: (message, options) => this.rpc.send(new BlocksMessage(message), {
-                to: options?.to
+                mode: options?.to
+                    ? new SilentDelivery({ to: options.to, redundancy: 1 })
+                    : undefined
             }),
             waitFor: this.rpc.waitFor.bind(this.rpc)
         });
@@ -370,6 +386,7 @@ let SharedLog = class SharedLog extends Program {
                     let maybeDelete = undefined;
                     const groupedByGid = await groupByGid(filteredHeads);
                     const promises = [];
+                    /// console.log("ADD CACHE", this.node.identity.publicKey.hashcode(), context.from!.hashcode(), groupedByGid.size)
                     for (const [gid, entries] of groupedByGid) {
                         const fn = async () => {
                             const headsWithGid = this.log.headsIndex.gids.get(gid);
@@ -377,9 +394,20 @@ let SharedLog = class SharedLog extends Program {
                                 ? maxReplicas(this, [...headsWithGid.values()])
                                 : this.replicas.min.getValue(this);
                             const maxReplicasFromNewEntries = maxReplicas(this, entries.map((x) => x.entry));
-                            const isLeader = await this.waitForIsLeader(gid, Math.max(maxReplicasFromHead, maxReplicasFromNewEntries));
-                            if (maxReplicasFromNewEntries < maxReplicasFromHead && isLeader) {
-                                (maybeDelete || (maybeDelete = [])).push(entries);
+                            const leaders = await this.waitForIsLeader(gid, Math.max(maxReplicasFromHead, maxReplicasFromNewEntries));
+                            const isLeader = !!leaders;
+                            if (isLeader) {
+                                if (leaders.find((x) => x === context.from.hashcode())) {
+                                    let peerSet = this._gidPeersHistory.get(gid);
+                                    if (!peerSet) {
+                                        peerSet = new Set();
+                                        this._gidPeersHistory.set(gid, peerSet);
+                                    }
+                                    peerSet.add(context.from.hashcode());
+                                }
+                                if (maxReplicasFromNewEntries < maxReplicasFromHead) {
+                                    (maybeDelete || (maybeDelete = [])).push(entries);
+                                }
                             }
                             outer: for (const entry of entries) {
                                 if (isLeader) {
@@ -407,8 +435,8 @@ let SharedLog = class SharedLog extends Program {
                     if (toMerge.length > 0) {
                         await this.log.join(toMerge);
                         toDelete &&
-                            this.prune(toDelete).catch((e) => {
-                                logger.error(e.toString());
+                            Promise.all(this.prune(toDelete)).catch((e) => {
+                                logger.info(e.toString());
                             });
                         this.rebalanceParticipationDebounced?.();
                     }
@@ -419,8 +447,8 @@ let SharedLog = class SharedLog extends Program {
                                 const minReplicas = maxReplicas(this, headsWithGid.values());
                                 const isLeader = await this.isLeader(entries[0].entry.meta.gid, minReplicas);
                                 if (!isLeader) {
-                                    this.prune(entries.map((x) => x.entry)).catch((e) => {
-                                        logger.error(e.toString());
+                                    Promise.all(this.prune(entries.map((x) => x.entry))).catch((e) => {
+                                        logger.info(e.toString());
                                     });
                                 }
                             }
@@ -428,12 +456,15 @@ let SharedLog = class SharedLog extends Program {
                     }
                 }
             }
-            else if (msg instanceof RequestIHave) {
+            else if (msg instanceof RequestIPrune) {
                 const hasAndIsLeader = [];
                 for (const hash of msg.hashes) {
                     const indexedEntry = this.log.entryIndex.getShallow(hash);
                     if (indexedEntry &&
                         (await this.isLeader(indexedEntry.meta.gid, decodeReplicas(indexedEntry).getValue(this)))) {
+                        this._gidPeersHistory
+                            .get(indexedEntry.meta.gid)
+                            ?.delete(context.from.hashcode());
                         hasAndIsLeader.push(hash);
                     }
                     else {
@@ -445,8 +476,14 @@ let SharedLog = class SharedLog extends Program {
                             },
                             callback: async (entry) => {
                                 if (await this.isLeader(entry.meta.gid, decodeReplicas(entry).getValue(this))) {
-                                    this.rpc.send(new ResponseIHave({ hashes: [entry.hash] }), {
-                                        to: [context.from]
+                                    this._gidPeersHistory
+                                        .get(entry.meta.gid)
+                                        ?.delete(context.from.hashcode());
+                                    this.rpc.send(new ResponseIPrune({ hashes: [entry.hash] }), {
+                                        mode: new SilentDelivery({
+                                            to: [context.from],
+                                            redundancy: 1
+                                        })
                                     });
                                 }
                                 prevPendingIHave && prevPendingIHave.callback(entry);
@@ -462,13 +499,13 @@ let SharedLog = class SharedLog extends Program {
                         this._pendingIHave.set(hash, pendingIHave);
                     }
                 }
-                await this.rpc.send(new ResponseIHave({ hashes: hasAndIsLeader }), {
-                    to: [context.from]
+                await this.rpc.send(new ResponseIPrune({ hashes: hasAndIsLeader }), {
+                    mode: new SilentDelivery({ to: [context.from], redundancy: 1 })
                 });
             }
-            else if (msg instanceof ResponseIHave) {
+            else if (msg instanceof ResponseIPrune) {
                 for (const hash of msg.hashes) {
-                    this._pendingDeletes.get(hash)?.callback(context.from.hashcode());
+                    this._pendingDeletes.get(hash)?.resolve(context.from.hashcode());
                 }
             }
             else if (msg instanceof BlocksMessage) {
@@ -482,7 +519,7 @@ let SharedLog = class SharedLog extends Program {
                     return;
                 }
                 await this.rpc.send(new ResponseRoleMessage({ role: this.role }), {
-                    to: [context.from]
+                    mode: new SilentDelivery({ to: [context.from], redundancy: 1 })
                 });
             }
             else if (msg instanceof ResponseRoleMessage) {
@@ -566,11 +603,12 @@ let SharedLog = class SharedLog extends Program {
                 removeListeners();
                 res(false);
             }, timeout);
-            const check = () => this.isLeader(slot, numberOfLeaders).then((isLeader) => {
+            const check = () => this.findLeaders(slot, numberOfLeaders).then((leaders) => {
+                const isLeader = leaders.find((l) => l === this.node.identity.publicKey.hashcode());
                 if (isLeader) {
                     removeListeners();
                     clearTimeout(timer);
-                    res(isLeader);
+                    res(leaders);
                 }
             });
             const roleListener = () => {
@@ -593,6 +631,53 @@ let SharedLog = class SharedLog extends Program {
         const cursor = hashToUniformNumber(seed); // bounded between 0 and 1
         return this.findLeadersFromUniformNumber(cursor, numberOfLeaders, options);
     }
+    collectNodesAroundPoint(time, roleAge, peers, currentNode, width, collector, point, done = () => false, onMatured = () => { }) {
+        let matured = 0;
+        const maybeIncrementMatured = (role) => {
+            if (time - Number(role.timestamp) > roleAge) {
+                matured++;
+                return true;
+            }
+            return false;
+        };
+        // Assume peers does not mutate during this loop
+        const startNode = currentNode;
+        const diffs = [];
+        while (currentNode && !done()) {
+            const start = currentNode.value.offset % width;
+            const absDelta = Math.abs(start - point());
+            const diff = Math.min(absDelta, width - absDelta);
+            if (diff < currentNode.value.role.factor / 2 + 0.00001) {
+                collector.add(currentNode.value.publicKey.hashcode());
+                if (maybeIncrementMatured(currentNode.value.role)) {
+                    onMatured(currentNode.value);
+                }
+            }
+            else {
+                diffs.push({
+                    diff: currentNode.value.role.factor > 0
+                        ? diff / currentNode.value.role.factor
+                        : Number.MAX_SAFE_INTEGER,
+                    rect: currentNode.value
+                });
+            }
+            currentNode = currentNode.next || peers.head;
+            if (currentNode?.value.publicKey &&
+                startNode?.value.publicKey.equals(currentNode?.value.publicKey)) {
+                break; // TODO throw error for failing to fetch ffull width
+            }
+        }
+        if (matured === 0) {
+            diffs.sort((x, y) => x.diff - y.diff);
+            for (const node of diffs) {
+                collector.add(node.rect.publicKey.hashcode());
+                maybeIncrementMatured(node.rect.role);
+                if (matured > 0) {
+                    break;
+                }
+            }
+        }
+    }
     findLeadersFromUniformNumber(cursor, numberOfLeaders, options) {
         const leaders = new Set();
         const width = 1; // this.getParticipationSum(roleAge);
@@ -605,43 +690,9 @@ let SharedLog = class SharedLog extends Program {
         const roleAge = options?.roleAge ??
             Math.min(WAIT_FOR_ROLE_MATURITY, +new Date() - this.openTime);
         for (let i = 0; i < numberOfLeaders; i++) {
-            let matured = 0;
-            const maybeIncrementMatured = (role) => {
-                if (t - Number(role.timestamp) > roleAge) {
-                    matured++;
-                }
-            };
-            const x = ((cursor + i / numberOfLeaders) % 1) * width;
-            let currentNode = peers.head;
-            const diffs = [];
-            while (currentNode) {
-                const start = currentNode.value.offset % width;
-                const absDelta = Math.abs(start - x);
-                const diff = Math.min(absDelta, width - absDelta);
-                if (diff < currentNode.value.role.factor / 2 + 0.00001) {
-                    leaders.add(currentNode.value.publicKey.hashcode());
-                    maybeIncrementMatured(currentNode.value.role);
-                }
-                else {
-                    diffs.push({
-                        diff: currentNode.value.role.factor > 0
-                            ? diff / currentNode.value.role.factor
-                            : Number.MAX_SAFE_INTEGER,
-                        rect: currentNode.value
-                    });
-                }
-                currentNode = currentNode.next;
-            }
-            if (matured === 0) {
-                diffs.sort((x, y) => x.diff - y.diff);
-                for (const node of diffs) {
-                    leaders.add(node.rect.publicKey.hashcode());
-                    maybeIncrementMatured(node.rect.role);
-                    if (matured > 0) {
-                        break;
-                    }
-                }
-            }
+            const point = ((cursor + i / numberOfLeaders) % 1) * width;
+            const currentNode = peers.head;
+            this.collectNodesAroundPoint(t, roleAge, peers, currentNode, width, leaders, () => point);
         }
         return [...leaders];
     }
@@ -655,6 +706,10 @@ let SharedLog = class SharedLog extends Program {
         // How much width you need to "query" to
         const peers = this.getReplicatorsSorted(); // TODO types
         const minReplicas = Math.min(peers.length, this.replicas.min.getValue(this));
+        // If min replicas = 2
+        // then we need to make sure we cover 0.5 of the total 'width' of the replication space
+        // to make sure we reach sufficient amount of nodes such that at least one one has
+        // the entry we are looking for
         const coveringWidth = width / minReplicas;
         let walker = peers.head;
         if (this.role instanceof Replicator) {
@@ -675,7 +730,7 @@ let SharedLog = class SharedLog extends Program {
                 walker = walker.next;
             }
         }
-        const set = [];
+        const set = new Set();
         let distance = 0;
         const startNode = walker;
         if (!startNode) {
@@ -683,30 +738,16 @@ let SharedLog = class SharedLog extends Program {
         }
         let nextPoint = startNode.value.offset;
         const t = +new Date();
-        while (walker && distance < coveringWidth) {
-            const absDelta = Math.abs(walker.value.offset - nextPoint);
-            const diff = Math.min(absDelta, width - absDelta);
-            if (diff < walker.value.role.factor / 2 + 0.00001) {
-                set.push(walker.value.publicKey.hashcode());
-                if (t - Number(walker.value.role.timestamp) >
-                    roleAge /* ||
-                walker!.value.publicKey.equals(this.node.identity.publicKey)) */) {
-                    nextPoint = (nextPoint + walker.value.role.factor) % 1;
-                    distance += walker.value.role.factor;
-                }
-            }
-            walker = walker.next || peers.head;
-            if (walker?.value.publicKey &&
-                startNode?.value.publicKey.equals(walker?.value.publicKey)) {
-                break; // TODO throw error for failing to fetch ffull width
-            }
-        }
-        return set;
+        this.collectNodesAroundPoint(t, roleAge, peers, walker, width, set, () => nextPoint, () => distance >= coveringWidth, (node) => {
+            distance += node.role.factor;
+            nextPoint = (nextPoint + walker.value.role.factor) % width;
+        });
+        return [...set];
     }
     async replicator(entry, options) {
         return this.isLeader(entry.gid, decodeReplicas(entry).getValue(this), options);
     }
-    onRoleChange(prev, role, publicKey) {
+    onRoleChange(role, publicKey) {
         if (this.closed) {
             return;
         }
@@ -727,10 +768,23 @@ let SharedLog = class SharedLog extends Program {
         }));
     }
     async modifyReplicators(role, publicKey) {
-        const { prev, changed } = await this._modifyReplicators(role, publicKey);
-        if (changed) {
-            await this.rebalanceParticipationDebounced?.(); // await this.rebalanceParticipation(false);
-            this.onRoleChange(prev, role, publicKey);
+        const update = await this._modifyReplicators(role, publicKey);
+        if (update.changed !== "none") {
+            if (update.changed === "added" || update.changed === "removed") {
+                this.setupRebalanceDebounceFunction();
+            }
+            if (this.rebalanceParticipationDebounced) {
+                await this.rebalanceParticipationDebounced?.(); /* await this.rebalanceParticipation(false); */
+            }
+            if (update.changed === "added") {
+                await this.rpc.send(new ResponseRoleMessage({ role: this._role }), {
+                    mode: new SeekDelivery({
+                        to: [publicKey.hashcode()],
+                        redundancy: 1
+                    })
+                });
+            }
+            this.onRoleChange(role, publicKey);
             return true;
         }
         return false;
@@ -739,14 +793,14 @@ let SharedLog = class SharedLog extends Program {
         if (role instanceof Replicator &&
             this._canReplicate &&
             !(await this._canReplicate(publicKey, role))) {
-            return { changed: false };
+            return { changed: "none" };
         }
         const sortedPeer = this._sortedPeersCache;
         if (!sortedPeer) {
             if (this.closed === false) {
                 throw new Error("Unexpected, sortedPeersCache is undefined");
             }
-            return { changed: false };
+            return { changed: "none" };
         }
         if (role instanceof Replicator && role.factor > 0) {
             // TODO use Set + list for fast lookup
@@ -767,7 +821,7 @@ let SharedLog = class SharedLog extends Program {
                 if (!currentNode) {
                     sortedPeer.push(rect);
                     this._totalParticipation += rect.role.factor;
-                    return { changed: true };
+                    return { changed: "added" };
                 }
                 else {
                     while (currentNode) {
@@ -779,7 +833,7 @@ let SharedLog = class SharedLog extends Program {
                             this._totalParticipation += rect.role.factor;
                             this._totalParticipation -= prev.role.factor;
                             // TODO change detection and only do change stuff if diff?
-                            return { prev: prev.role, changed: true };
+                            return { prev: prev.role, changed: "updated" };
                         }
                         if (code > currentNode.value.offset) {
                             const next = currentNode?.next;
@@ -804,11 +858,11 @@ let SharedLog = class SharedLog extends Program {
                     else {
                         throw new Error("Unexpected");
                     }
-                    return { changed: true };
+                    return { changed: "added" };
                 }
             }
             else {
-                return { changed: false };
+                return { changed: "none" };
             }
         }
         else {
@@ -817,11 +871,11 @@ let SharedLog = class SharedLog extends Program {
                 if (currentNode.value.publicKey.equals(publicKey)) {
                     sortedPeer.removeNode(currentNode);
                     this._totalParticipation -= currentNode.value.role.factor;
-                    return { prev: currentNode.value.role, changed: true };
+                    return { prev: currentNode.value.role, changed: "removed" };
                 }
                 currentNode = currentNode.next;
             }
-            return { changed: false };
+            return { changed: "none" };
         }
     }
     async handleSubscriptionChange(publicKey, changes, subscribed) {
@@ -832,8 +886,8 @@ let SharedLog = class SharedLog extends Program {
                         continue;
                     }
                     this.rpc
-                        .send(new ResponseRoleMessage(this.role), {
-                        mode: new AcknowledgeDelivery({ redundancy: 1, to: [publicKey] })
+                        .send(new ResponseRoleMessage({ role: this._role }), {
+                        mode: new SeekDelivery({ redundancy: 1, to: [publicKey] })
                     })
                         .catch((e) => logger.error(e.toString()));
                 }
@@ -849,11 +903,14 @@ let SharedLog = class SharedLog extends Program {
             }
         }
     }
-    async prune(entries, options) {
+    prune(entries, options) {
         if (options?.unchecked) {
-            return Promise.all(entries.map((x) => this.log.remove(x, {
-                recursively: true
-            })));
+            return entries.map((x) => {
+                this._gidPeersHistory.delete(x.meta.gid);
+                return this.log.remove(x, {
+                    recursively: true
+                });
+            });
         }
         // ask network if they have they entry,
         // so I can delete it
@@ -897,7 +954,8 @@ let SharedLog = class SharedLog extends Program {
                 clear: () => {
                     clear();
                 },
-                callback: async (publicKeyHash) => {
+                reject,
+                resolve: async (publicKeyHash) => {
                     const minReplicasValue = minReplicas.getValue(this);
                     const minMinReplicasValue = this.replicas.max
                         ? Math.min(minReplicasValue, this.replicas.max.getValue(this))
@@ -910,6 +968,7 @@ let SharedLog = class SharedLog extends Program {
                     if (leaders.find((x) => x === publicKeyHash)) {
                         existCounter.add(publicKeyHash);
                         if (minMinReplicasValue <= existCounter.size) {
+                            this._gidPeersHistory.delete(entry.meta.gid);
                             this.log
                                 .remove(entry, {
                                 recursively: true
@@ -927,21 +986,32 @@ let SharedLog = class SharedLog extends Program {
             promises.push(deferredPromise.promise);
         }
         if (filteredEntries.length == 0) {
-            return;
+            return [];
         }
-        this.rpc.send(new RequestIHave({ hashes: filteredEntries.map((x) => x.hash) }));
+        this.rpc.send(new RequestIPrune({ hashes: filteredEntries.map((x) => x.hash) }));
         const onNewPeer = async (e) => {
             if (e.detail.role instanceof Replicator) {
-                await this.rpc.send(new RequestIHave({ hashes: filteredEntries.map((x) => x.hash) }), {
-                    to: [e.detail.publicKey.hashcode()]
+                await this.rpc.send(new RequestIPrune({ hashes: filteredEntries.map((x) => x.hash) }), {
+                    mode: new SilentDelivery({
+                        to: [e.detail.publicKey.hashcode()],
+                        redundancy: 1
+                    })
                 });
             }
         };
         // check joining peers
         this.events.addEventListener("role", onNewPeer);
-        return Promise.all(promises).finally(() => this.events.removeEventListener("role", onNewPeer));
+        Promise.allSettled(promises).finally(() => this.events.removeEventListener("role", onNewPeer));
+        return promises;
     }
+    _queue;
     async distribute() {
+        if (this._queue?.size > 0) {
+            return;
+        }
+        (this._queue || (this._queue = new PQueue({ concurrency: 1 }))).add(() => this._distribute());
+    }
+    async _distribute() {
         /**
          * TODO use information of new joined/leaving peer to create a subset of heads
          * that we potentially need to share with other peers
@@ -953,7 +1023,7 @@ let SharedLog = class SharedLog extends Program {
         await this.log.trim();
         const heads = await this.log.getHeads();
         const groupedByGid = await groupByGid(heads);
-        const toDeliver = new Map();
+        const uncheckedDeliver = new Map();
         const allEntriesToDelete = [];
         for (const [gid, entries] of groupedByGid) {
             if (this.closed) {
@@ -965,6 +1035,7 @@ let SharedLog = class SharedLog extends Program {
             const oldPeersSet = this._gidPeersHistory.get(gid);
             const currentPeers = await this.findLeaders(gid, maxReplicas(this, entries) // pick max replication policy of all entries, so all information is treated equally important as the most important
             );
+            const isLeader = currentPeers.find((x) => x === this.node.identity.publicKey.hashcode());
             const currentPeersSet = new Set(currentPeers);
             this._gidPeersHistory.set(gid, currentPeersSet);
             for (const currentPeer of currentPeers) {
@@ -973,24 +1044,23 @@ let SharedLog = class SharedLog extends Program {
                 }
                 if (!oldPeersSet?.has(currentPeer)) {
                     // second condition means that if the new peer is us, we should not do anything, since we are expecting to receive heads, not send
-                    let arr = toDeliver.get(currentPeer);
+                    let arr = uncheckedDeliver.get(currentPeer);
                     if (!arr) {
                         arr = [];
-                        toDeliver.set(currentPeer, arr);
+                        uncheckedDeliver.set(currentPeer, arr);
                     }
                     for (const entry of entries) {
                         arr.push(entry);
                     }
                 }
             }
-            if (!currentPeers.find((x) => x === this.node.identity.publicKey.hashcode())) {
+            if (!isLeader) {
                 if (currentPeers.length > 0) {
                     // If we are observer, never prune locally created entries, since we dont really know who can store them
                     // if we are replicator, we will always persist entries that we need to so filtering on createdLocally will not make a difference
                     const entriesToDelete = this._role instanceof Observer
                         ? entries.filter((e) => !e.createdLocally)
                         : entries;
-                    entriesToDelete.map((x) => this._gidPeersHistory.delete(x.meta.gid));
                     allEntriesToDelete.push(...entriesToDelete);
                 }
             }
@@ -998,23 +1068,21 @@ let SharedLog = class SharedLog extends Program {
                 for (const entry of entries) {
                     this._pendingDeletes
                         .get(entry.hash)
-                        ?.promise.reject(new Error("Failed to delete, is leader: " +
-                        this.role.constructor.name +
-                        ". " +
-                        this.node.identity.publicKey.hashcode()));
+                        ?.reject(new Error("Failed to delete, is leader again"));
                 }
             }
         }
-        for (const [target, entries] of toDeliver) {
-            const message = await createExchangeHeadsMessage(this.log, entries, // TODO send to peers directly
-            this._gidParentCache);
-            // TODO perhaps send less messages to more receivers for performance reasons?
-            await this.rpc.send(message, {
-                to: [target]
-            });
+        for (const [target, entries] of uncheckedDeliver) {
+            for (let i = 0; i < entries.length; i += 100) {
+                const message = await createExchangeHeadsMessage(this.log, entries.slice(i, i + 100), this._gidParentCache);
+                // TODO perhaps send less messages to more receivers for performance reasons?
+                await this.rpc.send(message, {
+                    mode: new SilentDelivery({ to: [target], redundancy: 1 })
+                });
+            }
         }
         if (allEntriesToDelete.length > 0) {
-            this.prune(allEntriesToDelete).catch((e) => {
+            Promise.allSettled(this.prune(allEntriesToDelete)).catch((e) => {
                 logger.error(e.toString());
             });
         }