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

package/src/Internal.res

@@ -244,17 +244,16 @@ type evmTransactionInput = {
   type_?: int,
   root?: string,
   status?: int,
-  accessList?: Js.Json.t,
+  accessList?: JSON.t,
   // L2 specific fields (Optimism, Arbitrum, etc.)
   l1Fee?: bigint,
   l1GasPrice?: bigint,
   l1GasUsed?: bigint,
   l1FeeScalar?: float,
   gasUsedForL1?: bigint,
-  authorizationList?: Js.Json.t,
+  authorizationList?: JSON.t,
 }
 
-@genType
 type genericEvent<'params, 'block, 'transaction> = {
   contractName: string,
   eventName: string,
@@ -270,35 +269,28 @@ type event = genericEvent<eventParams, eventBlock, eventTransaction>
 
 external fromGenericEvent: genericEvent<'a, 'b, 'c> => event = "%identity"
 
-@genType
 type genericLoaderArgs<'event, 'context> = {
   event: 'event,
   context: 'context,
 }
-@genType
 type genericLoader<'args, 'loaderReturn> = 'args => promise<'loaderReturn>
 
-@genType
 type genericContractRegisterArgs<'event, 'context> = {
   event: 'event,
   context: 'context,
 }
-@genType.import(("./Types.ts", "GenericContractRegister"))
 type genericContractRegister<'args> = 'args => promise<unit>
 
 type contractRegisterContext
 type contractRegisterArgs = genericContractRegisterArgs<event, contractRegisterContext>
 type contractRegister = genericContractRegister<contractRegisterArgs>
 
-@genType
 type genericHandlerArgs<'event, 'context> = {
   event: 'event,
   context: 'context,
 }
-@genType
 type genericHandler<'args> = 'args => promise<unit>
 
-@genType
 type entityHandlerContext<'entity> = {
   get: string => promise<option<'entity>>,
   getOrThrow: (string, ~message: string=?) => promise<'entity>,
@@ -327,12 +319,28 @@ type handlerArgs = {
 }
 type handler = genericHandler<handlerArgs>
 
-@genType
-type genericHandlerWithLoader<'loader, 'handler, 'eventFilters> = {
+type genericHandlerWithLoader<'loader, 'handler, 'where> = {
   loader: 'loader,
   handler: 'handler,
   wildcard?: bool,
-  eventFilters?: 'eventFilters,
+  where?: 'where,
+}
+
+// Recursive tuple/struct component metadata emitted by the CLI when an event
+// param (or any nested field) is a Solidity struct. `name` is always non-empty —
+// the CLI fills in `"0"`, `"1"`, ... for anonymous components in mixed-name
+// tuples — so the runtime can always rebuild a keyed object.
+type rec eventParamComponent = {
+  name: string,
+  abiType: string,
+  components?: array<eventParamComponent>,
+}
+
+type eventParam = {
+  name: string,
+  abiType: string,
+  indexed: bool,
+  components?: array<eventParamComponent>,
 }
 
 // This is private so it's not manually constructed internally
@@ -353,6 +361,7 @@ type eventConfig = private {
   contractRegister: option<contractRegister>,
   paramsRawEventSchema: S.schema<eventParams>,
   simulateParamsSchema: S.schema<eventParams>,
+  startBlock: option<int>,
 }
 
 type fuelEventKind =
@@ -361,7 +370,6 @@ type fuelEventKind =
   | Burn
   | Transfer
   | Call
-@genType.opaque
 type fuelEventConfig = {
   ...eventConfig,
   kind: fuelEventKind,
@@ -378,36 +386,51 @@ type topicSelection = {
   topic3: array<EvmTypes.Hex.t>,
 }
 
-type eventFiltersArgs = {chainId: int, addresses: array<Address.t>}
+// Per-event, per-invocation arguments passed to a `where` callback. The
+// concrete `chain` shape (which contract key it exposes) is generated per
+// event in user-project codegen — here it's an open record so codegen'd
+// types subtype-coerce into it cleanly.
+type onEventWhereArgs<'chain> = {chain: 'chain}
 
 type eventFilters =
   Static(array<topicSelection>) | Dynamic(array<Address.t> => array<topicSelection>)
 
