envio 3.3.0-alpha.1 → 3.3.0-alpha.11

package/src/SimulateItems.res.mjs

@@ -1,10 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Config from "./Config.res.mjs";
 import * as Address from "./Address.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as SimulateSource from "./sources/SimulateSource.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as HandlerRegister from "./HandlerRegister.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
@@ -135,7 +137,37 @@ function findEventConfig(config, contractName, eventName) {
   return found.contents;
 }
 
-function parse(simulateItems, config, chainConfig) {
+let dummySrcAddress = "0x0000000000000000000000000000000000000000";
+
+function firstContractAddress(chainConfig, contractName) {
+  let found = {
+    contents: undefined
+  };
+  chainConfig.contracts.forEach(contract => {
+    if (Stdlib_Option.isNone(found.contents) && contract.name === contractName) {
+      found.contents = contract.addresses[0];
+      return;
+    }
+  });
+  return found.contents;
+}
+
+function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig, config) {
+  if (providedSrcAddress !== undefined) {
+    return Config.normalizeSimulateAddress(config, Primitive_option.valFromOption(providedSrcAddress));
+  }
+  if (HandlerRegister.isWildcard(eventConfig.contractName, eventConfig.name)) {
+    return dummySrcAddress;
+  }
+  let addr = firstContractAddress(chainConfig, eventConfig.contractName);
+  if (addr !== undefined) {
+    return Primitive_option.valFromOption(addr);
+  } else {
+    return dummySrcAddress;
+  }
+}
+
+function parse(simulateItems, config, chainConfig, onEventRegistrations) {
   let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
   let chainId = chainConfig.id;
   let startBlock = chainConfig.startBlock;
@@ -146,7 +178,8 @@ function parse(simulateItems, config, chainConfig) {
     contents: 0
   };
   let items = [];
-  simulateItems.forEach(rawJson => {
+  let seenCoordinates = {};
+  simulateItems.forEach((rawJson, itemIndex) => {
     let match = rawJson.contract;
     let match$1 = rawJson.event;
     if (match === undefined) {
@@ -163,32 +196,16 @@ function parse(simulateItems, config, chainConfig) {
     let li = rawJson.logIndex;
     let logIndex;
     if (li !== undefined) {
+      if (li >= currentLogIndex.contents) {
+        currentLogIndex.contents = li + 1 | 0;
+      }
       logIndex = li;
     } else {
       let li$1 = currentLogIndex.contents;
       currentLogIndex.contents = li$1 + 1 | 0;
       logIndex = li$1;
     }
-    let addr = rawJson.srcAddress;
-    let srcAddress;
-    if (addr !== undefined) {
-      srcAddress = Primitive_option.valFromOption(addr);
-    } else {
-      let addr$1 = {
-        contents: "0x0000000000000000000000000000000000000000"
-      };
-      chainConfig.contracts.forEach(contract => {
-        if (contract.name !== match) {
-          return;
-        }
-        let a = contract.addresses[0];
-        if (a !== undefined) {
-          addr$1.contents = Primitive_option.valFromOption(a);
-          return;
-        }
-      });
-      srcAddress = addr$1.contents;
-    }
+    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig, chainConfig, config);
     let blockJson = rawJson.block;
     let blockJson$1 = (blockJson == null) ? undefined : Primitive_option.some(blockJson);
     let transactionJson = rawJson.transaction;
@@ -200,18 +217,14 @@ function parse(simulateItems, config, chainConfig) {
         let block = parseEvmSimulateBlock(currentBlock.contents, blockJson$1);
         match$3 = [
           block,
-          block.number,
-          block.timestamp,
-          block.hash
+          block.number
         ];
         break;
       case "fuel" :
         let block$1 = parseFuelSimulateBlock(currentBlock.contents, blockJson$1);
         match$3 = [
           block$1,
-          block$1.height,
-          block$1.time,
-          block$1.id
+          block$1.height
         ];
         break;
       case "svm" :
@@ -233,14 +246,25 @@ function parse(simulateItems, config, chainConfig) {
         break;
     }
     currentBlock.contents = blockNumber;
+    let coordinate = blockNumber.toString() + `:` + logIndex.toString();
+    let firstIndex = seenCoordinates[coordinate];
+    if (firstIndex !== undefined) {
+      Stdlib_JsError.throwWithMessage(`simulate: items at index ` + firstIndex.toString() + ` and ` + itemIndex.toString() + ` on chain ` + chainId.toString() + ` both resolve to block ` + blockNumber.toString() + `, logIndex ` + logIndex.toString() + `. Give each item a distinct logIndex (or omit logIndex so they auto-increment).`);
+    } else {
+      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,
-      eventConfig: eventConfig,
-      timestamp: match$3[2],
+      onEventRegistration: newrecord,
       chain: chain,
       blockNumber: blockNumber,
-      blockHash: match$3[3],
       logIndex: logIndex,
+      transactionIndex: 0,
       payload: {
         contractName: eventConfig.contractName,
         eventName: eventConfig.name,
@@ -248,15 +272,15 @@ function parse(simulateItems, config, chainConfig) {
         chainId: chainId,
         srcAddress: srcAddress,
         logIndex: logIndex,
-        transaction: transaction,
-        block: match$3[0]
+        transaction: Primitive_option.some(transaction),
+        block: Primitive_option.some(match$3[0])
       }
     });
   });
   return items;
 }
 
-function patchConfig(config, processConfig) {
+function patchConfig(config, processConfig, registrationsByChainId) {
   let processChains = processConfig.chains;
   if (processChains == null) {
     return config;
@@ -271,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,
@@ -317,6 +356,9 @@ export {
   fuelSimulateTransactionSchema,
   parseFuelSimulateTransaction,
   findEventConfig,
+  dummySrcAddress,
+  firstContractAddress,
+  deriveSrcAddress,
   parse,
   patchConfig,
 }

package/src/TestIndexer.res

@@ -43,6 +43,33 @@ let toIndexingAddress = (dc: InternalTable.EnvioAddresses.t): Internal.indexingA
   registrationBlock: dc.registrationBlock,
 }
 
+// All indexing addresses (config-seeded + dynamically registered) grouped by
+// chain id string, derived from the envio_addresses entities.
+let getIndexingAddressesByChain = (state: testIndexerState): dict<
+  array<Internal.indexingAddress>,
+> => {
+  let byChain = Dict.make()
+  switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
+  | Some(dcDict) =>
+    dcDict
+    ->Dict.valuesToArray
+    ->Array.forEach(entity => {
+      let dc = entity->castToEnvioAddresses
+      let chainIdStr = dc.chainId->Int.toString
+      let contracts = switch byChain->Dict.get(chainIdStr) {
+      | Some(arr) => arr
+      | None =>
+        let arr = []
+        byChain->Dict.set(chainIdStr, arr)
+        arr
+      }
+      contracts->Array.push(dc->toIndexingAddress)->ignore
+    })
+  | None => ()
+  }
+  byChain
+}
+
 let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFilter.t): JSON.t => {
   // Loads for non-entity tables (e.g. effect caches `envio_effect_<name>`) reach
   // here too. TestIndexer never persists those, so there's nothing to return —
@@ -566,22 +593,10 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
                   `Cannot access ${contract.name}.addresses while indexer.process() is running. ` ++ "Wait for process() to complete before reading contract addresses.",
                 )
               }
-              let addresses = []
-              switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
-              | Some(dcDict) =>
-                dcDict
-                ->Dict.valuesToArray
-                ->Array.forEach(
-                  entity => {
-                    let dc = entity->castToEnvioAddresses
-                    if dc.contractName === contract.name && dc.chainId === chainConfig.id {
-                      addresses->Array.push(dc->Config.EnvioAddresses.getAddress)->ignore
-                    }
-                  },
-                )
-              | None => ()
-              }
-              addresses
+              getIndexingAddressesByChain(state)
+              ->Dict.get(chainConfig.id->Int.toString)
+              ->Option.getOr([])
+              ->Array.filterMap(ia => ia.contractName === contract.name ? Some(ia.address) : None)
             },
           },
         )
