@peerbit/rpc 1.0.2

package/lib/esm/encoding.js

@@ -0,0 +1,59 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { field, fixedArray, option, variant } from "@dao-xyz/borsh";
+import { MaybeEncrypted, X25519PublicKey } from "@peerbit/crypto";
+export let RPCMessage = class RPCMessage {
+};
+RPCMessage = __decorate([
+    variant(0)
+], RPCMessage);
+export let RequestV0 = class RequestV0 extends RPCMessage {
+    respondTo;
+    request;
+    constructor(properties) {
+        super();
+        this.respondTo = properties.respondTo;
+        this.request = properties.request;
+    }
+};
+__decorate([
+    field({ type: option(X25519PublicKey) }),
+    __metadata("design:type", X25519PublicKey)
+], RequestV0.prototype, "respondTo", void 0);
+__decorate([
+    field({ type: MaybeEncrypted }),
+    __metadata("design:type", MaybeEncrypted)
+], RequestV0.prototype, "request", void 0);
+RequestV0 = __decorate([
+    variant(0),
+    __metadata("design:paramtypes", [Object])
+], RequestV0);
+export let ResponseV0 = class ResponseV0 extends RPCMessage {
+    requestId;
+    response;
+    constructor(properties) {
+        super();
+        this.response = properties.response;
+        this.requestId = properties.requestId;
+    }
+};
+__decorate([
+    field({ type: fixedArray("u8", 32) }),
+    __metadata("design:type", Uint8Array)
+], ResponseV0.prototype, "requestId", void 0);
+__decorate([
+    field({ type: MaybeEncrypted }),
+    __metadata("design:type", MaybeEncrypted)
+], ResponseV0.prototype, "response", void 0);
+ResponseV0 = __decorate([
+    variant(1),
+    __metadata("design:paramtypes", [Object])
+], ResponseV0);
+//# sourceMappingURL=encoding.js.map

package/lib/esm/encoding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.js","sourceRoot":"","sources":["../../src/encoding.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAG3D,WAAe,UAAU,GAAzB,MAAe,UAAU;CAAG,CAAA;AAAb,UAAU;IAD/B,OAAO,CAAC,CAAC,CAAC;GACW,UAAU,CAAG;AAG5B,WAAM,SAAS,GAAf,MAAM,SAAU,SAAQ,UAAU;IAExC,SAAS,CAAmB;IAG5B,OAAO,CAAsB;IAE7B,YAAY,UAGX;QACA,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;QACtC,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;IACnC,CAAC;CACD,CAAA;AAbA;IADC,KAAK,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,eAAe,CAAC,EAAE,CAAC;8BAC7B,eAAe;4CAAC;AAG5B;IADC,KAAK,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC;8BACvB,cAAc;0CAAM;AALjB,SAAS;IADrB,OAAO,CAAC,CAAC,CAAC;;GACE,SAAS,CAerB;AAGM,WAAM,UAAU,GAAhB,MAAM,UAAW,SAAQ,UAAU;IAEzC,SAAS,CAAa;IAGtB,QAAQ,CAAsB;IAE9B,YAAY,UAGX;QACA,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;QACpC,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;IACvC,CAAC;CACD,CAAA;AAbA;IADC,KAAK,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC;8BAC3B,UAAU;6CAAC;AAGtB;IADC,KAAK,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC;8BACtB,cAAc;4CAAM;AALlB,UAAU;IADtB,OAAO,CAAC,CAAC,CAAC;;GACE,UAAU,CAetB"}

package/lib/esm/index.d.ts

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

package/lib/esm/index.js

@@ -0,0 +1,5 @@
+export * from "./encoding.js";
+export * from "./io.js";
+export * from "./controller.js";
+export * from "./utils.js";
+//# sourceMappingURL=index.js.map

package/lib/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC"}

package/lib/esm/io.d.ts

@@ -0,0 +1,22 @@
+import { X25519PublicKey, Ed25519PublicKey, PublicSignKey, X25519Keypair } from "@peerbit/crypto";
+export declare const logger: import("pino").Logger<import("pino").LoggerOptions | import("pino").DestinationStream>;
+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/lib/esm/io.js