-@genType.opaque
 type evmEventConfig = {
   ...eventConfig,
   getEventFiltersOrThrow: ChainMap.Chain.t => eventFilters,
   convertHyperSyncEventArgs: HyperSyncClient.Decoder.decodedEvent => eventParams,
   selectedBlockFields: Utils.Set.t<evmBlockField>,
   selectedTransactionFields: Utils.Set.t<evmTransactionField>,
+  // Retained so `HandlerLoader.applyRegistrations` can re-run
+  // `LogSelection.parseEventFiltersOrThrow` after handler modules register
+  // with a `where:` filter. Only indexed params are kept — they're all the
+  // filter parser needs for topic-getter construction + key validation.
+  sighash: string,
+  indexedParams: array<eventParam>,
 }
+
+// Shared formula for `eventConfig.dependsOnAddresses`. Kept here so
+// `EventConfigBuilder.build{Evm,Fuel}EventConfig` and
+// `HandlerLoader.applyRegistrations` stay in sync when handler state flips
+// the value. Fuel events always have `filterByAddresses=false`, so callers
+// there simply pass it through as `false`.
+let dependsOnAddresses = (~isWildcard, ~filterByAddresses) => !isWildcard || filterByAddresses
+
 type evmContractConfig = {
   name: string,
   abi: EvmTypes.Abi.t,
   events: array<evmEventConfig>,
 }
 
-type indexingContract = {
+type indexingAddress = {
   address: Address.t,
   contractName: string,
-  startBlock: int,
-  // Needed for rollback
-  // If not set, assume the contract comes from config
-  // and shouldn't be rolled back
-  registrationBlock: option<int>,
+  // Needed for rollback.
+  // -1 for config addresses that shouldn't be rolled back.
+  registrationBlock: int,
 }
 
-type dcs = array<indexingContract>
+type dcs = array<indexingAddress>
 
 // Duplicate the type from item
 // to make item properly unboxed
@@ -473,22 +496,19 @@ external getItemDcs: item => option<dcs> = "dcs"
 @set
 external setItemDcs: (item, dcs) => unit = "dcs"
 
-@genType
-type eventOptions<'eventFilters> = {
+type eventOptions<'where> = {
   wildcard?: bool,
-  eventFilters?: 'eventFilters,
+  where?: 'where,
 }
 
-@genType
 type fuelSupplyParams = {
   subId: string,
   amount: bigint,
 }
 let fuelSupplyParamsSchema = S.schema(s => {
   subId: s.matches(S.string),
-  amount: s.matches(BigInt.schema),
+  amount: s.matches(Utils.BigInt.schema),
 })