@@ -652,7 +667,7 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
             Int.compare(aId, bId)
           })
 
-          // Parse and validate all chain configs upfront before starting any workers
+          // Parse and validate the block ranges upfront before starting any workers.
           let chainEntries = sortedChainKeys->Array.map(chainIdStr => {
             let rawChainConfig = rawChains->Dict.getUnsafe(chainIdStr)
             let chainId = switch chainIdStr->Int.fromString {
@@ -684,26 +699,9 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
             let chains: dict<chainConfig> = Dict.make()
             chains->Dict.set(chainIdStr, processChainConfig)
 
-            // Extract dynamic contracts from state.entities for each chain
-            let indexingAddressesByChain: dict<array<Internal.indexingAddress>> = Dict.make()
-            switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
-            | Some(dcDict) =>
-              dcDict
-              ->Dict.valuesToArray
-              ->Array.forEach(entity => {
-                let dc = entity->castToEnvioAddresses
-                let dcChainIdStr = dc.chainId->Int.toString
-                let contracts = switch indexingAddressesByChain->Dict.get(dcChainIdStr) {
-                | Some(arr) => arr
-                | None =>
-                  let arr = []
-                  indexingAddressesByChain->Dict.set(dcChainIdStr, arr)
-                  arr
-                }
-                contracts->Array.push(dc->toIndexingAddress)->ignore
-              })
-            | None => ()
-            }
+            // Rebuilt per chain so workers see contracts registered by earlier
+            // chains in the same process() call.
+            let indexingAddressesByChain = getIndexingAddressesByChain(state)
 
             let initialState = makeInitialState(
               ~config,
@@ -852,7 +850,7 @@ let initTestWorker = () => {
     // Create proxy storage that communicates with main thread
     let proxy = TestIndexerProxyStorage.make(~parentPort, ~initialState)
     let storage = TestIndexerProxyStorage.makeStorage(proxy)
-    let config = Config.loadWithoutRegistrations()
+    let config = Config.load()
     let persistence = Persistence.make(
       ~userEntities=config.userEntities,
       ~allEnums=config.allEnums,
@@ -865,8 +863,8 @@ let initTestWorker = () => {
     | Some(_) => ()
     }
 
-    let patchConfig = (config, _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 {
@@ -875,7 +873,23 @@ let initTestWorker = () => {
         config
       }
     }
-    Main.start(~persistence, ~isTest=true, ~patchConfig, ~exitAfterFirstEventBlock)->ignore
+    Main.start(~persistence, ~isTest=true, ~patchConfig, ~exitAfterFirstEventBlock)
+    ->Promise.catch(exn => {
+      // `Main.start` rejects on any fatal error: a runtime failure arrives wrapped
+      // in `Main.FatalError` (already logged), a setup throw (e.g. an invalid
+      // simulate item) arrives raw. The parent only learns of failures
+      // through the worker `error` event, which fires on an *uncaught* exception.
+      // Throwing synchronously in this catch would just reject the catch's own
+      // promise (swallowed by `ignore`); `setImmediate` re-throws outside the
+      // promise chain so it becomes uncaught and reaches the parent.
+      let toThrow = switch exn {
+      | Main.FatalError(inner) => inner
+      | _ => exn->Utils.prettifyExn
+      }
+      NodeJs.setImmediate(() => throw(toThrow))
+      Promise.resolve()
+    })
+    ->ignore
   | None =>
     Logging.error("TestIndexerWorker: No worker data provided")
     NodeJs.process->NodeJs.exitWithCode(Failure)

package/src/TestIndexer.res.mjs

@@ -12,6 +12,7 @@ import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SimulateItems from "./SimulateItems.res.mjs";
@@ -32,6 +33,27 @@ function toIndexingAddress(dc) {
   };
 }
 
+function getIndexingAddressesByChain(state) {
+  let byChain = {};
+  let dcDict = state.entities[Config.EnvioAddresses.name];
+  if (dcDict !== undefined) {
+    Object.values(dcDict).forEach(entity => {
+      let chainIdStr = entity.chain_id.toString();
+      let arr = byChain[chainIdStr];
+      let contracts;
+      if (arr !== undefined) {
+        contracts = arr;
+      } else {
+        let arr$1 = [];
+        byChain[chainIdStr] = arr$1;
+        contracts = arr$1;
+      }
+      contracts.push(toIndexingAddress(entity));
+    });
+  }
+  return byChain;
+}
+
 function handleLoad(state, tableName, filter) {
   let entityConfig = state.entityConfigs[tableName];
   if (entityConfig === undefined) {
@@ -403,17 +425,11 @@ function makeCreateTestIndexer(config, workerPath) {
             if (state.processInProgress) {
               Stdlib_JsError.throwWithMessage(`Cannot access ` + contract.name + `.addresses while indexer.process() is running. ` + "Wait for process() to complete before reading contract addresses.");
             }
-            let addresses = [];
-            let dcDict = state.entities[Config.EnvioAddresses.name];
-            if (dcDict !== undefined) {
-              Object.values(dcDict).forEach(entity => {
-                if (entity.contract_name === contract.name && entity.chain_id === chainConfig.id) {
-                  addresses.push(Config.EnvioAddresses.getAddress(entity));
-                  return;
-                }
-              });
-            }
-            return addresses;
+            return Stdlib_Array.filterMap(Stdlib_Option.getOr(getIndexingAddressesByChain(state)[chainConfig.id.toString()], []), ia => {
+              if (ia.contractName === contract.name) {
+                return Primitive_option.some(ia.address);
+              }
+            });
           }
         });
         Object.defineProperty(chainObj, contract.name, {
@@ -484,23 +500,7 @@ function makeCreateTestIndexer(config, workerPath) {
         let chainId = param[1];
         let chains = {};
         chains[param[0]] = processChainConfig;
-        let indexingAddressesByChain = {};
-        let dcDict = state.entities[Config.EnvioAddresses.name];
-        if (dcDict !== undefined) {
-          Object.values(dcDict).forEach(entity => {
-            let dcChainIdStr = entity.chain_id.toString();
-            let arr = indexingAddressesByChain[dcChainIdStr];
-            let contracts;
-            if (arr !== undefined) {
-              contracts = arr;
-            } else {
-              let arr$1 = [];
-              indexingAddressesByChain[dcChainIdStr] = arr$1;
-              contracts = arr$1;
-            }
-            contracts.push(toIndexingAddress(entity));
-          });
-        }
+        let indexingAddressesByChain = getIndexingAddressesByChain(state);
         let initialState = makeInitialState(config, chains, indexingAddressesByChain);
         return new Promise((resolve, reject) => {
           let workerData_startBlock = processChainConfig.startBlock;
@@ -605,15 +605,15 @@ function initTestWorker() {
   };
   let proxy = TestIndexerProxyStorage.make(parentPort, workerData.initialState);
   let storage = TestIndexerProxyStorage.makeStorage(proxy);
-  let config = Config.loadWithoutRegistrations();
+  let config = Config.load();
   let persistence = Persistence.make(config.userEntities, config.allEnums, storage);
   if (Env.userLogLevel !== undefined) {
     
   } 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,
@@ -640,11 +640,18 @@ function initTestWorker() {
       return config$1;
     }
   };
-  Main.start(persistence, undefined, true, exitAfterFirstEventBlock, patchConfig);
+  Stdlib_Promise.$$catch(Main.start(persistence, undefined, true, exitAfterFirstEventBlock, patchConfig), exn => {
+    let toThrow = exn.RE_EXN_ID === Main.FatalError ? exn._1 : Utils.prettifyExn(exn);
+    setImmediate(() => {
+      throw toThrow;
+    });
+    return Promise.resolve();
+  });
 }
 
 export {
   toIndexingAddress,
+  getIndexingAddressesByChain,
   handleLoad,
   handleWriteBatch,
   makeInitialState,

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 */

package/src/bindings/Performance.res

@@ -0,0 +1,7 @@
+type timeRef = float
+
+@val @scope("performance") external now: unit => timeRef = "now"
+
+let secondsSince = (from: timeRef): float => (now() -. from) /. 1000.
+
+let secondsBetween = (~from: timeRef, ~to: timeRef): float => (to -. from) /. 1000.

package/src/bindings/Performance.res.mjs

@@ -0,0 +1,21 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function secondsSince(from) {
+  return (performance.now() - from) / 1000;
+}
+
+function secondsBetween(from, to) {
+  return (to - from) / 1000;
+}
+
+function now(prim) {
+  return performance.now();
+}
+
+export {
+  now,
+  secondsSince,
+  secondsBetween,
+}
+/* No side effect */

package/src/bindings/Performance.resi

@@ -0,0 +1,7 @@
+type timeRef = float
+
+let now: unit => timeRef
+
+let secondsSince: timeRef => float
+
+let secondsBetween: (~from: timeRef, ~to: timeRef) => float

package/src/bindings/Viem.res

@@ -1,52 +1,6 @@
-type eventLog = {
-  abi: EvmTypes.Abi.t,
-  data: string,
-  topics: array<EvmTypes.Hex.t>,
-}
-
-type decodedEvent<'a> = {
-  eventName: string,
-  args: 'a,
-}
-
-@module("viem") external decodeEventLogOrThrow: eventLog => decodedEvent<'a> = "decodeEventLog"
-
 type hex = EvmTypes.Hex.t
 @module("viem") external toHex: 'a => hex = "toHex"
-@module("viem") external keccak256: hex => hex = "keccak256"
-@module("viem") external keccak256Bytes: Uint8Array.t => hex = "keccak256"
 @module("viem") external pad: hex => hex = "pad"
-@module("viem")
-external encodePacked: (~types: array<string>, ~values: array<'a>) => hex = "encodePacked"
 
 type sizeOptions = {size: int}
-@module("viem") external intToHex: (int, ~options: sizeOptions=?) => hex = "numberToHex"
 @module("viem") external bigintToHex: (bigint, ~options: sizeOptions=?) => hex = "numberToHex"
-@module("viem") external stringToHex: (string, ~options: sizeOptions=?) => hex = "stringToHex"
-@module("viem") external boolToHex: (bool, ~options: sizeOptions=?) => hex = "boolToHex"
-@module("viem") external bytesToHex: (Uint8Array.t, ~options: sizeOptions=?) => hex = "bytesToHex"
-@module("viem") external concat: array<hex> => hex = "concat"
-
-exception ParseError(exn)
-exception UnknownContractName({contractName: string})
-
-let parseLogOrThrow = (
-  contractNameAbiMapping: dict<EvmTypes.Abi.t>,
-  ~contractName,
-  ~topics,
-  ~data,
-) => {
-  switch contractNameAbiMapping->Utils.Dict.dangerouslyGetNonOption(contractName) {
-  | None => throw(UnknownContractName({contractName: contractName}))
-  | Some(abi) =>
-    let viemLog: eventLog = {
-      abi,
-      data,
-      topics,
-    }
-
-    try viemLog->decodeEventLogOrThrow catch {
-    | exn => throw(ParseError(exn))
-    }
-  }
-}