envio 3.3.0-alpha.0 → 3.3.0-alpha.2

package/src/sources/TransactionStore.res

@@ -0,0 +1,111 @@
+// Binding to the Rust `TransactionStore` napi class. Transactions are kept in
+// Rust as raw structs (their large fields never enter JS until read) keyed by
+// (blockNumber, transactionIndex). One store lives per chain on `ChainState`;
+// each fetch response contributes a page that is merged in. At batch
+// preparation the selected fields are materialised in bulk, off the JS thread,
+// in columnar form and zipped into plain JS objects on the main thread.
+type t
+
+@send external classNew: Core.transactionStoreCtor => t = "new"
+let make = (): t => Core.getAddon().transactionStore->classNew
+
+// Field-name → bit-index map from an ordered field-name array. The index is the
+// field code shared with the Rust store (`EvmTxField`/`SvmTxField`).
+let fieldCodes = (fields: array<string>): dict<int> => {
+  let codes = Dict.make()
+  fields->Array.forEachWithIndex((name, i) => codes->Dict.set(name, i))
+  codes
+}
+
+let pow2: int => float = %raw(`c => Math.pow(2, c)`)
+
+// Union of an ecosystem's selected transaction fields as a bitmask float (bit
+// `code` set ⇔ selected). Built arithmetically to dodge 32-bit JS bitwise ops.
+let mask = (eventConfigs: array<Internal.eventConfig>, ~codes: dict<int>): float => {
+  let selected = Utils.Set.make()
+  eventConfigs->Array.forEach(eventConfig =>
+    eventConfig.selectedTransactionFields->Utils.Set.forEach(name =>
+      switch codes->Utils.Dict.dangerouslyGetNonOption(name) {
+      | Some(code) => selected->Utils.Set.add(code)->ignore
+      | None => ()
+      }
+    )
+  )
+  selected->Utils.Set.toArray->Array.reduce(0., (mask, code) => mask +. pow2(code))
+}
+
+// Drain another store (a fetch-response page) into this one.
+@send external merge: (t, t) => unit = "merge"
+
+// Bulk-materialise the fields selected by `mask` (one bit per field code) for
+// the given transactions, off the JS thread. Result is aligned with the input.
+@send
+external materialize: (
+  t,
+  ~blockNumbers: array<int>,
+  ~transactionIndices: array<int>,
+  ~mask: float,
+) => promise<array<Internal.eventTransaction>> = "materialize"
+
+// Drop transactions for blocks at or below the given block (already processed).
+@send external prune: (t, int) => unit = "prune"
+
+// Drop transactions for blocks above the given block (rolled back).
+@send external rollback: (t, int) => unit = "rollback"
+
+// Materialise the mask-selected fields for the store-backed items and write the
+// resulting transaction onto each item's payload. Items that already carry an
+// inline transaction (RPC/simulate/Fuel) are skipped. Store-backed items always
+// get a transaction object — the selected fields, or `{}` when the chain
+// selected none — so `event.transaction` is never `undefined` (matching the
+// inline sources). Deduped per (blockNumber, transactionIndex).
+let materializeItems = async (store: t, ~items: array<Internal.item>, ~mask: float) => {
+  // Store-backed items arrive in (block, logIndex) order, and a transaction's
+  // logs are contiguous within a block, so events sharing a (blockNumber,
+  // transactionIndex) are adjacent. Group them by extending the current run
+  // rather than hashing a string key per item. A key recurring non-adjacently
+  // just splits into two groups (one redundant decode) — never incorrect.
+  let blockNumbers = []
+  let transactionIndices = []
+  let payloadGroups = []
+
+  items->Array.forEach(item =>
+    switch item {
+    | Internal.Event(_) =>
+      let eventItem = item->Internal.castUnsafeEventItem
+      switch eventItem.payload->Internal.getPayloadTransaction->Nullable.toOption {
+      | Some(_) => () // RPC/simulate/Fuel carry the transaction inline.
+      | None =>
+        let {blockNumber, transactionIndex} = eventItem
+        let last = payloadGroups->Array.length - 1
+        if (
+          last >= 0 &&
+          blockNumbers->Array.getUnsafe(last) == blockNumber &&
+          transactionIndices->Array.getUnsafe(last) == transactionIndex
+        ) {
+          payloadGroups->Array.getUnsafe(last)->Array.push(eventItem.payload)
+        } else {
+          blockNumbers->Array.push(blockNumber)
+          transactionIndices->Array.push(transactionIndex)
+          payloadGroups->Array.push([eventItem.payload])
+        }
+      }
+    | Internal.Block(_) => ()
+    }
+  )
+
+  if payloadGroups->Utils.Array.notEmpty {
+    // A zero mask selects no fields, so there's nothing to decode — each
+    // store-backed item still gets an empty transaction object, so
+    // `event.transaction` is never undefined (matching the inline sources).
+    let txs = if mask == 0. {
+      payloadGroups->Array.map((_): Internal.eventTransaction => %raw(`{}`))
+    } else {
+      await store->materialize(~blockNumbers, ~transactionIndices, ~mask)
+    }
+    payloadGroups->Array.forEachWithIndex((payloads, i) => {
+      let tx = txs->Array.getUnsafe(i)
+      payloads->Array.forEach(payload => payload->Internal.setPayloadTransaction(tx))
+    })
+  }
+}

