envio 3.3.0-alpha.3 → 3.3.0-alpha.5

package/src/sources/TransactionStore.res

@@ -6,8 +6,20 @@
 // 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
+@send external newEvm: (Core.transactionStoreCtor, ~shouldChecksum: bool) => t = "newEvm"
+@send external newSvm: Core.transactionStoreCtor => t = "newSvm"
+@send external newFuel: Core.transactionStoreCtor => t = "newFuel"
+
+// The store's ecosystem is fixed here, from the chain's config. EVM carries the
+// chain's address-checksumming setting; SVM/Fuel need no extra data.
+let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool): t => {
+  let ctor = Core.getAddon().transactionStore
+  switch ecosystem {
+  | Evm => ctor->newEvm(~shouldChecksum)
+  | Svm => ctor->newSvm
+  | Fuel => ctor->newFuel
+  }
+}
 
 // Field-name → bit-index map from an ordered field-name array. The index is the
 // field code shared with the Rust store (`EvmTxField`/`SvmTxField`).
@@ -19,39 +31,45 @@ let fieldCodes = (fields: array<string>): dict<int> => {
 
 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 => ()
-      }
-    )
+// One event's selected transaction fields as a bitmask float (bit `code` set ⇔
+// selected). Each field appears once, so summing `pow2(code)` sets distinct bits
+// with no overlap; the result stays exact in f64 (codes span 0..31, so a mask is
+// at most 2^32-1).
+let maskFromFields = (selectedTransactionFields: Utils.Set.t<string>, ~codes: dict<int>): float => {
+  let mask = ref(0.)
+  selectedTransactionFields->Utils.Set.forEach(name =>
+    switch codes->Utils.Dict.dangerouslyGetNonOption(name) {
+    | Some(code) => mask := mask.contents +. pow2(code)
+    | None => ()
+    }
   )
-  selected->Utils.Set.toArray->Array.reduce(0., (mask, code) => mask +. pow2(code))
+  mask.contents
 }
 
-// Build an ecosystem's mask function from its ordered field-name array. The
-// field codes are derived once and closed over.
-let makeMaskFn = (fields: array<string>): (array<Internal.eventConfig> => float) => {
+// Build an ecosystem's per-event mask function from its ordered field-name
+// array. The field codes are derived once and closed over.
+let makeMaskFn = (fields: array<string>): (Utils.Set.t<string> => float) => {
   let codes = fieldCodes(fields)
-  eventConfigs => eventConfigs->mask(~codes)
+  selectedTransactionFields => selectedTransactionFields->maskFromFields(~codes)
 }
 
+// Bitwise OR of two per-event masks. Masks fit in 32 bits (≤32 transaction
+// fields), so `>>> 0` recovers the unsigned value that a plain `|` renders
+// negative once bit 31 is set.
+let orMask: (float, float) => float = %raw(`(a, b) => (a | b) >>> 0`)
+
 // 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.
+// Bulk-materialise transactions off the JS thread, one row per
+// (blockNumbers[i], transactionIndices[i]) key, decoding only the fields set in
+// that row's own masks[i]. Result is aligned with the input.
 @send
 external materialize: (
   t,
   ~blockNumbers: array<int>,
   ~transactionIndices: array<int>,
-  ~mask: float,
+  ~masks: array<float>,
 ) => promise<array<Internal.eventTransaction>> = "materialize"
 
 // Drop transactions for blocks at or below the given block (already processed).
@@ -60,69 +78,73 @@ external materialize: (
 // 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) => {
-  if mask == 0. {
-    // No fields selected: there's nothing to decode and no reason to group by
-    // key, but each store-backed item still gets an empty transaction object so
-    // `event.transaction` is never undefined (matching the inline sources).
-    items->Array.forEach(item =>
-      switch item {
-      | Internal.Event(_) =>
-        let payload = (item->Internal.castUnsafeEventItem).payload
-        switch payload->Internal.getPayloadTransaction->Nullable.toOption {
-        | Some(_) => () // RPC/simulate/Fuel carry the transaction inline.
-        | None => payload->Internal.setPayloadTransaction(%raw(`{}`))
-        }
-      | Internal.Block(_) => ()
-      }
-    )
-  } else {
-    // 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 = []
+// Materialise each store-backed item's selected transaction fields and write the
+// resulting transaction onto its payload. Every event's mask comes from its own
+// `eventConfig.transactionFieldMask`, so a transaction decodes only the fields
+// the events on it selected — a large field (e.g. `input`) never materialises
+// for events that didn't ask for it. 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 nothing was selected —
+// so `event.transaction` is never `undefined` (matching the inline sources).
+// Deduped per (blockNumber, transactionIndex); each row's mask is the OR of the
+// masks of the events sharing that transaction.
+let materializeItems = async (store: t, ~items: array<Internal.item>) => {
+  // 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 regardless of event. 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 masks = []
+  let payloadGroups = []
+  let anySelected = ref(false)
 
-    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])
-          }
+  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 mask = eventItem.eventConfig.transactionFieldMask
+        if mask != 0. {
+          anySelected := true
+        }
+        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)
+          masks->Array.setUnsafe(last, orMask(masks->Array.getUnsafe(last), mask))
+        } else {
+          blockNumbers->Array.push(blockNumber)
+          transactionIndices->Array.push(transactionIndex)
+          masks->Array.push(mask)
+          payloadGroups->Array.push([eventItem.payload])
         }
