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

package/src/HandlerLoader.res

@@ -72,108 +72,13 @@ let autoLoadFromSrcHandlers = async (~handlers: string) => {
   ->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 indexedParams = evmEv.paramsMetadata->Array.filter(p => p.indexed)
-            let {
-              getEventFiltersOrThrow,
-              filterByAddresses,
-              addressFilterParamGroups,
-            } = LogSelection.parseEventFiltersOrThrow(
-              ~eventFilters,
-              ~sighash=evmEv.sighash,
-              ~params=indexedParams->Array.map(p => p.name),
-              ~contractName=ev.contractName,
-              ~probeChainId=chain.id,
-              ~onEventBlockFilterSchema=config.ecosystem.onEventBlockFilterSchema,
-              ~topic1=?indexedParams
-              ->Array.get(0)
-              ->Option.map(EventConfigBuilder.buildTopicGetter),
-              ~topic2=?indexedParams
-              ->Array.get(1)
-              ->Option.map(EventConfigBuilder.buildTopicGetter),
-              ~topic3=?indexedParams
-              ->Array.get(2)
-              ->Option.map(EventConfigBuilder.buildTopicGetter),
-            )
-
-            ({
-              ...evmEv,
-              isWildcard,
-              handler,
-              contractRegister,
-              getEventFiltersOrThrow,
-              filterByAddresses,
-              clientAddressFilter: ?EventConfigBuilder.buildAddressFilter(addressFilterParamGroups),
-              dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses),
-            } :> Internal.eventConfig)
-          | Svm =>
-            let svmEv =
-              ev->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
-            ({
-              ...svmEv,
-              isWildcard,
-              handler,
-              contractRegister,
-              dependsOnAddresses: Internal.dependsOnAddresses(
-                ~isWildcard,
-                ~filterByAddresses=false,
-              ),
-            } :> Internal.eventConfig)
-          }
-        },
-      )
-      {...contract, events: newEvents}
-    })
-    {...chain, contracts: newContracts}
-  })
-  {...config, chainMap: newChainMap}
-}
-
-// `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)
+// `Config` holds only event definitions; handler + per-chain `where`
+// registration state is layered on separately as `onEventRegistration`s by
+// `HandlerRegister.finishRegistration`. This loads the user handler files
+// (populating the global `HandlerRegister` registry as a side effect) and
+// returns the resulting per-chain registrations.
+let registerAllHandlers = async (~config: Config.t): HandlerRegister.registrationsByChainId => {
+  HandlerRegister.startRegistration(~config)
 
   // Auto-load all .js files from src/handlers directory
   await autoLoadFromSrcHandlers(~handlers=config.handlers)
@@ -185,6 +90,5 @@ let registerAllHandlers = async (~config: Config.t) => {
   })
   ->Promise.all
 
-  let registrations = HandlerRegister.finishRegistration()
-  (applyRegistrations(~config), registrations)
+  HandlerRegister.finishRegistration(~config)
 }

package/src/HandlerLoader.res.mjs

@@ -5,16 +5,11 @@ import * as Path from "path";
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.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 EventConfigBuilder from "./EventConfigBuilder.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 try {
@@ -61,91 +56,17 @@ async function autoLoadFromSrcHandlers(handlers) {
   })));
 }
 
-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 indexedParams = ev.paramsMetadata.filter(p => p.indexed);
-            let match$1 = LogSelection.parseEventFiltersOrThrow(eventFilters, ev.sighash, indexedParams.map(p => p.name), ev.contractName, chain.id, config.ecosystem.onEventBlockFilterSchema, Stdlib_Option.map(indexedParams[0], EventConfigBuilder.buildTopicGetter), Stdlib_Option.map(indexedParams[1], EventConfigBuilder.buildTopicGetter), Stdlib_Option.map(indexedParams[2], EventConfigBuilder.buildTopicGetter));
-            let filterByAddresses = match$1.filterByAddresses;
-            let newrecord = {...ev};
-            newrecord.getEventFiltersOrThrow = match$1.getEventFiltersOrThrow;
-            newrecord.contractRegister = contractRegister;
-            newrecord.handler = handler;
-            newrecord.clientAddressFilter = EventConfigBuilder.buildAddressFilter(match$1.addressFilterParamGroups);
-            newrecord.dependsOnAddresses = Internal.dependsOnAddresses(isWildcard, filterByAddresses);
-            newrecord.filterByAddresses = filterByAddresses;
-            newrecord.isWildcard = isWildcard;
-            return newrecord;
-          case "fuel" :
-          case "svm" :
-            break;
-        }
-        let newrecord$1 = {...ev};
-        newrecord$1.contractRegister = contractRegister;
-        newrecord$1.handler = handler;
-        newrecord$1.dependsOnAddresses = Internal.dependsOnAddresses(isWildcard, false);
-        newrecord$1.isWildcard = isWildcard;
-        return newrecord$1;
-      });
-      return {
-        name: contract.name,
-        abi: contract.abi,
-        addresses: contract.addresses,
-        events: newEvents,
-        startBlock: contract.startBlock
-      };
-    });
-    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,
-    chainMap: newChainMap,
-    defaultChain: config.defaultChain,
-    ecosystem: config.ecosystem,
-    enableRawEvents: config.enableRawEvents,
-    maxAddrInPartition: config.maxAddrInPartition,
-    batchSize: config.batchSize,
-    lowercaseAddresses: config.lowercaseAddresses,
-    isDev: config.isDev,
-    userEntitiesByName: config.userEntitiesByName,
-    userEntities: config.userEntities,
-    allEntities: config.allEntities,
-    allEnums: config.allEnums
-  };
-}
-
 async function registerAllHandlers(config) {
-  HandlerRegister.startRegistration(config.ecosystem);
+  HandlerRegister.startRegistration(config);
   await autoLoadFromSrcHandlers(config.handlers);
   await Promise.all(config.contractHandlers.map(param => registerContractHandlers(param.name, param.handler)));
-  let registrations = HandlerRegister.finishRegistration();
-  return [
-    applyRegistrations(config),
-    registrations
-  ];
+  return HandlerRegister.finishRegistration(config);
 }
 
 export {
   toImportUrl,
   registerContractHandlers,
   autoLoadFromSrcHandlers,
-  applyRegistrations,
   registerAllHandlers,
 }
 /*  Not a pure module */