univo 0.4.0 → 0.4.2

package/dist/realtime.mjs

@@ -1,5 +1,5 @@
 import { hexToNumber } from 'viem';
-import { c as createLogger, b as iife, m as mutex, r as retry, i as isHexEqual } from './shared/univo.mlthZw0m.mjs';
+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.CUNaTwXY.mjs';
 
 function defineBlockchain(opts) {
   const log = createLogger({ quiet: opts.quiet });
@@ -77,156 +77,357 @@ function defineBlockchain(opts) {
     await reconcile(parentBlock);
     return await reconcile(newBlock);
   }
+  const enqueue = queue();
   return {
     chain,
-    prune: mutex(prune),
-    reconcile: mutex(reconcile)
+    prune: (tail) => enqueue(() => prune(tail)),
+    reconcile: (newBlock) => enqueue(() => reconcile(newBlock))
   };
 }
 const POLLING_INTERVAL_MS = 12 * 1e3;
-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 () => {
-    log.debug("Initialising realtime client for indexer");
-    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({ method: "eth_getBlockByNumber", params: ["latest", false] }),
-      //
-      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,
-      onBlockAdded: async (head) => {
+function realtime(realtime2) {
+  const log = createLogger({ quiet: realtime2.quiet, prefix: "[realtime]" });
+  const instance = ({ chain, node }) => {
+    const { isDisposed, onCleanup, interrupt } = lifecycle({
+      onCleanupError: (error) => {
+        if (error instanceof Error) {
+          log.warn(error.message);
+        }
+      }
+    });
+    const promise = iife(async () => {
+      const [chainLatestBlock, chainFinalizedBlock] = await Promise.all([
+        node.request({ method: "eth_getBlockByNumber", params: ["latest", false] }),
+        //
+        node.request({ method: "eth_getBlockByNumber", params: ["finalized", false] })
+      ]);
+      if (isDisposed()) {
+        return;
+      }
+      if (chainLatestBlock === null) {
+        throw new Error("Latest block not found");
+      }
+      if (chainFinalizedBlock === null) {
+        throw new Error("Finalized block not found");
+      }
+      const unfinalized = defineBlockchain({
+        quiet: realtime2.quiet,
+        getBlockByHash: async (hash) => {
+          const block = await node.request({ method: "eth_getBlockByHash", params: [hash, false] });
+          if (block === null) {
+            return null;
+          }
+          return { number: block.number, hash: block.hash, parent_hash: block.parentHash };
+        },
+        onBlockAdded: async (head) => {
+          try {
+            log.debug("Received unfinalized head");
+            await realtime2.indexer.request({
+              method: "public_writeUnfinalizedHead",
+              params: [{ chain, ...head }]
+            });
+            log.debug("Delivered unfinalized head");
+          } catch (error) {
+            if (error instanceof Error) {
+              log.warn(`Failed to write unfinalized head: ${error.message}`);
+            }
+          }
+        },
+        onBlockReorganised: async (head) => {
+          try {
+            log.debug("Received reorganised head");
+            await retry(
+              () => realtime2.indexer.request({ method: "public_deleteReorganisedHead", params: [{ chain, ...head }] }),
+              //
+              2
+            );
+            log.debug("Delivered reorganised head");
+          } catch (error) {
+            if (error instanceof Error) {
+              log.warn(`Failed to write reorganised head: ${error.message}`);
+            }
+          }
+        }
+      });
+      await unfinalized.reconcile({
+        hash: chainLatestBlock.hash,
+        number: chainLatestBlock.number,
+        parent_hash: chainLatestBlock.parentHash
+      });
+      if (isDisposed()) {
+        return;
+      }
+      log.debug("Subscribing unfinalized chain to new heads...");
+      const unsubscribe = await node.subscribe("newHeads", async (head) => {
+        await unfinalized.reconcile({ hash: head.hash, number: head.number, parent_hash: head.parentHash }).catch((error) => {
+          if (error instanceof Error) {
+            log.error(`Failed to reconcile unfinalized head: ${error.message}`);
+          }
+        });
+      });
+      onCleanup(() => unsubscribe());
+      if (isDisposed()) {
+        return;
+      }
+      log.debug("Subscribed unfinalized chain to new heads");
+      async function finalize() {
         try {
-          log.debug("Received unfinalized head");
-          await opts.indexer.request({
-            method: "public_writeUnfinalizedHead",
-            params: [{ chain, ...head }]
-          });
-          log.debug("Delivered unfinalized head");
+          log.debug("Finalizing indexer...");
+          await realtime2.indexer.request({ params: [chain], method: "public_finalize" });
+          log.debug("Indexer finalized");
         } catch (error) {
           if (error instanceof Error) {
-            log.warn(`Failed to write unfinalized head: ${error.message}`);
+            log.warn(`Failed to finalize: ${error.message}`);
           }
         }
-      },
-      onBlockReorganised: async (head) => {
+      }
+      const mutex_finalize = mutex(finalize);
+      let chainFinalizedHeight = hexToNumber(chainFinalizedBlock.number);
+      async function poll() {
         try {
-          log.debug("Received reorganised head");
-          await retry(
-            () => opts.indexer.request({ method: "public_deleteReorganisedHead", params: [{ chain, ...head }] }),
-            //
-            2
-          );
-          log.debug("Delivered reorganised head");
+          log.debug("Polling for finalized height...");
+          const finalizedBlock = await node.request({
+            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 realtime2.indexer.request({ params: [chain], method: "public_writeFinalizedHeight" });
+          const newFinalizedHeads = unfinalized.chain.filter((head) => {
+            if (hexToNumber(head.number) > chainFinalizedHeight && hexToNumber(head.number) <= nextFinalizedHeight) {
+              return true;
+            }
+            return false;
+          }).map((head) => {
+            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`);
+          const promises = newFinalizedHeads.map(async (head) => {
+            try {
+              log.debug("Received finalized head");
+              await realtime2.indexer.request({ params: [head], method: "public_writeFinalizedHead" });
+              log.debug("Delivered finalized head");
+            } catch (error) {
+              if (error instanceof Error) {
+                log.warn(`Failed to write finalized head: ${error.message}`);
+              }
+            }
+          });
+          await Promise.allSettled(promises);
+          log.debug(`Processed ${newFinalizedHeads.length} finalized head(s) in parallel`);
+          chainFinalizedHeight = nextFinalizedHeight;
+          await unfinalized.prune({
+            hash: finalizedBlock.hash,
+            number: finalizedBlock.number,
+            parent_hash: finalizedBlock.parentHash
+          });
+          await mutex_finalize();
         } catch (error) {
           if (error instanceof Error) {
-            log.warn(`Failed to write reorganised head: ${error.message}`);
+            log.error(`Failed to reconcile finalized head: ${error.message}`);
           }
         }
       }
+      const id = setInterval(poll, POLLING_INTERVAL_MS);
+      onCleanup(() => clearInterval(id));
+      log.debug("Started polling finalized height");
     });
-    await unfinalized.reconcile({
-      hash: chainLatestBlock.hash,
-      number: chainLatestBlock.number,
-      parent_hash: chainLatestBlock.parentHash
-    });
-    await opts.node.subscribe("newHeads", async (head) => {
-      await unfinalized.reconcile({ hash: head.hash, number: head.number, parent_hash: head.parentHash }).catch((error) => {
-        if (error instanceof Error) {
-          log.error(`Failed to reconcile unfinalized head: ${error.message}`);
-        }
-      });
+    promise.catch((error) => {
+      if (error instanceof Error) {
+        log.error(error.message);
+      }
+      interrupt();
     });
-    log.debug("Subscribed unfinalized chain to new heads");
-    async function finalize() {
-      try {
-        log.debug("Finalizing indexer...");
-        await opts.indexer.request({ params: [chain], method: "public_finalize" });
-        log.debug("Indexer finalized");
-      } catch (error) {
+    return interrupt;
+  };
+  const browser = (browser2) => {
+    const { isDisposed, onCleanup, interrupt } = lifecycle({
+      onCleanupError: (error) => {
         if (error instanceof Error) {
-          log.warn(`Failed to finalize: ${error.message}`);
+          log.warn(error.message);
         }
       }
+    });
+    browser2.signal.addEventListener("abort", interrupt, { once: true });
+    onCleanup(() => browser2.signal.removeEventListener("abort", interrupt));
+    if (browser2.signal.aborted) {
+      interrupt();
     }
-    const mutex_finalize = mutex(finalize);
-    let chainFinalizedHeight = hexToNumber(chainFinalizedBlock.number);
-    async function poll() {
-      try {
-        log.debug("Polling for finalized height...");
-        const finalizedBlock = await opts.node.request({
-          method: "eth_getBlockByNumber",
-          params: ["finalized", false]
-        });
-        if (finalizedBlock === null) {
-          throw new Error("Finalized block not found");
+    const promise = iife(async () => {
+      if (isDisposed()) {
+        return;
+      }
+      const subscriptions = {
+        node: /* @__PURE__ */ new Map(),
+        abstraction: /* @__PURE__ */ new Map()
+      };
+      const transport = {
+        protocol: "browser",
+        request: async (request) => {
+          if (request.method !== "eth_unsubscribe") {
+            browser2.signal.throwIfAborted();
+          }
+          const res = await browser2.provider.request({ method: request.method, params: request.params });
+          if (request.method !== "eth_unsubscribe" && request.method !== "eth_subscribe") {
+            browser2.signal.throwIfAborted();
+          }
+          return res;
+        },
+        subscribe: async (param, listener) => {
+          const listeners = subscriptions.abstraction.get(param);
+          if (listeners === void 0) {
+            const listeners2 = /* @__PURE__ */ new Set();
+            listeners2.add(listener);
+            subscriptions.abstraction.set(param, listeners2);
+            const id = await transport.request({ method: "eth_subscribe", params: [param] }).catch((cause) => {
+              throw new Error(`Failed to initialise subscription for param ${param}`, { cause });
+            });
+            subscriptions.node.set(id, param);
+          } else {
+            listeners.add(listener);
+          }
+          return async function unsubscribe() {
+            const listeners2 = subscriptions.abstraction.get(param);
+            if (listeners2 === void 0) {
+              return;
+            }
+            listeners2.delete(listener);
+            if (listeners2.size === 0) {
+              for (const [id, _param] of subscriptions.node) {
+                if (param === _param) {
+                  await transport.request({ method: "eth_unsubscribe", params: [id] }).catch(() => {
+                    log.warn("Failed to unsubscribe unused subscription");
+                  });
+                }
+              }
+            }
+          };
         }
-        const nextFinalizedHeight = hexToNumber(finalizedBlock.number);
-        if (nextFinalizedHeight <= chainFinalizedHeight) {
-          return log.debug("Chain finalized height has not progressed");
+      };
+      const onMessage = async (message) => {
+        if (message.type === "eth_subscription") {
+          const param = subscriptions.node.get(message.data.subscription);
+          if (param === void 0) {
+            return;
+          }
+          const listeners = subscriptions.abstraction.get(param);
+          if (listeners === void 0) {
+            return await transport.request({ method: "eth_unsubscribe", params: [message.data.subscription] }).catch(() => {
+              log.warn("Failed to unsubscribe stale subscription");
+            });
+          }
+          for (const listener of listeners) {
+            try {
+              listener(message.data.result);
+            } catch (error) {
+              if (error instanceof Error) {
+                log.error(error.message);
+              }
+            }
+          }
         }
-        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;
-          }
-          return false;
-        }).map((head) => {
-          return { chain, ...head };
-        });
-        if (newFinalizedHeads.length === 0) {
-          chainFinalizedHeight = nextFinalizedHeight;
-          return log.debug("No new finalized heads to process");
+      };
+      browser2.provider.on("message", onMessage);
+      onCleanup(() => browser2.provider.removeListener("message", onMessage));
+      const _interrupt = instance({ chain: browser2.chain, node: transport });
+      onCleanup(() => _interrupt());
+    });
+    promise.catch((error) => {
+      if (error instanceof Error) {
+        log.error(error.message);
+      }
+      interrupt();
+    });
+    return interrupt;
+  };
+  iife(async () => {
+    try {
+      log.debug("Initialising realtime client");
+      if (realtime2.node.protocol === "wss") {
+        log.debug("Found user provided node");
+        const [chain, metadata] = await Promise.all([
+          realtime2.node.request({ method: "eth_chainId", params: [] }),
+          realtime2.indexer.request({ method: "public_getMetadata", params: [] })
+        ]);
+        log.debug(`Determined chain identifier for connected node: ${hexToNumber(chain)}`);
+        if (!metadata.chains.some((_chain) => _chain === chain)) {
+          throw new Error("Provided `node` is connected to a chain not indexed by the provided `indexer`");
         }
-        log.debug(`Processing ${newFinalizedHeads.length} finalized head(s) in parallel`);
-        const promises = newFinalizedHeads.map(async (head) => {
-          try {
-            log.debug("Received finalized head");
-            await opts.indexer.request({ params: [head], method: "public_writeFinalizedHead" });
-            log.debug("Delivered finalized head");
-          } catch (error) {
-            if (error instanceof Error) {
-              log.warn(`Failed to write finalized head: ${error.message}`);
+        instance({ chain, node: realtime2.node });
+        return;
+      }
+      if (realtime2.node.protocol === "browser") {
+        log.debug("Looking for browser injected node providers");
+        if (typeof window === "undefined") {
+          return log.debug("Browser indexing invoked on the server, aborting...");
+        }
+        const metadata = await realtime2.indexer.request({ method: "public_getMetadata", params: [] });
+        const providers = /* @__PURE__ */ new Map();
+        const sessions = /* @__PURE__ */ new Map();
+        window.addEventListener("eip6963:announceProvider", async (event) => {
+          const typed = event;
+          const provider = typed.detail;
+          if (providers.get(provider.info.uuid) !== void 0) {
+            return log.debug(`Found duplicate provider (${provider.info.uuid})`);
+          }
+          log.debug(`Found provider (${provider.info.uuid})`);
+          providers.set(provider.info.uuid, provider);
+          let controller = new AbortController();
+          const initialise = (initialise2) => {
+            for (const [key2, interrupt2] of sessions) {
+              if (key2.startsWith(provider.info.uuid)) {
+                try {
+                  interrupt2();
+                  sessions.delete(key2);
+                } catch (error) {
+                  if (error instanceof Error) {
+                    log.error(error.message);
+                  }
+                  sessions.delete(key2);
+                }
+              }
             }
+            if (!metadata.chains.includes(initialise2.chain)) {
+              return;
+            }
+            for (const key2 of sessions.keys()) {
+              if (key2.endsWith(`:${initialise2.chain}`)) {
+                return log.debug(`Already indexing key ${key2}, aborting initialisation...`);
+              }
+            }
+            const key = `${provider.info.uuid}:${initialise2.chain}`;
+            log.debug(`Initialising indexing for key ${key}`);
+            const interrupt = browser({ signal: initialise2.signal, chain: initialise2.chain, provider: provider.provider });
+            sessions.set(key, interrupt);
+          };
+          provider.provider.on("chainChanged", async (chain) => {
+            log.debug(`Provider (${provider.info.uuid}) changed to chain (${hexToNumber(chain)})`);
+            controller.abort();
+            controller = new AbortController();
+            initialise({ chain, signal: controller.signal });
+          });
+          const initialSignal = controller.signal;
+          const initialChain = await provider.provider.request({ method: "eth_chainId" });
+          if (initialSignal.aborted) {
+            return;
           }
+          initialise({ chain: initialChain, signal: initialSignal });
         });
-        await Promise.allSettled(promises);
-        log.debug(`Processed ${newFinalizedHeads.length} finalized head(s) in parallel`);
-        chainFinalizedHeight = nextFinalizedHeight;
-        await unfinalized.prune({
-          hash: finalizedBlock.hash,
-          number: finalizedBlock.number,
-          parent_hash: finalizedBlock.parentHash
-        });
-        await mutex_finalize();
-      } catch (error) {
-        if (error instanceof Error) {
-          log.error(`Failed to reconcile finalized head: ${error.message}`);
-        }
+        window.dispatchEvent(new Event("eip6963:requestProvider"));
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        log.error(error.message);
       }
-    }
-    setInterval(poll, POLLING_INTERVAL_MS);
-    log.debug("Started polling finalized height");
-  });
-  promise.catch((error) => {
-    if (error instanceof Error) {
-      log.error(`Failed to initialise realtime client: ${error.message}`);
     }
   });
 }

package/dist/rpc.d.mts

@@ -1,4 +1,4 @@
-export { I as IndexerRpc, R as Rpc } from './shared/univo.DYd1g40o.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.CEA4vY0E.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.CEA4vY0E.d.ts → univo.7S1OTdpc.d.ts}

@@ -1,11 +1,6 @@
 import { RpcBlock, RpcTransactionReceipt } from 'viem';
 import { Storage } from '../metadata.js';
 
-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
@@ -47,16 +42,13 @@ type IndexerRpc = {
          */
         public_finalize: (chain: `0x${string}`) => Promise<void>;
         /**
-         * @returns Specified metadata about the indexer
+         * @returns Public metadata about the indexer
          */
-        private_getMetadata: () => Promise<Metadata>;
+        public_getMetadata: () => Promise<PublicMetadata>;
         /**
-         * @returns All events defined on this indexer
+         * @returns Private metadata about the indexer
          */
-        private_getEvents: () => Promise<{
-            id: string;
-            filters: Flatten<Filter>[];
-        }[]>;
+        private_getMetadata: () => Promise<PrivateMetadata>;
         /**
          * 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
@@ -82,10 +74,7 @@ type IndexerRpc = {
     subscribe: Record<string, never>;
 };
 
-/**
- * Types -----------------------------------------------------------------------------------------------------------------------------------
- */
-type Protocol = "http" | "wss" | "local";
+type Protocol = "http" | "wss" | "local" | "browser";
 type Transport<R extends Rpc, P extends Protocol = Protocol> = {
     /**
      * The underlying transport protocol.
@@ -104,38 +93,33 @@ type Transport<R extends Rpc, P extends Protocol = Protocol> = {
      * Subscribes to specific event to receive and invoke a callback for a stream of values
      * @returns An async function to unsubscribe from the stream
      */
-    subscribe: <M extends keyof R["subscribe"]>(param: M, handler: (message: R["subscribe"][M]) => void) => Promise<() => Promise<void>>;
+    subscribe: <M extends keyof R["subscribe"]>(param: M, listener: (message: R["subscribe"][M]) => void) => Promise<() => Promise<void>>;
 };
 /**
- * Local -----------------------------------------------------------------------------------------------------------------------------------
+ * local -----------------------------------------------------------------------------------------------------------------------------------
  */
 declare function local<R extends Rpc>(rpc: R): Transport<R, "local">;
+/**
+ * browser -----------------------------------------------------------------------------------------------------------------------------------
+ */
+declare function browser(): Transport<Rpc, "browser">;
 declare function wss<R extends Rpc>(url: string, opts?: {
     quiet?: boolean;
 }): Transport<R, "wss">;
 /**
- * HTTP -----------------------------------------------------------------------------------------------------------------------------------
+ * http -----------------------------------------------------------------------------------------------------------------------------------
  */
 declare function http<R extends Rpc>(url: string, opts?: {
     signingKey?: string;
 }): Transport<R, "http">;
 
+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];
+};
+
 /**
- * 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}`;
@@ -156,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 -----------------------------------------------------------------------------------------------------------------------------------
@@ -276,9 +262,16 @@ type Head = {
     number: `0x${string}`;
     parent_hash: `0x${string}`;
 };
-type Metadata = {
+type PublicMetadata = {
+    chains: `0x${string}`[];
+};
+type PrivateMetadata = {
     version: string;
     language: string;
+    events: {
+        id: string;
+        filters: Flatten<Filter>[];
+    }[];
 };
 type Result = {
     status: string;
@@ -350,5 +343,5 @@ type Indexer = {
 };
 declare function defineIndexer(opts: Indexer): Transport<IndexerRpc, "local">;
 
-export { defineEvent as a, defineAction as b, defineIndexer as d, http as h, local as l, wss as w };
-export type { Action as A, Block as B, Event as E, Filter as F, Head as H, IndexerRpc as I, Metadata as M, Rpc as R, Transport as T, Indexer as c, Result as e };
+export { defineEvent as a, browser as b, defineAction as c, defineIndexer as d, http as h, local as l, wss as w };
+export type { Action as A, Block as B, Event as E, Filter as F, Head as H, IndexerRpc as I, PublicMetadata as P, Rpc as R, Transport as T, Indexer as e, PrivateMetadata as f, Result as g };