@peerbit/shared-log 9.0.6 → 9.0.7-343b1fa

package/src/replication.ts

@@ -2,6 +2,7 @@ import {
 	BinaryReader,
 	deserialize,
 	field,
+	option,
 	serialize,
 	variant,
 	vec,
@@ -9,28 +10,14 @@ import {
 import { PublicSignKey, equals, randomBytes } from "@peerbit/crypto";
 import { type Index, id } from "@peerbit/indexer-interface";
 import { TransportMessage } from "./message.js";
-import { SEGMENT_COORDINATE_SCALE } from "./role.js";
+import {
+	Observer,
+	Replicator,
+	Role,
+	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 enum ReplicationIntent {
 	Explicit = 0,
@@ -280,7 +267,35 @@ export class RequestReplicationInfoMessage extends TransportMessage {
 	}
 }
 
+// @deprecated remove when possible
 @variant([1, 1])
+export class ResponseRoleMessage extends TransportMessage {
+	@field({ type: option(Role) })
+	role: Observer | Replicator;
+
+	constructor(properties: { role: Observer | Replicator }) {
+		super();
+		this.role = properties.role;
+	}
+
+	toReplicationInfoMessage(): ResponseReplicationInfoMessage {
+		return new ResponseReplicationInfoMessage({
+			segments:
+				this.role instanceof Replicator
+					? this.role.segments.map((x) => {
+							return new ReplicationRange({
+								id: randomBytes(32),
+								offset: x.offset,
+								factor: x.factor,
+								timestamp: x.timestamp,
+							});
+						})
+					: [],
+		});
+	}
+}
+
+@variant([1, 2])
 export class ResponseReplicationInfoMessage extends TransportMessage {
 	@field({ type: vec(ReplicationRange) })
 	segments: ReplicationRange[];
@@ -291,7 +306,7 @@ export class ResponseReplicationInfoMessage extends TransportMessage {
 	}
 }
 
-@variant([1, 2])
+@variant([1, 3])
 export class StartedReplicating extends TransportMessage {
 	@field({ type: vec(ReplicationRange) })
 	segments: ReplicationRange[];
@@ -302,7 +317,7 @@ export class StartedReplicating extends TransportMessage {
 	}
 }
 
-@variant([1, 3])
+@variant([1, 4])
 export class StoppedReplicating extends TransportMessage {
 	@field({ type: vec(Uint8Array) })
 	segmentIds: Uint8Array[];

package/src/role.ts

@@ -1,16 +1,23 @@
-/* import { field, variant, vec } from "@dao-xyz/borsh"; */
+/**
+ * @deprecated
+ * Code below is deprecated and will be removed in the future.
+ * Roles have been replaces with just replication segments.
+ */
+import { field, variant, vec } from "@dao-xyz/borsh";
+
+export const SEGMENT_COORDINATE_SCALE = 4294967295;
 
-/* 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): boolean; 
+export abstract class Role {
+	abstract equals(other: Role): boolean;
 }
- 
+
 export const NO_TYPE_VARIANT = new Uint8Array([0]);
 
 @variant(0)
@@ -29,83 +36,80 @@ export class Observer extends Role {
 	}
 }
 
-export const REPLICATOR_TYPE_VARIANT = new Uint8Array([2]);*/
-
-export const SEGMENT_COORDINATE_SCALE = 4294967295;
-/* export class ReplicationSegment {
+export const REPLICATOR_TYPE_VARIANT = new Uint8Array([2]);
 
+export class RoleReplicationSegment {
 	@field({ type: "u64" })
 	timestamp: bigint;
 
 	@field({ type: "u32" })
-	start: number;
-
-	@field({ type: 'u32' })
-	end: number;
-
+	private factorNominator: number;
 
+	@field({ type: "u32" })
+	private offsetNominator: number;
 
 	constructor(properties: {
-		start: number;
-		end: number;
-		timestamp: bigint;
+		factor: number;
+		offset: number;
+		timestamp?: bigint;
 	}) {
-		const { start, end, timestamp } = properties;
+		const { factor, timestamp, offset } = properties;
+		if (factor > 1 || factor < 0) {
+			throw new Error("Expecting factor to be between 0 and 1, got: " + factor);
+		}
 
-		if (start > end) {
-			throw new Error("Range 'start' needs to be lower or equal to 'end'")
+		this.timestamp = timestamp ?? BigInt(+new Date());
+		this.factorNominator = Math.round(SEGMENT_COORDINATE_SCALE * factor);
+
+		if (offset > 1 || offset < 0) {
+			throw new Error("Expecting offset to be between 0 and 1, got: " + offset);
 		}
-		this.start = Math.round(start * SEGMENT_COORDINATE_SCALE);
-		this.end = Math.round(end * SEGMENT_COORDINATE_SCALE);
-		this.timestamp = timestamp
+		this.offsetNominator = Math.round(SEGMENT_COORDINATE_SCALE * offset);
 	}
 
+	get factor(): number {
+		return this.factorNominator / SEGMENT_COORDINATE_SCALE;
+	}
 
-
+	get offset(): number {
+		return this.offsetNominator / SEGMENT_COORDINATE_SCALE;
+	}
 }
- */
-
-/* abstract class Capacity { }
 
 @variant(2)
 export class Replicator extends Role {
+	@field({ type: vec(RoleReplicationSegment) })
+	segments: RoleReplicationSegment[];
 
-	@field({ type: vec(Capacity) })
-	capacity: Capacity[];
-
-	constructor(properties?: { capacity: Capacity[] }) {
+	constructor(properties: {
+		factor: number;
+		timestamp?: bigint;
+		offset: number;
+	}) {
 		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;
-}
+		const segment: RoleReplicationSegment = new RoleReplicationSegment(
+			properties,
+		);
+		this.segments = [segment];
+	}
 
-get offset(): number {
-	return this.segments[0]!.offset;
-}
+	get factor(): number {
+		return this.segments[0]!.factor;
+	}
 
-get timestamp(): bigint {
-	return this.segments[0]!.timestamp;
-} */
-
-/* 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
+		);
+	}
+}