envio 3.0.0-alpha.18-main-pg-client-downgrade → 3.0.0-alpha.19-main-node-pg-client

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.0.0-alpha.18-main-pg-client-downgrade",
+  "version": "3.0.0-alpha.19-main-node-pg-client",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -61,13 +61,13 @@
     "ink": "6.8.0",
     "ink-big-text": "2.0.0",
     "ink-spinner": "5.0.0",
-    "postgres": "3.4.1",
+    "pg": "8.16.0",
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.0.0-alpha.18-main-pg-client-downgrade",
-    "envio-linux-arm64": "3.0.0-alpha.18-main-pg-client-downgrade",
-    "envio-darwin-x64": "3.0.0-alpha.18-main-pg-client-downgrade",
-    "envio-darwin-arm64": "3.0.0-alpha.18-main-pg-client-downgrade"
+    "envio-linux-x64": "3.0.0-alpha.19-main-node-pg-client",
+    "envio-linux-arm64": "3.0.0-alpha.19-main-node-pg-client",
+    "envio-darwin-x64": "3.0.0-alpha.19-main-node-pg-client",
+    "envio-darwin-arm64": "3.0.0-alpha.19-main-node-pg-client"
   }
 }

package/src/ChainFetcher.res

@@ -88,7 +88,9 @@ let make = (
         ).getEventFiltersOrThrow
 
         // Check for non-evm chains
-        if getEventFiltersOrThrow->(Utils.magic: (ChainMap.Chain.t => Internal.eventFilters) => bool) {
+        if (
+          getEventFiltersOrThrow->(Utils.magic: (ChainMap.Chain.t => Internal.eventFilters) => bool)
+        ) {
           switch getEventFiltersOrThrow(ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)) {
           | Static([]) => true
           | _ => false
@@ -525,4 +527,4 @@ let getLastKnownValidBlock = async (
 
 let isActivelyIndexing = (chainFetcher: t) => chainFetcher.fetchState->FetchState.isActivelyIndexing
 
-let isLive = (chainFetcher: t) => chainFetcher.timestampCaughtUpToHeadOrEndblock !== None
+let isReady = (chainFetcher: t) => chainFetcher.timestampCaughtUpToHeadOrEndblock !== None

package/src/ChainFetcher.res.mjs

@@ -318,7 +318,7 @@ function isActivelyIndexing(chainFetcher) {
   return FetchState.isActivelyIndexing(chainFetcher.fetchState);
 }
 
-function isLive(chainFetcher) {
+function isReady(chainFetcher) {
   return chainFetcher.timestampCaughtUpToHeadOrEndblock !== undefined;
 }
 
@@ -334,6 +334,6 @@ export {
   getHighestBlockBelowThreshold ,
   getLastKnownValidBlock ,
   isActivelyIndexing ,
-  isLive ,
+  isReady ,
 }
 /* Env Not a pure module */

package/src/ChainManager.res

@@ -21,11 +21,12 @@ let calculateTargetBufferSize = (~activeChainsCount) => {
   | Some(size) => size
   | None =>
     switch activeChainsCount {
-    | 1 => 50_000
+    | 1 => 60_000
     | 2 => 30_000
     | 3 => 20_000
     | 4 => 15_000
-    | _ => 10_000
+    | 5 => 10_000
+    | _ => 5_000
     }
   }
 }
@@ -80,6 +81,23 @@ let makeFromDbState = async (
 
   let chainFetchers = ChainMap.fromArrayUnsafe(chainFetchersArr)
 
+  // Set initial progress metrics from DB state so dashboards reflect
+  // the persisted state immediately on restart
+  let allChainsReady = ref(chainFetchersArr->Array.length > 0)
+  chainFetchersArr->Array.forEach(((chain, cf)) => {
+    let chainId = chain->ChainMap.Chain.toChainId
+    Prometheus.ProgressBlockNumber.set(~blockNumber=cf.committedProgressBlockNumber, ~chainId)
+    Prometheus.ProgressReady.init(~chainId)
+    if cf->ChainFetcher.isReady {
+      Prometheus.ProgressReady.set(~chainId)
+    } else {
+      allChainsReady := false
+    }
+  })
+  if allChainsReady.contents {
+    Prometheus.ProgressReady.setAllReady()
+  }
+
   {
     committedCheckpointId: initialState.checkpointId,
     multichain: config.multichain,

package/src/ChainManager.res.mjs

@@ -25,15 +25,17 @@ function calculateTargetBufferSize(activeChainsCount) {
   }
   switch (activeChainsCount) {
     case 1 :
-        return 50000;
+        return 60000;
     case 2 :
         return 30000;
     case 3 :
         return 20000;
     case 4 :
         return 15000;
+    case 5 :
+        return 10000;
     default:
-      return 10000;
+      return 5000;
   }
 }
 
@@ -58,6 +60,24 @@ async function makeFromDbState(initialState, config, registrations) {
                     ];
             })));
   var chainFetchers = ChainMap.fromArrayUnsafe(chainFetchersArr);
