univo 0.2.11 → 0.2.13

package/dist/shared/univo.BwPUSTpl.mjs

@@ -0,0 +1,221 @@
+import ws from 'ws';
+import { WebSocket } from 'partysocket';
+import { g as compress, j as raise, c as createLogger } from './univo.B_UsEiYb.mjs';
+
+function createException(message) {
+  return `univo:${message}`;
+}
+function catchException(unknown, exception) {
+  if (unknown instanceof Error) {
+    if (unknown.message === exception) {
+      return true;
+    }
+  }
+  return false;
+}
+function getException(unknown) {
+  if (unknown instanceof Error) {
+    if (unknown.message.startsWith("univo")) {
+      const [_, message] = unknown.message.split(":");
+      if (message) return message;
+    }
+  }
+}
+
+const UnknownMethodError = createException("The requested RPC method does not exist on the provided implementation");
+function local(rpc) {
+  const request = async (opts) => {
+    const method = rpc.request[opts.method];
+    if (method === void 0) {
+      throw new Error(UnknownMethodError);
+    }
+    return await method(...opts.params);
+  };
+  const subscribe = async () => {
+    throw new Error("Unable to `subscribe` on `local` transport");
+  };
+  return { protocol: "local", request, subscribe };
+}
+function createSocket(url, opts) {
+  const socket = new WebSocket(url, [], { WebSocket: ws });
+  socket.binaryType = "arraybuffer";
+  if (opts.onOpen) socket.onopen = opts.onOpen;
+  if (opts.onError) socket.onerror = opts.onError;
+  if (opts.onClose) socket.onclose = opts.onClose;
+  if (opts.onMessage) socket.onmessage = opts.onMessage;
+  return socket;
+}
+function wss(url, opts = {}) {
+  if (!url.startsWith("wss://")) {
+    throw new Error("Websocket connections must start with `wss://`");
+  }
+  const logger = createLogger({ quiet: opts.quiet ?? false });
+  let id = 0;
+  const requests = /* @__PURE__ */ new Map();
+  const subscriptions = /* @__PURE__ */ new Map();
+  const params = /* @__PURE__ */ new Map();
+  const socket = createSocket(url, {
+    async onError(cause) {
+      logger.error(new Error("Socket error", { cause }));
+    },
+    async onOpen() {
+      if (subscriptions.size === 0) {
+        return;
+      }
+      const params2 = [];
+      for (const [id2, subscription] of subscriptions) {
+        params2.push(subscription.param);
+        request({ method: "eth_unsubscribe", params: [id2] }).catch(() => {
+          logger.warn("Failed to cancel old susbcription");
+        });
+        subscriptions.delete(id2);
+      }
+      for (const param of params2) {
+        request({ method: "eth_subscribe", params: [param] }).then((id2) => {
+          subscriptions.set(id2, { param, latest: Date.now() });
+        });
+      }
+    },
+    async onMessage(event) {
+      const data = JSON.parse(event.data);
+      if (data.method === "eth_subscription") {
+        const subscription = subscriptions.get(data.params.subscription);
+        if (subscription === void 0) {
+          return await request({ method: "eth_unsubscribe", params: [data.params.subscription] }).catch(() => {
+            logger.warn("Failed to unsubscribe stale subscription");
+          });
+        }
+        const handlers = params.get(subscription.param);
+        if (handlers === void 0) {
+          return await request({ method: "eth_unsubscribe", params: [data.params.subscription] }).catch(() => {
+            logger.warn("Failed to unsubscribe stale subscription");
+          });
+        }
+        for (const handler2 of handlers) {
+          try {
+            handler2(data.params.result);
+          } catch (cause) {
+            logger.error(new Error("Handler error", { cause }));
+          }
+        }
+        subscription.latest = Date.now();
+        return;
+      }
+      const handler = requests.get(data.id);
+      if (handler === void 0) {
+        return logger.warn(`Received unknown response for request id ${data.id}...`);
+      }
+      return handler(data.result);
+    }
+  });
+  const request = async (opts2) => {
+    return await new Promise((resolve, reject) => {
+      const body = Object.assign({ id: id++ }, opts2);
+      const timeout = setTimeout(() => {
+        requests.delete(body.id);
+        reject(new Error("wss request timed out after 30 seconds"));
+      }, 30 * 1e3);
+      requests.set(body.id, (data) => {
+        clearTimeout(timeout);
+        requests.delete(body.id);
+        resolve(data);
+      });
+      try {
+        socket.send(JSON.stringify(body));
+      } catch (cause) {
+        clearTimeout(timeout);
+        requests.delete(body.id);
+        reject(new Error(ClientConnectionError, { cause }));
+      }
+    });
+  };
+  const subscribe = async (param, handler) => {
+    const handlers = params.get(param);
+    if (handlers === void 0) {
+      const handlers2 = (/* @__PURE__ */ new Set()).add(handler);
+      params.set(param, handlers2);
+      const id2 = await request({ method: "eth_subscribe", params: [param] }).catch((cause) => {
+        throw new Error(`Failed to initialise subscription for param ${param}`, { cause });
+      });
+      subscriptions.set(id2, { param, latest: Date.now() });
+    } else {
+      handlers.add(handler);
+    }
+    return async function unsubscribe() {
+      const handlers2 = params.get(param);
+      if (handlers2 === void 0) {
+        return logger.warn("Param already unsubscribed...");
+      }
+      handlers2.delete(handler);
+      if (handlers2.size === 0) {
+        await request({ method: "eth_unsubscribe", params: [id] }).catch(() => {
+          logger.warn("Failed to unsubscribe unused subscription");
+        });
+      }
+    };
+  };
+  function healthcheck() {
+    const params2 = [];
+    for (const [id2, subscription] of subscriptions) {
+      if (Date.now() - subscription.latest > 60 * 1e3) {
+        params2.push(subscription.param);
+        request({ method: "eth_unsubscribe", params: [id2] }).catch(() => {
+          logger.warn("Failed to cancel old susbcription");
+        });
+        subscriptions.delete(id2);
+        logger.warn(`Subscription ${id2} failed health check, reinitialising..`);
+      }
+    }
+    for (const param of params2) {
+      request({ method: "eth_subscribe", params: [param] }).then((id2) => {
+        subscriptions.set(id2, { param, latest: Date.now() });
+      });
+    }
+  }
+  setInterval(healthcheck, 60 * 1e3);
+  return { protocol: "wss", request, subscribe };
+}
+function http(url, opts = {}) {
+  let id = 0;
+  const request = async (options) => {
+    let body = JSON.stringify({
+      id: id++,
+      jsonrpc: "2.0",
+      method: options.method,
+      params: options.params
+    });
+    const headers = new Headers();
+    headers.set("Content-Type", "application/json");
+    if (options.method.startsWith("private_")) {
+      if (opts.signingKey === void 0) {
+        throw new Error(ClientUnauthorizedError);
+      }
+      body = await compress(body).catch((cause) => raise(ClientCompressionError, { cause }));
+      headers.set("Content-Encoding", "gzip");
+      headers.set("Authorization", `Bearer ${opts.signingKey}`);
+    }
+    const res = await fetch(url, { headers, body, method: "POST", signal: AbortSignal.timeout(30 * 1e3) }).catch((cause) => {
+      throw new Error(ClientConnectionError, { cause });
+    });
+    if (!res.ok || res.status < 200 || res.status >= 300) {
+      throw new Error(ClientConnectionError);
+    }
+    const json = await res.json().catch((cause) => {
+      throw new Error(ClientResponseError, { cause });
+    });
+    if (json.error) {
+      throw new Error(json.error.message);
+    }
+    return json.result;
+  };
+  const subscribe = async () => {
+    throw new Error("Unable to `subscribe` on `http` transport");
+  };
+  return { protocol: "http", request, subscribe };
+}
+const ClientCompressionError = createException("An error occurred when compressing the request");
+const ClientConnectionError = createException("An errored occurred when connecting to the server");
+const ClientResponseError = createException("An error occurred when reading the servers response");
+const ClientUnauthorizedError = createException("Attempted to execute a private method without providing a request signing key");
+
+export { catchException as a, createException as c, getException as g, http as h, local as l, wss as w };

