envio 2.29.2 → 2.30.0

package/src/sources/RpcSource.res.js

@@ -11,6 +11,7 @@ var Ethers = require("../bindings/Ethers.res.js");
 var Hrtime = require("../bindings/Hrtime.res.js");
 var Js_exn = require("rescript/lib/js/js_exn.js");
 var Source = require("./Source.res.js");
+var Address = require("../Address.res.js");
 var Logging = require("../Logging.res.js");
 var $$Promise = require("../bindings/Promise.res.js");
 var Belt_Int = require("rescript/lib/js/belt_Int.js");
@@ -22,6 +23,7 @@ var Caml_option = require("rescript/lib/js/caml_option.js");
 var EventRouter = require("./EventRouter.res.js");
 var LogSelection = require("../LogSelection.res.js");
 var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+var HyperSyncClient = require("./HyperSyncClient.res.js");
 var Caml_splice_call = require("rescript/lib/js/caml_splice_call.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
@@ -38,9 +40,10 @@ function getKnownBlock(provider, blockNumber) {
             });
 }
 
-async function getKnownBlockWithBackoff(provider, sourceName, chain, blockNumber, backoffMsOnFailure) {
+async function getKnownBlockWithBackoff(provider, sourceName, chain, blockNumber, backoffMsOnFailure, lowercaseAddresses) {
+  var result;
   try {
-    return await getKnownBlock(provider, blockNumber);
+    result = await getKnownBlock(provider, blockNumber);
   }
   catch (raw_err){
     var err = Caml_js_exceptions.internalToOCamlException(raw_err);
@@ -52,8 +55,12 @@ async function getKnownBlockWithBackoff(provider, sourceName, chain, blockNumber
           type: "EXPONENTIAL_BACKOFF"
         });
     await Time.resolvePromiseAfterDelay(backoffMsOnFailure);
-    return await getKnownBlockWithBackoff(provider, sourceName, chain, blockNumber, (backoffMsOnFailure << 1));
+    return await getKnownBlockWithBackoff(provider, sourceName, chain, blockNumber, (backoffMsOnFailure << 1), lowercaseAddresses);
   }
+  if (lowercaseAddresses) {
+    result.miner = Address.Evm.fromAddressLowercaseOrThrow(result.miner);
+  }
+  return result;
 }
 
 var suggestedRangeRegExp = /retry with the range (\d+)-(\d+)/;
