envio 3.0.0-alpha.3 → 3.0.0-alpha.5

package/src/Config.res

@@ -18,7 +18,21 @@ type contract = {
   startBlock: option<int>,
 }
 
+type codegenContract = {
+  name: string,
+  addresses: array<string>,
+  events: array<Internal.eventConfig>,
+  startBlock: option<int>,
+}
+
+type codegenChain = {
+  id: int,
+  contracts: array<codegenContract>,
+  sources: array<Source.t>,
+}
+
 type chain = {
+  name: string,
   id: int,
   startBlock: int,
   endBlock?: int,
@@ -40,6 +54,9 @@ type sourceSync = {
 type multichain = | @as("ordered") Ordered | @as("unordered") Unordered
 
 type t = {
+  name: string,
+  description: option<string>,
+  handlers: string,
   shouldRollbackOnReorg: bool,
   shouldSaveFullHistory: bool,
   multichain: multichain,
@@ -54,19 +71,96 @@ type t = {
   userEntitiesByName: dict<Internal.entityConfig>,
 }
 
-let make = (
-  ~shouldRollbackOnReorg=true,
-  ~shouldSaveFullHistory=false,
-  ~chains: array<chain>=[],
-  ~enableRawEvents=false,
-  ~ecosystem: Ecosystem.name=Ecosystem.Evm,
-  ~batchSize=5000,
-  ~lowercaseAddresses=false,
-  ~multichain=Unordered,
-  ~shouldUseHypersyncClientDecoder=true,
+let publicConfigChainSchema = S.schema(s =>
+  {
+    "id": s.matches(S.int),
+    "startBlock": s.matches(S.int),
+    "endBlock": s.matches(S.option(S.int)),
+    "maxReorgDepth": s.matches(S.option(S.int)),
+  }
+)
+
+let contractConfigSchema = S.schema(s =>
+  {
+    "abi": s.matches(S.json(~validate=false)),
+  }
+)
+
+let publicConfigEcosystemSchema = S.schema(s =>
+  {
+    "chains": s.matches(S.dict(publicConfigChainSchema)),
+    "contracts": s.matches(S.option(S.dict(contractConfigSchema))),
+  }
+)
+
+type addressFormat = | @as("lowercase") Lowercase | @as("checksum") Checksum
+type decoder = | @as("hypersync") Hypersync | @as("viem") Viem
+
+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]))),
+    "eventDecoder": s.matches(S.option(S.enum([Hypersync, Viem]))),
+  }
+)
+
+let multichainSchema = S.enum([Ordered, Unordered])
+
+let publicConfigSchema = S.schema(s =>
+  {
+    "name": s.matches(S.string),
+    "description": s.matches(S.option(S.string)),
+    "handlers": s.matches(S.option(S.string)),
+    "multichain": s.matches(S.option(multichainSchema)),
+    "fullBatchSize": s.matches(S.option(S.int)),
+    "rollbackOnReorg": s.matches(S.option(S.bool)),
+    "saveFullHistory": s.matches(S.option(S.bool)),
+    "rawEvents": s.matches(S.option(S.bool)),
+    "evm": s.matches(S.option(publicConfigEvmSchema)),
+    "fuel": s.matches(S.option(publicConfigEcosystemSchema)),
+    "svm": s.matches(S.option(publicConfigEcosystemSchema)),
+  }
+)
+
+let fromPublic = (
+  publicConfigJson: Js.Json.t,
+  ~codegenChains: array<codegenChain>=[],
   ~maxAddrInPartition=5000,
   ~userEntities: array<Internal.entityConfig>=[],
 ) => {
+  // 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}`)
+  }
+
+  // Determine ecosystem from publicConfig (extract just chains for unified handling)
+  let (publicChainsConfig, ecosystemName) = switch (
+    publicConfig["evm"],
+    publicConfig["fuel"],
+    publicConfig["svm"],
+  ) {
+  | (Some(ecosystemConfig), None, None) => (ecosystemConfig["chains"], Ecosystem.Evm)
+  | (None, Some(ecosystemConfig), None) => (ecosystemConfig["chains"], Ecosystem.Fuel)
+  | (None, None, Some(ecosystemConfig)) => (ecosystemConfig["chains"], Ecosystem.Svm)
+  | (None, None, None) =>
+    Js.Exn.raiseError("Invalid indexer config: No ecosystem configured (evm, fuel, or svm)")
+  | _ =>
+    Js.Exn.raiseError(
+      "Invalid indexer config: Multiple ecosystems are not supported for a single indexer",
+    )
+  }
+
+  // Extract EVM-specific options with defaults
+  let (lowercaseAddresses, shouldUseHypersyncClientDecoder) = switch publicConfig["evm"] {
+  | Some(evm) => (
+      evm["addressFormat"]->Option.getWithDefault(Checksum) == Lowercase,
+      evm["eventDecoder"]->Option.getWithDefault(Hypersync) == Hypersync,
+    )
+  | None => (false, true)
+  }
+
   // Validate that lowercase addresses is not used with viem decoder
   if lowercaseAddresses && !shouldUseHypersyncClientDecoder {
     Js.Exn.raiseError(
@@ -74,10 +168,106 @@ let make = (
     )
   }
 
+  // Parse ABIs from public config
+  let publicContractsConfig = switch (ecosystemName, publicConfig["evm"], publicConfig["fuel"]) {
+  | (Ecosystem.Evm, Some(evm), _) => evm["contracts"]
+  | (Ecosystem.Fuel, _, Some(fuel)) => fuel["contracts"]
+  | _ => None
+  }
+
+  let contractsWithAbis = switch publicContractsConfig {
+  | Some(contractsDict) =>
+    contractsDict
+    ->Js.Dict.entries
+    ->Js.Array2.map(((contractName, contractConfig)) => {
+      let abi = contractConfig["abi"]->(Utils.magic: Js.Json.t => EvmTypes.Abi.t)
+      (contractName, abi)
+    })
+    ->Js.Dict.fromArray
+  | None => Js.Dict.empty()
+  }
+
+  // Index codegenChains by id for efficient lookup
+  let codegenChainById = Js.Dict.empty()
+  codegenChains->Array.forEach(codegenChain => {
+    codegenChainById->Js.Dict.set(codegenChain.id->Int.toString, codegenChain)
+  })
+
+  // Create a dictionary to store merged contracts with ABIs by chain id
+  let contractsByChainId: Js.Dict.t<array<contract>> = Js.Dict.empty()
+  codegenChains->Array.forEach(codegenChain => {
+    let mergedContracts = codegenChain.contracts->Array.map(codegenContract => {
+      switch contractsWithAbis->Js.Dict.get(codegenContract.name) {
+      | Some(abi) =>
+        // Parse addresses based on ecosystem and address format
+        let parsedAddresses = codegenContract.addresses->Array.map(
+          addressString => {
+            switch ecosystemName {
+            | Ecosystem.Evm =>
+              if lowercaseAddresses {
+                addressString->Address.Evm.fromStringLowercaseOrThrow
+              } else {
+                addressString->Address.Evm.fromStringOrThrow
+              }
+            | Ecosystem.Fuel | Ecosystem.Svm => addressString->Address.unsafeFromString
+            }
+          },
+        )
+        // Convert codegenContract to contract by adding abi
+        {
+          name: codegenContract.name,
+          abi,
+          addresses: parsedAddresses,
+          events: codegenContract.events,
+          startBlock: codegenContract.startBlock,
+        }
+      | None =>
+        Js.Exn.raiseError(
+          `Contract "${codegenContract.name}" is missing ABI in public config (internal.config.ts)`,
+        )
+      }
+    })
+    contractsByChainId->Js.Dict.set(codegenChain.id->Int.toString, mergedContracts)
+  })
+
+  // Merge codegenChains with names from publicConfig
+  let chains =
+    publicChainsConfig
+    ->Js.Dict.keys
+    ->Js.Array2.map(chainName => {
+      let publicChainConfig = publicChainsConfig->Js.Dict.unsafeGet(chainName)
+      let chainId = publicChainConfig["id"]
+      let codegenChain = switch codegenChainById->Js.Dict.get(chainId->Int.toString) {
+      | Some(c) => c
+      | None =>
+        Js.Exn.raiseError(`Chain with id ${chainId->Int.toString} not found in codegen chains`)
+      }
+      let mergedContracts = switch contractsByChainId->Js.Dict.get(chainId->Int.toString) {
+      | Some(contracts) => contracts
+      | None =>
+        Js.Exn.raiseError(
+          `Contracts for chain with id ${chainId->Int.toString} not found in merged contracts`,
+        )
+      }
+      {
+        name: chainName,
+        id: codegenChain.id,
+        startBlock: publicChainConfig["startBlock"],
+        endBlock: ?publicChainConfig["endBlock"],
+        maxReorgDepth: switch ecosystemName {
+        | Ecosystem.Evm => publicChainConfig["maxReorgDepth"]->Option.getWithDefault(200)
+        // Fuel doesn't have reorgs, SVM reorg handling is not supported
+        | Ecosystem.Fuel | Ecosystem.Svm => 0
+        },
+        contracts: mergedContracts,
+        sources: codegenChain.sources,
+      }
+    })
+
   let chainMap =
     chains
-    ->Js.Array2.map(n => {
-      (ChainMap.Chain.makeUnsafe(~chainId=n.id), n)
+    ->Js.Array2.map(chain => {
+      (ChainMap.Chain.makeUnsafe(~chainId=chain.id), chain)
     })
     ->ChainMap.fromArrayUnsafe
 
@@ -90,10 +280,10 @@ let make = (
     })
   })
 
