univo 0.1.18 → 0.1.19

package/dist/cli.mjs

@@ -5,7 +5,7 @@ import { config } from 'dotenv';
 import { WebSocket } from 'partysocket';
 import { defineCommand, runMain } from 'citty';
 import { http } from './client.mjs';
-import { c as createLogger, v as version, l as name } from './shared/univo.mtzSyY24.mjs';
+import { c as createLogger, v as version, l as name } from './shared/univo.DSp9mW7b.mjs';
 
 const log = createLogger({ quiet: false });
 const dev = defineCommand({

package/dist/client.mjs

@@ -1,4 +1,4 @@
-import { b as createException, o as compress, j as raise, g as getException } from './shared/univo.mtzSyY24.mjs';
+import { b as createException, o as compress, k as raise, g as getException } from './shared/univo.DSp9mW7b.mjs';
 
 function http(url, opts = {}) {
   return {

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { c as createLogger, d as decompress, a as decoder, b as createException, g as getException, h as hexToNumber, i as isAddressEqual, e as catchException, r as retry, v as version, n as nonNullable, f as getSignature } from './shared/univo.mtzSyY24.mjs';
+import { c as createLogger, d as decompress, a as decoder, b as createException, g as getException, h as hexToNumber, i as isAddressEqual, e as catchException, r as retry, v as version, n as nonNullable, f as getSignature } from './shared/univo.DSp9mW7b.mjs';
 
 function matchFilter(block, filter) {
   if (!chainValid(block, filter)) return false;

package/dist/realtime.d.mts

@@ -2,11 +2,17 @@
  * Transport -----------------------------------------------------------------------------------------------------------------------------------
  */
 type Transport = {
+    /**
+     * Performs as JSON RPC request and returns the result
+     */
     request(opts: {
         method: string;
         params: any[];
     }): Promise<any>;
-    subscribe(param: string, handler: (message: any) => void): Promise<{
+    /**
+     * Subscribes to specific event types and returns a function to unsubscribe.
+     */
+    subscribe(param: "newHeads", handler: (message: any) => void): Promise<{
         unsubscribe(): Promise<void>;
     }>;
 };

package/dist/realtime.d.ts

@@ -2,11 +2,17 @@
  * Transport -----------------------------------------------------------------------------------------------------------------------------------
  */
 type Transport = {
+    /**
+     * Performs as JSON RPC request and returns the result
+     */
     request(opts: {
         method: string;
         params: any[];
     }): Promise<any>;
-    subscribe(param: string, handler: (message: any) => void): Promise<{
+    /**
+     * Subscribes to specific event types and returns a function to unsubscribe.
+     */
+    subscribe(param: "newHeads", handler: (message: any) => void): Promise<{
         unsubscribe(): Promise<void>;
     }>;
 };

package/dist/realtime.mjs

@@ -1,7 +1,7 @@
 import WS from 'ws';
 import { WebSocket } from 'partysocket';
 import { http } from './client.mjs';
-import { c as createLogger, r as retry, h as hexToNumber, j as raise, m as mutex, k as assert } from './shared/univo.mtzSyY24.mjs';
+import { j as assert, c as createLogger, r as retry, h as hexToNumber, k as raise, m as mutex } from './shared/univo.DSp9mW7b.mjs';
 
 function createSocket(url, opts) {
   const ws = new WebSocket(url, [], { WebSocket: WS });
@@ -13,67 +13,119 @@ function createSocket(url, opts) {
   return ws;
 }
 function defineTransport(url) {
+  assert(url.startsWith("wss://"), "Websocket connections must start with `wss://`");
   let id = 0;
   const requests = /* @__PURE__ */ new Map();
+  const subscriptions = /* @__PURE__ */ new Map();
+  const params = /* @__PURE__ */ new Map();
+  const socket = createSocket(url, {
+    async onError(cause) {
+      console.error(new Error("Socket error", { cause }));
+    },
+    async onOpen() {
+      if (subscriptions.size === 0) return;
+      const params2 = [];
+      for (const [id2, subscription] of subscriptions) {
+        params2.push(subscription.param);
+        request({ method: "eth_unsubscribe", params: [id2] }).catch(() => {
+          console.warn("Failed to cancel old susbcription");
+        });
+        subscriptions.delete(id2);
+      }
+      for (const param of params2) {
+        request({ method: "eth_subscribe", params: [param] }).then((id2) => {
+          subscriptions.set(id2, { param, latest: Date.now() });
+        });
+      }
+    },
+    async onMessage(event) {
+      const data = JSON.parse(event.data);
+      if (data.method === "eth_subscription") {
+        const subscription = subscriptions.get(data.params.subscription);
+        if (subscription === void 0) {
+          return await request({ method: "eth_unsubscribe", params: [data.params.subscription] }).catch(() => {
+            console.warn("Failed to unsubscribe stale subscription");
+          });
+        }
+        const handlers = params.get(subscription.param);
+        if (handlers === void 0) {
+          return await request({ method: "eth_unsubscribe", params: [data.params.subscription] }).catch(() => {
+            console.warn("Failed to unsubscribe stale subscription");
+          });
+        }
+        for (const handler2 of handlers) {
+          try {
+            handler2(data.params.result);
+          } catch (cause) {
+            console.error(new Error("Handler error", { cause }));
+          }
+        }
+        subscription.latest = Date.now();
+        return;
+      }
+      const handler = requests.get(data.id);
+      if (handler === void 0) {
+        return console.warn(`Received unknown response for request id ${data.id}...`);
+      }
+      return handler(data.result);
+    }
+  });
   async function request(opts) {
     return await new Promise((resolve) => {
       const body = Object.assign({ id: id++ }, opts);
-      requests.set(body.id, {
-        handler: (data) => {
-          requests.delete(body.id);
-          resolve(data);
-        }
+      requests.set(body.id, (data) => {
+        requests.delete(body.id);
+        resolve(data);
       });
       socket.send(JSON.stringify(body));
     });
   }
-  const subscriptions = /* @__PURE__ */ new Map();
   async function subscribe(param, handler) {
-    const id2 = await request({ method: "eth_subscribe", params: [param] });
-    subscriptions.set(id2, { param, handler, latest: Date.now() });
+    const handlers = params.get(param);
+    if (handlers === void 0) {
+      const handlers2 = (/* @__PURE__ */ new Set()).add(handler);
+      params.set(param, handlers2);
+      const id2 = await request({ method: "eth_subscribe", params: [param] }).catch((cause) => {
+        throw new Error(`Failed to initialise subscription for param ${param}`, { cause });
+      });
+      subscriptions.set(id2, { param, latest: Date.now() });
+    } else {
+      handlers.add(handler);
+    }
     return {
       async unsubscribe() {
-        subscriptions.delete(id2);
-        await request({ method: "eth_unsubscribe", params: [id2] }).catch(() => {
-        });
-      }
-    };
-  }
-  const socket = createSocket(url, {
-    onError(cause) {
-      console.error(new Error("Socket error", { cause }));
-    },
-    onOpen() {
-      if (subscriptions.size) {
-        const handlers = [];
-        for (const [id2, subscription] of subscriptions) {
-          handlers.push(subscription);
-          request({ method: "eth_unsubscribe", params: [id2] }).catch(() => {
-          });
-          subscriptions.delete(id2);
+        const handlers2 = params.get(param);
+        if (handlers2 === void 0) {
+          return console.warn("Param already unsubscribed...");
         }
-        for (const handler of handlers) {
-          request({ method: "eth_subscribe", params: [handler.param] }).then((id2) => {
-            subscriptions.set(id2, handler);
+        handlers2.delete(handler);
+        if (handlers2.size === 0) {
+          await request({ method: "eth_unsubscribe", params: [id] }).catch(() => {
+            console.warn("Failed to unsubscribe unused subscription");
           });
         }
       }
-    },
-    onMessage(event) {
-      const data = JSON.parse(event.data);
-      if (data.method === "eth_subscription") {
-        const subscription = subscriptions.get(data.params.subscription);
-        if (!subscription) {
-          return request({ method: "eth_unsubscribe", params: [data.params.subscription] }).catch(() => {
-          });
-        }
-        subscription.latest = Date.now();
-        return subscription.handler(data.params.result);
+    };
+  }
+  function healthcheck() {
+    const params2 = [];
+    for (const [id2, subscription] of subscriptions) {
+      if (Date.now() - subscription.latest > 60 * 1e3) {
+        params2.push(subscription.param);
+        request({ method: "eth_unsubscribe", params: [id2] }).catch(() => {
+          console.warn("Failed to cancel old susbcription");
+        });
+        subscriptions.delete(id2);
+        console.warn(`Subscription ${id2} failed health check, reinitialising..`);
       }
-      const _request = requests.get(data.id);
-      if (_request) _request.handler(data.result);
     }
-  });
+    for (const param of params2) {
+      request({ method: "eth_subscribe", params: [param] }).then((id2) => {
+        subscriptions.set(id2, { param, latest: Date.now() });
+      });
+    }
+  }
+  setInterval(healthcheck, 60 * 1e3);
   return { request, subscribe };
 }
 function defineBlockchain(opts) {

package/dist/shared/{univo.mtzSyY24.mjs → univo.DSp9mW7b.mjs}

@@ -1,5 +1,5 @@
 const name = "univo";
-const version = "0.1.18";
+const version = "0.1.19";
 
 function createException(message) {
   return `univo:${message}`;
@@ -104,4 +104,4 @@ async function decompress(input) {
 }
 const decoder = new TextDecoder();
 
-export { decoder as a, createException as b, createLogger as c, decompress as d, catchException as e, getSignature as f, getException as g, hexToNumber as h, isAddressEqual as i, raise as j, assert as k, name as l, mutex as m, nonNullable as n, compress as o, retry as r, version as v };
+export { decoder as a, createException as b, createLogger as c, decompress as d, catchException as e, getSignature as f, getException as g, hexToNumber as h, isAddressEqual as i, assert as j, raise as k, name as l, mutex as m, nonNullable as n, compress as o, retry as r, version as v };

package/package.json

@@ -2,7 +2,7 @@
 	"name": "univo",
 	"license": "MIT",
 	"type": "module",
-	"version": "0.1.18",
+	"version": "0.1.19",
 	"sideEffects": false,
 	"module": "./dist/index.mjs",
 	"types": "./dist/index.d.ts",