-      | Internal.Block(_) => ()
       }
-    )
+    | Internal.Block(_) => ()
+    }
+  )
 
-    if payloadGroups->Utils.Array.notEmpty {
-      let txs = await store->materialize(~blockNumbers, ~transactionIndices, ~mask)
+  if payloadGroups->Utils.Array.notEmpty {
+    if anySelected.contents {
+      let txs = await store->materialize(~blockNumbers, ~transactionIndices, ~masks)
       payloadGroups->Array.forEachWithIndex((payloads, i) => {
         let tx = txs->Array.getUnsafe(i)
         payloads->Array.forEach(payload => payload->Internal.setPayloadTransaction(tx))
       })
+    } else {
+      // No event selected any field: stamp an empty transaction object so
+      // `event.transaction` is never undefined, without a materialize call.
+      payloadGroups->Array.forEach(payloads =>
+        payloads->Array.forEach(payload => payload->Internal.setPayloadTransaction(%raw(`{}`)))
+      )
     }
   }
 }

package/src/sources/TransactionStore.res.mjs

@@ -2,10 +2,17 @@
 
 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 make(ecosystem, shouldChecksum) {
+  let ctor = Core.getAddon().TransactionStore;
+  switch (ecosystem) {
+    case "evm" :
+      return ctor.newEvm(shouldChecksum);
+    case "fuel" :
+      return ctor.newFuel();
+    case "svm" :
+      return ctor.newSvm();
+  }
 }
 
 function fieldCodes(fields) {
@@ -18,43 +25,35 @@ function fieldCodes(fields) {
 
 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;
-      }
-    });
+function maskFromFields(selectedTransactionFields, codes) {
+  let mask = {
+    contents: 0
+  };
+  selectedTransactionFields.forEach(name => {
+    let code = codes[name];
+    if (code !== undefined) {
+      mask.contents = mask.contents + pow2(code);
+      return;
+    }
   });
-  return Stdlib_Array.reduce(Array.from(selected), 0, (mask, code) => mask + pow2(code));
+  return mask.contents;
 }
 
 function makeMaskFn(fields) {
   let codes = fieldCodes(fields);
-  return eventConfigs => mask(eventConfigs, codes);
+  return selectedTransactionFields => maskFromFields(selectedTransactionFields, codes);
 }
 
-async function materializeItems(store, items, mask) {
-  if (mask === 0) {
-    items.forEach(item => {
-      if (item.kind !== 0) {
-        return;
-      }
-      let payload = item.payload;
-      let match = payload.transaction;
-      if (match == null) {
-        payload.transaction = {};
-        return;
-      }
-    });
-    return;
-  }
+let orMask = ((a, b) => (a | b) >>> 0);
+
+async function materializeItems(store, items) {
   let blockNumbers = [];
   let transactionIndices = [];
+  let masks = [];
   let payloadGroups = [];
+  let anySelected = {
+    contents: false
+  };
   items.forEach(item => {
     if (item.kind !== 0) {
       return;
@@ -65,23 +64,37 @@ async function materializeItems(store, items, mask) {
     }
     let transactionIndex = item.transactionIndex;
     let blockNumber = item.blockNumber;
+    let mask = item.eventConfig.transactionFieldMask;
+    if (mask !== 0) {
+      anySelected.contents = true;
+    }
     let last = payloadGroups.length - 1 | 0;
     if (last >= 0 && blockNumbers[last] === blockNumber && transactionIndices[last] === transactionIndex) {
       payloadGroups[last].push(item.payload);
+      masks[last] = orMask(masks[last], mask);
     } else {
       blockNumbers.push(blockNumber);
       transactionIndices.push(transactionIndex);
+      masks.push(mask);
       payloadGroups.push([item.payload]);
     }
   });
   if (!Utils.$$Array.notEmpty(payloadGroups)) {
     return;
   }
-  let txs = await store.materialize(blockNumbers, transactionIndices, mask);
-  payloadGroups.forEach((payloads, i) => {
-    let tx = txs[i];
+  if (anySelected.contents) {
+    let txs = await store.materialize(blockNumbers, transactionIndices, masks);
+    payloadGroups.forEach((payloads, i) => {
+      let tx = txs[i];
+      payloads.forEach(payload => {
+        payload.transaction = tx;
+      });
+    });
+    return;
+  }
+  payloadGroups.forEach(payloads => {
     payloads.forEach(payload => {
-      payload.transaction = tx;
+      payload.transaction = {};
     });
   });
 }
@@ -90,8 +103,9 @@ export {
   make,
   fieldCodes,
   pow2,
-  mask,
+  maskFromFields,
   makeMaskFn,
+  orMask,
   materializeItems,
 }
 /* Core Not a pure module */