envio 3.3.2 → 3.5.0-alpha.0

package/src/TestIndexer.res.mjs

@@ -1,29 +1,28 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Env from "./Env.res.mjs";
-import * as Main from "./Main.res.mjs";
-import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as Process from "process";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as IndexerLoop from "./IndexerLoop.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
+import * as IndexerState from "./IndexerState.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as HandlerLoader from "./HandlerLoader.res.mjs";
 import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SimulateItems from "./SimulateItems.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
-import * as Worker_threads from "worker_threads";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-import * as TestIndexerProxyStorage from "./TestIndexerProxyStorage.res.mjs";
 
 function toIndexingAddress(dc) {
   return {
@@ -55,32 +54,18 @@ function getIndexingAddressesByChain(state) {
 }
 
 function handleLoad(state, tableName, filter) {
-  let entityConfig = state.entityConfigs[tableName];
-  if (entityConfig === undefined) {
+  let match = state.entityConfigs[tableName];
+  if (match === undefined) {
     return [];
   }
   let entityDict = Stdlib_Option.getOr(state.entities[tableName], {});
-  let results = [];
-  let parseLeaf = (fieldName, fieldValue, isArray) => {
-    let queryField = Table.queryFields(entityConfig.table)[fieldName];
-    let queryField$1 = queryField !== undefined ? queryField : Stdlib_JsError.throwWithMessage(`Field ` + fieldName + ` not found in entity ` + tableName);
-    return S$RescriptSchema.convertOrThrow(fieldValue, isArray ? queryField$1.arrayFieldSchema : queryField$1.fieldSchema);
-  };
-  let filter$1 = EntityFilter.mapValues(filter, parseLeaf);
-  Object.values(entityDict).forEach(entity => {
-    if (!EntityFilter.matches(filter$1, entity)) {
-      return;
-    }
-    let jsonEntity = S$RescriptSchema.reverseConvertToJsonOrThrow(entity, entityConfig.schema);
-    results.push(jsonEntity);
-  });
-  return results;
+  return Object.values(entityDict).filter(entity => EntityFilter.matches(filter, entity));
 }
 
 function handleWriteBatch(state, updatedEntities, checkpointIds, checkpointChainIds, checkpointBlockNumbers, checkpointEventsProcessed) {
   let changesByCheckpoint = {};
   updatedEntities.forEach(param => {
-    let entityName = param.entityName;
+    let entityName = param.entityConfig.name;
     let dict = state.entities[entityName];
     let entityDict;
     if (dict !== undefined) {
@@ -90,65 +75,40 @@ function handleWriteBatch(state, updatedEntities, checkpointIds, checkpointChain
       state.entities[entityName] = dict$1;
       entityDict = dict$1;
     }
-    let entityConfig = state.entityConfigs[entityName];
+    let entityChangeFor = checkpointId => {
+      let checkpointKey = checkpointId.toString();
+      let changes = changesByCheckpoint[checkpointKey];
+      let entityChanges;
+      if (changes !== undefined) {
+        entityChanges = changes;
+      } else {
+        let changes$1 = {};
+        changesByCheckpoint[checkpointKey] = changes$1;
+        entityChanges = changes$1;
+      }
+      let change = entityChanges[entityName];
+      if (change !== undefined) {
+        return change;
+      }
+      let change_sets = [];
+      let change_deleted = [];
+      let change$1 = {
+        sets: change_sets,
+        deleted: change_deleted
+      };
+      entityChanges[entityName] = change$1;
+      return change$1;
+    };
     let processChange = change => {
       if (change.type === "SET") {
-        let parsedEntity = S$RescriptSchema.parseOrThrow(change.entity, entityConfig.schema);
-        entityDict[change.entityId] = parsedEntity;
-        let checkpointKey = change.checkpointId.toString();
-        let changes = changesByCheckpoint[checkpointKey];
-        let entityChanges;
-        if (changes !== undefined) {
-          entityChanges = changes;
-        } else {
-          let changes$1 = {};
-          changesByCheckpoint[checkpointKey] = changes$1;
-          entityChanges = changes$1;
-        }
-        let change$1 = entityChanges[entityName];
-        let entityChange;
-        if (change$1 !== undefined) {
-          entityChange = change$1;
-        } else {
-          let change_sets = [];
-          let change_deleted = [];
-          let change$2 = {
-            sets: change_sets,
-            deleted: change_deleted
-          };
-          entityChanges[entityName] = change$2;
-          entityChange = change$2;
-        }
-        entityChange.sets.push(parsedEntity);
+        let entity = change.entity;
+        entityDict[change.entityId] = entity;
+        entityChangeFor(change.checkpointId).sets.push(entity);
         return;
       }
       let entityId = change.entityId;
       Stdlib_Dict.$$delete(entityDict, entityId);
-      let checkpointKey$1 = change.checkpointId.toString();
-      let changes$2 = changesByCheckpoint[checkpointKey$1];
-      let entityChanges$1;
-      if (changes$2 !== undefined) {
-        entityChanges$1 = changes$2;
-      } else {
-        let changes$3 = {};
-        changesByCheckpoint[checkpointKey$1] = changes$3;
-        entityChanges$1 = changes$3;
-      }
-      let change$3 = entityChanges$1[entityName];
-      let entityChange$1;
-      if (change$3 !== undefined) {
-        entityChange$1 = change$3;
-      } else {
-        let change_sets$1 = [];
-        let change_deleted$1 = [];
-        let change$4 = {
-          sets: change_sets$1,
-          deleted: change_deleted$1
-        };
-        entityChanges$1[entityName] = change$4;
-        entityChange$1 = change$4;
-      }
-      entityChange$1.deleted.push(entityId);
+      entityChangeFor(change.checkpointId).deleted.push(entityId);
     };
     param.changes.forEach(processChange);
   });
@@ -186,7 +146,7 @@ function handleWriteBatch(state, updatedEntities, checkpointIds, checkpointChain
         if (deleted.length !== 0) {
           entityObj$1["deleted"] = deleted;
         }
-        change[entityName] = entityObj$1;
+        change[Utils.$$String.capitalize(entityName)] = entityObj$1;
       });
     }
     state.processChanges.push(change);
@@ -292,12 +252,16 @@ function parseBlockRange(chainIdStr, config, rawChainConfig, progressBlock) {
   };
 }
 
+function copyEntity(entity) {
+  return Utils.Dict.shallowCopy(entity);
+}
+
 function getEntityFromState(state, entityConfig, entityId, methodName) {
   if (state.processInProgress) {
     Stdlib_JsError.throwWithMessage(`Cannot call ` + entityConfig.name + `.` + methodName + `() while indexer.process() is running. ` + "Wait for process() to complete before accessing entities directly.");
   }
   let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
-  return entityDict[entityId];
+  return Stdlib_Option.map(entityDict[entityId], copyEntity);
 }
 
 function makeEntityGet(state, entityConfig) {
@@ -329,7 +293,7 @@ function makeEntitySet(state, entityConfig) {
       state.entities[entityConfig.name] = dict$1;
       entityDict = dict$1;
     }
-    entityDict[entity.id] = entity;
+    entityDict[entity.id] = Utils.Dict.shallowCopy(entity);
   };
 }
 
@@ -339,295 +303,304 @@ function makeEntityGetAll(state, entityConfig) {
       Stdlib_JsError.throwWithMessage(`Cannot call ` + entityConfig.name + `.getAll() while indexer.process() is running. ` + "Wait for process() to complete before accessing entities directly.");
     }
     let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
-    return Promise.resolve(Object.values(entityDict));
+    return Promise.resolve(Object.values(entityDict).map(copyEntity));
   };
 }
 
