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

package/src/sources/HyperFuelSource.res.mjs

@@ -2,263 +2,253 @@
 
 import * as Rest from "../vendored/Rest.res.mjs";
 import * as Hrtime from "../bindings/Hrtime.res.mjs";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Source from "./Source.res.mjs";
 import * as Logging from "../Logging.res.mjs";
-import * as $$Promise from "../bindings/Promise.res.mjs";
 import * as HyperFuel from "./HyperFuel.res.mjs";
 import * as HyperSync from "./HyperSync.res.mjs";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Prometheus from "../Prometheus.res.mjs";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
 import * as EventRouter from "./EventRouter.res.mjs";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
-import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-var EventRoutingFailed = /* @__PURE__ */Caml_exceptions.create("HyperFuelSource.EventRoutingFailed");
+let EventRoutingFailed = /* @__PURE__ */Primitive_exceptions.create("HyperFuelSource.EventRoutingFailed");
 
-var mintEventTag = "mint";
+let mintEventTag = "mint";
 
-var burnEventTag = "burn";
+let burnEventTag = "burn";
 
-var transferEventTag = "transfer";
+let transferEventTag = "transfer";
 
-var callEventTag = "call";
+let callEventTag = "call";
 
-var logDataReceiptTypeSelection = [6];
+let logDataReceiptTypeSelection = [6];
 
