@peerbit/shared-log 8.0.7 → 9.0.0-2bc15a6

package/src/replication.ts

@@ -1,26 +1,255 @@
 import {
-	variant,
+	BinaryReader,
 	deserialize,
-	serialize,
 	field,
-	option,
-	BinaryReader
+	serialize,
+	variant,
+	vec,
 } from "@dao-xyz/borsh";
+import { PublicSignKey, equals, randomBytes } from "@peerbit/crypto";
+import { type Index, id } from "@peerbit/indexer-interface";
 import { TransportMessage } from "./message.js";
-import { Observer, Replicator, Role } from "./role.js";
-import { PublicSignKey } from "@peerbit/crypto";
-import yallist from "yallist";
+import { SEGMENT_COORDINATE_SCALE } from "./role.js";
 
 export type ReplicationLimits = { min: MinReplicas; max?: MinReplicas };
+/* 
+export class ReplicatorRect {
+
+	@id({ type: Uint8Array })
+	id: Uint8Array;
+
+	@field({ type: 'string' })
+	hash: string;
+
+	@field({ type: vec(ReplicationSegment) })
+	segments: ReplicationSegment[];
+
+	constructor(properties: { hash: string; segments: ReplicationSegment[] }) {
+		this.id = randomBytes(32);
+		this.hash = properties.hash;
+		this.segments = properties.segments;
+	}
+};
+ */
 
