envio 3.3.0-alpha.1 → 3.3.0-alpha.3

package/src/SimulateItems.res.mjs

@@ -135,6 +135,64 @@ function findEventConfig(config, contractName, eventName) {
   return found.contents;
 }
 
+let dummySrcAddress = "0x0000000000000000000000000000000000000000";
+
+function firstContractAddress(chainConfig, contractName) {
+  let found = {
+    contents: undefined
+  };
+  chainConfig.contracts.forEach(contract => {
+    if (Stdlib_Option.isNone(found.contents) && contract.name === contractName) {
+      found.contents = contract.addresses[0];
+      return;
+    }
+  });
+  return found.contents;
+}
+
+function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig) {
+  if (providedSrcAddress !== undefined) {
+    return Primitive_option.valFromOption(providedSrcAddress);
+  }
+  if (eventConfig.isWildcard) {
+    return dummySrcAddress;
+  }
+  let addr = firstContractAddress(chainConfig, eventConfig.contractName);
+  if (addr !== undefined) {
+    return Primitive_option.valFromOption(addr);
+  } else {
+    return dummySrcAddress;
+  }
+}
+
+function validateSrcAddresses(simulateItems, config, chainConfig, indexingAddresses) {
+  let known = new Set();
+  indexingAddresses.forEach(ia => {
+    known.add(ia.address);
+  });
+  simulateItems.forEach(rawJson => {
+    let match = rawJson.contract;
+    let match$1 = rawJson.event;
+    if (match === undefined) {
+      return;
+    }
+    if (match$1 === undefined) {
+      return;
+    }
+    let eventConfig = findEventConfig(config, match, match$1);
+    if (eventConfig === undefined) {
+      return;
+    }
+    if (eventConfig.isWildcard) {
+      return;
+    }
+    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig, chainConfig);
+    if (!known.has(srcAddress)) {
+      return Stdlib_JsError.throwWithMessage(`simulate: ` + match + `.` + match$1 + ` resolved to address ` + srcAddress + `, which isn't indexed on chain ` + chainConfig.id.toString() + `. ` + (`Provide a "srcAddress" configured or registered for ` + match + ` on this chain, or use a wildcard event.`));
+    }
+  });
+}
+
 function parse(simulateItems, config, chainConfig) {
   let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
   let chainId = chainConfig.id;
@@ -169,26 +227,7 @@ function parse(simulateItems, config, chainConfig) {
       currentLogIndex.contents = li$1 + 1 | 0;
       logIndex = li$1;
     }
-    let addr = rawJson.srcAddress;
-    let srcAddress;
-    if (addr !== undefined) {
-      srcAddress = Primitive_option.valFromOption(addr);
-    } else {
-      let addr$1 = {
-        contents: "0x0000000000000000000000000000000000000000"
-      };
-      chainConfig.contracts.forEach(contract => {
-        if (contract.name !== match) {
-          return;
-        }
-        let a = contract.addresses[0];
-        if (a !== undefined) {
-          addr$1.contents = Primitive_option.valFromOption(a);
-          return;
-        }
-      });
-      srcAddress = addr$1.contents;
-    }
+    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig, chainConfig);
     let blockJson = rawJson.block;
     let blockJson$1 = (blockJson == null) ? undefined : Primitive_option.some(blockJson);
     let transactionJson = rawJson.transaction;
@@ -241,6 +280,7 @@ function parse(simulateItems, config, chainConfig) {
       blockNumber: blockNumber,
       blockHash: match$3[3],
       logIndex: logIndex,
+      transactionIndex: 0,
       payload: {
         contractName: eventConfig.contractName,
         eventName: eventConfig.name,
@@ -248,7 +288,7 @@ function parse(simulateItems, config, chainConfig) {
         chainId: chainId,
         srcAddress: srcAddress,
         logIndex: logIndex,
-        transaction: transaction,
+        transaction: Primitive_option.some(transaction),
         block: match$3[0]
       }
     });
@@ -317,6 +357,10 @@ export {
   fuelSimulateTransactionSchema,
   parseFuelSimulateTransaction,
   findEventConfig,
+  dummySrcAddress,
+  firstContractAddress,
+  deriveSrcAddress,
+  validateSrcAddresses,
   parse,
   patchConfig,
 }