package/dist/shared/univo.Cj4s4jNq.d.mts

@@ -0,0 +1,219 @@
+import { Storage } from '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];
+};
+
+/**
+ * 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>): {
+    event: <TEvent>(event: Event<TBlock, TEvent>) => Event<TBlock, TEvent>;
+    fetch: (req: Request) => Promise<Response>;
+    request: {
+        public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number>;
+        public_deleteReorganisedHead: (head: Head) => Promise<void>;
+        public_writeUnfinalizedHeads: (heads: Head[]) => Promise<void>;
+        public_writeFinalizedHeads: (heads: Head[]) => Promise<void>;
+        private_getMetadata: () => Promise<Metadata>;
+        private_getEvents: () => Promise<{
+            id: string;
+            filters: Flatten<Filter>[];
+        }[]>;
+        private_writeEvents: (params: {
+            events: string[];
+            blocks: Block[];
+        }) => Promise<{
+            failures: Result[];
+        }>;
+        private_writeEventsAndGetKeys: (params: {
+            events: string[];
+            head: Head;
+        }) => Promise<{
+            results: Result[];
+            keys: string[];
+        }>;
+    };
+    subscribe: Record<string, never>;
+};
+
+export { indexer as i, matchFilter as m };
+export type { Block as B, Event as E, Flatten as F, Head as H, Indexer as I, Metadata as M, Result as R, Filter as a };

package/dist/shared/univo.Cj4s4jNq.d.ts

@@ -0,0 +1,219 @@
+import { Storage } from '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];
+};
+
+/**
+ * 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>): {
+    event: <TEvent>(event: Event<TBlock, TEvent>) => Event<TBlock, TEvent>;
+    fetch: (req: Request) => Promise<Response>;
+    request: {
+        public_getFinalizedHeight: (chain: `0x${string}`) => Promise<number>;
+        public_deleteReorganisedHead: (head: Head) => Promise<void>;
+        public_writeUnfinalizedHeads: (heads: Head[]) => Promise<void>;
+        public_writeFinalizedHeads: (heads: Head[]) => Promise<void>;
+        private_getMetadata: () => Promise<Metadata>;
+        private_getEvents: () => Promise<{
+            id: string;
+            filters: Flatten<Filter>[];
+        }[]>;
+        private_writeEvents: (params: {
+            events: string[];
+            blocks: Block[];
+        }) => Promise<{
+            failures: Result[];
+        }>;
+        private_writeEventsAndGetKeys: (params: {
+            events: string[];
+            head: Head;
+        }) => Promise<{
+            results: Result[];
+            keys: string[];
+        }>;
+    };
+    subscribe: Record<string, never>;
+};
+
+export { indexer as i, matchFilter as m };
+export type { Block as B, Event as E, Flatten as F, Head as H, Indexer as I, Metadata as M, Result as R, Filter as a };

package/dist/transport.d.mts

@@ -1,15 +1,15 @@
 import { Rpc } from './rpc.mjs';
-import './index.mjs';
+import './shared/univo.Cj4s4jNq.mjs';
 import 'unstorage';
 
-type Protocol = "http" | "wss";
+type Protocol = "http" | "wss" | "local";
 type Transport<R extends Rpc, P extends Protocol = Protocol> = {
     /**
      * The underlying transport protocol.
      */
     protocol: P;
     /**
-     * Performs a JSON RPC request
+     * Performs an RPC request
      * @returns The RPC response
      */
     request: <M extends keyof R["request"]>(opts: {
@@ -22,6 +22,7 @@ type Transport<R extends Rpc, P extends Protocol = Protocol> = {
      */
     subscribe: <M extends keyof R["subscribe"]>(param: M, handler: (message: R["subscribe"][M]) => void) => Promise<() => Promise<void>>;
 };
+declare function local<R extends Rpc>(rpc: R): Transport<R, "local">;
 declare function wss<R extends Rpc>(url: string, opts?: {
     quiet?: boolean;
 }): Transport<R, "wss">;
@@ -32,5 +33,5 @@ declare function http<R extends Rpc>(url: string, opts?: {
     signingKey?: string;
 }): Transport<R, "http">;
 
-export { http, wss };
+export { http, local, wss };
 export type { Transport };