@@ -0,0 +1,3 @@
+import { logger as loggerFn } from "@peerbit/logger";
+export const logger = loggerFn({ module: "rpc" });
+//# sourceMappingURL=io.js.map

package/lib/esm/io.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"io.js","sourceRoot":"","sources":["../../src/io.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,MAAM,IAAI,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,CAAC,MAAM,MAAM,GAAG,QAAQ,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC"}

package/lib/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/lib/esm/utils.d.ts

@@ -0,0 +1,6 @@
+import { RPC } from "./controller";
+import { RPCOptions, RPCResponse } from "./io";
+export declare class MissingResponsesError extends Error {
+    constructor(message: string);
+}
+export declare const queryAll: <Q, R>(rpc: RPC<Q, R>, groups: string[][], request: Q, responseHandler: (response: RPCResponse<R>[]) => Promise<void> | void, options?: RPCOptions<R> | undefined) => Promise<void>;

package/lib/esm/utils.js

@@ -0,0 +1,57 @@
+export class MissingResponsesError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+export const queryAll = (rpc, groups, request, responseHandler, options) => {
+    // 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 = new Array(groups.length);
+            let counter = 0;
+            const peerToGroupIndex = new Map();
+            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();
+};
+//# sourceMappingURL=utils.js.map

package/lib/esm/utils.js.map

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

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@peerbit/rpc",
+	"version": "1.0.2",
+	"description": "RPC calls for peers",
+	"type": "module",
+	"sideEffects": false,
+	"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__",
+		"!documentation",
+		"LICENSE"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"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 ../../../node_modules/.bin/jest test  -c  ../../../jest.config.ts --runInBand --forceExit",
+		"test:unit": "node ../../../node_modules/.bin/jest test  -c  ../../../jest.config.unit.ts --runInBand --forceExit",
+		"test:integration": "node ../node_modules/.bin/jest test -c  ../../../jest.config.integration.ts --runInBand --forceExit"
+	},
+	"author": "dao.xyz",
+	"license": "MIT",
+	"dependencies": {
+		"@dao-xyz/borsh": "^5.1.5",
+		"@peerbit/crypto": "1.0.1",
+		"@peerbit/logger": "1.0.0",
+		"@peerbit/program": "1.0.1",
+		"@peerbit/time": "1.0.0"
+	},
+	"devDependencies": {
+		"@peerbit/test-utils": "^1.0.2"
+	},
+	"gitHead": "595db9f1efebf604393eddfff5f678f5d8f16142"
+}

package/src/controller.ts