+  var allChainsReady = {
+    contents: chainFetchersArr.length !== 0
+  };
+  Belt_Array.forEach(chainFetchersArr, (function (param) {
+          var cf = param[1];
+          var chain = param[0];
+          Prometheus.ProgressBlockNumber.set(cf.committedProgressBlockNumber, chain);
+          Prometheus.ProgressReady.init(chain);
+          if (ChainFetcher.isReady(cf)) {
+            return Prometheus.ProgressReady.set(chain);
+          } else {
+            allChainsReady.contents = false;
+            return ;
+          }
+        }));
+  if (allChainsReady.contents) {
+    Prometheus.ProgressReady.setAllReady();
+  }
   return {
           committedCheckpointId: initialState.checkpointId,
           chainFetchers: chainFetchers,

package/src/Config.res

@@ -203,6 +203,9 @@ let publicConfigChainSchema = S.schema(s =>
 let contractEventItemSchema = S.schema(s =>
   {
     "event": s.matches(S.string),
+    "name": s.matches(S.string),
+    "blockFields": s.matches(S.option(S.array(S.string))),
+    "transactionFields": s.matches(S.option(S.array(S.string))),
   }
 )
 
@@ -229,6 +232,8 @@ let publicConfigEvmSchema = S.schema(s =>
     "chains": s.matches(S.dict(publicConfigChainSchema)),
     "contracts": s.matches(S.option(S.dict(contractConfigSchema))),
     "addressFormat": s.matches(S.option(S.enum([Lowercase, Checksum]))),
+    "globalBlockFields": s.matches(S.option(S.array(Internal.evmBlockFieldSchema))),
+    "globalTransactionFields": s.matches(S.option(S.array(Internal.evmTransactionFieldSchema))),
   }
 )
 
@@ -273,10 +278,7 @@ let entityJsonSchema = S.schema(s =>
   }
 )
 
