univo 0.3.2 → 0.4.0

package/dist/proxy.d.mts

@@ -0,0 +1,20 @@
+import { T as Transport, I as IndexerRpc } from './shared/univo.DYd1g40o.mjs';
+import 'viem';
+import './metadata.mjs';
+import './metadata/adapters.mjs';
+
+/**
+ * Creates a web standard HTTP request handler `(req: Request) => Promise<Response>`.
+ *
+ * You can use this to deploy your indexer over HTTPs using any of your favourite frameworks like
+ * Next.js, Cloudflare Workers, or Bun.
+ *
+ * Note that we use the provided `signingKey` to prevent any unauthorized access.
+ */
+declare function http(opts: {
+    quiet?: boolean;
+    indexer: Transport<IndexerRpc>;
+    signingKey: string;
+}): (req: Request) => Promise<Response>;
+
+export { http };

package/dist/proxy.d.ts

@@ -0,0 +1,20 @@
+import { T as Transport, I as IndexerRpc } from './shared/univo.CEA4vY0E.js';
+import 'viem';
+import './metadata.js';
+import './metadata/adapters.js';
+
+/**
+ * Creates a web standard HTTP request handler `(req: Request) => Promise<Response>`.
+ *
+ * You can use this to deploy your indexer over HTTPs using any of your favourite frameworks like
+ * Next.js, Cloudflare Workers, or Bun.
+ *
+ * Note that we use the provided `signingKey` to prevent any unauthorized access.
+ */
+declare function http(opts: {
+    quiet?: boolean;
+    indexer: Transport<IndexerRpc>;
+    signingKey: string;
+}): (req: Request) => Promise<Response>;
+
+export { http };

package/dist/proxy.mjs

@@ -0,0 +1,90 @@
+import { g as getException } from './shared/univo.C0flyVee.mjs';
+import { c as createLogger, d as decompress, e as decoder } from './shared/univo.mlthZw0m.mjs';
+
+function http(opts) {
+  const log = createLogger({ quiet: opts.quiet ?? false, prefix: "[proxy]" });
+  return async function proxy(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.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);
+      }
+      return Response.json(
+        { jsonrpc: "2.0", id: json.id, error: { code: 0, message: "Internal server error" } },
+        //
+        { status: 500 }
+      );
+    }
+  };
+}
+
+export { http };

package/dist/realtime.d.mts

@@ -1,5 +1,4 @@
-import { NodeRpc, IndexerRpc } from './rpc.mjs';
-import { Transport } from './transport.mjs';
+import { T as Transport, R as Rpc, I as IndexerRpc } from './shared/univo.DYd1g40o.mjs';
 import 'viem';
 import './metadata.mjs';
 import './metadata/adapters.mjs';
