univo 0.2.11 → 0.2.13

package/dist/transport.d.ts

@@ -1,15 +1,15 @@
 import { Rpc } from './rpc.js';
-import './index.js';
+import './shared/univo.Cj4s4jNq.js';
 import 'unstorage';
 
-type Protocol = "http" | "wss";
+type Protocol = "http" | "wss" | "local";
 type Transport<R extends Rpc, P extends Protocol = Protocol> = {
     /**
      * The underlying transport protocol.
      */
     protocol: P;
     /**
-     * Performs a JSON RPC request
+     * Performs an RPC request
      * @returns The RPC response
      */
     request: <M extends keyof R["request"]>(opts: {
@@ -22,6 +22,7 @@ type Transport<R extends Rpc, P extends Protocol = Protocol> = {
      */
     subscribe: <M extends keyof R["subscribe"]>(param: M, handler: (message: R["subscribe"][M]) => void) => Promise<() => Promise<void>>;
 };
+declare function local<R extends Rpc>(rpc: R): Transport<R, "local">;
 declare function wss<R extends Rpc>(url: string, opts?: {
     quiet?: boolean;
 }): Transport<R, "wss">;
@@ -32,5 +33,5 @@ declare function http<R extends Rpc>(url: string, opts?: {
     signingKey?: string;
 }): Transport<R, "http">;
 
-export { http, wss };
+export { http, local, wss };
 export type { Transport };

package/dist/transport.mjs

@@ -1,188 +1,4 @@
-import ws from 'ws';
-import { WebSocket } from 'partysocket';
-import { c as createException } from './shared/univo.C0flyVee.mjs';
-import { g as compress, j as raise, c as createLogger } from './shared/univo.Cz5ut_5D.mjs';
-
-function createSocket(url, opts) {
-  const socket = new WebSocket(url, [], { WebSocket: ws });
-  socket.binaryType = "arraybuffer";
-  if (opts.onOpen) socket.onopen = opts.onOpen;
-  if (opts.onError) socket.onerror = opts.onError;
-  if (opts.onClose) socket.onclose = opts.onClose;
-  if (opts.onMessage) socket.onmessage = opts.onMessage;
-  return socket;
-}
-function wss(url, opts = {}) {
-  if (!url.startsWith("wss://")) {
-    throw new Error("Websocket connections must start with `wss://`");
-  }
-  const logger = createLogger({ quiet: opts.quiet ?? false });
-  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) {
-      logger.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(() => {
-          logger.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(() => {
-            logger.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(() => {
-            logger.warn("Failed to unsubscribe stale subscription");
-          });
-        }
-        for (const handler2 of handlers) {
-          try {
-            handler2(data.params.result);
-          } catch (cause) {
-            logger.error(new Error("Handler error", { cause }));
-          }
-        }
-        subscription.latest = Date.now();
-        return;
-      }
-      const handler = requests.get(data.id);
-      if (handler === void 0) {
-        return logger.warn(`Received unknown response for request id ${data.id}...`);
-      }
-      return handler(data.result);
-    }
-  });
-  const request = async (opts2) => {
-    return await new Promise((resolve, reject) => {
-      const body = Object.assign({ id: id++ }, opts2);
-      const timeout = setTimeout(() => {
-        requests.delete(body.id);
-        reject(new Error("wss request timed out after 30 seconds"));
-      }, 30 * 1e3);
-      requests.set(body.id, (data) => {
-        clearTimeout(timeout);
-        requests.delete(body.id);
-        resolve(data);
-      });
-      try {
-        socket.send(JSON.stringify(body));
-      } catch (cause) {
-        clearTimeout(timeout);
-        requests.delete(body.id);
-        reject(new Error(ClientConnectionError, { cause }));
-      }
-    });
-  };
-  const subscribe = async (param, handler) => {
-    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 function unsubscribe() {
-      const handlers2 = params.get(param);
-      if (handlers2 === void 0) {
-        return logger.warn("Param already unsubscribed...");
-      }
-      handlers2.delete(handler);
-      if (handlers2.size === 0) {
-        await request({ method: "eth_unsubscribe", params: [id] }).catch(() => {
-          logger.warn("Failed to unsubscribe unused subscription");
-        });
-      }
-    };
-  };
-  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(() => {
-          logger.warn("Failed to cancel old susbcription");
-        });
-        subscriptions.delete(id2);
-        logger.warn(`Subscription ${id2} failed health check, reinitialising..`);
-      }
-    }
-    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 { protocol: "wss", request, subscribe };
-}
-function http(url, opts = {}) {
-  let id = 0;
-  const request = async (options) => {
-    let body = JSON.stringify({
-      id: id++,
-      jsonrpc: "2.0",
-      method: options.method,
-      params: options.params
-    });
-    const headers = new Headers();
-    headers.set("Content-Type", "application/json");
-    if (options.method.startsWith("private_")) {
-      if (opts.signingKey === void 0) {
-        throw new Error(ClientUnauthorizedError);
-      }
-      body = await compress(body).catch((cause) => raise(ClientCompressionError, { cause }));
-      headers.set("Content-Encoding", "gzip");
-      headers.set("Authorization", `Bearer ${opts.signingKey}`);
-    }
-    const res = await fetch(url, { headers, body, method: "POST", signal: AbortSignal.timeout(30 * 1e3) }).catch((cause) => {
-      throw new Error(ClientConnectionError, { cause });
-    });
-    if (!res.ok || res.status < 200 || res.status >= 300) {
-      throw new Error(ClientConnectionError);
-    }
-    const json = await res.json().catch((cause) => {
-      throw new Error(ClientResponseError, { cause });
-    });
-    if (json.error) {
-      throw new Error(json.error.message);
-    }
-    return json.result;
-  };
-  const subscribe = async () => {
-    throw new Error("Unable to `subscribe` on `http` transport");
-  };
-  return { protocol: "http", request, subscribe };
-}
-const ClientCompressionError = createException("An error occurred when compressing the request");
-const ClientConnectionError = createException("An errored occurred when connecting to the server");
-const ClientResponseError = createException("An error occurred when reading the servers response");
-const ClientUnauthorizedError = createException("Attempted to execute a private method without providing a request signing key");
-
-export { http, wss };
+import 'ws';
+import 'partysocket';
+export { h as http, l as local, w as wss } from './shared/univo.BwPUSTpl.mjs';
+import './shared/univo.B_UsEiYb.mjs';

