univo 0.2.15 → 0.2.17

package/dist/cli.mjs

@@ -4,8 +4,8 @@ import open from 'open';
 import { config } from 'dotenv';
 import { WebSocket } from 'partysocket';
 import { defineCommand, runMain } from 'citty';
-import { h as http } from './shared/univo.O0SoVQWh.mjs';
-import { c as createLogger, v as version, g as name } from './shared/univo.BgwFxZpJ.mjs';
+import { h as http } from './shared/univo.DgQqsZEe.mjs';
+import { c as createLogger, v as version, b as name } from './shared/univo.BMmU53c6.mjs';
 
 const log = createLogger({ quiet: false });
 const dev = defineCommand({
@@ -18,39 +18,47 @@ const dev = defineCommand({
   },
   async run(ctx) {
     try {
-      if (!ctx.args.url.startsWith("http://")) throw new Error("`url` must start with http://");
-      config();
+      if (!ctx.args.url.startsWith("http://")) {
+        throw new Error("`url` must start with http://");
+      }
+      config({ quiet: true });
       const localSigningKey = process.env.UNIVO_SIGNING_KEY;
-      if (localSigningKey === void 0) throw new Error("Please provide a UNIVO_SIGNING_KEY environment variable");
+      if (localSigningKey === void 0) {
+        throw new Error("Please provide a UNIVO_SIGNING_KEY environment variable");
+      }
       const client = http(ctx.args.url, { signingKey: localSigningKey });
-      const [events, metadata] = await Promise.all([
-        client.request({ method: "private_getEvents", params: [] }),
-        client.request({ method: "private_getMetadata", params: [] })
-      ]);
+      await client.request({ method: "private_getMetadata", params: [] }).catch(() => {
+        throw new Error(`Failed to connect to ${ctx.args.url}. Check that your server is running on the correct port.`);
+      });
       const remoteSigningKey = crypto.randomUUID();
       const url = `https://tunnel-univo.app/v1/${crypto.randomUUID()}`;
       const endpoint = {
         url,
-        events,
-        metadata,
         signing_key: remoteSigningKey
       };
-      const data = btoa(JSON.stringify(endpoint));
-      await open(`https://univo.app/dev/${data}`);
+      const encoder = new TextEncoder();
+      const data = encoder.encode(JSON.stringify(endpoint));
+      const encoded = data.toBase64({ alphabet: "base64url", omitPadding: true });
+      await open(`https://univo.app/dev/${encoded}`);
       const ws$1 = new WebSocket(url, [], { WebSocket: ws });
       ws$1.binaryType = "arraybuffer";
-      ws$1.onerror = (event) => log.error(event.message);
-      ws$1.onopen = () => log.info(`Dev server started for ${ctx.args.url}`);
-      ws$1.onclose = () => log.info(`Dev server closed for ${ctx.args.url}`);
+      ws$1.onerror = (event) => {
+        log.error(event.message);
+      };
+      ws$1.onopen = () => {
+        log.info(`Dev server started for ${ctx.args.url}`);
+      };
+      ws$1.onclose = () => {
+        log.info(`Dev server closed for ${ctx.args.url}`);
+      };
       ws$1.onmessage = async (event) => {
         try {
-          const request = JSON.parse(event.data);
-          log.info(`Received request ${request.id}:${request.method}`);
-          const response = await client.request(request);
-          ws$1.send(JSON.stringify(response));
-        } catch (error) {
-          const response = { jsonrpc: "2.0", id: null, error: { code: 0, message: "Invalid request" } };
-          ws$1.send(JSON.stringify(response));
+          const json = JSON.parse(event.data);
+          log.debug(`Received request (${json.id}) for method '${json.method}'`);
+          const result = await client.request({ method: json.method, params: json.params });
+          ws$1.send(JSON.stringify({ jsonrpc: "2.0", id: json.id, result }));
+        } catch {
+          ws$1.send(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: 0, message: "Invalid request" } }));
         }
       };
     } catch (error) {

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-export { B as Block, E as Event, a as Filter, H as Head, I as Indexer, M as Metadata, R as Result, i as indexer, m as matchFilter } from './shared/univo.CjvLVVxo.mjs';
+export { B as Block, E as Event, a as Filter, H as Head, I as Indexer, M as Metadata, R as Result, i as indexer } from './shared/univo.DdHfpTWq.mjs';
 import '@storagesdk/core';

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { B as Block, E as Event, a as Filter, H as Head, I as Indexer, M as Metadata, R as Result, i as indexer, m as matchFilter } from './shared/univo.CjvLVVxo.js';
+export { B as Block, E as Event, a as Filter, H as Head, I as Indexer, M as Metadata, R as Result, i as indexer } from './shared/univo.DdHfpTWq.js';
 import '@storagesdk/core';

package/dist/index.mjs

@@ -1,9 +1,98 @@
 import { StorageError } from '@storagesdk/core';
-import { c as createException, a as catchException, l as local, g as getException } from './shared/univo.O0SoVQWh.mjs';
-import { c as createLogger, r as retry, v as version, h as hexToNumber, i as isHexEqual, d as decompress, a as decoder, n as normalizeHex, b as compress } from './shared/univo.BgwFxZpJ.mjs';
+import { g as getException, c as createException, a as catchException, l as local } from './shared/univo.DgQqsZEe.mjs';
+import { c as createLogger, d as decompress, e as decoder, r as retry, v as version, h as hexToNumber, a as isHexEqual, f as normalizeHex, g as compress } from './shared/univo.BMmU53c6.mjs';
 import 'ws';
 import 'partysocket';
 
+function createServer(opts) {
+  const log = createLogger({ quiet: opts.quiet, prefix: "[server]" });
+  const http = async (req) => {
+    let body_buffer;
+    try {
+      body_buffer = await req.arrayBuffer();
+    } catch {
+      return Response.json(
+        { jsonrpc: "2.0", id: null, error: { code: 0, message: "Invalid request body" } },
+        //
+        { status: 400 }
+      );
+    }
+    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: "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 }
+        );
+      }
+      body_string = await decompress(body_buffer);
+    } else {
+      body_string = decoder.decode(body_buffer);
+    }
+    let json;
+    try {
+      json = JSON.parse(body_string);
+    } catch {
+      return Response.json(
+        { jsonrpc: "2.0", id: null, error: { code: 0, message: "Malformed JSON request body" } },
+        //
+        { status: 400 }
+      );
+    }
+    if (json.method.startsWith("private_")) {
+      if (!authorization) {
+        return Response.json(
+          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "No bearer token provided" } },
+          //
+          { status: 400 }
+        );
+      }
+      if (authorization !== `Bearer ${opts.signingKey}`) {
+        return Response.json(
+          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Invalid bearer token" } },
+          //
+          { status: 400 }
+        );
+      }
+    }
+    try {
+      const result = await opts.transport.request({ method: json.method, params: json.params });
+      return Response.json({ jsonrpc: "2.0", id: json.id, result });
+    } catch (error) {
+      const message = getException(error);
+      if (message) {
+        log.error(message);
+        return Response.json(
+          { jsonrpc: "2.0", id: json.id, error: { code: 0, message } },
+          //
+          { status: 400 }
+        );
+      }
+      if (error instanceof Error) {
+        log.error(error.message);
+      }
+      return Response.json(
+        { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Internal server error" } },
+        //
+        { status: 500 }
+      );
+    }
+  };
+  return {
+    http
+  };
+}
+
 function matchFilter(block, filter) {
   if (!chainValid(block, filter)) return false;
   if (!toBlockValid(block, filter)) return false;
@@ -164,6 +253,62 @@ function indexer(opts) {
     const indexerHeight = hexToNumber(stored.number) - 1;
     return Math.min(indexerHeight, finalizedHeight);
   };
+  const public_writeUnfinalizedHead = async (head) => {
+    log.debug("Received unfinalized head...");
+    const blocks_start = Date.now();
+    const [finalizedBlock, block] = await Promise.all([
+      getBlock({ chain: head.chain, number: "finalized" }),
+      getBlock({ chain: head.chain, number: head.number, hash: head.hash })
+    ]);
+    if (block === null) {
+      return;
+    }
+    if (finalizedBlock === null) {
+      log.debug("Failed to determine finalized height when processing unfinalized heads");
+      throw new Error(GetBlockError);
+    }
+    const finalizedHeight = hexToNumber(finalizedBlock.eth_getBlockByNumber.number);
+    if (hexToNumber(head.number) <= finalizedHeight) {
+      return;
+    }
+    log.debug(`Loaded block in ${Date.now() - blocks_start}ms`);
+    const metadata_start = Date.now();
+    await metadata.blocks.upsert([block]);
+    log.debug(`Persisted block to metadata in ${Date.now() - metadata_start}ms`);
+    const events_start = Date.now();
+    const promises = events_grouped_by_storage_map.entries().map(async ([storage, grouped_events]) => {
+      const batch = [];
+      for (const event2 of grouped_events) {
+        try {
+          if (!event2.filters.some((filter) => matchFilter(block, filter))) {
+            log.debug(`Block matches no filters for event ${event2.id}`);
+            continue;
+          }
+          const events = event2.handler(block);
+          for (const event3 of events) {
+            batch.push(event3);
+          }
+        } catch (error) {
+          log.error(`Failed to run your 'handler' for event ${event2.id}`);
+          throw error;
+        }
+      }
+      if (batch.length > 0) {
+        const start = Date.now();
+        await retry(() => storage.upsert(batch), 2).catch((error) => {
+          for (const event2 of grouped_events) {
+            log.error(`Failed to run your 'upsert' handler for event ${event2.id}`);
+          }
+          throw error;
+        });
+        for (const event2 of grouped_events) {
+          log.debug(`Recorded ${batch.length} ${event2.id} in ${Date.now() - start}ms`);
+        }
+      }
+    });
+    await Promise.all(promises);
+    log.debug(`Wrote head in ${Date.now() - events_start}ms`);
+  };
   const public_writeUnfinalizedHeads = async (heads) => {
     if (heads.length === 0) {
       return log.debug("No heads received, returning...");
@@ -345,7 +490,9 @@ function indexer(opts) {
       return log.debug("No new heads received, returning...");
     }
     if (hexToNumber(firstNewHead.number) !== indexerHeight + 1) {
-      throw new Error("Client advanced too far. Heads received are greater than the indexer height");
+      throw new Error(
+        `Client advanced too far (${hexToNumber(firstNewHead.number)}). Heads received are greater than the first new head ${indexerHeight + 1}`
+      );
     }
     for (const head of newHeads) {
       const processed = await metadata.blocks.getBlocksByNumber(head.chain, head.number);
@@ -698,10 +845,21 @@ function indexer(opts) {
     });
     return { results: results_array, keys: filtered_keys };
   };
+  const event = (event2) => {
+    if (!/^[A-Za-z0-9_-]+$/.test(event2.id)) {
+      throw new Error(`Invalid event id \`${event2.id}\`. Only characters A-Z, a-z, 0-9, underscores, and hyphens are permitted.`);
+    }
+    all_events.push(event2);
+    const group = events_grouped_by_storage_map.get(event2.storage) ?? [];
+    group.push(event2);
+    events_grouped_by_storage_map.set(event2.storage, group);
+    return event2;
+  };
   const rpc = {
     request: {
       public_getFinalizedHeight,
       public_writeFinalizedHeads,
+      public_writeUnfinalizedHead,
       public_writeUnfinalizedHeads,
       public_deleteReorganisedHead,
       private_getEvents,
@@ -711,105 +869,17 @@ function indexer(opts) {
     },
     subscribe: {}
   };
-  const transport = local(rpc);
-  const handler = async (req) => {
-    let body_buffer;
-    try {
-      body_buffer = await req.arrayBuffer();
-    } catch {
-      return Response.json(
-        { jsonrpc: "2.0", id: null, error: { code: 0, message: "Invalid request body" } },
-        //
-        { status: 400 }
-      );
-    }
-    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: "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 }
-        );
-      }
-      body_string = await decompress(body_buffer);
-    } else {
-      body_string = decoder.decode(body_buffer);
-    }
-    let json;
-    try {
-      json = JSON.parse(body_string);
-    } catch {
-      return Response.json(
-        { jsonrpc: "2.0", id: null, error: { code: 0, message: "Malformed JSON request body" } },
-        //
-        { status: 400 }
-      );
-    }
-    if (json.method.startsWith("private_")) {
-      if (!authorization) {
-        return Response.json(
-          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "No bearer token provided" } },
-          //
-          { status: 400 }
-        );
-      }
-      if (authorization !== `Bearer ${opts.signingKey}`) {
-        return Response.json(
-          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Invalid bearer token" } },
-          //
-          { status: 400 }
-        );
-      }
-    }
-    try {
-      const result = await transport.request({ method: json.method, params: json.params });
-      return Response.json({ jsonrpc: "2.0", id: json.id, result });
-    } catch (error) {
-      const message = getException(error);
-      if (message) {
-        log.error(message);
-        return Response.json(
-          { jsonrpc: "2.0", id: json.id, error: { code: 0, message } },
-          //
-          { status: 400 }
-        );
-      }
-      if (error instanceof Error) {
-        log.error(error.message);
-      }
-      return Response.json(
-        { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Internal server error" } },
-        //
-        { status: 500 }
-      );
-    }
-  };
-  const event = (event2) => {
-    if (!/^[A-Za-z0-9_-]+$/.test(event2.id)) {
-      throw new Error(`Invalid event id \`${event2.id}\`. Only characters A-Z, a-z, 0-9, underscores, and hyphens are permitted.`);
-    }
-    all_events.push(event2);
-    const group = events_grouped_by_storage_map.get(event2.storage) ?? [];
-    group.push(event2);
-    events_grouped_by_storage_map.set(event2.storage, group);
-    return event2;
-  };
+  const server = createServer({
+    transport: local(rpc),
+    quiet: opts.quiet ?? false,
+    signingKey: opts.signingKey
+  });
   const indexer2 = {
     ...rpc,
     event,
-    fetch: handler
+    fetch: server.http
   };
   return indexer2;
 }
 
