*Update dist

*remove wisdom query for now

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Lume Web
+Copyright (c) 2022 Hammer Technologies LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,2 +1 @@
-# dht-rpc-client
-A client library that uses hypercore and the @lumeweb/relay server along with Skynet for web, to perform "Wisdom of the crowd" RPC requests.
+# rpc-client

dist/error.d.ts

@@ -0,0 +1,2 @@
+export declare const ERR_INVALID_SIGNATURE = "INVALID_SIGNATURE";
+//# sourceMappingURL=error.d.ts.map

dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,sBAAsB,CAAC"}

dist/error.js

@@ -0,0 +1 @@
+export const ERR_INVALID_SIGNATURE = "INVALID_SIGNATURE";

dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./query/index.js";
+export * from "./network.js";
+export * from "./util.js";
+//# sourceMappingURL=index.d.ts.map

dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC"}

dist/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./query/index.js";
+export * from "./network.js";
+export * from "./util.js";

dist/network.d.ts

@@ -0,0 +1,34 @@
+import RpcNetworkQueryFactory from "./query/index.js";
+export default class RpcNetwork {
+  private _relaysAvailablePromise?;
+  private _relaysAvailableResolve?;
+  constructor(swarm?: any);
+  private _methods;
+  get methods(): Map<string, Set<string>>;
+  private _factory;
+  get factory(): RpcNetworkQueryFactory;
+  private _swarm;
+  get swarm(): any;
+  private _majorityThreshold;
+  get majorityThreshold(): number;
+  set majorityThreshold(value: number);
+  private _queryTimeout;
+  get queryTimeout(): number;
+  set queryTimeout(value: number);
+  private _relayTimeout;
+  get relayTimeout(): number;
+  set relayTimeout(value: number);
+  private _relays;
+  get relays(): Map<string, string[]>;
+  private _ready?;
+  get ready(): Promise<void>;
+  get readyWithRelays(): Promise<void>;
+  private _bypassCache;
+  get bypassCache(): boolean;
+  set bypassCache(value: boolean);
+  getAvailableRelay(module: string, method: string): any;
+  getRelay(pubkey: string): any;
+  private init;
+  private setupRelayPromise;
+}
+//# sourceMappingURL=network.d.ts.map

dist/network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../src/network.ts"],"names":[],"mappings":"AAEA,OAAO,sBAAsB,MAAM,kBAAkB,CAAC;AAItD,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,OAAO,CAAC,uBAAuB,CAAC,CAAgB;IAChD,OAAO,CAAC,uBAAuB,CAAC,CAAW;gBAC/B,KAAK,MAAmB;IAKpC,OAAO,CAAC,QAAQ,CAA4D;IAE5E,IAAI,OAAO,IAAI,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAEtC;IAED,OAAO,CAAC,QAAQ,CAAoC;IAEpD,IAAI,OAAO,IAAI,sBAAsB,CAEpC;IAED,OAAO,CAAC,MAAM,CAAoB;IAElC,IAAI,KAAK,QAER;IAED,OAAO,CAAC,kBAAkB,CAAQ;IAElC,IAAI,iBAAiB,IAAI,MAAM,CAE9B;IAED,IAAI,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAElC;IAED,OAAO,CAAC,aAAa,CAAM;IAE3B,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,IAAI,YAAY,CAAC,KAAK,EAAE,MAAM,EAE7B;IAED,OAAO,CAAC,aAAa,CAAK;IAE1B,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,IAAI,YAAY,CAAC,KAAK,EAAE,MAAM,EAE7B;IAED,OAAO,CAAC,OAAO,CAAiD;IAEhE,IAAI,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAElC;IAED,OAAO,CAAC,MAAM,CAAC,CAAgB;IAE/B,IAAI,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED,IAAI,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAEnC;IAED,OAAO,CAAC,YAAY,CAAkB;IAEtC,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,IAAI,WAAW,CAAC,KAAK,EAAE,OAAO,EAE7B;IAEM,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAchD,QAAQ,CAAC,MAAM,EAAE,MAAM;IAQ9B,OAAO,CAAC,IAAI;IA+CZ,OAAO,CAAC,iBAAiB;CAK1B"}

dist/network.js