-@genType
 type fuelTransferParams = {
   to: Address.t,
   assetId: string,
@@ -497,7 +517,7 @@ type fuelTransferParams = {
 let fuelTransferParamsSchema = S.schema(s => {
   to: s.matches(Address.schema),
   assetId: s.matches(S.string),
-  amount: s.matches(BigInt.schema),
+  amount: s.matches(Utils.BigInt.schema),
 })
 
 type multichain = | @as("ordered") Ordered | @as("unordered") Unordered
@@ -548,7 +568,7 @@ type effect = {
   rateLimit: option<rateLimitState>,
 }
 let cacheTablePrefix = "envio_effect_"
-let cacheOutputSchema = S.json(~validate=false)->(Utils.magic: S.t<Js.Json.t> => S.t<effectOutput>)
+let cacheOutputSchema = S.json(~validate=false)->(Utils.magic: S.t<JSON.t> => S.t<effectOutput>)
 let effectCacheItemRowsSchema = S.array(
   S.schema(s => {id: s.matches(S.string), output: s.matches(cacheOutputSchema)}),
 )
@@ -562,8 +582,7 @@ let makeCacheTable = (~effectName) => {
   )
 }
 
-@genType.import(("./Types.ts", "Invalid"))
-type noEventFilters
+type noOnEventWhere
 
 type checkpointId = bigint
 

package/src/Internal.res.mjs

@@ -1,11 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Table from "./db/Table.res.mjs";
-import * as $$BigInt from "./bindings/BigInt.res.mjs";
+import * as Utils from "./Utils.res.mjs";
 import * as Address from "./Address.res.mjs";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
-var allEvmBlockFields = [
+let allEvmBlockFields = [
   "number",
   "timestamp",
   "hash",
@@ -35,9 +35,9 @@ var allEvmBlockFields = [
   "mixHash"
 ];
 
-var evmBlockFieldSchema = S$RescriptSchema.$$enum(allEvmBlockFields);
+let evmBlockFieldSchema = S$RescriptSchema.$$enum(allEvmBlockFields);
 
-var allEvmTransactionFields = [
+let allEvmTransactionFields = [
   "transactionIndex",
   "hash",
   "from",
@@ -72,46 +72,54 @@ var allEvmTransactionFields = [
   "authorizationList"
 ];
 
-var evmTransactionFieldSchema = S$RescriptSchema.$$enum(allEvmTransactionFields);
-
-var evmNullableBlockFields = new Set([
-      "nonce",
-      "difficulty",
-      "totalDifficulty",
-      "uncles",
-      "baseFeePerGas",
-      "blobGasUsed",
-      "excessBlobGas",
-      "parentBeaconBlockRoot",
-      "withdrawalsRoot",
-      "l1BlockNumber",
-      "sendCount",
-      "sendRoot",
-      "mixHash"
-    ]);
-
-var evmNullableTransactionFields = new Set([
-      "gasPrice",
-      "v",
-      "r",
-      "s",
-      "yParity",
-      "maxPriorityFeePerGas",
-      "maxFeePerGas",
-      "maxFeePerBlobGas",
-      "blobVersionedHashes",
-      "contractAddress",
-      "root",
-      "status",
-      "l1Fee",
-      "l1GasPrice",
-      "l1GasUsed",
-      "l1FeeScalar",
-      "gasUsedForL1",
-      "from",
-      "to",
-      "type"
-    ]);
+let evmTransactionFieldSchema = S$RescriptSchema.$$enum(allEvmTransactionFields);
+
+let evmNullableBlockFields = new Set([
+  "nonce",
+  "difficulty",
+  "totalDifficulty",
+  "uncles",
+  "baseFeePerGas",
+  "blobGasUsed",
+  "excessBlobGas",
+  "parentBeaconBlockRoot",
+  "withdrawalsRoot",
+  "l1BlockNumber",
+  "sendCount",
+  "sendRoot",
+  "mixHash"
+]);
+
+let evmNullableTransactionFields = new Set([
+  "gasPrice",
+  "v",
+  "r",
+  "s",
+  "yParity",
+  "maxPriorityFeePerGas",
+  "maxFeePerGas",
+  "maxFeePerBlobGas",
+  "blobVersionedHashes",
+  "contractAddress",
+  "root",
+  "status",
+  "l1Fee",
+  "l1GasPrice",
+  "l1GasUsed",
+  "l1FeeScalar",
+  "gasUsedForL1",
+  "from",
+  "to",
+  "type"
+]);
+
+function dependsOnAddresses(isWildcard, filterByAddresses) {
+  if (isWildcard) {
+    return filterByAddresses;
+  } else {
+    return true;
+  }
+}
 
 function getItemChainId(item) {
   if (item.kind === 0) {
@@ -121,52 +129,47 @@ function getItemChainId(item) {
   }
 }
 
-var fuelSupplyParamsSchema = S$RescriptSchema.schema(function (s) {
-      return {
-              subId: s.m(S$RescriptSchema.string),
-              amount: s.m($$BigInt.schema)
-            };
-    });
+let fuelSupplyParamsSchema = S$RescriptSchema.schema(s => ({
+  subId: s.m(S$RescriptSchema.string),
+  amount: s.m(Utils.$$BigInt.schema)
+}));
 
-var fuelTransferParamsSchema = S$RescriptSchema.schema(function (s) {
-      return {
-              to: s.m(Address.schema),
-              assetId: s.m(S$RescriptSchema.string),
-              amount: s.m($$BigInt.schema)
-            };
-    });
+let fuelTransferParamsSchema = S$RescriptSchema.schema(s => ({
+  to: s.m(Address.schema),
+  assetId: s.m(S$RescriptSchema.string),
+  amount: s.m(Utils.$$BigInt.schema)
+}));
 
-var cacheTablePrefix = "envio_effect_";
+let cacheTablePrefix = "envio_effect_";
 
-var cacheOutputSchema = S$RescriptSchema.json(false);
+let cacheOutputSchema = S$RescriptSchema.json(false);
 
-var effectCacheItemRowsSchema = S$RescriptSchema.array(S$RescriptSchema.schema(function (s) {
-          return {
-                  id: s.m(S$RescriptSchema.string),
-                  output: s.m(cacheOutputSchema)
-                };
-        }));
+let effectCacheItemRowsSchema = S$RescriptSchema.array(S$RescriptSchema.schema(s => ({
+  id: s.m(S$RescriptSchema.string),
+  output: s.m(cacheOutputSchema)
+})));
 
 function makeCacheTable(effectName) {
   return Table.mkTable(cacheTablePrefix + effectName, undefined, [
-              Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
-              Table.mkField("output", "Json", cacheOutputSchema, undefined, undefined, true, undefined, undefined, undefined)
-            ]);
+    Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
+    Table.mkField("output", "Json", cacheOutputSchema, undefined, undefined, true, undefined, undefined, undefined)
+  ]);
 }
 
 export {
-  allEvmBlockFields ,
-  evmBlockFieldSchema ,
-  allEvmTransactionFields ,
-  evmTransactionFieldSchema ,
-  evmNullableBlockFields ,
-  evmNullableTransactionFields ,
-  getItemChainId ,
-  fuelSupplyParamsSchema ,
-  fuelTransferParamsSchema ,
-  cacheTablePrefix ,
-  cacheOutputSchema ,
-  effectCacheItemRowsSchema ,
-  makeCacheTable ,
+  allEvmBlockFields,
+  evmBlockFieldSchema,
+  allEvmTransactionFields,
+  evmTransactionFieldSchema,
+  evmNullableBlockFields,
+  evmNullableTransactionFields,
+  dependsOnAddresses,
+  getItemChainId,
+  fuelSupplyParamsSchema,
+  fuelTransferParamsSchema,
+  cacheTablePrefix,
+  cacheOutputSchema,
+  effectCacheItemRowsSchema,
+  makeCacheTable,
 }
 /* evmBlockFieldSchema Not a pure module */

package/src/LazyLoader.res.mjs

@@ -2,31 +2,30 @@
 
 import * as Utils from "./Utils.res.mjs";
 import * as JsSdsl from "js-sdsl";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
-import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-var LoaderTimeout = /* @__PURE__ */Caml_exceptions.create("LazyLoader.LoaderTimeout");
+let LoaderTimeout = /* @__PURE__ */Primitive_exceptions.create("LazyLoader.LoaderTimeout");
 
 function make(loaderFn, onError, cacheSizeOpt, loaderPoolSizeOpt, retryDelayMillisOpt, timeoutMillisOpt) {
-  var cacheSize = cacheSizeOpt !== undefined ? cacheSizeOpt : 10000;
-  var loaderPoolSize = loaderPoolSizeOpt !== undefined ? loaderPoolSizeOpt : 10;
-  var retryDelayMillis = retryDelayMillisOpt !== undefined ? retryDelayMillisOpt : 5000;
-  var timeoutMillis = timeoutMillisOpt !== undefined ? timeoutMillisOpt : 300000;
+  let cacheSize = cacheSizeOpt !== undefined ? cacheSizeOpt : 10000;
+  let loaderPoolSize = loaderPoolSizeOpt !== undefined ? loaderPoolSizeOpt : 10;
+  let retryDelayMillis = retryDelayMillisOpt !== undefined ? retryDelayMillisOpt : 5000;
+  let timeoutMillis = timeoutMillisOpt !== undefined ? timeoutMillisOpt : 300000;
   return {
-          _cacheSize: cacheSize,
-          _loaderPoolSize: loaderPoolSize,
-          _retryDelayMillis: retryDelayMillis,
-          _timeoutMillis: timeoutMillis,
-          externalPromises: new Map(),
-          resolvers: new Map(),
-          inProgress: new Set(),
-          loaderQueue: new JsSdsl.Queue(),
-          loadedKeys: new JsSdsl.Queue(),
-          loaderFn: loaderFn,
-          onError: onError
-        };
+    _cacheSize: cacheSize,
+    _loaderPoolSize: loaderPoolSize,
+    _retryDelayMillis: retryDelayMillis,
+    _timeoutMillis: timeoutMillis,
+    externalPromises: new Map(),
+    resolvers: new Map(),
+    inProgress: new Set(),
+    loaderQueue: new JsSdsl.Queue(),
+    loadedKeys: new JsSdsl.Queue(),
+    loaderFn: loaderFn,
+    onError: onError
+  };
 }
 
 function deleteKey(_obj, _k) {
@@ -34,50 +33,45 @@ function deleteKey(_obj, _k) {
 }
 
 function timeoutAfter(timeoutMillis) {
-  return Utils.delay(timeoutMillis).then(function () {
-              return Promise.reject({
-                          RE_EXN_ID: LoaderTimeout,
-                          _1: "Query took longer than " + String(timeoutMillis / 1000 | 0) + " seconds"
-                        });
-            });
+  return Utils.delay(timeoutMillis).then(() => Promise.reject({
+    RE_EXN_ID: LoaderTimeout,
+    _1: `Query took longer than ` + String(timeoutMillis / 1000 | 0) + ` seconds`
+  }));
 }
 
 async function loadNext(am, k) {
   am.inProgress.add(k);
-  var awaitTaskPromiseAndLoadNextWithTimeout = async function () {
-    var val = await Promise.race([
-          am.loaderFn(k),
-          timeoutAfter(am._timeoutMillis)
-        ]);
-    Belt_Option.forEach(am.resolvers.get(k), (function (r) {
-            am.resolvers.delete(k);
-            r(val);
-          }));
+  let awaitTaskPromiseAndLoadNextWithTimeout = async () => {
+    let val = await Promise.race([
+      am.loaderFn(k),
+      timeoutAfter(am._timeoutMillis)
+    ]);
+    Belt_Option.forEach(am.resolvers.get(k), r => {
+      am.resolvers.delete(k);
+      r(val);
+    });
     am.inProgress.delete(k);
-    var loadedKeysNumber = am.loadedKeys.push(k);
+    let loadedKeysNumber = am.loadedKeys.push(k);
     if (loadedKeysNumber > am._cacheSize) {
-      var old = am.loadedKeys.pop();
+      let old = am.loadedKeys.pop();
       if (old !== undefined) {
-        am.externalPromises.delete(Caml_option.valFromOption(old));
+        am.externalPromises.delete(Primitive_option.valFromOption(old));
       }
-      
     }
-    var next = am.loaderQueue.pop();
+    let next = am.loaderQueue.pop();
     if (next !== undefined) {
-      return await loadNext(am, Caml_option.valFromOption(next));
+      return await loadNext(am, Primitive_option.valFromOption(next));
     }
-    
   };
-  var tmp;
-  var exit = 0;
-  var val;
+  let tmp;
+  let exit = 0;
+  let val;
   try {
     val = await awaitTaskPromiseAndLoadNextWithTimeout();
     exit = 1;
-  }
-  catch (raw_err){
-    var err = Caml_js_exceptions.internalToOCamlException(raw_err);
-    var onError = am.onError;
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    let onError = am.onError;
     if (onError !== undefined) {
       onError(am, err);
     }
@@ -91,13 +85,13 @@ async function loadNext(am, k) {
 }
 
 function get(am, k) {
-  var x = am.externalPromises.get(k);
+  let x = am.externalPromises.get(k);
   if (x !== undefined) {
-    return Caml_option.valFromOption(x);
+    return x;
   }
-  var promise = new Promise((function (resolve, param) {
-          am.resolvers.set(k, resolve);
-        }));
+  let promise = new Promise((resolve, param) => {
+    am.resolvers.set(k, resolve);
+  });
   am.externalPromises.set(k, promise);
   if (am.inProgress.size < am._loaderPoolSize) {
     loadNext(am, k);
@@ -108,11 +102,11 @@ function get(am, k) {
 }
 
 export {
-  LoaderTimeout ,
-  make ,
-  deleteKey ,
-  timeoutAfter ,
-  loadNext ,
-  get ,
+  LoaderTimeout,
+  make,
+  deleteKey,
+  timeoutAfter,
+  loadNext,
+  get,
 }
 /* Utils Not a pure module */