envio 3.3.0-alpha.1 → 3.3.0-alpha.11

package/src/bindings/Viem.res.mjs

@@ -1,44 +1,2 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Viem from "viem";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-
-let ParseError = /* @__PURE__ */Primitive_exceptions.create("Viem.ParseError");
-
-let UnknownContractName = /* @__PURE__ */Primitive_exceptions.create("Viem.UnknownContractName");
-
-function parseLogOrThrow(contractNameAbiMapping, contractName, topics, data) {
-  let abi = contractNameAbiMapping[contractName];
-  if (abi !== undefined) {
-    let viemLog_abi = Primitive_option.valFromOption(abi);
-    let viemLog = {
-      abi: viemLog_abi,
-      data: data,
-      topics: topics
-    };
-    try {
-      return Viem.decodeEventLog(viemLog);
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      throw {
-        RE_EXN_ID: ParseError,
-        _1: exn,
-        Error: new Error()
-      };
-    }
-  } else {
-    throw {
-      RE_EXN_ID: UnknownContractName,
-      contractName: contractName,
-      Error: new Error()
-    };
-  }
-}
-
-export {
-  ParseError,
-  UnknownContractName,
-  parseLogOrThrow,
-}
-/* viem Not a pure module */
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/sources/BlockStore.res

@@ -0,0 +1,46 @@
+// Binding to the Rust `BlockStore` napi class. Blocks are kept in Rust as raw
+// structs (their large fields never enter JS until read) keyed by block number.
+// 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 newEvm: (Core.blockStoreCtor, ~shouldChecksum: bool) => t = "newEvm"
+@send external newSvm: Core.blockStoreCtor => t = "newSvm"
+@send external newFuel: Core.blockStoreCtor => 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().blockStore
+  switch ecosystem {
+  | Evm => ctor->newEvm(~shouldChecksum)
+  | Svm => ctor->newSvm
+  | Fuel => ctor->newFuel
+  }
+}
+
+// One event's selected block 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, `EvmBlockField`).
+let makeMaskFn = FieldMask.makeMaskFn
+
+// Drain another store (a fetch-response page) into this one.
+@send external merge: (t, t) => unit = "merge"
+
+// Bulk-materialise blocks off the JS thread, one row per `blockNumbers[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>,
+  ~masks: array<float>,
+) => promise<array<Internal.eventBlock>> = "materialize"
+
+// Drop blocks at or below the given block (already processed).
+@send external prune: (t, int) => unit = "prune"
+
+// Drop blocks above the given block (rolled back).
+@send external rollback: (t, int) => unit = "rollback"

package/src/sources/BlockStore.res.mjs

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "../Core.res.mjs";
+import * as FieldMask from "./FieldMask.res.mjs";
+
+function make(ecosystem, shouldChecksum) {
+  let ctor = Core.getAddon().BlockStore;
+  switch (ecosystem) {
+    case "evm" :
+      return ctor.newEvm(shouldChecksum);
+    case "fuel" :
+      return ctor.newFuel();
+    case "svm" :
+      return ctor.newSvm();
+  }
+}
+
+let makeMaskFn = FieldMask.makeMaskFn;
+
+export {
+  make,
+  makeMaskFn,
+}
+/* Core Not a pure module */

package/src/sources/EventRouter.res

@@ -28,29 +28,25 @@ module Group = {
     }
   }
 
