envio 3.7.0 → 3.9.0-resolvers.0

package/src/Config.res

@@ -33,13 +33,19 @@ type sourceConfig =
   // A `simulate` run: the items the test fed in, parsed against the chain's
   // registrations. The source itself is built with the chain's address store,
   // like every other source, so it can apply the same gates.
-  | SimulateSourceConfig({items: array<Internal.item>, endBlock: int})
+  | SimulateSourceConfig({
+      items: array<Internal.item>,
+      endBlock: int,
+      transactionStore?: TransactionStore.t,
+      blockStore?: BlockStore.t,
+    })
   // For tests: pass custom sources directly
   | CustomSources(array<Source.t>)
 
 type chain = {
   name: string,
   id: ChainId.t,
+  ecosystem: Ecosystem.name,
   startBlock: int,
   endBlock?: int,
   maxReorgDepth: int,
@@ -88,6 +94,9 @@ type t = {
   name: string,
   description: option<string>,
   handlers: string,
+  // Relative path to the module declaring custom GraphQL resolvers, when the
+  // project ships them. None means entity fields only.
+  resolvers: option<string>,
   contractHandlers: array<contractHandler>,
   shouldRollbackOnReorg: bool,
   shouldSaveFullHistory: bool,
@@ -101,6 +110,9 @@ type t = {
   // they can express fits an INTEGER.
   chainIdMode: ChainId.mode,
   chainMap: ChainMap.t<chain>,
+  // Derived from every chain's contracts, so an id means the same contract on
+  // every chain and on every restart.
+  contractMapping: ContractMapping.t,
   defaultChain: option<chain>,
   ecosystem: Ecosystem.t,
   enableRawEvents: bool,
@@ -117,75 +129,9 @@ type t = {
   isDev: bool,
   userEntitiesByName: dict<Internal.entityConfig>,
   userEntities: array<Internal.entityConfig>,
-  allEntities: array<Internal.entityConfig>,
   allEnums: array<Table.enumConfig<Table.enum>>,
 }
 
-module EnvioAddresses = {
-  let name = "envio_addresses"
-  let index = -1
-
-  let makeId = (~chainId: ChainId.t, ~address) => {
-    chainId->ChainId.toString ++ "-" ++ address->Address.toString
-  }
-
-  type t = {
-    id: string,
-    @as("chain_id") chainId: ChainId.t,
-    @as("registration_block") registrationBlock: int,
-    // Vestigial: always written as -1 and never read back. The column stays so
-    // an existing schema doesn't need a migration.
-    @as("registration_log_index") registrationLogIndex: int,
-    @as("contract_name") contractName: string,
-  }
-
-  // Extract the raw contract address from the composite id ({chainId}-{address}).
-  // Inverse of makeId. Keep in sync with makeId above and the SUBSTRING SQL in
-  // InternalTable.Chains.makeGetInitialStateQuery.
-  let getAddress = (entity: t): Address.t => {
-    let sepIdx = entity.id->String.indexOf("-")
-    entity.id
-    ->String.slice(~start=sepIdx + 1, ~end=entity.id->String.length)
-    ->Address.unsafeFromString
-  }
-
-  let schema = S.schema(s => {
-    id: s.matches(S.string),
-    chainId: s.matches(ChainId.schema),
-    registrationBlock: s.matches(S.int),
-    registrationLogIndex: s.matches(S.int),
-    contractName: s.matches(S.string),
-  })
-
-  let table = Table.mkTable(
-    name,
-    ~fields=[
-      Table.mkField("id", String, ~isPrimaryKey=true, ~fieldSchema=S.string),
-      Table.mkField("chain_id", ChainId, ~fieldSchema=ChainId.schema),
-      Table.mkField("registration_block", Int32, ~fieldSchema=S.int),
-      // -1 sentinel when registered from a block handler (no log index)
-      Table.mkField("registration_log_index", Int32, ~fieldSchema=S.int),
-      Table.mkField("contract_name", String, ~fieldSchema=S.string),
-    ],
-  )
-
-  external castToInternal: t => Internal.entity = "%identity"
-
-  let entityConfig = {
-    Internal.name,
-    index,
-    schema,
-    table,
-    // Internal address tracking is Postgres-only; the global config is
-    // always required to have Postgres enabled (Storage::resolve forbids
-    // a Postgres-disabled global), so this is safe regardless of mode.
-    storage: {postgres: true, clickhouse: false},
-    // The table already keys rows by chain through the composite `id`, so the
-    // per-chain mode must not append a second chain-id column to it.
-    crossChain: true,
-  }->Internal.fromGenericEntityConfig
-}
-
 type rpcSourceFor = | @as("sync") Sync | @as("fallback") Fallback | @as("realtime") Realtime
 
 let rpcSourceForSchema = S.enum([Sync, Fallback, Realtime])
@@ -234,27 +180,6 @@ let publicConfigChainSchema = S.schema(s =>
 let svmEventDescriptorSchema = S.schema(s =>
   {
     "discriminator": s.matches(S.option(S.string)),
-    "discriminatorByteLen": s.matches(S.int),
-    "transactionFields": s.matches(S.array(Internal.svmTransactionFieldSchema)),
-    "blockFields": s.matches(S.option(S.array(Internal.svmBlockFieldSchema))),
-    "includeLogs": s.matches(S.bool),
-    // An array of AND-groups OR-ed together: the CLI normalizes both the flat
-    // and `any_of` YAML shapes to `Vec<Vec<SvmAccountFilterJson>>`.
-    "accountFilters": s.matches(
-      S.option(
-        S.array(
-          S.array(
-            S.schema(s =>
-              {
-                "position": s.matches(S.int),
-                "values": s.matches(S.array(S.string)),
-              }
-            ),
-          ),
-        ),
-      ),
-    ),
-    "isInner": s.matches(S.option(S.bool)),
     "accounts": s.matches(S.option(S.array(S.string))),
     "args": s.matches(S.option(S.json(~validate=false))),
   }
@@ -348,10 +273,18 @@ let propertySchema = S.schema(s =>
   }
 )
 
+let clickhouseSkippingIndexSchema: S.t<Internal.clickhouseSkippingIndex> = S.object(s => {
+  Internal.name: s.field("name", S.string),
+  expr: s.field("expr", S.string),
+  type_: s.field("type", S.string),
+  granularity: ?s.field("granularity", S.option(S.int)),
+})
+
 let clickhouseTableOptionsSchema: S.t<Internal.clickhouseTableOptions> = S.object(s => {
   Internal.partitionBy: ?s.field("partitionBy", S.option(S.string)),
   orderBy: ?s.field("orderBy", S.option(S.array(S.string))),
   ttl: ?s.field("ttl", S.option(S.string)),
+  skippingIndexes: ?s.field("skippingIndexes", S.option(S.array(clickhouseSkippingIndexSchema))),
 })
 
 // The entity's `clickhouse` storage arg mirrors the @storage directive:
@@ -377,6 +310,7 @@ let entityJsonSchema = S.schema(s =>
     "name": s.matches(S.string),
     "crossChain": s.matches(S.option(S.bool)),
     "storage": s.matches(S.option(entityStorageSchema)),
+    "internal": s.matches(S.option(S.bool)),
     "properties": s.matches(S.array(propertySchema)),
     "derivedFields": s.matches(S.option(S.array(derivedFieldSchema))),
     "compositeIndices": s.matches(S.option(S.array(S.array(compositeIndexFieldSchema)))),
@@ -431,7 +365,7 @@ let getFieldTypeAndSchema = (prop, ~enumConfigsByName: dict<Table.enumConfig<Tab
     baseSchema
   }
   let fieldSchema = if isNullable {
-    S.null(fieldSchema)->S.toUnknown
+    Utils.Schema.nullTolerant(fieldSchema)->S.toUnknown
   } else {
     fieldSchema
   }
@@ -580,6 +514,7 @@ let parseEntitiesFromJson = (
       table,
       storage,
       crossChain,
+      internal: entityJson["internal"]->Option.getOr(false),
     }->Internal.fromGenericEntityConfig
   })
 }
@@ -600,6 +535,7 @@ let publicConfigSchema = S.schema(s =>
     "name": s.matches(S.string),
     "description": s.matches(S.option(S.string)),
     "handlers": s.matches(S.option(S.string)),
+    "resolvers": s.matches(S.option(S.string)),
     "isDev": s.matches(S.option(S.bool)),
     "fullBatchSize": s.matches(S.option(S.int)),
     "rollbackOnReorg": s.matches(S.option(S.bool)),
@@ -616,6 +552,14 @@ let publicConfigSchema = S.schema(s =>
   }
 )
 
+let contractMappingOf = (~chainConfigs: array<chain>): ContractMapping.t => {
+  let names = []
+  chainConfigs->Array.forEach(chain =>
+    chain.contracts->Array.forEach(contract => names->Array.push(contract.name)->ignore)
+  )
+  ContractMapping.make(~names)
+}
+
 let fromPublic = (publicConfigJson: JSON.t) => {
   let maxAddrInPartition = Env.maxAddrInPartition
   // Parse public config
@@ -795,14 +739,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
               Utils.magic: _ => {
                 "svm": option<{
                   "discriminator": option<string>,
-                  "discriminatorByteLen": int,
-                  "transactionFields": array<Internal.svmTransactionField>,
-                  "blockFields": option<array<Internal.svmBlockField>>,
-                  "includeLogs": bool,
-                  "accountFilters": option<
-                    array<array<{"position": int, "values": array<string>}>>,
-                  >,
-                  "isInner": option<bool>,
                   "accounts": option<array<string>>,
                   "args": option<JSON.t>,
                 }>,
@@ -815,28 +751,11 @@ let fromPublic = (publicConfigJson: JSON.t) => {
               `SVM instruction ${contractName}.${eventName} is missing the "svm" descriptor in internal config`,
             )
           }
-          let accountFilters =
-            svm["accountFilters"]
-            ->Option.getOr([])
-            ->Array.map(group =>
-              group->Array.map(
-                af => {
-                  Internal.position: af["position"],
-                  values: af["values"]->SvmTypes.Pubkey.fromStringsUnsafe,
-                },
-              )
-            )
           (EventConfigBuilder.buildSvmInstructionEventConfig(
             ~contractName,
             ~instructionName=eventName,
             ~programId,
             ~discriminator=svm["discriminator"],
-            ~discriminatorByteLen=svm["discriminatorByteLen"],
-            ~transactionFields=svm["transactionFields"],
-            ~blockFields=?svm["blockFields"],
-            ~includeLogs=svm["includeLogs"],
-            ~accountFilters,
-            ~isInner=svm["isInner"],
             ~accounts=svm["accounts"]->Option.getOr([]),
             ~args=svm["args"]->Option.getOr(JSON.Null),
             ~definedTypes=svmDefinedTypes,
@@ -923,25 +842,24 @@ let fromPublic = (publicConfigJson: JSON.t) => {
           }
         })
 
-      // The same address under two contract definitions (or twice under one)
-      // would later violate the (chainId, address) primary key of
-      // envio_addresses with an opaque Postgres error — fail fast with the
-      // offending pair instead. parseAddress already canonicalizes casing
-      // (checksum or lowercase), so an exact match catches case variants too.
-      let contractNameByAddress = Dict.make()
+      // One address listed twice for the same contract would violate the
+      // (chainId, address, contract) primary key of envio_addresses with an
+      // opaque Postgres error — fail fast instead. Two contracts may share an
+      // address: each indexes it with its own events. parseAddress already
+      // canonicalizes casing (checksum or lowercase), so an exact match
+      // catches case variants too.
+      let seen = Utils.Set.make()
       contracts->Array.forEach(contract => {
         contract.addresses->Array.forEach(
           address => {
             let addressString = address->Address.toString
-            switch contractNameByAddress->Dict.get(addressString) {
-            | Some(existingContractName) =>
+            let key = contract.name ++ "-" ++ addressString
+            if seen->Utils.Set.has(key) {
               JsError.throwWithMessage(
-                existingContractName === contract.name
-                  ? `Address ${addressString} is listed multiple times for the contract ${contract.name} on chain ${chainId->ChainId.toString}. Please remove the duplicate from your config.`
-                  : `Address ${addressString} on chain ${chainId->ChainId.toString} is configured for multiple contracts: ${existingContractName} and ${contract.name}. Indexing the same address with multiple contract definitions is not supported. Please define the events on a single contract definition instead.`,
+                `Address ${addressString} is listed multiple times for the contract ${contract.name} on chain ${chainId->ChainId.toString}. Please remove the duplicate from your config.`,
               )
-            | None => contractNameByAddress->Dict.set(addressString, contract.name)
             }
+            seen->Utils.Set.add(key)->ignore
           },
         )
       })
@@ -1012,6 +930,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
       {
         name: chainName,
         id: chainId,
+        ecosystem: ecosystemName,
         startBlock: publicChainConfig["startBlock"],
         endBlock: ?publicChainConfig["endBlock"],
         maxReorgDepth: switch ecosystemName {
@@ -1066,8 +985,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     ->Option.getOr([])
     ->parseEntitiesFromJson(~enumConfigsByName, ~globalStorage, ~defaultCrossChain)
 
-  let allEntities = userEntities->Array.concat([EnvioAddresses.entityConfig])
-
   // Keyed by the capitalized entity name to match the handler-context
   // accessor (`context.Pool_snapshots`) the generated types expose, while
   // entityConfig.name stays the original schema name used for the physical
@@ -1097,6 +1014,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     name: publicConfig["name"],
     description: publicConfig["description"],
     handlers: publicConfig["handlers"]->Option.getOr("src/handlers"),
+    resolvers: publicConfig["resolvers"],
     contractHandlers,
     shouldRollbackOnReorg: publicConfig["rollbackOnReorg"]->Option.getOr(true),
     shouldSaveFullHistory: publicConfig["saveFullHistory"]->Option.getOr(false),
@@ -1104,6 +1022,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     storage: globalStorage,
     chainIdMode: publicConfig["chainIdMode"]->Option.getOr(Int32),
     chainMap,
+    contractMapping: contractMappingOf(~chainConfigs=chains),
     defaultChain: chains->Array.get(0),
     enableRawEvents: publicConfig["rawEvents"]->Option.getOr(false),
     ecosystem,
@@ -1115,11 +1034,18 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     isDev: publicConfig["isDev"]->Option.getOr(false),
     userEntitiesByName,
     userEntities,
-    allEntities,
     allEnums,
   }
 }
 
+// With no cross-chain entity, a reorg on one chain can never have changed a row
+// another chain owns, so its rollback stays isolated to that chain instead of
+// dragging every sibling back with it. A single chain has no sibling to spare,
+// and narrowing its rollback would only buy it a predicate that always holds.
+let isIsolatedMultichain = (config: t) =>
+  config.chainMap->ChainMap.keys->Array.length > 1 &&
+    config.userEntities->Array.every(entityConfig => !entityConfig.crossChain)
+
 // Canonicalize a user-provided address to the configured casing so it matches
 // addresses parsed from config.yaml during routing. HyperSync/RPC data arrives
 // already canonical; only user-land input (simulate srcAddress, contractRegister
@@ -1222,8 +1148,11 @@ let getPublicConfigJson = () =>
 
 // Drops source URLs from each chain so RPC/hypersync edits don't trigger
 // the resume-time compat check (and don't end up in `envio_info`). Also
-// drops `isDev`, which toggles between `envio dev` and `envio start` and
-// has no bearing on schema/indexing compatibility.
+// drops two fields that have no bearing on schema/indexing compatibility:
+// `isDev`, which toggles between `envio dev` and `envio start`, and
+// `resolvers`, which names where the custom GraphQL resolvers live. Without
+// the latter, adding `resolvers:` to a running indexer reads as an
+// incompatible config change and it refuses to resume.
 let stripSensitiveData = (json: JSON.t): JSON.t => {
   let cloned = json->JSON.stringify->JSON.parseOrThrow
   let stripChains = (ecosystem: option<JSON.t>) =>
@@ -1250,6 +1179,7 @@ let stripSensitiveData = (json: JSON.t): JSON.t => {
   switch cloned {
   | Object(obj) => {
       obj->Utils.Dict.deleteInPlace("isDev")
+      obj->Utils.Dict.deleteInPlace("resolvers")
       stripChains(obj->Dict.get("evm"))
       stripChains(obj->Dict.get("fuel"))
       stripChains(obj->Dict.get("svm"))

package/src/Config.res.mjs

@@ -16,6 +16,7 @@ import * as BigDecimal from "./bindings/BigDecimal.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as ContractMapping from "./ContractMapping.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -32,57 +33,6 @@ function chainIdColumnName(format) {
   }
 }
 
-let name = "envio_addresses";
-
-function makeId(chainId, address) {
-  return ChainId.toString(chainId) + "-" + address;
-}
-
-function getAddress(entity) {
-  let sepIdx = entity.id.indexOf("-");
-  return entity.id.slice(sepIdx + 1 | 0, entity.id.length);
-}
-
-let schema = S$RescriptSchema.schema(s => ({
-  id: s.m(S$RescriptSchema.string),
-  chain_id: s.m(ChainId.schema),
-  registration_block: s.m(S$RescriptSchema.int),
-  registration_log_index: s.m(S$RescriptSchema.int),
-  contract_name: s.m(S$RescriptSchema.string)
-}));
-
-let table = Table.mkTable(name, undefined, [
-  Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("chain_id", "ChainId", ChainId.schema, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("registration_block", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("registration_log_index", "Int32", S$RescriptSchema.int, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined),
-  Table.mkField("contract_name", "String", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined)
-], undefined);
-
-let entityConfig_storage = {
-  postgres: true,
-  clickhouse: false
-};
-
-let entityConfig = {
-  name: name,
-  index: -1,
-  schema: schema,
-  table: table,
-  storage: entityConfig_storage,
-  crossChain: true
-};
-
-let EnvioAddresses = {
-  name: name,
-  index: -1,
-  makeId: makeId,
-  getAddress: getAddress,
-  schema: schema,
-  table: table,
-  entityConfig: entityConfig
-};
-
 let rpcSourceForSchema = S$RescriptSchema.$$enum([
   "sync",
   "fallback",
@@ -123,15 +73,6 @@ let publicConfigChainSchema = S$RescriptSchema.schema(s => ({
 
 let svmEventDescriptorSchema = S$RescriptSchema.schema(s => ({
   discriminator: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
-  discriminatorByteLen: s.m(S$RescriptSchema.int),
-  transactionFields: s.m(S$RescriptSchema.array(Internal.svmTransactionFieldSchema)),
-  blockFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.svmBlockFieldSchema))),
-  includeLogs: s.m(S$RescriptSchema.bool),
-  accountFilters: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.array(S$RescriptSchema.schema(s => ({
-    position: s.m(S$RescriptSchema.int),
-    values: s.m(S$RescriptSchema.array(S$RescriptSchema.string))
-  })))))),
-  isInner: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   accounts: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string))),
   args: s.m(S$RescriptSchema.option(S$RescriptSchema.json(false)))
 }));
@@ -204,10 +145,18 @@ let propertySchema = S$RescriptSchema.schema(s => ({
   description: s.m(S$RescriptSchema.option(S$RescriptSchema.string))
 }));
 
+let clickhouseSkippingIndexSchema = S$RescriptSchema.object(s => ({
+  name: s.f("name", S$RescriptSchema.string),
+  expr: s.f("expr", S$RescriptSchema.string),
+  type: s.f("type", S$RescriptSchema.string),
+  granularity: s.f("granularity", S$RescriptSchema.option(S$RescriptSchema.int))
+}));
+
 let clickhouseTableOptionsSchema = S$RescriptSchema.object(s => ({
   partitionBy: s.f("partitionBy", S$RescriptSchema.option(S$RescriptSchema.string)),
   orderBy: s.f("orderBy", S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string))),
-  ttl: s.f("ttl", S$RescriptSchema.option(S$RescriptSchema.string))
+  ttl: s.f("ttl", S$RescriptSchema.option(S$RescriptSchema.string)),
+  skippingIndexes: s.f("skippingIndexes", S$RescriptSchema.option(S$RescriptSchema.array(clickhouseSkippingIndexSchema)))
 }));
 
 let entityClickhouseStorageJsonSchema = S$RescriptSchema.union([
@@ -230,6 +179,7 @@ let entityJsonSchema = S$RescriptSchema.schema(s => ({
   name: s.m(S$RescriptSchema.string),
   crossChain: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   storage: s.m(S$RescriptSchema.option(entityStorageSchema)),
+  internal: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   properties: s.m(S$RescriptSchema.array(propertySchema)),
   derivedFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(derivedFieldSchema))),
   compositeIndices: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.array(compositeIndexFieldSchema)))),
@@ -322,7 +272,7 @@ function getFieldTypeAndSchema(prop, enumConfigsByName) {
   }
   let baseSchema = match[1];
   let fieldSchema = isArray ? S$RescriptSchema.array(baseSchema) : baseSchema;
-  let fieldSchema$1 = isNullable ? S$RescriptSchema.$$null(fieldSchema) : fieldSchema;
+  let fieldSchema$1 = isNullable ? Utils.Schema.nullTolerant(fieldSchema) : fieldSchema;
   return [
     match[0],
     fieldSchema$1,
@@ -400,7 +350,8 @@ function parseEntitiesFromJson(entitiesJson, enumConfigsByName, globalStorage, d
       schema: schema,
       table: table,
       storage: storage,
-      crossChain: crossChain
+      crossChain: crossChain,
+      internal: Stdlib_Option.getOr(entityJson.internal, false)
     };
   });
 }
@@ -421,6 +372,7 @@ let publicConfigSchema = S$RescriptSchema.schema(s => ({
   name: s.m(S$RescriptSchema.string),
   description: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   handlers: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
+  resolvers: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   isDev: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   fullBatchSize: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   rollbackOnReorg: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
@@ -436,6 +388,16 @@ let publicConfigSchema = S$RescriptSchema.schema(s => ({
   entities: s.m(S$RescriptSchema.option(S$RescriptSchema.array(entityJsonSchema)))
 }));
 
+function contractMappingOf(chainConfigs) {
+  let names = [];
+  chainConfigs.forEach(chain => {
+    chain.contracts.forEach(contract => {
+      names.push(contract.name);
+    });
+  });
+  return ContractMapping.make(names);
+}
+
 function fromPublic(publicConfigJson) {
   let publicConfig;
   try {
@@ -560,11 +522,7 @@ function fromPublic(publicConfigJson) {
               ) : addresses[0];
             let s = eventItem.svm;
             let svm = s !== undefined ? Primitive_option.valFromOption(s) : Stdlib_JsError.throwWithMessage(`SVM instruction ` + contractName + `.` + eventName + ` is missing the "svm" descriptor in internal config`);
-            let accountFilters = Stdlib_Option.getOr(svm.accountFilters, []).map(group => group.map(af => ({
-              position: af.position,
-              values: af.values
-            })));
-            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, svm.includeLogs, svm.transactionFields, svm.blockFields, accountFilters, svm.isInner, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes);
+            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes);
         }
       });
     } else {
@@ -614,16 +572,14 @@ function fromPublic(publicConfigJson) {
         startBlock: startBlock
       };
     });