@@ -0,0 +1,124 @@
+// @ts-ignore
+import Hyperswarm from "hyperswarm";
+import RpcNetworkQueryFactory from "./query/index.js";
+import b4a from "b4a";
+import { createHash, maybeGetAsyncProperty } from "./util.js";
+export default class RpcNetwork {
+    _relaysAvailablePromise;
+    _relaysAvailableResolve;
+    constructor(swarm = new Hyperswarm()) {
+        this._swarm = swarm;
+        this.init();
+    }
+    _methods = new Map();
+    get methods() {
+        return this._methods;
+    }
+    _factory = new RpcNetworkQueryFactory(this);
+    get factory() {
+        return this._factory;
+    }
+    _swarm;
+    get swarm() {
+        return this._swarm;
+    }
+    _majorityThreshold = 0.75;
+    get majorityThreshold() {
+        return this._majorityThreshold;
+    }
+    set majorityThreshold(value) {
+        this._majorityThreshold = value;
+    }
+    _queryTimeout = 30;
+    get queryTimeout() {
+        return this._queryTimeout;
+    }
+    set queryTimeout(value) {
+        this._queryTimeout = value;
+    }
+    _relayTimeout = 2;
+    get relayTimeout() {
+        return this._relayTimeout;
+    }
+    set relayTimeout(value) {
+        this._relayTimeout = value;
+    }
+    _relays = new Map();
+    get relays() {
+        return this._relays;
+    }
+    _ready;
+    get ready() {
+        if (!this._ready) {
+            this._ready = maybeGetAsyncProperty(this._swarm.dht).then((dht) => dht.ready());
+        }
+        return this._ready;
+    }
+    get readyWithRelays() {
+        return this.ready.then(() => this._relaysAvailablePromise);
+    }
+    _bypassCache = false;
+    get bypassCache() {
+        return this._bypassCache;
+    }
+    set bypassCache(value) {
+        this._bypassCache = value;
+    }
+    getAvailableRelay(module, method) {
+        method = `${module}.${method}`;
+        let relays = this._methods.get(method) ?? new Set();
+        if (!relays.size) {
+            throw Error("no available relay");
+        }
+        return this._relays.get(Array.from(relays)[Math.floor(Math.random() * relays.size)]);
+    }
+    getRelay(pubkey) {
+        if (this._relays.has(pubkey)) {
+            return this._relays.get(pubkey);
+        }
+        return undefined;
+    }
+    init() {
+        this._swarm.join(createHash("lumeweb"));
+        this.setupRelayPromise();
+        this._swarm.on("connection", async (relay) => {
+            const pubkey = b4a
+                .from(await maybeGetAsyncProperty(relay.remotePublicKey))
+                .toString("hex");
+            relay.once("close", () => {
+                this._methods.forEach((item) => {
+                    if (item.has(pubkey)) {
+                        item.delete(pubkey);
+                    }
+                });
+                this.relays.delete(pubkey);
+                if (!this._relays.size) {
+                    this.setupRelayPromise();
+                }
+            });
+            const query = this._factory.simple({
+                relay,
+                query: { module: "core", method: "get_methods", data: null },
+            });
+            const resp = await query.result;
+            if (resp.error) {
+                relay.end();
+                return;
+            }
+            if (resp.data) {
+                this._relays.set(pubkey, relay);
+                resp.data.forEach((item) => {
+                    const methods = this._methods.get(item) ?? new Set();
+                    methods.add(pubkey);
+                    this._methods.set(item, methods);
+                });
+                this._relaysAvailableResolve?.();
+            }
+        });
+    }
+    setupRelayPromise() {
+        this._relaysAvailablePromise = new Promise((resolve) => {
+            this._relaysAvailableResolve = resolve;
+        });
+    }
+}

dist/query/base.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import RpcNetwork from "../network.js";
+import { RpcQueryOptions } from "../types.js";
+import type {
+  ClientRPCRequest,
+  RPCRequest,
+  RPCResponse,
+} from "@lumeweb/interface-relay";
+export default abstract class RpcQueryBase {
+  protected _network: RpcNetwork;
+  protected _query: RPCRequest;
+  protected _options: RpcQueryOptions;
+  protected _promise?: Promise<any>;
+  protected _timeoutTimer?: any;
+  protected _timeout: boolean;
+  protected _completed: boolean;
+  protected _response?: RPCResponse;
+  protected _error?: string;
+  protected _promiseResolve?: (data: any) => void;
+  constructor({
+    network,
+    query,
+    options,
+  }: {
+    network: RpcNetwork;
+    query: ClientRPCRequest | RPCRequest;
+    options: RpcQueryOptions;
+  });
+  get result(): Promise<RPCResponse>;
+  protected handeTimeout(): void;
+  protected resolve(data?: RPCResponse, timeout?: boolean): void;
+  run(): this;
+  private _doRun;
+  protected setupRelayTimeout(reject: Function): NodeJS.Timeout;
+  protected abstract _run(): void;
+  protected queryRpc(rpc: any, request: RPCRequest): Promise<unknown>;
+}
+//# sourceMappingURL=base.d.ts.map

dist/query/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/query/base.ts"],"names":[],"mappings":";AACA,OAAO,UAAU,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EACV,gBAAgB,EAChB,UAAU,EACV,WAAW,EACZ,MAAM,0BAA0B,CAAC;AAElC,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,YAAY;IACxC,SAAS,CAAC,QAAQ,EAAE,UAAU,CAAC;IAC/B,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC;IAC7B,SAAS,CAAC,QAAQ,EAAE,eAAe,CAAC;IAEpC,SAAS,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IAClC,SAAS,CAAC,aAAa,CAAC,EAAE,GAAG,CAAC;IAC9B,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAS;IACpC,SAAS,CAAC,UAAU,EAAE,OAAO,CAAS;IACtC,SAAS,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC;IAClC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;gBAEpC,EACV,OAAO,EACP,KAAK,EACL,OAAY,GACb,EAAE;QACD,OAAO,EAAE,UAAU,CAAC;QACpB,KAAK,EAAE,gBAAgB,GAAG,UAAU,CAAC;QACrC,OAAO,EAAE,eAAe,CAAC;KAC1B;IAMD,IAAI,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC,CAEjC;IAED,SAAS,CAAC,YAAY;IAItB,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,OAAO,GAAE,OAAe,GAAG,IAAI;IAc9D,GAAG,IAAI,IAAI;YAmBJ,MAAM;IASpB,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC,OAAO;IAO7D,SAAS,CAAC,QAAQ,CAAC,IAAI,IAAI,IAAI;cAEf,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,UAAU;CAyBvD"}

dist/query/base.js

@@ -0,0 +1,84 @@
+import { clearTimeout, setTimeout } from "timers";
+export default class RpcQueryBase {
+    _network;
+    _query;
+    _options;
+    _promise;
+    _timeoutTimer;
+    _timeout = false;
+    _completed = false;
+    _response;
+    _error;
+    _promiseResolve;
+    constructor({ network, query, options = {}, }) {
+        this._network = network;
+        this._query = query;
+        this._options = options;
+    }
+    get result() {
+        return this._promise;
+    }
+    handeTimeout() {
+        this.resolve(undefined, true);
+    }
+    resolve(data, timeout = false) {
+        clearTimeout(this._timeoutTimer);
+        this._timeout = timeout;
+        this._completed = true;
+        if (timeout) {
+            data = {
+                error: "timeout",
+            };
+        }
+        this._promiseResolve?.(data);
+    }
+    run() {
+        this._promise =
+            this._promise ??
+                new Promise((resolve) => {
+                    this._promiseResolve = resolve;
+                });
+        this._timeoutTimer =
+            this._timeoutTimer ??
+                setTimeout(this.handeTimeout.bind(this), (this._options?.queryTimeout || this._network.queryTimeout) * 1000);
+        this._doRun();
+        return this;
+    }
+    async _doRun() {
+        try {
+            await this._network.ready;
+            await this._run();
+        }
+        catch (e) {
+            this._promiseResolve?.({ error: e?.message || e?.error });
+        }
+    }
+    setupRelayTimeout(reject) {
+        return setTimeout(() => {
+            this._error = "timeout";
+            reject("timeout");
+        }, (this._options.relayTimeout || this._network.relayTimeout) * 1000);
+    }
+    async queryRpc(rpc, request) {
+        let timer;
+        return new Promise((resolve, reject) => {
+            rpc
+                // @ts-ignore
+                .request(`${request.module}.${request.method}`, request.data)
+                .then((resp) => {
+                if (resp.error) {
+                    throw new Error(resp.error);
+                }
+                clearTimeout(timer);
+                this._response = resp;
+                resolve(null);
+            })
+                .catch((e) => {
+                this._error = e.message;
+                reject({ error: e.message });
+                clearTimeout(timer);
+            });
+            timer = this.setupRelayTimeout(reject);
+        });
+    }
+}