@@ -0,0 +1,413 @@
+import {
+	AbstractType,
+	BorshError,
+	deserialize,
+	serialize,
+	variant,
+} from "@dao-xyz/borsh";
+import {
+	DecryptedThing,
+	MaybeEncrypted,
+	PublicSignKey,
+	toBase64,
+	AccessError,
+	X25519PublicKey,
+	X25519Keypair,
+} from "@peerbit/crypto";
+import { RequestV0, ResponseV0, RPCMessage } from "./encoding.js";
+import { RPCOptions, logger, RPCResponse, PublishOptions } from "./io.js";
+import { AbstractProgram, Address } from "@peerbit/program";
+import {
+	PubSubData,
+	PublishOptions as PubSubPublishOptions,
+} from "@peerbit/pubsub-interface";
+import { ComposableProgram } from "@peerbit/program";
+import { DataMessage } from "@peerbit/stream-interface";
+import pDefer, { DeferredPromise } from "p-defer";
+import { waitFor } from "@peerbit/time";
+
+export type SearchContext = (() => Address) | AbstractProgram;
+export type CanRead = (key?: PublicSignKey) => Promise<boolean> | boolean;
+
+export type RPCSetupOptions<Q, R> = {
+	topic: string;
+	queryType: AbstractType<Q>;
+	responseType: AbstractType<R>;
+	canRead?: CanRead;
+	responseHandler?: ResponseHandler<Q, R>;
+	subscriptionData?: Uint8Array;
+};
+export type QueryContext = {
+	from?: PublicSignKey;
+	address: string;
+};
+export type ResponseHandler<Q, R> = (
+	query: Q,
+	context: QueryContext
+) => Promise<R | undefined> | R | undefined;
+
+const createValueResolver = <T>(
+	type: AbstractType<T> | Uint8Array
+): ((decryptedThings: DecryptedThing<T>) => T) => {
+	if ((type as any) === Uint8Array) {
+		return (decrypted) => decrypted._data as T;
+	} else {
+		return (decrypted) => decrypted.getValue(type as AbstractType<T>);
+	}
+};
+
+@variant("rpc")
+export class RPC<Q, R> extends ComposableProgram<RPCSetupOptions<Q, R>> {
+	canRead: CanRead;
+
+	private _subscribed = false;
+	private _responseHandler?: ResponseHandler<Q, (R | undefined) | R>;
+	private _responseResolver: Map<
+		string,
+		(properties: { response: ResponseV0; message: DataMessage }) => any
+	>;
+	private _requestType: AbstractType<Q> | Uint8ArrayConstructor;
+	private _responseType: AbstractType<R>;
+	private _rpcTopic: string | undefined;
+	private _onMessageBinded: ((arg: any) => any) | undefined = undefined;
+	private _subscriptionMetaData: Uint8Array | undefined;
+
+	private _keypair: X25519Keypair;
+
+	private _getResponseValueFn: (decrypted: DecryptedThing<R>) => R;
+	private _getRequestValueFn: (decrypted: DecryptedThing<Q>) => Q;
+
+	async open(args: RPCSetupOptions<Q, R>): Promise<void> {
+		this._rpcTopic = args.topic ?? this._rpcTopic;
+		this._responseHandler = args.responseHandler;
+		this._requestType = args.queryType;
+		this._responseType = args.responseType;
+		this._responseResolver = new Map();
+		this._subscriptionMetaData = args.subscriptionData;
+		this.canRead = args.canRead || (() => Promise.resolve(true));
+
+		this._getResponseValueFn = createValueResolver(this._responseType);
+		this._getRequestValueFn = createValueResolver(this._requestType);
+
+		this._keypair = await X25519Keypair.create();
+		await this._subscribe();
+	}
+
+	public async close(from?: AbstractProgram): Promise<boolean> {
+		if (this._subscribed) {
+			await this.node.services.pubsub.unsubscribe(this.rpcTopic);
+			await this.node.services.pubsub.removeEventListener(
+				"data",
+				this._onMessage
+			);
+			this._subscribed = false;
+		}
+
+		return super.close(from);
+	}
+
+	private _subscribing: Promise<void>;
+	private async _subscribe(): Promise<void> {
+		await this._subscribing;
+		if (this._subscribed) {
+			return;
+		}
+		this._subscribed = true;
+		this._onMessageBinded = this._onMessageBinded || this._onMessage.bind(this);
+		this._subscribing = this.node.services.pubsub
+			.subscribe(this.rpcTopic, { data: this._subscriptionMetaData })
+			.then(() => {
+				this.node.services.pubsub.addEventListener(
+					"data",
+					this._onMessageBinded!
+				);
+			});
+
+		await this._subscribing;
+		await this.node.services.pubsub.requestSubscribers(this.rpcTopic);
+
+		logger.debug("subscribing to query topic (responses): " + this.rpcTopic);
+	}
+
+	async _onMessage(
+		evt: CustomEvent<{ data: PubSubData; message: DataMessage }>
+	): Promise<void> {
+		const { data, message } = evt.detail;
+
+		if (data?.topics.find((x) => x === this.rpcTopic) != null) {
+			try {
+				const rpcMessage = deserialize(data.data, RPCMessage);
+				if (rpcMessage instanceof RequestV0) {
+					if (this._responseHandler) {
+						const maybeEncrypted = rpcMessage.request;
+						const decrypted = await maybeEncrypted.decrypt(this.node.keychain);
+
+						if (!(await this.canRead(message.sender))) {
+							throw new AccessError();
+						}
+
+						const response = await this._responseHandler(
+							this._getRequestValueFn(decrypted),
+							{
+								address: this.rpcTopic,
+								from: message.sender,
+							}
+						);
+
+						if (response && rpcMessage.respondTo) {
+							// send query and wait for replies in a generator like behaviour
+							const serializedResponse = serialize(response);
+
+							// we use the peerId/libp2p identity for signatures, since we want to be able to send a message
+							// with pubsub with a certain reciever. If we use (this.identity) we are going to use an identity
+							// that is now known in the .pubsub network, hence the message might not be delivired if we
+							// send with { to: [RECIEVER] } param
+
+							const decryptedMessage = new DecryptedThing<Uint8Array>({
+								data: serializedResponse,
+							});
+							let maybeEncryptedMessage: MaybeEncrypted<Uint8Array> =
+								decryptedMessage;
+
+							maybeEncryptedMessage = await decryptedMessage.encrypt(
+								this._keypair,
+								rpcMessage.respondTo
+							);
+
+							await this.node.services.pubsub.publish(
+								serialize(
+									new ResponseV0({
+										response: maybeEncryptedMessage,
+										requestId: message.id,
+									})
+								),
+								{
+									topics: [this.rpcTopic],
+									to: [message.sender],
+									strict: true,
+								}
+							);
+						}
+					}
+				} else if (rpcMessage instanceof ResponseV0) {
+					const id = toBase64(rpcMessage.requestId);
+					let handler = this._responseResolver.get(id);
+					if (!handler) {
+						handler = await waitFor(() => this._responseResolver.get(id));
+					}
+					handler!({
+						message,
+						response: rpcMessage,
+					});
+				}
+			} catch (error: any) {
+				if (error instanceof AccessError) {
+					logger.debug("Got message I could not decrypt");
+					return;
+				}
+
+				if (error instanceof BorshError) {
+					logger.error("Got message for a different namespace");
+					return;
+				}
+				logger.error(
+					"Error handling query: " +
+						(error?.message ? error?.message?.toString() : error)
+				);
+			}
+		}
+	}
+
+	private async seal(
+		request: Q,
+		respondTo?: X25519PublicKey,
+		options?: PublishOptions
+	) {
+		const requestData =
+			(this._requestType as any) === Uint8Array
+				? (request as Uint8Array)
+				: serialize(request);
+
+		const decryptedMessage = new DecryptedThing<Uint8Array>({
+			data: requestData,
+		});
+		let maybeEncryptedMessage: MaybeEncrypted<Uint8Array> = decryptedMessage;
+
+		if (
+			options?.encryption?.responders &&
+			options?.encryption?.responders.length > 0
+		) {
+			maybeEncryptedMessage = await decryptedMessage.encrypt(
+				options.encryption.key,
+				...options.encryption.responders
+			);
+		}
+
+		const requestMessage = new RequestV0({
+			request: maybeEncryptedMessage,
+			respondTo,
+		});
+
+		return requestMessage;
+	}
+
+	private getPublishOptions(options?: PublishOptions): PubSubPublishOptions {
+		return options?.to
+			? { to: options.to, strict: true, topics: [this.rpcTopic] }
+			: { topics: [this.rpcTopic] };
+	}
+
+	/**
+	 * Send message and don't expect any response
+	 * @param message
+	 * @param options
+	 */
+	public async send(message: Q, options?: PublishOptions): Promise<void> {
+		await this.node.services.pubsub.publish(
+			serialize(await this.seal(message, undefined, options)),
+			this.getPublishOptions(options)
+		);
+	}
+
+	private createResponseHandler(
+		promise: DeferredPromise<any>,
+		keypair: X25519Keypair,
+		allResults: RPCResponse<R>[],
+		responders: Set<string>,
+		expectedResponders?: Set<string>,
+		options?: RPCOptions<R>
+	) {
+		return async (properties: {
+			response: ResponseV0;
+			message: DataMessage;
+		}) => {
+			try {
+				const { response, message } = properties;
+				const from = message.sender;
+
+				if (options?.isTrusted && !(await options?.isTrusted(from))) {
+					return;
+				}
+
+				const maybeEncrypted = response.response;
+				const decrypted = await maybeEncrypted.decrypt(keypair);
+				const resultData = this._getResponseValueFn(decrypted);
+
+				if (expectedResponders) {
+					if (from && expectedResponders?.has(from.hashcode())) {
+						options?.onResponse && options?.onResponse(resultData, from);
+						allResults.push({ response: resultData, from });
+						responders.add(from.hashcode());
+						if (responders.size === expectedResponders.size) {
+							promise.resolve();
+						}
+					}
+				} else {
+					options?.onResponse && options?.onResponse(resultData, from);
+					allResults.push({ response: resultData, from });
+					if (
+						options?.amount != null &&
+						allResults.length >= (options?.amount as number)
+					) {
+						promise.resolve();
+					}
+				}
+			} catch (error) {
+				if (error instanceof AccessError) {
+					return; // Ignore things we can not open
+				}
+
+				if (error instanceof BorshError && !options?.strict) {
+					logger.debug("Namespace error");
+					return; // Name space conflict most likely
+				}
+
+				console.error("failed ot deserialize query response", error);
+				promise.reject(error);
+			}
+		};
+	}
+
+	/**
+	 * Send a request and expect a response
+	 * @param request
+	 * @param options
+	 * @returns
+	 */
+	public async request(
+		request: Q,
+		options?: RPCOptions<R>
+	): Promise<RPCResponse<R>[]> {
+		// We are generatinga new encryption keypair for each send, so we now that when we get the responses, they are encrypted specifcally for me, and for this request
+		// this allows us to easily disregard a bunch of message just beacuse they are for a different reciever!
+		const keypair = await X25519Keypair.create();
+
+		// send query and wait for replies in a generator like behaviour
+		let timeoutFn: any = undefined;
+
+		const requestMessage = await this.seal(request, keypair.publicKey, options);
+		const requestBytes = serialize(requestMessage);
+
+		const allResults: RPCResponse<R>[] = [];
+
+		const deferredPromise = pDefer();
+		options?.stopper && options.stopper(deferredPromise.resolve);
+		timeoutFn = setTimeout(() => {
+			deferredPromise.resolve();
+		}, options?.timeout || 10 * 1000);
+
+		const expectedResponders =
+			options?.to && options.to.length > 0
+				? new Set(
+						options.to.map((x) => (typeof x === "string" ? x : x.hashcode()))
+				  )
+				: undefined;
+
+		const responders = new Set<string>();
+
+		const id = toBase64(
+			await this.node.services.pubsub.publish(
+				requestBytes,
+				this.getPublishOptions(options)
+			)
+		);
+		this._responseResolver.set(
+			id,
+			this.createResponseHandler(
+				deferredPromise,
+				keypair,
+				allResults,
+				responders,
+				expectedResponders,
+				options
+			)
+		);
+
+		try {
+			await deferredPromise.promise;
+		} catch (error: any) {
+			// timeout
+			if (error.constructor.name != "TimeoutError") {
+				throw new Error(
+					"Got unexpected error when query: " + error.constructor.name
+				);
+			}
+		} finally {
+			clearTimeout(timeoutFn);
+		}
+
+		this._responseResolver.delete(id);
+		return allResults;
+	}
+
+	public get rpcTopic(): string {
+		if (!this._rpcTopic) {
+			throw new Error("Not initialized");
+		}
+		return this._rpcTopic;
+	}
+
+	getTopics(): string[] {
+		return [this.rpcTopic];
+	}
+}