-let getFieldTypeAndSchema = (
-  prop,
-  ~enumConfigsByName: dict<Table.enumConfig<Table.enum>>,
-) => {
+let getFieldTypeAndSchema = (prop, ~enumConfigsByName: dict<Table.enumConfig<Table.enum>>) => {
   let typ = prop["type"]
   let isNullable = prop["isNullable"]->Option.getWithDefault(false)
   let isArray = prop["isArray"]->Option.getWithDefault(false)
@@ -312,8 +314,16 @@ let getFieldTypeAndSchema = (
   | other => Js.Exn.raiseError("Unknown field type in entity config: " ++ other)
   }
 
-  let fieldSchema = if isArray {S.array(baseSchema)->S.toUnknown} else {baseSchema}
-  let fieldSchema = if isNullable {S.null(fieldSchema)->S.toUnknown} else {fieldSchema}
+  let fieldSchema = if isArray {
+    S.array(baseSchema)->S.toUnknown
+  } else {
+    baseSchema
+  }
+  let fieldSchema = if isNullable {
+    S.null(fieldSchema)->S.toUnknown
+  } else {
+    fieldSchema
+  }
 
   (fieldType, fieldSchema, isNullable, isArray, isIndex)
 }
@@ -333,21 +343,22 @@ let parseEntitiesFromJson = (
   entitiesJson->Array.mapWithIndex((index, entityJson) => {
     let entityName = entityJson["name"]
 
-    let fields: array<Table.fieldOrDerived> =
-      entityJson["properties"]->Array.map(prop => {
-        let (fieldType, fieldSchema, isNullable, isArray, isIndex) =
-          getFieldTypeAndSchema(prop, ~enumConfigsByName)
-        Table.mkField(
-          prop["name"],
-          fieldType,
-          ~fieldSchema,
-          ~isPrimaryKey=prop["name"] === "id",
-          ~isNullable,
-          ~isArray,
-          ~isIndex,
-          ~linkedEntity=?prop["linkedEntity"],
-        )
-      })
+    let fields: array<Table.fieldOrDerived> = entityJson["properties"]->Array.map(prop => {
+      let (fieldType, fieldSchema, isNullable, isArray, isIndex) = getFieldTypeAndSchema(
+        prop,
+        ~enumConfigsByName,
+      )
+      Table.mkField(
+        prop["name"],
+        fieldType,
+        ~fieldSchema,
+        ~isPrimaryKey=prop["name"] === "id",
+        ~isNullable,
+        ~isArray,
+        ~isIndex,
+        ~linkedEntity=?prop["linkedEntity"],
+      )
+    })
 
     let derivedFields: array<Table.fieldOrDerived> =
       entityJson["derivedFields"]
@@ -364,14 +375,17 @@ let parseEntitiesFromJson = (
       entityJson["compositeIndices"]
       ->Option.getWithDefault([])
       ->Array.map(ci =>
-        ci->Array.map(f => {
-          Table.fieldName: f["fieldName"],
-          direction: f["direction"] == "Asc" ? Table.Asc : Table.Desc,
-        })
+        ci->Array.map(
+          f => {
+            Table.fieldName: f["fieldName"],
+            direction: f["direction"] == "Asc" ? Table.Asc : Table.Desc,
+          },
+        )
       )
 
     let table = Table.mkTable(
       entityName,
+      ~stmtId=index->Belt.Int.toString,
       ~fields=Array.concat(fields, derivedFields),
       ~compositeIndices,
     )
@@ -381,14 +395,16 @@ let parseEntitiesFromJson = (
     // to match the database column names used in Table.toSqlParams
     let schema = S.schema(s => {
       let dict = Js.Dict.empty()
-      entityJson["properties"]->Array.forEach(prop => {
-        let (_, fieldSchema, _, _, _) = getFieldTypeAndSchema(prop, ~enumConfigsByName)
-        let dbFieldName = switch prop["linkedEntity"] {
-        | Some(_) => prop["name"] ++ "_id"
-        | None => prop["name"]
-        }
-        dict->Js.Dict.set(dbFieldName, s.matches(fieldSchema))
-      })
+      entityJson["properties"]->Array.forEach(
+        prop => {
+          let (_, fieldSchema, _, _, _) = getFieldTypeAndSchema(prop, ~enumConfigsByName)
+          let dbFieldName = switch prop["linkedEntity"] {
+          | Some(_) => prop["name"] ++ "_id"
+          | None => prop["name"]
+          }
+          dict->Js.Dict.set(dbFieldName, s.matches(fieldSchema))
+        },
+      )
       dict
     })
 
@@ -396,7 +412,9 @@ let parseEntitiesFromJson = (
       Internal.name: entityName,
       index,
       schema: schema->(Utils.magic: S.t<dict<unknown>> => S.t<Internal.entity>),
-      rowsSchema: S.array(schema)->(Utils.magic: S.t<array<dict<unknown>>> => S.t<array<Internal.entity>>),
+      rowsSchema: S.array(schema)->(
+        Utils.magic: S.t<array<dict<unknown>>> => S.t<array<Internal.entity>>
+      ),
       table,
     }->Internal.fromGenericEntityConfig
   })
@@ -420,6 +438,66 @@ let publicConfigSchema = S.schema(s =>
   }
 )
 
+// Always-included block fields (number, timestamp, hash) are not in the JSON;
+// they're prepended at runtime so they're always present.
+let alwaysIncludedBlockFields: array<Internal.evmBlockField> = [Number, Timestamp, Hash]
+
+// Enrich EVM event configs with field selections from the JSON config.
+// Mutates the event configs in-place to set selectedBlockFields/selectedTransactionFields.
+let enrichEvmFieldSelections = (
+  events: array<Internal.eventConfig>,
+  ~jsonEvents: option<array<_>>,
+  ~globalBlockFieldsSet: Utils.Set.t<Internal.evmBlockField>,
+  ~globalTransactionFieldsSet: Utils.Set.t<Internal.evmTransactionField>,
+) => {
+  // Build a lookup by event name for events with per-event field overrides
+  let fieldsByName: Js.Dict.t<_> = Js.Dict.empty()
+  switch jsonEvents {
+  | Some(jes) =>
+    jes->Array.forEach(je => {
+      let name = je["name"]
+      if je["blockFields"] != None || je["transactionFields"] != None {
+        fieldsByName->Js.Dict.set(name, je)
+      }
+    })
+  | None => ()
+  }
+  events->Js.Array2.forEachi((event, i) => {
+    let evmEvent = event->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
+    let (selectedBlockFields, selectedTransactionFields) = switch fieldsByName->Js.Dict.get(
+      evmEvent.name,
+    ) {
+    | Some(je) => (
+        switch je["blockFields"] {
+        | Some(fields) =>
+          // Prepend always-included block fields for per-event overrides too
+          Utils.Set.fromArray(
+            Array.concat(
+              alwaysIncludedBlockFields,
+              fields->(Utils.magic: array<string> => array<Internal.evmBlockField>),
+            ),
+          )
+        | None => globalBlockFieldsSet
+        },
+        switch je["transactionFields"] {
+        | Some(fields) =>
+          Utils.Set.fromArray(
+            fields->(Utils.magic: array<string> => array<Internal.evmTransactionField>),
+          )
+        | None => globalTransactionFieldsSet
+        },
+      )
+    | None => (globalBlockFieldsSet, globalTransactionFieldsSet)
+    }
+    events->Js.Array2.unsafe_set(
+      i,
+      {...evmEvent, selectedBlockFields, selectedTransactionFields}->(
+        Utils.magic: Internal.evmEventConfig => Internal.eventConfig
+      ),
+    )
+  })
+}
+
 let fromPublic = (
   publicConfigJson: Js.Json.t,
   ~codegenChains: array<codegenChain>=[],
@@ -428,7 +506,9 @@ let fromPublic = (
   // Parse public config
   let publicConfig = try publicConfigJson->S.parseOrThrow(publicConfigSchema) catch {
   | S.Raised(exn) =>
-    Js.Exn.raiseError(`Invalid internal.config.ts: ${exn->Utils.prettifyExn->(Utils.magic: exn => string)}`)
+    Js.Exn.raiseError(
+      `Invalid internal.config.ts: ${exn->Utils.prettifyExn->(Utils.magic: exn => string)}`,
+    )
   }
 
   // Determine ecosystem from publicConfig (extract just chains for unified handling)
@@ -461,21 +541,42 @@ let fromPublic = (
   | _ => None
   }
 
-  // Store both ABI and event signatures for each contract (using inline tuple)
-  let contractsWithAbis: Js.Dict.t<(EvmTypes.Abi.t, array<string>)> = switch publicContractsConfig {
+  // Create global field selection Sets once (shared across events without per-event overrides)
+  let (globalBlockFieldsSet, globalTransactionFieldsSet) = switch publicConfig["evm"] {
+  | Some(evm) => (
+      Utils.Set.fromArray(
+        Array.concat(
+          alwaysIncludedBlockFields,
+          evm["globalBlockFields"]->Option.getWithDefault([]),
+        ),
+      ),
+      Utils.Set.fromArray(evm["globalTransactionFields"]->Option.getWithDefault([])),
+    )
+  | None => (Utils.Set.fromArray(alwaysIncludedBlockFields), Utils.Set.make())
+  }
+
+  // Store ABI and event signatures for each contract
+  let contractsWithAbis: Js.Dict.t<(EvmTypes.Abi.t, array<string>)> = Js.Dict.empty()
+  // Per-event field selection overrides, keyed by capitalized contract name
+  let jsonEventsByContract: Js.Dict.t<array<_>> = Js.Dict.empty()
+  switch publicContractsConfig {
   | Some(contractsDict) =>
     contractsDict
     ->Js.Dict.entries
-    ->Js.Array2.map(((contractName, contractConfig)) => {
+    ->Array.forEach(((contractName, contractConfig)) => {
+      let capitalizedName = contractName->Utils.String.capitalize
       let abi = contractConfig["abi"]->(Utils.magic: Js.Json.t => EvmTypes.Abi.t)
       let eventSignatures = switch contractConfig["events"] {
       | Some(events) => events->Array.map(eventItem => eventItem["event"])
       | None => []
       }
-      (contractName->Utils.String.capitalize, (abi, eventSignatures))
+      contractsWithAbis->Js.Dict.set(capitalizedName, (abi, eventSignatures))
+      switch contractConfig["events"] {
+      | Some(events) => jsonEventsByContract->Js.Dict.set(capitalizedName, events)
+      | None => ()
+      }
     })
-    ->Js.Dict.fromArray
-  | None => Js.Dict.empty()
+  | None => ()
   }
 
   // Index codegenChains by id for efficient lookup
@@ -504,6 +605,16 @@ let fromPublic = (
             }
           },
         )
+
+        // Enrich EVM event configs with field selections from JSON config
+        if ecosystemName == Ecosystem.Evm {
+          enrichEvmFieldSelections(
+            codegenContract.events,
+            ~jsonEvents=jsonEventsByContract->Js.Dict.get(codegenContract.name),
+            ~globalBlockFieldsSet,
+            ~globalTransactionFieldsSet,
+          )
+        }
         // Convert codegenContract to contract by adding abi and eventSignatures
         {
           name: codegenContract.name,
@@ -601,18 +712,12 @@ let fromPublic = (
       | Ecosystem.Fuel =>
         switch publicChainConfig["hypersync"] {
         | Some(hypersync) => FuelSourceConfig({hypersync: hypersync})
-        | None =>
-          Js.Exn.raiseError(
-            `Chain ${chainName} is missing hypersync endpoint in config`,
-          )
+        | None => Js.Exn.raiseError(`Chain ${chainName} is missing hypersync endpoint in config`)
         }
       | Ecosystem.Svm =>
         switch publicChainConfig["rpc"] {
         | Some(rpc) => SvmSourceConfig({rpc: rpc})
-        | None =>
-          Js.Exn.raiseError(
-            `Chain ${chainName} is missing rpc endpoint in config`,
-          )
+        | None => Js.Exn.raiseError(`Chain ${chainName} is missing rpc endpoint in config`)
         }
       }
 
@@ -670,8 +775,7 @@ let fromPublic = (
     ->Option.getWithDefault([])
     ->parseEntitiesFromJson(~enumConfigsByName)
 
-  let allEntities =
-    userEntities->Js.Array2.concat([DynamicContractRegistry.entityConfig])
+  let allEntities = userEntities->Js.Array2.concat([DynamicContractRegistry.entityConfig])
 
   let userEntitiesByName =
     userEntities
@@ -731,4 +835,3 @@ let getChain = (config, ~chainId) => {
         "No chain with id " ++ chain->ChainMap.Chain.toString ++ " found in config.yaml",
       )
 }
-

package/src/Config.res.mjs

@@ -10,6 +10,7 @@ import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Address from "./Address.res.mjs";
 import * as Js_dict from "rescript/lib/es6/js_dict.js";
 import * as ChainMap from "./ChainMap.res.mjs";
+import * as Internal from "./Internal.res.mjs";
 import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as BigDecimal from "./bindings/BigDecimal.res.mjs";
 import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
@@ -40,7 +41,7 @@ var schema = S$RescriptSchema.schema(function (s) {
 
 var rowsSchema = S$RescriptSchema.array(schema);
 
-var table = Table.mkTable(name, undefined, [
+var table = Table.mkTable(name, undefined, undefined, [
       Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
       Table.mkField("chain_id", "Int32", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
       Table.mkField("registering_event_block_number", "Int32", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
@@ -108,7 +109,10 @@ var publicConfigChainSchema = S$RescriptSchema.schema(function (s) {
 
 var contractEventItemSchema = S$RescriptSchema.schema(function (s) {
       return {
-              event: s.m(S$RescriptSchema.string)
+              event: s.m(S$RescriptSchema.string),
+              name: s.m(S$RescriptSchema.string),
+              blockFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string))),
+              transactionFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string)))
             };
     });
 
@@ -134,7 +138,9 @@ var publicConfigEvmSchema = S$RescriptSchema.schema(function (s) {
               addressFormat: s.m(S$RescriptSchema.option(S$RescriptSchema.$$enum([
                             "lowercase",
                             "checksum"
-                          ])))
+                          ]))),
+              globalBlockFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.evmBlockFieldSchema))),
+              globalTransactionFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.evmTransactionFieldSchema)))
             };
     });
 