-  let ecosystem = switch ecosystem {
+  let ecosystem = switch ecosystemName {
   | Ecosystem.Evm => Evm.ecosystem
   | Ecosystem.Fuel => Fuel.ecosystem
-  | Ecosystem.Solana => Solana.ecosystem
+  | Ecosystem.Svm => Svm.ecosystem
   }
 
   let userEntitiesByName =
@@ -104,15 +294,18 @@ let make = (
     ->Js.Dict.fromArray
 
   {
-    shouldRollbackOnReorg,
-    shouldSaveFullHistory,
-    multichain,
+    name: publicConfig["name"],
+    description: publicConfig["description"],
+    handlers: publicConfig["handlers"]->Option.getWithDefault("src/handlers"),
+    shouldRollbackOnReorg: publicConfig["rollbackOnReorg"]->Option.getWithDefault(true),
+    shouldSaveFullHistory: publicConfig["saveFullHistory"]->Option.getWithDefault(false),
+    multichain: publicConfig["multichain"]->Option.getWithDefault(Unordered),
     chainMap,
     defaultChain: chains->Array.get(0),
-    enableRawEvents,
+    enableRawEvents: publicConfig["rawEvents"]->Option.getWithDefault(false),
     ecosystem,
     maxAddrInPartition,
-    batchSize,
+    batchSize: publicConfig["fullBatchSize"]->Option.getWithDefault(5000),
     lowercaseAddresses,
     addContractNameToContractNameMapping,
     userEntitiesByName,

package/src/Config.res.mjs

@@ -1,33 +1,223 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Evm from "./sources/Evm.res.mjs";
+import * as Svm from "./sources/Svm.res.mjs";
 import * as Fuel from "./sources/Fuel.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Js_exn from "rescript/lib/es6/js_exn.js";
-import * as Solana from "./sources/Solana.res.mjs";
+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 Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
 
-function make(shouldRollbackOnReorgOpt, shouldSaveFullHistoryOpt, chainsOpt, enableRawEventsOpt, ecosystemOpt, batchSizeOpt, lowercaseAddressesOpt, multichainOpt, shouldUseHypersyncClientDecoderOpt, maxAddrInPartitionOpt, userEntitiesOpt) {
-  var shouldRollbackOnReorg = shouldRollbackOnReorgOpt !== undefined ? shouldRollbackOnReorgOpt : true;
-  var shouldSaveFullHistory = shouldSaveFullHistoryOpt !== undefined ? shouldSaveFullHistoryOpt : false;
-  var chains = chainsOpt !== undefined ? chainsOpt : [];
-  var enableRawEvents = enableRawEventsOpt !== undefined ? enableRawEventsOpt : false;
-  var ecosystem = ecosystemOpt !== undefined ? ecosystemOpt : "evm";
-  var batchSize = batchSizeOpt !== undefined ? batchSizeOpt : 5000;
-  var lowercaseAddresses = lowercaseAddressesOpt !== undefined ? lowercaseAddressesOpt : false;
-  var multichain = multichainOpt !== undefined ? multichainOpt : "unordered";
-  var shouldUseHypersyncClientDecoder = shouldUseHypersyncClientDecoderOpt !== undefined ? shouldUseHypersyncClientDecoderOpt : true;
+var publicConfigChainSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              id: s.m(S$RescriptSchema.$$int),
+              startBlock: s.m(S$RescriptSchema.$$int),
+              endBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
+              maxReorgDepth: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int))
+            };
+    });
+
+var contractConfigSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              abi: s.m(S$RescriptSchema.json(false))
+            };
+    });
+
+var publicConfigEcosystemSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              chains: s.m(S$RescriptSchema.dict(publicConfigChainSchema)),
+              contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(contractConfigSchema)))
+            };
+    });
+
+var publicConfigEvmSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              chains: s.m(S$RescriptSchema.dict(publicConfigChainSchema)),
+              contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(contractConfigSchema))),
+              addressFormat: s.m(S$RescriptSchema.option(S$RescriptSchema.$$enum([
+                            "lowercase",
+                            "checksum"
+                          ]))),
+              eventDecoder: s.m(S$RescriptSchema.option(S$RescriptSchema.$$enum([
+                            "hypersync",
+                            "viem"
+                          ])))
+            };
+    });
+
+var multichainSchema = S$RescriptSchema.$$enum([
+      "ordered",
+      "unordered"
+    ]);
+
+var publicConfigSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              name: s.m(S$RescriptSchema.string),
+              description: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
+              handlers: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
+              multichain: s.m(S$RescriptSchema.option(multichainSchema)),
+              fullBatchSize: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
+              rollbackOnReorg: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
+              saveFullHistory: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
+              rawEvents: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
+              evm: s.m(S$RescriptSchema.option(publicConfigEvmSchema)),
+              fuel: s.m(S$RescriptSchema.option(publicConfigEcosystemSchema)),
+              svm: s.m(S$RescriptSchema.option(publicConfigEcosystemSchema))
+            };
+    });
+
+function fromPublic(publicConfigJson, codegenChainsOpt, maxAddrInPartitionOpt, userEntitiesOpt) {
+  var codegenChains = codegenChainsOpt !== undefined ? codegenChainsOpt : [];
   var maxAddrInPartition = maxAddrInPartitionOpt !== undefined ? maxAddrInPartitionOpt : 5000;
   var userEntities = userEntitiesOpt !== undefined ? userEntitiesOpt : [];
-  if (lowercaseAddresses && !shouldUseHypersyncClientDecoder) {
+  var publicConfig;
+  try {
+    publicConfig = S$RescriptSchema.parseOrThrow(publicConfigJson, publicConfigSchema);
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    if (exn.RE_EXN_ID === S$RescriptSchema.Raised) {
+      publicConfig = Js_exn.raiseError("Invalid internal.config.ts: " + Utils.prettifyExn(exn._1));
+    } else {
+      throw exn;
+    }
+  }
+  var match = publicConfig.evm;
+  var match$1 = publicConfig.fuel;
+  var match$2 = publicConfig.svm;
+  var match$3 = match !== undefined ? (
+      match$1 !== undefined || match$2 !== undefined ? Js_exn.raiseError("Invalid indexer config: Multiple ecosystems are not supported for a single indexer") : [
+          Caml_option.valFromOption(match).chains,
+          "evm"
+        ]
+    ) : (
+      match$1 !== undefined ? (
+          match$2 !== undefined ? Js_exn.raiseError("Invalid indexer config: Multiple ecosystems are not supported for a single indexer") : [
+              Caml_option.valFromOption(match$1).chains,
+              "fuel"
+            ]
+        ) : (
+          match$2 !== undefined ? [
+              Caml_option.valFromOption(match$2).chains,
+              "svm"
+            ] : Js_exn.raiseError("Invalid indexer config: No ecosystem configured (evm, fuel, or svm)")
+        )
+    );
+  var ecosystemName = match$3[1];
+  var publicChainsConfig = match$3[0];
+  var evm = publicConfig.evm;
+  var match$4;
+  if (evm !== undefined) {
+    var evm$1 = Caml_option.valFromOption(evm);
+    match$4 = [
+      Belt_Option.getWithDefault(evm$1.addressFormat, "checksum") === "lowercase",
+      Belt_Option.getWithDefault(evm$1.eventDecoder, "hypersync") === "hypersync"
+    ];
+  } else {
+    match$4 = [
+      false,
+      true
+    ];
+  }
+  var lowercaseAddresses = match$4[0];
+  if (lowercaseAddresses && !match$4[1]) {
     Js_exn.raiseError("lowercase addresses is not supported when event_decoder is 'viem'. Please set event_decoder to 'hypersync-client' or change address_format to 'checksum'.");
   }
-  var chainMap = ChainMap.fromArrayUnsafe(chains.map(function (n) {
+  var match$5 = publicConfig.evm;
+  var match$6 = publicConfig.fuel;
+  var publicContractsConfig;
+  switch (ecosystemName) {
+    case "evm" :
+        publicContractsConfig = match$5 !== undefined ? Caml_option.valFromOption(match$5).contracts : undefined;
+        break;
+    case "fuel" :
+        publicContractsConfig = match$6 !== undefined ? Caml_option.valFromOption(match$6).contracts : undefined;
+        break;
+    case "svm" :
+        publicContractsConfig = undefined;
+        break;
+    
+  }
+  var contractsWithAbis = publicContractsConfig !== undefined ? Js_dict.fromArray(Js_dict.entries(publicContractsConfig).map(function (param) {
+              var abi = param[1].abi;
+              return [
+                      param[0],
+                      abi
+                    ];
+            })) : ({});
+  var codegenChainById = {};
+  Belt_Array.forEach(codegenChains, (function (codegenChain) {
+          codegenChainById[String(codegenChain.id)] = codegenChain;
+        }));
+  var contractsByChainId = {};
+  Belt_Array.forEach(codegenChains, (function (codegenChain) {
+          var mergedContracts = Belt_Array.map(codegenChain.contracts, (function (codegenContract) {
+                  var abi = Js_dict.get(contractsWithAbis, codegenContract.name);
+                  if (abi === undefined) {
+                    return Js_exn.raiseError("Contract \"" + codegenContract.name + "\" is missing ABI in public config (internal.config.ts)");
+                  }
+                  var parsedAddresses = Belt_Array.map(codegenContract.addresses, (function (addressString) {
+                          switch (ecosystemName) {
+                            case "evm" :
+                                if (lowercaseAddresses) {
+                                  return Address.Evm.fromStringLowercaseOrThrow(addressString);
+                                } else {
+                                  return Address.Evm.fromStringOrThrow(addressString);
+                                }
+                            case "fuel" :
+                            case "svm" :
+                                return addressString;
+                            
+                          }
+                        }));
+                  return {
+                          name: codegenContract.name,
+                          abi: Caml_option.valFromOption(abi),
+                          addresses: parsedAddresses,
+                          events: codegenContract.events,
+                          startBlock: codegenContract.startBlock
+                        };
+                }));
+          contractsByChainId[String(codegenChain.id)] = mergedContracts;
+        }));
+  var chains = Object.keys(publicChainsConfig).map(function (chainName) {
+        var publicChainConfig = publicChainsConfig[chainName];
+        var chainId = publicChainConfig.id;
+        var c = Js_dict.get(codegenChainById, String(chainId));
+        var codegenChain = c !== undefined ? c : Js_exn.raiseError("Chain with id " + String(chainId) + " not found in codegen chains");
+        var contracts = Js_dict.get(contractsByChainId, String(chainId));
+        var mergedContracts = contracts !== undefined ? contracts : Js_exn.raiseError("Contracts for chain with id " + String(chainId) + " not found in merged contracts");
+        var tmp;
+        switch (ecosystemName) {
+          case "evm" :
+              tmp = Belt_Option.getWithDefault(publicChainConfig.maxReorgDepth, 200);
+              break;
+          case "fuel" :
+          case "svm" :
+              tmp = 0;
+              break;
+          
+        }
+        return {
+                name: chainName,
+                id: codegenChain.id,
+                startBlock: publicChainConfig.startBlock,
+                endBlock: publicChainConfig.endBlock,
+                maxReorgDepth: tmp,
+                contracts: mergedContracts,
+                sources: codegenChain.sources
+              };
+      });
+  var chainMap = ChainMap.fromArrayUnsafe(chains.map(function (chain) {
             return [
-                    ChainMap.Chain.makeUnsafe(n.id),
-                    n
+                    ChainMap.Chain.makeUnsafe(chain.id),
+                    chain
                   ];
           }));
   var addContractNameToContractNameMapping = {};
@@ -37,16 +227,16 @@ function make(shouldRollbackOnReorgOpt, shouldSaveFullHistoryOpt, chainsOpt, ena
                   addContractNameToContractNameMapping[addKey] = contract.name;
                 }));
         }));
