@peerbit/log 1.0.2

package/lib/esm/values.js

@@ -0,0 +1,141 @@
+import yallist from "yallist";
+export class Values {
+    /**
+     * Keep track of sorted elements in descending sort order (i.e. newest elements)
+     */
+    _values;
+    _sortFn;
+    _byteLength;
+    _entryIndex;
+    constructor(entryIndex, sortFn, entries = []) {
+        this._values = yallist.create(entries
+            .slice()
+            .sort(sortFn)
+            .reverse()
+            .map((x) => {
+            if (!x.hash)
+                throw new Error("Unexpected");
+            return {
+                hash: x.hash,
+                byteLength: x._payload.byteLength,
+                gid: x.gid,
+            };
+        }));
+        this._byteLength = 0;
+        entries.forEach((entry) => {
+            this._byteLength += entry._payload.byteLength;
+        });
+        this._sortFn = sortFn;
+        this._entryIndex = entryIndex;
+    }
+    toArray() {
+        return Promise.all(this._values.toArrayReverse().map((x) => this._entryIndex.get(x.hash))).then((arr) => arr.filter((x) => !!x)); // we do reverse because we assume the log is only meaningful if we read it from start to end
+    }
+    get head() {
+        return this._values.head;
+    }
+    get tail() {
+        return this._values.tail;
+    }
+    get length() {
+        return this._values.length;
+    }
+    _putPromise = new Map();
+    async put(value) {
+        let promise = this._putPromise.get(value.hash);
+        if (promise) {
+            return promise;
+        }
+        promise = this._put(value).then((v) => {
+            this._putPromise.delete(value.hash);
+            return v;
+        });
+        this._putPromise.set(value.hash, promise);
+        return promise;
+    }
+    async _put(value) {
+        // assume we want to insert at head (or somehere close)
+        let walker = this._values.head;
+        let last = undefined;
+        while (walker) {
+            const walkerValue = await this.getEntry(walker);
+            if (!walkerValue) {
+                throw new Error("Missing walker value");
+            }
+            if (walkerValue.hash === value.hash) {
+                return; // already exist!
+            }
+            if (this._sortFn(walkerValue, value) < 0) {
+                break;
+            }
+            last = walker;
+            walker = walker.next;
+            continue;
+        }
+        this._byteLength += value._payload.byteLength;
+        if (!value.hash) {
+            throw new Error("Unexpected");
+        }
+        _insertAfter(this._values, last, {
+            byteLength: value._payload.byteLength,
+            gid: value.gid,
+            hash: value.hash,
+        });
+    }
+    async delete(value) {
+        const hash = typeof value === "string" ? value : value.hash;
+        // Assume we want to delete at tail (or somwhere close)
+        let walker = this._values.tail;
+        while (walker) {
+            const walkerValue = await this.getEntry(walker);
+            if (!walkerValue) {
+                throw new Error("Missing walker value");
+            }
+            if (walkerValue.hash === hash) {
+                this._values.removeNode(walker);
+                this._byteLength -= walkerValue._payload.byteLength;
+                return;
+            }
+            walker = walker.prev; // prev will be undefined if you do removeNode(walker)
+        }
+        throw new Error("Failed to delete, entry does not exist" +
+            " ??? " +
+            this.length +
+            " ??? " +
+            hash);
+    }
+    deleteNode(node) {
+        this._values.removeNode(node);
+        this._byteLength -= node.value.byteLength;
+        return;
+    }
+    pop() {
+        const value = this._values.pop();
+        if (value) {
+            this._byteLength -= value.byteLength;
+        }
+        return value;
+    }
+    get byteLength() {
+        return this._byteLength;
+    }
+    async getEntry(node) {
+        return this._entryIndex.get(node.value.hash);
+    }
+}
+function _insertAfter(self, node, value) {
+    const inserted = !node
+        ? new yallist.Node(value, null, self.head, self)
+        : new yallist.Node(value, node, node.next, self);
+    // is tail
+    if (inserted.next === null) {
+        self.tail = inserted;
+    }
+    // is head
+    if (inserted.prev === null) {
+        self.head = inserted;
+    }
+    self.length++;
+    return inserted;
+}
+//# sourceMappingURL=values.js.map

