univo 0.1.17 → 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, e as version, l as name } from './shared/univo.2F7MFHxq.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,6 +1,5 @@
-import { a as createException, o as compress, f as getSignature, g as getException } from './shared/univo.2F7MFHxq.mjs';
+import { b as createException, o as compress, k as raise, g as getException } from './shared/univo.DSp9mW7b.mjs';
 
-const MIN_GZIP_SIZE = 1024;
 function http(url, opts = {}) {
   return {
     async request({ jsonrpc, id, method, params }) {
@@ -10,16 +9,9 @@ function http(url, opts = {}) {
         headers.set("Content-Type", "application/json");
         if (method.startsWith("private_")) {
           if (opts.signingKey === void 0) throw new Error(ClientUnauthorizedError);
-          if (body.length > MIN_GZIP_SIZE) {
-            body = await compress(body).catch((cause) => {
-              throw new Error(ClientCompressionError, { cause });
-            });
-            headers.set("Content-Encoding", "gzip");
-          }
-          const signature = await getSignature({ key: opts.signingKey, body }).catch((cause) => {
-            throw new Error(ClientSignatureError, { cause });
-          });
-          headers.set("X-Univo-Signature", signature);
+          headers.set("Authorization", `Bearer ${opts.signingKey}`);
+          body = await compress(body).catch((cause) => raise(ClientCompressionError, { cause }));
+          headers.set("Content-Encoding", "gzip");
         }
         const res = await fetch(url, { headers, body, method: "POST" }).catch((cause) => {
           throw new Error(ClientConnectionError, { cause });
@@ -37,7 +29,6 @@ function http(url, opts = {}) {
 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 ClientSignatureError = createException("An error occurred with the outgoing request signature");
 const ClientUnauthorizedError = createException("Attempted to execute a private method without providing a request signing key");
 
 export { http };

package/dist/index.d.mts

@@ -49,7 +49,6 @@ type Head = {
 type Metadata = {
     version: string;
     language: string;
-    max_concurrency: number | undefined;
 };
 type Result = {
     status: string;
@@ -69,10 +68,6 @@ type IndexerOptions<TBlock> = {
      * Request signing key
      */
     signingKey: string;
-    /**
-     * Maximum number of concurrent connections to open when backfilling blocks
-     */
-    maxConcurrency?: number;
     /**
      * This function is to load each block when indexing blocks in realtime. This ensures that all block
      * data processed originates from a trusted RPC source and can be safely relied on.

package/dist/index.d.ts

@@ -49,7 +49,6 @@ type Head = {
 type Metadata = {
     version: string;
     language: string;
-    max_concurrency: number | undefined;
 };
 type Result = {
     status: string;
@@ -69,10 +68,6 @@ type IndexerOptions<TBlock> = {
      * Request signing key
      */
     signingKey: string;
-    /**
-     * Maximum number of concurrent connections to open when backfilling blocks
-     */
-    maxConcurrency?: number;
     /**
      * This function is to load each block when indexing blocks in realtime. This ensures that all block
      * data processed originates from a trusted RPC source and can be safely relied on.

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { c as createLogger, v as verifySignature, d as decompress, a as createException, g as getException, h as hexToNumber, i as isAddressEqual, b as catchException, r as retry, e as version, n as nonNullable, f as getSignature } from './shared/univo.2F7MFHxq.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;
@@ -46,8 +46,7 @@ function indexer(opts) {
   const private_getMetadata = async () => {
     return {
       version,
-      language: "javascript",
-      max_concurrency: opts.maxConcurrency
+      language: "javascript"
     };
   };
   const private_getEvents = async () => {
@@ -448,24 +447,27 @@ function indexer(opts) {
         { status: 400 }
       );
     }
-    let authenticated = false;
-    const signature = req.headers.get("X-Univo-Signature");
-    if (signature) {
-      try {
-        authenticated = await verifySignature({ key: opts.signingKey, body: body_buffer, signature });
-      } catch {
+    const authorization = req.headers.get("Authorization");
+    const authenticated = authorization === `Bearer ${opts.signingKey}`;
+    let body_string;
+    if (req.headers.get("Content-Encoding") === "gzip") {
+      if (!authorization) {
         return Response.json(
-          { jsonrpc: "2.0", id: null, error: { code: 0, message: "Failed to verify request signature" } },
+          { jsonrpc: "2.0", id: null, error: { code: 0, message: "No bearer token provided" } },
+          //
+          { status: 400 }
+        );
+      }
+      if (!authenticated) {
+        return Response.json(
+          { jsonrpc: "2.0", id: null, error: { code: 0, message: "Invalid bearer token" } },
           //
           { status: 400 }
         );
       }
-    }
-    let body_string;
-    if (req.headers.get("Content-Encoding") === "gzip") {
       body_string = await decompress(body_buffer);
     } else {
-      body_string = new TextDecoder().decode(body_buffer);
+      body_string = decoder.decode(body_buffer);
     }
     let json;
     try {
@@ -478,16 +480,16 @@ function indexer(opts) {
       );
     }
     if (json.method.startsWith("private_")) {
-      if (!signature) {
+      if (!authorization) {
         return Response.json(
-          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "No request signature provided" } },
+          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "No bearer token provided" } },
           //
           { status: 400 }
         );
       }
-      if (!authenticated) {
+      if (authorization !== `Bearer ${opts.signingKey}`) {
         return Response.json(
-          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Invalid request signature" } },
+          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Invalid bearer token" } },
           //
           { status: 400 }
         );

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.2F7MFHxq.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.2F7MFHxq.mjs → univo.DSp9mW7b.mjs}

@@ -1,5 +1,5 @@
 const name = "univo";
-const version = "0.1.17";
+const version = "0.1.19";
 
 function createException(message) {
   return `univo:${message}`;
@@ -63,19 +63,6 @@ async function getSignature(opts) {
   const hmac = await crypto.subtle.sign("HMAC", key, opts.body);
   return [...new Uint8Array(hmac)].map((binary) => binary.toString(16).padStart(2, "0")).join("");
 }
-async function verifySignature(opts) {
-  const keyData = encoder.encode(opts.key);
-  const key = await crypto.subtle.importKey("raw", keyData, { name: "HMAC", hash: "SHA-256" }, false, ["verify"]);
-  const pairs = opts.signature.match(/[\da-f]{2}/gi);
-  if (!pairs) return false;
-  if (typeof opts.body === "string") {
-    const dataToAuthenticate = encoder.encode(opts.body);
-    const hmac2 = new Uint8Array(pairs.map((byte) => Number.parseInt(byte, 16))).buffer;
-    return await crypto.subtle.verify("HMAC", key, hmac2, dataToAuthenticate);
-  }
-  const hmac = new Uint8Array(pairs.map((byte) => Number.parseInt(byte, 16))).buffer;
-  return await crypto.subtle.verify("HMAC", key, hmac, opts.body);
-}
 function hexToNumber(hex) {
   return Number.parseInt(hex, 16);
 }
@@ -115,5 +102,6 @@ async function decompress(input) {
   const decompressed = new Blob([input]).stream().pipeThrough(new DecompressionStream("gzip"));
   return new Response(decompressed).text();
 }
+const decoder = new TextDecoder();
 
-export { createException as a, catchException as b, createLogger as c, decompress as d, version 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, verifySignature 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.17",
+	"version": "0.1.19",
 	"sideEffects": false,
 	"module": "./dist/index.mjs",
 	"types": "./dist/index.d.ts",