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

package/src/EventConfigBuilder.res

@@ -1,20 +1,27 @@
-open Belt
-
-type eventParam = {
-  name: string,
-  abiType: string,
-  indexed: bool,
-}
-
-let eventParamSchema = S.object(s => {
+// Types moved to `Internal` so `Internal.evmEventConfig` can retain
+// `indexedParams: array<eventParam>` for post-registration filter rebuild.
+// Re-exported here as aliases for existing call sites.
+type eventParamComponent = Internal.eventParamComponent
+type eventParam = Internal.eventParam
+
+let eventParamComponentSchema = S.recursive(self =>
+  S.object((s): eventParamComponent => {
+    name: s.field("name", S.string),
+    abiType: s.field("abiType", S.string),
+    components: ?s.field("components", S.option(S.array(self))),
+  })
+)
+
+let eventParamSchema = S.object((s): eventParam => {
   name: s.field("name", S.string),
   abiType: s.field("abiType", S.string),
   indexed: s.fieldOr("indexed", S.bool, false),
+  components: ?s.field("components", S.option(S.array(eventParamComponentSchema))),
 })
 
 // Normalize a value that could be a single item or an array into an array
 let normalizeOrThrow: 'a => array<'a> = value => {
-  if Js.Array2.isArray(value->Obj.magic) {
+  if Array.isArray(value->Obj.magic) {
     value->Obj.magic
   } else {
     [value]
@@ -29,22 +36,22 @@ let splitTupleComponents = (inner: string): array<string> => {
   let components = []
   let depth = ref(0)
   let start = ref(0)
-  for i in 0 to inner->Js.String2.length - 1 {
-    let ch = inner->Js.String2.charAt(i)
+  for i in 0 to inner->String.length - 1 {
+    let ch = inner->String.charAt(i)
     if ch == "(" {
       depth := depth.contents + 1
     } else if ch == ")" {
       depth := depth.contents - 1
     } else if ch == "," && depth.contents == 0 {
-      components->Js.Array2.push(inner->Js.String2.slice(~from=start.contents, ~to_=i))->ignore
+      components->Array.push(inner->String.slice(~start=start.contents, ~end=i))->ignore
       start := i + 1
     }
   }
 
   // Last component
-  if start.contents < inner->Js.String2.length {
+  if start.contents < inner->String.length {
     components
-    ->Js.Array2.push(inner->Js.String2.sliceToEnd(~from=start.contents))
+    ->Array.push(inner->String.slice(~start=start.contents))
     ->ignore
   }
   components
@@ -54,53 +61,53 @@ let splitTupleComponents = (inner: string): array<string> => {
 
 let rec abiTypeToSchema = (abiType: string): S.t<unknown> => {
   // Handle array types: "type[]" or "type[N]"
-  if abiType->Js.String2.endsWith("]") {
-    let bracketIdx = abiType->Js.String2.lastIndexOf("[")
-    let baseType = abiType->Js.String2.slice(~from=0, ~to_=bracketIdx)
+  if abiType->String.endsWith("]") {
+    let bracketIdx = abiType->String.lastIndexOf("[")
+    let baseType = abiType->String.slice(~start=0, ~end=bracketIdx)
     S.array(abiTypeToSchema(baseType))->S.toUnknown
-  } else if abiType->Js.String2.startsWith("(") && abiType->Js.String2.endsWith(")") {
+  } else if abiType->String.startsWith("(") && abiType->String.endsWith(")") {
     // Tuple type: "(type1,type2,...)"
-    let inner = abiType->Js.String2.slice(~from=1, ~to_=abiType->Js.String2.length - 1)
+    let inner = abiType->String.slice(~start=1, ~end=abiType->String.length - 1)
     let components = splitTupleComponents(inner)
-    let schemas = components->Array.map(c => abiTypeToSchema(c->Js.String2.trim))
+    let schemas = components->Array.map(c => abiTypeToSchema(c->String.trim))
     S.tuple(s => {
-      schemas->Array.mapWithIndex((i, schema) => s.item(i, schema))
+      schemas->Array.mapWithIndex((schema, i) => s.item(i, schema))
     })->S.toUnknown
   } else {
     switch abiType {
     | "address" => Address.schema->S.toUnknown
     | "bool" => S.bool->S.toUnknown
     | "string" | "bytes" => S.string->S.toUnknown
-    | t if t->Js.String2.startsWith("uint") => BigInt.schema->S.toUnknown
-    | t if t->Js.String2.startsWith("int") => BigInt.schema->S.toUnknown
-    | t if t->Js.String2.startsWith("bytes") => S.string->S.toUnknown
-    | other => Js.Exn.raiseError(`Unsupported ABI type: ${other}`)
+    | t if t->String.startsWith("uint") => Utils.BigInt.schema->S.toUnknown
+    | t if t->String.startsWith("int") => Utils.BigInt.schema->S.toUnknown
+    | t if t->String.startsWith("bytes") => S.string->S.toUnknown
+    | other => JsError.throwWithMessage(`Unsupported ABI type: ${other}`)
     }
   }
 }
 
 // ABI type → schema for simulate items (accepts native JS values, not string-encoded)
 let rec abiTypeToSimulateSchema = (abiType: string): S.t<unknown> => {
-  if abiType->Js.String2.endsWith("]") {
-    let bracketIdx = abiType->Js.String2.lastIndexOf("[")
-    let baseType = abiType->Js.String2.slice(~from=0, ~to_=bracketIdx)
+  if abiType->String.endsWith("]") {
+    let bracketIdx = abiType->String.lastIndexOf("[")
+    let baseType = abiType->String.slice(~start=0, ~end=bracketIdx)
     S.array(abiTypeToSimulateSchema(baseType))->S.toUnknown
-  } else if abiType->Js.String2.startsWith("(") && abiType->Js.String2.endsWith(")") {
-    let inner = abiType->Js.String2.slice(~from=1, ~to_=abiType->Js.String2.length - 1)
+  } else if abiType->String.startsWith("(") && abiType->String.endsWith(")") {
+    let inner = abiType->String.slice(~start=1, ~end=abiType->String.length - 1)
     let components = splitTupleComponents(inner)
-    let schemas = components->Array.map(c => abiTypeToSimulateSchema(c->Js.String2.trim))
+    let schemas = components->Array.map(c => abiTypeToSimulateSchema(c->String.trim))
     S.tuple(s => {
-      schemas->Array.mapWithIndex((i, schema) => s.item(i, schema))
+      schemas->Array.mapWithIndex((schema, i) => s.item(i, schema))
     })->S.toUnknown
   } else {
     switch abiType {
     | "address" => S.string->S.toUnknown
     | "bool" => S.bool->S.toUnknown
     | "string" | "bytes" => S.string->S.toUnknown
-    | t if t->Js.String2.startsWith("uint") => S.bigint->S.toUnknown
-    | t if t->Js.String2.startsWith("int") => S.bigint->S.toUnknown
-    | t if t->Js.String2.startsWith("bytes") => S.string->S.toUnknown
-    | other => Js.Exn.raiseError(`Unsupported ABI type: ${other}`)
+    | t if t->String.startsWith("uint") => S.bigint->S.toUnknown
+    | t if t->String.startsWith("int") => S.bigint->S.toUnknown
+    | t if t->String.startsWith("bytes") => S.string->S.toUnknown
+    | other => JsError.throwWithMessage(`Unsupported ABI type: ${other}`)
     }
   }
 }
@@ -108,13 +115,13 @@ let rec abiTypeToSimulateSchema = (abiType: string): S.t<unknown> => {
 // ============== ABI type → default value for simulate ==============
 
 let rec abiTypeToDefaultValue = (abiType: string): unknown => {
-  if abiType->Js.String2.endsWith("]") {
+  if abiType->String.endsWith("]") {
     []->(Utils.magic: array<unknown> => unknown)
-  } else if abiType->Js.String2.startsWith("(") && abiType->Js.String2.endsWith(")") {
-    let inner = abiType->Js.String2.slice(~from=1, ~to_=abiType->Js.String2.length - 1)
+  } else if abiType->String.startsWith("(") && abiType->String.endsWith(")") {
+    let inner = abiType->String.slice(~start=1, ~end=abiType->String.length - 1)
     let components = splitTupleComponents(inner)
     components
-    ->Array.map(c => abiTypeToDefaultValue(c->Js.String2.trim))
+    ->Array.map(c => abiTypeToDefaultValue(c->String.trim))
     ->(Utils.magic: array<unknown> => unknown)
   } else {
     switch abiType {
@@ -125,14 +132,96 @@ let rec abiTypeToDefaultValue = (abiType: string): unknown => {
 
     | "bool" => false->(Utils.magic: bool => unknown)
     | "string" | "bytes" => ""->(Utils.magic: string => unknown)
-    | t if t->Js.String2.startsWith("uint") => 0n->(Utils.magic: bigint => unknown)
-    | t if t->Js.String2.startsWith("int") => 0n->(Utils.magic: bigint => unknown)
-    | t if t->Js.String2.startsWith("bytes") => ""->(Utils.magic: string => unknown)
+    | t if t->String.startsWith("uint") => 0n->(Utils.magic: bigint => unknown)
+    | t if t->String.startsWith("int") => 0n->(Utils.magic: bigint => unknown)
+    | t if t->String.startsWith("bytes") => ""->(Utils.magic: string => unknown)
     | _ => %raw(`undefined`)->(Utils.magic: 'a => unknown)
     }
   }
 }
 
+// ============== Named-tuple (struct) schema helpers ==============
+
+// Build a simulate schema that honours component names: whenever an event param
+// (or nested field) has components, we decode it as an object with named fields
+// rather than a positional tuple. Walks through array wrappers so `struct[]`
+// still produces `array<{...}>`.
+let rec componentsToSimulateSchema = (abiType: string, components: array<eventParamComponent>): S.t<
+  unknown,
+> => {
+  if abiType->String.endsWith("]") {
+    let bracketIdx = abiType->String.lastIndexOf("[")
+    let baseType = abiType->String.slice(~start=0, ~end=bracketIdx)
+    S.array(componentsToSimulateSchema(baseType, components))->S.toUnknown
+  } else {
+    // Must be a tuple at this level: build a record keyed by component names.
+    S.object(s => {
+      let dict = Dict.make()
+      components->Array.forEach(c => {
+        let childSchema = switch c.components {
+        | Some(sub) => componentsToSimulateSchema(c.abiType, sub)
+        | None => abiTypeToSimulateSchema(c.abiType)
+        }
+        dict->Dict.set(c.name, s.field(c.name, childSchema))
+      })
+      dict
+    })->S.toUnknown
+  }
+}
+
+// Default simulate value for a component tree — mirrors `abiTypeToDefaultValue`
+// but emits objects with named fields for tuples.
+let rec componentsToDefaultValue = (
+  abiType: string,
+  components: array<eventParamComponent>,
+): unknown => {
+  if abiType->String.endsWith("]") {
+    []->(Utils.magic: array<unknown> => unknown)
+  } else {
+    let dict = Dict.make()
+    components->Array.forEach(c => {
+      let v = switch c.components {
+      | Some(sub) => componentsToDefaultValue(c.abiType, sub)
+      | None => abiTypeToDefaultValue(c.abiType)
+      }
+      dict->Dict.set(c.name, v)
+    })
+    dict->(Utils.magic: dict<unknown> => unknown)
+  }
+}
+
+// Build a post-processor that converts the raw positional tuple values
+// produced by the HyperSync decoder into objects with named fields. Walks
+// through array wrappers so `struct[]` becomes `array<{...}>`. Returns `None`
+// for leaf params where no remapping is needed.
+let rec componentsToRemapper = (
+  abiType: string,
+  components: array<eventParamComponent>,
+  value: unknown,
+): unknown => {
+  if abiType->String.endsWith("]") {
+    let bracketIdx = abiType->String.lastIndexOf("[")
+    let baseType = abiType->String.slice(~start=0, ~end=bracketIdx)
+    let arr = value->(Utils.magic: unknown => array<unknown>)
+    arr
+    ->Array.map(item => componentsToRemapper(baseType, components, item))
+    ->(Utils.magic: array<unknown> => unknown)
+  } else {
+    // Must be a tuple at this level: build an object keyed by component names.
+    let arr = value->(Utils.magic: unknown => array<unknown>)
+    let dict = Dict.make()
+    components->Array.forEachWithIndex((c, i) => {
+      let raw = arr->Array.getUnsafe(i)
+      let mapped = switch c.components {
+      | Some(sub) => componentsToRemapper(c.abiType, sub, raw)
+      | None => raw
+      }
+      dict->Dict.set(c.name, mapped)
+    })
+    dict->(Utils.magic: dict<unknown> => unknown)
+  }
+}
+
 // ============== Build paramsRawEventSchema ==============
 
 let buildParamsSchema = (params: array<eventParam>): S.t<Internal.eventParams> => {
@@ -142,9 +231,9 @@ let buildParamsSchema = (params: array<eventParam>): S.t<Internal.eventParams> =
     ->(Utils.magic: S.t<unit> => S.t<Internal.eventParams>)
   } else {
     S.object(s => {
-      let dict = Js.Dict.empty()
+      let dict = Dict.make()
       params->Array.forEach(p => {
-        dict->Js.Dict.set(p.name, s.field(p.name, abiTypeToSchema(p.abiType)))
+        dict->Dict.set(p.name, s.field(p.name, abiTypeToSchema(p.abiType)))
       })
       dict
     })->(Utils.magic: S.t<dict<unknown>> => S.t<Internal.eventParams>)
@@ -153,6 +242,8 @@ let buildParamsSchema = (params: array<eventParam>): S.t<Internal.eventParams> =
 
 // Build a lenient params schema for simulate items.
 // Uses S.schema + s.matches with S.null->S.Option.getOr to fill missing fields with defaults.
+// When a param carries component metadata (Solidity struct), we accept and emit a
+// record with named fields rather than a positional tuple.
 let buildSimulateParamsSchema = (params: array<eventParam>): S.t<Internal.eventParams> => {
   if params->Array.length == 0 {
     S.unknown
@@ -160,16 +251,16 @@ let buildSimulateParamsSchema = (params: array<eventParam>): S.t<Internal.eventP
     ->(Utils.magic: S.t<unit> => S.t<Internal.eventParams>)
   } else {
     S.schema(s => {
-      let dict = Js.Dict.empty()
+      let dict = Dict.make()
       params->Array.forEach(p => {
-        dict->Js.Dict.set(
-          p.name,
-          s.matches(
-            S.null(abiTypeToSimulateSchema(p.abiType))->S.Option.getOr(
-              abiTypeToDefaultValue(p.abiType),
-            ),
-          ),
-        )
+        let (paramSchema, paramDefault) = switch p.components {
+        | Some(components) => (
+            componentsToSimulateSchema(p.abiType, components),
+            componentsToDefaultValue(p.abiType, components),
+          )
+        | None => (abiTypeToSimulateSchema(p.abiType), abiTypeToDefaultValue(p.abiType))
+        }
+        dict->Dict.set(p.name, s.matches(S.null(paramSchema)->S.Option.getOr(paramDefault)))
       })
       dict
     })->(Utils.magic: S.t<dict<unknown>> => S.t<Internal.eventParams>)
@@ -189,18 +280,18 @@ let buildHyperSyncDecoder = (params: array<eventParam>): (
   if params->Array.length == 0 {
     _ => ()->(Utils.magic: unit => Internal.eventParams)
   } else {
-    let indexedParams = params->Js.Array2.filter(p => p.indexed)
-    let bodyParams = params->Js.Array2.filter(p => !p.indexed)
+    let indexedParams = params->Array.filter(p => p.indexed)
+    let bodyParams = params->Array.filter(p => !p.indexed)
 
     let fields = []
-    indexedParams->Array.forEachWithIndex((i, p) => {
-      fields->Js.Array2.push(`"${p.name}": t(d.indexed[${i->Int.toString}])`)->ignore
+    indexedParams->Array.forEachWithIndex((p, i) => {
+      fields->Array.push(`"${p.name}": t(d.indexed[${i->Int.toString}])`)->ignore
     })
-    bodyParams->Array.forEachWithIndex((i, p) => {
-      fields->Js.Array2.push(`"${p.name}": t(d.body[${i->Int.toString}])`)->ignore
+    bodyParams->Array.forEachWithIndex((p, i) => {
+      fields->Array.push(`"${p.name}": t(d.body[${i->Int.toString}])`)->ignore
     })
     // Generate: function(t) { return function(d) { return { ... } } }
-    let body = `return function(d) { return {${fields->Js.Array2.joinWith(", ")}} }`
+    let body = `return function(d) { return {${fields->Array.joinUnsafe(", ")}} }`
 
     let factory: (
       HyperSyncClient.Decoder.decodedRaw => HyperSyncClient.Decoder.decodedUnderlying
@@ -211,7 +302,33 @@ let buildHyperSyncDecoder = (params: array<eventParam>): (
         ) => HyperSyncClient.Decoder.decodedEvent => Internal.eventParams
       )
 
-    factory(HyperSyncClient.Decoder.toUnderlying)
+    let baseDecode = factory(HyperSyncClient.Decoder.toUnderlying)
+
+    // For any param that has tuple component metadata, rewrite its value from a
+    // positional array into a named record post-decode. We pre-collect the
+    // params that need remapping so the hot path only walks those. Indexed
+    // struct/tuple params arrive as keccak256 topic hashes (single hex strings)
+    // rather than positional arrays, so they must be skipped here — running
+    // componentsToRemapper on a hash would treat the hex string as an array
+    // and read garbage.
+    let paramsToRemap = params->Array.filter(p => !p.indexed && p.components->Option.isSome)
+
+    if paramsToRemap->Array.length == 0 {
+      baseDecode
+    } else {
+      decoded => {
+        let result = baseDecode(decoded)
+        let dict = result->(Utils.magic: Internal.eventParams => dict<unknown>)
+        paramsToRemap->Array.forEach(p => {
+          switch (p.components, dict->Dict.get(p.name)) {
+          | (Some(components), Some(raw)) =>
+            dict->Dict.set(p.name, componentsToRemapper(p.abiType, components, raw))
+          | _ => ()
+          }
+        })
+        dict->(Utils.magic: dict<unknown> => Internal.eventParams)
+      }
+    }
   }
 }
 
@@ -219,7 +336,7 @@ let buildHyperSyncDecoder = (params: array<eventParam>): (
 
 let getTopicEncoder = (abiType: string): (unknown => EvmTypes.Hex.t) => {
   // Handle array/tuple types - these get keccak256'd
-  if abiType->Js.String2.endsWith("]") || abiType->Js.String2.startsWith("(") {
+  if abiType->String.endsWith("]") || abiType->String.startsWith("(") {
     TopicFilter.castToHexUnsafe->(Utils.magic: ('a => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t)
   } else {
     switch abiType {
@@ -240,33 +357,30 @@ let getTopicEncoder = (abiType: string): (unknown => EvmTypes.Hex.t) => {
         Utils.magic: (string => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
       )
 
-    | t if t->Js.String2.startsWith("uint") =>
+    | t if t->String.startsWith("uint") =>
       TopicFilter.fromBigInt->(Utils.magic: (bigint => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t)
-    | t if t->Js.String2.startsWith("int") =>
+    | t if t->String.startsWith("int") =>
       TopicFilter.fromSignedBigInt->(
         Utils.magic: (bigint => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
       )
 
-    | t if t->Js.String2.startsWith("bytes") =>
+    | t if t->String.startsWith("bytes") =>
       TopicFilter.castToHexUnsafe->(
         Utils.magic: ('a => EvmTypes.Hex.t) => unknown => EvmTypes.Hex.t
       )
 
-    | other => Js.Exn.raiseError(`Unsupported topic filter ABI type: ${other}`)
+    | other => JsError.throwWithMessage(`Unsupported topic filter ABI type: ${other}`)
     }
   }
 }
 
 let buildTopicGetter = (p: eventParam) => {
   let encoder = getTopicEncoder(p.abiType)
-  (eventFilter: Js.Dict.t<Js.Json.t>) =>
+  (eventFilter: dict<JSON.t>) =>
     eventFilter
     ->Utils.Dict.dangerouslyGetNonOption(p.name)
-    ->Option.mapWithDefault([], topicFilters =>
-      topicFilters
-      ->(Utils.magic: Js.Json.t => unknown)
-      ->normalizeOrThrow
-      ->Js.Array2.map(encoder)
+    ->Option.mapOr([], topicFilters =>
+      topicFilters->(Utils.magic: JSON.t => unknown)->normalizeOrThrow->Array.map(encoder)
     )
 }
 
@@ -303,24 +417,43 @@ let buildEvmEventConfig = (
   ~isWildcard: bool,
   ~handler: option<Internal.handler>,
   ~contractRegister: option<Internal.contractRegister>,
-  ~eventFilters: option<Js.Json.t>,
+  ~eventFilters: option<JSON.t>,
+  ~probeChainId: int,
+  ~onEventBlockFilterSchema: S.t<option<unknown>>,
   ~blockFields: option<array<Internal.evmBlockField>>=?,
   ~transactionFields: option<array<Internal.evmTransactionField>>=?,
+  ~startBlock: option<int>=?,
   ~globalBlockFieldsSet: Utils.Set.t<Internal.evmBlockField>=Utils.Set.make(),
   ~globalTransactionFieldsSet: Utils.Set.t<Internal.evmTransactionField>=Utils.Set.make(),
 ): Internal.evmEventConfig => {
   let topicCount = params->Array.reduce(1, (acc, p) => p.indexed ? acc + 1 : acc)
-  let indexedParams = params->Js.Array2.filter(p => p.indexed)
+  let indexedParams = params->Array.filter(p => p.indexed)
 
-  let {getEventFiltersOrThrow, filterByAddresses} = LogSelection.parseEventFiltersOrThrow(
+  let {
+    getEventFiltersOrThrow,
+    filterByAddresses,
+    startBlock: whereStartBlock,
+  } = LogSelection.parseEventFiltersOrThrow(
     ~eventFilters,
     ~sighash,
     ~params=indexedParams->Array.map(p => p.name),
+    ~contractName,
+    ~probeChainId,
+    ~onEventBlockFilterSchema,
     ~topic1=?indexedParams->Array.get(0)->Option.map(buildTopicGetter),
     ~topic2=?indexedParams->Array.get(1)->Option.map(buildTopicGetter),
     ~topic3=?indexedParams->Array.get(2)->Option.map(buildTopicGetter),
   )
 
+  // `where.block.number._gte` overrides the contract-level startBlock
+  // when present. The user opts into this explicitly in handler code so
+  // it should win over the `config.yaml` contract `start_block`; absent
+  // `where.block`, the caller's contract-level value passes through.
+  let resolvedStartBlock = switch whereStartBlock {
+  | Some(_) as sb => sb
+  | None => startBlock
+  }
+
   let (selectedBlockFields, selectedTransactionFields) = resolveFieldSelection(
     ~blockFields,
     ~transactionFields,
@@ -340,9 +473,12 @@ let buildEvmEventConfig = (
     getEventFiltersOrThrow,
     filterByAddresses,
     dependsOnAddresses: !isWildcard || filterByAddresses,
+    startBlock: resolvedStartBlock,
     convertHyperSyncEventArgs: buildHyperSyncDecoder(params),
     selectedBlockFields,
     selectedTransactionFields,
+    sighash,
+    indexedParams,
   }
 }
 
@@ -353,10 +489,11 @@ let buildFuelEventConfig = (
   ~eventName: string,
   ~kind: string,
   ~sighash: string,
-  ~rawAbi: Js.Json.t,
+  ~rawAbi: JSON.t,
   ~isWildcard: bool,
   ~handler: option<Internal.handler>,
   ~contractRegister: option<Internal.contractRegister>,
+  ~startBlock: option<int>=?,
 ): Internal.fuelEventConfig => {
   let fuelKind = switch kind {
   | "logData" =>
@@ -370,7 +507,7 @@ let buildFuelEventConfig = (
   | "burn" => Burn
   | "transfer" => Transfer
   | "call" => Call
-  | other => Js.Exn.raiseError(`Unsupported Fuel event kind: ${other}`)
+  | other => JsError.throwWithMessage(`Unsupported Fuel event kind: ${other}`)
   }
   let paramsSchema = switch kind {
   | "mint" | "burn" =>
@@ -386,8 +523,8 @@ let buildFuelEventConfig = (
   | "logData" =>
     S.json(~validate=false)
     ->Utils.Schema.coerceToJsonPgType
-    ->(Utils.magic: S.t<Js.Json.t> => S.t<Internal.eventParams>)
-  | other => Js.Exn.raiseError(`Unsupported Fuel event kind: ${other}`)
+    ->(Utils.magic: S.t<JSON.t> => S.t<Internal.eventParams>)
+  | other => JsError.throwWithMessage(`Unsupported Fuel event kind: ${other}`)
   }
   {
     id: switch kind {
@@ -403,6 +540,7 @@ let buildFuelEventConfig = (
     simulateParamsSchema: paramsSchema,
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
+    startBlock,
     kind: fuelKind,
   }
 }