envio 2.32.1 → 2.32.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.32.1",
+  "version": "v2.32.3",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "main": "./index.js",
@@ -25,10 +25,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.32.1",
-    "envio-linux-arm64": "v2.32.1",
-    "envio-darwin-x64": "v2.32.1",
-    "envio-darwin-arm64": "v2.32.1"
+    "envio-linux-x64": "v2.32.3",
+    "envio-linux-arm64": "v2.32.3",
+    "envio-darwin-x64": "v2.32.3",
+    "envio-darwin-arm64": "v2.32.3"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.6",

package/src/InMemoryStore.gen.ts

@@ -0,0 +1,6 @@
+/* TypeScript file generated from InMemoryStore.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+export type rawEventsKey = { readonly chainId: number; readonly eventId: string };

package/src/InMemoryStore.res

@@ -0,0 +1,157 @@
+@genType
+type rawEventsKey = {
+  chainId: int,
+  eventId: string,
+}
+
+let hashRawEventsKey = (key: rawEventsKey) =>
+  EventUtils.getEventIdKeyString(~chainId=key.chainId, ~eventId=key.eventId)
+
+module EntityTables = {
+  type t = dict<InMemoryTable.Entity.t<Internal.entity>>
+  exception UndefinedEntity({entityName: string})
+  let make = (entities: array<Internal.entityConfig>): t => {
+    let init = Js.Dict.empty()
+    entities->Belt.Array.forEach(entityConfig => {
+      init->Js.Dict.set((entityConfig.name :> string), InMemoryTable.Entity.make())
+    })
+    init
+  }
+
+  let get = (type entity, self: t, ~entityName: string) => {
+    switch self->Utils.Dict.dangerouslyGetNonOption(entityName) {
+    | Some(table) =>
+      table->(
+        Utils.magic: InMemoryTable.Entity.t<Internal.entity> => InMemoryTable.Entity.t<
+          entity,
+        >
+      )
+
+    | None =>
+      UndefinedEntity({entityName: entityName})->ErrorHandling.mkLogAndRaise(
+        ~msg="Unexpected, entity InMemoryTable is undefined",
+      )
+    }
+  }
+
+  let clone = (self: t) => {
+    self
+    ->Js.Dict.entries
+    ->Belt.Array.map(((k, v)) => (k, v->InMemoryTable.Entity.clone))
+    ->Js.Dict.fromArray
+  }
+}
+
+type effectCacheInMemTable = {
+  idsToStore: array<string>,
+  mutable invalidationsCount: int,
+  dict: dict<Internal.effectOutput>,
+  effect: Internal.effect,
+}
+
+type t = {
+  rawEvents: InMemoryTable.t<rawEventsKey, InternalTable.RawEvents.t>,
+  entities: dict<InMemoryTable.Entity.t<Internal.entity>>,
+  effects: dict<effectCacheInMemTable>,
+  rollbackTargetCheckpointId: option<int>,
+}
+
+let make = (
+  ~entities: array<Internal.entityConfig>,
+  ~rollbackTargetCheckpointId=?,
+): t => {
+  rawEvents: InMemoryTable.make(~hash=hashRawEventsKey),
+  entities: EntityTables.make(entities),
+  effects: Js.Dict.empty(),
+  rollbackTargetCheckpointId,
+}
+
+let clone = (self: t) => {
+  rawEvents: self.rawEvents->InMemoryTable.clone,
+  entities: self.entities->EntityTables.clone,
+  effects: Js.Dict.map(table => {
+    idsToStore: table.idsToStore->Array.copy,
+    invalidationsCount: table.invalidationsCount,
+    dict: table.dict->Utils.Dict.shallowCopy,
+    effect: table.effect,
+  }, self.effects),
+  rollbackTargetCheckpointId: self.rollbackTargetCheckpointId,
+}
+
+let getEffectInMemTable = (inMemoryStore: t, ~effect: Internal.effect) => {
+  let key = effect.name
+  switch inMemoryStore.effects->Utils.Dict.dangerouslyGetNonOption(key) {
+  | Some(table) => table
+  | None =>
+    let table = {
+      idsToStore: [],
+      dict: Js.Dict.empty(),
+      invalidationsCount: 0,
+      effect,
+    }
+    inMemoryStore.effects->Js.Dict.set(key, table)
+    table
+  }
+}
+
+let getInMemTable = (
+  inMemoryStore: t,
+  ~entityConfig: Internal.entityConfig,
+): InMemoryTable.Entity.t<Internal.entity> => {
+  inMemoryStore.entities->EntityTables.get(~entityName=entityConfig.name)
+}
+
+let isRollingBack = (inMemoryStore: t) => inMemoryStore.rollbackTargetCheckpointId !== None
+
+let setBatchDcs = (inMemoryStore: t, ~batch: Batch.t, ~shouldSaveHistory) => {
+  let inMemTable =
+    inMemoryStore->getInMemTable(
+      ~entityConfig=InternalTable.DynamicContractRegistry.config,
+    )
+
+  let itemIdx = ref(0)
+
+  for checkpoint in 0 to batch.checkpointIds->Array.length - 1 {
+    let checkpointId = batch.checkpointIds->Js.Array2.unsafe_get(checkpoint)
+    let chainId = batch.checkpointChainIds->Js.Array2.unsafe_get(checkpoint)
+    let checkpointEventsProcessed =
+      batch.checkpointEventsProcessed->Js.Array2.unsafe_get(checkpoint)
+
+    for idx in 0 to checkpointEventsProcessed - 1 {
+      let item = batch.items->Js.Array2.unsafe_get(itemIdx.contents + idx)
+      switch item->Internal.getItemDcs {
+      | None => ()
+      | Some(dcs) =>
+        // Currently only events support contract registration, so we can cast to event item
+        let eventItem = item->Internal.castUnsafeEventItem
+        for dcIdx in 0 to dcs->Array.length - 1 {
+          let dc = dcs->Js.Array2.unsafe_get(dcIdx)
+          let entity: InternalTable.DynamicContractRegistry.t = {
+            id: InternalTable.DynamicContractRegistry.makeId(~chainId, ~contractAddress=dc.address),
+            chainId,
+            contractAddress: dc.address,
+            contractName: dc.contractName,
+            registeringEventBlockNumber: eventItem.blockNumber,
+            registeringEventLogIndex: eventItem.logIndex,
+            registeringEventBlockTimestamp: eventItem.timestamp,
+            registeringEventContractName: eventItem.eventConfig.contractName,
+            registeringEventName: eventItem.eventConfig.name,
+            registeringEventSrcAddress: eventItem.event.srcAddress,
+          }
+
+          inMemTable->InMemoryTable.Entity.set(
+            {
+              entityId: entity.id,
+              checkpointId,
+              entityUpdateAction: Set(entity->InternalTable.DynamicContractRegistry.castToInternal),
+            },
+            ~shouldSaveHistory,
+          )
+        }
+      }
+    }
+
+    itemIdx := itemIdx.contents + checkpointEventsProcessed
+  }
+}
+

package/src/InMemoryStore.res.js

@@ -0,0 +1,163 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var $$Array = require("rescript/lib/js/array.js");
+var Utils = require("./Utils.res.js");
+var Js_dict = require("rescript/lib/js/js_dict.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var EventUtils = require("./EventUtils.res.js");
+var ErrorHandling = require("./ErrorHandling.res.js");
+var InMemoryTable = require("./InMemoryTable.res.js");
+var InternalTable = require("./db/InternalTable.res.js");
+var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+
+function hashRawEventsKey(key) {
+  return EventUtils.getEventIdKeyString(key.chainId, key.eventId);
+}
+
+var UndefinedEntity = /* @__PURE__ */Caml_exceptions.create("InMemoryStore.EntityTables.UndefinedEntity");
+
+function make(entities) {
+  var init = {};
+  Belt_Array.forEach(entities, (function (entityConfig) {
+          init[entityConfig.name] = InMemoryTable.Entity.make();
+        }));
+  return init;
+}
+
+function get(self, entityName) {
+  var table = self[entityName];
+  if (table !== undefined) {
+    return table;
+  } else {
+    return ErrorHandling.mkLogAndRaise(undefined, "Unexpected, entity InMemoryTable is undefined", {
+                RE_EXN_ID: UndefinedEntity,
+                entityName: entityName
+              });
+  }
+}
+
+function clone(self) {
+  return Js_dict.fromArray(Belt_Array.map(Js_dict.entries(self), (function (param) {
+                    return [
+                            param[0],
+                            InMemoryTable.Entity.clone(param[1])
+                          ];
+                  })));
+}
+
+var EntityTables = {
+  UndefinedEntity: UndefinedEntity,
+  make: make,
+  get: get,
+  clone: clone
+};
+
+function make$1(entities, rollbackTargetCheckpointId) {
+  return {
+          rawEvents: InMemoryTable.make(hashRawEventsKey),
+          entities: make(entities),
+          effects: {},
+          rollbackTargetCheckpointId: rollbackTargetCheckpointId
+        };
+}
+
+function clone$1(self) {
+  return {
+          rawEvents: InMemoryTable.clone(self.rawEvents),
+          entities: clone(self.entities),
+          effects: Js_dict.map((function (table) {
+                  return {
+                          idsToStore: $$Array.copy(table.idsToStore),
+                          invalidationsCount: table.invalidationsCount,
+                          dict: Utils.Dict.shallowCopy(table.dict),
+                          effect: table.effect
+                        };
+                }), self.effects),
+          rollbackTargetCheckpointId: self.rollbackTargetCheckpointId
+        };
+}
+
+function getEffectInMemTable(inMemoryStore, effect) {
+  var key = effect.name;
+  var table = inMemoryStore.effects[key];
+  if (table !== undefined) {
+    return table;
+  }
+  var table$1 = {
+    idsToStore: [],
+    invalidationsCount: 0,
+    dict: {},
+    effect: effect
+  };
+  inMemoryStore.effects[key] = table$1;
+  return table$1;
+}
+
+function getInMemTable(inMemoryStore, entityConfig) {
+  return get(inMemoryStore.entities, entityConfig.name);
+}
+
+function isRollingBack(inMemoryStore) {
+  return inMemoryStore.rollbackTargetCheckpointId !== undefined;
+}
+
+function setBatchDcs(inMemoryStore, batch, shouldSaveHistory) {
+  var inMemTable = getInMemTable(inMemoryStore, InternalTable.DynamicContractRegistry.config);
+  var itemIdx = 0;
+  for(var checkpoint = 0 ,checkpoint_finish = batch.checkpointIds.length; checkpoint < checkpoint_finish; ++checkpoint){
+    var checkpointId = batch.checkpointIds[checkpoint];
+    var chainId = batch.checkpointChainIds[checkpoint];
+    var checkpointEventsProcessed = batch.checkpointEventsProcessed[checkpoint];
+    for(var idx = 0; idx < checkpointEventsProcessed; ++idx){
+      var item = batch.items[itemIdx + idx | 0];
+      var dcs = item.dcs;
+      if (dcs !== undefined) {
+        for(var dcIdx = 0 ,dcIdx_finish = dcs.length; dcIdx < dcIdx_finish; ++dcIdx){
+          var dc = dcs[dcIdx];
+          var entity_id = InternalTable.DynamicContractRegistry.makeId(chainId, dc.address);
+          var entity_registering_event_block_number = item.blockNumber;
+          var entity_registering_event_log_index = item.logIndex;
+          var entity_registering_event_block_timestamp = item.timestamp;
+          var entity_registering_event_contract_name = item.eventConfig.contractName;
+          var entity_registering_event_name = item.eventConfig.name;
+          var entity_registering_event_src_address = item.event.srcAddress;
+          var entity_contract_address = dc.address;
+          var entity_contract_name = dc.contractName;
+          var entity = {
+            id: entity_id,
+            chain_id: chainId,
+            registering_event_block_number: entity_registering_event_block_number,
+            registering_event_log_index: entity_registering_event_log_index,
+            registering_event_block_timestamp: entity_registering_event_block_timestamp,
+            registering_event_contract_name: entity_registering_event_contract_name,
+            registering_event_name: entity_registering_event_name,
+            registering_event_src_address: entity_registering_event_src_address,
+            contract_address: entity_contract_address,
+            contract_name: entity_contract_name
+          };
+          InMemoryTable.Entity.set(inMemTable, {
+                entityId: entity_id,
+                entityUpdateAction: {
+                  TAG: "Set",
+                  _0: entity
+                },
+                checkpointId: checkpointId
+              }, shouldSaveHistory, undefined);
+        }
+      }
+      
+    }
+    itemIdx = itemIdx + checkpointEventsProcessed | 0;
+  }
+}
+
+exports.hashRawEventsKey = hashRawEventsKey;
+exports.EntityTables = EntityTables;
+exports.make = make$1;
+exports.clone = clone$1;
+exports.getEffectInMemTable = getEffectInMemTable;
+exports.getInMemTable = getInMemTable;
+exports.isRollingBack = isRollingBack;
+exports.setBatchDcs = setBatchDcs;
+/* Utils Not a pure module */

