univo 0.1.15

package/dist/index.mjs

@@ -0,0 +1,516 @@
+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.rTUTP64t.mjs';
+
+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;
+}
+const chainValid = (block, filter) => {
+  if (hexToNumber(block.eth_chainId) === filter.chain) return true;
+  return false;
+};
+const fromBlockValid = (block, filter) => {
+  if (hexToNumber(block.eth_getBlockByHash.number) >= filter.fromBlock) return true;
+  return false;
+};
+const toBlockValid = (block, filter) => {
+  if (filter.toBlock === void 0) return true;
+  if (hexToNumber(block.eth_getBlockByHash.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 (isAddressEqual(log.address, filter.address)) 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;
+    }
+  }
+  return false;
+};
+function indexer(opts) {
+  const log = createLogger({ quiet: opts.quiet || false });
+  const all_events = [];
+  const events_grouped_by_storage_map = /* @__PURE__ */ new Map();
+  const private_getMetadata = async () => {
+    return {
+      version,
+      language: "javascript",
+      max_concurrency: opts.maxConcurrency
+    };
+  };
+  const private_getEvents = async () => {
+    return all_events.map((event2) => {
+      const filters = event2.filters.map((filter) => {
+        return {
+          chain: filter.chain,
+          event: filter.event,
+          address: filter.address,
+          to_block: filter.toBlock,
+          from_block: filter.fromBlock
+        };
+      });
+      return { id: event2.id, filters };
+    });
+  };
+  const createResultsForEndpoint = async (endpoint, results) => {
+    const body = JSON.stringify({ endpoint, results });
+    const signature = await getSignature({ body, key: opts.signingKey });
+    const res = await fetch("https://api.univo.app/v1/results", {
+      body,
+      method: "POST",
+      headers: {
+        "X-Univo-Signature": signature,
+        "Content-Type": "application/json"
+      }
+    });
+    if (res.status !== 200) throw new Error("Received non-200 response from univo API");
+  };
+  const public_writeBlocks = async (endpoint, heads) => {
+    log.debug(`Received ${heads.length} heads...`);
+    const blocks_start = Date.now();
+    const results_map = {};
+    const blocks_nullable = await Promise.all(
+      heads.map(async (head) => {
+        try {
+          if (opts.getBlock === void 0) {
+            throw new Error("Provide a `getBlock` function to `serve` so that univo can process events in realtime");
+          }
+          return await retry(opts.getBlock, [head], 2).catch(() => {
+            throw new Error("Failed to load block from the provided `getBlock` function after 3 attempts");
+          });
+        } catch (error) {
+          if (error instanceof Error) {
+            log.error(error.message);
+          }
+          for (const event2 of all_events) {
+            const event_id = event2.id;
+            const chain = head.chain;
+            const block_hash = head.hash;
+            const block_number = head.number;
+            results_map[chain + block_number + block_hash + event_id] ??= {
+              status: "block_error",
+              event_id,
+              chain,
+              block_hash,
+              block_number,
+              created_at: Date.now()
+            };
+          }
+          return null;
+        }
+      })
+    );
+    const blocks = blocks_nullable.filter(nonNullable);
+    log.debug(`Loaded ${blocks.length} block(s) in ${Date.now() - blocks_start}ms`);
+    if (blocks.length > 0) {
+      const events_start = Date.now();
+      const promises = events_grouped_by_storage_map.entries().map(async ([storage, grouped_events]) => {
+        const batch = [];
+        for (const block of blocks) {
+          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) {
+              if (error instanceof Error) {
+                log.error(error.message);
+              }
+              const event_id = event2.id;
+              const chain = block.eth_chainId;
+              const block_hash = block.eth_getBlockByHash.hash;
+              const block_number = block.eth_getBlockByHash.number;
+              results_map[chain + block_number + block_hash + event_id] ??= {
+                status: "handler_error",
+                event_id,
+                chain,
+                block_hash,
+                block_number,
+                created_at: Date.now()
+              };
+            }
+          }
+        }
+        if (batch.length > 0) {
+          const start = Date.now();
+          await retry(storage.upsert, [batch], 2).catch((error) => {
+            if (error instanceof Error) {
+              log.error(error.message);
+            }
+            for (const block of blocks) {
+              for (const event2 of grouped_events) {
+                if (!event2.filters.some((filter) => matchFilter(block, filter))) {
+                  continue;
+                }
+                const event_id = event2.id;
+                const chain = block.eth_chainId;
+                const block_hash = block.eth_getBlockByHash.hash;
+                const block_number = block.eth_getBlockByHash.number;
+                results_map[chain + block_number + block_hash + event_id] ??= {
+                  status: "upsert_error",
+                  event_id,
+                  chain,
+                  block_hash,
+                  block_number,
+                  created_at: Date.now()
+                };
+              }
+            }
+          });
+          for (const event2 of grouped_events) {
+            log.debug(`Recorded ${batch.length} ${event2.id} in ${Date.now() - start}ms`);
+          }
+        }
+        for (const block of blocks) {
+          for (const event2 of grouped_events) {
+            if (!event2.filters.some((filter) => matchFilter(block, filter))) continue;
+            const event_id = event2.id;
+            const chain = block.eth_chainId;
+            const block_hash = block.eth_getBlockByHash.hash;
+            const block_number = block.eth_getBlockByHash.number;
+            results_map[chain + block_number + block_hash + event_id] ??= {
+              status: "ok",
+              event_id,
+              chain,
+              block_hash,
+              block_number,
+              created_at: Date.now()
+            };
+          }
+        }
+      });
+      await Promise.all(promises);
+      log.debug(`Wrote ${heads.length} heads in ${Date.now() - events_start}ms`);
+    }
+    const results_array = Object.values(results_map);
+    if (results_array.length === 0) return log.debug(`No results to record for ${heads.length} heads`);
+    try {
+      await retry(createResultsForEndpoint, [endpoint, results_array], 2);
+      log.debug(`Recorded ${results_array.length} results`);
+    } catch (error) {
+      log.error("Failed to submit realtime results to univo after 3 attempts");
+    }
+  };
+  const ignored = [
+    "toJSON",
+    "toString",
+    "valueOf",
+    "inspect",
+    "constructor",
+    "hasOwnProperty",
+    "isPrototypeOf",
+    "propertyIsEnumerable",
+    "__proto__",
+    "__defineGetter__",
+    "__defineSetter__",
+    "__lookupGetter__",
+    "__lookupSetter__"
+  ];
+  const getWriteEventsProxy = (value, error) => {
+    const createProxyHandler = (path) => {
+      return {
+        get(target, key, receiver) {
+          const value2 = Reflect.get(target, key, receiver);
+          if (Array.isArray(target)) {
+            if (typeof value2 === "object" && value2 !== null) {
+              return new Proxy(value2, createProxyHandler());
+            }
+            return value2;
+          }
+          if (value2 === void 0) {
+            if (ignored.some((ignored2) => key.endsWith(ignored2))) {
+              return value2;
+            }
+            throw error;
+          }
+          if (typeof value2 === "object" && value2 !== null) {
+            return new Proxy(value2, createProxyHandler());
+          }
+          return value2;
+        }
+      };
+    };
+    return new Proxy(value, createProxyHandler());
+  };
+  const private_writeEvents = async (params) => {
+    if (all_events.length === 0) return { failures: [] };
+    const relevant_events = all_events.filter((event2) => params.events.includes(event2.id));
+    if (relevant_events.length === 0) return { failures: [] };
+    if (params.events.length === 0) return { failures: [] };
+    const failures = {};
+    const proxied_blocks = getWriteEventsProxy(params.blocks, new Error(IncompleteBlockError));
+    const promises = events_grouped_by_storage_map.entries().map(async ([storage, grouped_events]) => {
+      const batch = [];
+      for (const event2 of grouped_events) {
+        if (!params.events.includes(event2.id)) continue;
+        for (const block of proxied_blocks) {
+          try {
+            if (!event2.filters.some((filter) => matchFilter(block, filter))) continue;
+            const events = event2.handler(block);
+            for (const event3 of events) batch.push(event3);
+          } catch (error) {
+            const status = catchException(error, IncompleteBlockError) ? "incomplete_error" : "handler_error";
+            if (status === "handler_error") {
+              if (error instanceof Error) {
+                log.error(error.message);
+              }
+            }
+            failures[event2.id + block.eth_getBlockByHash.number] ??= {
+              status,
+              event_id: event2.id,
+              chain: block.eth_chainId,
+              block_hash: block.eth_getBlockByHash.hash,
+              block_number: block.eth_getBlockByHash.number,
+              created_at: Date.now()
+            };
+          }
+        }
+      }
+      if (batch.length === 0) return;
+      const start = Date.now();
+      await retry(storage.upsert, [batch], 2).catch((error) => {
+        const status = catchException(error, IncompleteBlockError) ? "incomplete_error" : "upsert_error";
+        if (status === "upsert_error") {
+          if (error instanceof Error) {
+            log.error(error.message);
+          }
+        }
+        for (const event2 of relevant_events) {
+          for (const block of proxied_blocks) {
+            if (!event2.filters.some((filter) => matchFilter(block, filter))) continue;
+            failures[event2.id + block.eth_getBlockByHash.number] ??= {
+              status,
+              event_id: event2.id,
+              chain: block.eth_chainId,
+              block_hash: block.eth_getBlockByHash.hash,
+              block_number: block.eth_getBlockByHash.number,
+              created_at: Date.now()
+            };
+          }
+        }
+      });
+      const stop = Date.now() - start;
+      for (const event2 of relevant_events) {
+        log.debug(`Recorded ${batch.length} ${event2.id} in ${stop}ms`);
+      }
+    });
+    await Promise.all(promises);
+    const failures_array = Object.values(failures);
+    return { failures: failures_array };
+  };
+  const private_writeEventsAndGetKeys = async (params) => {
+    if (all_events.length === 0) return { results: [], keys: [] };
+    if (params.events.length === 0) return { results: [], keys: [] };
+    const relevant_events = all_events.filter((event2) => params.events.includes(event2.id));
+    if (relevant_events.length === 0) return { results: [], keys: [] };
+    const keys = /* @__PURE__ */ new Set();
+    const results = {};
+    function createProxyHandler(path) {
+      return {
+        get(target, key, receiver) {
+          const value = Reflect.get(target, key, receiver);
+          if (Array.isArray(target)) {
+            if (typeof value === "object" && value !== null) {
+              return new Proxy(value, createProxyHandler(path));
+            }
+            return value;
+          }
+          keys.add(path + key);
+          if (typeof value === "object" && value !== null) {
+            const delimiter = Array.isArray(value) ? "/" : ".";
+            return new Proxy(value, createProxyHandler(path + key + delimiter));
+          }
+          return value;
+        }
+      };
+    }
+    const proxy = new Proxy(params.block, createProxyHandler(""));
+    await Promise.all(
+      relevant_events.map(async (event2) => {
+        if (!event2.filters.some((filter) => matchFilter(proxy, filter))) {
+          return;
+        }
+        let events = [];
+        try {
+          events = event2.handler(proxy);
+        } catch (error) {
+          if (error instanceof Error) {
+            log.error(error.message);
+          }
+          results[event2.id + proxy.eth_getBlockByHash.number] = {
+            status: "handler_error",
+            event_id: event2.id,
+            chain: proxy.eth_chainId,
+            block_hash: proxy.eth_getBlockByHash.hash,
+            block_number: proxy.eth_getBlockByHash.number,
+            created_at: Date.now()
+          };
+          return;
+        }
+        if (events.length === 0) {
+          results[event2.id + proxy.eth_getBlockByHash.number] = {
+            status: "ok",
+            event_id: event2.id,
+            chain: proxy.eth_chainId,
+            block_hash: proxy.eth_getBlockByHash.hash,
+            block_number: proxy.eth_getBlockByHash.number,
+            created_at: Date.now()
+          };
+          return;
+        }
+        try {
+          const start = Date.now();
+          await event2.storage.upsert(events);
+          log.debug(`Recorded ${events.length} ${event2.id} in ${Date.now() - start}ms`);
+        } catch (error) {
+          if (error instanceof Error) {
+            log.error(error.message);
+          }
+          results[event2.id + proxy.eth_getBlockByHash.number] = {
+            status: "upsert_error",
+            event_id: event2.id,
+            chain: proxy.eth_chainId,
+            block_hash: proxy.eth_getBlockByHash.hash,
+            block_number: proxy.eth_getBlockByHash.number,
+            created_at: Date.now()
+          };
+          return;
+        }
+        results[event2.id + proxy.eth_getBlockByHash.number] = {
+          status: "ok",
+          event_id: event2.id,
+          chain: proxy.eth_chainId,
+          block_hash: proxy.eth_getBlockByHash.hash,
+          block_number: proxy.eth_getBlockByHash.number,
+          created_at: Date.now()
+        };
+      })
+    );
+    const results_array = Object.values(results);
+    const keys_array = Array.from(keys);
+    const filtered_keys = keys_array.filter((key, i) => {
+      if (ignored.some((ignored2) => key.endsWith(ignored2))) return false;
+      if (keys_array.some((_key) => _key.startsWith(`${key}/`) || _key.startsWith(`${key}.`))) return false;
+      return true;
+    });
+    return { results: results_array, keys: filtered_keys };
+  };
+  const rpc = {
+    public_writeBlocks,
+    private_getEvents,
+    private_getMetadata,
+    private_writeEvents,
+    private_writeEventsAndGetKeys
+  };
+  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 handler = async (req) => {
+    let body_buffer;
+    try {
+      body_buffer = new Uint8Array(await req.arrayBuffer());
+    } catch {
+      return Response.json(
+        { jsonrpc: "2.0", id: null, error: { code: 0, message: "Invalid request body" } },
+        //
+        { 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 {
+        return Response.json(
+          { jsonrpc: "2.0", id: null, error: { code: 0, message: "Failed to verify request signature" } },
+          //
+          { 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);
+    }
+    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 (!signature) {
+        return Response.json(
+          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "No request signature provided" } },
+          //
+          { status: 400 }
+        );
+      }
+      if (!authenticated) {
+        return Response.json(
+          { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Invalid request signature" } },
+          //
+          { status: 400 }
+        );
+      }
+    }
+    try {
+      if (rpc[json.method] === void 0) throw new Error(UnknownMethodError);
+      const result = await rpc[json.method](...json.params);
+      return Response.json({ jsonrpc: "2.0", id: json.id, result });
+    } catch (error) {
+      const message = getException(error);
+      if (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 { fetch: handler, event };
+}
+const UnknownMethodError = createException("The requested method does not exist");
+const IncompleteBlockError = createException("Received block with missing required property");
+
+export { indexer, matchFilter };

package/dist/realtime.d.mts

@@ -0,0 +1,50 @@
+/**
+ * Transport -----------------------------------------------------------------------------------------------------------------------------------
+ */
+type Transport = {
+    request(opts: {
+        method: string;
+        params: any[];
+    }): Promise<any>;
+    subscribe(param: string, handler: (message: any) => void): Promise<{
+        unsubscribe(): Promise<void>;
+    }>;
+};
+declare function defineTransport(url: string): Transport;
+/**
+ * Blockchain -----------------------------------------------------------------------------------------------------------------------------------
+ */
+type Head = {
+    chain: `0x${string}`;
+    hash: `0x${string}`;
+    number: `0x${string}`;
+    parentHash: `0x${string}`;
+};
+/**
+ * Stream -----------------------------------------------------------------------------------------------------------------------------------
+ */
+type Handler = (head: Head) => Promise<void> | void;
+type Stream = {
+    on(event: "block", handler: Handler): {
+        unsubscribe: () => void;
+    };
+};
+type CreateRealtimeStreamOpts = {
+    quiet: boolean;
+    transport: Transport;
+};
+declare function createRealtimeStream(opts: CreateRealtimeStreamOpts): Stream;
+/**
+ * Realtime -----------------------------------------------------------------------------------------------------------------------------------
+ */
+type RealtimeOptions = {
+    /** Custom transport */
+    transport: Transport;
+    /** Endpoints to publish realtime blocks to */
+    endpoints: string[];
+    /** Logs are emitted based on the environment LOG_LEVEL. Set `quiet: true` to surpress all logs. */
+    quiet?: boolean;
+};
+declare function realtime(opts: RealtimeOptions): void;
+
+export { createRealtimeStream, defineTransport, realtime };

package/dist/realtime.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Transport -----------------------------------------------------------------------------------------------------------------------------------
+ */
+type Transport = {
+    request(opts: {
+        method: string;
+        params: any[];
+    }): Promise<any>;
+    subscribe(param: string, handler: (message: any) => void): Promise<{
+        unsubscribe(): Promise<void>;
+    }>;
+};
+declare function defineTransport(url: string): Transport;
+/**
+ * Blockchain -----------------------------------------------------------------------------------------------------------------------------------
+ */
+type Head = {
+    chain: `0x${string}`;
+    hash: `0x${string}`;
+    number: `0x${string}`;
+    parentHash: `0x${string}`;
+};
+/**
+ * Stream -----------------------------------------------------------------------------------------------------------------------------------
+ */
+type Handler = (head: Head) => Promise<void> | void;
+type Stream = {
+    on(event: "block", handler: Handler): {
+        unsubscribe: () => void;
+    };
+};
+type CreateRealtimeStreamOpts = {
+    quiet: boolean;
+    transport: Transport;
+};
+declare function createRealtimeStream(opts: CreateRealtimeStreamOpts): Stream;
+/**
+ * Realtime -----------------------------------------------------------------------------------------------------------------------------------
+ */
+type RealtimeOptions = {
+    /** Custom transport */
+    transport: Transport;
+    /** Endpoints to publish realtime blocks to */
+    endpoints: string[];
+    /** Logs are emitted based on the environment LOG_LEVEL. Set `quiet: true` to surpress all logs. */
+    quiet?: boolean;
+};
+declare function realtime(opts: RealtimeOptions): void;
+
+export { createRealtimeStream, defineTransport, realtime };