package/src/sources/TransactionStore.res.mjs

@@ -0,0 +1,77 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "../Core.res.mjs";
+import * as Utils from "../Utils.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+
+function make() {
+  return Core.getAddon().TransactionStore.new();
+}
+
+function fieldCodes(fields) {
+  let codes = {};
+  fields.forEach((name, i) => {
+    codes[name] = i;
+  });
+  return codes;
+}
+
+let pow2 = (c => Math.pow(2, c));
+
+function mask(eventConfigs, codes) {
+  let selected = new Set();
+  eventConfigs.forEach(eventConfig => {
+    eventConfig.selectedTransactionFields.forEach(name => {
+      let code = codes[name];
+      if (code !== undefined) {
+        selected.add(code);
+        return;
+      }
+    });
+  });
+  return Stdlib_Array.reduce(Array.from(selected), 0, (mask, code) => mask + pow2(code));
+}
+
+async function materializeItems(store, items, mask) {
+  let blockNumbers = [];
+  let transactionIndices = [];
+  let payloadGroups = [];
+  items.forEach(item => {
+    if (item.kind !== 0) {
+      return;
+    }
+    let match = item.payload.transaction;
+    if (!(match == null)) {
+      return;
+    }
+    let transactionIndex = item.transactionIndex;
+    let blockNumber = item.blockNumber;
+    let last = payloadGroups.length - 1 | 0;
+    if (last >= 0 && blockNumbers[last] === blockNumber && transactionIndices[last] === transactionIndex) {
+      payloadGroups[last].push(item.payload);
+    } else {
+      blockNumbers.push(blockNumber);
+      transactionIndices.push(transactionIndex);
+      payloadGroups.push([item.payload]);
+    }
+  });
+  if (!Utils.$$Array.notEmpty(payloadGroups)) {
+    return;
+  }
+  let txs = mask === 0 ? payloadGroups.map(param => ({})) : await store.materialize(blockNumbers, transactionIndices, mask);
+  payloadGroups.forEach((payloads, i) => {
+    let tx = txs[i];
+    payloads.forEach(payload => {
+      payload.transaction = tx;
+    });
+  });
+}
+
+export {
+  make,
+  fieldCodes,
+  pow2,
+  mask,
+  materializeItems,
+}
+/* Core Not a pure module */

package/src/tui/Tui.res

