envio 3.3.0-alpha.8 → 3.3.0-rc.0

package/src/PruneStaleHistory.res.mjs

@@ -1,46 +1,140 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Env from "./Env.res.mjs";
 import * as Utils from "./Utils.res.mjs";
+import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as Throttler from "./Throttler.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
-import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-async function runPrune(state) {
-  let safeCheckpointId = IndexerState.getSafeCheckpointId(state);
-  if (safeCheckpointId === undefined) {
+function selectFrom(allEntities, lastPrunedAtMillis, writtenEntityNames, isRollback, nowMillis, intervalMillis, safeCheckpointId) {
+  let byOldestPrune = (param, param$1) => param[0] - param$1[0];
+  let toEntities = candidates => candidates.map(param => param[1]);
+  let concurrentCandidates = [];
+  let forcedCandidates = [];
+  allEntities.forEach(entityConfig => {
+    if (!entityConfig.storage.postgres) {
+      return;
+    }
+    let lastPrunedAt = Stdlib_Option.getOr(lastPrunedAtMillis[entityConfig.name], 0);
+    if (!isRollback && !writtenEntityNames.has(entityConfig.name) && nowMillis - lastPrunedAt >= intervalMillis) {
+      concurrentCandidates.push([
+        lastPrunedAt,
+        entityConfig
+      ]);
+      return;
+    } else if (nowMillis - lastPrunedAt >= intervalMillis * 5) {
+      forcedCandidates.push([
+        lastPrunedAt,
+        entityConfig
+      ]);
+      return;
+    } else {
+      return;
+    }
+  });
+  let sortedConcurrent = concurrentCandidates.toSorted(byOldestPrune);
+  for (let idx = 5, idx_finish = sortedConcurrent.length; idx < idx_finish; ++idx) {
+    let match = sortedConcurrent[idx];
+    if (nowMillis - match[0] >= intervalMillis * 5) {
+      forcedCandidates.push(sortedConcurrent[idx]);
+    }
+  }
+  return {
+    safeCheckpointId: safeCheckpointId,
+    concurrent: toEntities(sortedConcurrent.slice(0, 5)),
+    forced: toEntities(forcedCandidates.toSorted(byOldestPrune).slice(0, 5))
+  };
+}
+
+function select(state, writtenEntityNames, isRollback) {
+  let config = IndexerState.config(state);
+  if (!Config.shouldPruneHistory(config, IndexerState.isInReorgThreshold(state))) {
     return;
   }
+  let safeCheckpointId = IndexerState.getSafeCheckpointId(state);
+  if (safeCheckpointId !== undefined) {
+    return selectFrom(IndexerState.persistence(state).allEntities, IndexerState.lastPrunedAtMillis(state), writtenEntityNames, isRollback, Date.now(), Env.ThrottleWrites.pruneStaleDataIntervalMillis, safeCheckpointId);
+  }
+}
+
+async function pruneEntities(state, entities, safeCheckpointId) {
   let persistence = IndexerState.persistence(state);
-  await persistence.storage.pruneStaleCheckpoints(safeCheckpointId);
-  for (let idx = 0, idx_finish = persistence.allEntities.length; idx < idx_finish; ++idx) {
-    if (idx !== 0) {
-      await Utils.delay(1000);
-    }
-    let entityConfig = persistence.allEntities[idx];
+  for (let idx = 0, idx_finish = entities.length; idx < idx_finish; ++idx) {
+    let entityConfig = entities[idx];
     let timeRef = Performance.now();
+    IndexerState.lastPrunedAtMillis(state)[entityConfig.name] = Date.now();
+    let exit = 0;
+    let val;
     try {
-      await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
+      val = await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
+      exit = 1;
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
-      ErrorHandling.mkLogAndRaise(Logging.createChild({
+      Logging.childErrorWithExn(Logging.createChild({
         entityName: entityConfig.name,
         safeCheckpointId: safeCheckpointId
-      }), `Failed to prune stale entity history`, exn);
+      }), Utils.prettifyExn(exn), `Failed to prune stale entity history`);
+    }
+    if (exit === 1) {
+      Prometheus.RollbackHistoryPrune.increment(Performance.secondsSince(timeRef), entityConfig.name);
     }
-    Prometheus.RollbackHistoryPrune.increment(Performance.secondsSince(timeRef), entityConfig.name);
   }
 }
 
-function schedule(state) {
-  Throttler.schedule(IndexerState.pruneStaleEntityHistoryThrottler(state), () => runPrune(state));
+async function pruneCheckpoints(state, safeCheckpointId) {
+  try {
+    await IndexerState.persistence(state).storage.pruneStaleCheckpoints(safeCheckpointId);
+    return;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return Logging.childErrorWithExn(Logging.createChild({
+      safeCheckpointId: safeCheckpointId
+    }), Utils.prettifyExn(exn), `Failed to prune stale checkpoints`);
+  }
+}
+
+async function runConcurrent(state, targets) {
+  if (targets === undefined) {
+    return;
+  }
+  let concurrent = targets.concurrent;
+  let safeCheckpointId = targets.safeCheckpointId;
+  if (Utils.$$Array.notEmpty(concurrent)) {
+    await pruneCheckpoints(state, safeCheckpointId);
+    return await pruneEntities(state, concurrent, safeCheckpointId);
+  }
+}
+
+async function runForced(state, targets) {
+  if (targets === undefined) {
+    return;
+  }
+  let forced = targets.forced;
+  let safeCheckpointId = targets.safeCheckpointId;
+  if (Utils.$$Array.notEmpty(forced)) {
+    if (Utils.$$Array.isEmpty(targets.concurrent)) {
+      await pruneCheckpoints(state, safeCheckpointId);
+    }
+    return await pruneEntities(state, forced, safeCheckpointId);
+  }
 }
 
+let maxEntitiesPerWrite = 5;
+
+let forcedIntervalMultiplier = 5;
+
 export {
-  runPrune,
-  schedule,
+  maxEntitiesPerWrite,
+  forcedIntervalMultiplier,
+  selectFrom,
+  select,
+  pruneEntities,
+  pruneCheckpoints,
+  runConcurrent,
+  runForced,
 }
-/* Utils Not a pure module */
+/* Env Not a pure module */

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/RollbackCommit.res

@@ -6,7 +6,10 @@
 type args = {chainId: int, rollbackToBlock: int}
 type callback = args => promise<unit>
 
-let callbacks: array<callback> = []
+// Lives in the process-wide `EnvioGlobal` record so callbacks registered
+// through a duplicate envio module instance still fire.
+let callbacks =
+  EnvioGlobal.value.rollbackCommitCallbacks->(Utils.magic: array<unknown> => array<callback>)
 
 let register = (callback: callback) => {
   callbacks->Array.push(callback)

package/src/RollbackCommit.res.mjs

@@ -1,8 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 
-let callbacks = [];
+let callbacks = EnvioGlobal.value.rollbackCommitCallbacks;
 
 function register(callback) {
   callbacks.push(callback);
@@ -32,4 +33,4 @@ export {
   register,
   fire,
 }
-/* No side effect */
+/* EnvioGlobal Not a pure module */

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
@@ -336,7 +339,7 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
       | None => seenCoordinates->Dict.set(coordinate, itemIndex)
       }
 
-      // Build a real registration the same way `HandlerRegister.buildOnEventRegistrations`
+      // Build a real registration the same way `HandlerRegister.finishRegistration`
       // does at startup (not a stub), so the address filter and `where`
       // behave identically to real indexing — the dead-input tracker relies
       // on `clientAddressFilter` actually gating unrouted items.
@@ -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 */