envio 3.3.0-alpha.9 → 3.3.0

package/src/Envio.res.mjs

@@ -2,8 +2,8 @@
 
 import * as Address from "./Address.res.mjs";
 import * as Process from "process";
-import * as Internal from "./Internal.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 S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
 function durationToMs(duration) {
@@ -18,41 +18,36 @@ function durationToMs(duration) {
   }
 }
 
+let effectNameRe = /^[A-Za-z0-9_-][A-Za-z0-9_.-]*$/;
+
 function createEffect(options, handler) {
+  if (!effectNameRe.test(options.name)) {
+    Stdlib_JsError.throwWithMessage(`Invalid effect name "` + options.name + `". Effect names may contain letters, numbers, underscores, hyphens and dots (but must not start with a dot or contain a path separator), because the name is used as the cache table name and cache file path.`);
+  }
   let outputSchema = S$RescriptSchema.schema(param => options.output);
   let itemSchema = S$RescriptSchema.schema(s => ({
     id: s.m(S$RescriptSchema.string),
     output: s.m(outputSchema)
   }));
   let match = options.cache;
-  let match$1 = options.rateLimit;
+  let match$1 = options.crossChain;
+  let match$2 = options.rateLimit;
   let tmp;
-  if (match$1 === false) {
-    tmp = undefined;
-  } else {
-    let calls = match$1.calls;
-    tmp = {
-      callsPerDuration: calls,
-      durationMs: durationToMs(match$1.per),
-      availableCalls: calls,
-      windowStartTime: Date.now(),
-      queueCount: 0,
-      nextWindowPromise: undefined
-    };
-  }
+  tmp = match$2 === false ? undefined : ({
+      callsPerDuration: match$2.calls,
+      durationMs: durationToMs(match$2.per)
+    });
   return {
     name: options.name,
     handler: handler,
     storageMeta: {
       itemSchema: itemSchema,
-      outputSchema: outputSchema,
-      table: Internal.makeCacheTable(options.name)
+      outputSchema: outputSchema
     },
     defaultShouldCache: match !== undefined ? match : false,
+    crossChain: match$1 !== undefined ? match$1 : true,
     output: outputSchema,
     input: S$RescriptSchema.schema(param => options.input),
-    activeCallsCount: 0,
-    prevCallStartTimerRef: null,
     rateLimit: tmp
   };
 }
@@ -102,6 +97,7 @@ let TestHelpers = {
 
 export {
   durationToMs,
+  effectNameRe,
   createEffect,
   isNonInteractive,
   TestHelpers,

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) {