envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/Batch.res.mjs

@@ -1,38 +1,34 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as $$BigInt from "./bindings/BigInt.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as FetchState from "./FetchState.res.mjs";
 import * as ReorgDetection from "./ReorgDetection.res.mjs";
 
 function getOrderedNextChain(fetchStates, batchSizePerChain) {
-  var earliestChain;
-  var earliestChainTimestamp = 0;
-  var chainKeys = ChainMap.keys(fetchStates);
-  for(var idx = 0 ,idx_finish = chainKeys.length - 1; idx <= idx_finish; ++idx){
-    var chain = chainKeys[idx];
-    var fetchState = ChainMap.get(fetchStates, chain);
+  let earliestChain;
+  let earliestChainTimestamp = 0;
+  let chainKeys = ChainMap.keys(fetchStates);
+  for (let idx = 0, idx_finish = chainKeys.length - 1; idx <= idx_finish; ++idx) {
+    let chain = chainKeys[idx];
+    let fetchState = ChainMap.get(fetchStates, chain);
     if (FetchState.isActivelyIndexing(fetchState)) {
-      var batchSize = batchSizePerChain[chain];
-      var timestamp = FetchState.getTimestampAt(fetchState, batchSize !== undefined ? batchSize : 0);
-      var earliestChain$1 = earliestChain;
+      let batchSize = batchSizePerChain[chain];
+      let timestamp = FetchState.getTimestampAt(fetchState, batchSize !== undefined ? batchSize : 0);
+      let earliestChain$1 = earliestChain;
       if (!(earliestChain$1 !== undefined && (timestamp > earliestChainTimestamp || timestamp === earliestChainTimestamp && chain > earliestChain$1.chainId))) {
         earliestChain = fetchState;
         earliestChainTimestamp = timestamp;
       }
-      
     }
-    
   }
   return earliestChain;
 }
 
-var immutableEmptyBatchSizePerChain = {};
+let immutableEmptyBatchSizePerChain = {};
 
 function hasOrderedReadyItem(fetchStates) {
-  var fetchState = getOrderedNextChain(fetchStates, immutableEmptyBatchSizePerChain);
+  let fetchState = getOrderedNextChain(fetchStates, immutableEmptyBatchSizePerChain);
   if (fetchState !== undefined) {
     return FetchState.hasReadyItem(fetchState);
   } else {
@@ -41,13 +37,13 @@ function hasOrderedReadyItem(fetchStates) {
 }
 
 function hasUnorderedReadyItem(fetchStates) {
-  return ChainMap.values(fetchStates).some(function (fetchState) {
-              if (FetchState.isActivelyIndexing(fetchState)) {
-                return FetchState.hasReadyItem(fetchState);
-              } else {
-                return false;
-              }
-            });
+  return ChainMap.values(fetchStates).some(fetchState => {
+    if (FetchState.isActivelyIndexing(fetchState)) {
+      return FetchState.hasReadyItem(fetchState);
+    } else {
+      return false;
+    }
+  });
 }
 
 function hasMultichainReadyItem(fetchStates, multichain) {
@@ -61,37 +57,35 @@ function hasMultichainReadyItem(fetchStates, multichain) {
 function getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, fetchStateAfterBatch, batchSize) {
   if (chainBeforeBatch.progressBlockNumber < progressBlockNumberAfterBatch) {
     return {
-            batchSize: batchSize,
-            progressBlockNumber: progressBlockNumberAfterBatch,
-            sourceBlockNumber: chainBeforeBatch.sourceBlockNumber,
-            totalEventsProcessed: chainBeforeBatch.totalEventsProcessed + batchSize,
-            fetchState: fetchStateAfterBatch,
-            isProgressAtHeadWhenBatchCreated: progressBlockNumberAfterBatch >= chainBeforeBatch.sourceBlockNumber - chainBeforeBatch.chainConfig.blockLag
-          };
+      batchSize: batchSize,
+      progressBlockNumber: progressBlockNumberAfterBatch,
+      sourceBlockNumber: chainBeforeBatch.sourceBlockNumber,
+      totalEventsProcessed: chainBeforeBatch.totalEventsProcessed + batchSize,
+      fetchState: fetchStateAfterBatch,
+      isProgressAtHeadWhenBatchCreated: progressBlockNumberAfterBatch >= chainBeforeBatch.sourceBlockNumber - chainBeforeBatch.chainConfig.blockLag
+    };
   }
-  
 }
 
 function getProgressedChainsById(chainsBeforeBatch, batchSizePerChain, progressBlockNumberPerChain) {
-  var progressedChainsById = {};
-  Belt_Array.forEachU(ChainMap.values(chainsBeforeBatch), (function (chainBeforeBatch) {
-          var fetchState = chainBeforeBatch.fetchState;
-          var progressBlockNumber = progressBlockNumberPerChain[String(fetchState.chainId)];
-          var progressBlockNumberAfterBatch = progressBlockNumber !== undefined ? progressBlockNumber : chainBeforeBatch.progressBlockNumber;
-          var batchSize = batchSizePerChain[String(fetchState.chainId)];
-          var progressedChain;
-          if (batchSize !== undefined) {
-            var leftItems = fetchState.buffer.slice(batchSize);
-            progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, FetchState.updateInternal(fetchState, undefined, undefined, leftItems, undefined, undefined), batchSize);
-          } else {
-            progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, chainBeforeBatch.fetchState, 0);
-          }
-          if (progressedChain !== undefined) {
-            progressedChainsById[chainBeforeBatch.fetchState.chainId] = progressedChain;
-            return ;
-          }
-          
-        }));
+  let progressedChainsById = {};
+  ChainMap.values(chainsBeforeBatch).forEach(chainBeforeBatch => {
+    let fetchState = chainBeforeBatch.fetchState;
+    let progressBlockNumber = progressBlockNumberPerChain[fetchState.chainId.toString()];
+    let progressBlockNumberAfterBatch = progressBlockNumber !== undefined ? progressBlockNumber : chainBeforeBatch.progressBlockNumber;
+    let batchSize = batchSizePerChain[fetchState.chainId.toString()];
+    let progressedChain;
+    if (batchSize !== undefined) {
+      let leftItems = fetchState.buffer.slice(batchSize);
+      progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, FetchState.updateInternal(fetchState, undefined, undefined, leftItems, undefined, undefined), batchSize);
+    } else {
+      progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, chainBeforeBatch.fetchState, 0);
+    }
+    if (progressedChain !== undefined) {
+      progressedChainsById[chainBeforeBatch.fetchState.chainId] = progressedChain;
+      return;
+    }
+  });
   return progressedChainsById;
 }
 