package/src/encoding.ts

@@ -0,0 +1,41 @@
+import { field, fixedArray, option, variant } from "@dao-xyz/borsh";
+import { MaybeEncrypted, X25519PublicKey } from "@peerbit/crypto";
+
+@variant(0)
+export abstract class RPCMessage {}
+
+@variant(0)
+export class RequestV0 extends RPCMessage {
+	@field({ type: option(X25519PublicKey) })
+	respondTo?: X25519PublicKey;
+
+	@field({ type: MaybeEncrypted })
+	request: MaybeEncrypted<any>;
+
+	constructor(properties: {
+		request: MaybeEncrypted<any>;
+		respondTo?: X25519PublicKey;
+	}) {
+		super();
+		this.respondTo = properties.respondTo;
+		this.request = properties.request;
+	}
+}
+
+@variant(1)
+export class ResponseV0 extends RPCMessage {
+	@field({ type: fixedArray("u8", 32) })
+	requestId: Uint8Array;
+
+	@field({ type: MaybeEncrypted })
+	response: MaybeEncrypted<any>;
+
+	constructor(properties: {
+		response: MaybeEncrypted<any>;
+		requestId: Uint8Array;
+	}) {
+		super();
+		this.response = properties.response;
+		this.requestId = properties.requestId;
+	}
+}