package/lib/esm/values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.js","sourceRoot":"","sources":["../../src/values.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,79 @@
+{
+	"name": "@peerbit/log",
+	"version": "1.0.2",
+	"description": "Append-only log CRDT",
+	"author": "dao.xyz",
+	"license": "MIT",
+	"type": "module",
+	"module": "lib/esm/index.js",
+	"types": "lib/esm/index.d.ts",
+	"exports": {
+		"import": "./lib/esm/index.js",
+		"require": "./lib/cjs/index.js"
+	},
+	"files": [
+		"lib",
+		"src",
+		"!src/**/__tests__",
+		"!lib/**/__tests__",
+		"LICENSE"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"engines": {
+		"node": ">=16.15.1"
+	},
+	"keywords": [
+		"ipfs",
+		"log",
+		"crdts",
+		"crdt"
+	],
+	"dependencies": {
+		"@dao-xyz/borsh": "^5.1.5",
+		"@peerbit/blocks-interface": "^1.0.1",
+		"@peerbit/cache": "1.0.0",
+		"@peerbit/crypto": "1.0.1",
+		"@peerbit/logger": "1.0.0",
+		"libp2p": "^0.45.9",
+		"p-queue": "^7.3.3",
+		"path-browserify": "^1.0.1",
+		"yallist": "^4.0.0"
+	},
+	"devDependencies": {
+		"@peerbit/test-utils": "1.0.2",
+		"@types/yallist": "^4.0.1",
+		"assert": "^2.0.0",
+		"json-stringify-deterministic": "^1.0.7"
+	},
+	"contributors": [
+		"haadcode",
+		"aphelionz",
+		"shamb0t",
+		"thiagodelgado111",
+		"mistakia",
+		"satazor",
+		"RichardLitt",
+		"greenkeeperio-bot",
+		"chrisdostert",
+		"zachferland",
+		"kaibakker",
+		"dignifiedquire",
+		"adam-palazzo"
+	],
+	"scripts": {
+		"clean": "shx rm -rf lib/*",
+		"build": "yarn clean && tsc -p tsconfig.json",
+		"postbuild": "echo '{\"type\":\"module\"} ' | node ../../node_modules/.bin/json > lib/esm/package.json",
+		"test": "node --experimental-vm-modules ./../../node_modules/.bin/jest test  -c  ../../jest.config.ts --runInBand --forceExit",
+		"test:unit": "node --experimental-vm-modules ../../node_modules/.bin/jest test  -c  ../../jest.config.unit.ts --runInBand --forceExit",
+		"test:integration": "node --experimental-vm-modules ../node_modules/.bin/jest test -c  ../../jest.config.integration.ts --runInBand --forceExit",
+		"benchmark": "nyc  --require ts-node/register benchmark-runner -r -b --baselineLimit 1000",
+		"benchmark:stress": "benchmark-runner -r --grep stress"
+	},
+	"localMaintainers": [
+		"dao.xyz"
+	],
+	"gitHead": "595db9f1efebf604393eddfff5f678f5d8f16142"
+}

package/src/change.ts

@@ -0,0 +1,2 @@
+import { Entry } from "./entry";
+export type Change<T> = { added: Entry<T>[]; removed: Entry<T>[] };

package/src/clock.ts

@@ -0,0 +1,280 @@
+/**
+The MIT License (MIT)
+
+Copyright (c) 2021 Martin Heidegger
+Copyright (c) 2022 dao.xyz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+import { field, variant } from "@dao-xyz/borsh";
+import { compare, equals } from "@peerbit/uint8arrays";
+import hrtime from "./hrtime.js";
+
+const hrTimeNow = hrtime.bigint();
+const startTime = BigInt(Date.now()) * BigInt(1e6) - hrTimeNow;
+const bigintTime = () => startTime + hrtime.bigint();
+
+export function fromBits(low, high, unsigned, target?) {
+	if (target === undefined || target === null) {
+		return {
+			low: low | 0,
+			high: high | 0,
+			unsigned: !!unsigned,
+		};
+	}
+	target.low = low | 0;
+	target.high = high | 0;
+	target.unsigned = !!unsigned;
+	return target;
+}
+
+const n1e6 = BigInt(1e6);
+const UINT64_MAX = 18446744073709551615n;
+const UINT32_MAX = 0xffffffff;
+
+function bigIntCoerce(input, fallback) {
+	if (typeof input === "bigint") return input;
+	if (typeof input === "number" || typeof input === "string")
+		return BigInt(input);
+	return fallback;
+}
+
+@variant(0)
+export class Timestamp {
+	@field({ type: "u64" })
+	wallTime: bigint;
+
+	@field({ type: "u32" })
+	logical: number;
+
+	constructor(properties?: { wallTime: bigint; logical?: number }) {
+		if (properties) {
+			this.wallTime = properties.wallTime;
+			this.logical = properties.logical || 0;
+		}
+	}
+
+	static compare(a: Timestamp, b: Timestamp) {
+		if (a.wallTime > b.wallTime) return 1;
+		if (a.wallTime < b.wallTime) return -1;
+		if (a.logical > b.logical) return 1;
+		if (a.logical < b.logical) return -1;
+		return 0;
+	}
+
+	static bigger(a: Timestamp, b: Timestamp) {
+		return a.compare(b) === -1 ? b : a;
+	}
+	static smaller(a: Timestamp, b: Timestamp) {
+		return a.compare(b) === 1 ? b : a;
+	}
+
+	compare(other: Timestamp) {
+		return Timestamp.compare(this, other);
+	}
+	clone(): Timestamp {
+		return new Timestamp({
+			wallTime: this.wallTime,
+			logical: this.logical,
+		});
+	}
+
+	toString() {
+		return `Timestamp: wallTime: ${this.wallTime}, logical: ${this.logical}`;
+	}
+}
+
+export class HLC {
+	maxOffset: bigint;
+	wallTimeUpperBound: bigint;
+	toleratedForwardClockJump: bigint;
+	last: Timestamp;
+	wallTime: () => bigint;
+	constructor(
+		properties: {
+			wallTime?: () => bigint;
+			maxOffset?: bigint;
+			wallTimeUpperBound?: bigint;
+			toleratedForwardClockJump?: bigint;
+			last?: Timestamp;
+		} = {}
+	) {
+		this.wallTime = properties.wallTime || bigintTime;
+		this.maxOffset = bigIntCoerce(properties.maxOffset, 0n);
+		this.wallTimeUpperBound = bigIntCoerce(properties.wallTimeUpperBound, 0n);
+		this.toleratedForwardClockJump = bigIntCoerce(
+			properties.toleratedForwardClockJump,
+			0n
+		);
+		this.last = new Timestamp({ wallTime: this.wallTime() });
+		if (properties.last) {
+			this.last = Timestamp.bigger(properties.last, this.last);
+		}
+	}
+
+	now() {
+		return this.update(this.last);
+	}
+
+	validateOffset(offset: bigint) {
+		if (
+			this.toleratedForwardClockJump > 0n &&
+			-offset > this.toleratedForwardClockJump
+		) {
+			throw new ForwardJumpError(-offset, this.toleratedForwardClockJump);
+		}
+		if (this.maxOffset > 0n && offset > this.maxOffset) {
+			throw new ClockOffsetError(offset, this.maxOffset);
+		}
+	}
+
+	update(other: Timestamp) {
+		const last = Timestamp.bigger(other, this.last);
+		let wallTime = this.wallTime();
+		const offset = last.wallTime - wallTime;
+		this.validateOffset(offset);
+		let logical: number;
+		if (offset < 0n) {
+			logical = 0;
+		} else {
+			wallTime = last.wallTime;
+			logical = last.logical + 1;
+			if (logical > UINT32_MAX) {
+				wallTime += 1n;
+				logical = 0;
+			}
+		}
+		const maxWallTime =
+			this.wallTimeUpperBound > 0n ? this.wallTimeUpperBound : UINT64_MAX;
+		if (wallTime > maxWallTime) {
+			throw new WallTimeOverflowError(wallTime, maxWallTime);
+		}
+		this.last = new Timestamp({ wallTime, logical });
+		return this.last;
+	}
+}
+
+export class ClockOffsetError extends Error {
+	offset: bigint;
+	maxOffset: bigint;
+	constructor(offset: bigint, maxOffset: bigint) {
+		super(
+			`The received time is ${
+				offset / n1e6
+			}ms ahead of the wall time, exceeding the 'maxOffset' limit of ${
+				maxOffset / n1e6
+			}ms.`
+		);
+		this.offset = offset;
+		this.maxOffset = maxOffset;
+	}
+}
+
+export class WallTimeOverflowError extends Error {
+	time: bigint;
+	maxTime: bigint;
+	constructor(time: bigint, maxTime: bigint) {
+		super(
+			`The wall time ${time / n1e6}ms exceeds the max time of ${
+				maxTime / n1e6
+			}ms.`
+		);
+		this.time = time;
+		this.maxTime = maxTime;
+	}
+}
+
+export class ForwardJumpError extends Error {
+	timejump: bigint;
+	tolerance: bigint;
+	constructor(timejump: bigint, tolerance: bigint) {
+		super(
+			`Detected a forward time jump of ${
+				timejump / n1e6
+			}ms, which exceed the allowed tolerance of ${tolerance / n1e6}ms.`
+		);
+		this.timejump = timejump;
+		this.tolerance = tolerance;
+	}
+}
+
+@variant(0)
+export class LamportClock {
+	@field({ type: Uint8Array })
+	id: Uint8Array;
+
+	@field({ type: Timestamp })
+	timestamp: Timestamp;
+
+	constructor(properties?: { id: Uint8Array; timestamp?: Timestamp | number }) {
+		if (properties) {
+			this.id = properties.id;
+			if (!properties.timestamp) {
+				this.timestamp = new Timestamp({
+					wallTime: bigintTime(),
+					logical: 0,
+				});
+			} else {
+				if (typeof properties.timestamp === "number") {
+					this.timestamp = new Timestamp({
+						wallTime: bigintTime(),
+						logical: properties.timestamp,
+					});
+				} else {
+					this.timestamp = properties.timestamp;
+				}
+			}
+		}
+	}
+
+	clone() {
+		return new LamportClock({
+			id: this.id,
+			timestamp: this.timestamp.clone(),
+		});
+	}
+
+	equals(other: LamportClock): boolean {
+		return (
+			equals(this.id, other.id) && this.timestamp.compare(other.timestamp) === 0
+		);
+	}
+
+	/**
+	 * Not optimized, dont use for performance critical things
+	 * @returns
+	 */
+	advance() {
+		const h = new HLC();
+		h.update(new Timestamp(this.timestamp));
+		return new LamportClock({ id: this.id, timestamp: h.now() });
+	}
+
+	static compare(a: LamportClock, b: LamportClock) {
+		// Calculate the "distance" based on the clock, ie. lower or greater
+
+		const timestamp = a.timestamp.compare(b.timestamp);
+		if (timestamp !== 0) return timestamp;
+
+		// If the sequence number is the same (concurrent events),
+		// and the IDs are different, take the one with a "lower" id
+		return compare(a.id, b.id);
+	}
+}

