envio 3.0.0-alpha.21 → 3.0.0-alpha.22

package/src/TestIndexerProxyStorage.res

@@ -1,12 +1,10 @@
-open Belt
-
 // Message types for communication between worker and main thread
 type requestId = int
 
 // Serializable change with entity as JSON (for worker thread messaging)
 @tag("type")
 type serializableChange =
-  | @as("SET") Set({entityId: string, entity: Js.Json.t, checkpointId: bigint})
+  | @as("SET") Set({entityId: string, entity: JSON.t, checkpointId: bigint})
   | @as("DELETE") Delete({entityId: string, checkpointId: bigint})
 
 type serializableEntityUpdate = {
@@ -28,7 +26,7 @@ type workerPayload =
   LoadByField({
       tableName: string,
       fieldName: string,
-      fieldValue: Js.Json.t,
+      fieldValue: JSON.t,
       operator: Persistence.operator,
     })
   | @as("writeBatch")
@@ -37,14 +35,14 @@ type workerPayload =
       checkpointIds: array<bigint>,
       checkpointChainIds: array<int>,
       checkpointBlockNumbers: array<int>,
-      checkpointBlockHashes: array<Js.Null.t<string>>,
+      checkpointBlockHashes: array<Null.t<string>>,
       checkpointEventsProcessed: array<int>,
     })
 
 // Main thread -> Worker payloads
 @tag("type")
 type mainPayload =
-  | @as("response") Response({data: Js.Json.t})
+  | @as("response") Response({data: JSON.t})
   | @as("error") Error({message: string})
 
 // Message wrapper with id
@@ -54,7 +52,7 @@ type mainMessage = message<mainPayload>
 
 // Pending request tracker
 type pendingRequest = {
-  resolve: Js.Json.t => unit,
+  resolve: JSON.t => unit,
   reject: exn => unit,
 }
 
