*Add removeRelay and clearRelays API methods

src/index.ts

@@ -1,19 +1,19 @@
 import {
-  callModule as callModuleKernel,
+    callModule as callModuleKernel,
-  connectModule as connectModuleKernel,
+    connectModule as connectModuleKernel,
 } from "libkernel";
 import {
-  callModule as callModuleModule,
+    callModule as callModuleModule,
-  connectModule as connectModuleModule,
+    connectModule as connectModuleModule,
 } from "libkmodule";
-import { EventEmitter } from "events";
+import {EventEmitter} from "events";
-import { DataFn, ErrTuple } from "libskynet";
+import {DataFn, ErrTuple} from "libskynet";
-import { Buffer } from "buffer";
+import {Buffer} from "buffer";
 
 const DHT_MODULE = "AQD1IgE4lTZkq1fqdoYGojKRNrSk0YQ_wrHbRtIiHDrnow";
 
 let callModule: typeof callModuleModule,
-  connectModule: typeof connectModuleModule;
+    connectModule: typeof connectModuleModule;
 
 if (typeof window !== "undefined" && window?.document) {
     callModule = callModuleKernel;
@@ -24,78 +24,89 @@ if (typeof window !== "undefined" && window?.document) {
 }
 
 export class DHT {
-  public async connect(pubkey: string): Promise<Socket> {
+    public async connect(pubkey: string): Promise<Socket> {
-    const [resp, err] = await callModule(DHT_MODULE, "connect", { pubkey });
+        const [resp, err] = await callModule(DHT_MODULE, "connect", {pubkey});
-    if (err) {
+        if (err) {
-      throw new Error(err);
+            throw new Error(err);
+        }
+        return new Socket(resp.id);
     }
-    return new Socket(resp.id);
-  }
 
-  async ready(): Promise<ErrTuple> {
+    async ready(): Promise<ErrTuple> {
-    return callModule(DHT_MODULE, "ready");
+        return callModule(DHT_MODULE, "ready");
-  }
+    }
-
+
-  public async addRelay(pubkey: string): Promise<void> {
+    public async addRelay(pubkey: string): Promise<void> {
-    const [, err] = await callModule(DHT_MODULE, "addRelay", { pubkey });
+        const [, err] = await callModule(DHT_MODULE, "addRelay", {pubkey});
-    if (err) {
+        if (err) {
-      throw new Error(err);
+            throw new Error(err);
+        }
+    }
+
+    public async removeRelay(pubkey: string): Promise<void> {
+        const [, err] = await callModule(DHT_MODULE, "removeRelay", {pubkey});
+        if (err) {
+            throw new Error(err);
+        }
+    }
+
+    public async clearRelays(): Promise<void> {
+        await callModule(DHT_MODULE, "clearRelays");
     }
-  }
 }
 
 export class Socket extends EventEmitter {
-  private id: number;
+    private id: number;
-  private eventUpdates: { [event: string]: DataFn[] } = {};
+    private eventUpdates: { [event: string]: DataFn[] } = {};
 
-  constructor(id: number) {
+    constructor(id: number) {
-    super();
+        super();
-    this.id = id;
+        this.id = id;
-  }
-
-  on(eventName: string, listener: (...args: any[]) => void): this {
-    const [update, promise] = connectModule(
-      DHT_MODULE,
-      "listenSocketEvent",
-      { id: this.id, event: eventName },
-      (data: any) => {
-        this.emit(eventName, data);
-      }
-    );
-    this.trackEvent(eventName, update);
-
-    promise.then(() => {
-      this.off(eventName, listener);
-    });
-
-    return super.on(eventName, listener);
-  }
-
-  off(type: string, listener: any): this {
-    const updates = [...this.eventUpdates[type]];
-    this.eventUpdates[type] = [];
-    for (const func of updates) {
-      func({ action: "off" });
     }
-    return super.off(type, listener);
-  }
 
-  write(message: string | Buffer): void {
+    on(eventName: string, listener: (...args: any[]) => void): this {
-    callModule(DHT_MODULE, "write", { id: this.id, message });
+        const [update, promise] = connectModule(
-  }
+            DHT_MODULE,
+            "listenSocketEvent",
+            {id: this.id, event: eventName},
+            (data: any) => {
+                this.emit(eventName, data);
+            }
+        );
+        this.trackEvent(eventName, update);
 
-  end(): void {
+        promise.then(() => {
-    callModule(DHT_MODULE, "close", { id: this.id });
+            this.off(eventName, listener);
-  }
+        });
 
-  private ensureEvent(event: string): void {
+        return super.on(eventName, listener);
-    if (!(event in this.eventUpdates)) {
-      this.eventUpdates[event] = [];
     }
-  }
 
-  private trackEvent(event: string, update: DataFn): void {
+    off(type: string, listener: any): this {
-    this.ensureEvent(event as string);
+        const updates = [...this.eventUpdates[type]];
-    this.eventUpdates[event].push(update);
+        this.eventUpdates[type] = [];
-  }
+        for (const func of updates) {
+            func({action: "off"});
+        }
+        return super.off(type, listener);
+    }
+
+    write(message: string | Buffer): void {
+        callModule(DHT_MODULE, "write", {id: this.id, message});
+    }
+
+    end(): void {
+        callModule(DHT_MODULE, "close", {id: this.id});
+    }
+
+    private ensureEvent(event: string): void {
+        if (!(event in this.eventUpdates)) {
+            this.eventUpdates[event] = [];
+        }
+    }
+
+    private trackEvent(event: string, update: DataFn): void {
+        this.ensureEvent(event as string);
+        this.eventUpdates[event].push(update);
+    }
 }