-var txStatusSelection = [1];
+let txStatusSelection = [1];
 
 function makeGetNormalRecieptsSelection(nonWildcardLogDataRbsByContract, nonLogDataReceiptTypesByContract, contractNames) {
-  return function (addressesByContractName) {
-    var selection = [];
-    contractNames.forEach(function (contractName) {
-          var addresses = addressesByContractName[contractName];
-          if (addresses === undefined) {
-            return ;
-          }
-          if (addresses.length === 0) {
-            return ;
-          }
-          var receiptTypes = nonLogDataReceiptTypesByContract[contractName];
-          if (receiptTypes !== undefined) {
-            selection.push({
-                  rootContractId: addresses,
-                  receiptType: receiptTypes,
-                  txStatus: txStatusSelection
-                });
-          }
-          var nonWildcardLogDataRbs = nonWildcardLogDataRbsByContract[contractName];
-          if (nonWildcardLogDataRbs !== undefined && nonWildcardLogDataRbs.length !== 0) {
-            selection.push({
-                  rootContractId: addresses,
-                  receiptType: logDataReceiptTypeSelection,
-                  rb: nonWildcardLogDataRbs,
-                  txStatus: txStatusSelection
-                });
-            return ;
-          }
-          
+  return addressesByContractName => {
+    let selection = [];
+    contractNames.forEach(contractName => {
+      let addresses = addressesByContractName[contractName];
+      if (addresses === undefined) {
+        return;
+      }
+      if (addresses.length === 0) {
+        return;
+      }
+      let receiptTypes = nonLogDataReceiptTypesByContract[contractName];
+      if (receiptTypes !== undefined) {
+        selection.push({
+          rootContractId: addresses,
+          receiptType: receiptTypes,
+          txStatus: txStatusSelection
+        });
+      }
+      let nonWildcardLogDataRbs = nonWildcardLogDataRbsByContract[contractName];
+      if (nonWildcardLogDataRbs !== undefined && nonWildcardLogDataRbs.length !== 0) {
+        selection.push({
+          rootContractId: addresses,
+          receiptType: logDataReceiptTypeSelection,
+          rb: nonWildcardLogDataRbs,
+          txStatus: txStatusSelection
         });
+        return;
+      }
+    });
     return selection;
   };
 }
 
 function makeWildcardRecieptsSelection(wildcardLogDataRbs, nonLogDataWildcardReceiptTypes) {
-  var selection = [];
+  let selection = [];
   if (nonLogDataWildcardReceiptTypes.length !== 0) {
     selection.push({
-          receiptType: nonLogDataWildcardReceiptTypes,
-          txStatus: txStatusSelection
-        });
+      receiptType: nonLogDataWildcardReceiptTypes,
+      txStatus: txStatusSelection
+    });
   }
   if (wildcardLogDataRbs.length !== 0) {
     selection.push({
-          receiptType: logDataReceiptTypeSelection,
-          rb: wildcardLogDataRbs,
-          txStatus: txStatusSelection
-        });
+      receiptType: logDataReceiptTypeSelection,
+      rb: wildcardLogDataRbs,
+      txStatus: txStatusSelection
+    });
   }
   return selection;
 }
 
 function getSelectionConfig(selection, chain) {
-  var eventRouter = EventRouter.empty();
-  var nonWildcardLogDataRbsByContract = {};
-  var wildcardLogDataRbs = [];
-  var nonLogDataReceiptTypesByContract = {};
-  var nonLogDataWildcardReceiptTypes = [];
-  var addNonLogDataWildcardReceiptTypes = function (receiptType) {
+  let eventRouter = EventRouter.empty();
+  let nonWildcardLogDataRbsByContract = {};
+  let wildcardLogDataRbs = [];
+  let nonLogDataReceiptTypesByContract = {};
+  let nonLogDataWildcardReceiptTypes = [];
+  let addNonLogDataWildcardReceiptTypes = receiptType => {
     nonLogDataWildcardReceiptTypes.push(receiptType);
   };
-  var addNonLogDataReceiptType = function (contractName, receiptType) {
-    var receiptTypes = nonLogDataReceiptTypesByContract[contractName];
+  let addNonLogDataReceiptType = (contractName, receiptType) => {
+    let receiptTypes = nonLogDataReceiptTypesByContract[contractName];
     if (receiptTypes !== undefined) {
       receiptTypes.push(receiptType);
     } else {
       nonLogDataReceiptTypesByContract[contractName] = [receiptType];
     }
   };
-  var contractNames = new Set();
-  Belt_Array.forEach(selection.eventConfigs, (function (eventConfig) {
-          var contractName = eventConfig.contractName;
-          if (!eventConfig.isWildcard) {
-            contractNames.add(contractName);
-          }
-          EventRouter.addOrThrow(eventRouter, eventConfig.id, eventConfig, contractName, eventConfig.isWildcard, eventConfig.name, chain);
-          var isWildcard = eventConfig.isWildcard;
-          if (isWildcard) {
-            var tmp = eventConfig.kind;
-            if (typeof tmp !== "object") {
-              switch (tmp) {
-                case "Mint" :
-                    return addNonLogDataWildcardReceiptTypes(11);
-                case "Burn" :
-                    return addNonLogDataWildcardReceiptTypes(12);
-                case "Transfer" :
-                    addNonLogDataWildcardReceiptTypes(7);
-                    return addNonLogDataWildcardReceiptTypes(8);
-                case "Call" :
-                    return addNonLogDataWildcardReceiptTypes(0);
-                
-              }
-            }
-            
-          }
-          var match = eventConfig.kind;
-          if (typeof match !== "object") {
-            switch (match) {
-              case "Mint" :
-                  return addNonLogDataReceiptType(contractName, 11);
-              case "Burn" :
-                  return addNonLogDataReceiptType(contractName, 12);
-              case "Transfer" :
-                  addNonLogDataReceiptType(contractName, 7);
-                  return addNonLogDataReceiptType(contractName, 8);
-              case "Call" :
-                  return Js_exn.raiseError("Call receipt indexing currently supported only in wildcard mode");
-              
-            }
-          } else {
-            var rb = BigInt(match.logId);
-            if (isWildcard) {
-              wildcardLogDataRbs.push(rb);
-              return ;
-            }
-            var arr = nonWildcardLogDataRbsByContract[contractName];
-            if (arr !== undefined) {
-              arr.push(rb);
-            } else {
-              nonWildcardLogDataRbsByContract[contractName] = [rb];
-            }
-            return ;
-          }
-        }));
-  var tmp;
+  let contractNames = new Set();
+  selection.eventConfigs.forEach(eventConfig => {
+    let contractName = eventConfig.contractName;
+    if (!eventConfig.isWildcard) {
+      contractNames.add(contractName);
+    }
+    EventRouter.addOrThrow(eventRouter, eventConfig.id, eventConfig, contractName, eventConfig.isWildcard, eventConfig.name, chain);
+    let isWildcard = eventConfig.isWildcard;
+    if (isWildcard) {
+      let tmp = eventConfig.kind;
+      if (typeof tmp !== "object") {
+        switch (tmp) {
+          case "Mint" :
+            return addNonLogDataWildcardReceiptTypes(11);
+          case "Burn" :
+            return addNonLogDataWildcardReceiptTypes(12);
+          case "Transfer" :
+            addNonLogDataWildcardReceiptTypes(7);
+            return addNonLogDataWildcardReceiptTypes(8);
+          case "Call" :
+            return addNonLogDataWildcardReceiptTypes(0);
+        }
+      }
+    }
+    let match = eventConfig.kind;
+    if (typeof match !== "object") {
+      switch (match) {
+        case "Mint" :
+          return addNonLogDataReceiptType(contractName, 11);
+        case "Burn" :
+          return addNonLogDataReceiptType(contractName, 12);
+        case "Transfer" :
+          addNonLogDataReceiptType(contractName, 7);
+          return addNonLogDataReceiptType(contractName, 8);
+        case "Call" :
+          return Stdlib_JsError.throwWithMessage("Call receipt indexing currently supported only in wildcard mode");
+      }
+    } else {
+      let rb = BigInt(match.logId);
+      if (isWildcard) {
+        wildcardLogDataRbs.push(rb);
+        return;
+      }
+      let arr = nonWildcardLogDataRbsByContract[contractName];
+      if (arr !== undefined) {
+        arr.push(rb);
+      } else {
+        nonWildcardLogDataRbsByContract[contractName] = [rb];
+      }
+      return;
+    }
+  });
+  let tmp;
   if (selection.dependsOnAddresses) {
     tmp = makeGetNormalRecieptsSelection(nonWildcardLogDataRbsByContract, nonLogDataReceiptTypesByContract, contractNames);
   } else {
-    var recieptsSelection = makeWildcardRecieptsSelection(wildcardLogDataRbs, nonLogDataWildcardReceiptTypes);
-    tmp = (function (param) {
-        return recieptsSelection;
-      });
+    let recieptsSelection = makeWildcardRecieptsSelection(wildcardLogDataRbs, nonLogDataWildcardReceiptTypes);
+    tmp = param => recieptsSelection;
   }
   return {
-          getRecieptsSelection: tmp,
-          eventRouter: eventRouter
-        };
+    getRecieptsSelection: tmp,
+    eventRouter: eventRouter
+  };
 }
 
 function memoGetSelectionConfig(chain) {
-  var cache = new WeakMap();
-  return function (selection) {
-    var c = cache.get(selection);
+  let cache = new WeakMap();
+  return selection => {
+    let c = cache.get(selection);
     if (c !== undefined) {
       return c;
     }
-    var c$1 = getSelectionConfig(selection, chain);
+    let c$1 = getSelectionConfig(selection, chain);
     cache.set(selection, c$1);
     return c$1;
   };
 }
 
 function make(param) {
-  var endpointUrl = param.endpointUrl;
-  var chain = param.chain;
-  var name = "HyperFuel";
-  var getSelectionConfig = memoGetSelectionConfig(chain);
-  var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, knownHeight, param, selection, retry, logger) {
-    var mkLogAndRaise = function (extra, extra$1) {
-      return ErrorHandling.mkLogAndRaise(logger, extra, extra$1);
-    };
-    var totalTimeRef = Hrtime.makeTimer();
-    var selectionConfig = getSelectionConfig(selection);
-    var recieptsSelection = selectionConfig.getRecieptsSelection(addressesByContractName);
-    var startFetchingBatchTimeRef = Hrtime.makeTimer();
+  let endpointUrl = param.endpointUrl;
+  let chain = param.chain;
+  let name = "HyperFuel";
+  let getSelectionConfig = memoGetSelectionConfig(chain);
+  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, indexingAddresses, knownHeight, param, selection, retry, logger) => {
+    let mkLogAndRaise = (extra, extra$1) => ErrorHandling.mkLogAndRaise(logger, extra, extra$1);
+    let totalTimeRef = Hrtime.makeTimer();
+    let selectionConfig = getSelectionConfig(selection);
+    let recieptsSelection = selectionConfig.getRecieptsSelection(addressesByContractName);
+    let startFetchingBatchTimeRef = Hrtime.makeTimer();
     Prometheus.SourceRequestCount.increment(name, chain, "getLogs");
-    var pageUnsafe;
+    let pageUnsafe;
     try {
       pageUnsafe = await HyperFuel.GetLogs.query(endpointUrl, fromBlock, toBlock, recieptsSelection);
-    }
-    catch (raw_error){
-      var error = Caml_js_exceptions.internalToOCamlException(raw_error);
+    } catch (raw_error) {
+      let error = Primitive_exceptions.internalToException(raw_error);
       if (error.RE_EXN_ID === HyperSync.GetLogs.$$Error) {
-        var error$1 = error._1;
-        var tmp;
+        let error$1 = error._1;
+        let tmp;
         if (typeof error$1 !== "object") {
-          var backoffMillis = retry !== 0 ? Math.imul(500, retry) : 100;
+          let backoffMillis = retry !== 0 ? 500 * retry | 0 : 100;
           tmp = {
             TAG: "WithBackoff",
-            message: "Block #" + String(fromBlock) + " not found in HyperFuel. HyperFuel has multiple instances and it's possible that they drift independently slightly from the head. Indexing should continue correctly after retrying the query in " + String(backoffMillis) + "ms.",
+            message: `Block #` + fromBlock.toString() + ` not found in HyperFuel. HyperFuel has multiple instances and it's possible that they drift independently slightly from the head. Indexing should continue correctly after retrying the query in ` + backoffMillis.toString() + `ms.`,
             backoffMillis: backoffMillis
           };
         } else {
           tmp = {
             TAG: "ImpossibleForTheQuery",
-            message: "Source returned invalid data with missing required fields: " + error$1.missingParams.join(", ")
+            message: `Source returned invalid data with missing required fields: ` + error$1.missingParams.join(", ")
           };
         }
         throw {
-              RE_EXN_ID: Source.GetItemsError,
-              _1: {
-                TAG: "FailedGettingItems",
-                exn: null,
-                attemptedToBlock: Belt_Option.getWithDefault(toBlock, knownHeight),
-                retry: tmp
-              },
-              Error: new Error()
-            };
+          RE_EXN_ID: Source.GetItemsError,
+          _1: {
+            TAG: "FailedGettingItems",
+            exn: null,
+            attemptedToBlock: Stdlib_Option.getOr(toBlock, knownHeight),
+            retry: tmp
+          },
+          Error: new Error()
+        };
       }
       throw {
-            RE_EXN_ID: Source.GetItemsError,
-            _1: {
-              TAG: "FailedGettingItems",
-              exn: error,
-              attemptedToBlock: Belt_Option.getWithDefault(toBlock, knownHeight),
-              retry: {
-                TAG: "WithBackoff",
-                message: "Unexpected issue while fetching events from HyperFuel client. Attempt a retry.",
-                backoffMillis: retry !== 0 ? Math.imul(1000, retry) : 500
-              }
-            },
-            Error: new Error()
-          };
+        RE_EXN_ID: Source.GetItemsError,
+        _1: {
+          TAG: "FailedGettingItems",
+          exn: error,
+          attemptedToBlock: Stdlib_Option.getOr(toBlock, knownHeight),
+          retry: {
+            TAG: "WithBackoff",
+            message: `Unexpected issue while fetching events from HyperFuel client. Attempt a retry.`,
+            backoffMillis: retry !== 0 ? 1000 * retry | 0 : 500
+          }
+        },
+        Error: new Error()
+      };
     }
-    var pageFetchTime = Hrtime.toSecondsFloat(Hrtime.timeSince(startFetchingBatchTimeRef));
-    var knownHeight$1 = pageUnsafe.archiveHeight;
-    var heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
-    var match = Belt_Array.get(pageUnsafe.items, pageUnsafe.items.length - 1 | 0);
-    var lastBlockQueriedPromise;
-    var exit = 0;
+    let pageFetchTime = Hrtime.toSecondsFloat(Hrtime.timeSince(startFetchingBatchTimeRef));
+    let knownHeight$1 = pageUnsafe.archiveHeight;
+    let heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
+    let match = Belt_Array.get(pageUnsafe.items, pageUnsafe.items.length - 1 | 0);
+    let lastBlockQueriedPromise;
+    let exit = 0;
     if (match !== undefined) {
-      var block = match.block;
+      let block = match.block;
       if (block.height === heighestBlockQueried) {
         lastBlockQueriedPromise = Promise.resolve({
-              blockHash: block.id,
-              blockNumber: block.height,
-              blockTimestamp: block.time
-            });
+          blockHash: block.id,
+          blockNumber: block.height,
+          blockTimestamp: block.time
+        });
       } else {
         exit = 1;
       }
