univo 0.2.10 → 0.2.12

package/dist/cli.mjs

@@ -4,9 +4,8 @@ import open from 'open';
 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.DfCC9G2B.mjs';
-import './shared/univo.C0flyVee.mjs';
+import { h as http } from './shared/univo.Bb9Aplq9.mjs';
+import { c as createLogger, v as version, f as name } from './shared/univo.DicQZf-2.mjs';
 
 const log = createLogger({ quiet: false });
 const dev = defineCommand({

package/dist/index.d.mts

@@ -1,189 +1,2 @@
-import { Storage } from 'unstorage';
-
-/**
- * Block -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Block = {
-    eth_chainId: `0x${string}`;
-    eth_getBlockByNumber: {
-        hash: `0x${string}`;
-        number: `0x${string}`;
-        parentHash: `0x${string}`;
-    };
-    eth_getBlockReceipts: Array<{
-        blockHash: `0x${string}`;
-        logs: Array<{
-            address: `0x${string}`;
-            topics: `0x${string}`[];
-        }>;
-    }>;
-};
-/**
- * Filters -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Filter = {
-    /** Index blocks with this chain id */
-    chain: number;
-    /** Index blocks from this start block (inclusive) */
-    fromBlock: number;
-    /** Index blocks until this stop block (inclusive)  */
-    toBlock?: number;
-    /** Index blocks where this event topic was emitted */
-    event?: `0x${string}`;
-    /** Index blocks that involve this address */
-    address?: `0x${string}`;
-};
-declare function matchFilter(block: Block, filter: Filter): boolean;
-/**
- * Events -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Event<TBlock, TEvent> = {
-    /**
-     * A human-readable identifier for the event.
-     */
-    id: string;
-    /**
-     * Filters let you define what specific blocks you want this event to index.
-     *
-     * Blockchains are massive datasets and most of the time we are only ever interested in small portions of it.
-     * Sometimes that can be specific events like ERC20 transfers and other times it could be all events emitted
-     * by a specific contract. Filters provide a simple way for an event to define exactly which blocks we want
-     * to index.
-     *
-     * Filters reduce costs and improve backfill performance by ensuring we only index the blocks we need and
-     * ignore the blocks that don't have the data we are interested in.
-     *
-     * By default your event will not index any blocks, you must opt-in to indexing by providing atleast one filter.
-     *
-     * Each property in the filter operates like an AND statement. For example, if you specifiy an `address` and
-     * an `event` it implies that you only want to index blocks where the specific `address` emitted the specific
-     * `event` topic provided.
-     *
-     * However, when multiple filters are defined for a given event those filters operate like an OR statement. For
-     * example, if we define a second filter looking for a different `address` and `event` our event will now index
-     * any block that matches either the first filter or the second filter.
-     *
-     * Note that filters are a rudimentary method to dramatically reduce the number of blocks your application needs
-     * to index. Any advanced filtering should be performed in the event `handler` itself.
-     */
-    filters: Filter[];
-    /**
-     * Synchronously transforms a raw block into a list of events.
-     *
-     * When a block matches any of filters defined by your event it will be passed to this function to be synchronously
-     * transformed into a list of structured events.
-     *
-     * The shape of the input `block` is determined by the return value of `getBlock` function provided to your `indexer`.
-     *
-     * The returned output value should be an array containg any valid JavaScript values. Each event that you return from
-     * your handler should not depend on any information outside of the input block data. It should directly map a given
-     * input (the raw block) to a given output (structured events). This ensures that handler remains idempotent and that
-     * repeated calls with the same input block produce the same output events.
-     */
-    handler: (block: TBlock) => TEvent[];
-    /**
-     * Storage adapter to persist events in your off-chain storage.
-     */
-    storage: {
-        /**
-         * Upserts a batch of events into your storage system.
-         *
-         * After a block is transformed into a list of structured events by your `handler` function, that batch
-         * is passed to this `upsert` function so they can be upserted into your storage system.
-         *
-         * This function must be idempotent. Functionally, this means that if the same batch of events is upserted
-         * multiple times it only produces a single set of events in your storage system.
-         */
-        upsert: (events: TEvent[]) => Promise<void>;
-        /**
-         * Deletes a batch of events from your storage system.
-         *
-         * When your indexer encounters a chain reorganisation, this `delete` function will be invoked with the
-         * same batch of events created by that reorganised block. This ensures that any events that were previously
-         * upserted into your storage system that are no longer part of the canonical chain are safely removed.
-         */
-        delete?: (events: TEvent[]) => Promise<void>;
-    };
-};
-/**
- * Indexer -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Head = {
-    hash: `0x${string}`;
-    chain: `0x${string}`;
-    number: `0x${string}`;
-    parentHash: `0x${string}`;
-};
-type Metadata = {
-    version: string;
-    language: string;
-};
-type Result = {
-    status: string;
-    event_id: string;
-    chain: `0x${string}`;
-    block_hash: `0x${string}`;
-    block_number: `0x${string}`;
-    created_at: number;
-};
-type IndexerOptions<TBlock> = {
-    /**
-     * Silences all logs including errors.
-     *
-     * Logs are emitted based on the environment LOG_LEVEL. Set `quiet: true` to surpress all logs.
-     * Available log options are `DEBUG`, `INFO`, `WARN`, and `ERROR`.
-     */
-    quiet?: boolean;
-    /**
-     * Request signing key
-     *
-     * Facilitates secure communication with a trusted source like the univo dashboard.
-     */
-    signingKey: string;
-    /**
-     * Storage interface for durably persisting indexer metadata.
-     *
-     * This uses the unified key-value storage API from unstorage. Install the `unstorage` dependency
-     * and provide the return value of your `createStorage()` call. Check out the documentation for
-     * a full list of [supported storage drivers](https://unstorage.unjs.io/drivers).
-     *
-     * Functionally, storing metadata is fundamental to ensure the correct operation of your indexer. It
-     * ensures that you indexer recovers from downtime and ensures that all blocks are processed correctly during
-     * chain reorganisations.
-     */
-    metadataStorage: Storage;
-    /**
-     * Loads raw block data in realtime from a trusted set of RPC sources.
-     *
-     * Note that historical backfills do not use this function to load block data.
-     *
-     * The response from this function determines the input data to your `handler` functions in each event.
-     * Generally, the shape is a list of RPC methods with their corresponding value from an RPC node. This
-     * generic format allows you support the full range of RPC data available to you from your node. This
-     * flexibility is important in cases where some methods are supported on specific chains only.
-     *
-     * Note that there is a minimum set of RPC methods expected on the response notably `eth_chainId`,
-     * `eth_getBlockByNumber` and `eth_getBlockReceipts`. These are expected so that we can safely match
-     * each block processed against your event filters.
-     *
-     * Note that we provide only the block number to look up block data. During a chain reorganisation, this
-     * makes it possible for different RPC calls to return data for different block hashes. We manually verify
-     * that all methods return the expected block hash. However, for any custom methods you add you must manually
-     * verify the block hash is consistent with the other known methods.
-     */
-    getBlock: (block: {
-        chain: `0x${string}`;
-        number: string;
-    }) => Promise<TBlock | null>;
-};
-type Indexer<TBlock> = {
-    fetch: (req: Request) => Promise<Response>;
-    event: <TEvent>(event: Event<TBlock, TEvent>) => Event<TBlock, TEvent>;
-};
-declare function indexer<TBlock extends Block>(opts: IndexerOptions<TBlock>): {
-    fetch: (req: Request) => Promise<Response>;
-    event: <TEvent>(event: Event<TBlock, TEvent>) => Event<TBlock, TEvent>;
-};
-
-export { indexer, matchFilter };
-export type { Block, Event, Filter, Head, Indexer, Metadata, Result };
+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.Cj4s4jNq.mjs';
+import 'unstorage';