@@ -314,7 +320,7 @@ function parseEntitiesFromJson(entitiesJson, enumConfigsByName) {
                                             };
                                     }));
                       }));
-                var table = Table.mkTable(entityName, compositeIndices, Belt_Array.concat(fields, derivedFields));
+                var table = Table.mkTable(entityName, String(index), compositeIndices, Belt_Array.concat(fields, derivedFields));
                 var schema = S$RescriptSchema.schema(function (s) {
                       var dict = {};
                       Belt_Array.forEach(entityJson.properties, (function (prop) {
@@ -353,6 +359,59 @@ var publicConfigSchema = S$RescriptSchema.schema(function (s) {
             };
     });
 
+var alwaysIncludedBlockFields = [
+  "number",
+  "timestamp",
+  "hash"
+];
+
+function enrichEvmFieldSelections(events, jsonEvents, globalBlockFieldsSet, globalTransactionFieldsSet) {
+  var fieldsByName = {};
+  if (jsonEvents !== undefined) {
+    Belt_Array.forEach(jsonEvents, (function (je) {
+            var name = je.name;
+            if (je.blockFields !== undefined || je.transactionFields !== undefined) {
+              fieldsByName[name] = je;
+              return ;
+            }
+            
+          }));
+  }
+  events.forEach(function ($$event, i) {
+        var je = Js_dict.get(fieldsByName, $$event.name);
+        var match;
+        if (je !== undefined) {
+          var je$1 = Caml_option.valFromOption(je);
+          var fields = je$1.blockFields;
+          var fields$1 = je$1.transactionFields;
+          match = [
+            fields !== undefined ? new Set(Belt_Array.concat(alwaysIncludedBlockFields, fields)) : globalBlockFieldsSet,
+            fields$1 !== undefined ? new Set(fields$1) : globalTransactionFieldsSet
+          ];
+        } else {
+          match = [
+            globalBlockFieldsSet,
+            globalTransactionFieldsSet
+          ];
+        }
+        events[i] = {
+          id: $$event.id,
+          name: $$event.name,
+          contractName: $$event.contractName,
+          isWildcard: $$event.isWildcard,
+          filterByAddresses: $$event.filterByAddresses,
+          dependsOnAddresses: $$event.dependsOnAddresses,
+          handler: $$event.handler,
+          contractRegister: $$event.contractRegister,
+          paramsRawEventSchema: $$event.paramsRawEventSchema,
+          getEventFiltersOrThrow: $$event.getEventFiltersOrThrow,
+          convertHyperSyncEventArgs: $$event.convertHyperSyncEventArgs,
+          selectedBlockFields: match[0],
+          selectedTransactionFields: match[1]
+        };
+      });
+}
+
 function fromPublic(publicConfigJson, codegenChainsOpt, maxAddrInPartitionOpt) {
   var codegenChains = codegenChainsOpt !== undefined ? codegenChainsOpt : [];
   var maxAddrInPartition = maxAddrInPartitionOpt !== undefined ? maxAddrInPartitionOpt : 5000;
@@ -408,21 +467,45 @@ function fromPublic(publicConfigJson, codegenChainsOpt, maxAddrInPartitionOpt) {
         break;
     
   }
-  var contractsWithAbis = publicContractsConfig !== undefined ? Js_dict.fromArray(Js_dict.entries(publicContractsConfig).map(function (param) {
-              var contractConfig = param[1];
-              var abi = contractConfig.abi;
-              var events = contractConfig.events;
-              var eventSignatures = events !== undefined ? Belt_Array.map(events, (function (eventItem) {
-                        return eventItem.event;
-                      })) : [];
-              return [
-                      Utils.$$String.capitalize(param[0]),
-                      [
-                        abi,
-                        eventSignatures
-                      ]
-                    ];
-            })) : ({});
+  var evm$1 = publicConfig.evm;
+  var match$6;
+  if (evm$1 !== undefined) {
+    var evm$2 = Caml_option.valFromOption(evm$1);
+    match$6 = [
+      new Set(Belt_Array.concat(alwaysIncludedBlockFields, Belt_Option.getWithDefault(evm$2.globalBlockFields, []))),
+      new Set(Belt_Option.getWithDefault(evm$2.globalTransactionFields, []))
+    ];
+  } else {
+    match$6 = [
+      new Set(alwaysIncludedBlockFields),
+      new Set()
+    ];
+  }
+  var globalTransactionFieldsSet = match$6[1];
+  var globalBlockFieldsSet = match$6[0];
+  var contractsWithAbis = {};
+  var jsonEventsByContract = {};
+  if (publicContractsConfig !== undefined) {
+    Belt_Array.forEach(Js_dict.entries(publicContractsConfig), (function (param) {
+            var contractConfig = param[1];
+            var capitalizedName = Utils.$$String.capitalize(param[0]);
+            var abi = contractConfig.abi;
+            var events = contractConfig.events;
+            var eventSignatures = events !== undefined ? Belt_Array.map(events, (function (eventItem) {
+                      return eventItem.event;
+                    })) : [];
+            contractsWithAbis[capitalizedName] = [
+              abi,
+              eventSignatures
+            ];
+            var events$1 = contractConfig.events;
+            if (events$1 !== undefined) {
+              jsonEventsByContract[capitalizedName] = events$1;
+              return ;
+            }
+            
+          }));
+  }
   var codegenChainById = {};
   Belt_Array.forEach(codegenChains, (function (codegenChain) {
           codegenChainById[String(codegenChain.id)] = codegenChain;
@@ -448,6 +531,9 @@ function fromPublic(publicConfigJson, codegenChainsOpt, maxAddrInPartitionOpt) {
                             
                           }
                         }));
+                  if (ecosystemName === "evm") {
+                    enrichEvmFieldSelections(codegenContract.events, Js_dict.get(jsonEventsByContract, codegenContract.name), globalBlockFieldsSet, globalTransactionFieldsSet);
+                  }
                   return {
                           name: codegenContract.name,
                           abi: match[0],
@@ -666,6 +752,8 @@ export {
   parseEnumsFromJson ,
   parseEntitiesFromJson ,
   publicConfigSchema ,
+  alwaysIncludedBlockFields ,
+  enrichEvmFieldSelections ,
   fromPublic ,
   shouldSaveHistory ,
   shouldPruneHistory ,

package/src/Ctx.res

@@ -2,4 +2,4 @@ type t = {
   registrations: HandlerRegister.registrations,
   config: Config.t,
   persistence: Persistence.t,
-}
+}

package/src/Env.res

@@ -109,7 +109,7 @@ module Db = {
   )
   let ssl = envSafe->EnvSafe.get(
     "ENVIO_PG_SSL_MODE",
-    Postgres.sslOptionsSchema,
+    Pg.sslOptionsSchema,
     //this is a dev fallback option for local deployments, shouldn't run in the prod env
     //the SSL modes should be provided as string otherwise as 'require' | 'allow' | 'prefer' | 'verify-full'
     ~devFallback=Bool(false),
@@ -194,7 +194,6 @@ module ThrottleWrites = {
       S.int,
       ~devFallback=30_000,
     )
-
 }
 
 // You need to close the envSafe after you're done with it so that it immediately tells you about your  misconfigured environment on startup.