@@ -99,11 +93,11 @@ function addReorgCheckpoints(prevCheckpointId, reorgDetection, fromBlockExclusiv
   if (!(reorgDetection.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection.dataByBlockNumber))) {
     return prevCheckpointId;
   }
-  var prevCheckpointId$1 = prevCheckpointId;
-  for(var blockNumber = fromBlockExclusive + 1 ,blockNumber_finish = toBlockExclusive - 1; blockNumber <= blockNumber_finish; ++blockNumber){
-    var hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber);
+  let prevCheckpointId$1 = prevCheckpointId;
+  for (let blockNumber = fromBlockExclusive + 1, blockNumber_finish = toBlockExclusive - 1; blockNumber <= blockNumber_finish; ++blockNumber) {
+    let hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber);
     if (hash !== null) {
-      var checkpointId = $$BigInt.add(prevCheckpointId$1, 1n);
+      let checkpointId = prevCheckpointId$1 + 1n;
       prevCheckpointId$1 = checkpointId;
       mutCheckpointIds.push(checkpointId);
       mutCheckpointChainIds.push(chainId);
@@ -111,48 +105,45 @@ function addReorgCheckpoints(prevCheckpointId, reorgDetection, fromBlockExclusiv
       mutCheckpointBlockHashes.push(hash);
       mutCheckpointEventsProcessed.push(0);
     }
-    
   }
   return prevCheckpointId$1;
 }
 
 function prepareOrderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget) {
-  var totalBatchSize = 0;
-  var isFinished = false;
-  var prevCheckpointId = checkpointIdBeforeBatch;
-  var mutBatchSizePerChain = {};
-  var mutProgressBlockNumberPerChain = {};
-  var fetchStates = ChainMap.map(chainsBeforeBatch, (function (chainBeforeBatch) {
-          return chainBeforeBatch.fetchState;
-        }));
-  var items = [];
-  var checkpointIds = [];
-  var checkpointChainIds = [];
-  var checkpointBlockNumbers = [];
-  var checkpointBlockHashes = [];
-  var checkpointEventsProcessed = [];
-  while(totalBatchSize < batchSizeTarget && !isFinished) {
-    var fetchState = getOrderedNextChain(fetchStates, mutBatchSizePerChain);
+  let totalBatchSize = 0;
+  let isFinished = false;
+  let prevCheckpointId = checkpointIdBeforeBatch;
+  let mutBatchSizePerChain = {};
+  let mutProgressBlockNumberPerChain = {};
+  let fetchStates = ChainMap.map(chainsBeforeBatch, chainBeforeBatch => chainBeforeBatch.fetchState);
+  let items = [];
+  let checkpointIds = [];
+  let checkpointChainIds = [];
+  let checkpointBlockNumbers = [];
+  let checkpointBlockHashes = [];
+  let checkpointEventsProcessed = [];
+  while (totalBatchSize < batchSizeTarget && !isFinished) {
+    let fetchState = getOrderedNextChain(fetchStates, mutBatchSizePerChain);
     if (fetchState !== undefined) {
-      var chainBeforeBatch = ChainMap.get(chainsBeforeBatch, ChainMap.Chain.makeUnsafe(fetchState.chainId));
-      var batchSize = mutBatchSizePerChain[fetchState.chainId];
-      var itemsCountBefore = batchSize !== undefined ? batchSize : 0;
-      var progressBlockNumber = mutProgressBlockNumberPerChain[fetchState.chainId];
-      var prevBlockNumber = progressBlockNumber !== undefined ? progressBlockNumber : chainBeforeBatch.progressBlockNumber;
-      var newItemsCount = FetchState.getReadyItemsCount(fetchState, 1, itemsCountBefore);
+      let chainBeforeBatch = ChainMap.get(chainsBeforeBatch, ChainMap.Chain.makeUnsafe(fetchState.chainId));
+      let batchSize = mutBatchSizePerChain[fetchState.chainId];
+      let itemsCountBefore = batchSize !== undefined ? batchSize : 0;
+      let progressBlockNumber = mutProgressBlockNumberPerChain[fetchState.chainId];
+      let prevBlockNumber = progressBlockNumber !== undefined ? progressBlockNumber : chainBeforeBatch.progressBlockNumber;
+      let newItemsCount = FetchState.getReadyItemsCount(fetchState, 1, itemsCountBefore);
       if (newItemsCount > 0) {
-        var item0 = fetchState.buffer[itemsCountBefore];
-        var blockNumber = item0.blockNumber;
-        var chainId = fetchState.chainId;
-        var reorgDetection = chainBeforeBatch.reorgDetection;
-        var prevCheckpointId$1 = prevCheckpointId;
-        var tmp;
+        let item0 = fetchState.buffer[itemsCountBefore];
+        let blockNumber = item0.blockNumber;
+        let chainId = fetchState.chainId;
+        let reorgDetection = chainBeforeBatch.reorgDetection;
+        let prevCheckpointId$1 = prevCheckpointId;
+        let tmp;
         if (reorgDetection.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection.dataByBlockNumber)) {
-          var prevCheckpointId$2 = prevCheckpointId$1;
-          for(var blockNumber$1 = prevBlockNumber + 1 ,blockNumber_finish = blockNumber - 1; blockNumber$1 <= blockNumber_finish; ++blockNumber$1){
-            var hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber$1);
+          let prevCheckpointId$2 = prevCheckpointId$1;
+          for (let blockNumber$1 = prevBlockNumber + 1, blockNumber_finish = blockNumber - 1; blockNumber$1 <= blockNumber_finish; ++blockNumber$1) {
+            let hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber$1);
             if (hash !== null) {
-              var checkpointId = $$BigInt.add(prevCheckpointId$2, 1n);
+              let checkpointId = prevCheckpointId$2 + 1n;
               prevCheckpointId$2 = checkpointId;
               checkpointIds.push(checkpointId);
               checkpointChainIds.push(chainId);
@@ -160,16 +151,15 @@ function prepareOrderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSi
               checkpointBlockHashes.push(hash);
               checkpointEventsProcessed.push(0);
             }
-            
           }
           tmp = prevCheckpointId$2;
         } else {
           tmp = prevCheckpointId$1;
         }
         prevCheckpointId = tmp;
-        var checkpointId$1 = $$BigInt.add(prevCheckpointId, 1n);
+        let checkpointId$1 = prevCheckpointId + 1n;
         items.push(item0);
-        for(var idx = 1 ,idx_finish = newItemsCount - 1; idx <= idx_finish; ++idx){
+        for (let idx = 1, idx_finish = newItemsCount - 1; idx <= idx_finish; ++idx) {
           items.push(fetchState.buffer[itemsCountBefore + idx]);
         }
         checkpointIds.push(checkpointId$1);
@@ -182,18 +172,18 @@ function prepareOrderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSi
         mutBatchSizePerChain[fetchState.chainId] = itemsCountBefore + newItemsCount;
         mutProgressBlockNumberPerChain[fetchState.chainId] = blockNumber;
       } else {
-        var blockNumberAfterBatch = FetchState.bufferBlockNumber(fetchState);
-        var chainId$1 = fetchState.chainId;
-        var toBlockExclusive = blockNumberAfterBatch + 1;
-        var reorgDetection$1 = chainBeforeBatch.reorgDetection;
-        var prevCheckpointId$3 = prevCheckpointId;
-        var tmp$1;
+        let blockNumberAfterBatch = FetchState.bufferBlockNumber(fetchState);
+        let chainId$1 = fetchState.chainId;
+        let toBlockExclusive = blockNumberAfterBatch + 1;
+        let reorgDetection$1 = chainBeforeBatch.reorgDetection;
+        let prevCheckpointId$3 = prevCheckpointId;
+        let tmp$1;
         if (reorgDetection$1.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection$1.dataByBlockNumber)) {
-          var prevCheckpointId$4 = prevCheckpointId$3;
-          for(var blockNumber$2 = prevBlockNumber + 1 ,blockNumber_finish$1 = toBlockExclusive - 1; blockNumber$2 <= blockNumber_finish$1; ++blockNumber$2){
-            var hash$1 = ReorgDetection.getHashByBlockNumber(reorgDetection$1, blockNumber$2);
+          let prevCheckpointId$4 = prevCheckpointId$3;
+          for (let blockNumber$2 = prevBlockNumber + 1, blockNumber_finish$1 = toBlockExclusive - 1; blockNumber$2 <= blockNumber_finish$1; ++blockNumber$2) {
+            let hash$1 = ReorgDetection.getHashByBlockNumber(reorgDetection$1, blockNumber$2);
             if (hash$1 !== null) {
-              var checkpointId$2 = $$BigInt.add(prevCheckpointId$4, 1n);
+              let checkpointId$2 = prevCheckpointId$4 + 1n;
               prevCheckpointId$4 = checkpointId$2;
               checkpointIds.push(checkpointId$2);
               checkpointChainIds.push(chainId$1);
@@ -201,7 +191,6 @@ function prepareOrderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSi
               checkpointBlockHashes.push(hash$1);
               checkpointEventsProcessed.push(0);
             }
-            
           }
           tmp$1 = prevCheckpointId$4;
         } else {
@@ -216,54 +205,52 @@ function prepareOrderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSi
     }
   };
   return {
-          totalBatchSize: totalBatchSize,
-          items: items,
-          progressedChainsById: getProgressedChainsById(chainsBeforeBatch, mutBatchSizePerChain, mutProgressBlockNumberPerChain),
-          checkpointIds: checkpointIds,
-          checkpointChainIds: checkpointChainIds,
-          checkpointBlockNumbers: checkpointBlockNumbers,
-          checkpointBlockHashes: checkpointBlockHashes,
-          checkpointEventsProcessed: checkpointEventsProcessed
-        };
+    totalBatchSize: totalBatchSize,
+    items: items,
+    progressedChainsById: getProgressedChainsById(chainsBeforeBatch, mutBatchSizePerChain, mutProgressBlockNumberPerChain),
+    checkpointIds: checkpointIds,
+    checkpointChainIds: checkpointChainIds,
+    checkpointBlockNumbers: checkpointBlockNumbers,
+    checkpointBlockHashes: checkpointBlockHashes,
+    checkpointEventsProcessed: checkpointEventsProcessed
+  };
 }
 
 function prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget) {
-  var preparedFetchStates = FetchState.sortForUnorderedBatch(ChainMap.values(chainsBeforeBatch).map(function (chainBeforeBatch) {
-            return chainBeforeBatch.fetchState;
-          }), batchSizeTarget);
-  var chainIdx = 0;
-  var preparedNumber = preparedFetchStates.length;
-  var totalBatchSize = 0;
-  var prevCheckpointId = checkpointIdBeforeBatch;
-  var mutBatchSizePerChain = {};
-  var mutProgressBlockNumberPerChain = {};
-  var items = [];
-  var checkpointIds = [];
-  var checkpointChainIds = [];
-  var checkpointBlockNumbers = [];
-  var checkpointBlockHashes = [];
-  var checkpointEventsProcessed = [];
-  while(totalBatchSize < batchSizeTarget && chainIdx < preparedNumber) {
-    var fetchState = preparedFetchStates[chainIdx];
-    var chainBatchSize = FetchState.getReadyItemsCount(fetchState, batchSizeTarget - totalBatchSize, 0);
-    var chainBeforeBatch = ChainMap.get(chainsBeforeBatch, ChainMap.Chain.makeUnsafe(fetchState.chainId));
-    var prevBlockNumber = chainBeforeBatch.progressBlockNumber;
+  let preparedFetchStates = FetchState.sortForUnorderedBatch(ChainMap.values(chainsBeforeBatch).map(chainBeforeBatch => chainBeforeBatch.fetchState), batchSizeTarget);
+  let chainIdx = 0;
+  let preparedNumber = preparedFetchStates.length;
+  let totalBatchSize = 0;
+  let prevCheckpointId = checkpointIdBeforeBatch;
+  let mutBatchSizePerChain = {};
+  let mutProgressBlockNumberPerChain = {};
+  let items = [];
+  let checkpointIds = [];
+  let checkpointChainIds = [];
+  let checkpointBlockNumbers = [];
+  let checkpointBlockHashes = [];
+  let checkpointEventsProcessed = [];
+  while (totalBatchSize < batchSizeTarget && chainIdx < preparedNumber) {
+    let fetchState = preparedFetchStates[chainIdx];
+    let chainBatchSize = FetchState.getReadyItemsCount(fetchState, batchSizeTarget - totalBatchSize, 0);
+    let chainBeforeBatch = ChainMap.get(chainsBeforeBatch, ChainMap.Chain.makeUnsafe(fetchState.chainId));
+    let prevBlockNumber = chainBeforeBatch.progressBlockNumber;
     if (chainBatchSize > 0) {
-      for(var idx = 0 ,idx_finish = chainBatchSize - 1; idx <= idx_finish; ++idx){
-        var item = fetchState.buffer[idx];
-        var blockNumber = item.blockNumber;
+      for (let idx = 0, idx_finish = chainBatchSize - 1; idx <= idx_finish; ++idx) {
+        let item = fetchState.buffer[idx];
+        let blockNumber = item.blockNumber;
         if (blockNumber !== prevBlockNumber) {
-          var chainId = fetchState.chainId;
-          var fromBlockExclusive = prevBlockNumber;
-          var reorgDetection = chainBeforeBatch.reorgDetection;
-          var prevCheckpointId$1 = prevCheckpointId;
-          var tmp;
+          let chainId = fetchState.chainId;
+          let fromBlockExclusive = prevBlockNumber;
+          let reorgDetection = chainBeforeBatch.reorgDetection;
+          let prevCheckpointId$1 = prevCheckpointId;
+          let tmp;
           if (reorgDetection.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection.dataByBlockNumber)) {
-            var prevCheckpointId$2 = prevCheckpointId$1;
-            for(var blockNumber$1 = fromBlockExclusive + 1 ,blockNumber_finish = blockNumber - 1; blockNumber$1 <= blockNumber_finish; ++blockNumber$1){
-              var hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber$1);
+            let prevCheckpointId$2 = prevCheckpointId$1;
+            for (let blockNumber$1 = fromBlockExclusive + 1, blockNumber_finish = blockNumber - 1; blockNumber$1 <= blockNumber_finish; ++blockNumber$1) {
+              let hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber$1);
               if (hash !== null) {
-                var checkpointId = $$BigInt.add(prevCheckpointId$2, 1n);
+                let checkpointId = prevCheckpointId$2 + 1n;
                 prevCheckpointId$2 = checkpointId;
                 checkpointIds.push(checkpointId);
                 checkpointChainIds.push(chainId);
@@ -271,14 +258,13 @@ function prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batch
                 checkpointBlockHashes.push(hash);
                 checkpointEventsProcessed.push(0);
               }
-              
             }
             tmp = prevCheckpointId$2;
           } else {
             tmp = prevCheckpointId$1;
           }
           prevCheckpointId = tmp;
-          var checkpointId$1 = $$BigInt.add(prevCheckpointId, 1n);
+          let checkpointId$1 = prevCheckpointId + 1n;
           checkpointIds.push(checkpointId$1);
           checkpointChainIds.push(fetchState.chainId);
           checkpointBlockNumbers.push(blockNumber);
@@ -287,7 +273,7 @@ function prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batch
           prevBlockNumber = blockNumber;
           prevCheckpointId = checkpointId$1;
         } else {
-          var lastIndex = checkpointEventsProcessed.length - 1;
+          let lastIndex = checkpointEventsProcessed.length - 1;
           checkpointEventsProcessed[lastIndex] = checkpointEventsProcessed[lastIndex] + 1;
         }
         items.push(item);
@@ -295,19 +281,19 @@ function prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batch
       totalBatchSize = totalBatchSize + chainBatchSize;
       mutBatchSizePerChain[fetchState.chainId] = chainBatchSize;
     }
-    var progressBlockNumberAfterBatch = FetchState.getUnorderedMultichainProgressBlockNumberAt(fetchState, chainBatchSize);
-    var chainId$1 = fetchState.chainId;
-    var toBlockExclusive = progressBlockNumberAfterBatch + 1;
-    var fromBlockExclusive$1 = prevBlockNumber;
-    var reorgDetection$1 = chainBeforeBatch.reorgDetection;
-    var prevCheckpointId$3 = prevCheckpointId;
-    var tmp$1;
+    let progressBlockNumberAfterBatch = FetchState.getUnorderedMultichainProgressBlockNumberAt(fetchState, chainBatchSize);
+    let chainId$1 = fetchState.chainId;
+    let toBlockExclusive = progressBlockNumberAfterBatch + 1;
+    let fromBlockExclusive$1 = prevBlockNumber;
+    let reorgDetection$1 = chainBeforeBatch.reorgDetection;
+    let prevCheckpointId$3 = prevCheckpointId;
+    let tmp$1;
     if (reorgDetection$1.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection$1.dataByBlockNumber)) {
-      var prevCheckpointId$4 = prevCheckpointId$3;
-      for(var blockNumber$2 = fromBlockExclusive$1 + 1 ,blockNumber_finish$1 = toBlockExclusive - 1; blockNumber$2 <= blockNumber_finish$1; ++blockNumber$2){
-        var hash$1 = ReorgDetection.getHashByBlockNumber(reorgDetection$1, blockNumber$2);
+      let prevCheckpointId$4 = prevCheckpointId$3;
+      for (let blockNumber$2 = fromBlockExclusive$1 + 1, blockNumber_finish$1 = toBlockExclusive - 1; blockNumber$2 <= blockNumber_finish$1; ++blockNumber$2) {
+        let hash$1 = ReorgDetection.getHashByBlockNumber(reorgDetection$1, blockNumber$2);
         if (hash$1 !== null) {
-          var checkpointId$2 = $$BigInt.add(prevCheckpointId$4, 1n);
+          let checkpointId$2 = prevCheckpointId$4 + 1n;
           prevCheckpointId$4 = checkpointId$2;
           checkpointIds.push(checkpointId$2);
           checkpointChainIds.push(chainId$1);
@@ -315,7 +301,6 @@ function prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batch
           checkpointBlockHashes.push(hash$1);
           checkpointEventsProcessed.push(0);
         }
-        
       }
       tmp$1 = prevCheckpointId$4;
     } else {
@@ -326,19 +311,19 @@ function prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batch
     chainIdx = chainIdx + 1;
   };
   return {
-          totalBatchSize: totalBatchSize,
-          items: items,
-          progressedChainsById: getProgressedChainsById(chainsBeforeBatch, mutBatchSizePerChain, mutProgressBlockNumberPerChain),
-          checkpointIds: checkpointIds,
-          checkpointChainIds: checkpointChainIds,
-          checkpointBlockNumbers: checkpointBlockNumbers,
-          checkpointBlockHashes: checkpointBlockHashes,
-          checkpointEventsProcessed: checkpointEventsProcessed
-        };
+    totalBatchSize: totalBatchSize,
+    items: items,
+    progressedChainsById: getProgressedChainsById(chainsBeforeBatch, mutBatchSizePerChain, mutProgressBlockNumberPerChain),
+    checkpointIds: checkpointIds,
+    checkpointChainIds: checkpointChainIds,
+    checkpointBlockNumbers: checkpointBlockNumbers,
+    checkpointBlockHashes: checkpointBlockHashes,
+    checkpointEventsProcessed: checkpointEventsProcessed
+  };
 }
 
 function make(checkpointIdBeforeBatch, chainsBeforeBatch, multichain, batchSizeTarget) {
-  var tmp;
+  let tmp;
   tmp = multichain === "ordered" ? ChainMap.size(chainsBeforeBatch) === 1 : true;
   if (tmp) {
     return prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget);
@@ -348,11 +333,11 @@ function make(checkpointIdBeforeBatch, chainsBeforeBatch, multichain, batchSizeT
 }
 
 function findFirstEventBlockNumber(batch, chainId) {
-  var idx = 0;
-  var result;
-  var checkpointsLength = batch.checkpointIds.length;
-  while(idx < checkpointsLength && result === undefined) {
-    var checkpointChainId = batch.checkpointChainIds[idx];
+  let idx = 0;
+  let result;
+  let checkpointsLength = batch.checkpointIds.length;
+  while (idx < checkpointsLength && result === undefined) {
+    let checkpointChainId = batch.checkpointChainIds[idx];
     if (checkpointChainId === chainId && batch.checkpointEventsProcessed[idx] > 0) {
       result = batch.checkpointBlockNumbers[idx];
     } else {
@@ -363,10 +348,10 @@ function findFirstEventBlockNumber(batch, chainId) {
 }
 
 function findLastEventItem(batch, chainId) {
-  var idx = batch.items.length - 1;
-  var result;
-  while(idx >= 0 && result === undefined) {
-    var item = batch.items[idx];
+  let idx = batch.items.length - 1;
+  let result;
+  while (idx >= 0 && result === undefined) {
+    let item = batch.items[idx];
     if (item.kind === 0 && item.chain === chainId) {
       result = item;
     } else {
@@ -377,17 +362,17 @@ function findLastEventItem(batch, chainId) {
 }
 
 export {
-  getOrderedNextChain ,
-  immutableEmptyBatchSizePerChain ,
-  hasOrderedReadyItem ,
-  hasUnorderedReadyItem ,
-  hasMultichainReadyItem ,
-  getProgressedChainsById ,
-  addReorgCheckpoints ,
-  prepareOrderedBatch ,
-  prepareUnorderedBatch ,
-  make ,
-  findFirstEventBlockNumber ,
-  findLastEventItem ,
+  getOrderedNextChain,
+  immutableEmptyBatchSizePerChain,
+  hasOrderedReadyItem,
+  hasUnorderedReadyItem,
+  hasMultichainReadyItem,
+  getProgressedChainsById,
+  addReorgCheckpoints,
+  prepareOrderedBatch,
+  prepareUnorderedBatch,
+  make,
+  findFirstEventBlockNumber,
+  findLastEventItem,
 }
 /* Utils Not a pure module */

package/src/Bin.res

@@ -0,0 +1,89 @@
+@val external processChdir: string => unit = "process.chdir"
+let setEnvVar: (string, string) => unit = %raw(`(k, v) => { process.env[k] = v; }`)
+
+// Crash on unhandled promise rejections with a readable error.
+// ReScript exceptions compile to plain objects, not Error instances, so Node.js prints "#<Object>".
+NodeJs.globalProcess->NodeJs.onUnhandledRejection(reason => {
+  Logging.errorWithExn(reason->Utils.prettifyExn, "Unhandled promise rejection")
+  NodeJs.process->NodeJs.exitWithCode(Failure)
+})
+
+// Wire format mirrors the Rust `executor::Command` enum — a tagged JSON
+// object with a `kind` discriminator.
+// `migrate` is `Null.t`, not `option`: Rust serde encodes `None` as JSON
+// `null`, but ReScript's `option` expects `undefined`, so a `null` value
+// wrongly passes `Option.map`'s `!== undefined` check. Callers convert via
+// `Null.toOption` at use time.
+type startCmd = {
+  migrate: Null.t<Main.migrateOpts>,
+  cwd: string,
+  env: dict<JSON.t>,
+  config: JSON.t,
+}
+type migrateCmd = {reset: bool, persistedState: JSON.t, config: JSON.t}
+type dropSchemaCmd = {config: JSON.t}
+
+type command =
+  | Start(startCmd)
+  | Migrate(migrateCmd)
+  | DropSchema(dropSchemaCmd)
+
+let decodeCommand = (json: JSON.t): command => {
+  let obj = switch json->JSON.Decode.object {
+  | Some(o) => o
+  | None => JsError.throwWithMessage("Invalid command payload: not an object")
+  }
+  let kind = switch obj->Dict.get("kind")->Option.flatMap(JSON.Decode.string) {
+  | Some(k) => k
+  | None => JsError.throwWithMessage("Invalid command payload: missing kind")
+  }
+  switch kind {
+  | "start" => Start(json->(Utils.magic: JSON.t => startCmd))
+  | "migrate" => Migrate(json->(Utils.magic: JSON.t => migrateCmd))
+  | "drop-schema" => DropSchema(json->(Utils.magic: JSON.t => dropSchemaCmd))
+  | other => JsError.throwWithMessage(`Unknown command kind: ${other}`)
+  }
+}
+
+let applyEnv = (env: dict<JSON.t>) =>
+  env->Dict.forEachWithKey((value, key) => {
+    switch value->JSON.Decode.string {
+    | Some(v) => setEnvVar(key, v)
+    | None => ()
+    }
+  })
+
+let run = async args => {
+  try {
+    switch (await Core.runCli(args))->Null.toOption {
+    // Rust-only command (codegen / init / stop / docker / help / version /
+    // scripts) — nothing for JS to do, exit cleanly.
+    | None => ()
+    | Some(json) =>
+      switch decodeCommand(json->JSON.parseOrThrow) {
+      | Start({migrate, cwd, env, config}) =>
+        Config.prime(config)
+        processChdir(cwd)
+        applyEnv(env)
+        await Main.start(~migrate=?migrate->Null.toOption)
+      | Migrate({reset, persistedState, config}) =>
+        Config.prime(config)
+        await Main.migrate(~reset, ~persistedState)
+      | DropSchema({config}) =>
+        Config.prime(config)
+        await Main.dropSchema()
+      }
+    }
+  } catch {
+  | exn =>
+    // Log just the exception's own message — wrapping it in "Failed at
+    // initialization" and pino's err serializer buries the real cause under
+    // a nested `err: { type, message, stack, ... }` block.
+    let message = switch exn->JsExn.anyToExnInternal {
+    | JsExn(e) => e->JsExn.message->Option.getOr("Failed at initialization")
+    | _ => "Failed at initialization"
+    }
+    Logging.error(message)
+    NodeJs.process->NodeJs.exitWithCode(Failure)
+  }
+}