-  let get = (
-    group: t<'a>,
-    ~contractAddress,
-    ~blockNumber,
-    ~indexingAddresses: dict<FetchState.indexingAddress>,
-  ) =>
+  // Ownership only: resolve the owning contract from the partition's reverse
+  // index (the partition that fetched the log), not a chain-wide snapshot. The
+  // `effectiveStartBlock` temporal gate now lives in `clientAddressFilter`. The
+  // wildcard partition has an empty index → every log falls back to `wildcard`,
+  // so it can never claim an address-bound contract's logs.
+  let get = (group: t<'a>, ~contractAddress, ~contractNameByAddress: dict<string>) =>
     switch group {
     | {wildcard, byContractName} =>
-      switch indexingAddresses->Utils.Dict.dangerouslyGetNonOption(
+      switch contractNameByAddress->Utils.Dict.dangerouslyGetNonOption(
         contractAddress->Address.toString,
       ) {
-      | Some(indexingContract) =>
-        if indexingContract.effectiveStartBlock <= blockNumber {
-          switch byContractName->Utils.Dict.dangerouslyGetNonOption(indexingContract.contractName) {
-          // Fall back to the wildcard handler when the indexed contract has no
-          // matching event for this tag. This covers addresses registered for
-          // contracts without events (persisted for future config changes) as
-          // well as addresses whose contract has other events but not this one.
-          | None => wildcard
-          | Some(_) as event => event
-          }
-        } else {
-          None
+      | Some(contractName) =>
+        switch byContractName->Utils.Dict.dangerouslyGetNonOption(contractName) {
+        // Fall back to the wildcard handler when the owning contract has no
+        // matching event for this tag. This covers addresses registered for
+        // contracts without events (persisted for future config changes) as
+        // well as addresses whose contract has other events but not this one.
+        | None => wildcard
+        | Some(_) as event => event
         }
       | None => wildcard
       }
@@ -89,34 +85,13 @@ let addOrThrow = (
   }
 }
 
-let get = (router: t<'a>, ~tag, ~contractAddress, ~blockNumber, ~indexingAddresses) => {
+let get = (router: t<'a>, ~tag, ~contractAddress, ~contractNameByAddress) => {
   switch router->Utils.Dict.dangerouslyGetNonOption(tag) {
   | None => None
-  | Some(group) => group->Group.get(~contractAddress, ~blockNumber, ~indexingAddresses)
+  | Some(group) => group->Group.get(~contractAddress, ~contractNameByAddress)
   }
 }
 
-let getEvmEventId = (~sighash, ~topicCount) => {
-  sighash ++ "_" ++ topicCount->Int.toString
-}
-
-let fromEvmEventModsOrThrow = (events: array<Internal.evmEventConfig>, ~chain): t<
-  Internal.evmEventConfig,
-> => {
-  let router = empty()
-  events->Array.forEach(config => {
-    router->addOrThrow(
-      config.id,
-      config,
-      ~contractName=config.contractName,
-      ~eventName=config.name,
-      ~chain,
-      ~isWildcard=config.isWildcard,
-    )
-  })
-  router
-}
-
 /** Dispatch key for SVM instructions. `None` matches any instruction in the
  program (lowest priority). */
 let getSvmEventId = (~programId: SvmTypes.Pubkey.t, ~discriminator: option<string>) =>
@@ -135,21 +110,26 @@ type svmProgramOrdering = {
   byteLengthsDesc: array<int>,
 }
 
-let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConfig>, ~chain): (
-  t<Internal.svmInstructionEventConfig>,
+let fromSvmEventConfigsOrThrow = (events: array<Internal.svmOnEventRegistration>, ~chain): (
+  t<Internal.svmOnEventRegistration>,
   array<svmProgramOrdering>,
 ) => {
   let router = empty()
   events->Array.forEach(config => {
+    let eventConfig =
+      config.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
     // The router tag must include the programId so two programs declaring the
     // same discriminator coexist. The source-side lookup uses the same shape
     // via `getSvmEventId(~programId, ~discriminator)`.
-    let routerTag = getSvmEventId(~programId=config.programId, ~discriminator=config.discriminator)
+    let routerTag = getSvmEventId(
+      ~programId=eventConfig.programId,
+      ~discriminator=eventConfig.discriminator,
+    )
     router->addOrThrow(
       routerTag,
       config,
-      ~contractName=config.contractName,
-      ~eventName=config.name,
+      ~contractName=eventConfig.contractName,
+      ~eventName=eventConfig.name,
       ~chain,
       ~isWildcard=config.isWildcard,
     )
@@ -158,7 +138,9 @@ let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConf
   // Per-program list of declared discriminator byte lengths, sorted desc.
   let byProgram: dict<Utils.Set.t<int>> = Dict.make()
   events->Array.forEach(config => {
-    let key = config.programId->SvmTypes.Pubkey.toString
+    let eventConfig =
+      config.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
+    let key = eventConfig.programId->SvmTypes.Pubkey.toString
     let set = switch byProgram->Utils.Dict.dangerouslyGetNonOption(key) {
     | Some(s) => s
     | None =>
@@ -166,7 +148,7 @@ let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConf
       byProgram->Dict.set(key, s)
       s
     }
-    let _ = set->Utils.Set.add(config.discriminatorByteLen)
+    let _ = set->Utils.Set.add(eventConfig.discriminatorByteLen)
   })
   let ordering =
     byProgram

package/src/sources/EventRouter.res.mjs

@@ -39,16 +39,13 @@ function addOrThrow(group, event, contractName, isWildcard) {
   byContractName[contractName] = event;
 }
 
-function get(group, contractAddress, blockNumber, indexingAddresses) {
+function get(group, contractAddress, contractNameByAddress) {
   let wildcard = group.wildcard;
-  let indexingContract = indexingAddresses[contractAddress];
-  if (indexingContract === undefined) {
+  let contractName = contractNameByAddress[contractAddress];
+  if (contractName === undefined) {
     return wildcard;
   }
-  if (indexingContract.effectiveStartBlock > blockNumber) {
-    return;
-  }
-  let event = group.byContractName[indexingContract.contractName];
+  let event = group.byContractName[contractName];
   if (event !== undefined) {
     return event;
   } else {
@@ -93,23 +90,13 @@ function addOrThrow$1(router, eventId, event, contractName, isWildcard, eventNam
   }
 }
 
-function get$1(router, tag, contractAddress, blockNumber, indexingAddresses) {
+function get$1(router, tag, contractAddress, contractNameByAddress) {
   let group = router[tag];
   if (group !== undefined) {
-    return get(group, contractAddress, blockNumber, indexingAddresses);
+    return get(group, contractAddress, contractNameByAddress);
   }
 }
 
-function getEvmEventId(sighash, topicCount) {
-  return sighash + "_" + topicCount.toString();
-}
-
-function fromEvmEventModsOrThrow(events, chain) {
-  let router = {};
-  events.forEach(config => addOrThrow$1(router, config.id, config, config.contractName, config.isWildcard, config.name, chain));
-  return router;
-}
-
 function getSvmEventId(programId, discriminator) {
   if (discriminator !== undefined) {
     return programId + "_" + discriminator;
@@ -121,12 +108,14 @@ function getSvmEventId(programId, discriminator) {
 function fromSvmEventConfigsOrThrow(events, chain) {
   let router = {};
   events.forEach(config => {
-    let routerTag = getSvmEventId(config.programId, config.discriminator);
-    addOrThrow$1(router, routerTag, config, config.contractName, config.isWildcard, config.name, chain);
+    let eventConfig = config.eventConfig;
+    let routerTag = getSvmEventId(eventConfig.programId, eventConfig.discriminator);
+    addOrThrow$1(router, routerTag, config, eventConfig.contractName, config.isWildcard, eventConfig.name, chain);
   });
   let byProgram = {};
   events.forEach(config => {
-    let key = config.programId;
+    let eventConfig = config.eventConfig;
+    let key = eventConfig.programId;
     let s = byProgram[key];
     let set;
     if (s !== undefined) {
@@ -136,7 +125,7 @@ function fromSvmEventConfigsOrThrow(events, chain) {
       byProgram[key] = s$1;
       set = s$1;
     }
-    set.add(config.discriminatorByteLen);
+    set.add(eventConfig.discriminatorByteLen);
   });
   let ordering = Object.entries(byProgram).map(param => {
     let sorted = Array.from(param[1]).toSorted((a, b) => b - a | 0);
@@ -158,8 +147,6 @@ export {
   empty$1 as empty,
   addOrThrow$1 as addOrThrow,
   get$1 as get,
-  getEvmEventId,
-  fromEvmEventModsOrThrow,
   getSvmEventId,
   fromSvmEventConfigsOrThrow,
 }

package/src/sources/Evm.res

@@ -1,5 +1,7 @@
 // EVM's concrete item payload. Erased to `Internal.eventPayload` on the item
-// and recovered here via `toPayload`.
+// and recovered here via `toPayload`. HyperSync omits `transaction` (it lives
+// raw in the per-chain store and is written onto the payload at batch prep);
+// RPC/simulate build it inline.
 type payload = {
   contractName: string,
   eventName: string,
@@ -7,12 +9,62 @@ type payload = {
   chainId: int,
   srcAddress: Address.t,
   logIndex: int,
-  transaction: Internal.eventTransaction,
-  block: Internal.eventBlock,
+  transaction?: Internal.eventTransaction,
+  // HyperSync omits `block` (it lives raw in the per-chain store and is written
+  // onto the payload at batch prep); RPC/simulate build it inline.
+  block?: Internal.eventBlock,
 }
 external fromPayload: payload => Internal.eventPayload = "%identity"
 external toPayload: Internal.eventPayload => payload = "%identity"
 
+// Ordered transaction field names, the field codes shared with the Rust store
+// (`EvmTxField`). Derived from the typed field list so the two can't drift;
+// `Internal.allEvmTransactionFields` is pinned to the Rust ordinal order by a test.
+let transactionFields =
+  Internal.allEvmTransactionFields->(
+    Utils.magic: array<Internal.evmTransactionField> => array<string>
+  )
+
+// One event's selected transaction fields → store selection bitmask. Computed
+// per event at config build and cached on the event config.
+let eventTransactionFieldMask = TransactionStore.makeMaskFn(transactionFields)
+
+// Ordered block field names. The index of each is the field code shared with the
+// Rust store (`EvmBlockField`) — keep this order in sync.
+let blockFields = [
+  "number",
+  "timestamp",
+  "hash",
+  "parentHash",
+  "nonce",
+  "sha3Uncles",
+  "logsBloom",
+  "transactionsRoot",
+  "stateRoot",
+  "receiptsRoot",
+  "miner",
+  "difficulty",
+  "totalDifficulty",
+  "extraData",
+  "size",
+  "gasLimit",
+  "gasUsed",
+  "uncles",
+  "baseFeePerGas",
+  "blobGasUsed",
+  "excessBlobGas",
+  "parentBeaconBlockRoot",
+  "withdrawalsRoot",
+  "l1BlockNumber",
+  "sendCount",
+  "sendRoot",
+  "mixHash",
+]
+
+// One event's selected block fields → store selection bitmask. Computed per
+// event at config build and cached on the event config.
+let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields)
+
 let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
     delete fields.hash
     delete fields.number
@@ -21,70 +73,6 @@ let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
 
 let make = (~logger: Pino.t): Ecosystem.t => {
   name: Evm,
-  blockFields: [
-    "number",
-    "timestamp",
-    "hash",
-    "parentHash",
-    "nonce",
-    "sha3Uncles",
-    "logsBloom",
-    "transactionsRoot",
-    "stateRoot",
-    "receiptsRoot",
-    "miner",
-    "difficulty",
-    "totalDifficulty",
-    "extraData",
-    "size",
-    "gasLimit",
-    "gasUsed",
-    "uncles",
-    "baseFeePerGas",
-    "blobGasUsed",
-    "excessBlobGas",
-    "parentBeaconBlockRoot",
-    "withdrawalsRoot",
-    "l1BlockNumber",
-    "sendCount",
-    "sendRoot",
-    "mixHash",
-  ],
-  transactionFields: [
-    "transactionIndex",
-    "hash",
-    "from",
-    "to",
-    "gas",
-    "gasPrice",
-    "maxPriorityFeePerGas",
-    "maxFeePerGas",
-    "cumulativeGasUsed",
-    "effectiveGasPrice",
-    "gasUsed",
-    "input",
-    "nonce",
-    "value",
-    "v",
-    "r",
-    "s",
-    "contractAddress",
-    "logsBloom",
-    "root",
-    "status",
-    "yParity",
-    "chainId",
-    "maxFeePerBlobGas",
-    "blobVersionedHashes",
-    "type",
-    "l1Fee",
-    "l1GasPrice",
-    "l1GasUsed",
-    "l1FeeScalar",
-    "gasUsedForL1",
-    "accessList",
-    "authorizationList",
-  ],
   blockNumberName: "number",
   blockTimestampName: "timestamp",
   blockHashName: "hash",
@@ -102,17 +90,22 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   // range chunk is validated by `eventBlockRangeSchema` in
   // `LogSelection.res` which rejects `_lte`/`_every` (use `onBlock` for
   // stride- and endBlock-based block handlers).
+  // `S.strict` on the inner object rejects unknown `block` fields (e.g. a
+  // `numbre` typo or `block: {timestamp: ...}`) instead of silently
+  // ignoring them.
   onEventBlockFilterSchema: S.object(s =>
-    s.field("block", S.option(S.object(s2 => s2.field("number", S.unknown))))
+    s.field("block", S.option(S.object(s2 => s2.field("number", S.unknown))->S.strict))
   ),
   logger,
-  toEvent: eventItem => eventItem.payload->Internal.payloadToEvent,
+  // The payload carries `transaction` by batch prep (HyperSync) or inline
+  // (RPC/simulate), so the event is the payload as-is.
+  toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),
   toEventLogger: eventItem =>
     Logging.createChildFrom(
       ~logger,
       ~params={
-        "contract": eventItem.eventConfig.contractName,
-        "event": eventItem.eventConfig.name,
+        "contract": eventItem.onEventRegistration.eventConfig.contractName,
+        "event": eventItem.onEventRegistration.eventConfig.name,
         "chainId": eventItem.chain->ChainMap.Chain.toChainId,
         "block": eventItem.blockNumber,
         "logIndex": eventItem.logIndex,
@@ -121,11 +114,29 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     ),
   toRawEvent: eventItem => {
     let payload = eventItem.payload->toPayload
+    let eventConfig =
+      eventItem.onEventRegistration.eventConfig->(
+        Utils.magic: Internal.eventConfig => Internal.evmEventConfig
+      )
+    // Store-backed payloads get `block` written at batch prep and inline
+    // sources carry it from the start, with hash/timestamp always selected —
+    // so both are present by the time a raw event is built.
+    let header = switch payload.block {
+    | Some(block) => block->(Utils.magic: Internal.eventBlock => {"hash": string, "timestamp": int})
+    | None =>
+      JsError.throwWithMessage("Unexpected case: The event block is missing for a raw event")
+    }
     eventItem->RawEvent.make(
       ~block=payload.block,
       ~transaction=payload.transaction,
-      ~params=payload.params,
+      // The decoder emits `{}` for zero-parameter events, which the params
+      // schema rejects; pass unit so it serializes to the "null" sentinel.
+      ~params=eventConfig.paramsMetadata->Array.length == 0
+        ? ()->(Utils.magic: unit => Internal.eventParams)
+        : payload.params,
       ~srcAddress=payload.srcAddress,
+      ~blockHash=header["hash"],
+      ~blockTimestamp=header["timestamp"],
       ~cleanUpRawEventFieldsInPlace,
     )
   },