envio 3.3.0-alpha.10 → 3.3.0-alpha.12

package/src/HandlerRegister.res

@@ -679,7 +679,9 @@ let finishRegistration = (~config: Config.t): registrationsByChainId => {
                   config.ecosystem.name === Evm &&
                     (registration->getResolvedWhere).topicSelections->Utils.Array.isEmpty
                 if !isDroppedByWhere {
-                  onEventRegistrations->Array.push(registration)
+                  onEventRegistrations
+                  ->Array.push({...registration, index: onEventRegistrations->Array.length})
+                  ->ignore
                 }
               | None => ()
               }

package/src/HandlerRegister.res.mjs

@@ -388,10 +388,11 @@ function finishRegistration(config) {
           return;
         }
         let isDroppedByWhere = config.ecosystem.name === "evm" && Utils.$$Array.isEmpty(registration$1.resolvedWhere.topicSelections);
-        if (!isDroppedByWhere) {
-          onEventRegistrations.push(registration$1);
+        if (isDroppedByWhere) {
           return;
         }
+        let newrecord = {...registration$1};
+        onEventRegistrations.push((newrecord.index = onEventRegistrations.length, newrecord));
       });
     });
     registrationsByChainId[key] = {

package/src/Internal.res

@@ -330,6 +330,9 @@ type eventPayload
 @get external getPayloadBlock: eventPayload => Nullable.t<eventBlock> = "block"
 @set external setPayloadBlock: (eventPayload, eventBlock) => unit = "block"
 
+// The log's emitting address (EVM/Fuel; the program id carries it for SVM).
+@get external getPayloadSrcAddress: eventPayload => Address.t = "srcAddress"
+
 type genericLoaderArgs<'event, 'context> = {
   event: 'event,
   context: 'context,
@@ -555,6 +558,11 @@ type svmInstructionEventConfig = {
 // must stay directly constructable), and the evm→base cast in sources is sound
 // by ecosystem homogeneity — an EVM chain only ever holds `evmOnEventRegistration`s.
 type onEventRegistration = {
+  // Chain-scoped sequential index — the registration's position in the
+  // chain's onEventRegistrations array, assigned when registration finishes
+  // (-1 until then). Native-routed items reference their registration by this
+  // index across the napi boundary; sources resolve it before creating an item.
+  index: int,
   eventConfig: eventConfig,
   handler: option<handler>,
   contractRegister: option<contractRegister>,
@@ -601,8 +609,9 @@ type indexingAddress = {
 
 type dcs = array<indexingAddress>
 
-// Duplicate the type from item
-// to make item properly unboxed
+// Duplicate the type from item to keep item properly unboxed. Runtime event
+// items carry the registration their source already resolved from the
+// ChainState-owned registration array.
 type eventItem = private {
   kind: [#0],
   onEventRegistration: onEventRegistration,

package/src/LogSelection.res

@@ -1,65 +1,3 @@
-exception MissingRequiredTopic0
-let makeTopicSelection = (~topic0, ~topic1=[], ~topic2=[], ~topic3=[]): result<
-  Internal.topicSelection,
-  exn,
-> =>
-  if topic0->Utils.Array.isEmpty {
-    Error(MissingRequiredTopic0)
-  } else {
-    {
-      Internal.topic0,
-      topic1,
-      topic2,
-      topic3,
-    }->Ok
-  }
-
-let hasFilters = ({topic1, topic2, topic3}: Internal.topicSelection) => {
-  [topic1, topic2, topic3]->Array.find(topic => !Utils.Array.isEmpty(topic))->Option.isSome
-}
-
-/**
-For a group of topic selections, if multiple only use topic0, then they can be compressed into one
-selection combining the topic0s
-*/
-let compressTopicSelections = (topicSelections: array<Internal.topicSelection>) => {
-  let topic0sOfSelectionsWithoutFilters = []
-
-  let selectionsWithFilters = []
-
-  topicSelections->Array.forEach(selection => {
-    if selection->hasFilters {
-      selectionsWithFilters->Array.push(selection)->ignore
-    } else {
-      selection.topic0->Array.forEach(topic0 => {
-        topic0sOfSelectionsWithoutFilters->Array.push(topic0)->ignore
-      })
-    }
-  })
-
-  switch topic0sOfSelectionsWithoutFilters {
-  | [] => selectionsWithFilters
-  | topic0 =>
-    let selectionWithoutFilters: Internal.topicSelection = {
-      topic0,
-      topic1: [],
-      topic2: [],
-      topic3: [],
-    }
-    Array.concat([selectionWithoutFilters], selectionsWithFilters)
-  }
-}
-
-type t = {
-  addresses: array<Address.t>,
-  topicSelections: array<Internal.topicSelection>,
-}
-
-let make = (~addresses, ~topicSelections) => {
-  let topicSelections = compressTopicSelections(topicSelections)
-  {addresses, topicSelections}
-}
-
 // 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.

package/src/LogSelection.res.mjs

@@ -8,75 +8,6 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-let MissingRequiredTopic0 = /* @__PURE__ */Primitive_exceptions.create("LogSelection.MissingRequiredTopic0");
-
-function makeTopicSelection(topic0, topic1Opt, topic2Opt, topic3Opt) {
-  let topic1 = topic1Opt !== undefined ? topic1Opt : [];
-  let topic2 = topic2Opt !== undefined ? topic2Opt : [];
-  let topic3 = topic3Opt !== undefined ? topic3Opt : [];
-  if (Utils.$$Array.isEmpty(topic0)) {
-    return {
-      TAG: "Error",
-      _0: {
-        RE_EXN_ID: MissingRequiredTopic0
-      }
-    };
-  } else {
-    return {
-      TAG: "Ok",
-      _0: {
-        topic0: topic0,
-        topic1: topic1,
-        topic2: topic2,
-        topic3: topic3
-      }
-    };
-  }
-}
-
-function hasFilters(param) {
-  return Stdlib_Option.isSome([
-    param.topic1,
-    param.topic2,
-    param.topic3
-  ].find(topic => !Utils.$$Array.isEmpty(topic)));
-}
-
-function compressTopicSelections(topicSelections) {
-  let topic0sOfSelectionsWithoutFilters = [];
-  let selectionsWithFilters = [];
-  topicSelections.forEach(selection => {
-    if (hasFilters(selection)) {
-      selectionsWithFilters.push(selection);
-    } else {
-      selection.topic0.forEach(topic0 => {
-        topic0sOfSelectionsWithoutFilters.push(topic0);
-      });
-    }
-  });
-  if (topic0sOfSelectionsWithoutFilters.length === 0) {
-    return selectionsWithFilters;
-  }
-  let selectionWithoutFilters_topic1 = [];
-  let selectionWithoutFilters_topic2 = [];
-  let selectionWithoutFilters_topic3 = [];
-  let selectionWithoutFilters = {
-    topic0: topic0sOfSelectionsWithoutFilters,
-    topic1: selectionWithoutFilters_topic1,
-    topic2: selectionWithoutFilters_topic2,
-    topic3: selectionWithoutFilters_topic3
-  };
-  return [selectionWithoutFilters].concat(selectionsWithFilters);
-}
-
-function make(addresses, topicSelections) {
-  let topicSelections$1 = compressTopicSelections(topicSelections);
-  return {
-    addresses: addresses,
-    topicSelections: topicSelections$1
-  };
-}
-
 function materializeTopicFilter(filter, addresses) {
   if (filter.TAG === "Values") {
     return filter._0;
@@ -299,11 +230,6 @@ function parseWhereOrThrow(where, sighash, params, contractName, chainId, onEven
 }
 
 export {
-  MissingRequiredTopic0,
-  makeTopicSelection,
-  hasFilters,
-  compressTopicSelections,
-  make,
   materializeTopicFilter,
   materializeTopicSelections,
   eventBlockRangeSchema,

package/src/RawEvent.res

@@ -32,8 +32,8 @@ let make = (
   ~blockTimestamp: int,
   ~cleanUpRawEventFieldsInPlace: JSON.t => unit,
 ): Internal.rawEvent => {
-  let {onEventRegistration, chain, blockNumber, logIndex} = eventItem
-  let eventConfig = onEventRegistration.eventConfig
+  let {chain, blockNumber, logIndex} = eventItem
+  let eventConfig = eventItem.onEventRegistration.eventConfig
   let chainId = chain->ChainMap.Chain.toChainId
   let eventId = EventUtils.packEventIndex(~logIndex, ~blockNumber)
   let blockFields =

package/src/Rollback.res

@@ -72,7 +72,7 @@ let rec rollback = async (
     // found yet. Wait for the ReorgDetected branch above to find it and re-kick.
     | FindingReorgDepth => ()
     | FoundReorgDepth(_) if state->IndexerState.isProcessing =>
-      Logging.info("Waiting for batch to finish processing before executing rollback")
+      Logging.trace("Waiting for batch to finish processing before executing rollback")
     | FoundReorgDepth({chain: reorgChain, rollbackTargetBlockNumber}) =>
       await executeRollback(
         state,
@@ -96,10 +96,10 @@ and executeRollback = async (
 ) => {
   let startTime = Performance.now()
 
-  let chainState = state->IndexerState.getChainState(~chain=reorgChain)
-
-  let logger = Logging.createChildFrom(
-    ~logger=chainState->ChainState.logger,
+  // Not derived from the reorg chain's logger: that would bind its chainId onto
+  // every line, colliding with the per-chain chainId on the "Rollbacked" logs.
+  // The reorg chain is identified by the reorgChain param instead.
+  let logger = Logging.createChild(
     ~params={
       "action": "Rollback",
       "reorgChain": reorgChain,
@@ -161,10 +161,12 @@ and executeRollback = async (
     }
   }
 
+  let rolledBackChains = []
   state
   ->IndexerState.chainStates
   ->Utils.Dict.forEach(cs => {
     let chainId = (cs->ChainState.chainConfig).id
+    let fromBlock = cs->ChainState.committedProgressBlockNumber
     cs->ChainState.rollback(
       ~newProgressBlockNumber=newProgressBlockNumberPerChain->Utils.Dict.dangerouslyGetByIntNonOption(
         chainId,
@@ -175,6 +177,19 @@ and executeRollback = async (
       ~rollbackTargetBlockNumber,
       ~isReorgChain=chainId === reorgChainId,
     )
+    let toBlock = cs->ChainState.committedProgressBlockNumber
+    if fromBlock !== toBlock {
+      rolledBackChains
+      ->Array.push({
+        "chainId": chainId,
+        "fromBlock": fromBlock,
+        "toBlock": toBlock,
+        "rollbackedEvents": eventsProcessedDiffByChain
+        ->Utils.Dict.dangerouslyGetByIntNonOption(chainId)
+        ->Option.getOr(0.),
+      })
+      ->ignore
+    }
   })
 
   let diff = await state->InMemoryStore.prepareRollbackDiff(
@@ -183,15 +198,19 @@ and executeRollback = async (
     ~progressBlockNumberByChainId=newProgressBlockNumberPerChain,
   )
 
+  rolledBackChains->Array.forEach(chain => {
+    logger->Logging.childInfo({
+      "msg": "Rollbacked",
+      "chainId": chain["chainId"],
+      "fromBlock": chain["fromBlock"],
+      "toBlock": chain["toBlock"],
+      "rollbackedEvents": chain["rollbackedEvents"],
+    })
+  })
   logger->Logging.childTrace({
-    "msg": "Finished rollback on reorg",
-    "entityChanges": {
-      "deleted": diff["deletedEntities"],
-      "upserted": diff["setEntities"],
-    },
-    "rollbackedEvents": rollbackedProcessedEvents.contents,
-    "beforeCheckpointId": state->IndexerState.committedCheckpointId,
-    "targetCheckpointId": rollbackTargetCheckpointId,
+    "msg": "Rollback entity changes",
+    "deleted": diff["deletedEntities"],
+    "upserted": diff["setEntities"],
   })
   Prometheus.RollbackSuccess.increment(
     ~timeSeconds=Performance.secondsSince(startTime),

package/src/Rollback.res.mjs

@@ -33,8 +33,7 @@ async function getLastKnownValidBlock(chainState, reorgBlockNumber, isRealtime)
 
 async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing) {
   let startTime = Performance.now();
-  let chainState = IndexerState.getChainState(state, reorgChain);
-  let logger = Logging.createChildFrom(ChainState.logger(chainState), {
+  let logger = Logging.createChild({
     action: "Rollback",
     reorgChain: reorgChain,
     targetBlockNumber: rollbackTargetBlockNumber
@@ -55,20 +54,34 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
     eventsProcessedDiffByChain[diff.chain_id] = eventsProcessedDiff;
     newProgressBlockNumberPerChain[diff.chain_id] = rollbackTargetCheckpointId === 0n && diff.chain_id === reorgChain ? Primitive_int.min(diff.new_progress_block_number, rollbackTargetBlockNumber) : diff.new_progress_block_number;
   }
+  let rolledBackChains = [];
   Utils.Dict.forEach(IndexerState.chainStates(state), cs => {
     let chainId = ChainState.chainConfig(cs).id;
+    let fromBlock = ChainState.committedProgressBlockNumber(cs);
     ChainState.rollback(cs, newProgressBlockNumberPerChain[chainId], eventsProcessedDiffByChain[chainId], rollbackTargetBlockNumber, chainId === reorgChain);
+    let toBlock = ChainState.committedProgressBlockNumber(cs);
+    if (fromBlock !== toBlock) {
+      rolledBackChains.push({
+        chainId: chainId,
+        fromBlock: fromBlock,
+        toBlock: toBlock,
+        rollbackedEvents: Stdlib_Option.getOr(eventsProcessedDiffByChain[chainId], 0)
+      });
+      return;
+    }
   });
   let diff$1 = await InMemoryStore.prepareRollbackDiff(state, rollbackTargetCheckpointId, IndexerState.committedCheckpointId(state) + 1n, newProgressBlockNumberPerChain);
+  rolledBackChains.forEach(chain => Logging.childInfo(logger, {
+    msg: "Rollbacked",
+    chainId: chain.chainId,
+    fromBlock: chain.fromBlock,
+    toBlock: chain.toBlock,
+    rollbackedEvents: chain.rollbackedEvents
+  }));
   Logging.childTrace(logger, {
-    msg: "Finished rollback on reorg",
-    entityChanges: {
-      deleted: diff$1.deletedEntities,
-      upserted: diff$1.setEntities
-    },
-    rollbackedEvents: rollbackedProcessedEvents,
-    beforeCheckpointId: IndexerState.committedCheckpointId(state),
-    targetCheckpointId: rollbackTargetCheckpointId
+    msg: "Rollback entity changes",
+    deleted: diff$1.deletedEntities,
+    upserted: diff$1.setEntities
   });
   Prometheus.RollbackSuccess.increment(Performance.secondsSince(startTime), rollbackedProcessedEvents);
   IndexerState.completeRollback(state, eventsProcessedDiffByChain);
@@ -97,7 +110,7 @@ async function rollback(state, scheduleFetch, scheduleProcessing, scheduleRollba
         return scheduleRollback();
       case "FoundReorgDepth" :
         if (IndexerState.isProcessing(state)) {
-          return Logging.info("Waiting for batch to finish processing before executing rollback");
+          return Logging.trace("Waiting for batch to finish processing before executing rollback");
         } else {
           return await executeRollback(state, match.chain, match.rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing);
         }

package/src/SimulateDeadInputTracker.res

@@ -10,7 +10,7 @@ let itemKey = (item: Internal.item): string =>
     `${chain
       ->ChainMap.Chain.toChainId
       ->Int.toString}:${blockNumber->Int.toString}:${logIndex->Int.toString}`
-  | _ => "" // non-event items are never a provided simulate input
+  | Internal.Block(_) => ""
   }
 
 // `index` is the item's position in its chain's `simulate` array, reported back

package/src/SimulateItems.res

@@ -240,9 +240,12 @@ let deriveSrcAddress = (
   }
 }
 
-let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Config.chain): array<
-  Internal.item,
-> => {
+let parse = (
+  ~simulateItems: array<JSON.t>,
+  ~config: Config.t,
+  ~chainConfig: Config.chain,
+  ~onEventRegistrations: array<Internal.onEventRegistration>,
+): array<Internal.item> => {
   let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
   let chainId = chainConfig.id
   let startBlock = chainConfig.startBlock
@@ -345,6 +348,11 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
         ~chainId,
         ~eventConfig,
       )
+      // Append into the registration array that the chain state will own and
+      // put that same registration object directly on the simulated item.
+      let onEventRegistrationIndex = onEventRegistrations->Array.length
+      let onEventRegistration = {...onEventRegistration, index: onEventRegistrationIndex}
+      onEventRegistrations->Array.push(onEventRegistration)->ignore
 
       items
       ->Array.push(
@@ -382,7 +390,11 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
 
 // Apply simulate source config from processConfig JSON to a Config.t
 // This patches chainMap entries that have simulate items with CustomSources
-let patchConfig = (~config: Config.t, ~processConfig: JSON.t): Config.t => {
+let patchConfig = (
+  ~config: Config.t,
+  ~processConfig: JSON.t,
+  ~registrationsByChainId: HandlerRegister.registrationsByChainId,
+): Config.t => {
   let processChains: option<dict<JSON.t>> =
     (processConfig->(Utils.magic: JSON.t => {..}))["chains"]->Nullable.toOption
   switch processChains {
@@ -395,11 +407,31 @@ let patchConfig = (~config: Config.t, ~processConfig: JSON.t): Config.t => {
         let simulateRaw: option<array<JSON.t>> = raw["simulate"]->Nullable.toOption
         switch simulateRaw {
         | Some(simulateItems) =>
-          let items = parse(~simulateItems, ~config, ~chainConfig)
+          let chainRegistrations = switch registrationsByChainId->Utils.Dict.dangerouslyGetNonOption(
+            chainIdStr,
+          ) {
+          | Some(registrations) => registrations
+          | None =>
+            let registrations: HandlerRegister.chainRegistrations = {
+              onEventRegistrations: [],
+              onBlockRegistrations: [],
+            }
+            registrationsByChainId->Dict.set(chainIdStr, registrations)
+            registrations
+          }
           let startBlock: int = raw["startBlock"]->(Utils.magic: 'a => int)
           let endBlock: int = raw["endBlock"]->(Utils.magic: 'a => int)
+          // Parse with the process's startBlock so items default into the range
+          // the source will be queried over; the source now filters by range.
+          let chainConfig = {...chainConfig, startBlock, endBlock}
+          let items = parse(
+            ~simulateItems,
+            ~config,
+            ~chainConfig,
+            ~onEventRegistrations=chainRegistrations.onEventRegistrations,
+          )
           let source = SimulateSource.make(~items, ~endBlock, ~chain)
-          {...chainConfig, startBlock, endBlock, sourceConfig: Config.CustomSources([source])}
+          {...chainConfig, sourceConfig: Config.CustomSources([source])}
         | None => chainConfig
         }
       | None => chainConfig

package/src/SimulateItems.res.mjs

@@ -167,7 +167,7 @@ function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig, config)
   }
 }
 
-function parse(simulateItems, config, chainConfig) {
+function parse(simulateItems, config, chainConfig, onEventRegistrations) {
   let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
   let chainId = chainConfig.id;
   let startBlock = chainConfig.startBlock;
@@ -254,9 +254,13 @@ function parse(simulateItems, config, chainConfig) {
       seenCoordinates[coordinate] = itemIndex;
     }
     let onEventRegistration = HandlerRegister.buildOnEventRegistration(config, chainId, eventConfig, undefined);
+    let onEventRegistrationIndex = onEventRegistrations.length;
+    let newrecord = {...onEventRegistration};
+    newrecord.index = onEventRegistrationIndex;
+    onEventRegistrations.push(newrecord);
     items.push({
       kind: 0,
-      onEventRegistration: onEventRegistration,
+      onEventRegistration: newrecord,
       chain: chain,
       blockNumber: blockNumber,
       logIndex: logIndex,
@@ -276,7 +280,7 @@ function parse(simulateItems, config, chainConfig) {
   return items;
 }
 
-function patchConfig(config, processConfig) {
+function patchConfig(config, processConfig, registrationsByChainId) {
   let processChains = processConfig.chains;
   if (processChains == null) {
     return config;
@@ -291,18 +295,33 @@ function patchConfig(config, processConfig) {
     if (simulateRaw == null) {
       return chainConfig;
     }
-    let items = parse(simulateRaw, config, chainConfig);
+    let registrations = registrationsByChainId[chainIdStr];
+    let chainRegistrations;
+    if (registrations !== undefined) {
+      chainRegistrations = registrations;
+    } else {
+      let registrations_onEventRegistrations = [];
+      let registrations_onBlockRegistrations = [];
+      let registrations$1 = {
+        onEventRegistrations: registrations_onEventRegistrations,
+        onBlockRegistrations: registrations_onBlockRegistrations
+      };
+      registrationsByChainId[chainIdStr] = registrations$1;
+      chainRegistrations = registrations$1;
+    }
     let startBlock = processChainJson.startBlock;
     let endBlock = processChainJson.endBlock;
-    let source = SimulateSource.make(items, endBlock, chain);
     let newrecord = {...chainConfig};
-    newrecord.sourceConfig = {
+    newrecord.endBlock = endBlock;
+    newrecord.startBlock = startBlock;
+    let items = parse(simulateRaw, config, newrecord, chainRegistrations.onEventRegistrations);
+    let source = SimulateSource.make(items, endBlock, chain);
+    let newrecord$1 = {...newrecord};
+    newrecord$1.sourceConfig = {
       TAG: "CustomSources",
       _0: [source]
     };
-    newrecord.endBlock = endBlock;
-    newrecord.startBlock = startBlock;
-    return newrecord;
+    return newrecord$1;
   });
   return {
     name: config.name,

package/src/TestIndexer.res

@@ -863,8 +863,8 @@ let initTestWorker = () => {
     | Some(_) => ()
     }
 
-    let patchConfig = (config: Config.t, _registrations) => {
-      let config = SimulateItems.patchConfig(~config, ~processConfig)
+    let patchConfig = (config: Config.t, registrationsByChainId) => {
+      let config = SimulateItems.patchConfig(~config, ~processConfig, ~registrationsByChainId)
 
       // In auto-exit mode, set batchSize=1 to process one block checkpoint at a time
       if exitAfterFirstEventBlock {

package/src/TestIndexer.res.mjs

@@ -612,8 +612,8 @@ function initTestWorker() {
   } else {
     Logging.setLogLevel("silent");
   }
-  let patchConfig = (config, _registrations) => {
-    let config$1 = SimulateItems.patchConfig(config, processConfig);
+  let patchConfig = (config, registrationsByChainId) => {
+    let config$1 = SimulateItems.patchConfig(config, processConfig, registrationsByChainId);
     if (exitAfterFirstEventBlock) {
       return {
         name: config$1.name,

package/src/TopicFilter.res

@@ -1,27 +1,3 @@
-let toTwosComplement = (num: bigint, ~bytesLen: int) => {
-  let maxValue = 1n->BigInt.shiftLeft(BigInt.fromInt(bytesLen * 8))
-  let mask = maxValue->BigInt.sub(1n)
-  num->BigInt.add(maxValue)->BigInt.bitwiseAnd(mask)
-}
-
-let fromSignedBigInt = val => {
-  let bytesLen = 32
-  let val = val >= 0n ? val : val->toTwosComplement(~bytesLen)
-  val->Viem.bigintToHex(~options={size: bytesLen})
-}
-
 type hex = EvmTypes.Hex.t
-//bytes currently does not work with genType and we also currently generate bytes as a string type
-type bytesHex = string
-let keccak256 = Viem.keccak256
-let bytesToHex = Viem.bytesToHex
-let concat = Viem.concat
-let castToHexUnsafe: 'a => hex = val => val->(Utils.magic: 'a => hex)
-let fromBigInt: bigint => hex = val => val->Viem.bigintToHex(~options={size: 32})
-let fromDynamicString: string => hex = val => val->(Utils.magic: string => hex)->keccak256
-let fromString: string => hex = val => val->Viem.stringToHex(~options={size: 32})
+
 let fromAddress: Address.t => hex = addr => addr->(Utils.magic: Address.t => hex)->Viem.pad
-let fromDynamicBytes: bytesHex => hex = bytes => bytes->(Utils.magic: bytesHex => hex)->keccak256
-let fromBytes: bytesHex => hex = bytes =>
-  bytes->(Utils.magic: bytesHex => Uint8Array.t)->Viem.bytesToHex(~options={size: 32})
-let fromBool: bool => hex = b => b->Viem.boolToHex(~options={size: 32})

package/src/TopicFilter.res.mjs

@@ -1,86 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Viem from "viem";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-
-function toTwosComplement(num, bytesLen) {
-  let maxValue = (1n << BigInt((bytesLen << 3)));
-  let mask = maxValue - 1n;
-  return num + maxValue & mask;
-}
-
-function fromSignedBigInt(val) {
-  let val$1 = val >= 0n ? val : toTwosComplement(val, 32);
-  return Viem.numberToHex(val$1, {
-    size: 32
-  });
-}
-
-function keccak256(prim) {
-  return Viem.keccak256(prim);
-}
-
-function bytesToHex(prim0, prim1) {
-  return Viem.bytesToHex(prim0, prim1 !== undefined ? Primitive_option.valFromOption(prim1) : undefined);
-}
-
-function concat(prim) {
-  return Viem.concat(prim);
-}
-
-function castToHexUnsafe(val) {
-  return val;
-}
-
-function fromBigInt(val) {
-  return Viem.numberToHex(val, {
-    size: 32
-  });
-}
-
-function fromDynamicString(val) {
-  return Viem.keccak256(val);
-}
-
-function fromString(val) {
-  return Viem.stringToHex(val, {
-    size: 32
-  });
-}
 
 function fromAddress(addr) {
   return Viem.pad(addr);
 }
 
-function fromDynamicBytes(bytes) {
-  return Viem.keccak256(bytes);
-}
-
-function fromBytes(bytes) {
-  return Viem.bytesToHex(bytes, {
-    size: 32
-  });
-}
-
-function fromBool(b) {
-  return Viem.boolToHex(b, {
-    size: 32
-  });
-}
-
 export {
-  toTwosComplement,
-  fromSignedBigInt,
-  keccak256,
-  bytesToHex,
-  concat,
-  castToHexUnsafe,
-  fromBigInt,
-  fromDynamicString,
-  fromString,
   fromAddress,
-  fromDynamicBytes,
-  fromBytes,
-  fromBool,
 }
 /* viem Not a pure module */