-export { indexer, matchFilter };
+export { indexer };

package/dist/realtime.d.mts

@@ -1,6 +1,6 @@
 import { NodeRpc, IndexerRpc } from './rpc.mjs';
 import { Transport } from './transport.mjs';
-import './shared/univo.CjvLVVxo.mjs';
+import './shared/univo.DdHfpTWq.mjs';
 import '@storagesdk/core';
 
 type RealtimeOptions = {

package/dist/realtime.d.ts

@@ -1,6 +1,6 @@
 import { NodeRpc, IndexerRpc } from './rpc.js';
 import { Transport } from './transport.js';
-import './shared/univo.CjvLVVxo.js';
+import './shared/univo.DdHfpTWq.js';
 import '@storagesdk/core';
 
 type RealtimeOptions = {

package/dist/realtime.mjs

@@ -1,17 +1,27 @@
-import { c as createLogger, e as iife, h as hexToNumber, f as numberToHex, m as mutex, r as retry, i as isHexEqual } from './shared/univo.BgwFxZpJ.mjs';
+import { c as createLogger, i as iife, h as hexToNumber, n as numberToHex, m as mutex, r as retry, a as isHexEqual } from './shared/univo.BMmU53c6.mjs';
 
-const MAX_LENGTH = 1e4;
 function defineBlockchain(opts) {
   const log = createLogger({ quiet: opts.quiet });
   const chain = [];
+  function getHeadBlock() {
+    const block = chain[chain.length - 1];
+    if (block === void 0) {
+      throw new Error("Expected non-empty chain when retrieving latest block");
+    }
+    return block;
+  }
+  function getTailBlock() {
+    const block = chain[0];
+    if (block === void 0) {
+      throw new Error("Expected non-empty chain when retrieving oldest block");
+    }
+    return block;
+  }
   function setHeadBlock(newBlock) {
     chain.push(newBlock);
     if (opts.onBlockAdded) {
       opts.onBlockAdded(newBlock);
     }
-    if (chain.length > MAX_LENGTH) {
-      chain.shift();
-    }
   }
   function removeHeadBlock() {
     const head = chain.pop();
@@ -22,25 +32,19 @@ function defineBlockchain(opts) {
       opts.onBlockReorganised(head);
     }
   }
-  function getHeadBlock() {
-    const block = chain[chain.length - 1];
-    if (block === void 0) {
-      throw new Error("Expected non-empty chain when retrieving latest block");
+  async function prune(tail) {
+    if (hexToNumber(tail.number) >= hexToNumber(getHeadBlock().number)) {
+      throw new Error("Cannot remove head block");
     }
-    return block;
-  }
-  function getOldestBlock() {
-    const block = chain[0];
-    if (block === void 0) {
-      throw new Error("Expected non-empty chain when retrieving oldest block");
+    while (hexToNumber(tail.number) > hexToNumber(getTailBlock().number)) {
+      chain.shift();
     }
-    return block;
   }
   async function reconcile(newBlock) {
     if (chain.length === 0) {
       return setHeadBlock(newBlock);
     }
-    if (hexToNumber(newBlock.number) < hexToNumber(getOldestBlock().number)) {
+    if (hexToNumber(newBlock.number) < hexToNumber(getTailBlock().number)) {
       log.info(`Received block ${hexToNumber(newBlock.number)} older than our local chain`);
       throw new Error("Not implemented");
     }
@@ -74,6 +78,7 @@ function defineBlockchain(opts) {
   }
   return {
     chain,
+    prune: mutex(prune),
     reconcile: mutex(reconcile)
   };
 }
@@ -92,31 +97,25 @@ function realtime(opts) {
       opts.node.request({ method: "eth_getBlockByNumber", params: ["latest", false] }),
       opts.indexer.request({ method: "public_getFinalizedHeight", params: [chain] })
     ]);
-    let pending = [];
     const latest = defineBlockchain({
       getBlockByHash,
       quiet: opts.quiet ?? false,
       onBlockAdded: async (head) => {
         try {
           log.debug("Received unfinalized head");
-          pending.push(head);
-          const heads = pending.map((head2) => ({ chain, ...head2 }));
-          await opts.indexer.request({ method: "public_writeUnfinalizedHeads", params: [heads] });
-          log.debug(`Delivered ${heads.length} unfinalized head(s)`);
-          pending = pending.filter((head2) => {
-            return !heads.some((_head) => {
-              return isHexEqual(head2.hash, _head.hash);
-            });
-          });
+          await retry(() => opts.indexer.request({ method: "public_writeUnfinalizedHead", params: [{ chain, ...head }] }), 2);
+          log.debug("Delivered unfinalized head");
         } catch (error) {
           if (error instanceof Error) {
-            log.warn(`Failed to write heads: ${error.message}`);
+            log.warn(`Failed to write unfinalized head: ${error.message}`);
           }
         }
       },
       onBlockReorganised: async (head) => {
         try {
+          log.debug("Received reorganised head");
           await retry(() => opts.indexer.request({ method: "public_deleteReorganisedHead", params: [{ chain, ...head }] }), 2);
+          log.debug("Delivered reorganised head");
         } catch (error) {
           if (error instanceof Error) {
             log.warn(`Failed to write reorganised head: ${error.message}`);
@@ -194,6 +193,16 @@ function realtime(opts) {
         log.debug(`Delivered ${newHeads.length} finalized head(s)`);
         indexerHeight = hexToNumber(finalizedBlock.number);
         log.debug(`Updated indexer height to ${indexerHeight}`);
+        await indexer.prune({
+          number: finalizedBlock.number,
+          hash: finalizedBlock.hash,
+          parent_hash: finalizedBlock.parentHash
+        });
+        await latest.prune({
+          number: finalizedBlock.number,
+          hash: finalizedBlock.hash,
+          parent_hash: finalizedBlock.parentHash
+        });
       } catch (error) {
         if (error instanceof Error) {
           log.error(`Failed to reconcile finalized head: ${error.message}`);

package/dist/rpc.d.mts

@@ -1,4 +1,4 @@
-import { H as Head, M as Metadata, F as Flatten, a as Filter, B as Block, R as Result } from './shared/univo.CjvLVVxo.mjs';
+import { H as Head, M as Metadata, F as Flatten, a as Filter, B as Block, R as Result } from './shared/univo.DdHfpTWq.mjs';
 import '@storagesdk/core';
 
 type Rpc = {
@@ -54,6 +54,10 @@ type IndexerRpc = {
          * Accepts a reorganised block and deletes all related events from storage
          */
         public_deleteReorganisedHead: (head: Head) => Promise<void>;
+        /**
+         * Accepts an unfinalized head and writes all events to storage
+         */
+        public_writeUnfinalizedHead: (head: Head) => Promise<void>;
         /**
          * Accepts a list of the latest block heads and writes all events to storage
          */

package/dist/rpc.d.ts

@@ -1,4 +1,4 @@
-import { H as Head, M as Metadata, F as Flatten, a as Filter, B as Block, R as Result } from './shared/univo.CjvLVVxo.js';
+import { H as Head, M as Metadata, F as Flatten, a as Filter, B as Block, R as Result } from './shared/univo.DdHfpTWq.js';
 import '@storagesdk/core';
 
 type Rpc = {
@@ -54,6 +54,10 @@ type IndexerRpc = {
          * Accepts a reorganised block and deletes all related events from storage
          */
         public_deleteReorganisedHead: (head: Head) => Promise<void>;
+        /**
+         * Accepts an unfinalized head and writes all events to storage
+         */
+        public_writeUnfinalizedHead: (head: Head) => Promise<void>;
         /**
          * Accepts a list of the latest block heads and writes all events to storage
          */

package/dist/shared/{univo.BgwFxZpJ.mjs → univo.BMmU53c6.mjs}

@@ -1,5 +1,5 @@
 const name = "univo";
-const version = "0.2.15";
+const version = "0.2.17";
 
 function createLogger(opts) {
   let prefix = `[${name}@${version}]`;
@@ -93,4 +93,4 @@ const normalizeHex = (hex, length) => {
   return `0x${hex.slice(2).toLowerCase().padStart(length, "0")}`;
 };
 
-export { decoder as a, compress as b, createLogger as c, decompress as d, iife as e, numberToHex as f, name as g, hexToNumber as h, isHexEqual as i, raise as j, mutex as m, normalizeHex as n, retry as r, version as v };
+export { isHexEqual as a, name as b, createLogger as c, decompress as d, decoder as e, normalizeHex as f, compress as g, hexToNumber as h, iife as i, raise as j, mutex as m, numberToHex as n, retry as r, version as v };

package/dist/shared/{univo.CjvLVVxo.d.mts → univo.DdHfpTWq.d.mts}

@@ -38,7 +38,6 @@ type Filter = {
     /** Index blocks that involve this address */
     address?: `0x${string}`;
 };
-declare function matchFilter(block: Block, filter: Filter): boolean;
 /**
  * Events -----------------------------------------------------------------------------------------------------------------------------------
  */
@@ -192,6 +191,7 @@ declare function indexer<TBlock extends Block>(opts: IndexerOptions<TBlock>): {
     request: {
         public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number>;
         public_deleteReorganisedHead: (head: Head) => Promise<void>;
+        public_writeUnfinalizedHead: (head: Head) => Promise<void>;
         public_writeUnfinalizedHeads: (heads: Head[]) => Promise<void>;
         public_writeFinalizedHeads: (heads: Head[]) => Promise<void>;
         private_getMetadata: () => Promise<Metadata>;
@@ -216,5 +216,5 @@ declare function indexer<TBlock extends Block>(opts: IndexerOptions<TBlock>): {
     subscribe: Record<string, never>;
 };
 
-export { indexer as i, matchFilter as m };
+export { indexer as i };
 export type { Block as B, Event as E, Flatten as F, Head as H, Indexer as I, Metadata as M, Result as R, Filter as a };

package/dist/shared/{univo.CjvLVVxo.d.ts → univo.DdHfpTWq.d.ts}

@@ -38,7 +38,6 @@ type Filter = {
     /** Index blocks that involve this address */
     address?: `0x${string}`;
 };
-declare function matchFilter(block: Block, filter: Filter): boolean;
 /**
  * Events -----------------------------------------------------------------------------------------------------------------------------------
  */
@@ -192,6 +191,7 @@ declare function indexer<TBlock extends Block>(opts: IndexerOptions<TBlock>): {
     request: {
         public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number>;
         public_deleteReorganisedHead: (head: Head) => Promise<void>;
+        public_writeUnfinalizedHead: (head: Head) => Promise<void>;
         public_writeUnfinalizedHeads: (heads: Head[]) => Promise<void>;
         public_writeFinalizedHeads: (heads: Head[]) => Promise<void>;
         private_getMetadata: () => Promise<Metadata>;
@@ -216,5 +216,5 @@ declare function indexer<TBlock extends Block>(opts: IndexerOptions<TBlock>): {
     subscribe: Record<string, never>;
 };
 
-export { indexer as i, matchFilter as m };
+export { indexer as i };
 export type { Block as B, Event as E, Flatten as F, Head as H, Indexer as I, Metadata as M, Result as R, Filter as a };

package/dist/shared/{univo.O0SoVQWh.mjs → univo.DgQqsZEe.mjs}

@@ -1,6 +1,6 @@
 import ws from 'ws';
 import { WebSocket } from 'partysocket';
-import { b as compress, j as raise, c as createLogger } from './univo.BgwFxZpJ.mjs';
+import { g as compress, j as raise, c as createLogger } from './univo.BMmU53c6.mjs';
 
 function createException(message) {
   return `univo:${message}`;
@@ -22,6 +22,7 @@ function getException(unknown) {
   }
 }
 
+const DEFAULT_TIMEOUT = 60 * 1e3;
 const UnknownMethodError = createException("The requested RPC method does not exist on the provided implementation");
 function local(rpc) {
   const request = async (opts) => {
@@ -114,7 +115,7 @@ function wss(url, opts = {}) {
       const timeout = setTimeout(() => {
         requests.delete(body.id);
         reject(new Error("wss request timed out after 30 seconds"));
-      }, 30 * 1e3);
+      }, DEFAULT_TIMEOUT);
       requests.set(body.id, (data) => {
         clearTimeout(timeout);
         requests.delete(body.id);
@@ -194,7 +195,7 @@ function http(url, opts = {}) {
       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) => {
+    const res = await fetch(url, { headers, body, method: "POST", signal: AbortSignal.timeout(DEFAULT_TIMEOUT) }).catch((cause) => {
       throw new Error(ClientConnectionError, { cause });
     });
     if (!res.ok || res.status < 200 || res.status >= 300) {

package/dist/transport.d.mts

@@ -1,5 +1,5 @@
 import { Rpc } from './rpc.mjs';
-import './shared/univo.CjvLVVxo.mjs';
+import './shared/univo.DdHfpTWq.mjs';
 import '@storagesdk/core';
 
 type Protocol = "http" | "wss" | "local";

package/dist/transport.d.ts

@@ -1,5 +1,5 @@
 import { Rpc } from './rpc.js';
-import './shared/univo.CjvLVVxo.js';
+import './shared/univo.DdHfpTWq.js';
 import '@storagesdk/core';
 
 type Protocol = "http" | "wss" | "local";

package/dist/transport.mjs

@@ -1,4 +1,4 @@
 import 'ws';
 import 'partysocket';
-export { h as http, l as local, w as wss } from './shared/univo.O0SoVQWh.mjs';
-import './shared/univo.BgwFxZpJ.mjs';
+export { h as http, l as local, w as wss } from './shared/univo.DgQqsZEe.mjs';
+import './shared/univo.BMmU53c6.mjs';

package/package.json

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