@@ -266,196 +256,189 @@ function make(param) {
       exit = 1;
     }
     if (exit === 1) {
-      lastBlockQueriedPromise = $$Promise.$$catch(HyperFuel.queryBlockData(endpointUrl, heighestBlockQueried, logger).then(function (res) {
-                if (res !== undefined) {
-                  return res;
-                } else {
-                  return mkLogAndRaise("Failure, blockData for block " + String(heighestBlockQueried) + " unexpectedly returned None", {
-                              RE_EXN_ID: "Not_found"
-                            });
-                }
-              }), (function (exn) {
-              return mkLogAndRaise("Failed to query blockData for block " + String(heighestBlockQueried), exn);
-            }));
+      lastBlockQueriedPromise = Stdlib_Promise.$$catch(HyperFuel.queryBlockData(endpointUrl, heighestBlockQueried, logger).then(res => {
+        if (res !== undefined) {
+          return res;
+        } else {
+          return mkLogAndRaise(`Failure, blockData for block ` + heighestBlockQueried.toString() + ` unexpectedly returned None`, {
+            RE_EXN_ID: "Not_found"
+          });
+        }
+      }), exn => mkLogAndRaise(`Failed to query blockData for block ` + heighestBlockQueried.toString(), exn));
     }
-    var parsingTimeRef = Hrtime.makeTimer();
-    var parsedQueueItems = Belt_Array.map(pageUnsafe.items, (function (item) {
-            var block = item.block;
-            var receiptIndex = item.receiptIndex;
-            var receipt = item.receipt;
-            var contractAddress = item.contractId;
-            var eventId;
-            switch (receipt.receiptType) {
-              case 0 :
-                  eventId = callEventTag;
-                  break;
-              case 6 :
-                  eventId = receipt.rb.toString();
-                  break;
-              case 7 :
-              case 8 :
-                  eventId = transferEventTag;
-                  break;
-              case 11 :
-                  eventId = mintEventTag;
-                  break;
-              case 12 :
-                  eventId = burnEventTag;
-                  break;
-              
-            }
-            var eventConfig = EventRouter.get(selectionConfig.eventRouter, eventId, contractAddress, block.height, indexingContracts);
-            var eventConfig$1;
-            if (eventConfig !== undefined) {
-              eventConfig$1 = eventConfig;
-            } else {
-              var logger$1 = Logging.createChildFrom(logger, {
-                    chainId: chain,
-                    blockNumber: block.height,
-                    logIndex: receiptIndex,
-                    contractAddress: contractAddress,
-                    eventId: eventId
-                  });
-              eventConfig$1 = ErrorHandling.mkLogAndRaise(logger$1, "Failed to route registered event", {
-                    RE_EXN_ID: EventRoutingFailed
-                  });
-            }
-            var match = eventConfig$1.kind;
-            var params;
-            var exit = 0;
-            if (typeof match !== "object" || receipt.receiptType !== 6) {
-              exit = 1;
-            } else {
-              try {
-                params = match.decode(receipt.data);
-              }
-              catch (raw_exn){
-                var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-                var params$1 = {
-                  chainId: chain,
-                  blockNumber: block.height,
-                  logIndex: receiptIndex
-                };
-                var logger$2 = Logging.createChildFrom(logger, params$1);
-                params = ErrorHandling.mkLogAndRaise(logger$2, "Failed to decode Fuel LogData receipt, please double check your ABI.", exn);
-              }
-            }
-            if (exit === 1) {
-              switch (receipt.receiptType) {
-                case 0 :
-                    params = {
-                      to: receipt.to,
-                      assetId: receipt.assetId,
-                      amount: receipt.amount
-                    };
-                    break;
-                case 6 :
-                    params = Js_exn.raiseError("Unexpected bug in the event routing logic");
-                    break;
-                case 7 :
-                    params = {
-                      to: receipt.to,
-                      assetId: receipt.assetId,
-                      amount: receipt.amount
-                    };
-                    break;
-                case 8 :
-                    params = {
-                      to: receipt.toAddress,
-                      assetId: receipt.assetId,
-                      amount: receipt.amount
-                    };
-                    break;
-                case 11 :
-                case 12 :
-                    params = {
-                      subId: receipt.subId,
-                      amount: receipt.val
-                    };
-                    break;
-                
-              }
-            }
-            return {
-                    kind: 0,
-                    eventConfig: eventConfig$1,
-                    timestamp: block.time,
-                    chain: chain,
-                    blockNumber: block.height,
-                    logIndex: receiptIndex,
-                    event: {
-                      contractName: eventConfig$1.contractName,
-                      eventName: eventConfig$1.name,
-                      params: params,
-                      chainId: chain,
-                      srcAddress: contractAddress,
-                      logIndex: receiptIndex,
-                      transaction: {
-                        id: item.transactionId
-                      },
-                      block: block
-                    }
-                  };
-          }));
-    var parsingTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(parsingTimeRef));
-    var rangeLastBlock = await lastBlockQueriedPromise;
-    var reorgGuard = {
+    let parsingTimeRef = Hrtime.makeTimer();
+    let parsedQueueItems = pageUnsafe.items.map(item => {
+      let block = item.block;
+      let receiptIndex = item.receiptIndex;
+      let receipt = item.receipt;
+      let contractAddress = item.contractId;
+      let eventId;
+      switch (receipt.receiptType) {
+        case 0 :
+          eventId = callEventTag;
+          break;
+        case 6 :
+          eventId = receipt.rb.toString();
+          break;
+        case 7 :
+        case 8 :
+          eventId = transferEventTag;
+          break;
+        case 11 :
+          eventId = mintEventTag;
+          break;
+        case 12 :
+          eventId = burnEventTag;
+          break;
+      }
+      let eventConfig = EventRouter.get(selectionConfig.eventRouter, eventId, contractAddress, block.height, indexingAddresses);
+      let eventConfig$1;
+      if (eventConfig !== undefined) {
+        eventConfig$1 = eventConfig;
+      } else {
+        let logger$1 = Logging.createChildFrom(logger, {
+          chainId: chain,
+          blockNumber: block.height,
+          logIndex: receiptIndex,
+          contractAddress: contractAddress,
+          eventId: eventId
+        });
+        eventConfig$1 = ErrorHandling.mkLogAndRaise(logger$1, "Failed to route registered event", {
+          RE_EXN_ID: EventRoutingFailed
+        });
+      }
+      let match = eventConfig$1.kind;
+      let params;
+      let exit = 0;
+      if (typeof match !== "object" || receipt.receiptType !== 6) {
+        exit = 1;
+      } else {
+        try {
+          params = match.decode(receipt.data);
+        } catch (raw_exn) {
+          let exn = Primitive_exceptions.internalToException(raw_exn);
+          let params$1 = {
+            chainId: chain,
+            blockNumber: block.height,
+            logIndex: receiptIndex
+          };
+          let logger$2 = Logging.createChildFrom(logger, params$1);
+          params = ErrorHandling.mkLogAndRaise(logger$2, "Failed to decode Fuel LogData receipt, please double check your ABI.", exn);
+        }
+      }
+      if (exit === 1) {
+        switch (receipt.receiptType) {
+          case 0 :
+            params = {
+              to: receipt.to,
+              assetId: receipt.assetId,
+              amount: receipt.amount
+            };
+            break;
+          case 6 :
+            params = Stdlib_JsError.throwWithMessage("Unexpected bug in the event routing logic");
+            break;
+          case 7 :
+            params = {
+              to: receipt.to,
+              assetId: receipt.assetId,
+              amount: receipt.amount
+            };
+            break;
+          case 8 :
+            params = {
+              to: receipt.toAddress,
+              assetId: receipt.assetId,
+              amount: receipt.amount
+            };
+            break;
+          case 11 :
+          case 12 :
+            params = {
+              subId: receipt.subId,
+              amount: receipt.val
+            };
+            break;
+        }
+      }
+      return {
+        kind: 0,
+        eventConfig: eventConfig$1,
+        timestamp: block.time,
+        chain: chain,
+        blockNumber: block.height,
+        logIndex: receiptIndex,
+        event: {
+          contractName: eventConfig$1.contractName,
+          eventName: eventConfig$1.name,
+          params: params,
+          chainId: chain,
+          srcAddress: contractAddress,
+          logIndex: receiptIndex,
+          transaction: {
+            id: item.transactionId
+          },
+          block: block
+        }
+      };
+    });
+    let parsingTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(parsingTimeRef));
+    let rangeLastBlock = await lastBlockQueriedPromise;
+    let reorgGuard = {
       rangeLastBlock: rangeLastBlock,
       prevRangeLastBlock: undefined
     };
