envio 3.0.0-alpha.0 → 3.0.0-alpha.10

package/src/UserContext.res.mjs

@@ -0,0 +1,236 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Table from "./db/Table.res.mjs";
+import * as Utils from "./Utils.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Address from "./Address.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as Internal from "./Internal.res.mjs";
+import * as LoadLayer from "./LoadLayer.res.mjs";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as InMemoryStore from "./InMemoryStore.res.mjs";
+import * as InMemoryTable from "./InMemoryTable.res.mjs";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+var codegenHelpMessage = "Rerun 'pnpm dev' to update generated code after schema.graphql changes.";
+
+var paramsByThis = new WeakMap();
+
+var effectContextPrototype = (Object.create(null));
+
+Object.defineProperty(effectContextPrototype, "log", {
+      get: (function () {
+          return Logging.getUserLogger(paramsByThis.get(this).item);
+        })
+    });
+
+var EffectContext = function(params, defaultShouldCache, callEffect) {
+  paramsByThis.set(this, params);
+  this.effect = callEffect;
+  this.cache = defaultShouldCache;
+};
+EffectContext.prototype = effectContextPrototype;
+;
+
+function initEffect(params) {
+  var callEffect = function (effect, input) {
+    var effectContext = new EffectContext(params, effect.defaultShouldCache, callEffect);
+    var effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
+    var effectArgs = {
+      input: input,
+      context: effectContext,
+      cacheKey: effectArgs_cacheKey
+    };
+    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, params.inMemoryStore, params.isPreload, params.item);
+  };
+  return callEffect;
+}
+
+var getWhereTraps = {
+  get: (function (params, prop) {
+      var entityConfig = params.entityConfig;
+      if (typeof prop !== "string") {
+        return Js_exn.raiseError("Invalid context." + entityConfig.name + ".getWhere access by a non-string property.");
+      }
+      var field = Table.getFieldByDbName(entityConfig.table, prop);
+      if (field === undefined) {
+        return Js_exn.raiseError("Invalid context." + entityConfig.name + ".getWhere." + prop + " - the field doesn't exist. " + codegenHelpMessage);
+      }
+      var fieldValueSchema;
+      fieldValueSchema = field.TAG === "Field" ? field._0.fieldSchema : S$RescriptSchema.string;
+      return {
+              eq: (function (fieldValue) {
+                  return LoadLayer.loadByField(params.loadManager, params.persistence, "Eq", entityConfig, params.inMemoryStore, prop, fieldValueSchema, params.isPreload, params.item, fieldValue);
+                }),
+              gt: (function (fieldValue) {
+                  return LoadLayer.loadByField(params.loadManager, params.persistence, "Gt", entityConfig, params.inMemoryStore, prop, fieldValueSchema, params.isPreload, params.item, fieldValue);
+                }),
+              lt: (function (fieldValue) {
+                  return LoadLayer.loadByField(params.loadManager, params.persistence, "Lt", entityConfig, params.inMemoryStore, prop, fieldValueSchema, params.isPreload, params.item, fieldValue);
+                })
+            };
+    })
+};
+
+function noopSet(_entity) {
+  
+}
+
+function noopDeleteUnsafe(_entityId) {
+  
+}
+
+var entityTraps = {
+  get: (function (params, prop) {
+      var set = params.isPreload ? noopSet : (function (entity) {
+            InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), {
+                  type: "SET",
+                  entityId: entity.id,
+                  entity: entity,
+                  checkpointId: params.checkpointId
+                }, params.shouldSaveHistory, undefined);
+          });
+      switch (prop) {
+        case "deleteUnsafe" :
+            if (params.isPreload) {
+              return noopDeleteUnsafe;
+            } else {
+              return function (entityId) {
+                InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), {
+                      type: "DELETE",
+                      entityId: entityId,
+                      checkpointId: params.checkpointId
+                    }, params.shouldSaveHistory, undefined);
+              };
+            }
+        case "get" :
+            return function (entityId) {
+              return LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId);
+            };
+        case "getOrCreate" :
+            return function (entity) {
+              return LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entity.id).then(function (storageEntity) {
+                          if (storageEntity !== undefined) {
+                            return storageEntity;
+                          } else {
+                            set(entity);
+                            return entity;
+                          }
+                        });
+            };
+        case "getOrThrow" :
+            return function (entityId, message) {
+              return LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, params.inMemoryStore, params.isPreload, params.item, entityId).then(function (entity) {
+                          if (entity !== undefined) {
+                            return entity;
+                          } else {
+                            return Js_exn.raiseError(Belt_Option.getWithDefault(message, "Entity '" + params.entityConfig.name + "' with ID '" + entityId + "' is expected to exist."));
+                          }
+                        });
+            };
+        case "getWhere" :
+            return new Proxy(params, getWhereTraps);
+        case "set" :
+            return set;
+        default:
+          return Js_exn.raiseError("Invalid context." + params.entityConfig.name + "." + prop + " operation.");
+      }
+    })
+};
+
+var handlerTraps = {
+  get: (function (params, prop) {
+      if (params.isResolved) {
+        ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error("Impossible to access context." + prop + " after the handler is resolved. Make sure you didn't miss an await in the handler."));
+      }
+      switch (prop) {
+        case "chain" :
+            var chainId = Internal.getItemChainId(params.item);
+            return params.chains[chainId];
+        case "effect" :
+            return initEffect(params);
+        case "isPreload" :
+            return params.isPreload;
+        case "log" :
+            if (params.isPreload) {
+              return Logging.noopLogger;
+            } else {
+              return Logging.getUserLogger(params.item);
+            }
+        default:
+          var entityConfig = params.config.userEntitiesByName[prop];
+          if (entityConfig !== undefined) {
+            return new Proxy({
+                        item: params.item,
+                        checkpointId: params.checkpointId,
+                        inMemoryStore: params.inMemoryStore,
+                        loadManager: params.loadManager,
+                        persistence: params.persistence,
+                        isPreload: params.isPreload,
+                        shouldSaveHistory: params.shouldSaveHistory,
+                        chains: params.chains,
+                        config: params.config,
+                        isResolved: params.isResolved,
+                        entityConfig: entityConfig
+                      }, entityTraps);
+          } else {
+            return Js_exn.raiseError("Invalid context access by '" + prop + "' property. " + codegenHelpMessage);
+          }
+      }
+    })
+};
+
+function getHandlerContext(params) {
+  return new Proxy(params, handlerTraps);
+}
+
+var contractRegisterTraps = {
+  get: (function (params, prop) {
+      if (params.isResolved) {
+        ErrorHandling.mkLogAndRaise(Logging.getItemLogger(params.item), undefined, new Error("Impossible to access context." + prop + " after the contract register is resolved. Make sure you didn't miss an await in the handler."));
+      }
+      if (prop === "log") {
+        return Logging.getUserLogger(params.item);
+      }
+      var contractName = params.config.addContractNameToContractNameMapping[prop];
+      if (contractName !== undefined) {
+        return function (contractAddress) {
+          var validatedAddress = params.config.ecosystem.name === "evm" ? (
+              params.config.lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(contractAddress) : Address.Evm.fromAddressOrThrow(contractAddress)
+            ) : contractAddress;
+          params.onRegister(params.item, validatedAddress, contractName);
+        };
+      } else {
+        return Js_exn.raiseError("Invalid context access by '" + prop + "' property. " + codegenHelpMessage);
+      }
+    })
+};
+
+function getContractRegisterContext(params) {
+  return new Proxy(params, contractRegisterTraps);
+}
+
+function getContractRegisterArgs(params) {
+  return {
+          event: params.item.event,
+          context: new Proxy(params, contractRegisterTraps)
+        };
+}
+
+export {
+  codegenHelpMessage ,
+  paramsByThis ,
+  effectContextPrototype ,
+  initEffect ,
+  getWhereTraps ,
+  noopSet ,
+  noopDeleteUnsafe ,
+  entityTraps ,
+  handlerTraps ,
+  getHandlerContext ,
+  contractRegisterTraps ,
+  getContractRegisterContext ,
+  getContractRegisterArgs ,
+}
+/* paramsByThis Not a pure module */

