@peerbit/shared-log 11.4.3 → 11.5.1-0fddff8

package/package.json

@@ -1,72 +1,72 @@
 {
-	"name": "@peerbit/shared-log",
-	"version": "11.4.3",
-	"description": "Shared log",
-	"sideEffects": false,
-	"type": "module",
-	"types": "./dist/src/index.d.ts",
-	"typesVersions": {
-		"*": {
-			"*": [
-				"*",
-				"dist/*",
-				"dist/src/*",
-				"dist/src/*/index"
-			],
-			"src/*": [
-				"*",
-				"dist/*",
-				"dist/src/*",
-				"dist/src/*/index"
-			]
-		}
-	},
-	"files": [
-		"src",
-		"dist",
-		"!dist/e2e",
-		"!dist/test",
-		"!**/*.tsbuildinfo"
-	],
-	"exports": {
-		".": {
-			"types": "./dist/src/index.d.ts",
-			"import": "./dist/src/index.js"
-		}
-	},
-	"eslintConfig": {
-		"extends": "peerbit",
-		"parserOptions": {
-			"project": true,
-			"sourceType": "module"
-		},
-		"ignorePatterns": [
-			"!.aegir.js",
-			"test/ts-use",
-			"*.d.ts"
-		]
-	},
-	"publishConfig": {
-		"access": "public"
-	},
-	"scripts": {
-		"clean": "aegir clean",
-		"build": "aegir build --no-bundle",
-		"test": "aegir test --target node",
-		"lint": "aegir lint"
-	},
-	"author": "dao.xyz",
-	"license": "MIT",
-	"dependencies": {
-		"@dao-xyz/borsh": "^5.2.3",
-		"@peerbit/logger": "1.0.4",
-		"@peerbit/program": "5.3.0",
-		"@peerbit/log": "4.1.3",
-		"@peerbit/rpc": "5.3.21",
-		"@peerbit/time": "2.2.0",
-		"@peerbit/riblt": "1.0.6"
-	},
-	"devDependencies": {
-		"@peerbit/test-utils": "^2.2.3"
-	}
+  "name": "@peerbit/shared-log",
+  "version": "11.5.1-0fddff8",
+  "description": "Shared log",
+  "sideEffects": false,
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "*",
+        "dist/*",
+        "dist/src/*",
+        "dist/src/*/index"
+      ],
+      "src/*": [
+        "*",
+        "dist/*",
+        "dist/src/*",
+        "dist/src/*/index"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!dist/e2e",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "eslintConfig": {
+    "extends": "peerbit",
+    "parserOptions": {
+      "project": true,
+      "sourceType": "module"
+    },
+    "ignorePatterns": [
+      "!.aegir.js",
+      "test/ts-use",
+      "*.d.ts"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "aegir clean",
+    "build": "aegir build --no-bundle",
+    "test": "aegir test --target node",
+    "lint": "aegir lint"
+  },
+  "author": "dao.xyz",
+  "license": "MIT",
+  "dependencies": {
+    "@dao-xyz/borsh": "^5.2.3",
+    "@peerbit/logger": "1.0.4-0fddff8",
+    "@peerbit/program": "5.3.2-0fddff8",
+    "@peerbit/log": "4.1.5-0fddff8",
+    "@peerbit/rpc": "5.3.23-0fddff8",
+    "@peerbit/time": "2.2.0-0fddff8",
+    "@peerbit/riblt": "1.0.6-0fddff8"
+  },
+  "devDependencies": {
+    "@peerbit/test-utils": "2.2.5-0fddff8"
+  }
 }

package/src/index.ts