dist/query/clearCache.d.ts

@@ -0,0 +1,21 @@
+import RpcNetwork from "../network.js";
+import { RPCRequest } from "@lumeweb/interface-relay";
+import { RpcQueryOptions } from "../types.js";
+import SimpleRpcQuery from "./simple.js";
+export default class ClearCacheRpcQuery extends SimpleRpcQuery {
+  protected _relays: string[];
+  constructor({
+    network,
+    relays,
+    query,
+    options,
+  }: {
+    network: RpcNetwork;
+    relays: string[];
+    query: RPCRequest;
+    options: RpcQueryOptions;
+  });
+  protected _run(): Promise<void>;
+  protected queryRelay(): Promise<any>;
+}
+//# sourceMappingURL=clearCache.d.ts.map

dist/query/clearCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearCache.d.ts","sourceRoot":"","sources":["../../src/query/clearCache.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,eAAe,CAAC;AACvC,OAAO,EAAuB,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,cAAc,MAAM,aAAa,CAAC;AAEzC,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,cAAc;IAC5D,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;gBAEhB,EACV,OAAO,EACP,MAAM,EACN,KAAK,EACL,OAAO,GACR,EAAE;QACD,OAAO,EAAE,UAAU,CAAC;QACpB,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,KAAK,EAAE,UAAU,CAAC;QAClB,OAAO,EAAE,eAAe,CAAC;KAC1B;cAKe,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;cAOrB,UAAU,IAAI,OAAO,CAAC,GAAG,CAAC;CAiB3C"}

dist/query/clearCache.js

@@ -0,0 +1,29 @@
+import { hashQuery } from "../util.js";
+import SimpleRpcQuery from "./simple.js";
+export default class ClearCacheRpcQuery extends SimpleRpcQuery {
+    _relays;
+    constructor({ network, relays, query, options, }) {
+        super({ network, relay: "", query, options });
+        this._relays = relays;
+    }
+    async _run() {
+        // @ts-ignore
+        this._relay = getActiveRelay().stream.remotePublicKey;
+        await this.queryRelay();
+        await this.checkResponses();
+    }
+    async queryRelay() {
+        return this.queryRpc(this._network.getAvailableRelay("rpc", "broadcast_request"), {
+            module: "rpc",
+            method: "broadcast_request",
+            data: {
+                request: {
+                    module: "rpc",
+                    method: "clear_cached_item",
+                    data: hashQuery(this._query),
+                },
+                relays: this._relays,
+            },
+        });
+    }
+}

dist/query/index.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { ClientRPCRequest, RPCRequest } from "@lumeweb/interface-relay";
+import { RpcQueryOptions } from "../types.js";
+import SimpleRpcQuery from "./simple.js";
+import ClearCacheRpcQuery from "./clearCache.js";
+import RpcNetwork from "../network.js";
+import RpcQueryBase from "./base.js";
+export default class RpcNetworkQueryFactory {
+  private _network;
+  constructor(network: RpcNetwork);
+  simple({
+    relay,
+    query,
+    options,
+  }: {
+    relay?: string | Buffer;
+    query: ClientRPCRequest;
+    options?: RpcQueryOptions;
+  }): SimpleRpcQuery;
+  clearCache({
+    relays,
+    query,
+    options,
+  }: {
+    relays: string[];
+    query: RPCRequest;
+    options?: RpcQueryOptions;
+  }): ClearCacheRpcQuery;
+}
+export { RpcNetwork, RpcQueryBase, SimpleRpcQuery };
+//# sourceMappingURL=index.d.ts.map

dist/query/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/query/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,cAAc,MAAM,aAAa,CAAC;AACzC,OAAO,kBAAkB,MAAM,iBAAiB,CAAC;AACjD,OAAO,UAAU,MAAM,eAAe,CAAC;AACvC,OAAO,YAAY,MAAM,WAAW,CAAC;AAErC,MAAM,CAAC,OAAO,OAAO,sBAAsB;IACzC,OAAO,CAAC,QAAQ,CAAa;gBAEjB,OAAO,EAAE,UAAU;IAI/B,MAAM,CAAC,EACL,KAAK,EACL,KAAK,EACL,OAAY,GACb,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QACxB,KAAK,EAAE,gBAAgB,CAAC;QACxB,OAAO,CAAC,EAAE,eAAe,CAAC;KAC3B,GAAG,cAAc;IAYlB,UAAU,CAAC,EACT,MAAM,EACN,KAAK,EACL,OAAY,GACb,EAAE;QACD,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,KAAK,EAAE,UAAU,CAAC;QAClB,OAAO,CAAC,EAAE,eAAe,CAAC;KAC3B,GAAG,kBAAkB;CAQvB;AAED,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,cAAc,EAAE,CAAC"}

dist/query/index.js