package/src/Utils.res

@@ -32,6 +32,19 @@ module Object = {
 
   @val @scope("Object")
   external defineProperty: ('obj, string, propertyDescriptor<'a>) => 'obj = "defineProperty"
+
+  // Property descriptor with required value field (no boxing)
+  type enumerablePropertyDescriptor<'a> = {
+    enumerable: bool,
+    value: 'a,
+  }
+
+  @val @scope("Object")
+  external definePropertyWithValue: ('obj, string, enumerablePropertyDescriptor<'a>) => 'obj =
+    "defineProperty"
+
+  @val @scope("Object")
+  external createNullObject: (@as(json`null`) _, unit) => 'a = "create"
 }
 
 module Error = {
@@ -175,6 +188,15 @@ module Dict = {
     }
   `)
 
+  let unsafeDeleteUndefinedFieldsInPlace: 'a => unit = %raw(`(dict) => {
+      for (var key in dict) {
+        if (dict[key] === undefined) {
+          delete dict[key];
+        }
+      }
+    }
+  `)
+
   let updateImmutable: (
     dict<'a>,
     string,
@@ -472,6 +494,12 @@ module Schema = {
     ->(magic: S.t<Js.Json.t> => S.t<Js.Date.t>)
     ->S.preprocess(_ => {serializer: date => date->magic->Js.Date.toISOString})
 
+  // ClickHouse expects timestamps as numbers (milliseconds), not ISO strings
+  let clickHouseDate =
+    S.json(~validate=false)
+    ->(magic: S.t<Js.Json.t> => S.t<Js.Date.t>)
+    ->S.preprocess(_ => {serializer: date => date->magic->Js.Date.getTime})
+
   // When trying to serialize data to Json pg type, it will fail with
   // PostgresError: column "params" is of type json but expression is of type boolean
   // If there's bool or null on the root level. It works fine as object field values.

package/src/Utils.res.mjs

@@ -151,6 +151,14 @@ var deleteInPlace = ((dict, key) => {
       delete dict[key];
     });
 
+var unsafeDeleteUndefinedFieldsInPlace = ((dict) => {
+      for (var key in dict) {
+        if (dict[key] === undefined) {
+          delete dict[key];
+        }
+      }
+    });
+
 var updateImmutable = ((dict, key, value) => ({...dict, [key]: value}));
 
 var shallowCopy = ((dict) => ({...dict}));
@@ -172,6 +180,7 @@ var Dict = {
   size: size,
   isEmpty: isEmpty,
   deleteInPlace: deleteInPlace,
+  unsafeDeleteUndefinedFieldsInPlace: unsafeDeleteUndefinedFieldsInPlace,
   updateImmutable: updateImmutable,
   shallowCopy: shallowCopy,
   incrementByInt: incrementByInt
@@ -449,6 +458,14 @@ var dbDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), (function
               };
       }));
 
+var clickHouseDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), (function (param) {
+        return {
+                s: (function (date) {
+                    return date.getTime();
+                  })
+              };
+      }));
+
 function coerceToJsonPgType(schema) {
   return S$RescriptSchema.preprocess(schema, (function (s) {
                 var match = s.schema.t;
@@ -485,6 +502,7 @@ var Schema = {
   getNonOptionalFieldNames: getNonOptionalFieldNames,
   getCapitalizedFieldNames: getCapitalizedFieldNames,
   dbDate: dbDate,
+  clickHouseDate: clickHouseDate,
   coerceToJsonPgType: coerceToJsonPgType
 };
 

package/src/bindings/ClickHouse.res

@@ -98,6 +98,36 @@ let getClickHouseFieldType = (
   isNullable ? `Nullable(${baseType})` : baseType
 }
 
+// Creates an entity schema from table definition, using clickHouseDate for Date fields
+let makeClickHouseEntitySchema = (table: Table.table): S.t<Internal.entity> => {
+  S.schema(s => {
+    let dict = Js.Dict.empty()
+    table.fields->Belt.Array.forEach(field => {
+      switch field {
+      | Field(f) => {
+          let fieldName = f->Table.getDbFieldName
+          let fieldSchema = switch f.fieldType {
+          | Date => {
+              let dateSchema = Utils.Schema.clickHouseDate->S.toUnknown
+              if f.isNullable {
+                S.null(dateSchema)->S.toUnknown
+              } else if f.isArray {
+                S.array(dateSchema)->S.toUnknown
+              } else {
+                dateSchema
+              }
+            }
+          | _ => f.fieldSchema
+          }
+          dict->Js.Dict.set(fieldName, s.matches(fieldSchema))
+        }
+      | DerivedFrom(_) => () // Skip derived fields
+      }
+    })
+    dict->Utils.magic
+  })
+}
+
 let setCheckpointsOrThrow = async (client, ~batch: Batch.t, ~database: string) => {
   let checkpointsCount = batch.checkpointIds->Array.length
   if checkpointsCount === 0 {
@@ -154,7 +184,7 @@ let setUpdatesOrThrow = async (
           )}\``,
         convertOrThrow: S.compile(
           S.union([
-            EntityHistory.makeSetUpdateSchema(entityConfig.schema),
+            EntityHistory.makeSetUpdateSchema(makeClickHouseEntitySchema(entityConfig.table)),
             S.object(s => {
               s.tag(EntityHistory.changeFieldName, EntityHistory.RowAction.DELETE)
               Change.Delete({

package/src/bindings/ClickHouse.res.mjs

@@ -76,6 +76,31 @@ function getClickHouseFieldType(fieldType, isNullable, isArray) {
   }
 }
 
+function makeClickHouseEntitySchema(table) {
+  return S$RescriptSchema.schema(function (s) {
+              var dict = {};
+              Belt_Array.forEach(table.fields, (function (field) {
+                      if (field.TAG !== "Field") {
+                        return ;
+                      }
+                      var f = field._0;
+                      var fieldName = Table.getDbFieldName(f);
+                      var match = f.fieldType;
+                      var fieldSchema;
+                      if (typeof match !== "object" && match === "Date") {
+                        var dateSchema = Utils.Schema.clickHouseDate;
+                        fieldSchema = f.isNullable ? S$RescriptSchema.$$null(dateSchema) : (
+                            f.isArray ? S$RescriptSchema.array(dateSchema) : dateSchema
+                          );
+                      } else {
+                        fieldSchema = f.fieldSchema;
+                      }
+                      dict[fieldName] = s.m(fieldSchema);
+                    }));
+              return dict;
+            });
+}
+
 async function setCheckpointsOrThrow(client, batch, database) {
   var checkpointsCount = batch.checkpointIds.length;
   if (checkpointsCount === 0) {
@@ -120,7 +145,7 @@ async function setUpdatesOrThrow(client, updates, entityConfig, database) {
   } else {
     var cache_tableName = database + ".\`" + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + "\`";
     var cache_convertOrThrow = S$RescriptSchema.compile(S$RescriptSchema.union([
-              EntityHistory.makeSetUpdateSchema(entityConfig.schema),
+              EntityHistory.makeSetUpdateSchema(makeClickHouseEntitySchema(entityConfig.table)),
               S$RescriptSchema.object(function (s) {
                     s.tag(EntityHistory.changeFieldName, "DELETE");
                     return {
@@ -264,6 +289,7 @@ async function resume(client, database, checkpointId) {
 
 export {
   getClickHouseFieldType ,
+  makeClickHouseEntitySchema ,
   setCheckpointsOrThrow ,
   setUpdatesOrThrow ,
   makeCreateHistoryTableQuery ,

package/src/bindings/DateFns.res

@@ -0,0 +1,71 @@
+/**
+Formats: 
+hh:mm:ss         | 00:00:00
+do MMM ''yy      | 1st Jan '21
+ha do MMM ''yy   | 8PM 1st Jan '21
+ha               | 8PM
+iii              | Tues
+iii MMM          | Tues Jan
+MMM              | Jan
+`)
+*/
+type dateFormats =
+  | @as("HH:mm:ss") HoursMinSec
+  | @as("ha") Hour
+  | @as("do MMM ''yy") DayMonthYear
+  | @as("ha do MMM ''yy") HourDayMonthYear
+  | @as("h:mma do MMM ''yy") HourMinDayMonthYear
+  | @as("iii") DayName
+  | @as("iii MMM") DayNameMonth
+  | @as("do MMM") DayMonth
+  | @as("MMM") Month
+  | @as("h:mma") HourMin
+
+@module("date-fns") external format: (Js.Date.t, dateFormats) => string = "format"
+
+type formatDistanceToNowOptions = {includeSeconds: bool}
+@module("date-fns")
+external formatDistanceToNow: Js.Date.t => string = "formatDistanceToNow"
+
+@module("date-fns")
+external formatDistance: (Js.Date.t, Js.Date.t) => string = "formatDistance"
+
+@module("date-fns")
+external formatDistanceWithOptions: (Js.Date.t, Js.Date.t, formatDistanceToNowOptions) => string =
+  "formatDistance"
+
+@module("date-fns")
+external formatDistanceToNowWithOptions: (Js.Date.t, formatDistanceToNowOptions) => string =
+  "formatDistanceToNow"
+
+let formatDistanceToNowWithSeconds = (date: Js.Date.t) =>
+  date->formatDistanceToNowWithOptions({includeSeconds: true})
+
+type durationTimeFormat = {
+  years: int,
+  months: int,
+  weeks: int,
+  days: int,
+  hours: int,
+  minutes: int,
+  seconds: int,
+}
+
+@module("date-fns")
+external formatRelative: (Js.Date.t, Js.Date.t) => string = "formatRelative"
+
+type durationFormatOutput = {format: array<string>}
+
+@module("date-fns")
+external formatDuration: (durationTimeFormat, durationFormatOutput) => string = "formatDuration"
+
+type interval = {start: Js_date.t, end: Js_date.t}
+
+@module("date-fns")
+external intervalToDuration: interval => durationTimeFormat = "intervalToDuration"
+
+//helper to convert millis elapsed to duration object
+let durationFromMillis = (millis: int) =>
+  intervalToDuration({start: 0->Utils.magic, end: millis->Utils.magic})
+
+@module("date-fns") external fromUnixTime: float => Js.Date.t = "fromUnixTime"

package/src/bindings/DateFns.res.mjs

@@ -0,0 +1,22 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as DateFns from "date-fns";
+
+function formatDistanceToNowWithSeconds(date) {
+  return DateFns.formatDistanceToNow(date, {
+              includeSeconds: true
+            });
+}
+
+function durationFromMillis(millis) {
+  return DateFns.intervalToDuration({
+              start: 0,
+              end: millis
+            });
+}
+
+export {
+  formatDistanceToNowWithSeconds ,
+  durationFromMillis ,
+}
+/* date-fns Not a pure module */

package/src/bindings/Ethers.res

@@ -1,16 +1,3 @@
-type abi = EvmTypes.Abi.t
-
-let makeAbi = (abi: Js.Json.t): abi => abi->Utils.magic
-
-@deprecated("Use Address.t instead. The type will be removed in v3")
-type ethAddress = Address.t
-@deprecated("Use Address.Evm.fromStringOrThrow instead. The function will be removed in v3")
-let getAddressFromStringUnsafe = Address.Evm.fromStringOrThrow
-@deprecated("Use Address.toString instead. The function will be removed in v3")
-let ethAddressToString = Address.toString
-@deprecated("Use Address.schema instead. The function will be removed in v3")
-let ethAddressSchema = Address.schema
-
 type txHash = string
 
 module Constants = {
@@ -18,35 +5,6 @@ module Constants = {
   @module("ethers") @scope("ethers") external zeroAddress: Address.t = "ZeroAddress"
 }
 
-module Addresses = {
-  @genType
-  let mockAddresses = [
-    "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-    "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
-    "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
-    "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
-    "0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65",
-    "0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc",
-    "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
-    "0x14dC79964da2C08b23698B3D3cc7Ca32193d9955",
-    "0x23618e81E3f5cdF7f54C3d65f7FBc0aBf5B21E8f",
-    "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720",
-    "0xBcd4042DE499D14e55001CcbB24a551F3b954096",
-    "0x71bE63f3384f5fb98995898A86B02Fb2426c5788",
-    "0xFABB0ac9d68B0B445fB7357272Ff202C5651694a",
-    "0x1CBd3b2770909D4e10f157cABC84C7264073C9Ec",
-    "0xdF3e18d64BC6A983f673Ab319CCaE4f1a57C7097",
-    "0xcd3B766CCDd6AE721141F452C550Ca635964ce71",
-    "0x2546BcD3c84621e976D8185a91A922aE77ECEc30",
-    "0xbDA5747bFD65F08deb54cb465eB87D40e51B197E",
-    "0xdD2FD4581271e230360230F9337D5c0430Bf44C0",
-    "0x8626f6940E2eb28930eFb4CeF49B2d1F2C9C1199",
-  ]->Belt.Array.map(getAddressFromStringUnsafe)
-  @genType
-  let defaultAddress =
-    mockAddresses[0]
-}
-
 module Filter = {
   type t
 }
@@ -144,41 +102,43 @@ module JsonRpcProvider = {
   @send
   external getLogs: (t, ~filter: Filter.t) => promise<array<log>> = "getLogs"
 
-  @send
-  external getTransaction: (t, ~transactionHash: string) => promise<transaction> = "getTransaction"
-
   let makeGetTransactionFields = (~getTransactionByHash, ~lowercaseAddresses: bool) => async (
     log: log,
-  ): promise<unknown> => {
-    let transaction = await getTransactionByHash(log.transactionHash)
+  ): promise<Internal.evmTransactionFields> => {
+    let transaction: Internal.evmTransactionFields = 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
+    // RPC may return null for transactionIndex on pending transactions
     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 => ()
-      }
+    open Js.Nullable
+    switch fields["from"] {
+    | Value(from) =>
+      fields["from"] = lowercaseAddresses
+        ? from->Js.String2.toLowerCase->Address.unsafeFromString
+        : from->Address.Evm.fromStringOrThrow
+    | Undefined => ()
+    | Null => ()
+    }
+    switch fields["to"] {
+    | Value(to) =>
+      fields["to"] = lowercaseAddresses
+        ? to->Js.String2.toLowerCase->Address.unsafeFromString
+        : to->Address.Evm.fromStringOrThrow
+    | Undefined => ()
+    | Null => ()
+    }
+    switch fields["contractAddress"] {
+    | Value(contractAddress) =>
+      fields["contractAddress"] = lowercaseAddresses
+        ? contractAddress->Js.String2.toLowerCase->Address.unsafeFromString
+        : contractAddress->Address.Evm.fromStringOrThrow
+    | Undefined => ()
+    | Null => ()
     }
 
     fields->Obj.magic