@peerbit/rpc 1.0.2

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./encoding.js";
+export * from "./io.js";
+export * from "./controller.js";
+export * from "./utils.js";

package/src/io.ts

@@ -0,0 +1,28 @@
+import {
+	X25519PublicKey,
+	Ed25519PublicKey,
+	PublicSignKey,
+	X25519Keypair,
+} from "@peerbit/crypto";
+import { logger as loggerFn } from "@peerbit/logger";
+
+export const logger = loggerFn({ module: "rpc" });
+export type RPCOptions<R> = {
+	amount?: number;
+	timeout?: number;
+	isTrusted?: (publicKey: PublicSignKey) => Promise<boolean>;
+	strict?: boolean;
+	onResponse?: (response: R, from?: PublicSignKey) => void;
+	stopper?: (stopper: () => void) => void;
+} & PublishOptions;
+
+export type PublishOptions = {
+	encryption?: {
+		key: X25519Keypair;
+		responders?: (X25519PublicKey | Ed25519PublicKey)[];
+	};
+	to?: PublicSignKey[] | string[];
+	strict?: boolean;
+};
+
+export type RPCResponse<R> = { response: R; from?: PublicSignKey };

package/src/utils.ts

@@ -0,0 +1,73 @@
+import { RPC } from "./controller";
+import { RPCOptions, RPCResponse } from "./io";
+export class MissingResponsesError extends Error {
+	constructor(message: string) {
+		super(message);
+	}
+}
+export const queryAll = <Q, R>(
+	rpc: RPC<Q, R>,
+	groups: string[][],
+	request: Q,
+	responseHandler: (response: RPCResponse<R>[]) => Promise<void> | void,
+	options?: RPCOptions<R> | undefined
+) => {
+	// In each shard/group only query a subset
+	groups = [...groups].filter(
+		(x) => !x.find((y) => y === rpc.node.identity.publicKey.hashcode())
+	);
+
+	let rng = Math.round(Math.random() * groups.length);
+	const startRng = rng;
+	const fn = async () => {
+		let missingReponses = false;
+		while (groups.length > 0) {
+			const peersToQuery: string[] = new Array(groups.length);
+			let counter = 0;
+			const peerToGroupIndex = new Map<string, number>();
+			for (let i = 0; i < groups.length; i++) {
+				const group = groups[i];
+				peersToQuery[counter] = group[rng % group.length];
+				peerToGroupIndex.set(peersToQuery[counter], i);
+				counter++;
+			}
+			if (peersToQuery.length > 0) {
+				const results = await rpc.request(request, {
+					...options,
+					to: peersToQuery,
+				});
+
+				for (const result of results) {
+					if (!result.from) {
+						throw new Error("Unexpected, missing from");
+					}
+					peerToGroupIndex.delete(result.from.hashcode());
+				}
+
+				await responseHandler(results);
+
+				const indicesLeft = new Set([...peerToGroupIndex.values()]);
+
+				rng += 1;
+				groups = groups.filter((v, ix) => {
+					if (indicesLeft.has(ix)) {
+						const peerIndex = rng % v.length;
+						if (rng === startRng || peerIndex === startRng % v.length) {
+							// TODO Last condition needed?
+							missingReponses = true;
+							return false;
+						}
+						return true;
+					}
+					return false;
+				});
+			}
+		}
+		if (missingReponses) {
+			throw new MissingResponsesError(
+				"Did not recieve responses from all shards"
+			);
+		}
+	};
+	return fn();
+};