@peerbit/shared-log 16.0.12 → 16.0.13

package/src/receive-signature-verification.ts

@@ -0,0 +1,66 @@
+import type { Entry } from "@peerbit/log";
+import { equals as bytesEqual } from "uint8arrays";
+
+export type ReceiveSignatureVerificationFact<T> = {
+	entry: Entry<T>;
+	storageBytes: Uint8Array;
+	verified: boolean;
+};
+
+export const receiveSignatureVerificationResult = <T>(
+	factsByEntry: WeakMap<Entry<T>, ReceiveSignatureVerificationFact<T>[]>,
+	entry: Entry<T>,
+): boolean | undefined => {
+	const facts = factsByEntry.get(entry);
+	if (!facts || facts.length === 0) {
+		return undefined;
+	}
+	let storageBytes: Uint8Array;
+	try {
+		storageBytes = entry.getStorageBytes();
+	} catch {
+		return undefined;
+	}
+	for (let i = facts.length - 1; i >= 0; i--) {
+		const fact = facts[i]!;
+		if (bytesEqual(storageBytes, fact.storageBytes)) {
+			return fact.verified;
+		}
+	}
+	return undefined;
+};
+
+export const withReceiveSignatureVerificationFacts = async <T, R>(
+	factsByEntry: WeakMap<Entry<T>, ReceiveSignatureVerificationFact<T>[]>,
+	facts: ReceiveSignatureVerificationFact<T>[] | undefined,
+	operation: () => Promise<R>,
+): Promise<R> => {
+	if (!facts || facts.length === 0) {
+		return operation();
+	}
+	for (const fact of facts) {
+		const active = factsByEntry.get(fact.entry);
+		if (active) {
+			active.push(fact);
+		} else {
+			factsByEntry.set(fact.entry, [fact]);
+		}
+	}
+	try {
+		return await operation();
+	} finally {
+		for (const fact of facts) {
+			const active = factsByEntry.get(fact.entry);
+			if (!active) {
+				continue;
+			}
+			const index = active.indexOf(fact);
+			if (index >= 0) {
+				active.splice(index, 1);
+			}
+			if (active.length === 0) {
+				factsByEntry.delete(fact.entry);
+			}
+		}
+	}
+};

package/src/replication-info-v2-receive.ts

@@ -10,7 +10,9 @@ import {
 	AddedReplicationSegmentMessage,
 	AllReplicatingSegmentsMessage,
 	FullReplicationInfoV2Message,
+	ReplicationInfoV2AppliedMessage,
 	type ReplicationInfoV2Message,
+	RequestReplicationInfoV2AppliedMessage,
 	RequestReplicationInfoV2Message,
 	StoppedReplicating,
 	StoppedReplicationInfoV2Message,
@@ -1250,6 +1252,46 @@ export class ReplicationInfoV2ReceiveCoordinator {
 		return true;
 	}
 
+	/**
+	 * Answer only after the exact authenticated receive generation has committed
+	 * the queried sequence (or a newer one). No pending query is retained: the
+	 * sender's bounded retry loop reissues an authoritative snapshot and query.
+	 */
+	confirmApplied(
+		request: RequestReplicationInfoV2AppliedMessage,
+		properties: {
+			from: PublicSignKey;
+			peerSession: object;
+			receiveEpoch: object | null;
+			senderTransportSession: bigint;
+		},
+	): ReplicationInfoV2AppliedMessage | undefined {
+		const state = this._receiveStates.get(properties.from.hashcode());
+		if (
+			!state ||
+			state.peerSession !== properties.peerSession ||
+			state.receiveEpoch !== properties.receiveEpoch ||
+			state.senderTransportSession !== properties.senderTransportSession ||
+			!state.target.equals(properties.from) ||
+			!state.receiverBinding ||
+			!bytesEqual(request.receiverChallenge, state.receiverBinding) ||
+			!state.senderEpoch ||
+			!bytesEqual(request.senderEpoch, state.senderEpoch) ||
+			request.sequence <= 0n ||
+			state.lastSequence === undefined ||
+			state.lastSequence < request.sequence ||
+			!this.isStateCurrent(state)
+		) {
+			return undefined;
+		}
+		return new ReplicationInfoV2AppliedMessage({
+			receiverChallenge: request.receiverChallenge.slice(),
+			senderEpoch: request.senderEpoch.slice(),
+			sequence: request.sequence,
+			revision: request.revision,
+		});
+	}
+
 	requireFullAfterFailure(
 		admission: ReplicationInfoV2ReceiveAdmission,
 	): boolean {