@peerbit/blocks 1.1.7 → 2.0.2

package/src/libp2p.ts

@@ -1,63 +1,21 @@
-import { BlockStore } from "./store.js";
+import { BlockStore } from "./interface.js";
 import { Blocks as IBlocks } from "@peerbit/blocks-interface";
-import {
-	stringifyCid,
-	cidifyString,
-	codecCodes,
-	checkDecodeBlock
-} from "./block.js";
-import { variant, field, serialize, deserialize } from "@dao-xyz/borsh";
-import { CID } from "multiformats/cid";
-import { DataMessage } from "@peerbit/stream-interface";
 import { DirectStream } from "@peerbit/stream";
-
-import * as Block from "multiformats/block";
-import { PublicSignKey } from "@peerbit/crypto";
 import { DirectStreamComponents } from "@peerbit/stream";
-import { LevelBlockStore, MemoryLevelBlockStore } from "./level.js";
-import { Level } from "level";
+import { AnyBlockStore } from "./any-blockstore.js";
 import { GetOptions } from "@peerbit/blocks-interface";
-import PQueue from "p-queue";
-
-export class BlockMessage {}
-
-@variant(0)
-export class BlockRequest extends BlockMessage {
-	@field({ type: "string" })
-	cid: string;
-
-	constructor(cid: string) {
-		super();
-		this.cid = cid;
-	}
-}
-
-@variant(1)
-export class BlockResponse extends BlockMessage {
-	@field({ type: "string" })
-	cid: string;
-
-	@field({ type: Uint8Array })
-	bytes: Uint8Array;
-
-	constructor(cid: string, bytes: Uint8Array) {
-		super();
-		this.cid = cid;
-		this.bytes = bytes;
-	}
-}
+import { createStore } from "@peerbit/any-store";
+import { BlockMessage, RemoteBlocks } from "./remote.js";
+import { PublicSignKey } from "@peerbit/crypto";
+import { DataMessage } from "@peerbit/stream-interface";
+import { deserialize, serialize } from "@dao-xyz/borsh";
 
 export type DirectBlockComponents = DirectStreamComponents;
