univo 0.3.2 → 0.4.0

package/package.json

@@ -2,7 +2,7 @@
 	"name": "univo",
 	"license": "MIT",
 	"type": "module",
-	"version": "0.3.2",
+	"version": "0.4.0",
 	"sideEffects": false,
 	"module": "./dist/index.mjs",
 	"types": "./dist/index.d.ts",
@@ -18,6 +18,10 @@
 			"types": "./dist/rpc.d.ts",
 			"import": "./dist/rpc.mjs"
 		},
+		"./proxy": {
+			"types": "./dist/proxy.d.ts",
+			"import": "./dist/proxy.mjs"
+		},
 		"./transport": {
 			"types": "./dist/transport.d.ts",
 			"import": "./dist/transport.mjs"

package/dist/shared/univo.j1HWrILH.mjs

@@ -1,238 +0,0 @@
-import ws from 'ws';
-import { WebSocket } from 'partysocket';
-import { f as compress, g as raise, c as createLogger, m as mutex } from './univo.vwk4Xrn3.mjs';
-
-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;
-    }
-  }
-}
-
-const DEFAULT_TIMEOUT_MS = 60 * 1e3;
-const UnknownMethodError = createException("The requested RPC method does not exist on the provided implementation");
-function local(rpc) {
-  const request = async (opts) => {
-    const method = rpc.request[opts.method];
-    if (method === void 0) {
-      throw new Error(UnknownMethodError);
-    }
-    return await method(...opts.params);
-  };
-  const subscribe = async () => {
-    throw new Error("Unable to `subscribe` on `local` transport");
-  };
-  return { protocol: "local", request, subscribe };
-}
-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 log = 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) {
-      log.error(`Socket error: ${cause.message}`);
-    },
-    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(() => {
-          log.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 onClose() {
-      log.debug("Socket closed");
-    },
-    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(() => {
-            log.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(() => {
-            log.warn("Failed to unsubscribe stale subscription");
-          });
-        }
-        for (const handler2 of handlers) {
-          try {
-            handler2(data.params.result);
-          } catch (cause) {
-            log.error(new Error("Handler error", { cause }));
-          }
-        }
-        subscription.latest = Date.now();
-        return;
-      }
-      const handler = requests.get(data.id);
-      if (handler === void 0) {
-        return log.warn(`Received unknown response for request id ${data.id}...`);
-      }
-      return handler(data.result);
-    }
-  });
-  const request = async (opts2) => {
-    return await new Promise((resolve, reject) => {
-      const signal = opts2.signal ?? AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
-      const body = {
-        id: id++,
-        method: opts2.method,
-        params: opts2.params
-      };
-      function cleanup() {
-        requests.delete(body.id);
-        signal.removeEventListener("abort", abort);
-      }
-      function abort() {
-        cleanup();
-        reject(signal.reason);
-      }
-      if (signal.aborted) {
-        return abort();
-      }
-      signal.addEventListener("abort", abort, { once: true });
-      requests.set(body.id, (data) => {
-        cleanup();
-        resolve(data);
-      });
-      try {
-        socket.send(JSON.stringify(body));
-      } catch (cause) {
-        cleanup();
-        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 log.warn("Param already unsubscribed...");
-      }
-      handlers2.delete(handler);
-      if (handlers2.size === 0) {
-        await request({ method: "eth_unsubscribe", params: [id] }).catch(() => {
-          log.warn("Failed to unsubscribe unused subscription");
-        });
-      }
-    };
-  };
-  function healthcheck() {
-    try {
-      const failed = Object.values(subscriptions).some((subscription) => {
-        return Date.now() - subscription.latest > 60 * 1e3;
-      });
-      if (!failed) {
-        return;
-      }
-      log.warn("Health check failed. Reinitialising socket...");
-      socket.reconnect();
-    } catch (error) {
-      if (error instanceof Error) {
-        log.debug(`Failed healthcheck: ${error.message}`);
-      }
-    }
-  }
-  setInterval(mutex(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 signal = options.signal ?? AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
-    const res = await fetch(url, { headers, body, method: "POST", signal }).catch((cause) => {
-      if (signal.aborted) {
-        throw signal.reason;
-      }
-      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 { catchException as a, createException as c, getException as g, http as h, local as l, wss as w };