@@ -69,7 +67,7 @@ let make = (~parentPort, ~initialState): t => {
   let proxy = {
     parentPort,
     initialState,
-    pendingRequests: Js.Dict.empty(),
+    pendingRequests: Dict.make(),
     requestCounter: 0,
   }
 
@@ -80,9 +78,9 @@ let make = (~parentPort, ~initialState): t => {
       idStr,
     ) {
     | Some(pending) => pending
-    | None => Js.Exn.raiseError(`TestIndexer: No pending request found for id ${idStr}`)
+    | None => JsError.throwWithMessage(`TestIndexer: No pending request found for id ${idStr}`)
     }
-    Js.Dict.unsafeDeleteKey(proxy.pendingRequests->Obj.magic, idStr)
+    Dict.delete(proxy.pendingRequests->Obj.magic, idStr)
 
     switch msg.payload {
     | Response({data}) => resolve(data)
@@ -98,18 +96,19 @@ let nextRequestId = (proxy: t): requestId => {
   proxy.requestCounter
 }
 
-let sendRequest = (proxy: t, ~payload: workerPayload): promise<Js.Json.t> => {
+let sendRequest = (proxy: t, ~payload: workerPayload): promise<JSON.t> => {
   Promise.make((resolve, reject) => {
     let id = proxy->nextRequestId
-    proxy.pendingRequests->Js.Dict.set(id->Int.toString, {resolve, reject})
+    proxy.pendingRequests->Dict.set(id->Int.toString, {resolve, reject})
     proxy.parentPort->NodeJs.WorkerThreads.postMessage({id, payload})
   })
 }
 
 let makeStorage = (proxy: t): Persistence.storage => {
+  name: "test-proxy",
   isInitialized: async () => true,
   initialize: async (~chainConfigs as _=?, ~entities as _=?, ~enums as _=?) => {
-    Js.Exn.raiseError(
+    JsError.throwWithMessage(
       "TestIndexer: initialize should not be called. Use resumeInitialState instead.",
     )
   },
@@ -188,17 +187,17 @@ let makeStorage = (proxy: t): Persistence.storage => {
   pruneStaleEntityHistory: async (~entityName as _, ~entityIndex as _, ~safeCheckpointId as _) =>
     (),
   getRollbackTargetCheckpoint: async (~reorgChainId as _, ~lastKnownValidBlockNumber as _) => {
-    Js.Exn.raiseError(
+    JsError.throwWithMessage(
       "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
     )
   },
   getRollbackProgressDiff: async (~rollbackTargetCheckpointId as _) => {
-    Js.Exn.raiseError(
+    JsError.throwWithMessage(
       "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
     )
   },
   getRollbackData: async (~entityConfig as _, ~rollbackTargetCheckpointId as _) => {
-    Js.Exn.raiseError(
+    JsError.throwWithMessage(
       "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
     )
   },

package/src/TestIndexerProxyStorage.res.mjs

@@ -1,29 +1,28 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
-import * as Js_dict from "rescript/lib/es6/js_dict.js";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
 function make(parentPort, initialState) {
-  var proxy = {
+  let proxy = {
     parentPort: parentPort,
     initialState: initialState,
     pendingRequests: {},
     requestCounter: 0
   };
-  parentPort.on("message", (function (msg) {
-          var idStr = String(msg.id);
-          var pending = proxy.pendingRequests[idStr];
-          var match = pending !== undefined ? pending : Js_exn.raiseError("TestIndexer: No pending request found for id " + idStr);
-          Js_dict.unsafeDeleteKey(proxy.pendingRequests, idStr);
-          var match$1 = msg.payload;
-          if (match$1.type === "response") {
-            return match.resolve(match$1.data);
-          } else {
-            return match.reject(new Error(match$1.message));
-          }
-        }));
+  parentPort.on("message", msg => {
+    let idStr = msg.id.toString();
+    let pending = proxy.pendingRequests[idStr];
+    let match = pending !== undefined ? pending : Stdlib_JsError.throwWithMessage(`TestIndexer: No pending request found for id ` + idStr);
+    Stdlib_Dict.$$delete(proxy.pendingRequests, idStr);
+    let match$1 = msg.payload;
+    if (match$1.type === "response") {
+      return match.resolve(match$1.data);
+    } else {
+      return match.reject(new Error(match$1.message));
+    }
+  });
   return proxy;
 }
 
@@ -33,119 +32,96 @@ function nextRequestId(proxy) {
 }
 
 function sendRequest(proxy, payload) {
-  return new Promise((function (resolve, reject) {
-                var id = nextRequestId(proxy);
-                proxy.pendingRequests[String(id)] = {
-                  resolve: resolve,
-                  reject: reject
-                };
-                proxy.parentPort.postMessage({
-                      id: id,
-                      payload: payload
-                    });
-              }));
+  return new Promise((resolve, reject) => {
+    let id = nextRequestId(proxy);
+    proxy.pendingRequests[id.toString()] = {
+      resolve: resolve,
+      reject: reject
+    };
+    proxy.parentPort.postMessage({
+      id: id,
+      payload: payload
+    });
+  });
 }
 
 function makeStorage(proxy) {
   return {
-          isInitialized: (async function () {
-              return true;
-            }),
-          initialize: (async function (param, param$1, param$2) {
-              return Js_exn.raiseError("TestIndexer: initialize should not be called. Use resumeInitialState instead.");
-            }),
-          resumeInitialState: (async function () {
-              return proxy.initialState;
-            }),
-          loadByIdsOrThrow: (async function (ids, table, rowsSchema) {
-              var response = await sendRequest(proxy, {
-                    type: "loadByIds",
-                    tableName: table.tableName,
-                    ids: ids
-                  });
-              return S$RescriptSchema.parseOrThrow(response, rowsSchema);
-            }),
-          loadByFieldOrThrow: (async function (fieldName, fieldSchema, fieldValue, operator, table, rowsSchema) {
-              var response = await sendRequest(proxy, {
-                    type: "loadByField",
-                    tableName: table.tableName,
-                    fieldName: fieldName,
-                    fieldValue: S$RescriptSchema.reverseConvertToJsonOrThrow(fieldValue, fieldSchema),
-                    operator: operator
-                  });
-              return S$RescriptSchema.parseOrThrow(response, rowsSchema);
-            }),
-          dumpEffectCache: (async function () {
-              
-            }),
-          reset: (async function () {
-              
-            }),
-          setChainMeta: (async function (param) {
-              
-            }),
-          pruneStaleCheckpoints: (async function (param) {
-              
-            }),
-          pruneStaleEntityHistory: (async function (param, param$1, param$2) {
-              
-            }),
-          getRollbackTargetCheckpoint: (async function (param, param$1) {
-              return Js_exn.raiseError("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.");
-            }),
-          getRollbackProgressDiff: (async function (param) {
-              return Js_exn.raiseError("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.");
-            }),
-          getRollbackData: (async function (param, param$1) {
-              return Js_exn.raiseError("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.");
-            }),
-          writeBatch: (async function (batch, param, param$1, param$2, param$3, param$4, param$5, updatedEntities) {
-              var serializableEntities = Belt_Array.map(updatedEntities, (function (param) {
-                      var entityConfig = param.entityConfig;
-                      var encodeChange = function (change) {
-                        if (change.type === "SET") {
-                          return {
-                                  type: "SET",
-                                  entityId: change.entityId,
-                                  entity: S$RescriptSchema.reverseConvertToJsonOrThrow(change.entity, entityConfig.schema),
-                                  checkpointId: change.checkpointId
-                                };
-                        } else {
-                          return {
-                                  type: "DELETE",
-                                  entityId: change.entityId,
-                                  checkpointId: change.checkpointId
-                                };
-                        }
-                      };
-                      return {
-                              entityName: entityConfig.name,
-                              updates: Belt_Array.map(param.updates, (function (update) {
-                                      return {
-                                              latestChange: encodeChange(update.latestChange),
-                                              history: Belt_Array.map(update.history, encodeChange),
-                                              containsRollbackDiffChange: update.containsRollbackDiffChange
-                                            };
-                                    }))
-                            };
-                    }));
-              await sendRequest(proxy, {
-                    type: "writeBatch",
-                    updatedEntities: serializableEntities,
-                    checkpointIds: batch.checkpointIds,
-                    checkpointChainIds: batch.checkpointChainIds,
-                    checkpointBlockNumbers: batch.checkpointBlockNumbers,
-                    checkpointBlockHashes: batch.checkpointBlockHashes,
-                    checkpointEventsProcessed: batch.checkpointEventsProcessed
-                  });
-            })
+    name: "test-proxy",
+    isInitialized: async () => true,
+    initialize: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called. Use resumeInitialState instead."),
+    resumeInitialState: async () => proxy.initialState,
+    loadByIdsOrThrow: async (ids, table, rowsSchema) => {
+      let response = await sendRequest(proxy, {
+        type: "loadByIds",
+        tableName: table.tableName,
+        ids: ids
+      });
+      return S$RescriptSchema.parseOrThrow(response, rowsSchema);
+    },
+    loadByFieldOrThrow: async (fieldName, fieldSchema, fieldValue, operator, table, rowsSchema) => {
+      let response = await sendRequest(proxy, {
+        type: "loadByField",
+        tableName: table.tableName,
+        fieldName: fieldName,
+        fieldValue: S$RescriptSchema.reverseConvertToJsonOrThrow(fieldValue, fieldSchema),
+        operator: operator
+      });
+      return S$RescriptSchema.parseOrThrow(response, rowsSchema);
+    },
+    dumpEffectCache: async () => {},
+    reset: async () => {},
+    setChainMeta: async param => {},
+    pruneStaleCheckpoints: async param => {},
+    pruneStaleEntityHistory: async (param, param$1, param$2) => {},
+    getRollbackTargetCheckpoint: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config."),
+    getRollbackProgressDiff: async param => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config."),
+    getRollbackData: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config."),
+    writeBatch: async (batch, param, param$1, param$2, param$3, param$4, param$5, updatedEntities) => {
+      let serializableEntities = updatedEntities.map(param => {
+        let entityConfig = param.entityConfig;
+        let encodeChange = change => {
+          if (change.type === "SET") {
+            return {
+              type: "SET",
+              entityId: change.entityId,
+              entity: S$RescriptSchema.reverseConvertToJsonOrThrow(change.entity, entityConfig.schema),
+              checkpointId: change.checkpointId
+            };
+          } else {
+            return {
+              type: "DELETE",
+              entityId: change.entityId,
+              checkpointId: change.checkpointId
+            };
+          }
+        };
+        return {
+          entityName: entityConfig.name,
+          updates: param.updates.map(update => ({
+            latestChange: encodeChange(update.latestChange),
+            history: update.history.map(encodeChange),
+            containsRollbackDiffChange: update.containsRollbackDiffChange
+          }))
         };
+      });
+      await sendRequest(proxy, {
+        type: "writeBatch",
+        updatedEntities: serializableEntities,
+        checkpointIds: batch.checkpointIds,
+        checkpointChainIds: batch.checkpointChainIds,
+        checkpointBlockNumbers: batch.checkpointBlockNumbers,
+        checkpointBlockHashes: batch.checkpointBlockHashes,
+        checkpointEventsProcessed: batch.checkpointEventsProcessed
+      });
+    }
+  };
 }
 
 export {
-  make ,
-  nextRequestId ,
-  sendRequest ,
-  makeStorage ,
+  make,
+  nextRequestId,
+  sendRequest,
+  makeStorage,
 }
 /* S-RescriptSchema Not a pure module */

package/src/TestIndexerWorker.res

@@ -0,0 +1,4 @@
+// Spawned by `TestIndexer.makeCreateTestIndexer` as a sibling of `Api.res.mjs`
+// so `import.meta.url` resolves inside the envio package.
+
+TestIndexer.initTestWorker()

package/src/TestIndexerWorker.res.mjs

@@ -0,0 +1,7 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as TestIndexer from "./TestIndexer.res.mjs";
+
+TestIndexer.initTestWorker();
+
+/*  Not a pure module */

package/src/Throttler.res

@@ -19,13 +19,13 @@ let make = (~intervalMillis: int, ~logger) => {
 let rec startInternal = async (throttler: t) => {
   switch throttler {
   | {scheduled: Some(fn), isRunning: false, isAwaitingInterval: false} =>
-    let timeSinceLastRun = Js.Date.now() -. throttler.lastRunTimeMillis
+    let timeSinceLastRun = Date.now() -. throttler.lastRunTimeMillis
 
     //Only execute if we are passed the interval
     if timeSinceLastRun >= throttler.intervalMillis {
       throttler.isRunning = true
       throttler.scheduled = None
-      throttler.lastRunTimeMillis = Js.Date.now()
+      throttler.lastRunTimeMillis = Date.now()
 
       switch await fn() {
       | exception exn =>
@@ -43,7 +43,7 @@ let rec startInternal = async (throttler: t) => {
     } else {
       //Store isAwaitingInterval in state so that timers don't continuously get created
       throttler.isAwaitingInterval = true
-      let _ = Js.Global.setTimeout(() => {
+      let _ = setTimeout(() => {
         throttler.isAwaitingInterval = false
         throttler->startInternal->ignore
       }, Belt.Int.fromFloat(throttler.intervalMillis -. timeSinceLastRun))

package/src/Throttler.res.mjs

@@ -2,52 +2,51 @@
 
 import * as Pino from "./bindings/Pino.res.mjs";
 import * as Utils from "./Utils.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function make(intervalMillis, logger) {
   return {
-          lastRunTimeMillis: 0,
-          isRunning: false,
-          isAwaitingInterval: false,
-          scheduled: undefined,
-          intervalMillis: intervalMillis,
-          logger: logger
-        };
+    lastRunTimeMillis: 0,
+    isRunning: false,
+    isAwaitingInterval: false,
+    scheduled: undefined,
+    intervalMillis: intervalMillis,
+    logger: logger
+  };
 }
 
 async function startInternal(throttler) {
-  var match = throttler.isRunning;
+  let match = throttler.isRunning;
   if (match) {
-    return ;
+    return;
   }
-  var match$1 = throttler.isAwaitingInterval;
+  let match$1 = throttler.isAwaitingInterval;
   if (match$1) {
-    return ;
+    return;
   }
-  var fn = throttler.scheduled;
+  let fn = throttler.scheduled;
   if (fn === undefined) {
-    return ;
+    return;
   }
-  var timeSinceLastRun = Date.now() - throttler.lastRunTimeMillis;
+  let timeSinceLastRun = Date.now() - throttler.lastRunTimeMillis;
   if (timeSinceLastRun >= throttler.intervalMillis) {
     throttler.isRunning = true;
     throttler.scheduled = undefined;
     throttler.lastRunTimeMillis = Date.now();
     try {
       await fn();
-    }
-    catch (raw_exn){
-      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
       throttler.logger.error(Pino.createPinoMessageWithError("Scheduled action failed in throttler", Utils.prettifyExn(exn)));
     }
     throttler.isRunning = false;
     return await startInternal(throttler);
   }
   throttler.isAwaitingInterval = true;
-  setTimeout((function () {
-          throttler.isAwaitingInterval = false;
-          startInternal(throttler);
-        }), throttler.intervalMillis - timeSinceLastRun | 0);
+  setTimeout(() => {
+    throttler.isAwaitingInterval = false;
+    startInternal(throttler);
+  }, throttler.intervalMillis - timeSinceLastRun | 0);
 }
 
 function schedule(throttler, fn) {
@@ -56,7 +55,7 @@ function schedule(throttler, fn) {
 }
 
 export {
-  make ,
-  schedule ,
+  make,
+  schedule,
 }
 /* Pino Not a pure module */

package/src/Time.res

@@ -35,7 +35,7 @@ let rec retryAsyncWithExponentialBackOff = async (
         ~msg=`Failure. Max retries ${retryCount->Belt.Int.toString}/${maxRetries->Belt.Int.toString} exceeded`,
       )
       ->ErrorHandling.log
-      await Promise.reject(exn->Js.Exn.anyToExnInternal)
+      await Promise.reject(exn->JsExn.anyToExnInternal)
     }
   }
 }

package/src/Time.res.mjs

@@ -3,39 +3,36 @@
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function resolvePromiseAfterDelay(delayMilliseconds) {
-  return Utils.delay(delayMilliseconds);
-}
+let resolvePromiseAfterDelay = Utils.delay;
 
 async function retryAsyncWithExponentialBackOff(backOffMillisOpt, multiplicativeOpt, retryCountOpt, maxRetriesOpt, logger, f) {
-  var backOffMillis = backOffMillisOpt !== undefined ? backOffMillisOpt : 100;
-  var multiplicative = multiplicativeOpt !== undefined ? multiplicativeOpt : 4;
-  var retryCount = retryCountOpt !== undefined ? retryCountOpt : 0;
-  var maxRetries = maxRetriesOpt !== undefined ? maxRetriesOpt : 5;
+  let backOffMillis = backOffMillisOpt !== undefined ? backOffMillisOpt : 100;
+  let multiplicative = multiplicativeOpt !== undefined ? multiplicativeOpt : 4;
+  let retryCount = retryCountOpt !== undefined ? retryCountOpt : 0;
+  let maxRetries = maxRetriesOpt !== undefined ? maxRetriesOpt : 5;
   try {
     return await f();
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
     if (retryCount < maxRetries) {
-      var nextRetryCount = retryCount + 1 | 0;
-      var log = retryCount === 0 ? Logging.childTrace : Logging.childWarn;
+      let nextRetryCount = retryCount + 1 | 0;
+      let log = retryCount === 0 ? Logging.childTrace : Logging.childWarn;
       log(logger, {
-            msg: "Retrying query " + String(nextRetryCount) + "/" + String(maxRetries) + " in " + String(backOffMillis) + "ms - waiting for correct result.",
-            err: Utils.prettifyExn(exn)
-          });
+        msg: `Retrying query ` + String(nextRetryCount) + `/` + String(maxRetries) + ` in ` + String(backOffMillis) + `ms - waiting for correct result.`,
+        err: Utils.prettifyExn(exn)
+      });
       await Utils.delay(backOffMillis);
-      return await retryAsyncWithExponentialBackOff(Math.imul(backOffMillis, multiplicative), multiplicative, nextRetryCount, maxRetries, logger, f);
+      return await retryAsyncWithExponentialBackOff(backOffMillis * multiplicative | 0, multiplicative, nextRetryCount, maxRetries, logger, f);
     }
-    ErrorHandling.log(ErrorHandling.make(exn, logger, "Failure. Max retries " + String(retryCount) + "/" + String(maxRetries) + " exceeded"));
-    return await Promise.reject(Caml_js_exceptions.internalToOCamlException(exn));
+    ErrorHandling.log(ErrorHandling.make(exn, logger, `Failure. Max retries ` + String(retryCount) + `/` + String(maxRetries) + ` exceeded`));
+    return await Promise.reject(Primitive_exceptions.internalToException(exn));
   }
 }
 
 export {
-  resolvePromiseAfterDelay ,
-  retryAsyncWithExponentialBackOff ,
+  resolvePromiseAfterDelay,
+  retryAsyncWithExponentialBackOff,
 }
 /* Utils Not a pure module */

package/src/TopicFilter.res

@@ -1,7 +1,7 @@
 let toTwosComplement = (num: bigint, ~bytesLen: int) => {
-  let maxValue = 1n->BigInt.Bitwise.shift_left(BigInt.fromInt(bytesLen * 8))
+  let maxValue = 1n->BigInt.shiftLeft(BigInt.fromInt(bytesLen * 8))
   let mask = maxValue->BigInt.sub(1n)
-  num->BigInt.add(maxValue)->BigInt.Bitwise.logand(mask)
+  num->BigInt.add(maxValue)->BigInt.bitwiseAnd(mask)
 }
 
 let fromSignedBigInt = val => {
@@ -23,5 +23,5 @@ 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 => bytes)->Viem.bytesToHex(~options={size: 32})
+  bytes->(Utils.magic: bytesHex => Uint8Array.t)->Viem.bytesToHex(~options={size: 32})
 let fromBool: bool => hex = b => b->Viem.boolToHex(~options={size: 32})