package/src/difference.ts

@@ -0,0 +1,22 @@
+export const difference = (a: any, b: any, key: string) => {
+	// Indices for quick lookups
+	const processed: { [key: string]: any } = {};
+	const existing: { [key: string]: any } = {};
+
+	// Create an index of the first collection
+	const addToIndex = (e: any) => (existing[key ? e[key] : e] = true);
+	a.forEach(addToIndex);
+
+	// Reduce to entries that are not in the first collection
+	const reducer = (res: any, entry: any) => {
+		const isInFirst = existing[key ? entry[key] : entry] !== undefined;
+		const hasBeenProcessed = processed[key ? entry[key] : entry] !== undefined;
+		if (!isInFirst && !hasBeenProcessed) {
+			res.push(entry);
+			processed[key ? entry[key] : entry] = true;
+		}
+		return res;
+	};
+
+	return b.reduce(reducer, []);
+};

package/src/encoding.ts

@@ -0,0 +1,27 @@
+import { AbstractType, deserialize, serialize } from "@dao-xyz/borsh";
+
+export interface Encoding<T> {
+	encoder: (data: T) => Uint8Array;
+	decoder: (bytes: Uint8Array) => T;
+}
+export const NO_ENCODING: Encoding<any> = {
+	encoder: (obj: Uint8Array) => {
+		if (obj instanceof Uint8Array === false) {
+			throw new Error(
+				"With NO_ENCODING only Uint8arrays are allowed, recieved: " +
+					(typeof obj === "object" ? obj.constructor.name : typeof obj)
+			);
+		}
+		return obj;
+	},
+	decoder: (bytes: Uint8Array) => {
+		return bytes;
+	},
+};
+
+export const BORSH_ENCODING = <T>(clazz: AbstractType<T>): Encoding<T> => {
+	return {
+		decoder: (bytes: Uint8Array) => deserialize(bytes, clazz),
+		encoder: (data: any) => serialize(data),
+	};
+};