-export type ReplicatorRect = {
-	publicKey: PublicSignKey;
-	role: Replicator;
+export enum ReplicationIntent {
+	Explicit = 0,
+	Automatic = 1,
+}
+
+export const getSegmentsFromOffsetAndRange = (
+	offset: number,
+	factor: number,
+): [[number, number], [number, number]] => {
+	let start1 = offset;
+	let end1Unscaled = offset + factor; // only add factor if it is not 1 to prevent numerical issues (like (0.9 + 1) % 1 => 0.8999999)
+	let end1 = Math.min(end1Unscaled, 1);
+	return [
+		[start1, end1],
+		end1Unscaled > 1
+			? [0, (factor !== 1 ? offset + factor : offset) % 1]
+			: [start1, end1],
+	];
 };
 
+export class ReplicationRange {
+	@field({ type: Uint8Array })
+	private id: Uint8Array;
+
+	@field({ type: "u64" })
+	timestamp: bigint;
+
+	@field({ type: "u32" })
+	private _offset: number;
+
+	@field({ type: "u32" })
+	private _factor: number;
+
+	constructor(properties: {
+		id: Uint8Array;
+		offset: number;
+		factor: number;
+		timestamp: bigint;
+	}) {
+		const { id, offset, factor, timestamp } = properties;
+		this.id = id;
+		this._offset = Math.round(offset * SEGMENT_COORDINATE_SCALE);
+		this._factor = Math.round(factor * SEGMENT_COORDINATE_SCALE);
+		this.timestamp = timestamp;
+	}
+
+	get factor(): number {
+		return this._factor / SEGMENT_COORDINATE_SCALE;
+	}
+
+	get offset(): number {
+		return this._offset / SEGMENT_COORDINATE_SCALE;
+	}
+
+	toReplicationRangeIndexable(key: PublicSignKey): ReplicationRangeIndexable {
+		return new ReplicationRangeIndexable({
+			id: this.id,
+			publicKeyHash: key.hashcode(),
+			offset: this.offset,
+			length: this.factor,
+			timestamp: this.timestamp,
+		});
+	}
+}
+
+export class ReplicationRangeIndexable {
+	@id({ type: Uint8Array })
+	id: Uint8Array;
+
+	@field({ type: "string" })
+	hash: string;
+
+	@field({ type: "u64" })
+	timestamp: bigint;
+
+	@field({ type: "u32" })
+	start1: number;
+
+	@field({ type: "u32" })
+	end1: number;
+
+	@field({ type: "u32" })
+	start2: number;
+
+	@field({ type: "u32" })
+	end2: number;
+
+	@field({ type: "u32" })
+	width: number;
+
+	@field({ type: "u8" })
+	replicationIntent: ReplicationIntent;
+
+	constructor(
+		properties: {
+			id?: Uint8Array;
+
+			offset: number;
+			length: number;
+			replicationIntent?: ReplicationIntent;
+			timestamp?: bigint;
+		} & ({ publicKeyHash: string } | { publicKey: PublicSignKey }),
+	) {
+		this.id = properties.id ?? randomBytes(32);
+		this.hash =
+			(properties as { publicKeyHash: string }).publicKeyHash ||
+			(properties as { publicKey: PublicSignKey }).publicKey.hashcode();
+		this.transform({ length: properties.length, offset: properties.offset });
+		this.replicationIntent =
+			properties.replicationIntent ?? ReplicationIntent.Explicit;
+		this.timestamp = properties.timestamp || BigInt(0);
+	}
+
+	private transform(properties: { offset: number; length: number }) {
+		const ranges = getSegmentsFromOffsetAndRange(
+			properties.offset,
+			properties.length,
+		);
+		this.start1 = Math.round(ranges[0][0] * SEGMENT_COORDINATE_SCALE);
+		this.end1 = Math.round(ranges[0][1] * SEGMENT_COORDINATE_SCALE);
+		this.start2 = Math.round(ranges[1][0] * SEGMENT_COORDINATE_SCALE);
+		this.end2 = Math.round(ranges[1][1] * SEGMENT_COORDINATE_SCALE);
+
+		this.width =
+			this.end1 -
+			this.start1 +
+			(this.end2 < this.end1 ? this.end2 - this.start2 : 0);
+
+		if (
+			this.start1 > 0xffffffff ||
+			this.end1 > 0xffffffff ||
+			this.start2 > 0xffffffff ||
+			this.end2 > 0xffffffff ||
+			this.width > 0xffffffff
+		) {
+			throw new Error("Segment coordinate out of bounds");
+		}
+	}
+
+	contains(point: number) {
+		return (
+			(point >= this.start1 && point < this.end1) ||
+			(point >= this.start2 && point < this.end2)
+		);
+	}
+
+	overlaps(other: ReplicationRangeIndexable, checkOther = true): boolean {
+		if (
+			this.contains(other.start1) ||
+			this.contains(other.start2) ||
+			this.contains(other.end1) ||
+			this.contains(other.end2)
+		) {
+			return true;
+		}
+
+		if (checkOther) {
+			return other.overlaps(this, false);
+		}
+		return false;
+	}
+	toReplicationRange() {
+		return new ReplicationRange({
+			id: this.id,
+			offset: this.start1 / SEGMENT_COORDINATE_SCALE,
+			factor: this.width / SEGMENT_COORDINATE_SCALE,
+			timestamp: this.timestamp,
+		});
+	}
+
+	distanceTo(point: number) {
+		let wrappedPoint = SEGMENT_COORDINATE_SCALE - point;
+		return Math.min(
+			Math.abs(this.start1 - point),
+			Math.abs(this.end2 - point),
+			Math.abs(this.start1 - wrappedPoint),
+			Math.abs(this.end2 - wrappedPoint),
+		);
+	}
+	get wrapped() {
+		return this.end2 < this.end1;
+	}
+
+	get widthNormalized() {
+		return this.width / SEGMENT_COORDINATE_SCALE;
+	}
+
+	equals(other: ReplicationRangeIndexable) {
+		if (
+			equals(this.id, other.id) &&
+			this.hash === other.hash &&
+			this.timestamp === other.timestamp &&
+			this.replicationIntent === other.replicationIntent &&
+			this.start1 === other.start1 &&
+			this.end1 === other.end1 &&
+			this.start2 === other.start2 &&
+			this.end2 === other.end2 &&
+			this.width === other.width
+		) {
+			return true;
+		}
+
+		return false;
+	}
+
+	toString() {
+		let roundToTwoDecimals = (num: number) => Math.round(num * 100) / 100;
+
+		if (Math.abs(this.start1 - this.start2) < 0.0001) {
+			return `([${roundToTwoDecimals(this.start1 / SEGMENT_COORDINATE_SCALE)}, ${roundToTwoDecimals(this.end1 / SEGMENT_COORDINATE_SCALE)}])`;
+		}
+		return `([${roundToTwoDecimals(this.start1 / SEGMENT_COORDINATE_SCALE)}, ${roundToTwoDecimals(this.end1 / SEGMENT_COORDINATE_SCALE)}] [${roundToTwoDecimals(this.start2 / SEGMENT_COORDINATE_SCALE)}, ${roundToTwoDecimals(this.end2 / SEGMENT_COORDINATE_SCALE)}])`;
+	}
+}
+
 interface SharedLog {
 	replicas: Partial<ReplicationLimits>;
-	getReplicatorsSorted(): yallist<ReplicatorRect> | undefined;
+	replicationIndex: Index<ReplicationRangeIndexable> | undefined;
 }
 
 export class MinReplicas {
@@ -38,26 +267,49 @@ export class AbsoluteReplicas extends MinReplicas {
 		super();
 		this._value = value;
 	}
+
 	getValue(_log: SharedLog): number {
 		return this._value;
 	}
 }
 
 @variant([1, 0])
-export class RequestRoleMessage extends TransportMessage {
+export class RequestReplicationInfoMessage extends TransportMessage {
 	constructor() {
 		super();
 	}
 }
 
 @variant([1, 1])
-export class ResponseRoleMessage extends TransportMessage {
-	@field({ type: option(Role) })
-	role: Observer | Replicator;
+export class ResponseReplicationInfoMessage extends TransportMessage {
+	@field({ type: vec(ReplicationRange) })
+	segments: ReplicationRange[];
+
+	constructor(properties: { segments: ReplicationRange[] }) {
+		super();
+		this.segments = properties.segments;
+	}
+}
+
+@variant([1, 2])
+export class StartedReplicating extends TransportMessage {
+	@field({ type: vec(ReplicationRange) })
+	segments: ReplicationRange[];
+
+	constructor(properties: { segments: ReplicationRange[] }) {
+		super();
+		this.segments = properties.segments;
+	}
+}
+
+@variant([1, 3])
+export class StoppedReplicating extends TransportMessage {
+	@field({ type: vec(Uint8Array) })
+	segmentIds: Uint8Array[];
 
-	constructor(properties: { role: Observer | Replicator }) {
+	constructor(properties: { segmentIds: Uint8Array[] }) {
 		super();
-		this.role = properties.role;
+		this.segmentIds = properties.segmentIds;
 	}
 }
 
@@ -98,7 +350,7 @@ export const maxReplicas = (
 	log: SharedLog,
 	entries:
 		| { meta: { data?: Uint8Array } }[]
-		| IterableIterator<{ meta: { data?: Uint8Array } }>
+		| IterableIterator<{ meta: { data?: Uint8Array } }>,
 ) => {
 	let max = 0;
 	for (const entry of entries) {
@@ -112,7 +364,7 @@ export const maxReplicas = (
 
 export const hashToUniformNumber = (hash: Uint8Array) => {
 	const seedNumber = new BinaryReader(
-		hash.subarray(hash.length - 4, hash.length)
+		hash.subarray(hash.length - 4, hash.length),
 	).u32();
 	return seedNumber / 0xffffffff; // bounded between 0 and 1
 };

package/src/role.ts

@@ -1,16 +1,16 @@
-import { field, variant, vec } from "@dao-xyz/borsh";
+/* import { field, variant, vec } from "@dao-xyz/borsh"; */
 
-export const overlaps = (x1: number, x2: number, y1: number, y2: number) => {
+/* export const overlaps = (x1: number, x2: number, y1: number, y2: number) => {
 	if (x1 <= y2 && y1 <= x2) {
 		return true;
 	}
 	return false;
-};
+}; */
 
-export abstract class Role {
-	abstract equals(other: Role);
+/* export abstract class Role {
+	abstract equals(other: Role): boolean; 
 }
-
+ 
 export const NO_TYPE_VARIANT = new Uint8Array([0]);
 
 @variant(0)
@@ -29,103 +29,83 @@ export class Observer extends Role {
 	}
 }
 
-export const REPLICATOR_TYPE_VARIANT = new Uint8Array([2]);
+export const REPLICATOR_TYPE_VARIANT = new Uint8Array([2]);*/
+
+export const SEGMENT_COORDINATE_SCALE = 4294967295;
+/* export class ReplicationSegment {
 
-export class ReplicationSegment {
 	@field({ type: "u64" })
 	timestamp: bigint;
 
 	@field({ type: "u32" })
-	private factorNominator: number;
+	start: number;
+
+	@field({ type: 'u32' })
+	end: number;
+
 
-	@field({ type: "u32" })
-	private offsetNominator: number;
 
 	constructor(properties: {
-		factor: number;
-		offset: number;
-		timestamp?: bigint;
+		start: number;
+		end: number;
+		timestamp: bigint;
 	}) {
-		const { factor, timestamp, offset } = properties;
-		if (factor > 1 || factor < 0) {
-			throw new Error("Expecting factor to be between 0 and 1, got: " + factor);
-		}
+		const { start, end, timestamp } = properties;
 
-		this.timestamp = timestamp ?? BigInt(+new Date());
-		this.factorNominator = Math.round(4294967295 * factor);
-
-		if (offset > 1 || offset < 0) {
-			throw new Error("Expecting offset to be between 0 and 1, got: " + offset);
+		if (start > end) {
+			throw new Error("Range 'start' needs to be lower or equal to 'end'")
 		}
-		this.offsetNominator = Math.round(4294967295 * offset);
+		this.start = Math.round(start * SEGMENT_COORDINATE_SCALE);
+		this.end = Math.round(end * SEGMENT_COORDINATE_SCALE);
+		this.timestamp = timestamp
 	}
 
-	get factor(): number {
-		return this.factorNominator / 4294967295;
-	}
 
-	get offset(): number {
-		return this.offsetNominator / 4294967295;
-	}
-
-	overlaps(other: ReplicationSegment) {
-		let x1 = this.offset;
-		let x2 = this.offset + this.factor;
-		let y1 = other.offset;
-		let y2 = other.offset + other.factor;
-		if (overlaps(x1, x2, y1, y2)) {
-			return true;
-		}
 
-		if (x2 > 1 || y2 > 1) {
-			if (x2 > 1) {
-				x1 = 0;
-				x2 = x2 % 1;
-			}
-			if (y2 > 1) {
-				y1 = 0;
-				y2 = y2 % 1;
-			}
-			if (overlaps(x1, x2, y1, y2)) {
-				return true;
-			}
-		}
-		return false;
-	}
 }
+ */
+
+/* abstract class Capacity { }
 
 @variant(2)
 export class Replicator extends Role {
-	@field({ type: vec(ReplicationSegment) })
-	segments: ReplicationSegment[];
 
-	constructor(properties: {
-		factor: number;
-		timestamp?: bigint;
-		offset: number;
-	}) {
-		super();
-		const segment: ReplicationSegment = new ReplicationSegment(properties);
-		this.segments = [segment];
-	}
-
-	get factor(): number {
-		return this.segments[0]!.factor;
-	}
-
-	get offset(): number {
-		return this.segments[0]!.offset;
-	}
+	@field({ type: vec(Capacity) })
+	capacity: Capacity[];
 
-	get timestamp(): bigint {
-		return this.segments[0]!.timestamp;
-	}
+	constructor(properties?: { capacity: Capacity[] }) {
+		super();
+		this.capacity = properties?.capacity || [];
+	} */
+
+/* constructor(properties: {
+	timestamp?: bigint;
+	factor: number;
+	offset: number;
+}) {
+	super();
+	let timestamp = properties.timestamp || BigInt(+new Date);
+	let ranges = getSegmentsFromOffsetAndRange(properties.offset, properties.factor);
+	this.segments = ranges.map(x => new ReplicationSegment({ start: x[0], end: x[1], timestamp }));
+}
+*/
+/* get factor(): number {
+	return this.segments[0]!.factor;
+}
 
-	equals(other: Role) {
-		return (
-			other instanceof Replicator &&
-			other.factor === this.factor &&
-			other.offset === this.offset
-		);
-	}
+get offset(): number {
+	return this.segments[0]!.offset;
 }
+
+get timestamp(): bigint {
+	return this.segments[0]!.timestamp;
+} */
+
+/* equals(other: Role) {
+	return (
+		other instanceof Replicator &&
+		other.factor === this.factor &&
+		other.offset === this.offset
+	);
+} */
+/* } */