gennet.js 0.1.0

package/dist/index.mjs

@@ -0,0 +1,301 @@
+class RpcError extends Error {
+  code;
+  data;
+  constructor(message, code, data) {
+    super(message);
+    this.name = "RpcError";
+    this.code = code;
+    this.data = data;
+  }
+}
+
+let requestId = 0;
+class HttpProvider {
+  url;
+  constructor(url) {
+    this.url = url;
+  }
+  get connected() {
+    return true;
+  }
+  async request(method, params) {
+    const id = ++requestId;
+    const body = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+    const res = await fetch(this.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body
+    });
+    if (!res.ok) {
+      throw new RpcError(`HTTP ${res.status}: ${res.statusText}`, -32e3);
+    }
+    const json = await res.json();
+    if ("error" in json) {
+      const err = json.error;
+      throw new RpcError(err.message, err.code, err.data);
+    }
+    return json.result;
+  }
+  // HTTP unterstützt keine Push-Notifications
+  on(_event, _listener) {
+  }
+  off(_event, _listener) {
+  }
+  disconnect() {
+  }
+}
+
+const DEFAULT_TIMEOUT = 3e4;
+class WebSocketProvider {
+  url;
+  timeout;
+  ws = null;
+  requestId = 0;
+  pending = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  connectPromise = null;
+  constructor(url, timeout = DEFAULT_TIMEOUT) {
+    this.url = url;
+    this.timeout = timeout;
+  }
+  get connected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+  async connect() {
+    if (this.connected) return;
+    if (this.connectPromise) return this.connectPromise;
+    this.connectPromise = new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.url);
+      this.ws.onopen = () => {
+        this.connectPromise = null;
+        resolve();
+      };
+      this.ws.onerror = (ev) => {
+        this.connectPromise = null;
+        reject(new Error(`WebSocket-Verbindung fehlgeschlagen: ${this.url} (${ev})`));
+      };
+      this.ws.onmessage = (ev) => {
+        this.handleMessage(typeof ev.data === "string" ? ev.data : String(ev.data));
+      };
+      this.ws.onclose = () => {
+        this.connectPromise = null;
+        for (const [id, req] of this.pending) {
+          clearTimeout(req.timer);
+          req.reject(new Error("WebSocket-Verbindung geschlossen"));
+          this.pending.delete(id);
+        }
+      };
+    });
+    return this.connectPromise;
+  }
+  async request(method, params) {
+    if (!this.connected) {
+      await this.connect();
+    }
+    const id = ++this.requestId;
+    const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new RpcError(`Timeout nach ${this.timeout}ms f\xFCr ${method}`, -32e3));
+      }, this.timeout);
+      this.pending.set(id, { resolve, reject, timer });
+      this.ws.send(payload);
+    });
+  }
+  on(_event, listener) {
+    this.listeners.add(listener);
+  }
+  off(_event, listener) {
+    this.listeners.delete(listener);
+  }
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  // ── Private ────────────────────────────────────────────────
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.id !== void 0 && ("result" in msg || "error" in msg)) {
+      const response = msg;
+      const pending = this.pending.get(response.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(response.id);
+        if ("error" in response) {
+          const err = response.error;
+          pending.reject(new RpcError(err.message, err.code, err.data));
+        } else {
+          pending.resolve(response.result);
+        }
+      }
+      return;
+    }
+    if ("method" in msg && "params" in msg) {
+      const notification = msg;
+      for (const listener of this.listeners) {
+        listener(notification);
+      }
+    }
+  }
+}
+
+class Admin {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /** Node-Info: Status, PeerId, Adresse, Peers, Uptime, Module. */
+  async nodeInfo() {
+    return await this.provider.request("admin_nodeInfo");
+  }
+  /** Gateway herunterfahren. */
+  async shutdown() {
+    return await this.provider.request("admin_shutdown");
+  }
+  /** Alle Module und ihren Status auflisten. */
+  async modules() {
+    return await this.provider.request("admin_modules");
+  }
+  /** Ein Modul starten. */
+  async startModule(name) {
+    return await this.provider.request("admin_startModule", { name });
+  }
+  /** Ein Modul stoppen. */
+  async stopModule(name) {
+    return await this.provider.request("admin_stopModule", { name });
+  }
+}
+
+class Net {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /** Alle bekannten Peers auflisten. */
+  async peers() {
+    return await this.provider.request("net_peers");
+  }
+  /** Mit einem Peer über Multiaddr verbinden. */
+  async connect(multiaddr) {
+    return await this.provider.request("net_connect", { multiaddr });
+  }
+  /** Verschlüsselte Nachricht an einen Peer senden. */
+  async send(address, text) {
+    return await this.provider.request("net_send", { address, text });
+  }
+  /** Agent-Prompt auf einem Remote-Peer ausführen (ECIES-verschlüsselt). */
+  async peerAgent(address, prompt) {
+    return await this.provider.request("net_peerAgent", { address, prompt });
+  }
+}
+
+class Personal {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /** Neue Identität erstellen und im Keystore speichern. */
+  async newIdentity(password) {
+    return await this.provider.request("personal_newIdentity", { password });
+  }
+  /** Alle Identitäten im Keystore auflisten. */
+  async listIdentities() {
+    return await this.provider.request("personal_listIdentities");
+  }
+}
+
+class Agent {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /** Agent-Loop mit einem Prompt ausführen. */
+  async run(input) {
+    return await this.provider.request("agent_run", { input });
+  }
+}
+
+class Mempool {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /** Nachricht ans Netzwerk broadcasten (GossipSub). */
+  async broadcast(message) {
+    return await this.provider.request("mempool_broadcast", { message });
+  }
+}
+
+class GenNet {
+  admin;
+  net;
+  personal;
+  agent;
+  mempool;
+  provider;
+  constructor(providerOrUrl) {
+    if (typeof providerOrUrl === "string") {
+      this.provider = GenNet.createProvider(providerOrUrl);
+    } else {
+      this.provider = providerOrUrl;
+    }
+    this.admin = new Admin(this.provider);
+    this.net = new Net(this.provider);
+    this.personal = new Personal(this.provider);
+    this.agent = new Agent(this.provider);
+    this.mempool = new Mempool(this.provider);
+  }
+  /** Verbindung herstellen (nur bei WebSocket nötig). */
+  async connect() {
+    if (this.provider.connect) {
+      await this.provider.connect();
+    }
+  }
+  /** Verbindung schließen. */
+  disconnect() {
+    this.provider.disconnect();
+  }
+  /** Ob eine aktive Verbindung besteht. */
+  get connected() {
+    return this.provider.connected;
+  }
+  /**
+   * Subscription starten (nur WebSocket).
+   * Topics: 'logs', 'messages', 'mempool'.
+   */
+  async subscribe(topic, callback) {
+    const subId = await this.provider.request("gennet_subscribe", [topic]);
+    const listener = (notification) => {
+      if (notification.method === "gennet_subscription" && notification.params.subscription === subId) {
+        callback(notification.params.result);
+      }
+    };
+    this.provider.on("notification", listener);
+    return {
+      id: subId,
+      unsubscribe: async () => {
+        this.provider.off("notification", listener);
+        return await this.provider.request("gennet_unsubscribe", [subId]);
+      }
+    };
+  }
+  /** Raw JSON-RPC Request (für erweiterte Nutzung). */
+  async request(method, params) {
+    return this.provider.request(method, params);
+  }
+  // ── Private ────────────────────────────────────────────────
+  static createProvider(url) {
+    if (url.startsWith("ws://") || url.startsWith("wss://")) {
+      return new WebSocketProvider(url);
+    }
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      return new HttpProvider(url);
+    }
+    throw new Error(`Unbekanntes URL-Schema: ${url} (erwartet: ws://, wss://, http://, https://)`);
+  }
+}
+
+export { Admin, Agent, GenNet, HttpProvider, Mempool, Net, Personal, RpcError, WebSocketProvider };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "gennet.js",
+  "version": "0.1.0",
+  "description": "Client Library for GenNet — interact with GenNet nodes via JSON-RPC",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub",
+    "test": "vitest",
+    "lint": "eslint src/",
+    "check": "publint && attw --pack",
+    "prepublishOnly": "npm run build && npm run check"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cryptagoEU/gennet.js.git"
+  },
+  "keywords": [
+    "gennet",
+    "p2p",
+    "json-rpc",
+    "websocket",
+    "typescript",
+    "network",
+    "agentic",
+    "web3"
+  ],
+  "author": "Alexander Garber",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/cryptagoEU/gennet.js/issues"
+  },
+  "homepage": "https://github.com/cryptagoEU/gennet.js#readme",
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.0",
+    "publint": "^0.3.0",
+    "typescript": "^5.4.0",
+    "unbuild": "^3.0.0",
+    "vitest": "^3.0.0"
+  }
+}