+
 export class DirectBlock extends DirectStream implements IBlocks {
-	private _localStore: BlockStore;
-	private _responseHandler?: (evt: CustomEvent<DataMessage>) => any;
-	private _resolvers: Map<string, (data: Uint8Array) => void>;
-	private _loadFetchQueue: PQueue;
-	private _readFromPeersPromises: Map<
-		string,
-		Promise<Block.Block<any, any, any, 1> | undefined> | undefined
-	>;
-	_open = false;
+	private remoteBlocks: RemoteBlocks;
+	private onDataFn: any;
+	private onPeerConnectedFn: any;
 
 	constructor(
 		components: DirectBlockComponents,
@@ -68,183 +26,75 @@ export class DirectBlock extends DirectStream implements IBlocks {
 			messageProcessingConcurrency?: number;
 		}
 	) {
-		super(components, ["direct-block/1.0.0"], {
-			emitSelf: false,
+		super(components, ["/lazyblock/0.0.0"], {
 			signaturePolicy: "StrictNoSign",
 			messageProcessingConcurrency: options?.messageProcessingConcurrency || 10,
-			canRelayMessage: options?.canRelayMessage ?? true
+			canRelayMessage: options?.canRelayMessage ?? true,
+			connectionManager: {
+				dialer: false,
+				pruner: false
+			}
 		});
-
-		const localTimeout = options?.localTimeout || 1000;
-		this._loadFetchQueue = new PQueue({
-			concurrency: options?.messageProcessingConcurrency || 10
+		this.remoteBlocks = new RemoteBlocks({
+			local: new AnyBlockStore(createStore(options?.directory)),
+			publish: (message) => this.publish(serialize(message)),
+			localTimeout: options?.localTimeout || 1000,
+			messageProcessingConcurrency: options?.messageProcessingConcurrency || 10,
+			waitFor: this.waitFor.bind(this)
 		});
-		this._localStore =
-			options?.directory != null
-				? new LevelBlockStore(new Level(options.directory))
-				: new MemoryLevelBlockStore();
-		this._resolvers = new Map();
-		this._readFromPeersPromises = new Map();
-		this._responseHandler = async (evt: CustomEvent<DataMessage>) => {
-			if (!evt) {
-				return;
-			}
-			const message = evt.detail;
-			try {
-				const decoded = deserialize(message.data, BlockMessage);
-				if (decoded instanceof BlockRequest && this._localStore) {
-					this._loadFetchQueue.add(() =>
-						this.handleFetchRequest(decoded, localTimeout)
-					);
-				} else if (decoded instanceof BlockResponse) {
-					// TODO make sure we are not storing too much bytes in ram (like filter large blocks)
 
-					this._resolvers.get(decoded.cid)?.(decoded.bytes);
-				}
-			} catch (error) {
-				console.error("Got error for libp2p block transport: ", error);
-				return; // timeout o r invalid cid
-			}
+		this.onDataFn = (data: CustomEvent<DataMessage>) => {
+			data.detail?.data &&
+				this.remoteBlocks.onMessage(
+					deserialize(data.detail.data!, BlockMessage)
+				);
 		};
+		this.onPeerConnectedFn = (evt: CustomEvent<PublicSignKey>) =>
+			this.remoteBlocks.onReachable(evt.detail);
 	}
 
 	async put(bytes: Uint8Array): Promise<string> {
-		if (!this._localStore) {
-			throw new Error("Local store not set");
-		}
-		return this._localStore!.put(bytes);
+		return this.remoteBlocks.put(bytes);
 	}
 
 	async has(cid: string) {
-		return this._localStore.has(cid);
+		return this.remoteBlocks.has(cid);
 	}
 	async get(
 		cid: string,
 		options?: GetOptions | undefined
 	): Promise<Uint8Array | undefined> {
-		const cidObject = cidifyString(cid);
-		let value = this._localStore
-			? await this._localStore.get(cid, options)
-			: undefined;
-
-		if (!value) {
-			// try to get it remotelly
-			value = await this._readFromPeers(cid, cidObject, options);
-			if (options?.replicate && value) {
-				this._localStore!.put(value);
-			}
-		}
-		return value;
+		return this.remoteBlocks.get(cid, options);
 	}
 
 	async rm(cid: string) {
-		await this._localStore?.rm(cid);
+		return this.remoteBlocks.rm(cid);
 	}
 
 	async *iterator(): AsyncGenerator<[string, Uint8Array], void, void> {
-		for await (const [key, value] of this._localStore.iterator()) {
+		for await (const [key, value] of this.remoteBlocks.iterator()) {
 			yield [key, value];
 		}
 	}
 
 	async start(): Promise<void> {
-		await this._localStore?.start();
+		this.addEventListener("data", this.onDataFn);
+		this.addEventListener("peer:reachable", this.onPeerConnectedFn);
 		await super.start();
-		this.addEventListener("data", this._responseHandler!);
-		this._open = true;
-	}
-
-	private async handleFetchRequest(
-		request: BlockRequest,
-		localTimeout: number
-	) {
-		const cid = stringifyCid(request.cid);
-		const bytes = await this._localStore.get(cid, {
-			timeout: localTimeout
-		});
-		if (!bytes) {
-			return;
-		}
-		const response = serialize(new BlockResponse(cid, bytes));
-		await this.publish(response);
-	}
-
-	private async _readFromPeers(
-		cidString: string,
-		cidObject: CID,
-		options: { timeout?: number; hasher?: any } = {}
-	): Promise<Uint8Array | undefined> {
-		const codec = codecCodes[cidObject.code];
-		let promise = this._readFromPeersPromises.get(cidString);
-		if (!promise) {
-			promise = new Promise<Block.Block<any, any, any, 1> | undefined>(
-				(resolve, reject) => {
-					const timeoutCallback = setTimeout(
-						() => {
-							resolve(undefined);
-						},
-						options.timeout || 30 * 1000
-					);
-
-					this._resolvers.set(cidString, async (bytes: Uint8Array) => {
-						const value = await checkDecodeBlock(cidObject, bytes, {
-							codec,
-							hasher: options?.hasher
-						});
-
-						clearTimeout(timeoutCallback);
-						this._resolvers.delete(cidString); // TODO concurrency might not work as expected here
-						resolve(value);
-					});
-				}
-			);
-
-			this._readFromPeersPromises.set(cidString, promise);
-
-			const publish = (to?: PublicSignKey[]) =>
-				this.publish(serialize(new BlockRequest(cidString)), { to: to });
-
-			const publishOnNewPeers = (e: CustomEvent<PublicSignKey>) => {
-				return publish([e.detail]);
-			};
-			this.addEventListener("peer:reachable", publishOnNewPeers);
-			await publish();
-
-			// we want to make sure that if some new peers join, we also try to ask them
-
-			const result = await promise;
-			this._readFromPeersPromises.delete(cidString);
-
-			// stop asking new peers, because we already got an response
-			this.removeEventListener("peer:reachable", publishOnNewPeers);
-			return result?.bytes;
-		} else {
-			const result = await promise;
-			return result?.bytes;
-		}
+		await this.remoteBlocks.start();
 	}
 
 	async stop(): Promise<void> {
-		// Dont listen for more incoming messages
-		this.removeEventListener("data", this._responseHandler);
-
-		// Wait for processing request
-		this._loadFetchQueue.clear();
-		await this._loadFetchQueue.onIdle(); // wait for pending
+		this.removeEventListener("data", this.onDataFn);
+		this.removeEventListener("peer:reachable", this.onPeerConnectedFn);
 		await super.stop();
-		await this._localStore?.stop();
-		this._readFromPeersPromises.clear();
-		this._resolvers.clear();
-		this._open = false;
-
-		// we dont cleanup subscription because we dont know if someone else is sbuscribing also
+		await this.remoteBlocks.stop();
 	}
 
+	async size() {
+		return this.remoteBlocks?.size() || 0;
+	}
 	get status() {
-		if (this._open) {
-			return this._localStore?.status() || this.started;
-		} else {
-			return "closed";
-		}
+		return this.remoteBlocks?.status || this.started;
 	}
 }

package/src/remote.ts

@@ -0,0 +1,298 @@
+import { BlockStore } from "./interface.js";
+import { Blocks as IBlocks } from "@peerbit/blocks-interface";
+import {
+	stringifyCid,
+	cidifyString,
+	codecCodes,
+	checkDecodeBlock
+} from "./block.js";
+import { variant, field, serialize, deserialize } from "@dao-xyz/borsh";
+import { CID } from "multiformats/cid";
+import * as Block from "multiformats/block";
+import { PublicSignKey } from "@peerbit/crypto";
+import { AnyBlockStore } from "./any-blockstore.js";
+import { GetOptions } from "@peerbit/blocks-interface";
+import PQueue from "p-queue";
+import { AbortError } from "@peerbit/time";
+import type { PeerId } from "@libp2p/interface/peer-id";
+import { TypedEventEmitter, CustomEvent } from "@libp2p/interface";
+
+export class BlockMessage {}
+
+@variant(0)
+export class BlockRequest extends BlockMessage {
+	@field({ type: "string" })
+	cid: string;
+
+	constructor(cid: string) {
+		super();
+		this.cid = cid;
+	}
+}
+
+@variant(1)
+export class BlockResponse extends BlockMessage {
+	@field({ type: "string" })
+	cid: string;
+
+	@field({ type: Uint8Array })
+	bytes: Uint8Array;
+
+	constructor(cid: string, bytes: Uint8Array) {
+		super();
+		this.cid = cid;
+		this.bytes = bytes;
+	}
+}
+
+export class RemoteBlocks implements IBlocks {
+	localStore: BlockStore;
+
+	private _responseHandler?: (data: BlockMessage) => any;
+	private _resolvers: Map<string, (data: Uint8Array) => void>;
+	private _loadFetchQueue: PQueue;
+	private _readFromPeersPromises: Map<
+		string,
+		Promise<Block.Block<any, any, any, 1> | undefined> | undefined
+	>;
+	_open = false;
+	private _events: TypedEventEmitter<{
+		"peer:reachable": CustomEvent<PublicSignKey>;
+	}>;
+	private closeController: AbortController;
+
+	constructor(
+		readonly options: {
+			local: AnyBlockStore;
+			localTimeout?: number;
+			messageProcessingConcurrency?: number;
+			publish: (
+				message: BlockRequest | BlockResponse,
+				options?: { to?: string[] }
+			) => Promise<Uint8Array | void>;
+			waitFor(peer: PeerId | PublicSignKey): Promise<void>;
+		}
+	) {
+		const localTimeout = options?.localTimeout || 1000;
+		this._loadFetchQueue = new PQueue({
+			concurrency: options?.messageProcessingConcurrency || 10
+		});
+		this.localStore = options?.local;
+		this._resolvers = new Map();
+		this._readFromPeersPromises = new Map();
+		/* this._responseHandler = (async (evt: CustomEvent<DataMessage>) => {
+			if (!evt) {
+				return;
+			}
+			const message = evt.detail;
+			if (!message.data) {
+				return;
+			}
+
+			try {
+				const decoded = deserialize(message.data, BlockMessage);
+				if (decoded instanceof BlockRequest && this._localStore) {
+					this._loadFetchQueue.add(() =>
+						this.handleFetchRequest(decoded, localTimeout)
+					);
+				} else if (decoded instanceof BlockResponse) {
+					// TODO make sure we are not storing too much bytes in ram (like filter large blocks)
+
+					this._resolvers.get(decoded.cid)?.(decoded.bytes);
+				}
+			} catch (error) {
+				console.error("Got error for libp2p block transport: ", error);
+				return; // timeout o r invalid cid
+			}
+		}) */
+
+		this._responseHandler = async (message: BlockMessage) => {
+			try {
+				if (message instanceof BlockRequest && this.localStore) {
+					this._loadFetchQueue.add(() =>
+						this.handleFetchRequest(message, localTimeout)
+					);
+				} else if (message instanceof BlockResponse) {
+					// TODO make sure we are not storing too much bytes in ram (like filter large blocks)
+
+					this._resolvers.get(message.cid)?.(message.bytes);
+				}
+			} catch (error) {
+				console.error("Got error for libp2p block transport: ", error);
+				return; // timeout o r invalid cid
+			}
+		};
+	}
+
+	async put(bytes: Uint8Array): Promise<string> {
+		if (!this.localStore) {
+			throw new Error("Local store not set");
+		}
+		return this.localStore!.put(bytes);
+	}
+
+	async has(cid: string) {
+		return this.localStore.has(cid);
+	}
+	async get(
+		cid: string,
+		options?: GetOptions | undefined
+	): Promise<Uint8Array | undefined> {
+		const cidObject = cidifyString(cid);
+		let value = this.localStore
+			? await this.localStore.get(cid, options)
+			: undefined;
+
+		if (!value) {
+			// try to get it remotelly
+			value = await this._readFromPeers(cid, cidObject, options);
+			if (options?.replicate && value) {
+				this.localStore!.put(value);
+			}
+		}
+		return value;
+	}
+
+	async rm(cid: string) {
+		await this.localStore?.rm(cid);
+	}
+
+	async *iterator(): AsyncGenerator<[string, Uint8Array], void, void> {
+		for await (const [key, value] of this.localStore.iterator()) {
+			yield [key, value];
+		}
+	}
+
+	async start(): Promise<void> {
+		this._events = new TypedEventEmitter();
+		this.closeController = new AbortController();
+		await this.localStore?.start();
+		this._open = true;
+	}
+
+	onMessage(data: BlockMessage) {
+		return this._responseHandler!(data);
+	}
+	onReachable(publicKey: PublicSignKey) {
+		this._events.dispatchEvent(
+			new CustomEvent("peer:reachable", { detail: publicKey })
+		);
+	}
+
+	private async handleFetchRequest(
+		request: BlockRequest,
+		localTimeout: number
+	) {
+		const cid = stringifyCid(request.cid);
+		const bytes = await this.localStore.get(cid, {
+			timeout: localTimeout
+		});
+		if (!bytes) {
+			return;
+		}
+		await this.options.publish(new BlockResponse(cid, bytes));
+	}
+
+	private async _readFromPeers(
+		cidString: string,
+		cidObject: CID,
+		options: { timeout?: number; hasher?: any; from?: string[] } = {}
+	): Promise<Uint8Array | undefined> {
+		const codec = codecCodes[cidObject.code];
+		let promise = this._readFromPeersPromises.get(cidString);
+		if (!promise) {
+			promise = new Promise<Block.Block<any, any, any, 1> | undefined>(
+				(resolve, reject) => {
+					const timeoutCallback = setTimeout(
+						() => {
+							resolve(undefined);
+						},
+						options.timeout || 30 * 1000
+					);
+					const abortHandler = () => {
+						clearTimeout(timeoutCallback);
+						this._resolvers.delete(cidString);
+						this.closeController.signal.removeEventListener(
+							"abort",
+							abortHandler
+						);
+						reject(new AbortError());
+					};
+					this.closeController.signal.addEventListener("abort", abortHandler);
+
+					this._resolvers.set(cidString, async (bytes: Uint8Array) => {
+						const value = await checkDecodeBlock(cidObject, bytes, {
+							codec,
+							hasher: options?.hasher
+						});
+
+						clearTimeout(timeoutCallback);
+						this._resolvers.delete(cidString); // TODO concurrency might not work as expected here
+						this.closeController.signal.removeEventListener(
+							"abort",
+							abortHandler
+						);
+						resolve(value);
+					});
+				}
+			);
+
+			this._readFromPeersPromises.set(cidString, promise);
+
+			const publish = (to: string) => {
+				if (!options?.from || options.from.includes(to))
+					this.options.publish(new BlockRequest(cidString), { to: [to] });
+			};
+
+			const publishOnNewPeers = (e: CustomEvent<PublicSignKey>) => {
+				return publish(e.detail.hashcode());
+			};
+			this._events.addEventListener("peer:reachable", publishOnNewPeers);
+			this.options.publish(new BlockRequest(cidString), {
+				to: options.from
+			});
+
+			// we want to make sure that if some new peers join, we also try to ask them
+
+			const result = await promise;
+			this._readFromPeersPromises.delete(cidString);
+
+			// stop asking new peers, because we already got an response
+			this._events.removeEventListener("peer:reachable", publishOnNewPeers);
+			return result?.bytes;
+		} else {
+			const result = await promise;
+			return result?.bytes;
+		}
+	}
+
+	async stop(): Promise<void> {
+		// Dont listen for more incoming messages
+
+		// Wait for processing request
+		this.closeController.abort();
+		this._loadFetchQueue.clear();
+		await this._loadFetchQueue.onIdle(); // wait for pending
+		await this.localStore?.stop();
+		this._readFromPeersPromises.clear();
+		this._resolvers.clear();
+		this._open = false;
+		// we dont cleanup subscription because we dont know if someone else is sbuscribing also
+	}
+
+	waitFor(peer: PeerId | PublicSignKey): Promise<void> {
+		return this.options.waitFor(peer);
+	}
+
+	async size() {
+		return this.localStore.size();
+	}
+
+	get status() {
+		if (this._open) {
+			return this.localStore?.status();
+		} else {
+			return "closed";
+		}
+	}
+}

package/lib/esm/level.js.map

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

package/lib/esm/store.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=store.js.map

package/lib/esm/store.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"store.js","sourceRoot":"","sources":["../../src/store.ts"],"names":[],"mappings":""}

package/lib/esm/streams.d.ts

@@ -1 +0,0 @@
-export declare const x = 123;

package/lib/esm/streams.js

@@ -1,2 +0,0 @@
-export const x = 123;
-//# sourceMappingURL=streams.js.map

package/lib/esm/streams.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"streams.js","sourceRoot":"","sources":["../../src/streams.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC"}

package/src/streams.ts

@@ -1 +0,0 @@
-export const x = 123;