package/src/LoadManager.res

@@ -7,6 +7,7 @@ module Call = {
     input: input,
     resolve: output => unit,
     reject: exn => unit,
+    mutable exn: option<exn>,
     mutable promise: promise<output>,
     mutable isLoading: bool,
   }
@@ -16,7 +17,7 @@ module Group = {
   type t = {
     // Unique calls by input as a key
     calls: dict<Call.t>,
-    load: array<Call.input> => promise<unit>,
+    load: (array<Call.input>, ~onError: (~inputKey: string, ~exn: exn) => unit) => promise<unit>,
     getUnsafeInMemory: string => Call.output,
     hasInMemory: string => bool,
   }
@@ -66,32 +67,32 @@ let schedule = async loadManager => {
       }
     })
 
-    let isSuccess = if inputsToLoad->Utils.Array.isEmpty->not {
+    if inputsToLoad->Utils.Array.isEmpty->not {
       try {
-        await group.load(inputsToLoad)
-        true
+        await group.load(inputsToLoad, ~onError=(~inputKey, ~exn) => {
+          let call = calls->Js.Dict.unsafeGet(inputKey)
+          call.exn = Some(exn)
+        })
       } catch {
       | exn => {
           let exn = exn->Utils.prettifyExn
           currentInputKeys->Array.forEach(inputKey => {
             let call = calls->Js.Dict.unsafeGet(inputKey)
-            call.reject(exn)
+            call.exn = Some(exn)
           })
-          false
         }
       }
-    } else {
-      true
     }
 
     if currentInputKeys->Utils.Array.isEmpty->not {
-      if isSuccess {
-        currentInputKeys->Js.Array2.forEach(inputKey => {
-          let call = calls->Js.Dict.unsafeGet(inputKey)
-          calls->Utils.Dict.deleteInPlace(inputKey)
-          call.resolve(group.getUnsafeInMemory(inputKey))
-        })
-      }
+      currentInputKeys->Js.Array2.forEach(inputKey => {
+        let call = calls->Js.Dict.unsafeGet(inputKey)
+        calls->Utils.Dict.deleteInPlace(inputKey)
+        switch call.exn {
+        | Some(exn) => call.reject(exn->Utils.prettifyExn)
+        | None => call.resolve(group.getUnsafeInMemory(inputKey))
+        }
+      })
 
       // Clean up executed batch to reset
       // provided load function which
@@ -145,7 +146,12 @@ let call = (
         let g: Group.t = {
           calls: Js.Dict.empty(),
           load: load->(
-            Utils.magic: (array<'input> => promise<unit>) => array<Call.input> => promise<unit>
+            Utils.magic: (
+              (array<'input>, ~onError: (~inputKey: string, ~exn: exn) => unit) => promise<unit>
+            ) => (
+              array<Call.input>,
+              ~onError: (~inputKey: string, ~exn: exn) => unit,
+            ) => promise<unit>
           ),
           getUnsafeInMemory: getUnsafeInMemory->(
             Utils.magic: (string => 'output) => string => Call.output
@@ -166,6 +172,7 @@ let call = (
             resolve,
             reject,
             promise: %raw(`null`),
+            exn: None,
             isLoading: false,
           }
           group.calls->Js.Dict.set(inputKey, call)

package/src/LoadManager.res.js

@@ -40,34 +40,35 @@ async function schedule(loadManager) {
               }
               
             });
-        var isSuccess;
-        if (Utils.$$Array.isEmpty(inputsToLoad)) {
-          isSuccess = true;
-        } else {
+        if (!Utils.$$Array.isEmpty(inputsToLoad)) {
           try {
-            await group.load(inputsToLoad);
-            isSuccess = true;
+            await group.load(inputsToLoad, (function (inputKey, exn) {
+                    var call = calls[inputKey];
+                    call.exn = exn;
+                  }));
           }
           catch (raw_exn){
             var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
             var exn$1 = Utils.prettifyExn(exn);
             Belt_Array.forEach(currentInputKeys, (function (inputKey) {
                     var call = calls[inputKey];
-                    call.reject(exn$1);
+                    call.exn = exn$1;
                   }));
-            isSuccess = false;
           }
         }
         if (Utils.$$Array.isEmpty(currentInputKeys)) {
           return ;
         }
-        if (isSuccess) {
-          currentInputKeys.forEach(function (inputKey) {
-                var call = calls[inputKey];
-                Utils.Dict.deleteInPlace(calls, inputKey);
-                call.resolve(group.getUnsafeInMemory(inputKey));
-              });
-        }
+        currentInputKeys.forEach(function (inputKey) {
+              var call = calls[inputKey];
+              Utils.Dict.deleteInPlace(calls, inputKey);
+              var exn = call.exn;
+              if (exn !== undefined) {
+                return call.reject(Utils.prettifyExn(exn));
+              } else {
+                return call.resolve(group.getUnsafeInMemory(inputKey));
+              }
+            });
         var latestGroup = groups[key];
         if (Utils.$$Array.isEmpty(Object.keys(latestGroup.calls))) {
           return Utils.Dict.deleteInPlace(groups, key);
@@ -109,6 +110,7 @@ function call(loadManager, input, key, load, hasher, shouldGroup, hasInMemory, g
             input: input,
             resolve: resolve,
             reject: reject,
+            exn: undefined,
             promise: null,
             isLoading: false
           };

package/src/bindings/Promise.res

@@ -51,6 +51,9 @@ let catch = (promise: promise<'a>, callback: exn => promise<'a>): promise<'a> =>
   })
 }
 
+@send
+external catchResolve: (t<'a>, exn => 'a) => t<'a> = "catch"
+
 @scope("Promise") @val
 external race: array<t<'a>> => t<'a> = "race"