envio 3.3.0-alpha.6 → 3.3.0-alpha.8

package/src/sources/TransactionStore.res

@@ -21,42 +21,12 @@ let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool): t => {
   }
 }
 
-// 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)`)
-
-// 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 => ()
-    }
-  )
-  mask.contents
-}
-
-// 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)
-  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`)
+// One event's selected transaction fields → store selection bitmask, built from
+// the ecosystem's ordered field-name array (the bit index is the field code
+// shared with the Rust store, `EvmTxField`/`SvmTxField`).
+let makeMaskFn = FieldMask.makeMaskFn
+let orMask = FieldMask.orMask
+let fieldCodes = FieldMask.fieldCodes
 
 // Drain another store (a fetch-response page) into this one.
 @send external merge: (t, t) => unit = "merge"
@@ -77,74 +47,3 @@ external materialize: (
 
 // Drop transactions for blocks above the given block (rolled back).
 @send external rollback: (t, int) => unit = "rollback"
-
-// 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 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(_) => ()
-    }
-  )
-
-  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

@@ -1,7 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Core from "../Core.res.mjs";
-import * as Utils from "../Utils.res.mjs";
+import * as FieldMask from "./FieldMask.res.mjs";
 
 function make(ecosystem, shouldChecksum) {
   let ctor = Core.getAddon().TransactionStore;
@@ -15,97 +15,16 @@ function make(ecosystem, shouldChecksum) {
   }
 }
 
-function fieldCodes(fields) {
-  let codes = {};
-  fields.forEach((name, i) => {
-    codes[name] = i;
-  });
-  return codes;
-}
-
-let pow2 = (c => Math.pow(2, c));
-
-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 mask.contents;
-}
+let makeMaskFn = FieldMask.makeMaskFn;
 
-function makeMaskFn(fields) {
-  let codes = fieldCodes(fields);
-  return selectedTransactionFields => maskFromFields(selectedTransactionFields, codes);
-}
+let orMask = FieldMask.orMask;
 
-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;
-    }
-    let match = item.payload.transaction;
-    if (!(match == null)) {
-      return;
-    }
-    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;
-  }
-  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 = {};
-    });
-  });
-}
+let fieldCodes = FieldMask.fieldCodes;
 
 export {
   make,
-  fieldCodes,
-  pow2,
-  maskFromFields,
   makeMaskFn,
   orMask,
-  materializeItems,
+  fieldCodes,
 }
 /* Core Not a pure module */

package/svm.schema.json

@@ -472,6 +472,16 @@
             "$ref": "#/$defs/SvmTransactionField"
           }
         },
+        "block_fields": {
+          "description": "Block fields to include on each matched instruction's `block`, as a list of field names. `slot`/`time`/`hash` are always included; this adds `height`/`parentSlot`/`parentHash`.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/$defs/SvmBlockField"
+          }
+        },
         "log_fields": {
           "description": "Set to `true` to include program logs scoped to each matched instruction.",
           "type": [
@@ -505,6 +515,15 @@
         "version"
       ]
     },
+    "SvmBlockField": {
+      "description": "Selectable block field names (camelCase), matching the public\n`instruction.block` shape. `slot`/`time`/`hash` are always included,\nso everything here is opt-in on top of that trio.",
+      "type": "string",
+      "enum": [
+        "height",
+        "parentSlot",
+        "parentHash"
+      ]
+    },
     "ArgDef": {
       "description": "One named argument of an instruction. Mirrors\n`hypersync_client_solana::decode::NamedField`.",
       "type": "object",