Make an option to make addresses lower case

codegenerator/cli/npm/envio/evm.schema.json

@@ -113,6 +113,17 @@
         "boolean",
         "null"
       ]
+    },
+    "address_format": {
+      "description": "Address format for Ethereum addresses: 'checksum' or 'lowercase' (default: checksum)",
+      "anyOf": [
+        {
+          "$ref": "#/$defs/AddressFormat"
+        },
+        {
+          "type": "null"
+        }
+      ]
     }
   },
   "additionalProperties": false,
@@ -653,6 +664,13 @@
         "viem",
         "hypersync-client"
       ]
+    },
+    "AddressFormat": {
+      "type": "string",
+      "enum": [
+        "checksum",
+        "lowercase"
+      ]
     }
   }
 }

codegenerator/cli/npm/envio/src/Address.res

@@ -10,6 +10,29 @@ external unsafeFromString: string => t = "%identity"
 module Evm = {
   @module("viem")
   external fromStringOrThrow: string => t = "getAddress"
+
+  // NOTE: the function is named to be overshadowed by the one below, so that we don't have to import viem in the handler code
+  @module("viem")
+  external fromStringLowercaseOrThrow: string => bool = "isAddress"
+
+  // Reassign since the function might be used in the handler code
+  // and we don't want to have a "viem" import there. It's needed to keep "viem" a dependency
+  // of generated code instead of adding it to the indexer project dependencies.
+  // Also, we want a custom error message, which is searchable in our codebase.
+  // Validate that the string is a proper address but return a lowercased value
+  let fromStringLowercaseOrThrow = string => {
+    if fromStringLowercaseOrThrow(string) {
+      unsafeFromString(string->Js.String2.toLowerCase)
+    } else {
+      Js.Exn.raiseError(
+        `Address "${string}" is invalid. Expected a 20-byte hex string starting with 0x.`,
+      )
+    }
+  }
+
+  let fromAddressLowercaseOrThrow = address =>
+    address->toString->Js.String2.toLowerCase->(Utils.magic: string => t)
+
   // Reassign since the function might be used in the handler code
   // and we don't want to have a "viem" import there. It's needed to keep "viem" a dependency
   // of generated code instead of adding it to the indexer project dependencies.

codegenerator/cli/npm/envio/src/bindings/Ethers.res

@@ -147,19 +147,43 @@ module JsonRpcProvider = {
   @send
   external getTransaction: (t, ~transactionHash: string) => promise<transaction> = "getTransaction"
 
-  let makeGetTransactionFields = (~getTransactionByHash) =>
-    async (log: log): promise<unknown> => {
-      let transaction = await getTransactionByHash(log.transactionHash)
-      // Mutating should be fine, since the transaction isn't used anywhere else outside the function
-      let fields: {..} = transaction->Obj.magic
-
-      // Make it compatible with HyperSync transaction fields
-      fields["transactionIndex"] = log.transactionIndex
-      fields["input"] = fields["data"]
-
-      fields->Obj.magic
+  let makeGetTransactionFields = (~getTransactionByHash, ~lowercaseAddresses: bool) => async (
+    log: log,
+  ): promise<unknown> => {
+    let transaction = await getTransactionByHash(log.transactionHash)
+    // Mutating should be fine, since the transaction isn't used anywhere else outside the function
+    let fields: {..} = transaction->Obj.magic
+
+    // Make it compatible with HyperSync transaction fields
+    fields["transactionIndex"] = log.transactionIndex
+    fields["input"] = fields["data"]
+
+    // NOTE: this is wasteful if these fields are not selected in the users config.
+    //       There might be a better way to do this in the `makeThrowingGetEventTransaction` function rather based on the schema.
+    //       However this is not extremely expensive and good enough for now (only on rpc sync also).
+    if lowercaseAddresses {
+      open Js.Nullable
+      switch fields["from"] {
+      | Value(from) => fields["from"] = from->Js.String2.toLowerCase
+      | Undefined => ()
+      | Null => ()
+      }
+      switch fields["to"] {
+      | Value(to) => fields["to"] = to->Js.String2.toLowerCase
+      | Undefined => ()
+      | Null => ()
+      }
+      switch fields["contractAddress"] {
+      | Value(contractAddress) =>
+        fields["contractAddress"] = contractAddress->Js.String2.toLowerCase
+      | Undefined => ()
+      | Null => ()
+      }
     }
 
+    fields->Obj.magic
+  }
+
   type block = {
     _difficulty: bigint,
     difficulty: int,

codegenerator/cli/npm/envio/src/sources/HyperSyncClient.res

@@ -448,10 +448,16 @@ type t = {
 }
 
 @module("@envio-dev/hypersync-client") @scope("HypersyncClient") external make: cfg => t = "new"
-let make = (~url, ~apiToken, ~httpReqTimeoutMillis, ~maxNumRetries) =>
+let make = (
+  ~url,
+  ~apiToken,
+  ~httpReqTimeoutMillis,
+  ~maxNumRetries,
+  ~enableChecksumAddresses=true,
+) =>
   make({
     url,
-    enableChecksumAddresses: true,
+    enableChecksumAddresses,
     bearerToken: apiToken,
     httpReqTimeoutMillis,
     maxNumRetries,

codegenerator/cli/npm/envio/src/sources/HyperSyncSource.res

@@ -154,6 +154,7 @@ type options = {
   apiToken: option<string>,
   clientMaxRetries: int,
   clientTimeoutMillis: int,
+  lowercaseAddresses: bool,
 }
 
 let make = (
@@ -167,6 +168,7 @@ let make = (
     apiToken,
     clientMaxRetries,
     clientTimeoutMillis,
+    lowercaseAddresses,
   }: options,
 ): t => {
   let name = "HyperSync"
@@ -180,6 +182,7 @@ let make = (
     ~apiToken,
     ~maxNumRetries=clientMaxRetries,
     ~httpReqTimeoutMillis=clientTimeoutMillis,
+    ~enableChecksumAddresses=!lowercaseAddresses,
   )
 
   let hscDecoder: ref<option<HyperSyncClient.Decoder.t>> = ref(None)
@@ -193,7 +196,11 @@ let make = (
           ~msg="Failed to instantiate a decoder from hypersync client, please double check your ABI or try using 'event_decoder: viem' config option",
         )
       | decoder =>
-        decoder.enableChecksummedAddresses()
+        if lowercaseAddresses {
+          decoder.disableChecksummedAddresses()
+        } else {
+          decoder.enableChecksummedAddresses()
+        }
         decoder
       }
     }

codegenerator/cli/npm/envio/src/sources/RpcSource.res

@@ -22,6 +22,7 @@ let rec getKnownBlockWithBackoff = async (
   ~chain,
   ~blockNumber,
   ~backoffMsOnFailure,
+  ~lowercaseAddresses: bool,
 ) =>
   switch await getKnownBlock(provider, blockNumber) {
   | exception err =>
@@ -39,8 +40,17 @@ let rec getKnownBlockWithBackoff = async (
       ~chain,
       ~blockNumber,
       ~backoffMsOnFailure=backoffMsOnFailure * 2,
+      ~lowercaseAddresses,
     )
-  | result => result
+  | result =>
+    if lowercaseAddresses {
+      // NOTE: this is wasteful if these fields are not selected in the users config.
+      //       There might be a better way to do this based on the block schema.
+      //       However this is not extremely expensive and good enough for now (only on rpc sync also).
+      // The in place mutation is cheapest.
+      (result->Obj.magic)["miner"] = result.miner->Address.Evm.fromAddressLowercaseOrThrow
+    }
+    result
   }
 let getSuggestedBlockIntervalFromExn = {
   // Unknown provider: "retry with the range 123-456"
@@ -453,9 +463,24 @@ type options = {
   chain: ChainMap.Chain.t,
   contracts: array<Internal.evmContractConfig>,
   eventRouter: EventRouter.t<Internal.evmEventConfig>,
+  allEventSignatures: array<string>,
+  shouldUseHypersyncClientDecoder: bool,
+  lowercaseAddresses: bool,
 }
 
-let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options): t => {
+let make = (
+  {
+    sourceFor,
+    syncConfig,
+    url,
+    chain,
+    contracts,
+    eventRouter,
+    allEventSignatures,
+    shouldUseHypersyncClientDecoder,
+    lowercaseAddresses,
+  }: options,
+): t => {
   let urlHost = switch sanitizeUrl(url) {
   | None =>
     Js.Exn.raiseError(
@@ -498,6 +523,7 @@ let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options
         ~chain,
         ~backoffMsOnFailure=1000,
         ~blockNumber,
+        ~lowercaseAddresses,
       ),
     ~onError=(am, ~exn) => {
       Logging.error({
@@ -522,6 +548,7 @@ let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options
   let getEventTransactionOrThrow = makeThrowingGetEventTransaction(
     ~getTransactionFields=Ethers.JsonRpcProvider.makeGetTransactionFields(
       ~getTransactionByHash=LazyLoader.get(transactionLoader, _),
+      ~lowercaseAddresses,
     ),
   )
 
@@ -530,6 +557,32 @@ let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options
     contractNameAbiMapping->Js.Dict.set(contract.name, contract.abi)
   })
 
+  let convertEthersLogToHyperSyncEvent = (log: Ethers.log): HyperSyncClient.ResponseTypes.event => {
+    let hyperSyncLog: HyperSyncClient.ResponseTypes.log = {
+      removed: log.removed->Option.getWithDefault(false),
+      index: log.logIndex,
+      transactionIndex: log.transactionIndex,
+      transactionHash: log.transactionHash,
+      blockHash: log.blockHash,
+      blockNumber: log.blockNumber,
+      address: log.address,
+      data: log.data,
+      topics: log.topics->Array.map(topic => Js.Nullable.return(topic)),
+    }
+    {log: hyperSyncLog}
+  }
+
+  let hscDecoder: ref<option<HyperSyncClient.Decoder.t>> = ref(None)
+  let getHscDecoder = () => {
+    switch hscDecoder.contents {
+    | Some(decoder) => decoder
+    | None => {
+        let decoder = HyperSyncClient.Decoder.fromSignatures(allEventSignatures)
+        decoder
+      }
+    }
+  }
+
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
@@ -603,10 +656,106 @@ let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options
       )
     }
 
-    let parsedQueueItems =
+    let parsedQueueItems = if shouldUseHypersyncClientDecoder {
+      // Convert Ethers logs to HyperSync events
+      let hyperSyncEvents = logs->Belt.Array.map(convertEthersLogToHyperSyncEvent)
+
+      // Decode using HyperSyncClient decoder
+      let parsedEvents = try await getHscDecoder().decodeEvents(hyperSyncEvents) catch {
+      | exn =>
+        raise(
+          Source.GetItemsError(
+            FailedParsingItems({
+              message: "Failed to parse events using hypersync client decoder. Please double-check your ABI.",
+              exn,
+              blockNumber: fromBlock,
+              logIndex: 0,
+            }),
+          ),
+        )
+      }
+
+      await logs
+      ->Array.zip(parsedEvents)
+      ->Array.keepMap(((
+        log: Ethers.log,
+        maybeDecodedEvent: Js.Nullable.t<HyperSyncClient.Decoder.decodedEvent>,
+      )) => {
+        let topic0 = log.topics[0]->Option.getWithDefault("0x0"->EvmTypes.Hex.fromStringUnsafe)
+        let routedAddress = if lowercaseAddresses {
+          log.address->Address.Evm.fromAddressLowercaseOrThrow
+        } else {
+          log.address
+        }
+
+        switch eventRouter->EventRouter.get(
+          ~tag=EventRouter.getEvmEventId(
+            ~sighash=topic0->EvmTypes.Hex.toString,
+            ~topicCount=log.topics->Array.length,
+          ),
+          ~indexingContracts,
+          ~contractAddress=routedAddress,
+          ~blockNumber=log.blockNumber,
+        ) {
+        | None => None
+        | Some(eventConfig) =>
+          switch maybeDecodedEvent {
+          | Js.Nullable.Value(decoded) =>
+            Some(
+              (
+                async () => {
+                  let (block, transaction) = try await Promise.all2((
+                    log->getEventBlockOrThrow,
+                    log->getEventTransactionOrThrow(
+                      ~transactionSchema=eventConfig.transactionSchema,
+                    ),
+                  )) catch {
+                  | exn =>
+                    raise(
+                      Source.GetItemsError(
+                        FailedGettingFieldSelection({
+                          message: "Failed getting selected fields. Please double-check your RPC provider returns correct data.",
+                          exn,
+                          blockNumber: log.blockNumber,
+                          logIndex: log.logIndex,
+                        }),
+                      ),
+                    )
+                  }
+
+                  Internal.Event({
+                    eventConfig: (eventConfig :> Internal.eventConfig),
+                    timestamp: block.timestamp,
+                    blockNumber: block.number,
+                    chain,
+                    logIndex: log.logIndex,
+                    event: {
+                      chainId: chain->ChainMap.Chain.toChainId,
+                      params: decoded->eventConfig.convertHyperSyncEventArgs,
+                      transaction,
+                      block: block->(
+                        Utils.magic: Ethers.JsonRpcProvider.block => Internal.eventBlock
+                      ),
+                      srcAddress: routedAddress,
+                      logIndex: log.logIndex,
+                    }->Internal.fromGenericEvent,
+                  })
+                }
+              )(),
+            )
+          | Js.Nullable.Null
+          | Js.Nullable.Undefined =>
+            None
+          }
+        }
+      })
+      ->Promise.all
+    } else {
+      // Decode using Viem
       await logs
       ->Belt.Array.keepMap(log => {
         let topic0 = log.topics->Js.Array2.unsafe_get(0)
+
         switch eventRouter->EventRouter.get(
           ~tag=EventRouter.getEvmEventId(
             ~sighash=topic0->EvmTypes.Hex.toString,
@@ -685,6 +834,7 @@ let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options
         }
       })
       ->Promise.all
+    }
 
     let optFirstBlockParent = await firstBlockParentPromise
 

codegenerator/cli/src/cli_args/init_config.rs

@@ -171,6 +171,7 @@ pub mod evm {
                 field_selection: None,
                 raw_events: None,
                 preload_handlers: Some(true),
+                address_format: None,
             })
         }