envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/GlobalStateManager.res

@@ -1,4 +1,3 @@
-open Belt
 module type State = {
   type t
   type action
@@ -40,7 +39,7 @@ module MakeManager = (S: State) => {
   }
   and dispatchTask = (self, task: S.task) => {
     let stateId = self.state->S.getId
-    Js.Global.setTimeout(() => {
+    setTimeout(() => {
       if stateId !== self.state->S.getId {
         Logging.info("Invalidated task discarded")
       } else {

package/src/GlobalStateManager.res.mjs

@@ -1,60 +1,52 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Logging from "./Logging.res.mjs";
-import * as $$Promise from "./bindings/Promise.res.mjs";
 import * as Process from "process";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as GlobalState from "./GlobalState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function make(state, onErrorOpt) {
-  var onError = onErrorOpt !== undefined ? onErrorOpt : (function (e) {
-        ErrorHandling.log(ErrorHandling.make(e, undefined, "Indexer has failed with an unexpected error"));
-        Process.exit(1);
-      });
+  let onError = onErrorOpt !== undefined ? onErrorOpt : e => {
+      ErrorHandling.log(ErrorHandling.make(e, undefined, "Indexer has failed with an unexpected error"));
+      Process.exit(1);
+    };
   return {
-          state: state,
-          onError: onError
-        };
+    state: state,
+    onError: onError
+  };
 }
 
 function dispatchAction(stateIdOpt, self, action) {
-  var stateId = stateIdOpt !== undefined ? stateIdOpt : 0;
+  let stateId = stateIdOpt !== undefined ? stateIdOpt : 0;
   try {
-    var reducer = stateId === GlobalState.getId(self.state) ? GlobalState.actionReducer : GlobalState.invalidatedActionReducer;
-    var match = reducer(self.state, action);
+    let reducer = stateId === GlobalState.getId(self.state) ? GlobalState.actionReducer : GlobalState.invalidatedActionReducer;
+    let match = reducer(self.state, action);
     self.state = match[0];
-    return Belt_Array.forEach(match[1], (function (task) {
-                  dispatchTask(self, task);
-                }));
-  }
-  catch (raw_e){
-    var e = Caml_js_exceptions.internalToOCamlException(raw_e);
-    return self.onError(e);
+    match[1].forEach(task => dispatchTask(self, task));
+    return;
+  } catch (raw_e) {
+    return self.onError(Primitive_exceptions.internalToException(raw_e));
   }
 }
 
 function dispatchTask(self, task) {
-  var stateId = GlobalState.getId(self.state);
-  setTimeout((function () {
-          if (stateId !== GlobalState.getId(self.state)) {
-            return Logging.info("Invalidated task discarded");
-          }
-          try {
-            $$Promise.$$catch(GlobalState.taskReducer(self.state, task, (function (action) {
-                        dispatchAction(stateId, self, action);
-                      })), (function (e) {
-                    self.onError(e);
-                    return Promise.resolve();
-                  }));
-            return ;
-          }
-          catch (raw_e){
-            var e = Caml_js_exceptions.internalToOCamlException(raw_e);
-            return self.onError(e);
-          }
-        }), 0);
+  let stateId = GlobalState.getId(self.state);
+  setTimeout(() => {
+    if (stateId !== GlobalState.getId(self.state)) {
+      return Logging.info("Invalidated task discarded");
+    }
+    try {
+      Stdlib_Promise.$$catch(GlobalState.taskReducer(self.state, task, action => dispatchAction(stateId, self, action)), e => {
+        self.onError(e);
+        return Promise.resolve();
+      });
+      return;
+    } catch (raw_e) {
+      return self.onError(Primitive_exceptions.internalToException(raw_e));
+    }
+  }, 0);
 }
 
 function getState(self) {
@@ -66,10 +58,10 @@ function setState(self, state) {
 }
 
 export {
-  make ,
-  dispatchAction ,
-  dispatchTask ,
-  getState ,
-  setState ,
+  make,
+  dispatchAction,
+  dispatchTask,
+  getState,
+  setState,
 }
 /* Logging Not a pure module */

package/src/HandlerLoader.res

@@ -25,11 +25,14 @@ let registerContractHandlers = async (~contractName, ~handler: option<string>) =
       let _ = await Utils.importPath(toImportUrl(handlerPath))
     } catch {
     | exn =>
+      let cause = exn->Utils.prettifyExn->Obj.magic
       Logging.errorWithExn(
         exn,
         `Failed to load handler file for contract ${contractName}: ${handlerPath}`,
       )
-      Js.Exn.raiseError(`Failed to load handler file for contract ${contractName}: ${handlerPath}`)
+      JsError.throwWithMessage(
+        `Failed to load handler file for contract ${contractName}: ${handlerPath}. Cause: ${cause}`,
+      )
     }
   }
 }
@@ -41,16 +44,16 @@ let autoLoadFromSrcHandlers = async (~handlers: string) => {
     let iterator = globIterator(srcPattern)
     let files = await iterator->Utils.Array.fromAsyncIterator
     // Filter out test and spec files
-    files->Js.Array2.filter(file => {
+    files->Array.filter(file => {
       !(
-        file->Js.String2.includes(".test.") ||
-        file->Js.String2.includes(".spec.") ||
-        file->Js.String2.includes("_test.")
+        file->String.includes(".test.") ||
+        file->String.includes(".spec.") ||
+        file->String.includes("_test.")
       )
     })
   } catch {
   | exn =>
-    Js.Exn.raiseError(
+    JsError.throwWithMessage(
       `Failed to glob src/handlers directory for auto-loading handlers. Pattern: ${srcPattern}. Before continuing, check that you're using Node.js >=22 version. Error: ${exn
         ->Utils.prettifyExn
         ->Obj.magic}`,
@@ -58,19 +61,100 @@ let autoLoadFromSrcHandlers = async (~handlers: string) => {
   }
 
   // Import handler files using absolute file:// URLs resolved from cwd
-  let _ =
-    await handlerFiles
-    ->Js.Array2.map(file => {
-      Utils.importPath(toImportUrl(file))->Promise.catch(exn => {
-        Logging.errorWithExn(exn, `Failed to auto-load handler file: ${file}`)
-        Js.Exn.raiseError(`Failed to auto-load handler file: ${file}`)
-      })
+  let _ = await handlerFiles
+  ->Array.map(file => {
+    Utils.importPath(toImportUrl(file))->Promise.catch(exn => {
+      let cause = exn->Utils.prettifyExn->Obj.magic
+      Logging.errorWithExn(exn, `Failed to auto-load handler file: ${file}`)
+      JsError.throwWithMessage(`Failed to auto-load handler file: ${file}. Cause: ${cause}`)
+    })
+  })
+  ->Promise.all
+}
+
+// EVM re-runs `parseEventFiltersOrThrow` with the registered `where:` JSON so
+// per-event filters propagate into `getEventFiltersOrThrow` / `filterByAddresses`
+// — which is why `evmEventConfig` has to retain `sighash` and `indexedParams`.
+// `dependsOnAddresses` is routed through `Internal.dependsOnAddresses` so the
+// formula stays in sync with `EventConfigBuilder.build{Evm,Fuel}EventConfig`.
+let applyRegistrations = (~config: Config.t): Config.t => {
+  let newChainMap = config.chainMap->ChainMap.map(chain => {
+    let newContracts = chain.contracts->Array.map(contract => {
+      let newEvents = contract.events->Array.map(
+        ev => {
+          let isWildcard = HandlerRegister.isWildcard(
+            ~contractName=ev.contractName,
+            ~eventName=ev.name,
+          )
+          let handler = HandlerRegister.getHandler(
+            ~contractName=ev.contractName,
+            ~eventName=ev.name,
+          )
+          let contractRegister = HandlerRegister.getContractRegister(
+            ~contractName=ev.contractName,
+            ~eventName=ev.name,
+          )
+          switch config.ecosystem.name {
+          | Fuel =>
+            let fuelEv = ev->(Utils.magic: Internal.eventConfig => Internal.fuelEventConfig)
+
+            ({
+              ...fuelEv,
+              isWildcard,
+              handler,
+              contractRegister,
+              dependsOnAddresses: Internal.dependsOnAddresses(
+                ~isWildcard,
+                ~filterByAddresses=false,
+              ),
+            } :> Internal.eventConfig)
+          | Evm =>
+            let evmEv = ev->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
+            let eventFilters = HandlerRegister.getOnEventWhere(
+              ~contractName=ev.contractName,
+              ~eventName=ev.name,
+            )
+            let {getEventFiltersOrThrow, filterByAddresses} = LogSelection.parseEventFiltersOrThrow(
+              ~eventFilters,
+              ~sighash=evmEv.sighash,
+              ~params=evmEv.indexedParams->Array.map(p => p.name),
+              ~contractName=ev.contractName,
+              ~probeChainId=chain.id,
+              ~onEventBlockFilterSchema=config.ecosystem.onEventBlockFilterSchema,
+              ~topic1=?evmEv.indexedParams
+              ->Array.get(0)
+              ->Option.map(EventConfigBuilder.buildTopicGetter),
+              ~topic2=?evmEv.indexedParams
+              ->Array.get(1)
+              ->Option.map(EventConfigBuilder.buildTopicGetter),
+              ~topic3=?evmEv.indexedParams
+              ->Array.get(2)
+              ->Option.map(EventConfigBuilder.buildTopicGetter),
+            )
+
+            ({
+              ...evmEv,
+              isWildcard,
+              handler,
+              contractRegister,
+              getEventFiltersOrThrow,
+              filterByAddresses,
+              dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses),
+            } :> Internal.eventConfig)
+          | Svm =>
+            JsError.throwWithMessage(`SVM does not support indexer.onEvent or indexer.contractRegister. Use indexer.onSlot for per-slot handlers.`)
+          }
+        },
+      )
+      {...contract, events: newEvents}
     })
-    ->Promise.all
+    {...chain, contracts: newContracts}
+  })
+  {...config, chainMap: newChainMap}
 }
 
-// Register all handlers - must be called BEFORE creating the final config
-// so that event registrations are captured in the config
+// `Config` never reads `HandlerRegister`. The only way to get a config that
+// reflects registration state is through the returned value here.
 let registerAllHandlers = async (~config: Config.t) => {
   HandlerRegister.startRegistration(~ecosystem=config.ecosystem, ~multichain=config.multichain)
 
@@ -78,12 +162,12 @@ let registerAllHandlers = async (~config: Config.t) => {
   await autoLoadFromSrcHandlers(~handlers=config.handlers)
 
   // Load contract-specific handlers
-  let _ =
-    await config.contractHandlers
-    ->Js.Array2.map(({name, handler}) => {
-      registerContractHandlers(~contractName=name, ~handler)
-    })
-    ->Promise.all
+  let _ = await config.contractHandlers
+  ->Array.map(({name, handler}) => {
+    registerContractHandlers(~contractName=name, ~handler)
+  })
+  ->Promise.all
 
-  HandlerRegister.finishRegistration()
+  let registrations = HandlerRegister.finishRegistration()
+  (applyRegistrations(~config), registrations)
 }

package/src/HandlerLoader.res.mjs

@@ -3,77 +3,167 @@
 import * as Url from "url";
 import * as Path from "path";
 import * as Utils from "./Utils.res.mjs";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Logging from "./Logging.res.mjs";
-import * as $$Promise from "./bindings/Promise.res.mjs";
 import * as Process from "process";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as Internal from "./Internal.res.mjs";
 import * as Nodemodule from "node:module";
+import * as LogSelection from "./LogSelection.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as HandlerRegister from "./HandlerRegister.res.mjs";
 import * as Promises from "node:fs/promises";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as EventConfigBuilder from "./EventConfigBuilder.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 try {
   Nodemodule.register("tsx/esm", import.meta.url);
-}
-catch (exn){
+} catch (exn) {
   
 }
 
 function toImportUrl(relativePath) {
-  var absolutePath = Path.resolve(Process.cwd(), relativePath);
+  let absolutePath = Path.resolve(Process.cwd(), relativePath);
   return Url.pathToFileURL(absolutePath).toString();
 }
 
 async function registerContractHandlers(contractName, handler) {
   if (handler === undefined) {
-    return ;
+    return;
   }
   try {
     await import(toImportUrl(handler));
-    return ;
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-    Logging.errorWithExn(exn, "Failed to load handler file for contract " + contractName + ": " + handler);
-    return Js_exn.raiseError("Failed to load handler file for contract " + contractName + ": " + handler);
+    return;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let cause = Utils.prettifyExn(exn);
+    Logging.errorWithExn(exn, `Failed to load handler file for contract ` + contractName + `: ` + handler);
+    return Stdlib_JsError.throwWithMessage(`Failed to load handler file for contract ` + contractName + `: ` + handler + `. Cause: ` + cause);
   }
 }
 
 async function autoLoadFromSrcHandlers(handlers) {
-  var srcPattern = "./" + handlers + "/**/*.{js,mjs,ts}";
-  var handlerFiles;
+  let srcPattern = `./` + handlers + `/**/*.{js,mjs,ts}`;
+  let handlerFiles;
   try {
-    var iterator = Promises.glob(srcPattern);
-    var files = await Utils.$$Array.fromAsyncIterator(iterator);
-    handlerFiles = files.filter(function (file) {
-          return !(file.includes(".test.") || file.includes(".spec.") || file.includes("_test."));
-        });
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-    handlerFiles = Js_exn.raiseError("Failed to glob src/handlers directory for auto-loading handlers. Pattern: " + srcPattern + ". Before continuing, check that you're using Node.js >=22 version. Error: " + Utils.prettifyExn(exn));
+    let iterator = Promises.glob(srcPattern);
+    let files = await Utils.$$Array.fromAsyncIterator(iterator);
+    handlerFiles = files.filter(file => !(file.includes(".test.") || file.includes(".spec.") || file.includes("_test.")));
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    handlerFiles = Stdlib_JsError.throwWithMessage(`Failed to glob src/handlers directory for auto-loading handlers. Pattern: ` + srcPattern + `. Before continuing, check that you're using Node.js >=22 version. Error: ` + Utils.prettifyExn(exn));
   }
-  await Promise.all(handlerFiles.map(function (file) {
-            return $$Promise.$$catch(import(toImportUrl(file)), (function (exn) {
-                          Logging.errorWithExn(exn, "Failed to auto-load handler file: " + file);
-                          return Js_exn.raiseError("Failed to auto-load handler file: " + file);
-                        }));
-          }));
+  await Promise.all(handlerFiles.map(file => Stdlib_Promise.$$catch(import(toImportUrl(file)), exn => {
+    let cause = Utils.prettifyExn(exn);
+    Logging.errorWithExn(exn, `Failed to auto-load handler file: ` + file);
+    return Stdlib_JsError.throwWithMessage(`Failed to auto-load handler file: ` + file + `. Cause: ` + cause);
+  })));
+}
+
+function applyRegistrations(config) {
+  let newChainMap = ChainMap.map(config.chainMap, chain => {
+    let newContracts = chain.contracts.map(contract => {
+      let newEvents = contract.events.map(ev => {
+        let isWildcard = HandlerRegister.isWildcard(ev.contractName, ev.name);
+        let handler = HandlerRegister.getHandler(ev.contractName, ev.name);
+        let contractRegister = HandlerRegister.getContractRegister(ev.contractName, ev.name);
+        let match = config.ecosystem.name;
+        switch (match) {
+          case "evm" :
+            let eventFilters = HandlerRegister.getOnEventWhere(ev.contractName, ev.name);
+            let match$1 = LogSelection.parseEventFiltersOrThrow(eventFilters, ev.sighash, ev.indexedParams.map(p => p.name), ev.contractName, chain.id, config.ecosystem.onEventBlockFilterSchema, Stdlib_Option.map(ev.indexedParams[0], EventConfigBuilder.buildTopicGetter), Stdlib_Option.map(ev.indexedParams[1], EventConfigBuilder.buildTopicGetter), Stdlib_Option.map(ev.indexedParams[2], EventConfigBuilder.buildTopicGetter));
+            let filterByAddresses = match$1.filterByAddresses;
+            return {
+              id: ev.id,
+              name: ev.name,
+              contractName: ev.contractName,
+              isWildcard: isWildcard,
+              filterByAddresses: filterByAddresses,
+              dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, filterByAddresses),
+              handler: handler,
+              contractRegister: contractRegister,
+              paramsRawEventSchema: ev.paramsRawEventSchema,
+              simulateParamsSchema: ev.simulateParamsSchema,
+              startBlock: ev.startBlock,
+              getEventFiltersOrThrow: match$1.getEventFiltersOrThrow,
+              convertHyperSyncEventArgs: ev.convertHyperSyncEventArgs,
+              selectedBlockFields: ev.selectedBlockFields,
+              selectedTransactionFields: ev.selectedTransactionFields,
+              sighash: ev.sighash,
+              indexedParams: ev.indexedParams
+            };
+          case "fuel" :
+            return {
+              id: ev.id,
+              name: ev.name,
+              contractName: ev.contractName,
+              isWildcard: isWildcard,
+              filterByAddresses: ev.filterByAddresses,
+              dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, false),
+              handler: handler,
+              contractRegister: contractRegister,
+              paramsRawEventSchema: ev.paramsRawEventSchema,
+              simulateParamsSchema: ev.simulateParamsSchema,
+              startBlock: ev.startBlock,
+              kind: ev.kind
+            };
+          case "svm" :
+            return Stdlib_JsError.throwWithMessage(`SVM does not support indexer.onEvent or indexer.contractRegister. Use indexer.onSlot for per-slot handlers.`);
+        }
+      });
+      return {
+        name: contract.name,
+        abi: contract.abi,
+        addresses: contract.addresses,
+        events: newEvents,
+        startBlock: contract.startBlock,
+        eventSignatures: contract.eventSignatures
+      };
+    });
+    let newrecord = {...chain};
+    newrecord.contracts = newContracts;
+    return newrecord;
+  });
+  return {
+    name: config.name,
+    description: config.description,
+    handlers: config.handlers,
+    contractHandlers: config.contractHandlers,
+    shouldRollbackOnReorg: config.shouldRollbackOnReorg,
+    shouldSaveFullHistory: config.shouldSaveFullHistory,
+    storage: config.storage,
+    multichain: config.multichain,
+    chainMap: newChainMap,
+    defaultChain: config.defaultChain,
+    ecosystem: config.ecosystem,
+    enableRawEvents: config.enableRawEvents,
+    maxAddrInPartition: config.maxAddrInPartition,
+    batchSize: config.batchSize,
+    lowercaseAddresses: config.lowercaseAddresses,
+    userEntitiesByName: config.userEntitiesByName,
+    userEntities: config.userEntities,
+    allEntities: config.allEntities,
+    allEnums: config.allEnums
+  };
 }
 
 async function registerAllHandlers(config) {
   HandlerRegister.startRegistration(config.ecosystem, config.multichain);
   await autoLoadFromSrcHandlers(config.handlers);
-  await Promise.all(config.contractHandlers.map(function (param) {
-            return registerContractHandlers(param.name, param.handler);
-          }));
-  return HandlerRegister.finishRegistration();
+  await Promise.all(config.contractHandlers.map(param => registerContractHandlers(param.name, param.handler)));
+  let registrations = HandlerRegister.finishRegistration();
+  return [
+    applyRegistrations(config),
+    registrations
+  ];
 }
 
 export {
-  toImportUrl ,
-  registerContractHandlers ,
-  autoLoadFromSrcHandlers ,
-  registerAllHandlers ,
+  toImportUrl,
+  registerContractHandlers,
+  autoLoadFromSrcHandlers,
+  applyRegistrations,
+  registerAllHandlers,
 }
 /*  Not a pure module */