package/src/TestIndexer.res

@@ -43,6 +43,33 @@ let toIndexingAddress = (dc: InternalTable.EnvioAddresses.t): Internal.indexingA
   registrationBlock: dc.registrationBlock,
 }
 
+// All indexing addresses (config-seeded + dynamically registered) grouped by
+// chain id string, derived from the envio_addresses entities.
+let getIndexingAddressesByChain = (state: testIndexerState): dict<
+  array<Internal.indexingAddress>,
+> => {
+  let byChain = Dict.make()
+  switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
+  | Some(dcDict) =>
+    dcDict
+    ->Dict.valuesToArray
+    ->Array.forEach(entity => {
+      let dc = entity->castToEnvioAddresses
+      let chainIdStr = dc.chainId->Int.toString
+      let contracts = switch byChain->Dict.get(chainIdStr) {
+      | Some(arr) => arr
+      | None =>
+        let arr = []
+        byChain->Dict.set(chainIdStr, arr)
+        arr
+      }
+      contracts->Array.push(dc->toIndexingAddress)->ignore
+    })
+  | None => ()
+  }
+  byChain
+}
+
 let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFilter.t): JSON.t => {
   // Loads for non-entity tables (e.g. effect caches `envio_effect_<name>`) reach
   // here too. TestIndexer never persists those, so there's nothing to return —
@@ -566,22 +593,10 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
                   `Cannot access ${contract.name}.addresses while indexer.process() is running. ` ++ "Wait for process() to complete before reading contract addresses.",
                 )
               }
-              let addresses = []
-              switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
-              | Some(dcDict) =>
-                dcDict
-                ->Dict.valuesToArray
-                ->Array.forEach(
-                  entity => {
-                    let dc = entity->castToEnvioAddresses
-                    if dc.contractName === contract.name && dc.chainId === chainConfig.id {
-                      addresses->Array.push(dc->Config.EnvioAddresses.getAddress)->ignore
-                    }
-                  },
-                )
-              | None => ()
-              }
-              addresses
+              getIndexingAddressesByChain(state)
+              ->Dict.get(chainConfig.id->Int.toString)
+              ->Option.getOr([])
+              ->Array.filterMap(ia => ia.contractName === contract.name ? Some(ia.address) : None)
             },
           },
         )
@@ -653,6 +668,7 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
           })
 
           // Parse and validate all chain configs upfront before starting any workers
+          let preflightAddressesByChain = getIndexingAddressesByChain(state)
           let chainEntries = sortedChainKeys->Array.map(chainIdStr => {
             let rawChainConfig = rawChains->Dict.getUnsafe(chainIdStr)
             let chainId = switch chainIdStr->Int.fromString {
@@ -668,6 +684,19 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
               ~rawChainConfig,
               ~progressBlock=state.progressBlockByChain->Dict.get(chainIdStr),
             )
+            switch rawChainConfig.simulate {
+            | Some(simulateItems) =>
+              let chainConfig = config.chainMap->ChainMap.get(ChainMap.Chain.makeUnsafe(~chainId))
+              SimulateItems.validateSrcAddresses(
+                ~simulateItems,
+                ~config,
+                ~chainConfig,
+                ~indexingAddresses=preflightAddressesByChain
+                ->Dict.get(chainIdStr)
+                ->Option.getOr([]),
+              )
+            | None => ()
+            }
             (chainIdStr, chainId, rawChainConfig, processChainConfig)
           })
 
@@ -684,26 +713,9 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
             let chains: dict<chainConfig> = Dict.make()
             chains->Dict.set(chainIdStr, processChainConfig)
 