-  var ecosystem$1;
-  switch (ecosystem) {
+  var ecosystem;
+  switch (ecosystemName) {
     case "evm" :
-        ecosystem$1 = Evm.ecosystem;
+        ecosystem = Evm.ecosystem;
         break;
     case "fuel" :
-        ecosystem$1 = Fuel.ecosystem;
+        ecosystem = Fuel.ecosystem;
         break;
-    case "solana" :
-        ecosystem$1 = Solana.ecosystem;
+    case "svm" :
+        ecosystem = Svm.ecosystem;
         break;
     
   }
@@ -57,15 +247,18 @@ function make(shouldRollbackOnReorgOpt, shouldSaveFullHistoryOpt, chainsOpt, ena
                   ];
           }));
   return {
-          shouldRollbackOnReorg: shouldRollbackOnReorg,
-          shouldSaveFullHistory: shouldSaveFullHistory,
-          multichain: multichain,
+          name: publicConfig.name,
+          description: publicConfig.description,
+          handlers: Belt_Option.getWithDefault(publicConfig.handlers, "src/handlers"),
+          shouldRollbackOnReorg: Belt_Option.getWithDefault(publicConfig.rollbackOnReorg, true),
+          shouldSaveFullHistory: Belt_Option.getWithDefault(publicConfig.saveFullHistory, false),
+          multichain: Belt_Option.getWithDefault(publicConfig.multichain, "unordered"),
           chainMap: chainMap,
           defaultChain: Belt_Array.get(chains, 0),
-          ecosystem: ecosystem$1,
-          enableRawEvents: enableRawEvents,
+          ecosystem: ecosystem,
+          enableRawEvents: Belt_Option.getWithDefault(publicConfig.rawEvents, false),
           maxAddrInPartition: maxAddrInPartition,
-          batchSize: batchSize,
+          batchSize: Belt_Option.getWithDefault(publicConfig.fullBatchSize, 5000),
           lowercaseAddresses: lowercaseAddresses,
           addContractNameToContractNameMapping: addContractNameToContractNameMapping,
           userEntitiesByName: userEntitiesByName
@@ -100,9 +293,15 @@ function getChain(config, chainId) {
 }
 
 export {
-  make ,
+  publicConfigChainSchema ,
+  contractConfigSchema ,
+  publicConfigEcosystemSchema ,
+  publicConfigEvmSchema ,
+  multichainSchema ,
+  publicConfigSchema ,
+  fromPublic ,
   shouldSaveHistory ,
   shouldPruneHistory ,
   getChain ,
 }
-/* Utils Not a pure module */
+/* publicConfigChainSchema Not a pure module */

package/src/{Indexer.res → Ctx.res}

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

package/src/Ecosystem.res

@@ -1,4 +1,4 @@
-type name = | @as("evm") Evm | @as("fuel") Fuel | @as("solana") Solana
+type name = | @as("evm") Evm | @as("fuel") Fuel | @as("svm") Svm
 
 type t = {
   name: name,
@@ -15,7 +15,7 @@ type t = {
 
 let makeOnBlockArgs = (~blockNumber: int, ~ecosystem: t, ~context): Internal.onBlockArgs => {
   switch ecosystem.name {
-  | Solana => {slot: blockNumber, context}
+  | Svm => {slot: blockNumber, context}
   | _ => {
       let blockEvent = Js.Dict.empty()
       blockEvent->Js.Dict.set(ecosystem.blockNumberName, blockNumber->Utils.magic)

package/src/Ecosystem.res.mjs

@@ -8,7 +8,7 @@ function makeOnBlockArgs(blockNumber, ecosystem, context) {
     case "evm" :
     case "fuel" :
         break;
-    case "solana" :
+    case "svm" :
         return {
                 slot: blockNumber,
                 context: context

package/src/Envio.gen.ts

@@ -15,7 +15,7 @@ export type blockEvent = { readonly number: number };
 
 export type fuelBlockEvent = { readonly height: number };
 
-export type solanaOnBlockArgs<context> = { readonly slot: number; readonly context: context };
+export type svmOnBlockArgs<context> = { readonly slot: number; readonly context: context };
 
 export type onBlockArgs<block,context> = { readonly block: block; readonly context: context };
 

package/src/Envio.res

@@ -9,7 +9,7 @@ type blockEvent = {number: int}
 type fuelBlockEvent = {height: int}
 
 @genType
-type solanaOnBlockArgs<'context> = {slot: int, context: 'context}
+type svmOnBlockArgs<'context> = {slot: int, context: 'context}
 
 @genType
 type onBlockArgs<'block, 'context> = {