@@ -0,0 +1,30 @@
+import SimpleRpcQuery from "./simple.js";
+import ClearCacheRpcQuery from "./clearCache.js";
+import RpcNetwork from "../network.js";
+import RpcQueryBase from "./base.js";
+export default class RpcNetworkQueryFactory {
+    _network;
+    constructor(network) {
+        this._network = network;
+    }
+    simple({ relay, query, options = {}, }) {
+        return new SimpleRpcQuery({
+            network: this._network,
+            relay,
+            query: {
+                ...query,
+                bypassCache: query?.bypassCache || this._network.bypassCache,
+            },
+            options,
+        }).run();
+    }
+    clearCache({ relays, query, options = {}, }) {
+        return new ClearCacheRpcQuery({
+            network: this._network,
+            query,
+            relays,
+            options,
+        }).run();
+    }
+}
+export { RpcNetwork, RpcQueryBase, SimpleRpcQuery };

dist/query/simple.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import RpcNetwork from "../network.js";
+import { ClientRPCRequest } from "@lumeweb/interface-relay";
+import { RpcQueryOptions } from "../types.js";
+import RpcQueryBase from "./base.js";
+export default class SimpleRpcQuery extends RpcQueryBase {
+  protected _relay?: string | any;
+  protected _query: ClientRPCRequest;
+  constructor({
+    network,
+    relay,
+    query,
+    options,
+  }: {
+    network: RpcNetwork;
+    relay?: string | Buffer | any;
+    query: ClientRPCRequest;
+    options: RpcQueryOptions;
+  });
+  protected _run(): Promise<void>;
+  protected queryRelay(): Promise<any>;
+  protected checkResponses(): Promise<void>;
+}
+//# sourceMappingURL=simple.d.ts.map

dist/query/simple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple.d.ts","sourceRoot":"","sources":["../../src/query/simple.ts"],"names":[],"mappings":";AAAA,OAAO,UAAU,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,gBAAgB,EAAe,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAW9C,OAAO,YAAY,MAAM,WAAW,CAAC;AAErC,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,YAAY;IACtD,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;IAChC,UAAkB,MAAM,EAAE,gBAAgB,CAAC;gBAE/B,EACV,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,GACR,EAAE;QACD,OAAO,EAAE,UAAU,CAAC;QACpB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,CAAC;QAC9B,KAAK,EAAE,gBAAgB,CAAC;QACxB,OAAO,EAAE,eAAe,CAAC;KAC1B;cASe,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;cAKrB,UAAU,IAAI,OAAO,CAAC,GAAG,CAAC;cAwD1B,cAAc;CAsB/B"}

dist/query/simple.js

