envio 3.3.0-alpha.10 → 3.3.0-alpha.11

package/src/Core.res.mjs

@@ -180,6 +180,17 @@ function getConfigJson(configPath, directory) {
   return addon.getConfigJson(Stdlib_Null.fromOption(configPath), Stdlib_Null.fromOption(directory));
 }
 
+function parseConfigYaml(schema, env, files, isRescriptOpt, yaml) {
+  let isRescript = isRescriptOpt !== undefined ? isRescriptOpt : false;
+  let addon = getAddon();
+  return addon.parseConfigYaml(yaml, {
+    schema: schema,
+    env: env,
+    files: files,
+    isRescript: isRescript
+  });
+}
+
 function runCli(args) {
   let addon = getAddon();
   return addon.runCli(args, envioPackageDir);
@@ -196,6 +207,7 @@ export {
   addonRef,
   getAddon,
   getConfigJson,
+  parseConfigYaml,
   runCli,
 }
 /* envioPackageDir Not a pure module */

package/src/CrossChainState.res

@@ -267,7 +267,24 @@ let checkAndFetch = async (
         ~chunkItemsMultiplier,
         ~maxTargetBlock?,
       ) {
-      | (WaitingForNewBlock | NothingToQuery) as action =>
+      | WaitingForNewBlock as action => actionByChain->Utils.Dict.setByInt(chainId, action)
+      | NothingToQuery =>
+        // A chain below its head that emitted no query this tick — its budget
+        // went to more-behind chains, or the cross-chain alignment clamped its
+        // range to nothing — and has nothing else to wake it must keep polling
+        // for new blocks instead of going silent. NothingToQuery isn't
+        // dispatched, so such a chain would never be re-scheduled and its head
+        // tracking would freeze (the knownHeight == 0 branch above forces a poll
+        // for the same reason). A chain is genuinely idle — and correctly left
+        // undispatched — when it is caught up to its head/endblock, still
+        // draining in-flight queries, or holding ready items that batch
+        // processing will drain and re-schedule from.
+        let action =
+          cs->ChainState.isFetchingAtHead ||
+          cs->ChainState.pendingBudget > 0. ||
+          cs->ChainState.bufferReadyCount > 0
+            ? FetchState.NothingToQuery
+            : FetchState.WaitingForNewBlock
         actionByChain->Utils.Dict.setByInt(chainId, action)
       | Ready(queries) => {
           let consumed =

package/src/CrossChainState.res.mjs

@@ -163,7 +163,8 @@ async function checkAndFetch(crossChainState, dispatchChain) {
         actionByChain[chainId] = action;
         return;
       }
-      actionByChain[chainId] = action;
+      let action$1 = ChainState.isFetchingAtHead(cs) || ChainState.pendingBudget(cs) > 0 || ChainState.bufferReadyCount(cs) > 0 ? "NothingToQuery" : "WaitingForNewBlock";
+      actionByChain[chainId] = action$1;
       return;
     } else {
       let queries = action._0;

package/src/EventConfigBuilder.res

@@ -236,58 +236,30 @@ let buildSimulateParamsSchema = (params: array<paramMeta>): S.t<Internal.eventPa
 
 // ============== Build topic filter getters ==============
 
-let getTopicEncoder = (abiType: string): (unknown => EvmTypes.Hex.t) => {
-  // Handle array/tuple types - these get keccak256'd
-  if abiType->String.endsWith("]") || abiType->String.startsWith("(") {
-    TopicFilter.castToHexUnsafe->(Utils.magic: ('a => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t)
-  } else {
-    switch abiType {
-    | "address" =>
-      // Lowercase before encoding so mixed-case (checksummed) user input
-      // still matches the lowercase hex topics returned by sources.
-
-      (
-        (value: string) =>
-          value->String.toLowerCase->Address.unsafeFromString->TopicFilter.fromAddress
-      )->(Utils.magic: (string => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t)
-
-    | "bool" =>
-      TopicFilter.fromBool->(Utils.magic: (bool => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t)
-    | "string" =>
-      TopicFilter.fromDynamicString->(
-        Utils.magic: (string => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
-      )
-
-    | "bytes" =>
-      TopicFilter.fromDynamicBytes->(
-        Utils.magic: (string => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
-      )
-
-    | t if t->String.startsWith("uint") =>
-      TopicFilter.fromBigInt->(Utils.magic: (bigint => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t)
-    | t if t->String.startsWith("int") =>
-      TopicFilter.fromSignedBigInt->(
-        Utils.magic: (bigint => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
-      )
-
-    | t if t->String.startsWith("bytes") =>
-      TopicFilter.castToHexUnsafe->(
-        Utils.magic: ('a => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
-      )
-
-    | other => JsError.throwWithMessage(`Unsupported topic filter ABI type: ${other}`)
-    }
-  }
-}
+let getTopicEncoder = (abiType: string): (unknown => EvmTypes.Hex.t) => value =>
+  Core.getAddon().encodeIndexedTopic(~abiType, ~value)
 
 let buildTopicGetter = (p: paramMeta) => {
   let encoder = getTopicEncoder(p.abiType)
+  let isTuple = p.abiType->String.startsWith("(")
   (eventFilter: dict<JSON.t>) =>
     eventFilter
     ->Utils.Dict.dangerouslyGetNonOption(p.name)
-    ->Option.mapOr([], topicFilters =>
-      topicFilters->(Utils.magic: JSON.t => unknown)->normalizeOrThrow->Array.map(encoder)
-    )
+    ->Option.mapOr([], topicFilters => {
+      let raw = topicFilters->(Utils.magic: JSON.t => unknown)
+      // A tuple filter value is itself an array, so a directly-passed tuple is
+      // indistinguishable from an OR-list by shape alone. A single tuple is
+      // the common case, so try it first; when the value doesn't ABI-encode as
+      // one tuple it must be an OR-list of tuples.
+      if isTuple {
+        switch encoder(raw) {
+        | encoded => [encoded]
+        | exception _ => raw->normalizeOrThrow->Array.map(encoder)
+        }
+      } else {
+        raw->normalizeOrThrow->Array.map(encoder)
+      }
+    })
 }
 
 // ============== Field selection ==============
@@ -452,6 +424,7 @@ let buildEvmOnEventRegistration = (
   }
 
   {
+    index: -1,
     eventConfig: (eventConfig :> Internal.eventConfig),
     isWildcard,
     handler,
@@ -536,6 +509,7 @@ let buildSvmOnEventRegistration = (
   ~contractRegister: option<Internal.contractRegister>,
   ~startBlock: option<int>=?,
 ): Internal.svmOnEventRegistration => {
+  index: -1,
   eventConfig: (eventConfig :> Internal.eventConfig),
   handler,
   contractRegister,
@@ -613,6 +587,7 @@ let buildFuelOnEventRegistration = (
   ~contractRegister: option<Internal.contractRegister>,
   ~startBlock: option<int>=?,
 ): Internal.fuelOnEventRegistration => {
+  index: -1,
   eventConfig: (eventConfig :> Internal.eventConfig),
   handler,
   contractRegister,

package/src/EventConfigBuilder.res.mjs

@@ -2,11 +2,11 @@
 
 import * as Evm from "./sources/Evm.res.mjs";
 import * as Svm from "./sources/Svm.res.mjs";
+import * as Core from "./Core.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Address from "./Address.res.mjs";
 import * as FuelSDK from "./sources/FuelSDK.res.mjs";
 import * as Internal from "./Internal.res.mjs";
-import * as TopicFilter from "./TopicFilter.res.mjs";
 import * as LogSelection from "./LogSelection.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -208,34 +208,24 @@ function buildSimulateParamsSchema(params) {
 }
 
 function getTopicEncoder(abiType) {
-  if (abiType.endsWith("]") || abiType.startsWith("(")) {
-    return TopicFilter.castToHexUnsafe;
-  }
-  switch (abiType) {
-    case "address" :
-      return value => TopicFilter.fromAddress(value.toLowerCase());
-    case "bool" :
-      return TopicFilter.fromBool;
-    case "bytes" :
-      return TopicFilter.fromDynamicBytes;
-    case "string" :
-      return TopicFilter.fromDynamicString;
-    default:
-      if (abiType.startsWith("uint")) {
-        return TopicFilter.fromBigInt;
-      } else if (abiType.startsWith("int")) {
-        return TopicFilter.fromSignedBigInt;
-      } else if (abiType.startsWith("bytes")) {
-        return TopicFilter.castToHexUnsafe;
-      } else {
-        return Stdlib_JsError.throwWithMessage(`Unsupported topic filter ABI type: ` + abiType);
-      }
-  }
+  return value => Core.getAddon().encodeIndexedTopic(abiType, value);
 }
 
 function buildTopicGetter(p) {
   let encoder = getTopicEncoder(p.abiType);
-  return eventFilter => Stdlib_Option.mapOr(eventFilter[p.name], [], topicFilters => normalizeOrThrow(topicFilters).map(encoder));
+  let isTuple = p.abiType.startsWith("(");
+  return eventFilter => Stdlib_Option.mapOr(eventFilter[p.name], [], topicFilters => {
+    if (!isTuple) {
+      return normalizeOrThrow(topicFilters).map(encoder);
+    }
+    let encoded;
+    try {
+      encoded = encoder(topicFilters);
+    } catch (exn) {
+      return normalizeOrThrow(topicFilters).map(encoder);
+    }
+    return [encoded];
+  });
 }
 
 let alwaysIncludedBlockFields = [
@@ -317,6 +307,7 @@ function buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractR
   let sb = resolvedWhere.startBlock;
   let resolvedStartBlock = sb !== undefined ? sb : startBlock;
   return {
+    index: -1,
     eventConfig: eventConfig,
     handler: handler,
     contractRegister: contractRegister,
@@ -369,6 +360,7 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
 
 function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock) {
   return {
+    index: -1,
     eventConfig: eventConfig,
     handler: handler,
     contractRegister: contractRegister,
@@ -438,6 +430,7 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi) {
 
 function buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock) {
   return {
+    index: -1,
     eventConfig: eventConfig,
     handler: handler,
     contractRegister: contractRegister,

package/src/EventProcessing.res

@@ -73,9 +73,10 @@ let runEventHandlerOrThrow = async (
     )
   }
   let handlerDuration = timeBeforeHandler->Performance.secondsSince
+  let eventConfig = eventItem.onEventRegistration.eventConfig
   Prometheus.ProcessingHandler.increment(
-    ~contract=eventItem.onEventRegistration.eventConfig.contractName,
-    ~event=eventItem.onEventRegistration.eventConfig.name,
+    ~contract=eventConfig.contractName,
+    ~event=eventConfig.name,
     ~duration=handlerDuration,
   )
 }
@@ -121,8 +122,8 @@ let runHandlerOrThrow = async (
         }),
       )
     }
-  | Event({onEventRegistration}) =>
-    switch onEventRegistration.handler {
+  | Event(_) =>
+    switch (item->Internal.castUnsafeEventItem).onEventRegistration.handler {
     | Some(handler) =>
       await item->runEventHandlerOrThrow(
         ~handler,
@@ -161,7 +162,9 @@ let preloadBatchOrThrow = async (
     for idx in 0 to checkpointEventsProcessed - 1 {
       let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
       switch item {
-      | Event({onEventRegistration: {handler, eventConfig: {contractName, name: eventName}}}) =>
+      | Event(_) =>
+        let {handler, eventConfig: {contractName, name: eventName}} =
+          (item->Internal.castUnsafeEventItem).onEventRegistration
         switch handler {
         | None => ()
         | Some(handler) =>

package/src/EventProcessing.res.mjs

@@ -65,7 +65,8 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, indexerState,
     };
   }
   let handlerDuration = Performance.secondsSince(timeBeforeHandler);
-  return Prometheus.ProcessingHandler.increment(item.onEventRegistration.eventConfig.contractName, item.onEventRegistration.eventConfig.name, handlerDuration);
+  let eventConfig = item.onEventRegistration.eventConfig;
+  return Prometheus.ProcessingHandler.increment(eventConfig.contractName, eventConfig.name, handlerDuration);
 }
 
 async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager, persistence, config, chains) {