-function makeCreateTestIndexer(config, workerPath) {
-  return () => {
-    let allEntities = config.allEntities;
-    let entities = {};
-    let entityConfigs = {};
-    allEntities.forEach(entityConfig => {
-      entities[entityConfig.name] = {};
-      entityConfigs[entityConfig.name] = entityConfig;
-    });
-    let envioAddressesDict = entities[Config.EnvioAddresses.name];
-    ChainMap.values(config.chainMap).forEach(chainConfig => {
-      chainConfig.contracts.forEach(contract => {
-        contract.addresses.forEach(address => {
-          let entity_id = Config.EnvioAddresses.makeId(chainConfig.id, address);
-          let entity_chain_id = chainConfig.id;
-          let entity_contract_name = contract.name;
-          let entity = {
-            id: entity_id,
-            chain_id: entity_chain_id,
-            registration_block: -1,
-            registration_log_index: -1,
-            contract_name: entity_contract_name
-          };
-          envioAddressesDict[entity_id] = entity;
-        });
-      });
-    });
-    let state = {
-      processInProgress: false,
-      progressBlockByChain: {},
-      entities: entities,
-      entityConfigs: entityConfigs,
-      processChanges: []
+function makeInMemoryStorage(state) {
+  return {
+    name: "test-inmemory",
+    isInitialized: async () => true,
+    initialize: async (param, param$1, param$2, param$3) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
+    resumeInitialState: async () => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
+    loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
+    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. The runner forces rollbackOnReorg off, so this should be unreachable."),
+    getRollbackProgressDiff: async param => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
+    getRollbackData: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
+    writeBatch: async (batch, param, param$1, param$2, param$3, param$4, updatedEntities, param$5, param$6) => handleWriteBatch(state, updatedEntities, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointEventsProcessed),
+    close: async () => {}
+  };
+}
+
+function cloneRegistrations(base) {
+  let clone = {};
+  Object.entries(base).forEach(param => {
+    let chainRegistrations = param[1];
+    clone[param[0]] = {
+      onEventRegistrations: chainRegistrations.onEventRegistrations.slice(),
+      onBlockRegistrations: chainRegistrations.onBlockRegistrations.slice()
     };
-    let entityOpsDict = {};
-    allEntities.forEach(entityConfig => {
-      if (entityConfig.name !== Config.EnvioAddresses.name) {
-        entityOpsDict[entityConfig.name] = {
-          get: makeEntityGet(state, entityConfig),
-          getAll: makeEntityGetAll(state, entityConfig),
-          getOrThrow: makeEntityGetOrThrow(state, entityConfig),
-          set: makeEntitySet(state, entityConfig)
+  });
+  return clone;
+}
+
+let registrationsRef = {
+  contents: undefined
+};
+
+function getRegistrations(config) {
+  let promise = registrationsRef.contents;
+  if (promise !== undefined) {
+    return promise;
+  }
+  let promise$1 = HandlerLoader.registerAllHandlers(config);
+  registrationsRef.contents = promise$1;
+  return promise$1;
+}
+
+function createTestIndexer() {
+  let config = Config.load();
+  let allEntities = config.allEntities;
+  let entities = {};
+  let entityConfigs = {};
+  allEntities.forEach(entityConfig => {
+    entities[entityConfig.name] = {};
+    entityConfigs[entityConfig.name] = entityConfig;
+  });
+  let envioAddressesDict = entities[Config.EnvioAddresses.name];
+  ChainMap.values(config.chainMap).forEach(chainConfig => {
+    chainConfig.contracts.forEach(contract => {
+      contract.addresses.forEach(address => {
+        let entity_id = Config.EnvioAddresses.makeId(chainConfig.id, address);
+        let entity_chain_id = chainConfig.id;
+        let entity_contract_name = contract.name;
+        let entity = {
+          id: entity_id,
+          chain_id: entity_chain_id,
+          registration_block: -1,
+          registration_log_index: -1,
+          contract_name: entity_contract_name
         };
-        return;
-      }
+        envioAddressesDict[entity_id] = entity;
+      });
     });
-    let chainIds = [];
-    let chains = Object.create(null);
-    ChainMap.values(config.chainMap).forEach(chainConfig => {
-      let chainIdStr = chainConfig.id.toString();
-      chainIds.push(chainConfig.id);
-      let chainObj = Object.create(null);
-      Object.defineProperty(Object.defineProperty(Object.defineProperty(Object.defineProperty(Object.defineProperty(chainObj, "id", {
-        enumerable: true,
-        value: chainConfig.id
-      }), "startBlock", {
-        enumerable: true,
-        value: chainConfig.startBlock
-      }), "endBlock", {
+  });
+  let state = {
+    processInProgress: false,
+    progressBlockByChain: {},
+    entities: entities,
+    entityConfigs: entityConfigs,
+    processChanges: []
+  };
+  let storage = makeInMemoryStorage(state);
+  let persistence = Persistence.make(config.userEntities, config.allEnums, storage);
+  if (Env.userLogLevel !== undefined) {
+    
+  } else {
+    Logging.setLogLevel("silent");
+  }
+  let entityOpsDict = {};
+  allEntities.forEach(entityConfig => {
+    if (entityConfig.name !== Config.EnvioAddresses.name) {
+      entityOpsDict[entityConfig.name] = {
+        get: makeEntityGet(state, entityConfig),
+        getAll: makeEntityGetAll(state, entityConfig),
+        getOrThrow: makeEntityGetOrThrow(state, entityConfig),
+        set: makeEntitySet(state, entityConfig)
+      };
+      return;
+    }
+  });
+  let chainIds = [];
+  let chains = Object.create(null);
+  ChainMap.values(config.chainMap).forEach(chainConfig => {
+    let chainIdStr = chainConfig.id.toString();
+    chainIds.push(chainConfig.id);
+    let chainObj = Object.create(null);
+    Object.defineProperty(Object.defineProperty(Object.defineProperty(Object.defineProperty(Object.defineProperty(chainObj, "id", {
+      enumerable: true,
+      value: chainConfig.id
+    }), "startBlock", {
+      enumerable: true,
+      value: chainConfig.startBlock
+    }), "endBlock", {
+      enumerable: true,
+      value: chainConfig.endBlock
+    }), "name", {
+      enumerable: true,
+      value: chainConfig.name
+    }), "isRealtime", {
+      enumerable: true,
+      value: false
+    });
+    chainConfig.contracts.forEach(contract => {
+      let contractObj = Object.create(null);
+      Object.defineProperty(Object.defineProperty(Object.defineProperty(contractObj, "name", {
         enumerable: true,
-        value: chainConfig.endBlock
-      }), "name", {
+        value: contract.name
+      }), "abi", {
         enumerable: true,
-        value: chainConfig.name
-      }), "isRealtime", {
+        value: contract.abi
+      }), "addresses", {
         enumerable: true,
-        value: false
-      });
-      chainConfig.contracts.forEach(contract => {
-        let contractObj = Object.create(null);
-        Object.defineProperty(Object.defineProperty(Object.defineProperty(contractObj, "name", {
-          enumerable: true,
-          value: contract.name
-        }), "abi", {
-          enumerable: true,
-          value: contract.abi
-        }), "addresses", {
-          enumerable: true,
-          get: () => {
-            if (state.processInProgress) {
-              Stdlib_JsError.throwWithMessage(`Cannot access ` + contract.name + `.addresses while indexer.process() is running. ` + "Wait for process() to complete before reading contract addresses.");
-            }
-            return Stdlib_Array.filterMap(Stdlib_Option.getOr(getIndexingAddressesByChain(state)[chainConfig.id.toString()], []), ia => {
-              if (ia.contractName === contract.name) {
-                return Primitive_option.some(ia.address);
-              }
-            });
+        get: () => {
+          if (state.processInProgress) {
+            Stdlib_JsError.throwWithMessage(`Cannot access ` + contract.name + `.addresses while indexer.process() is running. ` + "Wait for process() to complete before reading contract addresses.");
           }
-        });
-        Object.defineProperty(chainObj, contract.name, {
-          enumerable: true,
-          value: contractObj
-        });
+          return Stdlib_Array.filterMap(Stdlib_Option.getOr(getIndexingAddressesByChain(state)[chainConfig.id.toString()], []), ia => {
+            if (ia.contractName === contract.name) {
+              return Primitive_option.some(ia.address);
+            }
+          });
+        }
       });
-      Object.defineProperty(chains, chainIdStr, {
+      Object.defineProperty(chainObj, contract.name, {
         enumerable: true,
+        value: contractObj
+      });
+    });
+    Object.defineProperty(chains, chainIdStr, {
+      enumerable: true,
+      value: chainObj
+    });
+    if (chainConfig.name !== chainIdStr) {
+      Object.defineProperty(chains, chainConfig.name, {
+        enumerable: false,
         value: chainObj
       });
-      if (chainConfig.name !== chainIdStr) {
-        Object.defineProperty(chains, chainConfig.name, {
-          enumerable: false,
-          value: chainObj
-        });
-        return;
+      return;
+    }
+  });
+  let result = {};
+  result["chainIds"] = chainIds;
+  result["chains"] = chains;
+  Object.entries(entityOpsDict).forEach(param => {
+    result[Utils.$$String.capitalize(param[0])] = param[1];
+  });
+  result["process"] = processConfig => {
+    if (state.processInProgress) {
+      Stdlib_JsError.throwWithMessage("createTestIndexer process is already running. Only one process call is allowed at a time");
+    }
+    let parsedConfig;
+    try {
+      parsedConfig = S$RescriptSchema.parseOrThrow(processConfig, processConfigSchema);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      if (exn.RE_EXN_ID === S$RescriptSchema.Raised) {
+        parsedConfig = Stdlib_JsError.throwWithMessage(`Invalid processConfig: ` + Utils.prettifyExn(exn._1));
+      } else {
+        throw exn;
       }
+    }
+    let rawChains = parsedConfig.chains;
+    let chainKeys = Object.keys(rawChains);
+    if (chainKeys.length === 0) {
+      Stdlib_JsError.throwWithMessage("createTestIndexer requires at least one chain to be defined");
+    }
+    let sortedChainKeys = chainKeys.slice();
+    sortedChainKeys.sort((a, b) => {
+      let aId = Stdlib_Option.getOr(Stdlib_Int.fromString(a, undefined), 0);
+      let bId = Stdlib_Option.getOr(Stdlib_Int.fromString(b, undefined), 0);
+      return Primitive_int.compare(aId, bId);
     });
-    let result = {};
-    result["chainIds"] = chainIds;
-    result["chains"] = chains;
-    Object.entries(entityOpsDict).forEach(param => {
-      result[param[0]] = param[1];
+    let chainEntries = sortedChainKeys.map(chainIdStr => {
+      let rawChainConfig = rawChains[chainIdStr];
+      if (Stdlib_Option.isNone(Stdlib_Int.fromString(chainIdStr, undefined))) {
+        Stdlib_JsError.throwWithMessage(`Invalid chain ID "` + chainIdStr + `": expected a numeric chain ID`);
+      }
+      let processChainConfig = parseBlockRange(chainIdStr, config, rawChainConfig, state.progressBlockByChain[chainIdStr]);
+      return [
+        chainIdStr,
+        rawChainConfig,
+        processChainConfig
+      ];
     });
-    result["process"] = processConfig => {
-      if (state.processInProgress) {
-        Stdlib_JsError.throwWithMessage("createTestIndexer process is already running. Only one process call is allowed at a time");
+    state.processChanges = [];
+    let runChainInProcess = async param => {
+      let processChainConfig = param[2];
+      let chainIdStr = param[0];
+      let chains = {};
+      chains[chainIdStr] = processChainConfig;
+      let indexingAddressesByChain = getIndexingAddressesByChain(state);
+      let initialState = makeInitialState(config, chains, indexingAddressesByChain);
+      let exitAfterFirstEventBlock = Stdlib_Option.isNone(processChainConfig.endBlock);
+      let resolvedChainDict = {};
+      resolvedChainDict["startBlock"] = processChainConfig.startBlock;
+      let eb = processChainConfig.endBlock;
+      if (eb !== undefined) {
+        resolvedChainDict["endBlock"] = eb;
       }
-      let parsedConfig;
-      try {
-        parsedConfig = S$RescriptSchema.parseOrThrow(processConfig, processConfigSchema);
-      } catch (raw_exn) {
-        let exn = Primitive_exceptions.internalToException(raw_exn);
-        if (exn.RE_EXN_ID === S$RescriptSchema.Raised) {
-          parsedConfig = Stdlib_JsError.throwWithMessage(`Invalid processConfig: ` + Utils.prettifyExn(exn._1));
-        } else {
-          throw exn;
-        }
+      let s = param[1].simulate;
+      if (s !== undefined) {
+        resolvedChainDict["simulate"] = s;
       }
-      let rawChains = parsedConfig.chains;
-      let chainKeys = Object.keys(rawChains);
-      if (chainKeys.length === 0) {
-        Stdlib_JsError.throwWithMessage("createTestIndexer requires at least one chain to be defined");
+      let resolvedChainsDict = {};
+      resolvedChainsDict[chainIdStr] = resolvedChainDict;
+      let processConfigJson = {
+        chains: resolvedChainsDict
+      };
+      let registrationsByChainId = cloneRegistrations(await getRegistrations(config));
+      let patchedConfig = SimulateItems.patchConfig(config, processConfigJson, registrationsByChainId);
+      let newrecord = {...patchedConfig};
+      newrecord.shouldRollbackOnReorg = false;
+      let runConfig;
+      if (exitAfterFirstEventBlock) {
+        let newrecord$1 = {...newrecord};
+        newrecord$1.batchSize = 1;
+        runConfig = newrecord$1;
+      } else {
+        runConfig = newrecord;
       }
-      let sortedChainKeys = chainKeys.slice();
-      sortedChainKeys.sort((a, b) => {
-        let aId = Stdlib_Option.getOr(Stdlib_Int.fromString(a, undefined), 0);
-        let bId = Stdlib_Option.getOr(Stdlib_Int.fromString(b, undefined), 0);
-        return Primitive_int.compare(aId, bId);
-      });
-      let chainEntries = sortedChainKeys.map(chainIdStr => {
-        let rawChainConfig = rawChains[chainIdStr];
-        let id = Stdlib_Int.fromString(chainIdStr, undefined);
-        let chainId = id !== undefined ? id : Stdlib_JsError.throwWithMessage(`Invalid chain ID "` + chainIdStr + `": expected a numeric chain ID`);
-        let processChainConfig = parseBlockRange(chainIdStr, config, rawChainConfig, state.progressBlockByChain[chainIdStr]);
-        return [
-          chainIdStr,
-          chainId,
-          rawChainConfig,
-          processChainConfig
-        ];
-      });
-      state.processChanges = [];
-      let runChainWorker = param => {
-        let processChainConfig = param[3];
-        let rawChainConfig = param[2];
-        let chainId = param[1];
-        let chains = {};
-        chains[param[0]] = processChainConfig;
-        let indexingAddressesByChain = getIndexingAddressesByChain(state);
-        let initialState = makeInitialState(config, chains, indexingAddressesByChain);
-        return new Promise((resolve, reject) => {
-          let workerData_startBlock = processChainConfig.startBlock;
-          let workerData_endBlock = processChainConfig.endBlock;
-          let workerData_simulate = rawChainConfig.simulate;
-          let workerData = {
-            chainId: chainId,
-            startBlock: workerData_startBlock,
-            endBlock: workerData_endBlock,
-            simulate: workerData_simulate,
-            initialState: initialState
-          };
-          let worker;
-          try {
-            worker = new Worker_threads.Worker(workerPath, {
-              workerData: workerData,
-              env: process.env
-            });
-          } catch (raw_exn) {
-            let exn = Primitive_exceptions.internalToException(raw_exn);
-            reject(exn);
-            throw exn;
-          }
-          worker.on("message", msg => {
-            let respond = data => {
-              worker.postMessage({
-                id: msg.id,
-                payload: {
-                  type: "response",
-                  data: data
-                }
-              });
-            };
-            let match = msg.payload;
-            if (match.type === "load") {
-              return respond(handleLoad(state, match.tableName, match.filter));
-            }
-            handleWriteBatch(state, match.updatedEntities, match.checkpointIds, match.checkpointChainIds, match.checkpointBlockNumbers, match.checkpointEventsProcessed);
-            respond(null);
-          });
-          worker.on("error", err => {
-            worker.terminate();
-            reject(err);
-          });
-          worker.on("exit", code => {
-            if (code !== 0) {
-              return reject(new Error(`Worker exited with code ` + code.toString()));
-            } else {
-              return resolve();
-            }
-          });
-        });
+      persistence.storageStatus = {
+        TAG: "Ready",
+        _0: initialState
       };
-      state.processInProgress = true;
-      let runChains = idx => {
-        if (idx >= chainEntries.length) {
-          state.processInProgress = false;
-          return Promise.resolve({
-            changes: state.processChanges
-          });
-        } else {
-          return runChainWorker(chainEntries[idx]).then(() => runChains(idx + 1 | 0));
+      let indexerStateRef = {
+        contents: undefined
+      };
+      let cleanup = async () => {
+        let indexerState = indexerStateRef.contents;
+        if (indexerState === undefined) {
+          return;
         }
+        let indexerState$1 = Primitive_option.valFromOption(indexerState);
+        IndexerState.stop(indexerState$1);
+        while (IndexerState.isProcessing(indexerState$1) || Stdlib_Option.isSome(IndexerState.writeFiber(indexerState$1))) {
+          let fiber = IndexerState.writeFiber(indexerState$1);
+          if (fiber !== undefined) {
+            await fiber;
+          } else {
+            await Utils.delay(0);
+          }
+        };
       };
-      return Stdlib_Promise.$$catch(runChains(0), err => {
+      try {
+        await new Promise((resolve, reject) => {
+          let indexerState = IndexerState.makeFromDbState(runConfig, persistence, initialState, registrationsByChainId, undefined, undefined, exitAfterFirstEventBlock, undefined, undefined, errHandler => {
+            ErrorHandling.log(errHandler);
+            reject(Utils.prettifyExn(errHandler.exn));
+          }, () => resolve());
+          indexerStateRef.contents = Primitive_option.some(indexerState);
+          IndexerLoop.start(indexerState);
+        });
+        return await cleanup();
+      } catch (exn) {
+        await cleanup();
+        throw exn;
+      }
+    };
+    state.processInProgress = true;
+    let runChains = idx => {
+      if (idx >= chainEntries.length) {
         state.processInProgress = false;
-        return Promise.reject(Utils.prettifyExn(err));
-      });
+        return Promise.resolve({
+          changes: state.processChanges
+        });
+      } else {
+        return runChainInProcess(chainEntries[idx]).then(() => runChains(idx + 1 | 0));
+      }
     };
-    return result;
-  };
-}
-
-function initTestWorker() {
-  if (Worker_threads.isMainThread) {
-    Stdlib_JsError.throwWithMessage("initTestWorker must be called from a worker thread");
-  }
-  let port = Worker_threads.parentPort;
-  let parentPort = (port == null) ? Stdlib_JsError.throwWithMessage("initTestWorker: No parent port available") : port;
-  let workerData = Worker_threads.workerData;
-  if (workerData == null) {
-    Logging.error("TestIndexerWorker: No worker data provided");
-    Process.exit(1);
-    return;
-  }
-  let simulate = workerData.simulate;
-  let endBlock = workerData.endBlock;
-  let chainIdStr = workerData.chainId.toString();
-  let exitAfterFirstEventBlock = Stdlib_Option.isNone(endBlock);
-  let resolvedChainDict = {};
-  resolvedChainDict["startBlock"] = workerData.startBlock;
-  if (endBlock !== undefined) {
-    resolvedChainDict["endBlock"] = endBlock;
-  }
-  if (simulate !== undefined) {
-    resolvedChainDict["simulate"] = simulate;
-  }
-  let resolvedChainsDict = {};
-  resolvedChainsDict[chainIdStr] = resolvedChainDict;
-  let processConfig = {
-    chains: resolvedChainsDict
-  };
-  let proxy = TestIndexerProxyStorage.make(parentPort, workerData.initialState);
-  let storage = TestIndexerProxyStorage.makeStorage(proxy);
-  let config = Config.load();
-  let persistence = Persistence.make(config.userEntities, config.allEnums, storage);
-  if (Env.userLogLevel !== undefined) {
-    
-  } else {
-    Logging.setLogLevel("silent");
-  }
-  let patchConfig = (config, registrationsByChainId) => {
-    let config$1 = SimulateItems.patchConfig(config, processConfig, registrationsByChainId);
-    if (!exitAfterFirstEventBlock) {
-      return config$1;
-    }
-    let newrecord = {...config$1};
-    newrecord.batchSize = 1;
-    return newrecord;
-  };
-  Stdlib_Promise.$$catch(Main.start(persistence, undefined, true, exitAfterFirstEventBlock, patchConfig), exn => {
-    let toThrow = exn.RE_EXN_ID === Main.FatalError ? exn._1 : Utils.prettifyExn(exn);
-    setImmediate(() => {
-      throw toThrow;
+    return Stdlib_Promise.$$catch(runChains(0), err => {
+      state.processInProgress = false;
+      return Promise.reject(Utils.prettifyExn(err));
     });
-    return Promise.resolve();
-  });
+  };
+  return result;
 }
 
 export {
@@ -640,12 +613,16 @@ export {
   processConfigSchema,
   getSimulateEndBlock,
   parseBlockRange,
+  copyEntity,
   getEntityFromState,
   makeEntityGet,
   makeEntityGetOrThrow,
   makeEntitySet,
   makeEntityGetAll,
-  makeCreateTestIndexer,
-  initTestWorker,
+  makeInMemoryStorage,
+  cloneRegistrations,
+  registrationsRef,
+  getRegistrations,
+  createTestIndexer,
 }
 /* rawChainConfigSchema Not a pure module */