@@ -2964,57 +2964,90 @@ export class SharedLog<
 
 	async waitForReplicator(
 		key: PublicSignKey,
-		options?: { signal?: AbortSignal },
+		options?: {
+			signal?: AbortSignal;
+			eager?: boolean;
+			roleAge?: number;
+			timeout?: number;
+		},
 	) {
-		let deferred = pDefer<void>();
-
-		let timeout = setTimeout(() => {
-			clear();
-			deferred.reject(
-				new TimeoutError(`Timeout waiting for replicator ${key.hashcode()}`),
-			);
-		}, this.waitForReplicatorTimeout);
+		const deferred = pDefer<void>();
+		const timeoutMs = options?.timeout ?? this.waitForReplicatorTimeout;
+		const resolvedRoleAge = options?.eager
+			? undefined
+			: (options?.roleAge ?? (await this.getDefaultMinRoleAge()));
 
-		if (options?.signal) {
-			options.signal.addEventListener("abort", () => {
-				clear();
-				deferred.reject(new AbortError());
-			});
-		}
+		let settled = false;
+		let timer: ReturnType<typeof setTimeout> | undefined;
 
 		const clear = () => {
 			this.events.removeEventListener("replicator:mature", check);
 			this.events.removeEventListener("replication:change", check);
-			if (options?.signal) {
-				options.signal.removeEventListener("abort", clear);
+			options?.signal?.removeEventListener("abort", onAbort);
+			if (timer != null) {
+				clearTimeout(timer);
+				timer = undefined;
 			}
-			clearTimeout(timeout);
 		};
 
-		deferred.promise.finally(() => {
+		const resolve = () => {
+			if (settled) {
+				return;
+			}
+			settled = true;
 			clear();
-		});
+			deferred.resolve();
+		};
+
+		const reject = (error: Error) => {
+			if (settled) {
+				return;
+			}
+			settled = true;
+			clear();
+			deferred.reject(error);
+		};
+
+		const onAbort = () => reject(new AbortError());
+		if (options?.signal) {
+			options.signal.addEventListener("abort", onAbort);
+		}
+
+		timer = setTimeout(() => {
+			reject(
+				new TimeoutError(`Timeout waiting for replicator ${key.hashcode()}`),
+			);
+		}, timeoutMs);
 
 		const check = async () => {
 			const iterator = this.replicationIndex?.iterate(
 				{ query: new StringMatch({ key: "hash", value: key.hashcode() }) },
 				{ reference: true },
 			);
-			const rects = await iterator?.next(1);
-			await iterator.close();
-			const rect = rects[0]?.value;
-			if (
-				!rect ||
-				!isMatured(rect, +new Date(), await this.getDefaultMinRoleAge())
-			) {
-				return;
+			try {
+				const rects = await iterator?.next(1);
+				const rect = rects?.[0]?.value;
+				if (!rect) {
+					return;
+				}
+				if (!options?.eager && resolvedRoleAge != null) {
+					if (!isMatured(rect, +new Date(), resolvedRoleAge)) {
+						return;
+					}
+				}
+				resolve();
+			} catch (error) {
+				reject(error instanceof Error ? error : new Error(String(error)));
+			} finally {
+				await iterator?.close();
 			}
-			return deferred.resolve();
 		};
+
 		check();
 		this.events.addEventListener("replicator:mature", check);
 		this.events.addEventListener("replication:change", check);
-		return deferred.promise;
+
+		return deferred.promise.finally(clear);
 	}
 
 	async waitForReplicators(options?: {

package/src/ranges.ts

@@ -2394,6 +2394,15 @@ export const getCoverSet = async <R extends "u32" | "u64">(properties: {
 				? properties.numbers.min(startForNext, endLocation)
 				: startForNext
 			: properties.numbers.min(startForNext, endLocation);
+
+		if (
+			(typeof nextLocation === "bigint" &&
+				nextLocation === (endLocation as bigint)) ||
+			(typeof nextLocation === "number" &&
+				nextLocation === (endLocation as number))
+		) {
+			break;
+		}
 	}
 
 	start instanceof PublicSignKey && ret.add(start.hashcode());

package/src/sync/rateless-iblt.ts

@@ -420,8 +420,6 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 				}, 2e4); // TODO arg
 			};
 
-			let count = 0;
-			/* let t0 = +new Date(); */
 			let messageQueue: {
 				seqNo: bigint;
 				symbols: (SSymbol | SymbolSerialized)[];
@@ -452,47 +450,13 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 					if (messageQueue[0].seqNo !== lastSeqNo + 1n) {
 						return;
 					}
-					lastSeqNo++;
 
-					const symbolMessage = messageQueue.shift();
-					if (!symbolMessage) {
-						return;
-					}
-
-					for (const symbol of symbolMessage.symbols) {
-						decoder.add_coded_symbol(symbol);
-					}
-					try {
-						decoder.try_decode();
-					} catch (error: any) {
-						if (
-							error?.message === "Invalid degree" ||
-							error === "Invalid degree"
-						) {
-							// TODO in some way test this code path
-							logger.error(error?.message ?? error);
-							obj.free();
-							await this.simple.rpc.send(
-								new RequestAll({
-									syncId: message.syncId,
-								}),
-								{
-									mode: new SilentDelivery({
-										to: [context.from!],
-										redundancy: 1,
-									}),
-									priority: 1,
-								},
-							);
-							return true;
-						} else {
-							throw error;
+					const finalizeIfDecoded = (): boolean => {
+						if (!decoder.decoded()) {
+							return false;
 						}
-					}
-					count += symbolMessage.symbols.length;
 
-					if (decoder.decoded()) {
-						let allMissingSymbolsInRemote: bigint[] = [];
+						const allMissingSymbolsInRemote: bigint[] = [];
 						for (const missingSymbol of decoder.get_remote_symbols()) {
 							allMissingSymbolsInRemote.push(missingSymbol);
 						}
@@ -502,6 +466,48 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 						});
 						obj.free();
 						return true;
+					};
+
+					while (
+						messageQueue.length > 0 &&
+						messageQueue[0].seqNo === lastSeqNo + 1n
+					) {
+						const symbolMessage = messageQueue.shift();
+						if (!symbolMessage) {
+							break;
+						}
+
+						lastSeqNo = symbolMessage.seqNo;
+
+						for (const symbol of symbolMessage.symbols) {
+							const normalizedSymbol =
+								symbol instanceof SymbolSerialized
+									? symbol
+									: new SymbolSerialized({
+											count: symbol.count,
+											hash: symbol.hash,
+											symbol: symbol.symbol,
+										});
+
+							decoder.add_coded_symbol(normalizedSymbol);
+							try {
+								decoder.try_decode();
+								if (finalizeIfDecoded()) {
+									return true;
+								}
+							} catch (error: any) {
+								if (
+									error?.message === "Invalid degree" ||
+									error === "Invalid degree"
+								) {
+									logger.debug(
+										"Decoder reported invalid degree; waiting for more symbols",
+									);
+									continue;
+								}
+								throw error;
+							}
+						}
 					}
 					return false;
 				},