@peerbit/shared-log 3.1.9 → 4.0.1

package/src/replication.ts

@@ -3,11 +3,25 @@ import {
 	deserialize,
 	serialize,
 	field,
-	BorshError
+	option,
+	BinaryReader
 } from "@dao-xyz/borsh";
+import { TransportMessage } from "./message.js";
+import { Observer, Replicator, Role } from "./role.js";
+import { PublicSignKey } from "@peerbit/crypto";
+import yallist from "yallist";
+
+export type ReplicationLimits = { min: MinReplicas; max?: MinReplicas };
+
+export type ReplicatorRect = {
+	publicKey: PublicSignKey;
+	offset: number;
+	role: Replicator;
+};
 
 interface SharedLog {
-	getReplicatorsSorted(): { hash: string; timestamp: number }[] | undefined;
+	replicas: Partial<ReplicationLimits>;
+	getReplicatorsSorted(): yallist<ReplicatorRect> | undefined;
 }
 
 export class MinReplicas {
@@ -30,6 +44,25 @@ export class AbsoluteReplicas extends MinReplicas {
 	}
 }
 
+@variant([1, 0])
+export class RequestRoleMessage extends TransportMessage {
+	constructor() {
+		super();
+	}
+}
+
+@variant([1, 1])
+export class ResponseRoleMessage extends TransportMessage {
+	@field({ type: option(Role) })
+	role: Observer | Replicator;
+
+	constructor(role: Observer | Replicator) {
+		super();
+
+		this.role = role;
+	}
+}
+
 /* 
 @variant(1)
 export class RelativeMinReplicas extends MinReplicas {
@@ -65,11 +98,23 @@ export const decodeReplicas = (entry: {
 
 export const maxReplicas = (
 	log: SharedLog,
-	entries: { meta: { data?: Uint8Array } }[]
+	entries:
+		| { meta: { data?: Uint8Array } }[]
+		| IterableIterator<{ meta: { data?: Uint8Array } }>
 ) => {
 	let max = 0;
 	for (const entry of entries) {
 		max = Math.max(decodeReplicas(entry).getValue(log), max);
 	}
-	return max;
+	const lower = log.replicas.min?.getValue(log) || 1;
+	const higher = log.replicas.max?.getValue(log) ?? Number.MAX_SAFE_INTEGER;
+	const numberOfLeaders = Math.max(Math.min(higher, max), lower);
+	return numberOfLeaders;
+};
+
+export const hashToUniformNumber = (hash: Uint8Array) => {
+	const seedNumber = new BinaryReader(
+		hash.subarray(hash.length - 4, hash.length)
+	).u32();
+	return seedNumber / 0xffffffff; // bounded between 0 and 1
 };

package/src/role.ts

@@ -1,4 +1,4 @@
-import { field, variant } from "@dao-xyz/borsh";
+import { field, option, variant, vec } from "@dao-xyz/borsh";
 
 export abstract class Role {}
 
@@ -8,19 +8,80 @@ export const NO_TYPE_VARIANT = new Uint8Array([0]);
 export class NoType extends Role {}
 
 export const OBSERVER_TYPE_VARIANT = new Uint8Array([1]);
+
 @variant(1)
 export class Observer extends Role {}
 
 export const REPLICATOR_TYPE_VARIANT = new Uint8Array([2]);
 
+class ReplicationSegment {
+	@field({ type: "u64" })
+	timestamp: bigint;
+
+	@field({ type: "u32" })
+	private factorNominator: number;
+
+	@field({ type: option("u32") })
+	private offsetNominator?: number;
+
+	constructor(properties: {
+		factor: number;
+		timestamp?: bigint;
+		offset?: number;
+	}) {
+		const { factor, timestamp, offset } = properties;
+		if (factor > 1 || factor < 0) {
+			throw new Error("Expecting factor to be between 0 and 1, got: " + factor);
+		}
+
+		this.timestamp = timestamp ?? BigInt(+new Date());
+		this.factorNominator = Math.round(4294967295 * factor);
+
+		if (offset != null) {
+			if (offset > 1 || offset < 0) {
+				throw new Error(
+					"Expecting offset to be between 0 and 1, got: " + offset
+				);
+			}
+			this.offsetNominator = Math.round(4294967295 * offset);
+		}
+	}
+
+	get factor(): number {
+		return this.factorNominator / 4294967295;
+	}
+
+	get offset(): number | undefined {
+		return this.offsetNominator != null
+			? this.offsetNominator / 4294967295
+			: undefined;
+	}
+}
+
 @variant(2)
 export class Replicator extends Role {
-	@field({ type: "u32" })
-	multiplier: number; // 1 means I do the same amount of work as anyone else, 2 means double
+	@field({ type: vec(ReplicationSegment) })
+	segments: ReplicationSegment[];
 
-	constructor() {
-		// multiplier is unsupported for now, so contructor is empty
+	constructor(properties: {
+		factor: number;
+		timestamp?: bigint;
+		offset?: number;
+	}) {
 		super();
-		this.multiplier = 1;
+		const segment: ReplicationSegment = new ReplicationSegment(properties);
+		this.segments = [segment];
+	}
+
+	get factor(): number {
+		return this.segments[0]!.factor;
+	}
+
+	get offset(): number | undefined {
+		return this.segments[0]!.offset;
+	}
+
+	get timestamp(): bigint {
+		return this.segments[0]!.timestamp;
 	}
 }