univo 0.4.1 → 0.4.3

package/dist/cli.mjs

@@ -5,7 +5,7 @@ import { config } from 'dotenv';
 import { WebSocket } from 'partysocket';
 import { defineCommand, runMain } from 'citty';
 import { http } from './transport.mjs';
-import { c as createLogger, v as version, f as name } from './shared/univo.DD1x3F1G.mjs';
+import { c as createLogger, v as version, n as name } from './shared/univo.DEUuEEoe.mjs';
 
 const log = createLogger({ quiet: false });
 const dev = defineCommand({

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-export { A as Action, B as Block, E as Event, F as Filter, H as Head, e as Indexer, f as PrivateMetadata, P as PublicMetadata, g as Result, c as defineAction, a as defineEvent, d as defineIndexer } from './shared/univo.BcZ0twA5.mjs';
+export { A as Action, B as Block, E as Event, F as Filter, H as Head, e as Indexer, f as PrivateMetadata, P as PublicMetadata, g as Result, c as defineAction, a as defineEvent, d as defineIndexer } from './shared/univo.Ckj3I8tQ.mjs';
 import 'viem';
 import './metadata.mjs';
 import './metadata/adapters.mjs';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { A as Action, B as Block, E as Event, F as Filter, H as Head, e as Indexer, f as PrivateMetadata, P as PublicMetadata, g as Result, c as defineAction, a as defineEvent, d as defineIndexer } from './shared/univo.CNIJRI7c.js';
+export { A as Action, B as Block, E as Event, F as Filter, H as Head, e as Indexer, f as PrivateMetadata, P as PublicMetadata, g as Result, c as defineAction, a as defineEvent, d as defineIndexer } from './shared/univo.7S1OTdpc.js';
 import 'viem';
 import './metadata.js';
 import './metadata/adapters.js';

package/dist/index.mjs

@@ -1,50 +1,122 @@
-import { hexToNumber, numberToHex, hexToBytes, keccak256, toRlp, hexToBigInt, formatTransaction, serializeTransaction, numberToBytes, isHex, concatBytes } from 'viem';
+import { hexToNumber, numberToHex, hexToBytes, keccak256, toRlp, hexToBigInt, numberToBytes, isHex, concatBytes, concatHex, formatTransaction, serializeTransaction } from 'viem';
 import { local } from './transport.mjs';
-import { c as createLogger, r as retry, v as version, n as normalizeHex, d as decompress, i as isHexEqual, a as compress, b as iife, e as decoder } from './shared/univo.DD1x3F1G.mjs';
+import { c as createLogger, r as retry, v as version, d as normalizeHex, e as decompress, a as isHexEqual, b as compress, i as iife, f as decoder } from './shared/univo.DEUuEEoe.mjs';
 import { AdapterError } from './metadata/adapters.mjs';
-import { c as createException, a as catchException } from './shared/univo.C0flyVee.mjs';
 import 'ws';
 import 'partysocket';
 
-function matchFilter(block, filter) {
-  if (!chainValid(block, filter)) return false;
-  if (!toBlockValid(block, filter)) return false;
-  if (!fromBlockValid(block, filter)) return false;
-  if (!includesLogEvent(block, filter)) return false;
-  if (!includesLogAddress(block, filter)) return false;
-  return true;
+function createException(message) {
+  return `univo:${message}`;
 }
-const chainValid = (block, filter) => {
-  if (hexToNumber(block.eth_chainId) === filter.chain) return true;
-  return false;
-};
-const fromBlockValid = (block, filter) => {
-  if (hexToNumber(block.eth_getBlockByNumber.number) >= filter.fromBlock) return true;
-  return false;
-};
-const toBlockValid = (block, filter) => {
-  if (filter.toBlock === void 0) return true;
-  if (hexToNumber(block.eth_getBlockByNumber.number) <= filter.toBlock) return true;
-  return false;
-};
-const includesLogAddress = (block, filter) => {
-  if (filter.address === void 0) return true;
-  for (const receipt of block.eth_getBlockReceipts) {
-    for (const log of receipt.logs) {
-      if (isHexEqual(log.address, filter.address)) return true;
+function catchException(unknown, exception) {
+  if (unknown instanceof Error) {
+    if (unknown.message === exception) {
+      return true;
     }
   }
   return false;
-};
-const includesLogEvent = (block, filter) => {
-  if (filter.event === void 0) return true;
-  for (const receipt of block.eth_getBlockReceipts) {
-    for (const log of receipt.logs) {
-      if (log.topics[0] === filter.event) return true;
+}
+
+function matchFilter(block, filter) {
+  if (hexToNumber(block.eth_chainId) !== filter.chain) {
+    return false;
+  }
+  if (hexToNumber(block.eth_getBlockByNumber.number) < filter.fromBlock) {
+    return false;
+  }
+  if (typeof filter.toBlock === "number" && hexToNumber(block.eth_getBlockByNumber.number) > filter.toBlock) {
+    return false;
+  }
+  if (filter.address && filter.event && filter.function) {
+    const txs = [];
+    for (const tx of block.eth_getBlockByNumber.transactions) {
+      if (tx.to !== null && isHexEqual(tx.to, filter.address)) {
+        if (isHexEqual(tx.input.slice(0, 10), filter.function)) {
+          txs.push(tx.transactionIndex);
+        }
+      }
+    }
+    for (const receipt of block.eth_getBlockReceipts) {
+      for (const log of receipt.logs) {
+        if (log.topics[0] !== void 0 && isHexEqual(log.topics[0], filter.event)) {
+          if (isHexEqual(log.address, filter.address)) {
+            if (txs.some((tx) => isHexEqual(tx, log.transactionIndex))) {
+              return true;
+            }
+          }
+        }
+      }
     }
+    return false;
   }
-  return false;
-};
+  if (filter.address && filter.event && filter.function === void 0) {
+    for (const receipt of block.eth_getBlockReceipts) {
+      for (const log of receipt.logs) {
+        if (log.topics[0] !== void 0 && isHexEqual(log.topics[0], filter.event)) {
+          if (isHexEqual(log.address, filter.address)) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  if (filter.address && filter.event === void 0 && filter.function) {
+    for (const tx of block.eth_getBlockByNumber.transactions) {
+      if (tx.to !== null && isHexEqual(tx.to, filter.address)) {
+        if (isHexEqual(tx.input.slice(0, 10), filter.function)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  if (filter.address === void 0 && filter.event && filter.function) {
+    const txs = [];
+    for (const tx of block.eth_getBlockByNumber.transactions) {
+      if (tx.to !== null && isHexEqual(tx.input.slice(0, 10), filter.function)) {
+        txs.push(tx.transactionIndex);
+      }
+    }
+    for (const receipt of block.eth_getBlockReceipts) {
+      for (const log of receipt.logs) {
+        if (log.topics[0] !== void 0 && isHexEqual(log.topics[0], filter.event)) {
+          if (txs.some((tx) => isHexEqual(tx, log.transactionIndex))) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  if (filter.address === void 0 && filter.event && filter.function === void 0) {
+    for (const receipt of block.eth_getBlockReceipts) {
+      for (const log of receipt.logs) {
+        if (log.topics[0] !== void 0 && isHexEqual(log.topics[0], filter.event)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  if (filter.address === void 0 && filter.event === void 0 && filter.function) {
+    for (const tx of block.eth_getBlockByNumber.transactions) {
+      if (tx.to !== null && isHexEqual(tx.input.slice(0, 10), filter.function)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  if (filter.address && filter.event === void 0 && filter.function === void 0) {
+    for (const tx of block.eth_getBlockByNumber.transactions) {
+      if (isHexEqual(tx.from, filter.address) || tx.to !== null && isHexEqual(tx.to, filter.address)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return true;
+}
 function defineEvent(event) {
   return event;
 }
@@ -298,6 +370,45 @@ function defineIndexer(opts) {
     const type = hexToBigInt(receipt.type);
     return type === 0n ? encoded : concatBytes([Uint8Array.of(Number(type)), encoded]);
   }
+  function serializeTransaction$1(tx) {
+    if (tx.type === "0x4") {
+      return concatHex([
+        "0x04",
+        toRlp([
+          quantityToBytes(tx.chainId),
+          quantityToBytes(tx.nonce),
+          quantityToBytes(tx.maxPriorityFeePerGas),
+          quantityToBytes(tx.maxFeePerGas),
+          quantityToBytes(tx.gas),
+          hexToBytes(tx.to),
+          quantityToBytes(tx.value),
+          hexToBytes(tx.input),
+          tx.accessList.map(({ address, storageKeys }) => [hexToBytes(address), storageKeys.map((key) => hexToBytes(key))]),
+          (tx.authorizationList ?? []).map((authorization) => [
+            quantityToBytes(authorization.chainId),
+            hexToBytes(authorization.address),
+            quantityToBytes(authorization.nonce),
+            quantityToBytes(authorization.yParity),
+            quantityToBytes(authorization.r),
+            quantityToBytes(authorization.s)
+          ]),
+          quantityToBytes(tx.yParity ?? tx.v),
+          quantityToBytes(tx.r),
+          quantityToBytes(tx.s)
+        ])
+      ]);
+    }
+    const { input, ...formatted } = formatTransaction(tx);
+    if (formatted.type === "legacy" && (formatted.v === 27n || formatted.v === 28n)) {
+      formatted.chainId = void 0;
+    }
+    const signature = formatted.type === "legacy" ? { r: formatted.r, s: formatted.s, v: formatted.v } : { r: formatted.r, s: formatted.s, yParity: formatted.yParity };
+    return serializeTransaction(
+      { ...formatted, data: input },
+      //
+      signature
+    );
+  }
   const SUPPORTED_TRANSACTION_TYPES = /* @__PURE__ */ new Set([0n, 1n, 2n, 3n, 4n]);
   function verifyTransactionsRoot(block) {
     const unsupportedTxs = block.eth_getBlockByNumber.transactions.filter((tx) => {
@@ -310,16 +421,7 @@ function defineIndexer(opts) {
       return log.warn("Unable to verify block `transactionsRoot` because of unsupported tx type");
     }
     const transactions = block.eth_getBlockByNumber.transactions.map((tx) => {
-      const { input, ...formatted } = formatTransaction(tx);
-      if (formatted.type === "legacy" && (formatted.v === 27n || formatted.v === 28n)) {
-        formatted.chainId = void 0;
-      }
-      const signature = formatted.type === "legacy" ? { r: formatted.r, s: formatted.s, v: formatted.v } : { r: formatted.r, s: formatted.s, yParity: formatted.yParity };
-      const serialized = serializeTransaction(
-        { ...formatted, data: input },
-        //
-        signature
-      );
+      const serialized = serializeTransaction$1(tx);
       if (!isHexEqual(tx.hash, keccak256(serialized))) {
         throw new Error(`Transaction ${tx.hash} failed serialization check`);
       }
@@ -930,6 +1032,7 @@ function defineIndexer(opts) {
             event: filter.event,
             address: filter.address,
             to_block: filter.toBlock,
+            function: filter.function,
             from_block: filter.fromBlock
           };
         });

package/dist/proxy.d.mts

@@ -1,4 +1,4 @@
-import { T as Transport, I as IndexerRpc } from './shared/univo.BcZ0twA5.mjs';
+import { T as Transport, I as IndexerRpc } from './shared/univo.Ckj3I8tQ.mjs';
 import 'viem';
 import './metadata.mjs';
 import './metadata/adapters.mjs';

package/dist/proxy.d.ts

@@ -1,4 +1,4 @@
-import { T as Transport, I as IndexerRpc } from './shared/univo.CNIJRI7c.js';
+import { T as Transport, I as IndexerRpc } from './shared/univo.7S1OTdpc.js';
 import 'viem';
 import './metadata.js';
 import './metadata/adapters.js';

package/dist/proxy.mjs

@@ -1,12 +1,39 @@
-import { g as getException } from './shared/univo.C0flyVee.mjs';
-import { c as createLogger, d as decompress, e as decoder } from './shared/univo.DD1x3F1G.mjs';
+import { c as createLogger } from './shared/univo.DEUuEEoe.mjs';
 
 function http(opts) {
   const log = createLogger({ quiet: opts.quiet, prefix: "[proxy]" });
   return async function proxy(req) {
-    let body_buffer;
+    const authorization = req.headers.get("Authorization");
+    const compressed = req.headers.get("Content-Encoding") === "gzip";
+    const authenticated = authorization === `Bearer ${opts.signingKey}`;
+    if (compressed && (!authorization || !authenticated)) {
+      return Response.json(
+        { jsonrpc: "2.0", id: null, error: { code: 0, message: "Invalid bearer token" } },
+        //
+        { status: 400 }
+      );
+    }
+    let body_string = "";
     try {
-      body_buffer = await req.arrayBuffer();
+      if (compressed) {
+        if (!req.body) {
+          throw new Error("Missing compressed request body");
+        }
+        const reader = req.body.pipeThrough(new DecompressionStream("gzip")).pipeThrough(new TextDecoderStream()).getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              break;
+            }
+            body_string += value;
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      } else {
+        body_string = await req.text();
+      }
     } catch {
       return Response.json(
         { jsonrpc: "2.0", id: null, error: { code: 0, message: "Invalid request body" } },
@@ -14,28 +41,6 @@ function http(opts) {
         { 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);
@@ -46,40 +51,21 @@ function http(opts) {
         { 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 }
-        );
-      }
+    if (json.method.startsWith("private_") && (!authorization || !authenticated)) {
+      return Response.json(
+        { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Invalid bearer token" } },
+        //
+        { status: 400 }
+      );
     }
     try {
       const result = await opts.indexer.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);
-      }
+      const message = error instanceof Error ? error.message : "Internal error";
+      log.error(message);
       return Response.json(
-        { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Internal server error" } },
+        { jsonrpc: "2.0", id: json.id, error: { code: 0, message } },
         //
         { status: 500 }
       );

package/dist/realtime.d.mts

@@ -1,4 +1,4 @@
-import { T as Transport, R as Rpc, I as IndexerRpc } from './shared/univo.BcZ0twA5.mjs';
+import { T as Transport, R as Rpc, I as IndexerRpc } from './shared/univo.Ckj3I8tQ.mjs';
 import 'viem';
 import './metadata.mjs';
 import './metadata/adapters.mjs';

package/dist/realtime.d.ts

@@ -1,4 +1,4 @@
-import { T as Transport, R as Rpc, I as IndexerRpc } from './shared/univo.CNIJRI7c.js';
+import { T as Transport, R as Rpc, I as IndexerRpc } from './shared/univo.7S1OTdpc.js';
 import 'viem';
 import './metadata.js';
 import './metadata/adapters.js';

package/dist/realtime.mjs

@@ -1,5 +1,5 @@
 import { hexToNumber } from 'viem';
-import { c as createLogger, b as iife, m as mutex, l as lifecycle, q as queue, r as retry, i as isHexEqual } from './shared/univo.DD1x3F1G.mjs';
+import { c as createLogger, i as iife, m as mutex, l as lifecycle, q as queue, r as retry, a as isHexEqual } from './shared/univo.DEUuEEoe.mjs';
 
 function defineBlockchain(opts) {
   const log = createLogger({ quiet: opts.quiet });
@@ -182,6 +182,7 @@ function realtime(realtime2) {
         }
       }
       const mutex_finalize = mutex(finalize);
+      void mutex_finalize();
       let chainFinalizedHeight = hexToNumber(chainFinalizedBlock.number);
       async function poll() {
         try {

package/dist/rpc.d.mts

@@ -1,4 +1,4 @@
-export { I as IndexerRpc, R as Rpc } from './shared/univo.BcZ0twA5.mjs';
+export { I as IndexerRpc, R as Rpc } from './shared/univo.Ckj3I8tQ.mjs';
 import 'viem';
 import './metadata.mjs';
 import './metadata/adapters.mjs';

package/dist/rpc.d.ts

@@ -1,4 +1,4 @@
-export { I as IndexerRpc, R as Rpc } from './shared/univo.CNIJRI7c.js';
+export { I as IndexerRpc, R as Rpc } from './shared/univo.7S1OTdpc.js';
 import 'viem';
 import './metadata.js';
 import './metadata/adapters.js';

package/dist/shared/{univo.CNIJRI7c.d.ts → univo.7S1OTdpc.d.ts}

@@ -119,21 +119,7 @@ type Flatten<T> = {
 };
 
 /**
- * The minimum RPC data required to process a block.
- *
- * Extend this interface in your application to expose additional RPC methods to every event:
- *
- * ```ts
- * import "univo";
- *
- * declare module "univo" {
- *   interface Block {
- *     eth_getBalance: `0x${string}`;
- *   }
- * }
- * ```
- *
- * Your `getBlock` function must also return any required fields added by the augmentation.
+ * Block
  */
 interface Block {
     eth_chainId: `0x${string}`;
@@ -154,6 +140,8 @@ type Filter = {
     event?: `0x${string}`;
     /** Index blocks that involve this address */
     address?: `0x${string}`;
+    /** Index blocks where this function signature was invoked */
+    function?: `0x${string}`;
 };
 /**
  * Events -----------------------------------------------------------------------------------------------------------------------------------

package/dist/shared/{univo.BcZ0twA5.d.mts → univo.Ckj3I8tQ.d.mts}

@@ -119,21 +119,7 @@ type Flatten<T> = {
 };
 
 /**
- * The minimum RPC data required to process a block.
- *
- * Extend this interface in your application to expose additional RPC methods to every event:
- *
- * ```ts
- * import "univo";
- *
- * declare module "univo" {
- *   interface Block {
- *     eth_getBalance: `0x${string}`;
- *   }
- * }
- * ```
- *
- * Your `getBlock` function must also return any required fields added by the augmentation.
+ * Block
  */
 interface Block {
     eth_chainId: `0x${string}`;
@@ -154,6 +140,8 @@ type Filter = {
     event?: `0x${string}`;
     /** Index blocks that involve this address */
     address?: `0x${string}`;
+    /** Index blocks where this function signature was invoked */
+    function?: `0x${string}`;
 };
 /**
  * Events -----------------------------------------------------------------------------------------------------------------------------------

package/dist/shared/{univo.DD1x3F1G.mjs → univo.DEUuEEoe.mjs}

@@ -1,5 +1,5 @@
 const name = "univo";
-const version = "0.4.1";
+const version = "0.4.3";
 
 function createLogger(opts) {
   const noop = (..._) => {
@@ -159,4 +159,4 @@ const normalizeHex = (hex, length) => {
   return `0x${hex.slice(2).toLowerCase().padStart(length, "0")}`;
 };
 
-export { compress as a, iife as b, createLogger as c, decompress as d, decoder as e, name as f, isHexEqual as i, lifecycle as l, mutex as m, normalizeHex as n, queue as q, retry as r, version as v };
+export { isHexEqual as a, compress as b, createLogger as c, normalizeHex as d, decompress as e, decoder as f, iife as i, lifecycle as l, mutex as m, name as n, queue as q, retry as r, version as v };

package/dist/transport.d.mts

@@ -1,4 +1,4 @@
-export { T as Transport, b as browser, h as http, l as local, w as wss } from './shared/univo.BcZ0twA5.mjs';
+export { T as Transport, b as browser, h as http, l as local, w as wss } from './shared/univo.Ckj3I8tQ.mjs';
 import 'viem';
 import './metadata.mjs';
 import './metadata/adapters.mjs';

package/dist/transport.d.ts

@@ -1,4 +1,4 @@
-export { T as Transport, b as browser, h as http, l as local, w as wss } from './shared/univo.CNIJRI7c.js';
+export { T as Transport, b as browser, h as http, l as local, w as wss } from './shared/univo.7S1OTdpc.js';
 import 'viem';
 import './metadata.js';
 import './metadata/adapters.js';

package/dist/transport.mjs

@@ -1,6 +1,6 @@
 import ws from 'ws';
 import { WebSocket } from 'partysocket';
-import { a as compress, c as createLogger, m as mutex } from './shared/univo.DD1x3F1G.mjs';
+import { b as compress, c as createLogger, m as mutex } from './shared/univo.DEUuEEoe.mjs';
 
 const DEFAULT_TIMEOUT_MS = 60 * 1e3;
 function local(rpc) {

package/package.json

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

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 };