-    var totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(totalTimeRef));
-    var stats_parsing$unknowntime$unknown$lpars$rpar = parsingTimeElapsed;
-    var stats_page$unknownfetch$unknowntime$unknown$lpars$rpar = pageFetchTime;
-    var stats = {
+    let totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(totalTimeRef));
+    let stats_parsing$unknowntime$unknown$lpars$rpar = parsingTimeElapsed;
+    let stats_page$unknownfetch$unknowntime$unknown$lpars$rpar = pageFetchTime;
+    let stats = {
       "total time elapsed (s)": totalTimeElapsed,
       "parsing time (s)": stats_parsing$unknowntime$unknown$lpars$rpar,
       "page fetch time (s)": stats_page$unknownfetch$unknowntime$unknown$lpars$rpar
     };
     return {
-            knownHeight: knownHeight$1,
-            reorgGuard: reorgGuard,
-            parsedQueueItems: parsedQueueItems,
-            fromBlockQueried: fromBlock,
-            latestFetchedBlockNumber: rangeLastBlock.blockNumber,
-            latestFetchedBlockTimestamp: rangeLastBlock.blockTimestamp,
-            stats: stats
-          };
-  };
-  var getBlockHashes = function (param, param$1) {
-    return Js_exn.raiseError("HyperFuel does not support getting block hashes");
+      knownHeight: knownHeight$1,
+      reorgGuard: reorgGuard,
+      parsedQueueItems: parsedQueueItems,
+      fromBlockQueried: fromBlock,
+      latestFetchedBlockNumber: rangeLastBlock.blockNumber,
+      latestFetchedBlockTimestamp: rangeLastBlock.blockTimestamp,
+      stats: stats
+    };
   };