@@ -0,0 +1,75 @@
+import b4a from "b4a";
+import { hashQuery, isPromise, maybeGetAsyncProperty, setupStream, validateTimestampedResponse, } from "../util.js";
+import { ERR_INVALID_SIGNATURE } from "../error.js";
+import RpcQueryBase from "./base.js";
+export default class SimpleRpcQuery extends RpcQueryBase {
+    _relay;
+    constructor({ network, relay, query, options, }) {
+        super({ network, query, options });
+        if (b4a.isBuffer(relay)) {
+            relay = b4a.from(relay).toString("hex");
+        }
+        this._relay = relay;
+    }
+    async _run() {
+        await this.queryRelay();
+        await this.checkResponses();
+    }
+    async queryRelay() {
+        let socket = this._relay;
+        if (socket) {
+            if (typeof socket === "string") {
+                try {
+                    const relay = this._network.getRelay(socket);
+                    if (this._network.getRelay(socket)) {
+                        socket = relay;
+                    }
+                }
+                catch { }
+            }
+            if (typeof socket === "string") {
+                try {
+                    socket = this._network.swarm.connect(b4a.from(this._relay, "hex"));
+                    if (isPromise(socket)) {
+                        socket = await socket;
+                    }
+                }
+                catch { }
+            }
+        }
+        if (!socket) {
+            socket = this._network.getAvailableRelay(this._query.module, this._query.method);
+        }
+        this._relay = socket;
+        await socket.opened;
+        const rpc = await setupStream(socket);
+        if (this._query.bypassCache) {
+            delete this._query.bypassCache;
+            await this.queryRpc(rpc, {
+                module: "rpc",
+                method: "clear_cached_item",
+                data: hashQuery(this._query),
+            });
+        }
+        if ("bypassCache" in this._query) {
+            delete this._query.bypassCache;
+        }
+        try {
+            await this.queryRpc(rpc, this._query);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async checkResponses() {
+        let response = this._response;
+        if (this._error) {
+            response = { error: this._error };
+        }
+        if (!response.error &&
+            !validateTimestampedResponse(b4a.from(await maybeGetAsyncProperty(this._relay.remotePublicKey), "hex"), response)) {
+            response = { error: ERR_INVALID_SIGNATURE };
+        }
+        this.resolve(response);
+    }
+}

dist/types.d.ts

@@ -0,0 +1,5 @@
+export interface RpcQueryOptions {
+  queryTimeout?: number;
+  relayTimeout?: number;
+}
+//# sourceMappingURL=types.d.ts.map

dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB"}

dist/types.js

@@ -0,0 +1 @@
+export {};

dist/util.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import type { RPCRequest, RPCResponse } from "@lumeweb/interface-relay";
+export declare const RPC_PROTOCOL_SYMBOL: unique symbol;
+export declare function isPromise(obj: Promise<any>): boolean;
+export declare function flatten(target: any, opts?: any): any[];
+export declare function validateResponse(
+  relay: Buffer,
+  response: RPCResponse,
+  timestamped?: boolean
+): boolean;
+export declare function validateTimestampedResponse(
+  relay: Buffer,
+  response: RPCResponse
+): boolean;
+export declare function hashQuery(query: RPCRequest): string;
+export declare function createHash(data: string): Buffer;
+export declare function setupStream(stream: any): Promise<any>;
+export declare function maybeGetAsyncProperty(object: any): Promise<any>;
+//# sourceMappingURL=util.d.ts.map

dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAOxE,eAAO,MAAM,mBAAmB,eAAwB,CAAC;AAEzD,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,WAM1C;AAKD,wBAAgB,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,GAAE,GAAQ,GAAG,GAAG,EAAE,CA0C1D;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,WAAW,EACrB,WAAW,UAAQ,GAClB,OAAO,CAkBT;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,WAAW,GACpB,OAAO,CAET;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAUnD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM/C;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,GAAG,gBAa5C;AAED,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,GAAG,gBAUtD"}

dist/util.js

@@ -0,0 +1,102 @@
+// @ts-ignore
+import stringify from "json-stringify-deterministic";
+// @ts-ignore
+import crypto from "hypercore-crypto";
+// @ts-ignore
+import sodium from "sodium-universal";
+import b4a from "b4a";
+import RPC from "@lumeweb/rpc";
+export const RPC_PROTOCOL_SYMBOL = Symbol.for("lumeweb");
+export function isPromise(obj) {
+    return (!!obj &&
+        (typeof obj === "object" || typeof obj === "function") &&
+        typeof obj.then === "function");
+}
+/*
+Forked from https://github.com/hughsk/flat
+ */
+export function flatten(target, opts = {}) {
+    opts = opts || {};
+    const delimiter = opts.delimiter || ".";
+    const maxDepth = opts.maxDepth;
+    const transformKey = opts.transformKey || ((key) => (isNaN(parseInt(key)) ? key : ""));
+    const output = [];
+    function step(object, prev, currentDepth) {
+        currentDepth = currentDepth || 1;
+        if (!Array.isArray(object)) {
+            object = Object.keys(object ?? {});
+        }
+        object.forEach(function (key) {
+            const value = object[key];
+            const isarray = opts.safe && Array.isArray(value);
+            const type = Object.prototype.toString.call(value);
+            const isbuffer = b4a.isBuffer(value);
+            const isobject = type === "[object Object]" || type === "[object Array]";
+            const newKey = prev
+                ? prev + delimiter + transformKey(key)
+                : transformKey(key);
+            if (!isarray &&
+                !isbuffer &&
+                isobject &&
+                Object.keys(value).length &&
+                (!opts.maxDepth || currentDepth < maxDepth)) {
+                return step(value, newKey, currentDepth + 1);
+            }
+            output.push(`${newKey}=${value}`);
+        });
+    }
+    step(target);
+    return output;
+}
+export function validateResponse(relay, response, timestamped = false) {
+    const field = response.signedField || "data";
+    // @ts-ignore
+    let json = response[field];
+    if (typeof json !== "string") {
+        json = stringify(json);
+    }
+    const updated = response.updated;
+    if (timestamped && updated) {
+        json = updated.toString() + json;
+    }
+    return !!crypto.verify(b4a.from(json), b4a.from(response.signature, "hex"), relay);
+}
+export function validateTimestampedResponse(relay, response) {
+    return validateResponse(relay, response, true);
+}
+export function hashQuery(query) {
+    const clonedQuery = {
+        module: query.module,
+        method: query.method,
+        data: query.data,
+    };
+    const queryHash = Buffer.allocUnsafe(32);
+    sodium.crypto_generichash(queryHash, Buffer.from(stringify(clonedQuery)));
+    return queryHash.toString("hex");
+}
+export function createHash(data) {
+    const buffer = b4a.from(data);
+    let hash = b4a.allocUnsafe(32);
+    sodium.crypto_generichash(hash, buffer);
+    return hash;
+}
+export async function setupStream(stream) {
+    const existing = stream[RPC_PROTOCOL_SYMBOL];
+    if (existing) {
+        await existing.ready;
+        return existing;
+    }
+    const rpc = new RPC(stream);
+    stream[RPC_PROTOCOL_SYMBOL] = rpc;
+    await rpc.ready;
+    return rpc;
+}
+export async function maybeGetAsyncProperty(object) {
+    if (typeof object === "function") {
+        object = object();
+    }
+    if (isPromise(object)) {
+        object = await object;
+    }
+    return object;
+}

package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@lumeweb/rpc-client",
+    "type": "module",
+    "version": "0.1.0",
+    "description": "",
+    "main": "dist/index.js",
+    "scripts": {
+        "build": "rimraf dist && tsc"
+    },
+    "devDependencies": {
+        "@lumeweb/interface-relay": "git+https://git.lumeweb.com/LumeWeb/interface-relay.git",
+        "@types/b4a": "^1.6.0",
+        "@types/express": "^4.17.14",
+        "@types/node": "^18.0.0",
+        "node-cache": "^5.1.2",
+        "prettier": "^2.7.1",
+        "typescript": "^4.7.4"
+    },
+    "dependencies": {
+        "@hyperswarm/dht": "^6.0.1",
+        "@lumeweb/rpc": "git+https://git.lumeweb.com/LumeWeb/rpc.git",
+        "b4a": "^1.6.1",
+        "hypercore-crypto": "^3.3.1",
+        "hyperswarm": "^4.3.7",
+        "json-stringify-deterministic": "^1.0.7",
+        "libskynet": "^0.0.61",
+        "msgpackr": "^1.6.1",
+        "sodium-universal": "^4.0.0"
+    }
+}

src/error.ts

@@ -0,0 +1 @@
+export const ERR_INVALID_SIGNATURE = "INVALID_SIGNATURE";

src/index.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./query/index.js";
+export * from "./network.js";
+export * from "./util.js";

src/network.ts

@@ -0,0 +1,169 @@
+// @ts-ignore
+import Hyperswarm from "hyperswarm";
+import RpcNetworkQueryFactory from "./query/index.js";
+import b4a from "b4a";
+import { createHash, maybeGetAsyncProperty } from "./util.js";
+
+export default class RpcNetwork {
+  private _relaysAvailablePromise?: Promise<void>;
+  private _relaysAvailableResolve?: Function;
+  constructor(swarm = new Hyperswarm()) {
+    this._swarm = swarm;
+    this.init();
+  }
+
+  private _methods: Map<string, Set<string>> = new Map<string, Set<string>>();
+
+  get methods(): Map<string, Set<string>> {
+    return this._methods;
+  }
+
+  private _factory = new RpcNetworkQueryFactory(this);
+
+  get factory(): RpcNetworkQueryFactory {
+    return this._factory;
+  }
+
+  private _swarm: typeof Hyperswarm;
+
+  get swarm() {
+    return this._swarm;
+  }
+
+  private _majorityThreshold = 0.75;
+
+  get majorityThreshold(): number {
+    return this._majorityThreshold;
+  }
+
+  set majorityThreshold(value: number) {
+    this._majorityThreshold = value;
+  }
+
+  private _queryTimeout = 30;
+
+  get queryTimeout(): number {
+    return this._queryTimeout;
+  }
+
+  set queryTimeout(value: number) {
+    this._queryTimeout = value;
+  }
+
+  private _relayTimeout = 2;
+
+  get relayTimeout(): number {
+    return this._relayTimeout;
+  }
+
+  set relayTimeout(value: number) {
+    this._relayTimeout = value;
+  }
+
+  private _relays: Map<string, any> = new Map<string, string[]>();
+
+  get relays(): Map<string, string[]> {
+    return this._relays;
+  }
+
+  private _ready?: Promise<void>;
+
+  get ready(): Promise<void> {
+    if (!this._ready) {
+      this._ready = maybeGetAsyncProperty(this._swarm.dht).then((dht: any) =>
+        dht.ready()
+      ) as Promise<void>;
+    }
+
+    return this._ready as Promise<void>;
+  }
+
+  get readyWithRelays(): Promise<void> {
+    return this.ready.then(() => this._relaysAvailablePromise);
+  }
+
+  private _bypassCache: boolean = false;
+
+  get bypassCache(): boolean {
+    return this._bypassCache;
+  }
+
+  set bypassCache(value: boolean) {
+    this._bypassCache = value;
+  }
+
+  public getAvailableRelay(module: string, method: string) {
+    method = `${module}.${method}`;
+
+    let relays = this._methods.get(method) ?? new Set();
+
+    if (!relays.size) {
+      throw Error("no available relay");
+    }
+
+    return this._relays.get(
+      Array.from(relays)[Math.floor(Math.random() * relays.size)]
+    );
+  }
+
+  public getRelay(pubkey: string) {
+    if (this._relays.has(pubkey)) {
+      return this._relays.get(pubkey);
+    }
+
+    return undefined;
+  }
+
+  private init() {
+    this._swarm.join(createHash("lumeweb"));
+    this.setupRelayPromise();
+
+    this._swarm.on("connection", async (relay: any) => {
+      const pubkey = b4a
+        .from(await maybeGetAsyncProperty(relay.remotePublicKey))
+        .toString("hex");
+      relay.once("close", () => {
+        this._methods.forEach((item) => {
+          if (item.has(pubkey)) {
+            item.delete(pubkey);
+          }
+        });
+        this.relays.delete(pubkey);
+
+        if (!this._relays.size) {
+          this.setupRelayPromise();
+        }
+      });
+
+      const query = this._factory.simple({
+        relay,
+        query: { module: "core", method: "get_methods", data: null },
+      });
+      const resp = await query.result;
+
+      if (resp.error) {
+        relay.end();
+        return;
+      }
+
+      if (resp.data) {
+        this._relays.set(pubkey, relay);
+
+        (resp.data as string[]).forEach((item) => {
+          const methods: Set<string> =
+            this._methods.get(item) ?? new Set<string>();
+
+          methods.add(pubkey);
+          this._methods.set(item, methods);
+        });
+        this._relaysAvailableResolve?.();
+      }
+    });
+  }
+
+  private setupRelayPromise() {
+    this._relaysAvailablePromise = new Promise<void>((resolve) => {
+      this._relaysAvailableResolve = resolve;
+    });
+  }
+}

src/query/base.ts

@@ -0,0 +1,121 @@
+import { clearTimeout, setTimeout } from "timers";
+import RpcNetwork from "../network.js";
+import { RpcQueryOptions } from "../types.js";
+import type {
+  ClientRPCRequest,
+  RPCRequest,
+  RPCResponse,
+} from "@lumeweb/interface-relay";
+
+export default abstract class RpcQueryBase {
+  protected _network: RpcNetwork;
+  protected _query: RPCRequest;
+  protected _options: RpcQueryOptions;
+
+  protected _promise?: Promise<any>;
+  protected _timeoutTimer?: any;
+  protected _timeout: boolean = false;
+  protected _completed: boolean = false;
+  protected _response?: RPCResponse;
+  protected _error?: string;
+  protected _promiseResolve?: (data: any) => void;
+
+  constructor({
+    network,
+    query,
+    options = {},
+  }: {
+    network: RpcNetwork;
+    query: ClientRPCRequest | RPCRequest;
+    options: RpcQueryOptions;
+  }) {
+    this._network = network;
+    this._query = query;
+    this._options = options;
+  }
+
+  get result(): Promise<RPCResponse> {
+    return this._promise as Promise<RPCResponse>;
+  }
+
+  protected handeTimeout() {
+    this.resolve(undefined, true);
+  }
+
+  protected resolve(data?: RPCResponse, timeout: boolean = false): void {
+    clearTimeout(this._timeoutTimer);
+    this._timeout = timeout;
+    this._completed = true;
+
+    if (timeout) {
+      data = {
+        error: "timeout",
+      };
+    }
+
+    this._promiseResolve?.(data);
+  }
+
+  public run(): this {
+    this._promise =
+      this._promise ??
+      new Promise<any>((resolve) => {
+        this._promiseResolve = resolve;
+      });
+
+    this._timeoutTimer =
+      this._timeoutTimer ??
+      setTimeout(
+        this.handeTimeout.bind(this),
+        (this._options?.queryTimeout || this._network.queryTimeout) * 1000
+      );
+
+    this._doRun();
+
+    return this;
+  }
+
+  private async _doRun() {
+    try {
+      await this._network.ready;
+      await this._run();
+    } catch (e: any) {
+      this._promiseResolve?.({ error: e?.message || e?.error });
+    }
+  }
+
+  protected setupRelayTimeout(reject: Function): NodeJS.Timeout {
+    return setTimeout(() => {
+      this._error = "timeout";
+      reject("timeout");
+    }, (this._options.relayTimeout || this._network.relayTimeout) * 1000) as NodeJS.Timeout;
+  }
+
+  protected abstract _run(): void;
+
+  protected async queryRpc(rpc: any, request: RPCRequest) {
+    let timer: NodeJS.Timeout;
+
+    return new Promise((resolve, reject) => {
+      rpc
+        // @ts-ignore
+        .request(`${request.module}.${request.method}`, request.data)
+        .then((resp: any) => {
+          if (resp.error) {
+            throw new Error(resp.error);
+          }
+          clearTimeout(timer as any);
+
+          this._response = resp;
+          resolve(null);
+        })
+        .catch((e: Error) => {
+          this._error = e.message;
+          reject({ error: e.message });
+          clearTimeout(timer as any);
+        });
+
+      timer = this.setupRelayTimeout(reject);
+    });
+  }
+}

src/query/clearCache.ts

@@ -0,0 +1,49 @@
+import RpcNetwork from "../network.js";
+import { RPCBroadcastRequest, RPCRequest } from "@lumeweb/interface-relay";
+import { RpcQueryOptions } from "../types.js";
+import { hashQuery } from "../util.js";
+import SimpleRpcQuery from "./simple.js";
+
+export default class ClearCacheRpcQuery extends SimpleRpcQuery {
+  protected _relays: string[];
+
+  constructor({
+    network,
+    relays,
+    query,
+    options,
+  }: {
+    network: RpcNetwork;
+    relays: string[];
+    query: RPCRequest;
+    options: RpcQueryOptions;
+  }) {
+    super({ network, relay: "", query, options });
+    this._relays = relays;
+  }
+
+  protected async _run(): Promise<void> {
+    // @ts-ignore
+    this._relay = getActiveRelay().stream.remotePublicKey;
+    await this.queryRelay();
+    await this.checkResponses();
+  }
+
+  protected async queryRelay(): Promise<any> {
+    return this.queryRpc(
+      this._network.getAvailableRelay("rpc", "broadcast_request"),
+      {
+        module: "rpc",
+        method: "broadcast_request",
+        data: {
+          request: {
+            module: "rpc",
+            method: "clear_cached_item",
+            data: hashQuery(this._query),
+          },
+          relays: this._relays,
+        } as RPCBroadcastRequest,
+      }
+    );
+  }
+}

src/query/index.ts

@@ -0,0 +1,53 @@
+import { ClientRPCRequest, RPCRequest } from "@lumeweb/interface-relay";
+import { RpcQueryOptions } from "../types.js";
+import SimpleRpcQuery from "./simple.js";
+import ClearCacheRpcQuery from "./clearCache.js";
+import RpcNetwork from "../network.js";
+import RpcQueryBase from "./base.js";
+
+export default class RpcNetworkQueryFactory {
+  private _network: RpcNetwork;
+
+  constructor(network: RpcNetwork) {
+    this._network = network;
+  }
+
+  simple({
+    relay,
+    query,
+    options = {},
+  }: {
+    relay?: string | Buffer;
+    query: ClientRPCRequest;
+    options?: RpcQueryOptions;
+  }): SimpleRpcQuery {
+    return new SimpleRpcQuery({
+      network: this._network,
+      relay,
+      query: {
+        ...query,
+        bypassCache: query?.bypassCache || this._network.bypassCache,
+      },
+      options,
+    }).run();
+  }
+
+  clearCache({
+    relays,
+    query,
+    options = {},
+  }: {
+    relays: string[];
+    query: RPCRequest;
+    options?: RpcQueryOptions;
+  }): ClearCacheRpcQuery {
+    return new ClearCacheRpcQuery({
+      network: this._network,
+      query,
+      relays,
+      options,
+    }).run();
+  }
+}
+
+export { RpcNetwork, RpcQueryBase, SimpleRpcQuery };

src/query/simple.ts

@@ -0,0 +1,122 @@
+import RpcNetwork from "../network.js";
+import { ClientRPCRequest, RPCResponse } from "@lumeweb/interface-relay";
+import { RpcQueryOptions } from "../types.js";
+import b4a from "b4a";
+import {
+  hashQuery,
+  isPromise,
+  maybeGetAsyncProperty,
+  setupStream,
+  validateTimestampedResponse,
+} from "../util.js";
+import RPC from "@lumeweb/rpc";
+import { ERR_INVALID_SIGNATURE } from "../error.js";
+import RpcQueryBase from "./base.js";
+
+export default class SimpleRpcQuery extends RpcQueryBase {
+  protected _relay?: string | any;
+  protected declare _query: ClientRPCRequest;
+
+  constructor({
+    network,
+    relay,
+    query,
+    options,
+  }: {
+    network: RpcNetwork;
+    relay?: string | Buffer | any;
+    query: ClientRPCRequest;
+    options: RpcQueryOptions;
+  }) {
+    super({ network, query, options });
+    if (b4a.isBuffer(relay)) {
+      relay = b4a.from(relay).toString("hex");
+    }
+
+    this._relay = relay;
+  }
+
+  protected async _run(): Promise<void> {
+    await this.queryRelay();
+    await this.checkResponses();
+  }
+
+  protected async queryRelay(): Promise<any> {
+    let socket = this._relay;
+
+    if (socket) {
+      if (typeof socket === "string") {
+        try {
+          const relay = this._network.getRelay(socket);
+          if (this._network.getRelay(socket)) {
+            socket = relay;
+          }
+        } catch {}
+      }
+
+      if (typeof socket === "string") {
+        try {
+          socket = this._network.swarm.connect(b4a.from(this._relay, "hex"));
+          if (isPromise(socket)) {
+            socket = await socket;
+          }
+        } catch {}
+      }
+    }
+
+    if (!socket) {
+      socket = this._network.getAvailableRelay(
+        this._query.module,
+        this._query.method
+      );
+    }
+
+    this._relay = socket;
+
+    await socket.opened;
+
+    const rpc = await setupStream(socket);
+
+    if (this._query.bypassCache) {
+      delete this._query.bypassCache;
+      await this.queryRpc(rpc, {
+        module: "rpc",
+        method: "clear_cached_item",
+        data: hashQuery(this._query),
+      });
+    }
+
+    if ("bypassCache" in this._query) {
+      delete this._query.bypassCache;
+    }
+
+    try {
+      await this.queryRpc(rpc, this._query);
+    } catch (e: any) {
+      throw e;
+    }
+  }
+
+  protected async checkResponses() {
+    let response: RPCResponse = this._response as RPCResponse;
+
+    if (this._error) {
+      response = { error: this._error };
+    }
+
+    if (
+      !response.error &&
+      !validateTimestampedResponse(
+        b4a.from(
+          await maybeGetAsyncProperty(this._relay.remotePublicKey),
+          "hex"
+        ) as Buffer,
+        response
+      )
+    ) {
+      response = { error: ERR_INVALID_SIGNATURE };
+    }
+
+    this.resolve(response);
+  }
+}

src/types.ts

@@ -0,0 +1,4 @@
+export interface RpcQueryOptions {
+  queryTimeout?: number;
+  relayTimeout?: number;
+}

src/util.ts

@@ -0,0 +1,143 @@
+// @ts-ignore
+import stringify from "json-stringify-deterministic";
+import type { RPCRequest, RPCResponse } from "@lumeweb/interface-relay";
+// @ts-ignore
+import crypto from "hypercore-crypto";
+// @ts-ignore
+import sodium from "sodium-universal";
+import b4a from "b4a";
+import RPC from "@lumeweb/rpc";
+export const RPC_PROTOCOL_SYMBOL = Symbol.for("lumeweb");
+
+export function isPromise(obj: Promise<any>) {
+  return (
+    !!obj &&
+    (typeof obj === "object" || typeof obj === "function") &&
+    typeof obj.then === "function"
+  );
+}
+
+/*
+Forked from https://github.com/hughsk/flat
+ */
+export function flatten(target: any, opts: any = {}): any[] {
+  opts = opts || {};
+
+  const delimiter = opts.delimiter || ".";
+  const maxDepth = opts.maxDepth;
+  const transformKey =
+    opts.transformKey || ((key: any) => (isNaN(parseInt(key)) ? key : ""));
+  const output: any[] = [];
+
+  function step(object: any, prev?: any, currentDepth?: any) {
+    currentDepth = currentDepth || 1;
+    if (!Array.isArray(object)) {
+      object = Object.keys(object ?? {});
+    }
+    object.forEach(function (key: any) {
+      const value = object[key];
+      const isarray = opts.safe && Array.isArray(value);
+      const type = Object.prototype.toString.call(value);
+      const isbuffer = b4a.isBuffer(value);
+      const isobject = type === "[object Object]" || type === "[object Array]";
+
+      const newKey = prev
+        ? prev + delimiter + transformKey(key)
+        : transformKey(key);
+
+      if (
+        !isarray &&
+        !isbuffer &&
+        isobject &&
+        Object.keys(value).length &&
+        (!opts.maxDepth || currentDepth < maxDepth)
+      ) {
+        return step(value, newKey, currentDepth + 1);
+      }
+
+      output.push(`${newKey}=${value}`);
+    });
+  }
+
+  step(target);
+
+  return output;
+}
+
+export function validateResponse(
+  relay: Buffer,
+  response: RPCResponse,
+  timestamped = false
+): boolean {
+  const field = response.signedField || "data";
+  // @ts-ignore
+  let json = response[field];
+  if (typeof json !== "string") {
+    json = stringify(json);
+  }
+  const updated = response.updated as number;
+
+  if (timestamped && updated) {
+    json = updated.toString() + json;
+  }
+
+  return !!crypto.verify(
+    b4a.from(json),
+    b4a.from(response.signature as string, "hex"),
+    relay
+  );
+}
+
+export function validateTimestampedResponse(
+  relay: Buffer,
+  response: RPCResponse
+): boolean {
+  return validateResponse(relay, response, true);
+}
+
+export function hashQuery(query: RPCRequest): string {
+  const clonedQuery: RPCRequest = {
+    module: query.module,
+    method: query.method,
+    data: query.data,
+  };
+  const queryHash = Buffer.allocUnsafe(32);
+  sodium.crypto_generichash(queryHash, Buffer.from(stringify(clonedQuery)));
+
+  return queryHash.toString("hex");
+}
+
+export function createHash(data: string): Buffer {
+  const buffer = b4a.from(data);
+  let hash = b4a.allocUnsafe(32) as Buffer;
+  sodium.crypto_generichash(hash, buffer);
+
+  return hash;
+}
+
+export async function setupStream(stream: any) {
+  const existing = stream[RPC_PROTOCOL_SYMBOL];
+  if (existing) {
+    await existing.ready;
+    return existing;
+  }
+
+  const rpc = new RPC(stream);
+  stream[RPC_PROTOCOL_SYMBOL] = rpc;
+
+  await rpc.ready;
+
+  return rpc;
+}
+
+export async function maybeGetAsyncProperty(object: any) {
+  if (typeof object === "function") {
+    object = object();
+  }
+
+  if (isPromise(object)) {
+    object = await object;
+  }
+
+  return object;
+}

tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "declaration": true,
+        "strict": true,
+        "module": "esnext",
+        "target": "esnext",
+        "esModuleInterop": true,
+        "sourceMap": false,
+        "rootDir": "src",
+        "outDir": "dist",
+        "typeRoots": [
+            "node_modules/@types",
+        ],
+        "moduleResolution": "node",
+        "declarationMap": true,
+        "declarationDir": "dist",
+        "emitDeclarationOnly": false,
+        "allowJs": true
+    },
+    "include": [
+        "src"
+    ]
+}