package/package.json

@@ -2,7 +2,7 @@
 	"name": "univo",
 	"license": "MIT",
 	"type": "module",
-	"version": "0.2.11",
+	"version": "0.2.13",
 	"sideEffects": false,
 	"module": "./dist/index.mjs",
 	"types": "./dist/index.d.ts",
@@ -43,11 +43,9 @@
 		"ws": "^8.18.1"
 	},
 	"devDependencies": {
-		"@hono/node-server": "^1.14.1",
 		"@types/node": "^20.11.27",
 		"@types/ws": "^8.18.1",
 		"changelogen": "^0.6.1",
-		"hono": "^4.7.8",
 		"jiti": "^2.4.2",
 		"msw": "^2.10.2",
 		"typescript": "^5.8.2",

package/dist/shared/univo.C0flyVee.mjs

@@ -1,21 +0,0 @@
-function createException(message) {
-  return `univo:${message}`;
-}
-function catchException(unknown, exception) {
-  if (unknown instanceof Error) {
-    if (unknown.message === exception) {
-      return true;
-    }
-  }
-  return false;
-}
-function getException(unknown) {
-  if (unknown instanceof Error) {
-    if (unknown.message.startsWith("univo")) {
-      const [_, message] = unknown.message.split(":");
-      if (message) return message;
-    }
-  }
-}
-
-export { catchException as a, createException as c, getException as g };