-  var jsonApiClient = Rest.client(endpointUrl, undefined);
+  let getBlockHashes = (param, param$1) => Stdlib_JsError.throwWithMessage("HyperFuel does not support getting block hashes");
+  let jsonApiClient = Rest.client(endpointUrl, undefined);
   return {
-          name: name,
-          sourceFor: "Sync",
-          chain: chain,
-          poweredByHyperSync: true,
-          pollingInterval: 100,
-          getBlockHashes: getBlockHashes,
-          getHeightOrThrow: (async function () {
-              var timerRef = Hrtime.makeTimer();
-              var height = await Rest.$$fetch(HyperFuel.heightRoute, undefined, jsonApiClient);
-              var seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef));
-              Prometheus.SourceRequestCount.increment(name, chain, "getHeight");
-              Prometheus.SourceRequestCount.addSeconds(name, chain, "getHeight", seconds);
-              return height;
-            }),
-          getItemsOrThrow: getItemsOrThrow
-        };
+    name: name,
+    sourceFor: "Sync",
+    chain: chain,
+    poweredByHyperSync: true,
+    pollingInterval: 100,
+    getBlockHashes: getBlockHashes,
+    getHeightOrThrow: async () => {
+      let timerRef = Hrtime.makeTimer();
+      let height = await Rest.fetch(HyperFuel.heightRoute, undefined, jsonApiClient);
+      let seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef));
+      Prometheus.SourceRequestCount.increment(name, chain, "getHeight");
+      Prometheus.SourceRequestCount.addSeconds(name, chain, "getHeight", seconds);
+      return height;
+    },
+    getItemsOrThrow: getItemsOrThrow
+  };
 }
 
 export {
-  EventRoutingFailed ,
-  mintEventTag ,
-  burnEventTag ,
-  transferEventTag ,
-  callEventTag ,
-  logDataReceiptTypeSelection ,
-  txStatusSelection ,
-  makeGetNormalRecieptsSelection ,
-  makeWildcardRecieptsSelection ,
-  getSelectionConfig ,
-  memoGetSelectionConfig ,
-  make ,
+  EventRoutingFailed,
+  mintEventTag,
+  burnEventTag,
+  transferEventTag,
+  callEventTag,
+  logDataReceiptTypeSelection,
+  txStatusSelection,
+  makeGetNormalRecieptsSelection,
+  makeWildcardRecieptsSelection,
+  getSelectionConfig,
+  memoGetSelectionConfig,
+  make,
 }
 /* Rest Not a pure module */