univo 0.2.14 → 0.2.16

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.CzTm3CDN.mjs';
-import { c as createLogger, v as version, f as name } from './shared/univo.sqV2c2Yj.mjs';
+import { h as http } from './shared/univo.CkhykU8v.mjs';
+import { c as createLogger, v as version, b as name } from './shared/univo.BVikUbk_.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.DcmLb3Hn.mjs';
-import 'unstorage';
+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.DcmLb3Hn.js';
-import 'unstorage';
+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,8 +1,98 @@
-import { c as createException, a as catchException, l as local, g as getException } from './shared/univo.CzTm3CDN.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 } from './shared/univo.sqV2c2Yj.mjs';
+import { StorageError } from '@storagesdk/core';
+import { g as getException, c as createException, a as catchException, l as local } from './shared/univo.CkhykU8v.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.BVikUbk_.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;
@@ -48,48 +138,61 @@ function indexer(opts) {
   const events_grouped_by_storage_map = /* @__PURE__ */ new Map();
   const metadata = {
     blocks: {
-      async list(head) {
-        let prefix = `/blocks/v1/${normalizeHex(head.chain)}`;
-        if (typeof head.number === "string") {
-          prefix += `/${normalizeHex(head.number, 16)}`;
+      async getNextUnfinalizedBlock(chain) {
+        const prefix = `blocks/v1/${normalizeHex(chain)}`;
+        const keys = await opts.metadataStorage.list({ prefix, limit: 1 });
+        const [key] = keys.items;
+        if (key === void 0) {
+          return null;
         }
-        const keys = await opts.metadataStorage.getKeys(prefix);
-        return keys.map((key) => {
-          const [__, ___, chain, number, hash] = key.split(":");
-          return { chain, number, hash };
-        });
+        const [_, __, ___, number, hash] = key.path.split("/");
+        return { chain, number, hash };
       },
-      async get(head) {
-        let prefix = `/blocks/v1/${head.chain.toLowerCase()}`;
-        if (typeof head.number === "string") {
-          prefix += `/${normalizeHex(head.number, 16)}`;
+      async getBlocksByNumber(chain, number) {
+        const prefix = `blocks/v1/${normalizeHex(chain)}/${normalizeHex(number, 16)}`;
+        const keys = await opts.metadataStorage.list({ prefix });
+        if (keys.items.length === 0) {
+          return [];
         }
-        if (typeof head.hash === "string") {
-          if (head.number === void 0) {
-            throw new Error("Requested block by hash without specifying a block number");
-          }
-          prefix += `/${head.hash.toLowerCase()}`;
-          const block = await opts.metadataStorage.getItem(prefix);
-          if (block === null) {
-            return [];
+        const blocks = await Promise.all(
+          keys.items.map(async (item) => {
+            const blob = await opts.metadataStorage.download(item.path, { as: "blob" });
+            const block = await decompress(blob);
+            const parsed = JSON.parse(block);
+            return parsed;
+          })
+        );
+        return blocks;
+      },
+      async getBlockByNumberAndHash(chain, number, hash) {
+        const prefix = `blocks/v1/${normalizeHex(chain)}/${normalizeHex(number, 16)}/${normalizeHex(hash)}`;
+        const blob = await opts.metadataStorage.download(prefix, { as: "blob" }).catch((error) => {
+          if (error instanceof StorageError) {
+            if (error.code === "NotFound") {
+              return null;
+            }
           }
-          return [block];
+          throw error;
+        });
+        if (blob === null) {
+          return null;
         }
-        const keys = await opts.metadataStorage.getKeys(prefix);
-        const results = await opts.metadataStorage.getItems(keys);
-        return results.map((result) => result.value);
+        const block = await decompress(blob);
+        const parsed = JSON.parse(block);
+        return parsed;
       },
       async upsert(blocks) {
         if (blocks.length === 0) {
           return;
         }
-        await opts.metadataStorage.setItems(
-          blocks.map((block) => {
+        await Promise.all(
+          blocks.map(async (block) => {
             const chain = normalizeHex(block.eth_chainId);
             const hash = normalizeHex(block.eth_getBlockByNumber.hash);
             const number = normalizeHex(block.eth_getBlockByNumber.number, 16);
-            const key = `/blocks/v1/${chain}/${number}/${hash}`;
-            return { key, value: block };
+            const prefix = `blocks/v1/${chain}/${number}/${hash}`;
+            const compressed = await compress(JSON.stringify(block));
+            await opts.metadataStorage.upload(prefix, compressed);
           })
         );
       },
@@ -102,7 +205,8 @@ function indexer(opts) {
             const chain = normalizeHex(block.eth_chainId);
             const hash = normalizeHex(block.eth_getBlockByNumber.hash);
             const number = normalizeHex(block.eth_getBlockByNumber.number, 16);
-            await opts.metadataStorage.del(`/blocks/v1/${chain}/${number}/${hash}`);
+            const prefix = `blocks/v1/${chain}/${number}/${hash}`;
+            await opts.metadataStorage.delete(prefix);
           })
         );
       }
@@ -133,8 +237,8 @@ function indexer(opts) {
   }
   const GetBlockError = createException("Failed to load block from the provided `getBlock` function");
   const public_getFinalizedHeight = async (chain) => {
-    const [[stored], finalizedBlock] = await Promise.all([
-      metadata.blocks.list({ chain }),
+    const [stored, finalizedBlock] = await Promise.all([
+      metadata.blocks.getNextUnfinalizedBlock(chain),
       //
       getBlock({ chain, number: "finalized" })
     ]);
@@ -143,12 +247,68 @@ function indexer(opts) {
       throw new Error(GetBlockError);
     }
     const finalizedHeight = hexToNumber(finalizedBlock.eth_getBlockByNumber.number);
-    if (stored === void 0) {
+    if (stored === null) {
       return finalizedHeight;
     }
     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...");
@@ -231,11 +391,11 @@ function indexer(opts) {
   };
   const public_deleteReorganisedHead = async (head) => {
     log.debug(`Received reorganised head ${hexToNumber(head.number)}`);
-    const [canonical_block, [stored_block]] = await Promise.all([
+    const [canonical_block, stored_block] = await Promise.all([
       getBlock({ chain: head.chain, number: head.number }),
-      metadata.blocks.get({ chain: head.chain, number: head.number, hash: head.hash })
+      metadata.blocks.getBlockByNumberAndHash(head.chain, head.number, head.hash)
     ]);
-    if (stored_block === void 0) {
+    if (stored_block === null) {
       return log.debug("Reorganised block never/already processed");
     }
     if (canonical_block === null) {
@@ -299,8 +459,8 @@ function indexer(opts) {
       }
       previousHead = head;
     }
-    const [[unfinalizedMetadataBlock], finalizedBlock] = await Promise.all([
-      metadata.blocks.list({ chain }),
+    const [unfinalizedMetadataBlock, finalizedBlock] = await Promise.all([
+      metadata.blocks.getNextUnfinalizedBlock(chain),
       //
       getBlock({ chain, number: "finalized" })
     ]);
@@ -314,7 +474,7 @@ function indexer(opts) {
         throw new Error("Received head greater than chain finalized height");
       }
     }
-    if (unfinalizedMetadataBlock === void 0) {
+    if (unfinalizedMetadataBlock === null) {
       return log.debug("No heads to finalize, returning...");
     }
     const indexerHeight = hexToNumber(unfinalizedMetadataBlock.number) - 1;
@@ -330,10 +490,12 @@ 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.get({ chain: head.chain, number: head.number });
+      const processed = await metadata.blocks.getBlocksByNumber(head.chain, head.number);
       if (processed.length === 0) {
         await writeFinalizedHead(head, null);
         continue;
@@ -683,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,
@@ -696,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,7 +1,7 @@
 import { NodeRpc, IndexerRpc } from './rpc.mjs';
 import { Transport } from './transport.mjs';
-import './shared/univo.DcmLb3Hn.mjs';
-import 'unstorage';
+import './shared/univo.DdHfpTWq.mjs';
+import '@storagesdk/core';
 
 type RealtimeOptions = {
     /**

package/dist/realtime.d.ts

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

package/dist/realtime.mjs

@@ -1,17 +1,27 @@
-import { c as createLogger, b as iife, h as hexToNumber, e as numberToHex, m as mutex, r as retry, i as isHexEqual } from './shared/univo.sqV2c2Yj.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.BVikUbk_.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)
   };
 }
@@ -194,6 +199,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,5 +1,5 @@
-import { H as Head, M as Metadata, F as Flatten, a as Filter, B as Block, R as Result } from './shared/univo.DcmLb3Hn.mjs';
-import 'unstorage';
+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,5 +1,5 @@
-import { H as Head, M as Metadata, F as Flatten, a as Filter, B as Block, R as Result } from './shared/univo.DcmLb3Hn.js';
-import 'unstorage';
+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.sqV2c2Yj.mjs → univo.BVikUbk_.mjs}

@@ -1,5 +1,5 @@
 const name = "univo";
-const version = "0.2.14";
+const version = "0.2.16";
 
 function createLogger(opts) {
   let prefix = `[${name}@${version}]`;
@@ -78,6 +78,10 @@ async function compress(input) {
   return new Response(compressed).arrayBuffer();
 }
 async function decompress(input) {
+  if (input instanceof Blob) {
+    const decompressed2 = input.stream().pipeThrough(new DecompressionStream("gzip"));
+    return new Response(decompressed2).text();
+  }
   const decompressed = new Blob([input]).stream().pipeThrough(new DecompressionStream("gzip"));
   return new Response(decompressed).text();
 }
@@ -89,4 +93,4 @@ const normalizeHex = (hex, length) => {
   return `0x${hex.slice(2).toLowerCase().padStart(length, "0")}`;
 };
 
-export { decoder as a, iife as b, createLogger as c, decompress as d, numberToHex as e, name as f, compress 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.CzTm3CDN.mjs → univo.CkhykU8v.mjs}

@@ -1,6 +1,6 @@
 import ws from 'ws';
 import { WebSocket } from 'partysocket';
-import { g as compress, j as raise, c as createLogger } from './univo.sqV2c2Yj.mjs';
+import { g as compress, j as raise, c as createLogger } from './univo.BVikUbk_.mjs';
 
 function createException(message) {
   return `univo:${message}`;

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

@@ -1,4 +1,4 @@
-import { Storage } from 'unstorage';
+import { Storage } from '@storagesdk/core';
 
 type CamelToSnake<T extends string, P extends string = ""> = string extends T ? string : T extends `${infer C0}${infer R}` ? CamelToSnake<R, `${P}${C0 extends Lowercase<C0> ? "" : "_"}${Lowercase<C0>}`> : P;
 type Flatten<T> = {
@@ -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.DcmLb3Hn.d.ts → univo.DdHfpTWq.d.ts}

@@ -1,4 +1,4 @@
-import { Storage } from 'unstorage';
+import { Storage } from '@storagesdk/core';
 
 type CamelToSnake<T extends string, P extends string = ""> = string extends T ? string : T extends `${infer C0}${infer R}` ? CamelToSnake<R, `${P}${C0 extends Lowercase<C0> ? "" : "_"}${Lowercase<C0>}`> : P;
 type Flatten<T> = {
@@ -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/transport.d.mts

@@ -1,6 +1,6 @@
 import { Rpc } from './rpc.mjs';
-import './shared/univo.DcmLb3Hn.mjs';
-import 'unstorage';
+import './shared/univo.DdHfpTWq.mjs';
+import '@storagesdk/core';
 
 type Protocol = "http" | "wss" | "local";
 type Transport<R extends Rpc, P extends Protocol = Protocol> = {

package/dist/transport.d.ts

@@ -1,6 +1,6 @@
 import { Rpc } from './rpc.js';
-import './shared/univo.DcmLb3Hn.js';
-import 'unstorage';
+import './shared/univo.DdHfpTWq.js';
+import '@storagesdk/core';
 
 type Protocol = "http" | "wss" | "local";
 type Transport<R extends Rpc, P extends Protocol = Protocol> = {

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.CzTm3CDN.mjs';
-import './shared/univo.sqV2c2Yj.mjs';
+export { h as http, l as local, w as wss } from './shared/univo.CkhykU8v.mjs';
+import './shared/univo.BVikUbk_.mjs';

package/package.json

@@ -2,7 +2,7 @@
 	"name": "univo",
 	"license": "MIT",
 	"type": "module",
-	"version": "0.2.14",
+	"version": "0.2.16",
 	"sideEffects": false,
 	"module": "./dist/index.mjs",
 	"types": "./dist/index.d.ts",
@@ -54,6 +54,7 @@
 		"vitest": "^3.1.3"
 	},
 	"peerDependencies": {
-		"unstorage": ">=1"
+		"@storagesdk/core": ">=0.4.2",
+		"@storagesdk/adapters": ">=0.6.0"
 	}
 }