envio 3.13.0-alpha.0 → 3.13.0

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -3,6 +3,7 @@
 import * as Source from "./Source.res.mjs";
 import * as HyperSync from "./HyperSync.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
+import * as RequestStat from "./RequestStat.res.mjs";
 import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as HyperSyncSSE from "./HyperSyncSSE.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -136,17 +137,15 @@ function make(param) {
             TAG: "WithBackoff",
             message: `Unexpected issue while fetching instructions from SVM HyperSync. Attempt a retry.`,
             backoffMillis: retry !== 0 ? 1000 * retry | 0 : 500
-          }
+          },
+          requestStats: RequestStat.single("getInstructions", pageFetchRef)
         },
         Error: new Error()
       };
     }
     let resp = match[0];
     let pageFetchTime = Performance.secondsSince(pageFetchRef);
-    let requestStats = [{
-        method: "getInstructions",
-        seconds: pageFetchTime
-      }];
+    let requestStats = RequestStat.single("getInstructions", pageFetchRef);
     let parsingRef = Performance.now();
     let parsedQueueItems = resp.items.map(item => {
       let onEventRegistration = onEventRegistrations[item.onEventRegistrationIndex];
@@ -171,7 +170,6 @@ function make(param) {
       parsedQueueItems: parsedQueueItems,
       transactionStore: Primitive_option.some(match[1]),
       blockStore: match[2],
-      fromBlockQueried: fromBlock,
       latestFetchedBlockNumber: highestSlot,
       stats: {
         "total time elapsed (s)": totalTimeElapsed,

package/src/sources/TransactionStore.res

@@ -6,16 +6,15 @@
 // in columnar form and zipped into plain JS objects on the main thread.
 type t
 
-@send external newEvm: (Core.transactionStoreCtor, ~shouldChecksum: bool) => t = "newEvm"
+@send external newEvm: Core.transactionStoreCtor => t = "newEvm"
 @send external newSvm: Core.transactionStoreCtor => t = "newSvm"
 @send external newFuel: Core.transactionStoreCtor => t = "newFuel"
 
-// The store's ecosystem is fixed here, from the chain's config. EVM carries the
-// chain's address-checksumming setting; SVM/Fuel need no extra data.
-let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool): t => {
+// The store's ecosystem is fixed here, from the chain's config.
+let make = (~ecosystem: Ecosystem.name): t => {
   let ctor = Core.getAddon().transactionStore
   switch ecosystem {
-  | Evm => ctor->newEvm(~shouldChecksum)
+  | Evm => ctor->newEvm
   | Svm => ctor->newSvm
   | Fuel => ctor->newFuel
   }
@@ -71,13 +70,17 @@ let fromSvmJs = (transactions: array<svmTxInput>, activities: array<svmActivityI
 
 // Bulk-materialise transactions off the JS thread, one row per
 // (blockNumbers[i], transactionIndices[i]) key, decoding only the fields set in
-// that row's own masks[i]. Result is aligned with the input.
+// that row's own masks[i]. Result is aligned with the input. `shouldChecksum` is
+// the caller's spelling for the addresses decoded out of the store: the rows
+// themselves are raw bytes, so a page merged from a differently configured store
+// can't fix it in.
 @send
 external materialize: (
   t,
   ~blockNumbers: array<int>,
   ~transactionIndices: array<int>,
   ~masks: array<float>,
+  ~shouldChecksum: bool,
 ) => promise<array<Internal.eventTransaction>> = "materialize"
 
 // Drop transactions for blocks at or below the given block (already processed).

package/src/sources/TransactionStore.res.mjs

@@ -3,11 +3,11 @@
 import * as Core from "../Core.res.mjs";
 import * as FieldMask from "./FieldMask.res.mjs";
 
-function make(ecosystem, shouldChecksum) {
+function make(ecosystem) {
   let ctor = Core.getAddon().TransactionStore;
   switch (ecosystem) {
     case "evm" :
-      return ctor.newEvm(shouldChecksum);
+      return ctor.newEvm();
     case "fuel" :
       return ctor.newFuel();
     case "svm" :

package/src/tui/Tui.res

@@ -248,29 +248,15 @@ module App = {
   }
 }
 
-type args = {@as("tui-off") tuiOff?: bool}
-
-type process
-@val external process: process = "process"
-@get external argv: process => 'a = "argv"
-
-type mainArgs = Yargs.parsedArgs<args>
-
-// Whether this process draws the progress display: `--tui-off` first, then
-// `ENVIO_TUI`, then whether anything is watching. A supervisor asks the same
-// question its workers would have, since it is the one drawing for the run.
-let shouldUse = (~suppressed=false) => {
-  let mainArgs: mainArgs = process->argv->Yargs.hideBin->Yargs.yargs->Yargs.argv
-  let explicitTui = switch mainArgs.tuiOff {
-  | Some(off) => Some(!off)
-  | None => Env.tuiEnvVar
-  }
+// Whether this process draws the progress display: `ENVIO_TUI` first, then
+// whether anything is watching. A supervisor asks the same question its
+// workers would have, since it is the one drawing for the run.
+let shouldUse = (~suppressed=false, ~explicitTui=Env.tuiEnvVar) =>
   switch (suppressed, explicitTui) {
   | (true, _) => false
   | (_, Some(tui)) => tui
   | (_, None) => !Envio.isNonInteractive()
   }
-}
 
 let start = (~config, ~getMetrics) => {
   let {rerender} = render(<App config getMetrics />)

package/src/tui/Tui.res.mjs

@@ -8,13 +8,12 @@ import * as React from "react";
 import * as SyncETA from "./components/SyncETA.res.mjs";
 import * as TuiData from "./components/TuiData.res.mjs";
 import * as Messages from "./components/Messages.res.mjs";
-import Yargs from "yargs/yargs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import InkBigText from "ink-big-text";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Helpers from "yargs/helpers";
 import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as JsxRuntime from "react/jsx-runtime";
 import * as BufferedProgressBar from "./components/BufferedProgressBar.res.mjs";
 
@@ -325,11 +324,9 @@ let App = {
   make: Tui$App
 };
 
-function shouldUse(suppressedOpt) {
+function shouldUse(suppressedOpt, explicitTuiOpt) {
   let suppressed = suppressedOpt !== undefined ? suppressedOpt : false;
-  let mainArgs = Yargs(Helpers.hideBin(process.argv)).argv;
-  let off = mainArgs["tui-off"];
-  let explicitTui = off !== undefined ? !off : Env.tuiEnvVar;
+  let explicitTui = explicitTuiOpt !== undefined ? Primitive_option.valFromOption(explicitTuiOpt) : Env.tuiEnvVar;
   if (suppressed) {
     return false;
   } else if (explicitTui !== undefined) {

package/src/LazyLoader.res

@@ -1,135 +0,0 @@
-exception LoaderTimeout(string)
-
-type rec asyncMap<'key, 'value> = {
-  // The number of loaded results to keep cached. (For block loading this should be our maximum block interval)
-  _cacheSize: int,
-  // The maximum number of results we can try to load simultaneously.
-  _loaderPoolSize: int,
-  // How long to wait before retrying failures
-  // TODO: Add randomized exponential back-off (outdated)
-  _retryDelayMillis: int,
-  // How long to wait before cancelling a load request
-  _timeoutMillis: int,
-  // The promises we return to callers. We satisfy them asynchronously.
-  externalPromises: Utils.Map.t<'key, promise<'value>>,
-  // The handled used to populate the external promises once we have loaded their data.
-  resolvers: Utils.Map.t<'key, 'value => unit>,
-  // The keys currently being loaded
-  inProgress: Utils.Set.t<'key>,
-  // Keys  for items that we have not started loading yet.
-  loaderQueue: SDSL.Queue.t<'key>,
-  // Keys for items that have been loaded already. Used to evict the oldest keys from cache.
-  loadedKeys: SDSL.Queue.t<'key>,
-  // The function used to load the result.
-  loaderFn: 'key => promise<'value>,
-  // Callback on load error
-  onError: option<(asyncMap<'key, 'value>, ~exn: exn) => unit>,
-}
-
-let make = (
-  ~loaderFn,
-  ~onError=?,
-  ~cacheSize: int=10_000,
-  ~loaderPoolSize: int=10,
-  ~retryDelayMillis=5_000,
-  ~timeoutMillis=300_000,
-) => // After 5 minutes (unclear what is best to do here - crash or just keep printing the error)
-{
-  _cacheSize: cacheSize,
-  _loaderPoolSize: loaderPoolSize,
-  _retryDelayMillis: retryDelayMillis,
-  _timeoutMillis: timeoutMillis,
-  externalPromises: Utils.Map.make(),
-  resolvers: Utils.Map.make(),
-  inProgress: Utils.Set.make(),
-  loaderQueue: SDSL.Queue.make(),
-  loadedKeys: SDSL.Queue.make(),
-  loaderFn,
-  onError,
-}
-
-let deleteKey: (dict<'value>, string) => unit = (_obj, _k) => %raw(`delete _obj[_k]`)
-
-// If something takes longer than this to load, reject the promise and try again
-let timeoutAfter = timeoutMillis =>
-  Utils.delay(timeoutMillis)->Promise.then(() =>
-    Promise.reject(
-      LoaderTimeout(`Query took longer than ${Int.toString(timeoutMillis / 1000)} seconds`),
-    )
-  )
-
-// Remember `k` as cached, evicting the oldest entry once the cache is full.
-let rememberLoaded = (am: asyncMap<'key, 'value>, k: 'key) => {
-  if am.loadedKeys->SDSL.Queue.push(k) > am._cacheSize {
-    switch am.loadedKeys->SDSL.Queue.pop {
-    | None => ()
-    | Some(old) =>
-      let _ = am.externalPromises->Utils.Map.delete(old)
-    }
-  }
-}
-
-let rec loadNext = async (am: asyncMap<'key, 'value>, k: 'key) => {
-  // Track that we are loading it now
-  let _ = am.inProgress->Utils.Set.add(k)
-
-  let awaitTaskPromiseAndLoadNextWithTimeout = async () => {
-    let val = await Promise.race([am.loaderFn(k), timeoutAfter(am._timeoutMillis)])
-    // Resolve the external promise
-    am.resolvers
-    ->Utils.Map.get(k)
-    ->Option.forEach(r => {
-      let _ = am.resolvers->Utils.Map.delete(k)
-      r(val)
-    })
-
-    // Track that it is no longer in progress
-    let _ = am.inProgress->Utils.Set.delete(k)
-
-    am->rememberLoaded(k)
-
-    // Load the next one, if there is anything in the queue
-    switch am.loaderQueue->SDSL.Queue.pop {
-    | None => ()
-    | Some(next) => await loadNext(am, next)
-    }
-  }
-
-  await (
-    switch await awaitTaskPromiseAndLoadNextWithTimeout() {
-    | _ => Promise.resolve()
-    | exception err =>
-      switch am.onError {
-      | None => ()
-      | Some(onError) => onError(am, ~exn=err)
-      }
-      await Utils.delay(am._retryDelayMillis)
-      awaitTaskPromiseAndLoadNextWithTimeout()
-    }
-  )
-}
-
-let get = (am: asyncMap<'key, 'value>, k: 'key): promise<'value> => {
-  switch am.externalPromises->Utils.Map.get(k) {
-  | Some(x) => x
-  | None => {
-      // Create a promise to deliver the eventual value asynchronously
-      let promise = Promise.make((resolve, _) => {
-        // Expose the resolver externally, so that we can run it from the loader.
-        let _ = am.resolvers->Utils.Map.set(k, resolve)
-      })
-      // Cache the promise to de-duplicate requests
-      let _ = am.externalPromises->Utils.Map.set(k, promise)
-
-      //   Do we have a free loader in the pool?
-      if am.inProgress->Utils.Set.size < am._loaderPoolSize {
-        loadNext(am, k)->ignore
-      } else {
-        // Queue the loader
-        let _ = am.loaderQueue->SDSL.Queue.push(k)
-      }
-
-      promise
-    }
-  }
-}

package/src/LazyLoader.res.mjs

@@ -1,118 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Utils from "./Utils.res.mjs";
-import * as JsSdsl from "js-sdsl";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-
-let LoaderTimeout = /* @__PURE__ */Primitive_exceptions.create("LazyLoader.LoaderTimeout");
-
-function make(loaderFn, onError, cacheSizeOpt, loaderPoolSizeOpt, retryDelayMillisOpt, timeoutMillisOpt) {
-  let cacheSize = cacheSizeOpt !== undefined ? cacheSizeOpt : 10000;
-  let loaderPoolSize = loaderPoolSizeOpt !== undefined ? loaderPoolSizeOpt : 10;
-  let retryDelayMillis = retryDelayMillisOpt !== undefined ? retryDelayMillisOpt : 5000;
-  let timeoutMillis = timeoutMillisOpt !== undefined ? timeoutMillisOpt : 300000;
-  return {
-    _cacheSize: cacheSize,
-    _loaderPoolSize: loaderPoolSize,
-    _retryDelayMillis: retryDelayMillis,
-    _timeoutMillis: timeoutMillis,
-    externalPromises: new Map(),
-    resolvers: new Map(),
-    inProgress: new Set(),
-    loaderQueue: new JsSdsl.Queue(),
-    loadedKeys: new JsSdsl.Queue(),
-    loaderFn: loaderFn,
-    onError: onError
-  };
-}
-
-function deleteKey(_obj, _k) {
-  ((delete _obj[_k]));
-}
-
-function timeoutAfter(timeoutMillis) {
-  return Utils.delay(timeoutMillis).then(() => Promise.reject({
-    RE_EXN_ID: LoaderTimeout,
-    _1: `Query took longer than ` + (timeoutMillis / 1000 | 0).toString() + ` seconds`
-  }));
-}
-
-function rememberLoaded(am, k) {
-  if (am.loadedKeys.push(k) <= am._cacheSize) {
-    return;
-  }
-  let old = am.loadedKeys.pop();
-  if (old !== undefined) {
-    am.externalPromises.delete(Primitive_option.valFromOption(old));
-    return;
-  }
-}
-
-async function loadNext(am, k) {
-  am.inProgress.add(k);
-  let awaitTaskPromiseAndLoadNextWithTimeout = async () => {
-    let val = await Promise.race([
-      am.loaderFn(k),
-      timeoutAfter(am._timeoutMillis)
-    ]);
-    Stdlib_Option.forEach(am.resolvers.get(k), r => {
-      am.resolvers.delete(k);
-      r(val);
-    });
-    am.inProgress.delete(k);
-    rememberLoaded(am, k);
-    let next = am.loaderQueue.pop();
-    if (next !== undefined) {
-      return await loadNext(am, Primitive_option.valFromOption(next));
-    }
-  };
-  let tmp;
-  let exit = 0;
-  let val;
-  try {
-    val = await awaitTaskPromiseAndLoadNextWithTimeout();
-    exit = 1;
-  } catch (raw_err) {
-    let err = Primitive_exceptions.internalToException(raw_err);
-    let onError = am.onError;
-    if (onError !== undefined) {
-      onError(am, err);
-    }
-    await Utils.delay(am._retryDelayMillis);
-    tmp = awaitTaskPromiseAndLoadNextWithTimeout();
-  }
-  if (exit === 1) {
-    tmp = Promise.resolve();
-  }
-  return await tmp;
-}
-
-function get(am, k) {
-  let x = am.externalPromises.get(k);
-  if (x !== undefined) {
-    return x;
-  }
-  let promise = new Promise((resolve, param) => {
-    am.resolvers.set(k, resolve);
-  });
-  am.externalPromises.set(k, promise);
-  if (am.inProgress.size < am._loaderPoolSize) {
-    loadNext(am, k);
-  } else {
-    am.loaderQueue.push(k);
-  }
-  return promise;
-}
-
-export {
-  LoaderTimeout,
-  make,
-  deleteKey,
-  timeoutAfter,
-  rememberLoaded,
-  loadNext,
-  get,
-}
-/* Utils Not a pure module */

package/src/bindings/SDSL.res

@@ -1,12 +0,0 @@
-module Queue = {
-  type t<'a>
-
-  @module("js-sdsl") @new external make: unit => t<'a> = "Queue"
-
-  type containerSize = int
-  @send external size: t<'a> => containerSize = "size"
-  @send external push: (t<'a>, 'a) => containerSize = "push"
-  @send external pop: t<'a> => option<'a> = "pop"
-  //Returns the front item without popping it
-  @send external front: t<'a> => option<'a> = "front"
-}

package/src/bindings/SDSL.res.mjs

@@ -1,9 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-let Queue = {};
-
-export {
-  Queue,
-}
-/* No side effect */

package/src/bindings/Yargs.res

@@ -1,8 +0,0 @@
-type arg = string
-
-type parsedArgs<'a> = 'a
-
-@module("yargs/yargs") external yargs: array<arg> => parsedArgs<'a> = "default"
-@module("yargs/helpers") external hideBin: array<arg> => array<arg> = "hideBin"
-
-@get external argv: parsedArgs<'a> => 'a = "argv"

package/src/bindings/Yargs.res.mjs

@@ -1,2 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/sources/Rpc.res

@@ -1,185 +0,0 @@
-type rpcError = {code: int, message: string}
-exception JsonRpcError(rpcError)
-
-let makeRpcRoute = (method: string, paramsSchema, resultSchema) => {
-  let idSchema = S.literal(1)
-  let versionSchema = S.literal("2.0")
-  Rest.route(() => {
-    method: Post,
-    path: "",
-    input: s => {
-      let _ = s.field("method", S.literal(method))
-      let _ = s.field("id", idSchema)
-      let _ = s.field("jsonrpc", versionSchema)
-      s.field("params", paramsSchema)
-    },
-    responses: [
-      s => {
-        let _ = s.field("jsonrpc", versionSchema)
-        let _ = s.field("id", idSchema)
-        s.field("result", resultSchema)
-      },
-    ],
-  })
-}
-
-let jsonRpcFetcher: Rest.ApiFetcher.t = async args => {
-  let response = await Rest.ApiFetcher.default(args)
-  let data: {..} = response.data->Obj.magic
-  switch data["error"]->Nullable.toOption {
-  | Some(error) =>
-    throw(
-      JsonRpcError({
-        code: error["code"],
-        message: error["message"],
-      }),
-    )
-  | None => response
-  }
-}
-
-let makeClient = (url, ~headers=?) => {
-  let fetcher: Rest.ApiFetcher.t = switch headers {
-  | None => jsonRpcFetcher
-  | Some(customHeaders) =>
-    async args => {
-      let headers = switch args.headers {
-      | Some(headers) => headers
-      | None => Dict.make()
-      }
-      customHeaders->Dict.forEachWithKey((value, key) => headers->Dict.set(key, value->Obj.magic))
-      await jsonRpcFetcher({...args, headers: Some(headers)})
-    }
-  }
-  Rest.client(url, ~fetcher)
-}
-
-type hex = string
-let makeHexSchema = fromStr =>
-  S.string->S.transform(s => {
-    parser: str =>
-      switch str->fromStr {
-      | Some(v) => v
-      | None => s.fail("The string is not valid hex")
-      },
-    serializer: value => value->Viem.toHex->(Utils.magic: EvmTypes.Hex.t => 'a),
-  })
-
-let hexBigintSchema: S.schema<bigint> = makeHexSchema(BigInt.fromString)
-external number: string => int = "Number"
-let hexIntSchema: S.schema<int> = makeHexSchema(v => v->number->Some)
-
-external parseFloat: string => float = "Number"
-let decimalFloatSchema: S.schema<float> = S.string->S.transform(s => {
-  parser: str => {
-    let v = parseFloat(str)
-    if Float.isNaN(v) {
-      s.fail("The string is not a valid decimal number")
-    } else {
-      v
-    }
-  },
-})
-
-module GetLogs = {
-  type log = {
-    address: Address.t,
-    topics: array<hex>,
-    blockNumber: int,
-    transactionHash: hex,
-    transactionIndex: int,
-    blockHash: hex,
-    logIndex: int,
-  }
-}
-
-module GetBlockByNumber = {
-  type block = {
-    difficulty: option<bigint>,
-    extraData: hex,
-    gasLimit: bigint,
-    gasUsed: bigint,
-    hash: hex,
-    logsBloom: hex,
-    mutable miner: Address.t,
-    mixHash: option<hex>,
-    nonce: option<bigint>,
-    number: int,
-    parentHash: hex,
-    receiptsRoot: hex,
-    sha3Uncles: hex,
-    size: bigint,
-    stateRoot: hex,
-    timestamp: int,
-    totalDifficulty: option<bigint>,
-    transactions: array<JSON.t>,
-    transactionsRoot: hex,
-    uncles: option<array<hex>>,
-  }
-
-  let blockSchema = S.object((s): block => {
-    difficulty: s.field("difficulty", S.null(hexBigintSchema)),
-    extraData: s.field("extraData", S.string),
-    gasLimit: s.field("gasLimit", hexBigintSchema),
-    gasUsed: s.field("gasUsed", hexBigintSchema),
-    hash: s.field("hash", S.string),
-    logsBloom: s.field("logsBloom", S.string),
-    miner: s.field("miner", Address.schema),
-    mixHash: s.field("mixHash", S.null(S.string)),
-    nonce: s.field("nonce", S.null(hexBigintSchema)),
-    number: s.field("number", hexIntSchema),
-    parentHash: s.field("parentHash", S.string),
-    receiptsRoot: s.field("receiptsRoot", S.string),
-    sha3Uncles: s.field("sha3Uncles", S.string),
-    size: s.field("size", hexBigintSchema),
-    stateRoot: s.field("stateRoot", S.string),
-    timestamp: s.field("timestamp", hexIntSchema),
-    totalDifficulty: s.field("totalDifficulty", S.null(hexBigintSchema)),
-    transactions: s.field("transactions", S.array(S.json(~validate=false))),
-    transactionsRoot: s.field("transactionsRoot", S.string),
-    uncles: s.field("uncles", S.null(S.array(S.string))),
-  })
-
-  let paramsSchema = S.tuple(s =>
-    {
-      "blockNumber": s.item(0, hexIntSchema),
-      "includeTransactions": s.item(1, S.bool),
-    }
-  )
-
-  let resultSchema = S.null(blockSchema)
-
-  let route = makeRpcRoute("eth_getBlockByNumber", paramsSchema, resultSchema)
-
-  let rawRoute = makeRpcRoute("eth_getBlockByNumber", paramsSchema, S.null(S.json(~validate=false)))
-}
-
-module GetTransactionByHash = {
-  let rawRoute = makeRpcRoute(
-    "eth_getTransactionByHash",
-    S.tuple1(S.string),
-    S.null(S.json(~validate=false)),
-  )
-}
-
-module GetTransactionReceipt = {
-  let rawRoute = makeRpcRoute(
-    "eth_getTransactionReceipt",
-    S.tuple1(S.string),
-    S.null(S.json(~validate=false)),
-  )
-}
-
-let getBlock = async (~client: Rest.client, ~blockNumber: int) => {
-  await GetBlockByNumber.route->Rest.fetch(
-    {"blockNumber": blockNumber, "includeTransactions": false},
-    ~client,
-  )
-}
-
-let getRawBlock = async (~client: Rest.client, ~blockNumber: int) => {
-  await GetBlockByNumber.rawRoute->Rest.fetch(
-    {"blockNumber": blockNumber, "includeTransactions": false},
-    ~client,
-  )
-}