package/dist/index.d.ts

@@ -1,189 +1,2 @@
-import { Storage } from 'unstorage';
-
-/**
- * Block -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Block = {
-    eth_chainId: `0x${string}`;
-    eth_getBlockByNumber: {
-        hash: `0x${string}`;
-        number: `0x${string}`;
-        parentHash: `0x${string}`;
-    };
-    eth_getBlockReceipts: Array<{
-        blockHash: `0x${string}`;
-        logs: Array<{
-            address: `0x${string}`;
-            topics: `0x${string}`[];
-        }>;
-    }>;
-};
-/**
- * Filters -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Filter = {
-    /** Index blocks with this chain id */
-    chain: number;
-    /** Index blocks from this start block (inclusive) */
-    fromBlock: number;
-    /** Index blocks until this stop block (inclusive)  */
-    toBlock?: number;
-    /** Index blocks where this event topic was emitted */
-    event?: `0x${string}`;
-    /** Index blocks that involve this address */
-    address?: `0x${string}`;
-};
-declare function matchFilter(block: Block, filter: Filter): boolean;
-/**
- * Events -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Event<TBlock, TEvent> = {
-    /**
-     * A human-readable identifier for the event.
-     */
-    id: string;
-    /**
-     * Filters let you define what specific blocks you want this event to index.
-     *
-     * Blockchains are massive datasets and most of the time we are only ever interested in small portions of it.
-     * Sometimes that can be specific events like ERC20 transfers and other times it could be all events emitted
-     * by a specific contract. Filters provide a simple way for an event to define exactly which blocks we want
-     * to index.
-     *
-     * Filters reduce costs and improve backfill performance by ensuring we only index the blocks we need and
-     * ignore the blocks that don't have the data we are interested in.
-     *
-     * By default your event will not index any blocks, you must opt-in to indexing by providing atleast one filter.
-     *
-     * Each property in the filter operates like an AND statement. For example, if you specifiy an `address` and
-     * an `event` it implies that you only want to index blocks where the specific `address` emitted the specific
-     * `event` topic provided.
-     *
-     * However, when multiple filters are defined for a given event those filters operate like an OR statement. For
-     * example, if we define a second filter looking for a different `address` and `event` our event will now index
-     * any block that matches either the first filter or the second filter.
-     *
-     * Note that filters are a rudimentary method to dramatically reduce the number of blocks your application needs
-     * to index. Any advanced filtering should be performed in the event `handler` itself.
-     */
-    filters: Filter[];
-    /**
-     * Synchronously transforms a raw block into a list of events.
-     *
-     * When a block matches any of filters defined by your event it will be passed to this function to be synchronously
-     * transformed into a list of structured events.
-     *
-     * The shape of the input `block` is determined by the return value of `getBlock` function provided to your `indexer`.
-     *
-     * The returned output value should be an array containg any valid JavaScript values. Each event that you return from
-     * your handler should not depend on any information outside of the input block data. It should directly map a given
-     * input (the raw block) to a given output (structured events). This ensures that handler remains idempotent and that
-     * repeated calls with the same input block produce the same output events.
-     */
-    handler: (block: TBlock) => TEvent[];
-    /**
-     * Storage adapter to persist events in your off-chain storage.
-     */
-    storage: {
-        /**
-         * Upserts a batch of events into your storage system.
-         *
-         * After a block is transformed into a list of structured events by your `handler` function, that batch
-         * is passed to this `upsert` function so they can be upserted into your storage system.
-         *
-         * This function must be idempotent. Functionally, this means that if the same batch of events is upserted
-         * multiple times it only produces a single set of events in your storage system.
-         */
-        upsert: (events: TEvent[]) => Promise<void>;
-        /**
-         * Deletes a batch of events from your storage system.
-         *
-         * When your indexer encounters a chain reorganisation, this `delete` function will be invoked with the
-         * same batch of events created by that reorganised block. This ensures that any events that were previously
-         * upserted into your storage system that are no longer part of the canonical chain are safely removed.
-         */
-        delete?: (events: TEvent[]) => Promise<void>;
-    };
-};
-/**
- * Indexer -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Head = {
-    hash: `0x${string}`;
-    chain: `0x${string}`;
-    number: `0x${string}`;
-    parentHash: `0x${string}`;
-};
-type Metadata = {
-    version: string;
-    language: string;
-};
-type Result = {
-    status: string;
-    event_id: string;
-    chain: `0x${string}`;
-    block_hash: `0x${string}`;
-    block_number: `0x${string}`;
-    created_at: number;
-};
-type IndexerOptions<TBlock> = {
-    /**
-     * Silences all logs including errors.
-     *
-     * Logs are emitted based on the environment LOG_LEVEL. Set `quiet: true` to surpress all logs.
-     * Available log options are `DEBUG`, `INFO`, `WARN`, and `ERROR`.
-     */
-    quiet?: boolean;
-    /**
-     * Request signing key
-     *
-     * Facilitates secure communication with a trusted source like the univo dashboard.
-     */
-    signingKey: string;
-    /**
-     * Storage interface for durably persisting indexer metadata.
-     *
-     * This uses the unified key-value storage API from unstorage. Install the `unstorage` dependency
-     * and provide the return value of your `createStorage()` call. Check out the documentation for
-     * a full list of [supported storage drivers](https://unstorage.unjs.io/drivers).
-     *
-     * Functionally, storing metadata is fundamental to ensure the correct operation of your indexer. It
-     * ensures that you indexer recovers from downtime and ensures that all blocks are processed correctly during
-     * chain reorganisations.
-     */
-    metadataStorage: Storage;
-    /**
-     * Loads raw block data in realtime from a trusted set of RPC sources.
-     *
-     * Note that historical backfills do not use this function to load block data.
-     *
-     * The response from this function determines the input data to your `handler` functions in each event.
-     * Generally, the shape is a list of RPC methods with their corresponding value from an RPC node. This
-     * generic format allows you support the full range of RPC data available to you from your node. This
-     * flexibility is important in cases where some methods are supported on specific chains only.
-     *
-     * Note that there is a minimum set of RPC methods expected on the response notably `eth_chainId`,
-     * `eth_getBlockByNumber` and `eth_getBlockReceipts`. These are expected so that we can safely match
-     * each block processed against your event filters.
-     *
-     * Note that we provide only the block number to look up block data. During a chain reorganisation, this
-     * makes it possible for different RPC calls to return data for different block hashes. We manually verify
-     * that all methods return the expected block hash. However, for any custom methods you add you must manually
-     * verify the block hash is consistent with the other known methods.
-     */
-    getBlock: (block: {
-        chain: `0x${string}`;
-        number: string;
-    }) => Promise<TBlock | null>;
-};
-type Indexer<TBlock> = {
-    fetch: (req: Request) => Promise<Response>;
-    event: <TEvent>(event: Event<TBlock, TEvent>) => Event<TBlock, TEvent>;
-};
-declare function indexer<TBlock extends Block>(opts: IndexerOptions<TBlock>): {
-    fetch: (req: Request) => Promise<Response>;
-    event: <TEvent>(event: Event<TBlock, TEvent>) => Event<TBlock, TEvent>;
-};
-
-export { indexer, matchFilter };
-export type { Block, Event, Filter, Head, Indexer, Metadata, Result };
+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.Cj4s4jNq.js';
+import 'unstorage';