-    let contractNameByAddress = {};
+    let seen = new Set();
     contracts.forEach(contract => {
       contract.addresses.forEach(address => {
-        let existingContractName = contractNameByAddress[address];
-        if (existingContractName !== undefined) {
-          return Stdlib_JsError.throwWithMessage(existingContractName === contract.name ? `Address ` + address + ` is listed multiple times for the contract ` + contract.name + ` on chain ` + ChainId.toString(chainId) + `. Please remove the duplicate from your config.` : `Address ` + address + ` on chain ` + ChainId.toString(chainId) + ` is configured for multiple contracts: ` + existingContractName + ` and ` + contract.name + `. Indexing the same address with multiple contract definitions is not supported. Please define the events on a single contract definition instead.`);
-        } else {
-          contractNameByAddress[address] = contract.name;
-          return;
+        let key = contract.name + "-" + address;
+        if (seen.has(key)) {
+          Stdlib_JsError.throwWithMessage(`Address ` + address + ` is listed multiple times for the contract ` + contract.name + ` on chain ` + ChainId.toString(chainId) + `. Please remove the duplicate from your config.`);
         }
+        seen.add(key);
       });
     });
     let sourceConfig;
@@ -696,6 +652,7 @@ function fromPublic(publicConfigJson) {
     return {
       name: chainName,
       id: chainId,
+      ecosystem: ecosystemName,
       startBlock: publicChainConfig.startBlock,
       endBlock: publicChainConfig.endBlock,
       maxReorgDepth: tmp,
@@ -725,7 +682,6 @@ function fromPublic(publicConfigJson) {
   };
   let defaultCrossChain = Stdlib_Option.getOr(publicConfig.defaultCrossChain, true);
   let userEntities = parseEntitiesFromJson(Stdlib_Option.getOr(publicConfig.entities, []), enumConfigsByName, globalStorage, defaultCrossChain);
-  let allEntities = userEntities.concat([entityConfig]);
   let userEntitiesByName = Object.fromEntries(userEntities.map(entityConfig => [
     Utils.$$String.capitalize(entityConfig.name),
     entityConfig
@@ -738,6 +694,7 @@ function fromPublic(publicConfigJson) {
     name: publicConfig.name,
     description: publicConfig.description,
     handlers: Stdlib_Option.getOr(publicConfig.handlers, "src/handlers"),
+    resolvers: publicConfig.resolvers,
     contractHandlers: contractHandlers,
     shouldRollbackOnReorg: Stdlib_Option.getOr(publicConfig.rollbackOnReorg, true),
     shouldSaveFullHistory: Stdlib_Option.getOr(publicConfig.saveFullHistory, false),
@@ -745,6 +702,7 @@ function fromPublic(publicConfigJson) {
     storage: globalStorage,
     chainIdMode: Stdlib_Option.getOr(publicConfig.chainIdMode, "int32"),
     chainMap: chainMap,
+    contractMapping: contractMappingOf(chains),
     defaultChain: chains[0],
     ecosystem: ecosystem,
     enableRawEvents: Stdlib_Option.getOr(publicConfig.rawEvents, false),
@@ -756,11 +714,18 @@ function fromPublic(publicConfigJson) {
     isDev: Stdlib_Option.getOr(publicConfig.isDev, false),
     userEntitiesByName: userEntitiesByName,
     userEntities: userEntities,
-    allEntities: allEntities,
     allEnums: allEnums
   };
 }
 
+function isIsolatedMultichain(config) {
+  if (ChainMap.keys(config.chainMap).length > 1) {
+    return config.userEntities.every(entityConfig => !entityConfig.crossChain);
+  } else {
+    return false;
+  }
+}
+
 function normalizeUserAddress(config, address) {
   let match = config.ecosystem.name;
   switch (match) {
@@ -899,6 +864,7 @@ function stripSensitiveData(json) {
   };
   if (typeof cloned === "object" && cloned !== null && !Array.isArray(cloned)) {
     Utils.Dict.deleteInPlace(cloned, "isDev");
+    Utils.Dict.deleteInPlace(cloned, "resolvers");
     stripChains(cloned["evm"]);
     stripChains(cloned["fuel"]);
     stripChains(cloned["svm"]);
@@ -1083,7 +1049,6 @@ function getPgUserEntities(config) {
 export {
   chainIdFieldName,
   chainIdColumnName,
-  EnvioAddresses,
   rpcSourceForSchema,
   rpcConfigSchema,
   chainContractSchema,
@@ -1097,6 +1062,7 @@ export {
   compositeIndexFieldSchema,
   derivedFieldSchema,
   propertySchema,
+  clickhouseSkippingIndexSchema,
   clickhouseTableOptionsSchema,
   entityClickhouseStorageJsonSchema,
   entityStorageSchema,
@@ -1108,7 +1074,9 @@ export {
   columnNameFormatSchema,
   publicConfigStorageSchema,
   publicConfigSchema,
+  contractMappingOf,
   fromPublic,
+  isIsolatedMultichain,
   normalizeUserAddress,
   normalizeSimulateAddress,
   getEventConfig,
@@ -1124,4 +1092,4 @@ export {
   load,
   getPgUserEntities,
 }
-/* schema Not a pure module */
+/* rpcSourceForSchema Not a pure module */