@@ -485,6 +492,9 @@ function sanitizeUrl(url) {
 }
 
 function make(param) {
+  var lowercaseAddresses = param.lowercaseAddresses;
+  var shouldUseHypersyncClientDecoder = param.shouldUseHypersyncClientDecoder;
+  var allEventSignatures = param.allEventSignatures;
   var eventRouter = param.eventRouter;
   var chain = param.chain;
   var url = param.url;
@@ -510,7 +520,7 @@ function make(param) {
               });
         }), undefined, undefined, undefined, undefined);
   var blockLoader = LazyLoader.make((function (blockNumber) {
-          return getKnownBlockWithBackoff(provider, name, chain, blockNumber, 1000);
+          return getKnownBlockWithBackoff(provider, name, chain, blockNumber, 1000, lowercaseAddresses);
         }), (function (am, exn) {
           Logging.error({
                 err: exn,
@@ -526,13 +536,51 @@ function make(param) {
   var getEventBlockOrThrow = makeThrowingGetEventBlock(function (blockNumber) {
         return LazyLoader.get(blockLoader, blockNumber);
       });
-  var getEventTransactionOrThrow = makeThrowingGetEventTransaction(Ethers.JsonRpcProvider.makeGetTransactionFields(function (__x) {
-            return LazyLoader.get(transactionLoader, __x);
-          }));
+  var getEventTransactionOrThrow = makeThrowingGetEventTransaction(Ethers.JsonRpcProvider.makeGetTransactionFields((function (__x) {
+              return LazyLoader.get(transactionLoader, __x);
+            }), lowercaseAddresses));
   var contractNameAbiMapping = {};
   Belt_Array.forEach(param.contracts, (function (contract) {
           contractNameAbiMapping[contract.name] = contract.abi;
         }));
+  var convertEthersLogToHyperSyncEvent = function (log) {
+    var hyperSyncLog_removed = Belt_Option.getWithDefault(log.removed, false);
+    var hyperSyncLog_logIndex = log.index;
+    var hyperSyncLog_transactionIndex = log.transactionIndex;
+    var hyperSyncLog_transactionHash = log.transactionHash;
+    var hyperSyncLog_blockHash = log.blockHash;
+    var hyperSyncLog_blockNumber = log.blockNumber;
+    var hyperSyncLog_address = Caml_option.some(log.address);
+    var hyperSyncLog_data = log.data;
+    var hyperSyncLog_topics = Belt_Array.map(log.topics, (function (topic) {
+            return topic;
+          }));
+    var hyperSyncLog = {
+      removed: hyperSyncLog_removed,
+      logIndex: hyperSyncLog_logIndex,
+      transactionIndex: hyperSyncLog_transactionIndex,
+      transactionHash: hyperSyncLog_transactionHash,
+      blockHash: hyperSyncLog_blockHash,
+      blockNumber: hyperSyncLog_blockNumber,
+      address: hyperSyncLog_address,
+      data: hyperSyncLog_data,
+      topics: hyperSyncLog_topics
+    };
+    return {
+            log: hyperSyncLog
+          };
+  };
+  var hscDecoder = {
+    contents: undefined
+  };
+  var getHscDecoder = function () {
+    var decoder = hscDecoder.contents;
+    if (decoder !== undefined) {
+      return decoder;
+    } else {
+      return HyperSyncClient.Decoder.fromSignatures(allEventSignatures);
+    }
+  };
   var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, currentBlockHeight, partitionId, selection, param, param$1) {
     var startFetchingBatchTimeRef = Hrtime.makeTimer();
     var maxSuggestedBlockInterval = mutSuggestedBlockIntervals[maxSuggestedBlockIntervalKey];
@@ -548,77 +596,151 @@ function make(param) {
             return LazyLoader.get(blockLoader, blockNumber);
           }), syncConfig, provider, mutSuggestedBlockIntervals, partitionId);
     var latestFetchedBlock = match$2.latestFetchedBlock;
+    var logs = match$2.logs;
     var executedBlockInterval = (suggestedToBlock - fromBlock | 0) + 1 | 0;
     if (executedBlockInterval >= suggestedBlockInterval && !Utils.Dict.has(mutSuggestedBlockIntervals, maxSuggestedBlockIntervalKey)) {
       mutSuggestedBlockIntervals[partitionId] = Caml.int_min(executedBlockInterval + syncConfig.accelerationAdditive | 0, syncConfig.intervalCeiling);
     }
-    var parsedQueueItems = await Promise.all(Belt_Array.keepMap(match$2.logs, (function (log) {
-                var topic0 = log.topics[0];
-                var eventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), log.address, log.blockNumber, indexingContracts);
-                if (eventConfig === undefined) {
-                  return ;
-                }
-                var blockNumber = log.blockNumber;
-                var logIndex = log.index;
-                return Caml_option.some((async function () {
-                                var match;
-                                try {
-                                  match = await Promise.all([
-                                        getEventBlockOrThrow(log),
-                                        getEventTransactionOrThrow(log, eventConfig.transactionSchema)
-                                      ]);
-                                }
-                                catch (raw_exn){
-                                  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-                                  throw {
-                                        RE_EXN_ID: Source.GetItemsError,
-                                        _1: {
-                                          TAG: "FailedGettingFieldSelection",
-                                          exn: exn,
-                                          blockNumber: blockNumber,
-                                          logIndex: logIndex,
-                                          message: "Failed getting selected fields. Please double-check your RPC provider returns correct data."
-                                        },
-                                        Error: new Error()
-                                      };
-                                }
-                                var block = match[0];
-                                var decodedEvent;
-                                try {
-                                  decodedEvent = Viem.parseLogOrThrow(contractNameAbiMapping, eventConfig.contractName, log.topics, log.data);
-                                }
-                                catch (raw_exn$1){
-                                  var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
-                                  throw {
-                                        RE_EXN_ID: Source.GetItemsError,
-                                        _1: {
-                                          TAG: "FailedParsingItems",
-                                          exn: exn$1,
-                                          blockNumber: blockNumber,
-                                          logIndex: logIndex,
-                                          message: "Failed to parse event with viem, please double-check your ABI."
-                                        },
-                                        Error: new Error()
-                                      };
-                                }
-                                return {
-                                        kind: 0,
-                                        eventConfig: eventConfig,
-                                        timestamp: block.timestamp,
-                                        chain: chain,
-                                        blockNumber: block.number,
-                                        logIndex: log.index,
-                                        event: {
-                                          params: decodedEvent.args,
-                                          chainId: chain,
-                                          srcAddress: log.address,
+    var parsedQueueItems;
+    if (shouldUseHypersyncClientDecoder) {
+      var hyperSyncEvents = Belt_Array.map(logs, convertEthersLogToHyperSyncEvent);
+      var parsedEvents;
+      try {
+        parsedEvents = await getHscDecoder().decodeEvents(hyperSyncEvents);
+      }
+      catch (raw_exn){
+        var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+        throw {
+              RE_EXN_ID: Source.GetItemsError,
+              _1: {
+                TAG: "FailedParsingItems",
+                exn: exn,
+                blockNumber: fromBlock,
+                logIndex: 0,
+                message: "Failed to parse events using hypersync client decoder. Please double-check your ABI."
+              },
+              Error: new Error()
+            };
+      }
+      parsedQueueItems = await Promise.all(Belt_Array.keepMap(Belt_Array.zip(logs, parsedEvents), (function (param) {
+                  var maybeDecodedEvent = param[1];
+                  var log = param[0];
+                  var topic0 = Belt_Option.getWithDefault(Belt_Array.get(log.topics, 0), "0x0");
+                  var routedAddress = lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(log.address) : log.address;
+                  var eventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), routedAddress, log.blockNumber, indexingContracts);
+                  if (eventConfig !== undefined && !(maybeDecodedEvent === null || maybeDecodedEvent === undefined)) {
+                    return Caml_option.some((async function () {
+                                    var match;
+                                    try {
+                                      match = await Promise.all([
+                                            getEventBlockOrThrow(log),
+                                            getEventTransactionOrThrow(log, eventConfig.transactionSchema)
+                                          ]);
+                                    }
+                                    catch (raw_exn){
+                                      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+                                      throw {
+                                            RE_EXN_ID: Source.GetItemsError,
+                                            _1: {
+                                              TAG: "FailedGettingFieldSelection",
+                                              exn: exn,
+                                              blockNumber: log.blockNumber,
+                                              logIndex: log.index,
+                                              message: "Failed getting selected fields. Please double-check your RPC provider returns correct data."
+                                            },
+                                            Error: new Error()
+                                          };
+                                    }
+                                    var block = match[0];
+                                    return {
+                                            kind: 0,
+                                            eventConfig: eventConfig,
+                                            timestamp: block.timestamp,
+                                            chain: chain,
+                                            blockNumber: block.number,
+                                            logIndex: log.index,
+                                            event: {
+                                              params: eventConfig.convertHyperSyncEventArgs(maybeDecodedEvent),
+                                              chainId: chain,
+                                              srcAddress: routedAddress,
+                                              logIndex: log.index,
+                                              transaction: match[1],
+                                              block: block
+                                            }
+                                          };
+                                  })());
+                  }
+                  
+                })));
+    } else {
+      parsedQueueItems = await Promise.all(Belt_Array.keepMap(logs, (function (log) {
+                  var topic0 = log.topics[0];
+                  var eventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), log.address, log.blockNumber, indexingContracts);
+                  if (eventConfig === undefined) {
+                    return ;
+                  }
+                  var blockNumber = log.blockNumber;
+                  var logIndex = log.index;
+                  return Caml_option.some((async function () {
+                                  var match;
+                                  try {
+                                    match = await Promise.all([
+                                          getEventBlockOrThrow(log),
+                                          getEventTransactionOrThrow(log, eventConfig.transactionSchema)
+                                        ]);
+                                  }
+                                  catch (raw_exn){
+                                    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+                                    throw {
+                                          RE_EXN_ID: Source.GetItemsError,
+                                          _1: {
+                                            TAG: "FailedGettingFieldSelection",
+                                            exn: exn,
+                                            blockNumber: blockNumber,
+                                            logIndex: logIndex,
+                                            message: "Failed getting selected fields. Please double-check your RPC provider returns correct data."
+                                          },
+                                          Error: new Error()
+                                        };
+                                  }
+                                  var block = match[0];
+                                  var decodedEvent;
+                                  try {
+                                    decodedEvent = Viem.parseLogOrThrow(contractNameAbiMapping, eventConfig.contractName, log.topics, log.data);
+                                  }
+                                  catch (raw_exn$1){
+                                    var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+                                    throw {
+                                          RE_EXN_ID: Source.GetItemsError,
+                                          _1: {
+                                            TAG: "FailedParsingItems",
+                                            exn: exn$1,
+                                            blockNumber: blockNumber,
+                                            logIndex: logIndex,
+                                            message: "Failed to parse event with viem, please double-check your ABI."
+                                          },
+                                          Error: new Error()
+                                        };
+                                  }
+                                  return {
+                                          kind: 0,
+                                          eventConfig: eventConfig,
+                                          timestamp: block.timestamp,
+                                          chain: chain,
+                                          blockNumber: block.number,
                                           logIndex: log.index,
-                                          transaction: match[1],
-                                          block: block
-                                        }
-                                      };
-                              })());
-              })));
+                                          event: {
+                                            params: decodedEvent.args,
+                                            chainId: chain,
+                                            srcAddress: log.address,
+                                            logIndex: log.index,
+                                            transaction: match[1],
+                                            block: block
+                                          }
+                                        };
+                                })());
+                })));
+    }
     var optFirstBlockParent = await firstBlockParentPromise;
     var totalTimeElapsed = Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(startFetchingBatchTimeRef)));
     var reorgGuard_rangeLastBlock = {