package/dist/index.mjs

@@ -1,5 +1,7 @@
-import { c as createLogger, d as decompress, a as decoder, h as hexToNumber, i as isHexEqual, r as retry, v as version, n as normalizeHex } from './shared/univo.DfCC9G2B.mjs';
-import { c as createException, g as getException, a as catchException } from './shared/univo.C0flyVee.mjs';
+import { c as createException, a as catchException, l as local, g as getException } from './shared/univo.Bb9Aplq9.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.DicQZf-2.mjs';
+import 'ws';
+import 'partysocket';
 
 function matchFilter(block, filter) {
   if (!chainValid(block, filter)) return false;
@@ -556,10 +558,20 @@ function indexer(opts) {
     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: [] };
+    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: [] };
+    if (relevant_events.length === 0) {
+      return { results: [], keys: [] };
+    }
+    const block = await getBlock(params.head);
+    if (block === null) {
+      throw new Error(GetBlockError);
+    }
     const keys = /* @__PURE__ */ new Set();
     const results = {};
     function createProxyHandler(path) {
@@ -581,7 +593,7 @@ function indexer(opts) {
         }
       };
     }
-    const proxy = new Proxy(params.block, createProxyHandler(""));
+    const proxy = new Proxy(block, createProxyHandler(""));
     await Promise.all(
       relevant_events.map(async (event2) => {
         if (!event2.filters.some((filter) => matchFilter(proxy, filter))) {
@@ -653,26 +665,19 @@ function indexer(opts) {
     return { results: results_array, keys: filtered_keys };
   };
   const rpc = {
-    public_getFinalizedHeight,
-    public_writeFinalizedHeads,
-    public_writeUnfinalizedHeads,
-    public_deleteReorganisedHead,
-    private_getEvents,
-    private_getMetadata,
-    private_writeEvents,
-    private_writeEventsAndGetKeys
+    request: {
+      public_getFinalizedHeight,
+      public_writeFinalizedHeads,
+      public_writeUnfinalizedHeads,
+      public_deleteReorganisedHead,
+      private_getEvents,
+      private_getMetadata,
+      private_writeEvents,
+      private_writeEventsAndGetKeys
+    },
+    subscribe: {}
   };
-  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 UnknownMethodError = createException("The requested method does not exist");
+  const transport = local(rpc);
   const handler = async (req) => {
     let body_buffer;
     try {
@@ -733,8 +738,7 @@ function indexer(opts) {
       }
     }
     try {
-      if (rpc[json.method] === void 0) throw new Error(UnknownMethodError);
-      const result = await rpc[json.method](...json.params);
+      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);
@@ -756,7 +760,22 @@ function indexer(opts) {
       );
     }
   };
-  return { fetch: handler, event };
+  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 indexer2 = {
+    ...rpc,
+    event,
+    fetch: handler
+  };
+  return indexer2;
 }
 
 export { indexer, matchFilter };

package/dist/realtime.d.mts

@@ -1,6 +1,6 @@
 import { NodeRpc, IndexerRpc } from './rpc.mjs';
 import { Transport } from './transport.mjs';
-import './index.mjs';
+import './shared/univo.Cj4s4jNq.mjs';
 import 'unstorage';
 
 type RealtimeOptions = {

package/dist/realtime.d.ts

@@ -1,6 +1,6 @@
 import { NodeRpc, IndexerRpc } from './rpc.js';
 import { Transport } from './transport.js';
-import './index.js';
+import './shared/univo.Cj4s4jNq.js';
 import 'unstorage';
 
 type RealtimeOptions = {

package/dist/realtime.mjs

@@ -1,4 +1,4 @@
-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.DfCC9G2B.mjs';
+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.DicQZf-2.mjs';
 
 const MAX_LENGTH = 1e4;
 function defineBlockchain(opts) {
@@ -102,7 +102,7 @@ function realtime(opts) {
           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 heads`);
+          log.debug(`Delivered ${heads.length} unfinalized head(s)`);
           pending = pending.filter((head2) => {
             return !heads.some((_head) => {
               return isHexEqual(head2.hash, _head.hash);

package/dist/rpc.d.mts

@@ -1,11 +1,6 @@
-import { Head, Metadata, Filter, Block, Result } from './index.mjs';
+import { H as Head, M as Metadata, F as Flatten, a as Filter, B as Block, R as Result } from './shared/univo.Cj4s4jNq.mjs';
 import 'unstorage';
 
-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> = {
-    [K in keyof T as CamelToSnake<Extract<K, string>>]: T[K];
-};
-
 type Rpc = {
     /**
      * All available methods that can be requested
@@ -92,12 +87,12 @@ type IndexerRpc = {
             failures: Result[];
         }>;
         /**
-         * Accepts a raw block directly from the chain and writes events to storage
-         * @returns A list of the block keys that were accessed as events are written to storage
+         * Accepts a block head and writes events to storage
+         * @returns A list of results and block keys that were accessed as those events were written to storage
          */
         private_writeEventsAndGetKeys: (params: {
             events: string[];
-            block: Block;
+            head: Head;
         }) => Promise<{
             results: Result[];
             keys: string[];

package/dist/rpc.d.ts

@@ -1,11 +1,6 @@
-import { Head, Metadata, Filter, Block, Result } from './index.js';
+import { H as Head, M as Metadata, F as Flatten, a as Filter, B as Block, R as Result } from './shared/univo.Cj4s4jNq.js';
 import 'unstorage';
 
-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> = {
-    [K in keyof T as CamelToSnake<Extract<K, string>>]: T[K];
-};
-
 type Rpc = {
     /**
      * All available methods that can be requested
@@ -92,12 +87,12 @@ type IndexerRpc = {
             failures: Result[];
         }>;
         /**
-         * Accepts a raw block directly from the chain and writes events to storage
-         * @returns A list of the block keys that were accessed as events are written to storage
+         * Accepts a block head and writes events to storage
+         * @returns A list of results and block keys that were accessed as those events were written to storage
          */
         private_writeEventsAndGetKeys: (params: {
             events: string[];
-            block: Block;
+            head: Head;
         }) => Promise<{
             results: Result[];
             keys: string[];