-            // Extract dynamic contracts from state.entities for each chain
-            let indexingAddressesByChain: dict<array<Internal.indexingAddress>> = Dict.make()
-            switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
-            | Some(dcDict) =>
-              dcDict
-              ->Dict.valuesToArray
-              ->Array.forEach(entity => {
-                let dc = entity->castToEnvioAddresses
-                let dcChainIdStr = dc.chainId->Int.toString
-                let contracts = switch indexingAddressesByChain->Dict.get(dcChainIdStr) {
-                | Some(arr) => arr
-                | None =>
-                  let arr = []
-                  indexingAddressesByChain->Dict.set(dcChainIdStr, arr)
-                  arr
-                }
-                contracts->Array.push(dc->toIndexingAddress)->ignore
-              })
-            | None => ()
-            }
+            // Rebuilt per chain so workers see contracts registered by earlier
+            // chains in the same process() call.
+            let indexingAddressesByChain = getIndexingAddressesByChain(state)
 
             let initialState = makeInitialState(
               ~config,

package/src/TestIndexer.res.mjs

@@ -12,6 +12,7 @@ import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SimulateItems from "./SimulateItems.res.mjs";
@@ -32,6 +33,27 @@ function toIndexingAddress(dc) {
   };
 }
 
+function getIndexingAddressesByChain(state) {
+  let byChain = {};
+  let dcDict = state.entities[Config.EnvioAddresses.name];
+  if (dcDict !== undefined) {
+    Object.values(dcDict).forEach(entity => {
+      let chainIdStr = entity.chain_id.toString();
+      let arr = byChain[chainIdStr];
+      let contracts;
+      if (arr !== undefined) {
+        contracts = arr;
+      } else {
+        let arr$1 = [];
+        byChain[chainIdStr] = arr$1;
+        contracts = arr$1;
+      }
+      contracts.push(toIndexingAddress(entity));
+    });
+  }
+  return byChain;
+}
+
 function handleLoad(state, tableName, filter) {
   let entityConfig = state.entityConfigs[tableName];
   if (entityConfig === undefined) {
@@ -403,17 +425,11 @@ function makeCreateTestIndexer(config, workerPath) {
             if (state.processInProgress) {
               Stdlib_JsError.throwWithMessage(`Cannot access ` + contract.name + `.addresses while indexer.process() is running. ` + "Wait for process() to complete before reading contract addresses.");
             }
-            let addresses = [];
-            let dcDict = state.entities[Config.EnvioAddresses.name];
-            if (dcDict !== undefined) {
-              Object.values(dcDict).forEach(entity => {
-                if (entity.contract_name === contract.name && entity.chain_id === chainConfig.id) {
-                  addresses.push(Config.EnvioAddresses.getAddress(entity));
-                  return;
-                }
-              });
-            }
-            return addresses;
+            return Stdlib_Array.filterMap(Stdlib_Option.getOr(getIndexingAddressesByChain(state)[chainConfig.id.toString()], []), ia => {
+              if (ia.contractName === contract.name) {
+                return Primitive_option.some(ia.address);
+              }
+            });
           }
         });
         Object.defineProperty(chainObj, contract.name, {
@@ -465,11 +481,17 @@ function makeCreateTestIndexer(config, workerPath) {
         let bId = Stdlib_Option.getOr(Stdlib_Int.fromString(b, undefined), 0);
         return Primitive_int.compare(aId, bId);
       });
+      let preflightAddressesByChain = getIndexingAddressesByChain(state);
       let chainEntries = sortedChainKeys.map(chainIdStr => {
         let rawChainConfig = rawChains[chainIdStr];
         let id = Stdlib_Int.fromString(chainIdStr, undefined);
         let chainId = id !== undefined ? id : Stdlib_JsError.throwWithMessage(`Invalid chain ID "` + chainIdStr + `": expected a numeric chain ID`);
         let processChainConfig = parseBlockRange(chainIdStr, config, rawChainConfig, state.progressBlockByChain[chainIdStr]);
+        let simulateItems = rawChainConfig.simulate;
+        if (simulateItems !== undefined) {
+          let chainConfig = ChainMap.get(config.chainMap, ChainMap.Chain.makeUnsafe(chainId));
+          SimulateItems.validateSrcAddresses(simulateItems, config, chainConfig, Stdlib_Option.getOr(preflightAddressesByChain[chainIdStr], []));
+        }
         return [
           chainIdStr,
           chainId,
@@ -484,23 +506,7 @@ function makeCreateTestIndexer(config, workerPath) {
         let chainId = param[1];
         let chains = {};
         chains[param[0]] = processChainConfig;
-        let indexingAddressesByChain = {};
-        let dcDict = state.entities[Config.EnvioAddresses.name];
-        if (dcDict !== undefined) {
-          Object.values(dcDict).forEach(entity => {
-            let dcChainIdStr = entity.chain_id.toString();
-            let arr = indexingAddressesByChain[dcChainIdStr];
-            let contracts;
-            if (arr !== undefined) {
-              contracts = arr;
-            } else {
-              let arr$1 = [];
-              indexingAddressesByChain[dcChainIdStr] = arr$1;
-              contracts = arr$1;
-            }
-            contracts.push(toIndexingAddress(entity));
-          });
-        }
+        let indexingAddressesByChain = getIndexingAddressesByChain(state);
         let initialState = makeInitialState(config, chains, indexingAddressesByChain);
         return new Promise((resolve, reject) => {
           let workerData_startBlock = processChainConfig.startBlock;
@@ -645,6 +651,7 @@ function initTestWorker() {
 
 export {
   toIndexingAddress,
+  getIndexingAddressesByChain,
   handleLoad,
   handleWriteBatch,
   makeInitialState,

package/src/bindings/Performance.res

@@ -0,0 +1,7 @@
+type timeRef = float
+
+@val @scope("performance") external now: unit => timeRef = "now"
+
+let secondsSince = (from: timeRef): float => (now() -. from) /. 1000.
+
+let secondsBetween = (~from: timeRef, ~to: timeRef): float => (to -. from) /. 1000.

package/src/bindings/Performance.res.mjs

@@ -0,0 +1,21 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function secondsSince(from) {
+  return (performance.now() - from) / 1000;
+}
+
+function secondsBetween(from, to) {
+  return (to - from) / 1000;
+}
+
+function now(prim) {
+  return performance.now();
+}
+
+export {
+  now,
+  secondsSince,
+  secondsBetween,
+}
+/* No side effect */

package/src/bindings/Performance.resi

@@ -0,0 +1,7 @@
+type timeRef = float
+
+let now: unit => timeRef
+
+let secondsSince: timeRef => float
+
+let secondsBetween: (~from: timeRef, ~to: timeRef) => float

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,10 +85,10 @@ 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)
   }
 }
 

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,10 +90,10 @@ 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);
   }
 }
 

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,51 @@ type payload = {
   chainId: int,
   srcAddress: Address.t,
   logIndex: int,
-  transaction: Internal.eventTransaction,
+  transaction?: Internal.eventTransaction,
   block: Internal.eventBlock,
 }
 external fromPayload: payload => Internal.eventPayload = "%identity"
 external toPayload: Internal.eventPayload => payload = "%identity"
 
+// Ordered transaction field names. The index of each is the field code shared
+// with the Rust store (`EvmTxField`) — keep this order in sync.
+let transactionFields = [
+  "transactionIndex",
+  "hash",
+  "from",
+  "to",
+  "gas",
+  "gasPrice",
+  "maxPriorityFeePerGas",
+  "maxFeePerGas",
+  "cumulativeGasUsed",
+  "effectiveGasPrice",
+  "gasUsed",
+  "input",
+  "nonce",
+  "value",
+  "v",
+  "r",
+  "s",
+  "contractAddress",
+  "logsBloom",
+  "root",
+  "status",
+  "yParity",
+  "maxFeePerBlobGas",
+  "blobVersionedHashes",
+  "type",
+  "l1Fee",
+  "l1GasPrice",
+  "l1GasUsed",
+  "l1FeeScalar",
+  "gasUsedForL1",
+  "accessList",
+  "authorizationList",
+]
+
+let transactionFieldMask = TransactionStore.makeMaskFn(transactionFields)
+
 let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
     delete fields.hash
     delete fields.number
@@ -21,70 +62,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",
@@ -106,7 +83,10 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     s.field("block", S.option(S.object(s2 => s2.field("number", S.unknown))))
   ),
   logger,
-  toEvent: eventItem => eventItem.payload->Internal.payloadToEvent,
+  transactionFieldMask,
+  // 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,