@@ -157,18 +157,15 @@ module App = {
       ->IndexerState.chainStates
       ->Dict.valuesToArray
       ->Array.map(cs => {
-        let numEventsProcessed = cs->ChainState.numEventsProcessed
-        let fetchState = cs->ChainState.fetchState
+        let data = cs->ChainState.toChainData
+        let numEventsProcessed = data.numEventsProcessed
         let committedProgressBlockNumber = cs->ChainState.committedProgressBlockNumber
-        let timestampCaughtUpToHeadOrEndblock = cs->ChainState.timestampCaughtUpToHeadOrEndblock
+        let timestampCaughtUpToHeadOrEndblock = data.timestampCaughtUpToHeadOrEndblock
         let sourceManager = cs->ChainState.sourceManager
-        let latestFetchedBlockNumber = Pervasives.max(fetchState->FetchState.bufferBlockNumber, 0)
+        let latestFetchedBlockNumber = data.latestFetchedBlockNumber
         let hasProcessedToEndblock = cs->ChainState.hasProcessedToEndblock
-        let knownHeight = hasProcessedToEndblock
-          ? fetchState.endBlock->Option.getOr(fetchState.knownHeight)
-          : fetchState.knownHeight
 
-        let firstEventBlock = fetchState.firstEventBlock
+        let firstEventBlock = data.firstEventBlockNumber
         let progress: TuiData.progress = if hasProcessedToEndblock {
           // If the endblock has been reached then set the progress to synced.
           // if there's chains that have no events in the block range start->end,
@@ -204,19 +201,19 @@ module App = {
         (
           {
             progress,
-            knownHeight,
+            knownHeight: data.knownHeight,
             latestFetchedBlockNumber,
             eventsProcessed: numEventsProcessed,
             chainId: (cs->ChainState.chainConfig).id->Int.toString,
-            progressBlock: committedProgressBlockNumber < fetchState.startBlock
-              ? Some(fetchState.startBlock)
+            progressBlock: committedProgressBlockNumber < data.startBlock
+              ? Some(data.startBlock)
               : Some(committedProgressBlockNumber),
             bufferBlock: Some(latestFetchedBlockNumber),
-            sourceBlock: Some(fetchState.knownHeight),
-            firstEventBlockNumber: fetchState.firstEventBlock,
-            startBlock: fetchState.startBlock,
-            endBlock: fetchState.endBlock,
-            poweredByHyperSync: (sourceManager->SourceManager.getActiveSource).poweredByHyperSync,
+            sourceBlock: Some(cs->ChainState.knownHeight),
+            firstEventBlockNumber: firstEventBlock,
+            startBlock: data.startBlock,
+            endBlock: data.endBlock,
+            poweredByHyperSync: data.poweredByHyperSync,
             blockUnit: switch (state->IndexerState.config).ecosystem.name {
             | Svm => "Slot"
             | Evm | Fuel => "Block"

package/src/tui/Tui.res.mjs

@@ -8,7 +8,6 @@ import * as SyncETA from "./components/SyncETA.res.mjs";
 import * as TuiData from "./components/TuiData.res.mjs";
 import * as Messages from "./components/Messages.res.mjs";
 import * as ChainState from "../ChainState.res.mjs";
-import * as FetchState from "../FetchState.res.mjs";
 import * as IndexerState from "../IndexerState.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import InkBigText from "ink-big-text";
@@ -208,15 +207,14 @@ function Tui$App(props) {
     };
   }, [getState]);
   let chains = Object.values(IndexerState.chainStates(state)).map(cs => {
-    let numEventsProcessed = ChainState.numEventsProcessed(cs);
-    let fetchState = ChainState.fetchState(cs);
+    let data = ChainState.toChainData(cs);
+    let numEventsProcessed = data.numEventsProcessed;
     let committedProgressBlockNumber = ChainState.committedProgressBlockNumber(cs);
-    let timestampCaughtUpToHeadOrEndblock = ChainState.timestampCaughtUpToHeadOrEndblock(cs);
+    let timestampCaughtUpToHeadOrEndblock = data.timestampCaughtUpToHeadOrEndblock;
     let sourceManager = ChainState.sourceManager(cs);
-    let latestFetchedBlockNumber = Primitive_int.max(FetchState.bufferBlockNumber(fetchState), 0);
+    let latestFetchedBlockNumber = data.latestFetchedBlockNumber;
     let hasProcessedToEndblock = ChainState.hasProcessedToEndblock(cs);
-    let knownHeight = hasProcessedToEndblock ? Stdlib_Option.getOr(fetchState.endBlock, fetchState.knownHeight) : fetchState.knownHeight;
-    let firstEventBlock = fetchState.firstEventBlock;
+    let firstEventBlock = data.firstEventBlockNumber;
     let progress = hasProcessedToEndblock ? ({
         TAG: "Synced",
         _0: {
@@ -259,16 +257,16 @@ function Tui$App(props) {
     return {
       chainId: ChainState.chainConfig(cs).id.toString(),
       eventsProcessed: numEventsProcessed,
-      progressBlock: committedProgressBlockNumber < fetchState.startBlock ? fetchState.startBlock : committedProgressBlockNumber,
+      progressBlock: committedProgressBlockNumber < data.startBlock ? data.startBlock : committedProgressBlockNumber,
       bufferBlock: latestFetchedBlockNumber,
-      sourceBlock: fetchState.knownHeight,
-      startBlock: fetchState.startBlock,
-      endBlock: fetchState.endBlock,
-      firstEventBlockNumber: fetchState.firstEventBlock,
-      poweredByHyperSync: SourceManager.getActiveSource(sourceManager).poweredByHyperSync,
+      sourceBlock: ChainState.knownHeight(cs),
+      startBlock: data.startBlock,
+      endBlock: data.endBlock,
+      firstEventBlockNumber: firstEventBlock,
+      poweredByHyperSync: data.poweredByHyperSync,
       progress: progress,
       latestFetchedBlockNumber: latestFetchedBlockNumber,
-      knownHeight: knownHeight,
+      knownHeight: data.currentBlockHeight,
       blockUnit: tmp,
       rateLimitTimeMs: SourceManager.getRateLimitTimeMs(sourceManager),
       isRateLimited: SourceManager.isRateLimited(sourceManager),