package/src/entry-index.ts

@@ -0,0 +1,78 @@
+import { Cache } from "@peerbit/cache";
+import { Entry } from "./entry.js";
+import { deserialize } from "@dao-xyz/borsh";
+import { logger } from "./logger.js";
+import { Blocks } from "@peerbit/blocks-interface";
+
+export class EntryIndex<T> {
+	_cache: Cache<Entry<T> | null>;
+	_store: Blocks;
+	_init: (entry: Entry<T>) => void;
+	_index: Set<string>;
+
+	constructor(properties: {
+		store: Blocks;
+		init: (entry: Entry<T>) => void;
+		cache: Cache<Entry<T>>;
+	}) {
+		this._cache = properties.cache;
+		this._store = properties.store;
+		this._init = properties.init;
+		this._index = new Set();
+	}
+
+	async set(v: Entry<T>, toMultihash = true) {
+		if (toMultihash) {
+			const existingHash = v.hash;
+			v.hash = undefined as any;
+			try {
+				const hash = await Entry.toMultihash(this._store, v);
+				v.hash = existingHash;
+				if (v.hash === undefined) {
+					v.hash = hash; // can happen if you sync entries that you load directly from ipfs
+				} else if (existingHash !== v.hash) {
+					logger.error("Head hash didn't match the contents");
+					throw new Error("Head hash didn't match the contents");
+				}
+			} catch (error) {
+				logger.error(error);
+				throw error;
+			}
+		}
+		this._cache.add(v.hash, v);
+		this._index.add(v.hash);
+	}
+
+	async get(
+		k: string,
+		options?: { replicate?: boolean; timeout?: number }
+	): Promise<Entry<T> | undefined> {
+		if (this._index.has(k)) {
+			let mem = this._cache.get(k);
+			if (mem === undefined) {
+				mem = await this.getFromStore(k, options);
+				if (mem) {
+					this._init(mem);
+					mem.hash = k;
+				}
+				this._cache.add(k, mem);
+			}
+			return mem ? mem : undefined;
+		}
+		return undefined;
+	}
+
+	private async getFromStore(
+		k: string,
+		options?: { replicate?: boolean; timeout?: number }
+	): Promise<Entry<T> | null> {
+		const value = await this._store.get(k, options);
+		return value ? deserialize(value, Entry) : null;
+	}
+
+	async delete(k: string) {
+		this._cache.del(k);
+		this._index.delete(k);
+		return this._store.rm(k);
+	}
+}

package/src/entry-with-refs.ts

@@ -0,0 +1,6 @@
+import { Entry } from "./entry.js";
+
+export interface EntryWithRefs<T> {
+	entry: Entry<T>;
+	references: Entry<T>[];
+}