@@ -17,7 +16,7 @@ type RealtimeOptions = {
      *
      * Must use the `wss` transport protocol from `univo/transport`.
      */
-    node: Transport<NodeRpc, "wss">;
+    node: Transport<Rpc, "wss">;
     /**
      * Connection to a univo indexer.
      *

package/dist/realtime.d.ts

@@ -1,5 +1,4 @@
-import { NodeRpc, IndexerRpc } from './rpc.js';
-import { Transport } from './transport.js';
+import { T as Transport, R as Rpc, I as IndexerRpc } from './shared/univo.CEA4vY0E.js';
 import 'viem';
 import './metadata.js';
 import './metadata/adapters.js';
@@ -17,7 +16,7 @@ type RealtimeOptions = {
      *
      * Must use the `wss` transport protocol from `univo/transport`.
      */
-    node: Transport<NodeRpc, "wss">;
+    node: Transport<Rpc, "wss">;
     /**
      * Connection to a univo indexer.
      *

package/dist/realtime.mjs

@@ -1,5 +1,5 @@
 import { hexToNumber } from 'viem';
-import { c as createLogger, i as iife, m as mutex, r as retry, a as isHexEqual } from './shared/univo.vwk4Xrn3.mjs';
+import { c as createLogger, b as iife, m as mutex, r as retry, i as isHexEqual } from './shared/univo.mlthZw0m.mjs';
 
 function defineBlockchain(opts) {
   const log = createLogger({ quiet: opts.quiet });
@@ -88,6 +88,9 @@ function realtime(opts) {
   const log = createLogger({ quiet: opts.quiet ?? false, prefix: "[realtime]" });
   async function getBlockByHash(hash) {
     const block = await opts.node.request({ method: "eth_getBlockByHash", params: [hash, false] });
+    if (block === null) {
+      return null;
+    }
     return { number: block.number, hash: block.hash, parent_hash: block.parentHash };
   }
   const promise = iife(async () => {
@@ -95,10 +98,16 @@ function realtime(opts) {
     const chain = await opts.node.request({ method: "eth_chainId", params: [] });
     log.debug(`Determined chain identifier for connected node: ${hexToNumber(chain)}`);
     const [chainLatestBlock, chainFinalizedBlock] = await Promise.all([
-      opts.node.request({ params: ["latest", false], method: "eth_getBlockByNumber" }),
+      opts.node.request({ method: "eth_getBlockByNumber", params: ["latest", false] }),
       //
-      opts.node.request({ params: ["finalized", false], method: "eth_getBlockByNumber" })
+      opts.node.request({ method: "eth_getBlockByNumber", params: ["finalized", false] })
     ]);
+    if (chainLatestBlock === null) {
+      throw new Error("Latest block not found");
+    }
+    if (chainFinalizedBlock === null) {
+      throw new Error("Finalized block not found");
+    }
     const unfinalized = defineBlockchain({
       getBlockByHash,
       quiet: opts.quiet ?? false,
@@ -165,7 +174,14 @@ function realtime(opts) {
           method: "eth_getBlockByNumber",
           params: ["finalized", false]
         });
+        if (finalizedBlock === null) {
+          throw new Error("Finalized block not found");
+        }
         const nextFinalizedHeight = hexToNumber(finalizedBlock.number);
+        if (nextFinalizedHeight <= chainFinalizedHeight) {
+          return log.debug("Chain finalized height has not progressed");
+        }
+        await opts.indexer.request({ params: [chain], method: "public_writeFinalizedHeight" });
         const newFinalizedHeads = unfinalized.chain.filter((head) => {
           if (hexToNumber(head.number) > chainFinalizedHeight && hexToNumber(head.number) <= nextFinalizedHeight) {
             return true;
@@ -175,6 +191,7 @@ function realtime(opts) {
           return { chain, ...head };
         });
         if (newFinalizedHeads.length === 0) {
+          chainFinalizedHeight = nextFinalizedHeight;
           return log.debug("No new finalized heads to process");
         }
         log.debug(`Processing ${newFinalizedHeads.length} finalized head(s) in parallel`);

package/dist/rpc.d.mts

@@ -1,327 +1,4 @@
-import * as viem from 'viem';
-import { Storage } from './metadata.mjs';
+export { I as IndexerRpc, R as Rpc } from './shared/univo.DYd1g40o.mjs';
+import 'viem';
+import './metadata.mjs';
 import './metadata/adapters.mjs';
-
-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
-     */
-    request: Record<string, any>;
-    /**
-     * All available event types to subscribe to a stream of values
-     */
-    subscribe: Record<string, any>;
-};
-/**
- * Node -----------------------------------------------------------------------------------------------------------------------------------
- */
-type NodeRpc = {
-    request: {
-        /**
-         * @returns The chain identifier of the node
-         */
-        eth_chainId: () => Promise<`0x${string}`>;
-        /**
-         * Accepts a block tag and boolean for including receipts
-         * @returns A block with optional receipts
-         */
-        eth_getBlockByNumber: (number: string, receipts: boolean) => Promise<NodeBlock>;
-        /**
-         * Accepts a block hash and boolean for including receipts
-         * @returns A block with optional receipts
-         */
-        eth_getBlockByHash: (hash: `0x${string}`, receipts: boolean) => Promise<NodeBlock>;
-    };
-    subscribe: {
-        newHeads: NodeBlock;
-    };
-};
-type NodeBlock = {
-    hash: `0x${string}`;
-    number: `0x${string}`;
-    parentHash: `0x${string}`;
-};
-/**
- * Indexer -----------------------------------------------------------------------------------------------------------------------------------
- */
-type IndexerRpc = {
-    request: {
-        /**
-         * Accepts a chain identifier
-         * @returns Height of the last finalized block indexed
-         */
-        public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number>;
-        /**
-         * 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 finalized head and executes all actions
-         */
-        public_writeFinalizedHead: (head: Head) => Promise<void>;
-        /**
-         * Accepts a chain identifier and finalizes the indexer
-         */
-        public_finalize: (chain: `0x${string}`) => Promise<void>;
-        /**
-         * @returns Specified metadata about the indexer
-         */
-        private_getMetadata: () => Promise<Metadata>;
-        /**
-         * @returns All events defined on this indexer
-         */
-        private_getEvents: () => Promise<{
-            id: string;
-            filters: Flatten<Filter>[];
-        }[]>;
-        /**
-         * Accepts a list of events and a batch of minified block data and writes to storage
-         * @returns A list of failures that occured for each event and block pair
-         */
-        private_writeEvents: (params: {
-            events: string[];
-            blocks: Block[];
-        }) => Promise<{
-            failures: Result[];
-        }>;
-        /**
-         * 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[];
-            head: Head;
-        }) => Promise<{
-            results: Result[];
-            keys: string[];
-        }>;
-    };
-    subscribe: Record<string, never>;
-};
-
-/**
- * Block -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Block = {
-    eth_chainId: `0x${string}`;
-    eth_getBlockByNumber: viem.RpcBlock<"latest", true>;
-    eth_getBlockReceipts: viem.RpcTransactionReceipt[];
-};
-/**
- * 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}`;
-};
-/**
- * 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>;
-    };
-};
-/**
- * Actions -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Action<TBlock, TEvent> = {
-    /**
-     * A human-readable identifier for the action.
-     */
-    id: string;
-    /**
-     * The on-chain event that should invoke this action.
-     */
-    event: Event<TBlock, TEvent>;
-    /**
-     * The action you want to execute when the event _finalizes_ on-chain.
-     *
-     * Actions are processed during realtime indexing only and are never invoked during historical
-     * backfills. Common actions include payment notifications for confirming payments or customer
-     * deposits, transaction monitoring for KYC/AML compliance tracking, DeFi protocol monitoring,
-     * or wallet activity notifications or alerts.
-     *
-     * Actions may be invoked multiple times. It is important that your application code is
-     * resilient to this by making use of an idempotency key (usually the id of the event passed
-     * to your handler).
-     *
-     * Actions can be extremely powerful when combined with a durable execution framework like
-     * Temporal, Inngest, Trigger.dev, Cloudflare Workflows, or Restate.dev to perform more
-     * advanced workflows that allow you to chain together multiple steps and handle retries.
-     *
-     * Actions operate with at-least-once delivery. This means that your actions may be invoked
-     * multiple times. It is important that your handler is resilient to this by making use of an
-     * idempotency key (usually the identifier in the event passed to your handler). We guarantee
-     * that the indexer will not finalize a given block until it achieves a non-erroring execution
-     * from your action.
-     */
-    handler: (event: TEvent) => Promise<void> | void;
-};
-/**
- * Indexer -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Head = {
-    hash: `0x${string}`;
-    chain: `0x${string}`;
-    number: `0x${string}`;
-    parent_hash: `0x${string}`;
-};
-type Metadata = {
-    version: string;
-    language: string;
-};
-type Result = {
-    status: string;
-    event_id: string;
-    hash: `0x${string}`;
-    chain: `0x${string}`;
-    number: `0x${string}`;
-    parent_hash: `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.
-     *
-     * 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> = {
-    /**
-     * A web standard HTTP request handler. This is the entrypoint to your indexer and allows it to be deployed
-     * to your framework of choice so that it can receive requests and process responses.
-     */
-    fetch: (req: Request) => Promise<Response>;
-    /**
-     * Define on-chain events you want to record in your off-chain storage system.
-     */
-    event: <TEvent>(event: Event<TBlock, TEvent>) => Event<TBlock, TEvent>;
-    /**
-     * Perform fire-and-forget effects in response to on-chain events.
-     */
-    action: <TEvent>(action: Action<TBlock, TEvent>) => Action<TBlock, TEvent>;
-};
-declare function defineIndexer<TBlock extends Block>(opts: IndexerOptions<TBlock>): Indexer<TBlock> & IndexerRpc;
-
-export { defineIndexer as d };
-export type { Block as B, Event as E, Filter as F, Head as H, Indexer as I, IndexerRpc, Metadata as M, NodeRpc, Result as R, Rpc };