dist/index.d.ts

@@ -1,27 +1,50 @@
 /// <reference types="node" />
 import { ErrTuple } from "libskynet";
-import type {
+import type { RPCRequest, RPCResponse } from "@lumeweb/relay-types";
-  RPCRequest,
+import {
-  RPCResponse,
+  RpcQueryOptions,
-  ClientRPCRequest,
+  StreamHandlerFunction,
-} from "@lumeweb/interface-relay";
+  StreamingRpcQueryOptions,
-import { RpcQueryOptions } from "@lumeweb/rpc-client";
+} from "@lumeweb/dht-rpc-client";
 import { Buffer } from "buffer";
-import { Client } from "@lumeweb/libkernel-universal";
+export declare class RpcNetwork {
-export declare class RpcNetwork extends Client {
+  private _actionQueue;
+  private _addQueue;
+  private _removeQueue;
   private _def;
   constructor(def?: boolean);
   private _networkId;
   get networkId(): number;
   get ready(): Promise<ErrTuple>;
+  private static deleteItem;
+  addRelay(pubkey: string): void;
+  removeRelay(pubkey: string): void;
+  clearRelays(): void;
+  wisdomQuery(
+    method: string,
+    module: string,
+    data?: object | any[],
+    bypassCache?: boolean,
+    options?: RpcQueryOptions
+  ): WisdomRpcQuery;
+  streamingQuery(
+    relay: Buffer | string,
+    method: string,
+    module: string,
+    streamHandler: StreamHandlerFunction,
+    data?: object | any[],
+    options?: RpcQueryOptions
+  ): StreamingRpcQuery;
   simpleQuery(
     relay: Buffer | string,
-    query: ClientRPCRequest,
+    method: string,
+    module: string,
     data?: object | any[],
     options?: RpcQueryOptions
   ): SimpleRpcQuery;
+  processQueue(): Promise<void>;
 }
-export declare abstract class RpcQueryBase extends Client {
+export declare abstract class RpcQueryBase {
   protected _promise?: Promise<any>;
   protected _network: RpcNetwork;
   protected _query: RPCRequest;
@@ -38,18 +61,32 @@ export declare abstract class RpcQueryBase extends Client {
 }
 export declare class SimpleRpcQuery extends RpcQueryBase {
   protected _relay: string | Buffer;
-  constructor({
+  constructor(
-    network,
+    network: RpcNetwork,
-    relay,
+    relay: string | Buffer,
-    query,
+    query: RPCRequest,
-    options,
+    options: RpcQueryOptions
-  }: {
+  );
-    network: RpcNetwork;
-    relay: string | Buffer;
-    query: RPCRequest;
-    options: RpcQueryOptions;
-  });
   run(): this;
 }
-export declare const createClient: (...args: any) => RpcNetwork;
+export declare class StreamingRpcQuery extends SimpleRpcQuery {
+  protected _options: StreamingRpcQueryOptions;
+  private _sendUpdate?;
+  constructor(
+    network: RpcNetwork,
+    relay: string | Buffer,
+    query: RPCRequest,
+    options: StreamingRpcQueryOptions
+  );
+  cancel(): void;
+  run(): this;
+  get result(): Promise<RPCResponse>;
+}
+export declare class WisdomRpcQuery extends RpcQueryBase {
+  constructor(
+    network: RpcNetwork,
+    query: RPCRequest,
+    options?: RpcQueryOptions
+  );
+}
 //# sourceMappingURL=index.d.ts.map

dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,gBAAgB,EACjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,MAAM,EAAW,MAAM,8BAA8B,CAAC;AAI/D,qBAAa,UAAW,SAAQ,MAAM;IACpC,OAAO,CAAC,IAAI,CAAU;gBAEV,GAAG,GAAE,OAAc;IAK/B,OAAO,CAAC,UAAU,CAAa;IAE/B,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,KAAK,IAAI,OAAO,CAAC,QAAQ,CAAC,CAY7B;IACM,WAAW,CAChB,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,KAAK,EAAE,gBAAgB,EACvB,IAAI,GAAE,MAAM,GAAG,GAAG,EAAO,EACzB,OAAO,GAAE,eAAoB,GAC5B,cAAc;CAQlB;AAED,8BAAsB,YAAa,SAAQ,MAAM;IAC/C,SAAS,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IAClC,SAAS,CAAC,QAAQ,EAAE,UAAU,CAAC;IAC/B,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC;IAC7B,SAAS,CAAC,QAAQ,EAAE,eAAe,CAAC;IACpC,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;gBAG3B,OAAO,EAAE,UAAU,EACnB,KAAK,EAAE,UAAU,EACjB,OAAO,6BAAsB,EAC7B,SAAS,EAAE,MAAM;IASnB,IAAI,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC,CAQjC;IAEM,GAAG,IAAI,IAAI;CASnB;AAED,qBAAa,cAAe,SAAQ,YAAY;IAC9C,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;gBACtB,EACV,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,GACR,EAAE;QACD,OAAO,EAAE,UAAU,CAAC;QACpB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QACvB,KAAK,EAAE,UAAU,CAAC;QAClB,OAAO,EAAE,eAAe,CAAC;KAC1B;IAIM,GAAG,IAAI,IAAI;CAUnB;AAED,eAAO,MAAM,YAAY,8BAA8C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

dist/index.js

@@ -1,9 +1,26 @@
-import { Client, factory } from "@lumeweb/libkernel-universal";
+const RPC_MODULE = "AQDaEPIo_lpdvz7AKbeafERBHR331RiyvweJ6OrFTplzyg";
-const RPC_MODULE = "fAAgZfXMqN3YOn0-b9DICt8OPsOFeWw3YKY2p84aytzBww";
+let callModule, connectModule;
-export class RpcNetwork extends Client {
+async function loadLibs() {
+    if (callModule && connectModule) {
+        return;
+    }
+    if (typeof window !== "undefined" && window?.document) {
+        const pkg = await import("libkernel");
+        callModule = pkg.callModule;
+        connectModule = pkg.connectModule;
+    }
+    else {
+        const pkg = await import("libkmodule");
+        callModule = pkg.callModule;
+        connectModule = pkg.connectModule;
+    }
+}
+export class RpcNetwork {
+    _actionQueue = [];
+    _addQueue = [];
+    _removeQueue = [];
     _def;
     constructor(def = true) {
-        super();
         this._def = def;
     }
     _networkId = 0;
@@ -11,72 +28,163 @@ export class RpcNetwork extends Client {
         return this._networkId;
     }
     get ready() {
+        let promise = loadLibs();
         if (this._def) {
             this._networkId = 1;
         }
         else {
-            Promise.resolve()
+            promise = promise
-                .then(() => this.callModuleReturn(RPC_MODULE, "createNetwork"))
+                .then(() => callModule(RPC_MODULE, "createNetwork"))
                 .then((ret) => (this._networkId = ret[0]));
         }
-        return this.callModuleReturn("ready", {
+        return promise.then(() => callModule(RPC_MODULE, "ready", { network: this._networkId }));
+    }
+    static deleteItem(array, item) {
+        if (array.includes(item)) {
+            let queue = new Set(array);
+            queue.delete(item);
+            [].splice.apply(array, [0, array.length].concat([...queue]));
+        }
+    }
+    addRelay(pubkey) {
+        this._addQueue.push(pubkey);
+        this._addQueue = [...new Set(this._addQueue)];
+        RpcNetwork.deleteItem(this._removeQueue, pubkey);
+    }
+    removeRelay(pubkey) {
+        this._removeQueue.push(pubkey);
+        this._removeQueue = [...new Set(this._removeQueue)];
+        RpcNetwork.deleteItem(this._addQueue, pubkey);
+    }
+    clearRelays() {
+        this._actionQueue.push(["clearRelays", {}]);
+    }
+    wisdomQuery(method, module, data = {}, bypassCache = false, options = {}) {
+        return new WisdomRpcQuery(this, {
+            method,
+            module,
+            data,
+            bypassCache,
+        }, options).run();
+    }
+    streamingQuery(relay, method, module, streamHandler, data = {}, options = {}) {
+        return new StreamingRpcQuery(this, relay, { method, module, data }, { streamHandler, ...options }).run();
+    }
+    simpleQuery(relay, method, module, data = {}, options = {}) {
+        return new SimpleRpcQuery(this, relay, {
+            method,
+            module,
+            data,
+        }, options).run();
+    }
+    async processQueue() {
+        await loadLibs();
+        for (const action of this._actionQueue) {
+            try {
+                await callModule(RPC_MODULE, action[0], {
+                    ...action[1],
                     network: this._networkId,
                 });
             }
-    simpleQuery(relay, query, data = {}, options = {}) {
+            catch (e) { }
-        return new SimpleRpcQuery({
+        }
-            network: this,
+        await Promise.allSettled(this._removeQueue.map((item) => callModule(RPC_MODULE, "removeRelay", {
-            relay,
+            pubkey: item,
-            query,
+            network: this._networkId,
-            options,
+        })));
-        }).run();
+        await Promise.allSettled(this._addQueue.map((item) => callModule(RPC_MODULE, "addRelay", {
+            pubkey: item,
+            network: this._networkId,
+        })));
+        this._actionQueue = [];
+        this._removeQueue = [];
+        this._addQueue = [];
     }
 }
-export class RpcQueryBase extends Client {
+export class RpcQueryBase {
     _promise;
     _network;
     _query;
     _options;
     _queryType;
     constructor(network, query, options = {}, queryType) {
-        super();
         this._network = network;
         this._query = query;
         this._options = options;
         this._queryType = queryType;
     }
     get result() {
-        return this._promise
+        return this._promise.then((result) => {
-            .then((result) => {
+            if (result[1]) {
+                return { error: result[1] };
+            }
             return result[0];
-        })
-            .catch((error) => {
-            return { error: error.message };
         });
     }
     run() {
-        this._promise = this.callModule(this._queryType, {
+        this._promise = this._network.processQueue().then(() => callModule(RPC_MODULE, this._queryType, {
             query: this._query,
             options: this._options,
             network: this._network.networkId,
-        });
+        }));
         return this;
     }
 }
 export class SimpleRpcQuery extends RpcQueryBase {
     _relay;
-    constructor({ network, relay, query, options, }) {
+    constructor(network, relay, query, options) {
         super(network, query, options, "simpleQuery");
         this._relay = relay;
     }
     run() {
-        this._promise = this.callModule(this._queryType, {
+        this._promise = this._network.processQueue().then(() => callModule(RPC_MODULE, this._queryType, {
             relay: this._relay,
             query: this._query,
             options: this._options,
             network: this._network.networkId,
-        });
+        }));
         return this;
     }
 }
-export const createClient = factory(RpcNetwork, RPC_MODULE);
+export class StreamingRpcQuery extends SimpleRpcQuery {
+    _options;
+    _sendUpdate;
+    constructor(network, relay, query, options) {
+        super(network, relay, query, options);
+        this._options = options;
+        this._queryType = "streamingQuery";
+    }
+    cancel() {
+        if (this._sendUpdate) {
+            this._sendUpdate({ cancel: true });
+        }
+    }
+    run() {
+        this._promise = this._network.processQueue().then(() => {
+            const ret = connectModule(RPC_MODULE, this._queryType, {
+                relay: this._relay,
+                query: this._query,
+                options: { ...this._options, streamHandler: true },
+                network: this._network.networkId,
+            }, this._options.streamHandler);
+            this._sendUpdate = ret[0];
+            return ret[1];
+        });
+        return this;
+    }
+    get result() {
+        return this._promise
+            .then((result) => result)
+            .then((response) => {
+            if (response[1]) {
+                return { error: response[1] };
+            }
+            return response[0];
+        });
+    }
+}
+export class WisdomRpcQuery extends RpcQueryBase {
+    constructor(network, query, options = {}) {
+        super(network, query, options, "wisdomQuery");
+    }
+}

package.json

@@ -4,20 +4,15 @@
     "type": "module",
     "main": "dist/index.js",
     "dependencies": {
-        "@lumeweb/libkernel-universal": "git+https://git.lumeweb.com/LumeWeb/libkernel-universal.git",
+        "@lumeweb/dht-rpc-client": "https://github.com/LumeWeb/dht-rpc-client.git",
-        "@lumeweb/rpc-client": "git+https://git.lumeweb.com/LumeWeb/rpc-client.git",
         "buffer": "^6.0.3",
-        "libkernel": "^0.1.48",
+        "libkernel": "^0.1.43",
-        "libkmodule": "^0.2.53",
+        "libkmodule": "^0.2.44",
         "libskynet": "^0.0.62"
     },
     "devDependencies": {
-        "@lumeweb/cfg": "git+https://git.lumeweb.com/LumeWeb/cfg.git",
+        "@lumeweb/relay-types": "https://github.com/LumeWeb/relay-types.git",
-        "@lumeweb/interface-relay": "git+https://git.lumeweb.com/LumeWeb/interface-relay.git",
+        "@types/node": "^18.0.6",
-        "@types/b4a": "^1.6.0",
+        "prettier": "^2.7.1"
-        "@types/node": "^18.15.5",
-        "@types/node-cache": "^4.2.5",
-        "prettier": "^2.8.6",
-        "typescript": "^5.0.2"
     }
 }

src/index.ts

@@ -1,20 +1,40 @@
 import { ErrTuple } from "libskynet";
-import type {
+import type { RPCRequest, RPCResponse } from "@lumeweb/relay-types";
-  RPCRequest,
+import {
-  RPCResponse,
+  RpcQueryOptions,
-  ClientRPCRequest,
+  StreamHandlerFunction,
-} from "@lumeweb/interface-relay";
+  StreamingRpcQueryOptions,
-import { RpcQueryOptions } from "@lumeweb/rpc-client";
+} from "@lumeweb/dht-rpc-client";
 import { Buffer } from "buffer";
-import { Client, factory } from "@lumeweb/libkernel-universal";
+import { DataFn } from "libskynet/dist";
 
-const RPC_MODULE = "fAAgZfXMqN3YOn0-b9DICt8OPsOFeWw3YKY2p84aytzBww";
+const RPC_MODULE = "AQDaEPIo_lpdvz7AKbeafERBHR331RiyvweJ6OrFTplzyg";
 
-export class RpcNetwork extends Client {
+let callModule: any, connectModule: any;
+
+async function loadLibs() {
+  if (callModule && connectModule) {
+    return;
+  }
+
+  if (typeof window !== "undefined" && window?.document) {
+    const pkg = await import("libkernel");
+    callModule = pkg.callModule;
+    connectModule = pkg.connectModule;
+  } else {
+    const pkg = await import("libkmodule");
+    callModule = pkg.callModule;
+    connectModule = pkg.connectModule;
+  }
+}
+
+export class RpcNetwork {
+  private _actionQueue: [string, any][] = [];
+  private _addQueue: string[] = [];
+  private _removeQueue: string[] = [];
   private _def: boolean;
 
   constructor(def: boolean = true) {
-    super();
     this._def = def;
   }
 
@@ -25,34 +45,134 @@ export class RpcNetwork extends Client {
   }
 
   get ready(): Promise<ErrTuple> {
+    let promise = loadLibs();
+
     if (this._def) {
       this._networkId = 1;
     } else {
-      Promise.resolve()
+      promise = promise
-        .then(() => this.callModuleReturn(RPC_MODULE, "createNetwork"))
+        .then(() => callModule(RPC_MODULE, "createNetwork"))
         .then((ret: ErrTuple) => (this._networkId = ret[0]));
     }
 
-    return this.callModuleReturn("ready", {
+    return promise.then(() =>
-      network: this._networkId,
+      callModule(RPC_MODULE, "ready", { network: this._networkId })
-    });
+    );
   }
-  public simpleQuery(
+
-    relay: Buffer | string,
+  private static deleteItem(array: Array<any>, item: string): void {
-    query: ClientRPCRequest,
+    if (array.includes(item)) {
-    data: object | any[] = {},
+      let queue = new Set(array);
-    options: RpcQueryOptions = {}
+      queue.delete(item);
-  ): SimpleRpcQuery {
+      [].splice.apply(array, [0, array.length].concat([...queue]) as any);
-    return new SimpleRpcQuery({
-      network: this,
-      relay,
-      query,
-      options,
-    }).run();
     }
   }
 
-export abstract class RpcQueryBase extends Client {
+  public addRelay(pubkey: string): void {
+    this._addQueue.push(pubkey);
+    this._addQueue = [...new Set(this._addQueue)];
+    RpcNetwork.deleteItem(this._removeQueue, pubkey);
+  }
+
+  public removeRelay(pubkey: string): void {
+    this._removeQueue.push(pubkey);
+    this._removeQueue = [...new Set(this._removeQueue)];
+    RpcNetwork.deleteItem(this._addQueue, pubkey);
+  }
+
+  public clearRelays(): void {
+    this._actionQueue.push(["clearRelays", {}]);
+  }
+
+  public wisdomQuery(
+    method: string,
+    module: string,
+    data: object | any[] = {},
+    bypassCache: boolean = false,
+    options: RpcQueryOptions = {}
+  ): WisdomRpcQuery {
+    return new WisdomRpcQuery(
+      this,
+      {
+        method,
+        module,
+        data,
+        bypassCache,
+      },
+      options
+    ).run();
+  }
+
+  public streamingQuery(
+    relay: Buffer | string,
+    method: string,
+    module: string,
+    streamHandler: StreamHandlerFunction,
+    data: object | any[] = {},
+    options: RpcQueryOptions = {}
+  ): StreamingRpcQuery {
+    return new StreamingRpcQuery(
+      this,
+      relay,
+      { method, module, data },
+      { streamHandler, ...options }
+    ).run();
+  }
+
+  public simpleQuery(
+    relay: Buffer | string,
+    method: string,
+    module: string,
+    data: object | any[] = {},
+    options: RpcQueryOptions = {}
+  ): SimpleRpcQuery {
+    return new SimpleRpcQuery(
+      this,
+      relay,
+      {
+        method,
+        module,
+        data,
+      },
+      options
+    ).run();
+  }
+
+  public async processQueue(): Promise<void> {
+    await loadLibs();
+    for (const action of this._actionQueue) {
+      try {
+        await callModule(RPC_MODULE, action[0], {
+          ...action[1],
+          network: this._networkId,
+        });
+      } catch (e: any) {}
+    }
+
+    await Promise.allSettled(
+      this._removeQueue.map((item: string) =>
+        callModule(RPC_MODULE, "removeRelay", {
+          pubkey: item,
+          network: this._networkId,
+        })
+      )
+    );
+    await Promise.allSettled(
+      this._addQueue.map((item: string) =>
+        callModule(RPC_MODULE, "addRelay", {
+          pubkey: item,
+          network: this._networkId,
+        })
+      )
+    );
+
+    this._actionQueue = [];
+    this._removeQueue = [];
+    this._addQueue = [];
+  }
+}
+
+export abstract class RpcQueryBase {
   protected _promise?: Promise<any>;
   protected _network: RpcNetwork;
   protected _query: RPCRequest;
@@ -65,7 +185,6 @@ export abstract class RpcQueryBase extends Client {
     options: RpcQueryOptions = {},
     queryType: string
   ) {
-    super();
     this._network = network;
     this._query = query;
     this._options = options;
@@ -73,21 +192,22 @@ export abstract class RpcQueryBase extends Client {
   }
 
   get result(): Promise<RPCResponse> {
-    return (this._promise as Promise<any>)
+    return (this._promise as Promise<any>).then((result): RPCResponse => {
-      .then((result: ErrTuple): RPCResponse => {
+      if (result[1]) {
+        return { error: result[1] };
+      }
       return result[0];
-      })
-      .catch((error: Error) => {
-        return { error: error.message };
     });
   }
 
   public run(): this {
-    this._promise = this.callModule(this._queryType, {
+    this._promise = this._network.processQueue().then(() =>
+      callModule(RPC_MODULE, this._queryType, {
         query: this._query,
         options: this._options,
         network: this._network.networkId,
-    });
+      })
+    );
 
     return this;
   }
@@ -95,30 +215,88 @@ export abstract class RpcQueryBase extends Client {
 
 export class SimpleRpcQuery extends RpcQueryBase {
   protected _relay: string | Buffer;
-  constructor({
+  constructor(
-    network,
+    network: RpcNetwork,
-    relay,
+    relay: string | Buffer,
-    query,
+    query: RPCRequest,
-    options,
+    options: RpcQueryOptions
-  }: {
+  ) {
-    network: RpcNetwork;
-    relay: string | Buffer;
-    query: RPCRequest;
-    options: RpcQueryOptions;
-  }) {
     super(network, query, options, "simpleQuery");
     this._relay = relay;
   }
   public run(): this {
-    this._promise = this.callModule(this._queryType, {
+    this._promise = this._network.processQueue().then(() =>
+      callModule(RPC_MODULE, this._queryType, {
         relay: this._relay,
         query: this._query,
         options: this._options,
         network: this._network.networkId,
-    });
+      })
+    );
 
     return this;
   }
 }
 
-export const createClient = factory<RpcNetwork>(RpcNetwork, RPC_MODULE);
+export class StreamingRpcQuery extends SimpleRpcQuery {
+  protected _options: StreamingRpcQueryOptions;
+  private _sendUpdate?: DataFn;
+
+  constructor(
+    network: RpcNetwork,
+    relay: string | Buffer,
+    query: RPCRequest,
+    options: StreamingRpcQueryOptions
+  ) {
+    super(network, relay, query, options);
+    this._options = options;
+    this._queryType = "streamingQuery";
+  }
+
+  public cancel() {
+    if (this._sendUpdate) {
+      this._sendUpdate({ cancel: true });
+    }
+  }
+
+  public run(): this {
+    this._promise = this._network.processQueue().then(() => {
+      const ret = connectModule(
+        RPC_MODULE,
+        this._queryType,
+        {
+          relay: this._relay,
+          query: this._query,
+          options: { ...this._options, streamHandler: true },
+          network: this._network.networkId,
+        },
+        this._options.streamHandler
+      );
+      this._sendUpdate = ret[0];
+      return ret[1];
+    });
+
+    return this;
+  }
+
+  get result(): Promise<RPCResponse> {
+    return (this._promise as Promise<any>)
+      .then((result): Promise<ErrTuple> => result)
+      .then((response: ErrTuple) => {
+        if (response[1]) {
+          return { error: response[1] };
+        }
+        return response[0];
+      });
+  }
+}
+
+export class WisdomRpcQuery extends RpcQueryBase {
+  constructor(
+    network: RpcNetwork,
+    query: RPCRequest,
+    options: RpcQueryOptions = {}
+  ) {
+    super(network, query, options, "wisdomQuery");
+  }
+}