envio 3.3.0-alpha.8 → 3.3.0-alpha.9

package/src/LogSelection.res

@@ -1,5 +1,8 @@
 exception MissingRequiredTopic0
-let makeTopicSelection = (~topic0, ~topic1=[], ~topic2=[], ~topic3=[]) =>
+let makeTopicSelection = (~topic0, ~topic1=[], ~topic2=[], ~topic3=[]): result<
+  Internal.topicSelection,
+  exn,
+> =>
   if topic0->Utils.Array.isEmpty {
     Error(MissingRequiredTopic0)
   } else {
@@ -37,8 +40,8 @@ let compressTopicSelections = (topicSelections: array<Internal.topicSelection>)
   switch topic0sOfSelectionsWithoutFilters {
   | [] => selectionsWithFilters
   | topic0 =>
-    let selectionWithoutFilters = {
-      Internal.topic0,
+    let selectionWithoutFilters: Internal.topicSelection = {
+      topic0,
       topic1: [],
       topic2: [],
       topic3: [],
@@ -57,20 +60,33 @@ let make = (~addresses, ~topicSelections) => {
   {addresses, topicSelections}
 }
 
-type parsedEventFilters = {
-  getEventFiltersOrThrow: ChainMap.Chain.t => Internal.eventFilters,
+// Expand a resolved topic selection into concrete topic values for a query:
+// `ContractAddresses` markers become the given partition addresses encoded as
+// topics; `Values` pass through.
+let materializeTopicFilter = (filter: Internal.topicFilter, ~addresses: array<Address.t>) =>
+  switch filter {
+  | Values(values) => values
+  | ContractAddresses(_) => addresses->Array.map(TopicFilter.fromAddress)
+  }
+
+let materializeTopicSelections = (
+  topicSelections: array<Internal.resolvedTopicSelection>,
+  ~addresses: array<Address.t>,
+): array<Internal.topicSelection> =>
+  topicSelections->Array.map(({topic0, topic1, topic2, topic3}): Internal.topicSelection => {
+    topic0,
+    topic1: topic1->materializeTopicFilter(~addresses),
+    topic2: topic2->materializeTopicFilter(~addresses),
+    topic3: topic3->materializeTopicFilter(~addresses),
+  })
+
+type parsedWhere = {
+  resolvedWhere: Internal.resolvedWhere,
   filterByAddresses: bool,
   // Indexed params filtered by `chain.<Contract>.addresses`, in disjunctive
   // normal form (outer array OR of AND-groups). Empty unless `filterByAddresses`.
   // Consumed by the codegen of the event's `clientAddressFilter`.
   addressFilterParamGroups: array<array<string>>,
-  // `_gte` from the top-level `block` filter of the user's `where`,
-  // resolved at build time (per-chain via the `probeChainId`). The
-  // caller uses this to override the per-event `startBlock` — a
-  // `where`-derived startBlock always wins over contract-level
-  // config, so users can widen or narrow individual event ranges
-  // without touching `config.yaml`.
-  startBlock: option<int>,
 }
 
 // Inner schema for the event `block` filter chunk: `{_gte?}`.
@@ -123,24 +139,12 @@ let extractStartBlock = (
   }
 }
 
-// Build the runtime `chain` argument passed into a `where` callback.
-// Exposes `chain.id` and `chain.<ContractName>.addresses` as plain values
-// on a normal (Object.prototype) JS object. `Dict` is used so the
-// contract name can be a dynamic property key without defineProperty
-// ceremony.
-let makeChainArg = (~contractName: string, ~chainId: int, ~addresses: array<Address.t>) => {
-  let chainObj = Dict.make()
-  chainObj->Dict.set("id", chainId->Obj.magic)
-  chainObj->Dict.set(contractName, {"addresses": addresses}->Obj.magic)
-  chainObj
-}
-
-// Build the detection-time `chain` argument. `chain.<ContractName>.addresses`
-// is a getter so the runtime can tell whether the callback actually reads
-// it; the contract sub-object itself is built via `defineProperty` only
-// because its `addresses` field needs the getter — the enclosing chainObj
-// is a plain JS object.
-let makeDetectionChainArg = (
+// Build the `chain` argument passed into a `where` callback.
+// `chain.<ContractName>.addresses` is a getter so the runtime can tell
+// whether the callback actually reads it; the contract sub-object itself is
+// built via `defineProperty` only because its `addresses` field needs the
+// getter — the enclosing chainObj is a plain JS object.
+let makeChainArg = (
   ~contractName: string,
   ~chainId: int,
   ~getAddresses: unit => array<Address.t>,
@@ -155,7 +159,7 @@ let makeDetectionChainArg = (
   chainObj
 }
 
-// Sentinel returned by `chain.<Contract>.addresses` during detection. A Proxy
+// Sentinel returned by `chain.<Contract>.addresses`. A Proxy
 // whose traps throw on any access, so the only non-throwing use is passing it
 // straight through as a param filter value — which `extractAddressFilterGroups`
 // then finds by identity. Misuse (spread/map/index/...) fails loud at the site.
@@ -173,78 +177,46 @@ let makeAddressesProbe: (
   return new Proxy([], {get: trap});
 }`)
 
-// Find which indexed params the probed `where` result assigned the Proxy to
-// (DNF: object => one AND-group, array => OR of groups), neutralizing each match
-// to `[]` so later passes can't touch the throwing Proxy. Throws when the
-// callback read the addresses but didn't use them as a param filter value, since
-// the caller only invokes this once it knows the addresses were read.
-let extractAddressFilterGroupsOrThrow = (
-  result: JSON.t,
-  ~probe: array<Address.t>,
-  ~contractName: string,
-): array<array<string>> => {
-  let groups = []
-  let scanGroup = (paramsObj: dict<JSON.t>) => {
-    let names = []
-    paramsObj->Utils.Dict.forEachWithKey((value, key) => {
-      if value === probe->(Utils.magic: array<Address.t> => JSON.t) {
-        names->Array.push(key)->ignore
-        paramsObj->Dict.set(key, []->(Utils.magic: array<unknown> => JSON.t))
-      }
-    })
-    if names->Utils.Array.isEmpty->not {
-      groups->Array.push(names)->ignore
-    }
-  }
-  switch result {
-  | Object(obj) =>
-    switch obj->Dict.get("params") {
-    | Some(Object(p)) => scanGroup(p)
-    | Some(Array(arr)) =>
-      arr->Array.forEach(item =>
-        switch item {
-        | Object(p) => scanGroup(p)
-        | _ => ()
-        }
-      )
-    | _ => ()
-    }
-  | _ => ()
-  }
-  if groups->Utils.Array.isEmpty {
-    JsError.throwWithMessage(
-      `Invalid where configuration for ${contractName}. The callback reads \`chain.${contractName}.addresses\` but doesn't use it as an indexed-param filter value. Use it directly, e.g. { params: { to: chain.${contractName}.addresses } }.`,
-    )
-  }
-  groups
-}
-
-let parseEventFiltersOrThrow = {
+let parseWhereOrThrow = {
   let emptyTopics = []
   let noopGetter = _ => emptyTopics
 
   (
-    ~eventFilters: option<JSON.t>,
+    ~where: option<JSON.t>,
     ~sighash,
-    ~params,
+    ~params: array<string>,
     ~contractName: string,
-    ~probeChainId: int,
+    ~chainId: int,
     ~onEventBlockFilterSchema: S.t<option<unknown>>,
     ~topic1=noopGetter,
     ~topic2=noopGetter,
     ~topic3=noopGetter,
-  ): parsedEventFilters => {
-    let filterByAddresses = ref(false)
-    let addressFilterParamGroups = ref([])
-    let startBlock = ref(None)
+  ): parsedWhere => {
+    let addressFilterParamGroups = []
+    let readAddresses = ref(false)
+    let addressesSentinel = makeAddressesProbe(~contractName)
+    let sentinelJson = addressesSentinel->(Utils.magic: array<Address.t> => JSON.t)
     let topic0 = [sighash->EvmTypes.Hex.fromStringUnsafe]
     let default = {
       Internal.topic0,
-      topic1: emptyTopics,
-      topic2: emptyTopics,
-      topic3: emptyTopics,
+      topic1: Values(emptyTopics),
+      topic2: Values(emptyTopics),
+      topic3: Values(emptyTopics),
     }
 
+    // Topic positions map 1:1 onto the event's indexed params in declared
+    // order, so the sentinel check keys off `params[index]`. The sentinel must
+    // be detected before the topic getter runs — the getter would otherwise
+    // touch the throwing Proxy while encoding.
+    let topicFilterAt = (paramsFilter: dict<JSON.t>, ~index, ~getter) =>
+      switch params
+      ->Array.get(index)
+      ->Option.flatMap(name => paramsFilter->Utils.Dict.dangerouslyGetNonOption(name)) {
+      | Some(value) if value === sentinelJson =>
+        Internal.ContractAddresses({contractName: contractName})
+      | _ => Values(getter(paramsFilter))
+      }
+
     // Build a single topic selection from one indexed-param record (the
     // inside of `params`). Validates that the keys are actual indexed
     // parameters of the event — TS type checking doesn't catch this when
@@ -253,18 +225,25 @@ let parseEventFiltersOrThrow = {
       if paramsFilter->Utils.Dict.isEmpty {
         default
       } else {
-        paramsFilter->Utils.Dict.forEachWithKey((_, key) => {
+        let sentinelParamNames = []
+        paramsFilter->Utils.Dict.forEachWithKey((value, key) => {
           if params->Array.includes(key)->not {
             JsError.throwWithMessage(
               `Invalid where configuration. The event doesn't have an indexed parameter "${key}" and can't use it for filtering`,
             )
           }
+          if value === sentinelJson {
+            sentinelParamNames->Array.push(key)->ignore
+          }
         })
+        if sentinelParamNames->Utils.Array.isEmpty->not {
+          addressFilterParamGroups->Array.push(sentinelParamNames)->ignore
+        }
         {
           Internal.topic0,
-          topic1: topic1(paramsFilter),
-          topic2: topic2(paramsFilter),
-          topic3: topic3(paramsFilter),
+          topic1: paramsFilter->topicFilterAt(~index=0, ~getter=topic1),
+          topic2: paramsFilter->topicFilterAt(~index=1, ~getter=topic2),
+          topic3: paramsFilter->topicFilterAt(~index=2, ~getter=topic3),
         }
       }
     }
@@ -289,7 +268,7 @@ let parseEventFiltersOrThrow = {
     //
     // The runtime accepts both the function form (the only form ReScript
     // exposes) and a top-level static object form (TypeScript convenience).
-    let parse = (where: JSON.t): array<Internal.topicSelection> => {
+    let parse = (where: JSON.t): array<Internal.resolvedTopicSelection> => {
       if where === Obj.magic(true) {
         [default]
       } else if where === Obj.magic(false) {
@@ -335,84 +314,42 @@ let parseEventFiltersOrThrow = {
       }
     }
 
-    let getEventFiltersOrThrow = switch eventFilters {
-    | None => {
-        let static: Internal.eventFilters = Static([default])
-        _ => static
+    // The callback is invoked exactly once per chain, at registration time,
+    // with the chain's real configured id. `chain.<Contract>.addresses` yields
+    // the throwing-Proxy sentinel, which the param parser turns into a
+    // `ContractAddresses` marker; addresses are expanded from the marker only
+    // when a source query is built.
+    // A misused Proxy (or any throw from the callback) propagates as-is —
+    // the Proxy's guidance message surfaces without wrapping.
+    let (topicSelections, startBlock) = switch where {
+    | None => ([default], None)
+    | Some(where) =>
+      let whereValue = if typeof(where) === #function {
+        let fn = where->(Utils.magic: JSON.t => Internal.onEventWhereArgs<_> => JSON.t)
+        let chain = makeChainArg(~contractName, ~chainId, ~getAddresses=() => {
+          readAddresses := true
+          addressesSentinel
+        })
+        fn({chain: chain->Obj.magic})
+      } else {
+        where
       }
-    | Some(eventFilters) =>
-      if typeof(eventFilters) === #function {
-        let fn = eventFilters->(Utils.magic: JSON.t => Internal.onEventWhereArgs<_> => JSON.t)
-        // Determine whether the callback uses addresses by probing it with
-        // a detection chain arg whose `chain.<ContractName>.addresses` getter
-        // flips a flag. The probe uses this chain's real configured id, so
-        // handlers that branch on `chain.id` are exercised along the path
-        // they take for this chain. Event configs are built per-chain, so
-        // each chain gets a `filterByAddresses` verdict that matches its
-        // own callback behaviour.
-        //
-        // The probe result is also reused to extract the per-event
-        // `startBlock` (from `where.block`) for this chain — a second
-        // invocation would risk observing different state for callbacks
-        // that close over mutable references.
-        // A misused Proxy (or any throw from the callback) propagates as-is —
-        // the Proxy's guidance message surfaces without wrapping.
-        let addressesProbe = makeAddressesProbe(~contractName)
-        let chain = makeDetectionChainArg(
-          ~contractName,
-          ~chainId=probeChainId,
-          ~getAddresses=() => {
-            filterByAddresses := true
-            addressesProbe
-          },
+      let topicSelections = whereValue->parse
+      if readAddresses.contents && addressFilterParamGroups->Utils.Array.isEmpty {
+        JsError.throwWithMessage(
+          `Invalid where configuration for ${contractName}. The callback reads \`chain.${contractName}.addresses\` but doesn't use it as an indexed-param filter value. Use it directly, e.g. { params: { to: chain.${contractName}.addresses } }.`,
         )
-        let probedResult = fn({chain: chain->Obj.magic})
-        if filterByAddresses.contents {
-          addressFilterParamGroups :=
-            extractAddressFilterGroupsOrThrow(probedResult, ~probe=addressesProbe, ~contractName)
-        }
-        startBlock := extractStartBlock(~onEventBlockFilterSchema, ~contractName, probedResult)
-        if filterByAddresses.contents {
-          chain => Internal.Dynamic(
-            addresses => {
-              let chainArg = makeChainArg(
-                ~contractName,
-                ~chainId=chain->ChainMap.Chain.toChainId,
-                ~addresses,
-              )
-              fn({chain: chainArg->Obj.magic})->parse
-            },
-          )
-        } else {
-          // No probed chain referenced the contract — cache as Static
-          // per chain to avoid recomputing topic selections each batch.
-          // The addresses getter throws: if a code path the probe didn't
-          // exercise reads `chain.<Contract>.addresses` at runtime, silent
-          // [] would produce wrong topics — throw a user-friendly error
-          // instead so the user rewrites the callback to surface the
-          // dependency up-front.
-          chain => {
-            let chainId = chain->ChainMap.Chain.toChainId
-            let chainArg = makeDetectionChainArg(~contractName, ~chainId, ~getAddresses=() =>
-              JsError.throwWithMessage(
-                `Invalid where configuration. Event callback for contract "${contractName}" read \`chain.${contractName}.addresses\` at runtime but the probe didn't detect the access on chainId ${chainId->Int.toString}. Move the \`chain.${contractName}.addresses\` read above any \`chain.id\` branching so the probe picks up the dependency and switches to the dynamic fetch path.`,
-              )
-            )
-            Internal.Static(fn({chain: chainArg->Obj.magic})->parse)
-          }
-        }
-      } else {
-        startBlock := extractStartBlock(~onEventBlockFilterSchema, ~contractName, eventFilters)
-        let static: Internal.eventFilters = Static(eventFilters->parse)
-        _ => static
       }
+      (topicSelections, extractStartBlock(~onEventBlockFilterSchema, ~contractName, whereValue))
     }
 
     {
-      getEventFiltersOrThrow,
-      filterByAddresses: filterByAddresses.contents,
-      addressFilterParamGroups: addressFilterParamGroups.contents,
-      startBlock: startBlock.contents,
+      resolvedWhere: {
+        topicSelections,
+        startBlock,
+      },
+      filterByAddresses: addressFilterParamGroups->Utils.Array.isEmpty->not,
+      addressFilterParamGroups,
     }
   }
 }

package/src/LogSelection.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
+import * as TopicFilter from "./TopicFilter.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 Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
@@ -76,6 +77,23 @@ function make(addresses, topicSelections) {
   };
 }
 
+function materializeTopicFilter(filter, addresses) {
+  if (filter.TAG === "Values") {
+    return filter._0;
+  } else {
+    return addresses.map(TopicFilter.fromAddress);
+  }
+}
+
+function materializeTopicSelections(topicSelections, addresses) {
+  return topicSelections.map(param => ({
+    topic0: param.topic0,
+    topic1: materializeTopicFilter(param.topic1, addresses),
+    topic2: materializeTopicFilter(param.topic2, addresses),
+    topic3: materializeTopicFilter(param.topic3, addresses)
+  }));
+}
+
 let eventBlockRangeSchema = S$RescriptSchema.strict(S$RescriptSchema.object(s => ({
   _gte: s.f("_gte", S$RescriptSchema.option(S$RescriptSchema.int))
 })));
@@ -100,16 +118,7 @@ function extractStartBlock(where, onEventBlockFilterSchema, contractName) {
   }
 }
 
-function makeChainArg(contractName, chainId, addresses) {
-  let chainObj = {};
-  chainObj["id"] = chainId;
-  chainObj[contractName] = {
-    addresses: addresses
-  };
-  return chainObj;
-}
-
-function makeDetectionChainArg(contractName, chainId, getAddresses) {
+function makeChainArg(contractName, chainId, getAddresses) {
   let contractObj = Object.create(null);
   Object.defineProperty(contractObj, "addresses", {
     enumerable: true,
@@ -133,85 +142,78 @@ let makeAddressesProbe = (function (contractName) {
   return new Proxy([], {get: trap});
 });
 
-function extractAddressFilterGroupsOrThrow(result, probe, contractName) {
-  let groups = [];
-  let scanGroup = paramsObj => {
-    let names = [];
-    Utils.Dict.forEachWithKey(paramsObj, (value, key) => {
-      if (value === probe) {
-        names.push(key);
-        paramsObj[key] = [];
-        return;
-      }
-    });
-    if (!Utils.$$Array.isEmpty(names)) {
-      groups.push(names);
-      return;
-    }
-  };
-  if (typeof result === "object" && result !== null && !Array.isArray(result)) {
-    let match = result["params"];
-    if (match !== undefined) {
-      if (Array.isArray(match)) {
-        match.forEach(item => {
-          if (typeof item === "object" && item !== null && !Array.isArray(item)) {
-            return scanGroup(item);
-          }
-        });
-      } else {
-        switch (typeof match) {
-          case "object" :
-            scanGroup(match);
-            break;
-        }
-      }
-    }
-  }
-  if (Utils.$$Array.isEmpty(groups)) {
-    Stdlib_JsError.throwWithMessage(`Invalid where configuration for ` + contractName + `. The callback reads \`chain.` + contractName + `.addresses\` but doesn't use it as an indexed-param filter value. Use it directly, e.g. { params: { to: chain.` + contractName + `.addresses } }.`);
-  }
-  return groups;
-}
-
 let emptyTopics = [];
 
 function noopGetter(param) {
   return emptyTopics;
 }
 
-function parseEventFiltersOrThrow(eventFilters, sighash, params, contractName, probeChainId, onEventBlockFilterSchema, topic1Opt, topic2Opt, topic3Opt) {
+function parseWhereOrThrow(where, sighash, params, contractName, chainId, onEventBlockFilterSchema, topic1Opt, topic2Opt, topic3Opt) {
   let topic1 = topic1Opt !== undefined ? topic1Opt : noopGetter;
   let topic2 = topic2Opt !== undefined ? topic2Opt : noopGetter;
   let topic3 = topic3Opt !== undefined ? topic3Opt : noopGetter;
-  let filterByAddresses = {
+  let addressFilterParamGroups = [];
+  let readAddresses = {
     contents: false
   };
-  let addressFilterParamGroups = [];
-  let startBlock;
+  let addressesSentinel = makeAddressesProbe(contractName);
   let topic0 = [sighash];
+  let default_topic1 = {
+    TAG: "Values",
+    _0: emptyTopics
+  };
+  let default_topic2 = {
+    TAG: "Values",
+    _0: emptyTopics
+  };
+  let default_topic3 = {
+    TAG: "Values",
+    _0: emptyTopics
+  };
   let $$default = {
     topic0: topic0,
-    topic1: emptyTopics,
-    topic2: emptyTopics,
-    topic3: emptyTopics
+    topic1: default_topic1,
+    topic2: default_topic2,
+    topic3: default_topic3
   };
-  let paramsRecordToTopicSelection = paramsFilter => {
-    if (Utils.Dict.isEmpty(paramsFilter)) {
-      return $$default;
+  let topicFilterAt = (paramsFilter, index, getter) => {
+    let value = Stdlib_Option.flatMap(params[index], name => paramsFilter[name]);
+    if (value !== undefined && value === addressesSentinel) {
+      return {
+        TAG: "ContractAddresses",
+        contractName: contractName
+      };
     } else {
-      Utils.Dict.forEachWithKey(paramsFilter, (param, key) => {
-        if (!params.includes(key)) {
-          return Stdlib_JsError.throwWithMessage(`Invalid where configuration. The event doesn't have an indexed parameter "` + key + `" and can't use it for filtering`);
-        }
-      });
       return {
-        topic0: topic0,
-        topic1: topic1(paramsFilter),
-        topic2: topic2(paramsFilter),
-        topic3: topic3(paramsFilter)
+        TAG: "Values",
+        _0: getter(paramsFilter)
       };
     }
   };
+  let paramsRecordToTopicSelection = paramsFilter => {
+    if (Utils.Dict.isEmpty(paramsFilter)) {
+      return $$default;
+    }
+    let sentinelParamNames = [];
+    Utils.Dict.forEachWithKey(paramsFilter, (value, key) => {
+      if (!params.includes(key)) {
+        Stdlib_JsError.throwWithMessage(`Invalid where configuration. The event doesn't have an indexed parameter "` + key + `" and can't use it for filtering`);
+      }
+      if (value === addressesSentinel) {
+        sentinelParamNames.push(key);
+        return;
+      }
+    });
+    if (!Utils.$$Array.isEmpty(sentinelParamNames)) {
+      addressFilterParamGroups.push(sentinelParamNames);
+    }
+    return {
+      topic0: topic0,
+      topic1: topicFilterAt(paramsFilter, 0, topic1),
+      topic2: topicFilterAt(paramsFilter, 1, topic2),
+      topic3: topicFilterAt(paramsFilter, 2, topic3)
+    };
+  };
   let acceptedWhereKeys = [
     "params",
     "block"
@@ -258,58 +260,41 @@ function parseEventFiltersOrThrow(eventFilters, sighash, params, contractName, p
         return Stdlib_JsError.throwWithMessage("Invalid where configuration. Expected `params` to be an object or an array of objects");
     }
   };
-  let getEventFiltersOrThrow;
-  if (eventFilters !== undefined) {
-    if (typeof eventFilters === "function") {
-      let addressesProbe = makeAddressesProbe(contractName);
-      let chain = makeDetectionChainArg(contractName, probeChainId, () => {
-        filterByAddresses.contents = true;
-        return addressesProbe;
+  let match;
+  if (where !== undefined) {
+    let whereValue;
+    if (typeof where === "function") {
+      let chain = makeChainArg(contractName, chainId, () => {
+        readAddresses.contents = true;
+        return addressesSentinel;
       });
-      let probedResult = eventFilters({
+      whereValue = where({
         chain: chain
       });
-      if (filterByAddresses.contents) {
-        addressFilterParamGroups = extractAddressFilterGroupsOrThrow(probedResult, addressesProbe, contractName);
-      }
-      startBlock = extractStartBlock(probedResult, onEventBlockFilterSchema, contractName);
-      getEventFiltersOrThrow = filterByAddresses.contents ? chain => ({
-          TAG: "Dynamic",
-          _0: addresses => {
-            let chainArg = makeChainArg(contractName, chain, addresses);
-            return parse(eventFilters({
-              chain: chainArg
-            }));
-          }
-        }) : chain => {
-          let chainArg = makeDetectionChainArg(contractName, chain, () => Stdlib_JsError.throwWithMessage(`Invalid where configuration. Event callback for contract "` + contractName + `" read \`chain.` + contractName + `.addresses\` at runtime but the probe didn't detect the access on chainId ` + chain.toString() + `. Move the \`chain.` + contractName + `.addresses\` read above any \`chain.id\` branching so the probe picks up the dependency and switches to the dynamic fetch path.`));
-          return {
-            TAG: "Static",
-            _0: parse(eventFilters({
-              chain: chainArg
-            }))
-          };
-        };
     } else {
-      startBlock = extractStartBlock(eventFilters, onEventBlockFilterSchema, contractName);
-      let $$static = {
-        TAG: "Static",
-        _0: parse(eventFilters)
-      };
-      getEventFiltersOrThrow = param => $$static;
+      whereValue = where;
+    }
+    let topicSelections = parse(whereValue);
+    if (readAddresses.contents && Utils.$$Array.isEmpty(addressFilterParamGroups)) {
+      Stdlib_JsError.throwWithMessage(`Invalid where configuration for ` + contractName + `. The callback reads \`chain.` + contractName + `.addresses\` but doesn't use it as an indexed-param filter value. Use it directly, e.g. { params: { to: chain.` + contractName + `.addresses } }.`);
     }
+    match = [
+      topicSelections,
+      extractStartBlock(whereValue, onEventBlockFilterSchema, contractName)
+    ];
   } else {
-    let $$static$1 = {
-      TAG: "Static",
-      _0: [$$default]
-    };
-    getEventFiltersOrThrow = param => $$static$1;
+    match = [
+      [$$default],
+      undefined
+    ];
   }
   return {
-    getEventFiltersOrThrow: getEventFiltersOrThrow,
-    filterByAddresses: filterByAddresses.contents,
-    addressFilterParamGroups: addressFilterParamGroups,
-    startBlock: startBlock
+    resolvedWhere: {
+      topicSelections: match[0],
+      startBlock: match[1]
+    },
+    filterByAddresses: !Utils.$$Array.isEmpty(addressFilterParamGroups),
+    addressFilterParamGroups: addressFilterParamGroups
   };
 }
 
@@ -319,12 +304,12 @@ export {
   hasFilters,
   compressTopicSelections,
   make,
+  materializeTopicFilter,
+  materializeTopicSelections,
   eventBlockRangeSchema,
   extractStartBlock,
   makeChainArg,
-  makeDetectionChainArg,
   makeAddressesProbe,
-  extractAddressFilterGroupsOrThrow,
-  parseEventFiltersOrThrow,
+  parseWhereOrThrow,
 }
 /* eventBlockRangeSchema Not a pure module */