envio 2.27.6 → 2.28.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.27.6",
+  "version": "v2.28.0-alpha.1",
   "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.27.6",
-    "envio-linux-arm64": "v2.27.6",
-    "envio-darwin-x64": "v2.27.6",
-    "envio-darwin-arm64": "v2.27.6"
+    "envio-linux-x64": "v2.28.0-alpha.1",
+    "envio-linux-arm64": "v2.28.0-alpha.1",
+    "envio-darwin-x64": "v2.28.0-alpha.1",
+    "envio-darwin-arm64": "v2.28.0-alpha.1"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.5",

package/rescript.json

@@ -13,6 +13,9 @@
     "in-source": true
   },
   "gentypeconfig": {
+    "shims": {
+      "Js": "Js"
+    },
     "generatedFileExtension": ".gen.ts"
   },
   "bs-dependencies": ["rescript-schema"],

package/src/Hasura.res

@@ -218,28 +218,149 @@ let createEntityRelationship = async (
   }
 }
 
+let trackMeta = async (~auth, ~endpoint, ~pgSchema) => {
+  try {
+    // Track EnvioMeta logical model with scalar fields
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type": "pg_track_logical_model","args": {"source": "default","name":"EnvioMeta","fields":[{"name":"chainId","type":"int"},{"name":"startBlock","type":"int"},{"name":"endBlock","type":"int","nullable":true},{"name":"bufferBlock","type":"int"},{"name":"readyAt","type":"timestamptz","nullable":true},{"name":"firstEventBlock","type":"int","nullable":true},{"name":"eventsProcessed","type":"int"},{"name":"isReady","type":"bool"}]}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura EnvioMeta logical model created`
+    | AlreadyDone => `Hasura EnvioMeta logical model already created`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+
+    // Update _meta native query to return hardcoded block object
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type":"pg_track_native_query","args":{"type":"query","source":"default","root_field_name":"_meta","arguments":{},"returns":"EnvioMeta","code":"SELECT \\\"${(#id: InternalTable.Chains.field :> string)}\\\" AS \\\"chainId\\\", \\\"${(#start_block: InternalTable.Chains.field :> string)}\\\" AS \\\"startBlock\\\", \\\"${(#end_block: InternalTable.Chains.field :> string)}\\\" AS \\\"endBlock\\\", \\\"${(#buffer_block: InternalTable.Chains.field :> string)}\\\" AS \\\"bufferBlock\\\", \\\"${(#ready_at: InternalTable.Chains.field :> string)}\\\" AS \\\"readyAt\\\", \\\"${(#first_event_block: InternalTable.Chains.field :> string)}\\\" AS \\\"firstEventBlock\\\", \\\"${(#events_processed: InternalTable.Chains.field :> string)}\\\" AS \\\"eventsProcessed\\\", (\\\"${(#ready_at: InternalTable.Chains.field :> string)}\\\" IS NOT NULL) AS \\\"isReady\\\" FROM \\\"${pgSchema}\\\".\\\"${InternalTable.Chains.table.tableName}\\\" ORDER BY \\\"id\\\""}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura _meta native query created`
+    | AlreadyDone => `Hasura _meta native query already created`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+
+    // Add public select permissions for EnvioMeta logical model
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type": "pg_create_logical_model_select_permission", "args": {"source": "default", "name": "EnvioMeta", "role": "public", "permission": {"columns": "*", "filter": {}}}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura _meta public select permission created`
+    | AlreadyDone => `Hasura _meta public select permission already exists`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type": "pg_track_logical_model","args": {"source": "default","name":"chain_metadata","fields":[{"name":"block_height","type":"int"},{"name":"chain_id","type":"int"},{"name":"end_block","type":"int"},{"name":"first_event_block_number","type":"int"},{"name":"is_hyper_sync","type":"boolean"},{"name":"latest_fetched_block_number","type":"int"},{"name":"latest_processed_block","type":"int"},{"name":"num_batches_fetched","type":"int"},{"name":"num_events_processed","type":"int"},{"name":"start_block","type":"int"},{"name":"timestamp_caught_up_to_head_or_endblock","type":"timestamptz"}]}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura chain_metadata logical model created`
+    | AlreadyDone => `Hasura chain_metadata logical model already created`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+
+    // Need this to keep backwards compatibility,
+    // since it's used on Hosted Service
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type":"pg_track_native_query","args":{"type":"query","source":"default","root_field_name":"chain_metadata","arguments":{},"returns":"chain_metadata","code":"SELECT \\\"${(#source_block: InternalTable.Chains.field :> string)}\\\" AS \\\"block_height\\\", \\\"${(#id: InternalTable.Chains.field :> string)}\\\" AS \\\"chain_id\\\", \\\"${(#end_block: InternalTable.Chains.field :> string)}\\\", \\\"${(#first_event_block: InternalTable.Chains.field :> string)}\\\" AS \\\"first_event_block_number\\\", \\\"${(#_is_hyper_sync: InternalTable.Chains.field :> string)}\\\" AS \\\"is_hyper_sync\\\", \\\"${(#buffer_block: InternalTable.Chains.field :> string)}\\\" AS \\\"latest_fetched_block_number\\\", \\\"${(#_latest_processed_block: InternalTable.Chains.field :> string)}\\\" AS \\\"latest_processed_block\\\", \\\"${(#_num_batches_fetched: InternalTable.Chains.field :> string)}\\\" AS \\\"num_batches_fetched\\\", \\\"${(#events_processed: InternalTable.Chains.field :> string)}\\\" AS \\\"num_events_processed\\\", \\\"${(#start_block: InternalTable.Chains.field :> string)}\\\", \\\"${(#ready_at: InternalTable.Chains.field :> string)}\\\" AS \\\"timestamp_caught_up_to_head_or_endblock\\\" FROM \\\"${pgSchema}\\\".\\\"${InternalTable.Chains.table.tableName}\\\""}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura chain_metadata native query created`
+    | AlreadyDone => `Hasura chain_metadata native query already created`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+
+    // Add public select permissions for chain_metadata logical model
+    let result = await rawBodyRoute->Rest.fetch(
+      {
+        "auth": auth,
+        "bodyString": `{"type": "pg_create_logical_model_select_permission", "args": {"source": "default", "name": "chain_metadata", "role": "public", "permission": {"columns": "*", "filter": {}}}}`,
+      },
+      ~client=Rest.client(endpoint),
+    )
+    let msg = switch result {
+    | QuerySucceeded => `Hasura chain_metadata public select permission created`
+    | AlreadyDone => `Hasura chain_metadata public select permission already exists`
+    }
+    Logging.trace({
+      "msg": msg,
+    })
+  } catch {
+  | exn =>
+    Logging.error({
+      "msg": `EE808: There was an issue setting up _meta field in hasura - indexing may still work - but you may have issues querying the data in hasura.`,
+      "err": exn->Utils.prettifyExn,
+    })
+  }
+}
+
 let trackDatabase = async (
   ~endpoint,
   ~auth,
   ~pgSchema,
-  ~allStaticTables,
-  ~allEntityTables,
+  ~userEntities: array<Internal.entityConfig>,
   ~aggregateEntities,
   ~responseLimit,
   ~schema,
 ) => {
+  let trackOnlyInternalTableNames = [
+    InternalTable.Chains.table.tableName,
+    InternalTable.EventSyncState.table.tableName,
+    InternalTable.PersistedState.table.tableName,
+    InternalTable.EndOfBlockRangeScannedData.table.tableName,
+    InternalTable.DynamicContractRegistry.table.tableName,
+  ]
+  let exposedInternalTableNames = [InternalTable.RawEvents.table.tableName]
+  let userTableNames = userEntities->Js.Array2.map(entity => entity.table.tableName)
+
   Logging.info("Tracking tables in Hasura")
 
   let _ = await clearHasuraMetadata(~endpoint, ~auth)
-  let tableNames =
-    [allStaticTables, allEntityTables]
-    ->Belt.Array.concatMany
-    ->Js.Array2.map(({tableName}: Table.table) => tableName)
 
-  await trackTables(~endpoint, ~auth, ~pgSchema, ~tableNames)
+  await trackTables(
+    ~endpoint,
+    ~auth,
+    ~pgSchema,
+    ~tableNames=[
+      exposedInternalTableNames,
+      trackOnlyInternalTableNames,
+      userTableNames,
+    ]->Belt.Array.concatMany,
+  )
 
   let _ =
-    await tableNames
+    await [exposedInternalTableNames, userTableNames]
+    ->Belt.Array.concatMany
     ->Js.Array2.map(tableName =>
       createSelectPermissions(
         ~endpoint,
@@ -251,11 +372,11 @@ let trackDatabase = async (
       )
     )
     ->Js.Array2.concatMany(
-      allEntityTables->Js.Array2.map(table => {
-        let {tableName} = table
+      userEntities->Js.Array2.map(entityConfig => {
+        let {tableName} = entityConfig.table
         [
           //Set array relationships
-          table
+          entityConfig.table
           ->Table.getDerivedFromFields
           ->Js.Array2.map(derivedFromField => {
             //determines the actual name of the underlying relational field (if it's an entity mapping then suffixes _id for eg.)
@@ -275,7 +396,7 @@ let trackDatabase = async (
             )
           }),
           //Set object relationships
-          table
+          entityConfig.table
           ->Table.getLinkedEntityFields
           ->Js.Array2.map(((field, linkedEntityName)) => {
             createEntityRelationship(
@@ -294,4 +415,6 @@ let trackDatabase = async (
       }),
     )
     ->Promise.all
+
+  await trackMeta(~auth, ~endpoint, ~pgSchema)
 }

package/src/Hasura.res.js

@@ -7,6 +7,7 @@ var Utils = require("./Utils.res.js");
 var Schema = require("./db/Schema.res.js");
 var Logging = require("./Logging.res.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var InternalTable = require("./db/InternalTable.res.js");
 var Caml_splice_call = require("rescript/lib/js/caml_splice_call.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
@@ -203,31 +204,111 @@ async function createEntityRelationship(pgSchema, endpoint, auth, tableName, rel
   }
 }
 
-async function trackDatabase(endpoint, auth, pgSchema, allStaticTables, allEntityTables, aggregateEntities, responseLimit, schema) {
+async function trackMeta(auth, endpoint, pgSchema) {
+  try {
+    var result = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\": \"pg_track_logical_model\",\"args\": {\"source\": \"default\",\"name\":\"EnvioMeta\",\"fields\":[{\"name\":\"chainId\",\"type\":\"int\"},{\"name\":\"startBlock\",\"type\":\"int\"},{\"name\":\"endBlock\",\"type\":\"int\",\"nullable\":true},{\"name\":\"bufferBlock\",\"type\":\"int\"},{\"name\":\"readyAt\",\"type\":\"timestamptz\",\"nullable\":true},{\"name\":\"firstEventBlock\",\"type\":\"int\",\"nullable\":true},{\"name\":\"eventsProcessed\",\"type\":\"int\"},{\"name\":\"isReady\",\"type\":\"bool\"}]}}"
+        }, Rest.client(endpoint, undefined));
+    var msg;
+    msg = result === "QuerySucceeded" ? "Hasura EnvioMeta logical model created" : "Hasura EnvioMeta logical model already created";
+    Logging.trace({
+          msg: msg
+        });
+    var result$1 = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\":\"pg_track_native_query\",\"args\":{\"type\":\"query\",\"source\":\"default\",\"root_field_name\":\"_meta\",\"arguments\":{},\"returns\":\"EnvioMeta\",\"code\":\"SELECT \\\"" + "id" + "\\\" AS \\\"chainId\\\", \\\"" + "start_block" + "\\\" AS \\\"startBlock\\\", \\\"" + "end_block" + "\\\" AS \\\"endBlock\\\", \\\"" + "buffer_block" + "\\\" AS \\\"bufferBlock\\\", \\\"" + "ready_at" + "\\\" AS \\\"readyAt\\\", \\\"" + "first_event_block" + "\\\" AS \\\"firstEventBlock\\\", \\\"" + "events_processed" + "\\\" AS \\\"eventsProcessed\\\", (\\\"" + "ready_at" + "\\\" IS NOT NULL) AS \\\"isReady\\\" FROM \\\"" + pgSchema + "\\\".\\\"" + InternalTable.Chains.table.tableName + "\\\" ORDER BY \\\"id\\\"\"}}"
+        }, Rest.client(endpoint, undefined));
+    var msg$1;
+    msg$1 = result$1 === "QuerySucceeded" ? "Hasura _meta native query created" : "Hasura _meta native query already created";
+    Logging.trace({
+          msg: msg$1
+        });
+    var result$2 = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\": \"pg_create_logical_model_select_permission\", \"args\": {\"source\": \"default\", \"name\": \"EnvioMeta\", \"role\": \"public\", \"permission\": {\"columns\": \"*\", \"filter\": {}}}}"
+        }, Rest.client(endpoint, undefined));
+    var msg$2;
+    msg$2 = result$2 === "QuerySucceeded" ? "Hasura _meta public select permission created" : "Hasura _meta public select permission already exists";
+    Logging.trace({
+          msg: msg$2
+        });
+    var result$3 = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\": \"pg_track_logical_model\",\"args\": {\"source\": \"default\",\"name\":\"chain_metadata\",\"fields\":[{\"name\":\"block_height\",\"type\":\"int\"},{\"name\":\"chain_id\",\"type\":\"int\"},{\"name\":\"end_block\",\"type\":\"int\"},{\"name\":\"first_event_block_number\",\"type\":\"int\"},{\"name\":\"is_hyper_sync\",\"type\":\"boolean\"},{\"name\":\"latest_fetched_block_number\",\"type\":\"int\"},{\"name\":\"latest_processed_block\",\"type\":\"int\"},{\"name\":\"num_batches_fetched\",\"type\":\"int\"},{\"name\":\"num_events_processed\",\"type\":\"int\"},{\"name\":\"start_block\",\"type\":\"int\"},{\"name\":\"timestamp_caught_up_to_head_or_endblock\",\"type\":\"timestamptz\"}]}}"
+        }, Rest.client(endpoint, undefined));
+    var msg$3;
+    msg$3 = result$3 === "QuerySucceeded" ? "Hasura chain_metadata logical model created" : "Hasura chain_metadata logical model already created";
+    Logging.trace({
+          msg: msg$3
+        });
+    var result$4 = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\":\"pg_track_native_query\",\"args\":{\"type\":\"query\",\"source\":\"default\",\"root_field_name\":\"chain_metadata\",\"arguments\":{},\"returns\":\"chain_metadata\",\"code\":\"SELECT \\\"" + "source_block" + "\\\" AS \\\"block_height\\\", \\\"" + "id" + "\\\" AS \\\"chain_id\\\", \\\"" + "end_block" + "\\\", \\\"" + "first_event_block" + "\\\" AS \\\"first_event_block_number\\\", \\\"" + "_is_hyper_sync" + "\\\" AS \\\"is_hyper_sync\\\", \\\"" + "buffer_block" + "\\\" AS \\\"latest_fetched_block_number\\\", \\\"" + "_latest_processed_block" + "\\\" AS \\\"latest_processed_block\\\", \\\"" + "_num_batches_fetched" + "\\\" AS \\\"num_batches_fetched\\\", \\\"" + "events_processed" + "\\\" AS \\\"num_events_processed\\\", \\\"" + "start_block" + "\\\", \\\"" + "ready_at" + "\\\" AS \\\"timestamp_caught_up_to_head_or_endblock\\\" FROM \\\"" + pgSchema + "\\\".\\\"" + InternalTable.Chains.table.tableName + "\\\"\"}}"
+        }, Rest.client(endpoint, undefined));
+    var msg$4;
+    msg$4 = result$4 === "QuerySucceeded" ? "Hasura chain_metadata native query created" : "Hasura chain_metadata native query already created";
+    Logging.trace({
+          msg: msg$4
+        });
+    var result$5 = await Rest.$$fetch(rawBodyRoute, {
+          auth: auth,
+          bodyString: "{\"type\": \"pg_create_logical_model_select_permission\", \"args\": {\"source\": \"default\", \"name\": \"chain_metadata\", \"role\": \"public\", \"permission\": {\"columns\": \"*\", \"filter\": {}}}}"
+        }, Rest.client(endpoint, undefined));
+    var msg$5;
+    msg$5 = result$5 === "QuerySucceeded" ? "Hasura chain_metadata public select permission created" : "Hasura chain_metadata public select permission already exists";
+    return Logging.trace({
+                msg: msg$5
+              });
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return Logging.error({
+                msg: "EE808: There was an issue setting up _meta field in hasura - indexing may still work - but you may have issues querying the data in hasura.",
+                err: Utils.prettifyExn(exn)
+              });
+  }
+}
+
+async function trackDatabase(endpoint, auth, pgSchema, userEntities, aggregateEntities, responseLimit, schema) {
+  var trackOnlyInternalTableNames = [
+    InternalTable.Chains.table.tableName,
+    InternalTable.EventSyncState.table.tableName,
+    InternalTable.PersistedState.table.tableName,
+    InternalTable.EndOfBlockRangeScannedData.table.tableName,
+    InternalTable.DynamicContractRegistry.table.tableName
+  ];
+  var exposedInternalTableNames = [InternalTable.RawEvents.table.tableName];
+  var userTableNames = userEntities.map(function (entity) {
+        return entity.table.tableName;
+      });
   Logging.info("Tracking tables in Hasura");
   await clearHasuraMetadata(endpoint, auth);
-  var tableNames = Belt_Array.concatMany([
-          allStaticTables,
-          allEntityTables
-        ]).map(function (param) {
-        return param.tableName;
-      });
-  await trackTables(endpoint, auth, pgSchema, tableNames);
-  await Promise.all(Caml_splice_call.spliceObjApply(tableNames.map(function (tableName) {
+  await trackTables(endpoint, auth, pgSchema, Belt_Array.concatMany([
+            exposedInternalTableNames,
+            trackOnlyInternalTableNames,
+            userTableNames
+          ]));
+  await Promise.all(Caml_splice_call.spliceObjApply(Belt_Array.concatMany([
+                  exposedInternalTableNames,
+                  userTableNames
+                ]).map(function (tableName) {
                 return createSelectPermissions(auth, endpoint, tableName, pgSchema, responseLimit, aggregateEntities);
-              }), "concat", [allEntityTables.map(function (table) {
-                  var tableName = table.tableName;
+              }), "concat", [userEntities.map(function (entityConfig) {
+                  var match = entityConfig.table;
+                  var tableName = match.tableName;
                   return [
-                            Table.getDerivedFromFields(table).map(function (derivedFromField) {
+                            Table.getDerivedFromFields(entityConfig.table).map(function (derivedFromField) {
                                   var relationalFieldName = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(schema, derivedFromField));
                                   return createEntityRelationship(pgSchema, endpoint, auth, tableName, "array", relationalFieldName, derivedFromField.fieldName, derivedFromField.derivedFromEntity, true);
                                 }),
-                            Table.getLinkedEntityFields(table).map(function (param) {
+                            Table.getLinkedEntityFields(entityConfig.table).map(function (param) {
                                   var field = param[0];
                                   return createEntityRelationship(pgSchema, endpoint, auth, tableName, "object", field.fieldName, field.fieldName, param[1], false);
                                 })
                           ].flat(1);
                 })]));
+  return await trackMeta(auth, endpoint, pgSchema);
 }
 
 exports.auth = auth;
@@ -240,5 +321,6 @@ exports.clearHasuraMetadata = clearHasuraMetadata;
 exports.trackTables = trackTables;
 exports.createSelectPermissions = createSelectPermissions;
 exports.createEntityRelationship = createEntityRelationship;
+exports.trackMeta = trackMeta;
 exports.trackDatabase = trackDatabase;
 /* Rest Not a pure module */

package/src/Internal.res

@@ -176,13 +176,16 @@ let fuelTransferParamsSchema = S.schema(s => {
 })
 
 type entity = private {id: string}
-type entityConfig = {
+type genericEntityConfig<'entity> = {
   name: string,
-  schema: S.t<entity>,
-  rowsSchema: S.t<array<entity>>,
+  schema: S.t<'entity>,
+  rowsSchema: S.t<array<'entity>>,
   table: Table.table,
-  entityHistory: EntityHistory.t<entity>,
+  entityHistory: EntityHistory.t<'entity>,
 }
+type entityConfig = genericEntityConfig<entity>
+external fromGenericEntityConfig: genericEntityConfig<'entity> => entityConfig = "%identity"
+
 type enum
 type enumConfig<'enum> = {
   name: string,

package/src/InternalConfig.res

@@ -0,0 +1,20 @@
+// TODO: rename the file to Config.res after finishing the migration from codegen
+// And turn it into PublicConfig instead
+// For internal use we should create Indexer.res with a stateful type
+
+type contract = {
+  name: string,
+  abi: EvmTypes.Abi.t,
+  addresses: array<Address.t>,
+  events: array<Internal.eventConfig>,
+  startBlock: option<int>,
+}
+
+type chain = {
+  id: int,
+  startBlock: int,
+  endBlock?: int,
+  confirmedBlockThreshold: int,
+  contracts: array<contract>,
+  sources: array<Source.t>,
+}

package/src/InternalConfig.res.js

@@ -0,0 +1,2 @@
+// 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/Js.shim.ts

@@ -0,0 +1,11 @@
+export type Json_t =
+  | string
+  | boolean
+  | number
+  | null
+  | { [key: string]: Json_t }
+  | Json_t[];
+
+export type t = unknown;
+
+export type Exn_t = Error;

package/src/LoadManager.res

@@ -66,9 +66,10 @@ let schedule = async loadManager => {
       }
     })
 
-    if inputsToLoad->Utils.Array.isEmpty->not {
+    let isSuccess = if inputsToLoad->Utils.Array.isEmpty->not {
       try {
         await group.load(inputsToLoad)
+        true
       } catch {
       | exn => {
           let exn = exn->Utils.prettifyExn
@@ -76,16 +77,21 @@ let schedule = async loadManager => {
             let call = calls->Js.Dict.unsafeGet(inputKey)
             call.reject(exn)
           })
+          false
         }
       }
+    } else {
+      true
     }
 
     if currentInputKeys->Utils.Array.isEmpty->not {
-      currentInputKeys->Js.Array2.forEach(inputKey => {
-        let call = calls->Js.Dict.unsafeGet(inputKey)
-        calls->Utils.Dict.deleteInPlace(inputKey)
-        call.resolve(group.getUnsafeInMemory(inputKey))
-      })
+      if isSuccess {
+        currentInputKeys->Js.Array2.forEach(inputKey => {
+          let call = calls->Js.Dict.unsafeGet(inputKey)
+          calls->Utils.Dict.deleteInPlace(inputKey)
+          call.resolve(group.getUnsafeInMemory(inputKey))
+        })
+      }
 
       // Clean up executed batch to reset
       // provided load function which

package/src/LoadManager.res.js

@@ -40,9 +40,13 @@ async function schedule(loadManager) {
               }
               
             });
-        if (!Utils.$$Array.isEmpty(inputsToLoad)) {
+        var isSuccess;
+        if (Utils.$$Array.isEmpty(inputsToLoad)) {
+          isSuccess = true;
+        } else {
           try {
             await group.load(inputsToLoad);
+            isSuccess = true;
           }
           catch (raw_exn){
             var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
@@ -51,16 +55,19 @@ async function schedule(loadManager) {
                     var call = calls[inputKey];
                     call.reject(exn$1);
                   }));
+            isSuccess = false;
           }
         }
         if (Utils.$$Array.isEmpty(currentInputKeys)) {
           return ;
         }
-        currentInputKeys.forEach(function (inputKey) {
-              var call = calls[inputKey];
-              Utils.Dict.deleteInPlace(calls, inputKey);
-              call.resolve(group.getUnsafeInMemory(inputKey));
-            });
+        if (isSuccess) {
+          currentInputKeys.forEach(function (inputKey) {
+                var call = calls[inputKey];
+                Utils.Dict.deleteInPlace(calls, inputKey);
+                call.resolve(group.getUnsafeInMemory(inputKey));
+              });
+        }
         var latestGroup = groups[key];
         if (Utils.$$Array.isEmpty(Object.keys(latestGroup.calls))) {
           return Utils.Dict.deleteInPlace(groups, key);

package/src/Persistence.res

@@ -13,6 +13,12 @@ type effectCacheRecord = {
   mutable count: int,
 }
 
+type initialState = {
+  cleanRun: bool,
+  cache: dict<effectCacheRecord>,
+  chains: array<InternalTable.Chains.t>,
+}
+
 type operator = [#">" | #"="]
 
 type storage = {
@@ -22,10 +28,11 @@ type storage = {
   // Should initialize the storage so we can start interacting with it
   // Eg create connection, schema, tables, etc.
   initialize: (
+    ~chainConfigs: array<InternalConfig.chain>=?,
     ~entities: array<Internal.entityConfig>=?,
-    ~generalTables: array<Table.table>=?,
     ~enums: array<Internal.enumConfig<Internal.enum>>=?,
-  ) => promise<unit>,
+  ) => promise<initialState>,
+  loadInitialState: unit => promise<initialState>,
   @raises("StorageError")
   loadByIdsOrThrow: 'item. (
     ~ids: array<string>,
@@ -55,10 +62,6 @@ type storage = {
   ) => promise<unit>,
   // This is to download cache from the database to .envio/cache
   dumpEffectCache: unit => promise<unit>,
-  // This is not good, but the function does two things:
-  // - Gets info about existing cache tables
-  // - if withUpload is true, it also populates the cache from .envio/cache to the database
-  restoreEffectCache: (~withUpload: bool) => promise<array<effectCacheRecord>>,
 }
 
 exception StorageError({message: string, reason: exn})
@@ -66,11 +69,10 @@ exception StorageError({message: string, reason: exn})
 type storageStatus =
   | Unknown
   | Initializing(promise<unit>)
-  | Ready({cleanRun: bool, cache: dict<effectCacheRecord>})
+  | Ready(initialState)
 
 type t = {
   userEntities: array<Internal.entityConfig>,
-  staticTables: array<Table.table>,
   allEntities: array<Internal.entityConfig>,
   allEnums: array<Internal.enumConfig<Internal.enum>>,
   mutable storageStatus: storageStatus,
@@ -86,18 +88,15 @@ let entityHistoryActionEnumConfig: Internal.enumConfig<EntityHistory.RowAction.t
 
 let make = (
   ~userEntities,
-  ~dcRegistryEntityConfig,
   // TODO: Should only pass userEnums and create internal config in runtime
   ~allEnums,
-  ~staticTables,
   ~storage,
 ) => {
-  let allEntities = userEntities->Js.Array2.concat([dcRegistryEntityConfig])
+  let allEntities = userEntities->Js.Array2.concat([InternalTable.DynamicContractRegistry.config])
   let allEnums =
     allEnums->Js.Array2.concat([entityHistoryActionEnumConfig->Internal.fromGenericEnumConfig])
   {
     userEntities,
-    staticTables,
     allEntities,
     allEnums,
     storageStatus: Unknown,
@@ -106,17 +105,7 @@ let make = (
 }
 
 let init = {
-  let loadInitialCache = async (persistence, ~withUpload) => {
-    let effectCacheRecords = await persistence.storage.restoreEffectCache(~withUpload)
-    let cache = Js.Dict.empty()
-    effectCacheRecords->Js.Array2.forEach(record => {
-      Prometheus.EffectCacheCount.set(~count=record.count, ~effectName=record.effectName)
-      cache->Js.Dict.set(record.effectName, record)
-    })
-    cache
-  }
-
-  async (persistence, ~reset=false) => {
+  async (persistence, ~chainConfigs, ~reset=false) => {
     try {
       let shouldRun = switch persistence.storageStatus {
       | Unknown => true
@@ -135,17 +124,14 @@ let init = {
         if reset || !(await persistence.storage.isInitialized()) {
           Logging.info(`Initializing the indexer storage...`)
 
-          await persistence.storage.initialize(
+          let initialState = await persistence.storage.initialize(
             ~entities=persistence.allEntities,
-            ~generalTables=persistence.staticTables,
             ~enums=persistence.allEnums,
+            ~chainConfigs,
           )
 
           Logging.info(`The indexer storage is ready. Uploading cache...`)
-          persistence.storageStatus = Ready({
-            cleanRun: true,
-            cache: await loadInitialCache(persistence, ~withUpload=true),
-          })
+          persistence.storageStatus = Ready(initialState)
         } else if (
           // In case of a race condition,
           // we want to set the initial status to Ready only once.
@@ -155,10 +141,7 @@ let init = {
           }
         ) {
           Logging.info(`The indexer storage is ready.`)
-          persistence.storageStatus = Ready({
-            cleanRun: false,
-            cache: await loadInitialCache(persistence, ~withUpload=false),
-          })
+          persistence.storageStatus = Ready(await persistence.storage.loadInitialState())
         }
         resolveRef.contents()
       }
@@ -178,6 +161,15 @@ let getInitializedStorageOrThrow = persistence => {
   }
 }
 
+let getInitializedState = persistence => {
+  switch persistence.storageStatus {
+  | Unknown
+  | Initializing(_) =>
+    Js.Exn.raiseError(`Failed to access the initial state. The Persistence layer is not initialized.`)
+  | Ready(initialState) => initialState
+  }
+}
+
 let setEffectCacheOrThrow = async (persistence, ~effect: Internal.effect, ~items) => {
   switch persistence.storageStatus {
   | Unknown