envio 3.8.0 → 3.9.0

package/src/TestIndexer.res

@@ -37,44 +37,19 @@ type testIndexerState = {
   // Store decoded entities (not JSON) for proper comparison operations
   entities: dict<dict<Internal.entity>>,
   entityConfigs: dict<Internal.entityConfig>,
+  addresses: AddressRows.Table.t,
+  contractMapping: ContractMapping.t,
   mutable processChanges: array<unknown>,
 }
 
-// Cast Internal.entity back to EnvioAddresses.t
-external castToEnvioAddresses: Internal.entity => InternalTable.EnvioAddresses.t = "%identity"
+let addressRowsByChain = (state: testIndexerState) =>
+  state.addresses->AddressRows.Table.groupByChain
 
-let toIndexingAddress = (dc: InternalTable.EnvioAddresses.t): Internal.indexingAddress => {
-  address: dc->Config.EnvioAddresses.getAddress,
-  contractName: dc.contractName,
-  registrationBlock: dc.registrationBlock,
-}
-
-// All indexing addresses (config-seeded + dynamically registered) grouped by
-// chain id string, derived from the envio_addresses entities.
-let getIndexingAddressesByChain = (state: testIndexerState): dict<
-  array<Internal.indexingAddress>,
-> => {
-  let byChain = Dict.make()
-  switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
-  | Some(dcDict) =>
-    dcDict
-    ->Dict.valuesToArray
-    ->Array.forEach(entity => {
-      let dc = entity->castToEnvioAddresses
-      let chainIdStr = dc.chainId->ChainId.toString
-      let contracts = switch byChain->Dict.get(chainIdStr) {
-      | Some(arr) => arr
-      | None =>
-        let arr = []
-        byChain->Dict.set(chainIdStr, arr)
-        arr
-      }
-      contracts->Array.push(dc->toIndexingAddress)->ignore
-    })
-  | None => ()
-  }
-  byChain
-}
+let renderRows = (rows: array<AddressRows.row>, ~config: Config.t) =>
+  rows->AddressRows.render(
+    ~ecosystem=(config.ecosystem.name :> string),
+    ~shouldChecksum=!config.lowercaseAddresses,
+  )
 
 // Rows of a per-chain entity are keyed per (chain, id): the same id exists
 // independently on every chain.
@@ -125,7 +100,9 @@ let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFi
 
 let handleWriteBatch = (
   state: testIndexerState,
+  ~config: Config.t,
   ~updatedEntities: array<Persistence.updatedEntity>,
+  ~registeredAddresses: array<AddressRows.staged>,
   ~checkpointIds: array<bigint>,
   ~checkpointChainIds: array<ChainId.t>,
   ~checkpointBlockNumbers: array<int>,
@@ -135,6 +112,22 @@ let handleWriteBatch = (
   // checkpointId -> entityName -> entityChange
   let changesByCheckpoint: dict<dict<entityChange>> = Dict.make()
 
+  // checkpointId -> the addresses that checkpoint registered, rendered for the
+  // change log. Rendering is the Rust codec's job, so the rows keep their keys
+  // right up to here.
+  let addressesByCheckpoint: dict<array<{"address": Address.t, "contract": string}>> = Dict.make()
+  let rendered = registeredAddresses->Array.map(({row}) => row)->renderRows(~config)
+  registeredAddresses->Array.forEachWithIndex(({row, checkpointId}, idx) => {
+    state.addresses->AddressRows.Table.insert(row)
+    addressesByCheckpoint->Utils.Dict.push(
+      checkpointId->BigInt.toString,
+      {
+        "address": rendered->Array.getUnsafe(idx),
+        "contract": state.contractMapping->ContractMapping.nameOfOrThrow(row.contractId),
+      },
+    )
+  })
+
   updatedEntities->Array.forEach(({entityConfig, scope, changes}: Persistence.updatedEntity) => {
     let entityName = entityConfig.name
     // The scope is what makes a per-chain row identifiable, so it's stamped
@@ -210,43 +203,33 @@ let handleWriteBatch = (
 
     // Add entity changes for this checkpoint
     let checkpointKey = checkpointId->BigInt.toString
+    switch addressesByCheckpoint->Utils.Dict.dangerouslyGetNonOption(checkpointKey) {
+    | Some(rendered) =>
+      let addressesObj: dict<unknown> = Dict.make()
+      addressesObj->Dict.set(
+        "sets",
+        rendered->(Utils.magic: array<{"address": Address.t, "contract": string}> => unknown),
+      )
+      change->Dict.set("addresses", addressesObj->(Utils.magic: dict<unknown> => unknown))
+    | None => ()
+    }
     switch changesByCheckpoint->Dict.get(checkpointKey) {
     | Some(entityChanges) =>
       entityChanges
       ->Dict.toArray
       ->Array.forEach(((entityName, {sets, deleted})) => {
-        // Transform envio_addresses to addresses with simplified structure
-        if entityName === InternalTable.EnvioAddresses.name {
-          let entityObj: dict<unknown> = Dict.make()
-          if sets->Array.length > 0 {
-            // Transform sets to simplified {address, contract} objects
-            let simplifiedSets = sets->Array.map(entity => {
-              let dc = entity->Utils.magic->castToEnvioAddresses
-              {"address": dc->Config.EnvioAddresses.getAddress, "contract": dc.contractName}
-            })
-            entityObj->Dict.set(
-              "sets",
-              simplifiedSets->(
-                Utils.magic: array<{"address": Address.t, "contract": string}> => unknown
-              ),
-            )
-          }
-          // Note: deleted is not relevant for addresses since we use address string directly
-          change->Dict.set("addresses", entityObj->(Utils.magic: dict<unknown> => unknown))
-        } else {
-          let entityObj: dict<unknown> = Dict.make()
-          if sets->Array.length > 0 {
-            entityObj->Dict.set("sets", sets->(Utils.magic: array<unknown> => unknown))
-          }
-          if deleted->Array.length > 0 {
-            entityObj->Dict.set("deleted", deleted->(Utils.magic: array<EntityId.t> => unknown))
-          }
-          // Match the capitalized entity accessor the generated change types expose.
-          change->Dict.set(
-            entityName->Utils.String.capitalize,
-            entityObj->(Utils.magic: dict<unknown> => unknown),
-          )
+        let entityObj: dict<unknown> = Dict.make()
+        if sets->Array.length > 0 {
+          entityObj->Dict.set("sets", sets->(Utils.magic: array<unknown> => unknown))
+        }
+        if deleted->Array.length > 0 {
+          entityObj->Dict.set("deleted", deleted->(Utils.magic: array<EntityId.t> => unknown))
         }
+        // Match the capitalized entity accessor the generated change types expose.
+        change->Dict.set(
+          entityName->Utils.String.capitalize,
+          entityObj->(Utils.magic: dict<unknown> => unknown),
+        )
       })
     | None => ()
     }
@@ -260,7 +243,8 @@ let handleWriteBatch = (
 let makeInitialState = (
   ~config: Config.t,
   ~processConfigChains: dict<chainConfig>,
-  ~indexingAddressesByChain: dict<array<Internal.indexingAddress>>,
+  ~addressRowsByChain: dict<AddressRows.seedRows>,
+  ~contractMapping: ContractMapping.t,
 ): Persistence.initialState => {
   let chainKeys = processConfigChains->Dict.keysToArray
   let chains = chainKeys->Array.map(chainIdStr => {
@@ -271,7 +255,10 @@ let makeInitialState = (
     }
 
     let processChainConfig = processConfigChains->Dict.getUnsafe(chainIdStr)
-    let indexingAddresses = indexingAddressesByChain->Dict.get(chainIdStr)->Option.getOr([])
+    let addressRows =
+      addressRowsByChain
+      ->Utils.Dict.dangerouslyGetNonOption(chainIdStr)
+      ->Option.getOr(AddressRows.emptySeedRows())
     {
       Persistence.id: chain,
       startBlock: processChainConfig.startBlock,
@@ -282,17 +269,18 @@ let makeInitialState = (
       numEventsProcessed: 0.,
       firstEventBlockNumber: None,
       timestampCaughtUpToHeadOrEndblock: None,
-      indexingAddresses,
+      addressRows,
     }
   })
 
   {
     cleanRun: true,
+    contractMapping,
+    envioInfo: Some(JSON.Encode.object(Dict.make())),
     cache: Dict.make(),
     chains,
     checkpointId: InternalTable.Checkpoints.initialCheckpointId,
     reorgCheckpoints: [],
-    envioInfo: Some(Config.getPublicConfigJson()->Config.stripSensitiveData),
   }
 }
 
@@ -591,7 +579,13 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
   // The runner injects the config-derived initial state by setting
   // `persistence.storageStatus = Ready(...)` directly, bypassing `Persistence.init`,
   // so neither of these is reached.
-  initialize: async (~chainConfigs as _=?, ~entities as _=?, ~enums as _=?, ~envioInfo as _) =>
+  initialize: async (
+    ~chainConfigs as _=?,
+    ~entities as _=?,
+    ~enums as _=?,
+    ~contractMapping as _,
+    ~envioInfo as _,
+  ) =>
     JsError.throwWithMessage(
       "TestIndexer: initialize should not be called; the initial state is derived from config.",
     ),
@@ -611,15 +605,18 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     ~batch,
     ~rollback as _,
     ~isInReorgThreshold as _,
-    ~config as _,
+    ~config,
     ~allEntities as _,
     ~updatedEffectsCache as _,
     ~updatedEntities,
+    ~registeredAddresses,
     ~chainMetaData as _,
     ~onWrite as _,
   ) =>
     state->handleWriteBatch(
+      ~config,
       ~updatedEntities,
+      ~registeredAddresses,
       ~checkpointIds=batch.checkpointIds,
       ~checkpointChainIds=batch.checkpointChainIds,
       ~checkpointBlockNumbers=batch.checkpointBlockNumbers,
@@ -688,7 +685,7 @@ let getRegistrations = (~config) =>
 
 let createTestIndexer = (): t<'processConfig> => {
   let config = Config.load()
-  let allEntities = config.allEntities
+  let allEntities = config.userEntities
   let entities = Dict.make()
   let entityConfigs = Dict.make()
   allEntities->Array.forEach(entityConfig => {
@@ -696,32 +693,19 @@ let createTestIndexer = (): t<'processConfig> => {
     entityConfigs->Dict.set(entityConfig.name, entityConfig)
   })
 
-  // Populate config addresses into the entity dict, mirroring PgStorage.initialize
-  let envioAddressesDict = entities->Dict.getUnsafe(InternalTable.EnvioAddresses.name)
-  config.chainMap
-  ->ChainMap.values
-  ->Array.forEach(chainConfig => {
-    chainConfig.contracts->Array.forEach(contract => {
-      contract.addresses->Array.forEach(
-        address => {
-          let entity: InternalTable.EnvioAddresses.t = {
-            id: Config.EnvioAddresses.makeId(~chainId=chainConfig.id, ~address),
-            chainId: chainConfig.id,
-            contractName: contract.name,
-            registrationBlock: -1,
-            registrationLogIndex: -1,
-          }
-          envioAddressesDict->Dict.set(entity.id, entity->Config.EnvioAddresses.castToInternal)
-        },
-      )
-    })
-  })
+  let chainConfigs = config.chainMap->ChainMap.values
+  let contractMapping = config.contractMapping
+  let ecosystem = config.ecosystem.name
+  let addresses = AddressRows.Table.make()
+  addresses->ChainState.seedConfigAddresses(~chainConfigs, ~ecosystem, ~contractMapping)
 
   let state = {
     processInProgress: false,
     progressBlockByChain: Dict.make(),
     entities,
     entityConfigs,
+    addresses,
+    contractMapping,
     processChanges: [],
   }
 
@@ -744,19 +728,16 @@ let createTestIndexer = (): t<'processConfig> => {
   // Build entity operations for each user entity
   let entityOpsDict: dict<entityOperations> = Dict.make()
   allEntities->Array.forEach(entityConfig => {
-    // Only create ops for user entities (not internal tables like envio_addresses)
-    if entityConfig.name !== InternalTable.EnvioAddresses.name {
-      entityOpsDict->Dict.set(
-        entityConfig.name,
-        {
-          get: makeEntityGet(~state, ~entityConfig),
-          getAll: makeEntityGetAll(~state, ~entityConfig),
-          getWhere: makeEntityGetWhere(~state, ~entityConfig),
-          getOrThrow: makeEntityGetOrThrow(~state, ~entityConfig),
-          set: makeEntitySet(~state, ~entityConfig),
-        },
-      )
-    }
+    entityOpsDict->Dict.set(
+      entityConfig.name,
+      {
+        get: makeEntityGet(~state, ~entityConfig),
+        getAll: makeEntityGetAll(~state, ~entityConfig),
+        getWhere: makeEntityGetWhere(~state, ~entityConfig),
+        getOrThrow: makeEntityGetOrThrow(~state, ~entityConfig),
+        set: makeEntitySet(~state, ~entityConfig),
+      },
+    )
   })
 
   // Build chain info from config (similar to Main.getGlobalIndexer but static)
@@ -799,10 +780,11 @@ let createTestIndexer = (): t<'processConfig> => {
                 `Cannot access ${contract.name}.addresses while indexer.process() is running. ` ++ "Wait for process() to complete before reading contract addresses.",
               )
             }
-            getIndexingAddressesByChain(state)
-            ->Dict.get(chainConfig.id->ChainId.toString)
-            ->Option.getOr([])
-            ->Array.filterMap(ia => ia.contractName === contract.name ? Some(ia.address) : None)
+            let contractId = state.contractMapping->ContractMapping.idOfOrThrow(contract.name)
+            state.addresses
+            ->AddressRows.Table.rows
+            ->Array.filter(row => row.chainId === chainConfig.id && row.contractId === contractId)
+            ->renderRows(~config)
           },
         },
       )
@@ -899,11 +881,11 @@ let createTestIndexer = (): t<'processConfig> => {
           // by earlier ones.
           let chains: dict<chainConfig> = Dict.make()
           chains->Dict.set(chainIdStr, processChainConfig)
-          let indexingAddressesByChain = getIndexingAddressesByChain(state)
           let initialState = makeInitialState(
             ~config,
             ~processConfigChains=chains,
-            ~indexingAddressesByChain,
+            ~addressRowsByChain=addressRowsByChain(state),
+            ~contractMapping=state.contractMapping,
           )
 
           // No endBlock means auto-exit mode: process one block checkpoint at a

package/src/TestIndexer.res.mjs

@@ -9,13 +9,14 @@ import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as EntityId from "./EntityId.res.mjs";
 import * as Internal from "./Internal.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as AddressRows from "./AddressRows.res.mjs";
 import * as IndexerLoop from "./IndexerLoop.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as HandlerLoader from "./HandlerLoader.res.mjs";
 import * as InternalTable from "./db/InternalTable.res.mjs";
@@ -24,37 +25,17 @@ import * as SimulateItems from "./SimulateItems.res.mjs";
 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 Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as ContractMapping from "./ContractMapping.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function toIndexingAddress(dc) {
-  return {
-    address: Config.EnvioAddresses.getAddress(dc),
-    contractName: dc.contract_name,
-    registrationBlock: dc.registration_block
-  };
+function addressRowsByChain(state) {
+  return AddressRows.Table.groupByChain(state.addresses);
 }
 
-function getIndexingAddressesByChain(state) {
-  let byChain = {};
-  let dcDict = state.entities[Config.EnvioAddresses.name];
-  if (dcDict !== undefined) {
-    Object.values(dcDict).forEach(entity => {
-      let chainIdStr = ChainId.toString(entity.chain_id);
-      let arr = byChain[chainIdStr];
-      let contracts;
-      if (arr !== undefined) {
-        contracts = arr;
-      } else {
-        let arr$1 = [];
-        byChain[chainIdStr] = arr$1;
-        contracts = arr$1;
-      }
-      contracts.push(toIndexingAddress(entity));
-    });
-  }
-  return byChain;
+function renderRows(rows, config) {
+  return AddressRows.render(rows, config.ecosystem.name, !config.lowercaseAddresses);
 }
 
 function rowKey(scope, entityId) {
@@ -88,8 +69,18 @@ function handleLoad(state, tableName, filter) {
   }
 }
 
-function handleWriteBatch(state, updatedEntities, checkpointIds, checkpointChainIds, checkpointBlockNumbers, checkpointEventsProcessed) {
+function handleWriteBatch(state, config, updatedEntities, registeredAddresses, checkpointIds, checkpointChainIds, checkpointBlockNumbers, checkpointEventsProcessed) {
   let changesByCheckpoint = {};
+  let addressesByCheckpoint = {};
+  let rendered = renderRows(registeredAddresses.map(param => param.row), config);
+  registeredAddresses.forEach((param, idx) => {
+    let row = param.row;
+    AddressRows.Table.insert(state.addresses, row);
+    Utils.Dict.push(addressesByCheckpoint, param.checkpointId.toString(), {
+      address: rendered[idx],
+      contract: ContractMapping.nameOfOrThrow(state.contractMapping, row.contractId)
+    });
+  });
   updatedEntities.forEach(param => {
     let scope = param.scope;
     let entityConfig = param.entityConfig;
@@ -151,40 +142,33 @@ function handleWriteBatch(state, updatedEntities, checkpointIds, checkpointChain
     change["chainId"] = checkpointChainIds[i];
     change["eventsProcessed"] = checkpointEventsProcessed[i];
     let checkpointKey = checkpointId.toString();
+    let rendered$1 = addressesByCheckpoint[checkpointKey];
+    if (rendered$1 !== undefined) {
+      let addressesObj = {};
+      addressesObj["sets"] = rendered$1;
+      change["addresses"] = addressesObj;
+    }
     let entityChanges = changesByCheckpoint[checkpointKey];
     if (entityChanges !== undefined) {
       Object.entries(entityChanges).forEach(param => {
         let match = param[1];
         let deleted = match.deleted;
         let sets = match.sets;
-        let entityName = param[0];
-        if (entityName === Config.EnvioAddresses.name) {
-          let entityObj = {};
-          if (sets.length !== 0) {
-            let simplifiedSets = sets.map(entity => ({
-              address: Config.EnvioAddresses.getAddress(entity),
-              contract: entity.contract_name
-            }));
-            entityObj["sets"] = simplifiedSets;
-          }
-          change["addresses"] = entityObj;
-          return;
-        }
-        let entityObj$1 = {};
+        let entityObj = {};
         if (sets.length !== 0) {
-          entityObj$1["sets"] = sets;
+          entityObj["sets"] = sets;
         }
         if (deleted.length !== 0) {
-          entityObj$1["deleted"] = deleted;
+          entityObj["deleted"] = deleted;
         }
-        change[Utils.$$String.capitalize(entityName)] = entityObj$1;
+        change[Utils.$$String.capitalize(param[0])] = entityObj;
       });
     }
     state.processChanges.push(change);
   }
 }
 
-function makeInitialState(config, processConfigChains, indexingAddressesByChain) {
+function makeInitialState(config, processConfigChains, addressRowsByChain, contractMapping) {
   let chainKeys = Object.keys(processConfigChains);
   let chains = chainKeys.map(chainIdStr => {
     let chain = ChainId.normalizeOrThrow(chainIdStr);
@@ -192,7 +176,7 @@ function makeInitialState(config, processConfigChains, indexingAddressesByChain)
       Stdlib_JsError.throwWithMessage(`Chain ` + chainIdStr + ` is not configured in config.yaml`);
     }
     let processChainConfig = processConfigChains[chainIdStr];
-    let indexingAddresses = Stdlib_Option.getOr(indexingAddressesByChain[chainIdStr], []);
+    let addressRows = Stdlib_Option.getOr(addressRowsByChain[chainIdStr], AddressRows.emptySeedRows());
     return {
       id: chain,
       startBlock: processChainConfig.startBlock,
@@ -202,17 +186,18 @@ function makeInitialState(config, processConfigChains, indexingAddressesByChain)
       numEventsProcessed: 0,
       firstEventBlockNumber: undefined,
       timestampCaughtUpToHeadOrEndblock: undefined,
-      indexingAddresses: indexingAddresses,
+      addressRows: addressRows,
       sourceBlockNumber: Stdlib_Option.getOr(processChainConfig.endBlock, 0)
     };
   });
   return {
     cleanRun: true,
+    contractMapping: contractMapping,
+    envioInfo: {},
     cache: {},
     chains: chains,
     checkpointId: InternalTable.Checkpoints.initialCheckpointId,
-    reorgCheckpoints: [],
-    envioInfo: Config.stripSensitiveData(Config.getPublicConfigJson())
+    reorgCheckpoints: []
   };
 }
 
@@ -399,7 +384,7 @@ function makeInMemoryStorage(state) {
   return {
     name: "test-inmemory",
     isInitialized: async () => true,
-    initialize: async (param, param$1, param$2, param$3) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
+    initialize: async (param, param$1, param$2, param$3, param$4) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
     resumeInitialState: async () => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
     loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
     ensureQueryIndexes: async (param, param$1) => {},
@@ -413,7 +398,7 @@ function makeInMemoryStorage(state) {
     getRollbackTargetCheckpoint: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
     getRollbackProgressDiff: async param => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
     getRollbackData: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
-    writeBatch: async (batch, param, param$1, param$2, param$3, param$4, updatedEntities, param$5, param$6) => handleWriteBatch(state, updatedEntities, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointEventsProcessed),
+    writeBatch: async (batch, param, param$1, config, param$2, param$3, updatedEntities, registeredAddresses, param$4, param$5) => handleWriteBatch(state, config, updatedEntities, registeredAddresses, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointEventsProcessed),
     close: async () => {}
   };
 }
@@ -446,36 +431,25 @@ function getRegistrations(config) {
 
 function createTestIndexer() {
   let config = Config.load();
-  let allEntities = config.allEntities;
+  let allEntities = config.userEntities;
   let entities = {};
   let entityConfigs = {};
   allEntities.forEach(entityConfig => {
     entities[entityConfig.name] = {};
     entityConfigs[entityConfig.name] = entityConfig;
   });
-  let envioAddressesDict = entities[Config.EnvioAddresses.name];
-  ChainMap.values(config.chainMap).forEach(chainConfig => {
-    chainConfig.contracts.forEach(contract => {
-      contract.addresses.forEach(address => {
-        let entity_id = Config.EnvioAddresses.makeId(chainConfig.id, address);
-        let entity_chain_id = chainConfig.id;
-        let entity_contract_name = contract.name;
-        let entity = {
-          id: entity_id,
-          chain_id: entity_chain_id,
-          registration_block: -1,
-          registration_log_index: -1,
-          contract_name: entity_contract_name
-        };
-        envioAddressesDict[entity_id] = entity;
-      });
-    });
-  });
+  let chainConfigs = ChainMap.values(config.chainMap);
+  let contractMapping = config.contractMapping;
+  let ecosystem = config.ecosystem.name;
+  let addresses = AddressRows.Table.make();
+  ChainState.seedConfigAddresses(addresses, chainConfigs, ecosystem, contractMapping);
   let state = {
     processInProgress: false,
     progressBlockByChain: {},
     entities: entities,
     entityConfigs: entityConfigs,
+    addresses: addresses,
+    contractMapping: contractMapping,
     processChanges: []
   };
   let storage = makeInMemoryStorage(state);
@@ -487,16 +461,13 @@ function createTestIndexer() {
   }
   let entityOpsDict = {};
   allEntities.forEach(entityConfig => {
-    if (entityConfig.name !== Config.EnvioAddresses.name) {
-      entityOpsDict[entityConfig.name] = {
-        get: makeEntityGet(state, entityConfig),
-        getAll: makeEntityGetAll(state, entityConfig),
-        getWhere: makeEntityGetWhere(state, entityConfig),
-        getOrThrow: makeEntityGetOrThrow(state, entityConfig),
-        set: makeEntitySet(state, entityConfig)
-      };
-      return;
-    }
+    entityOpsDict[entityConfig.name] = {
+      get: makeEntityGet(state, entityConfig),
+      getAll: makeEntityGetAll(state, entityConfig),
+      getWhere: makeEntityGetWhere(state, entityConfig),
+      getOrThrow: makeEntityGetOrThrow(state, entityConfig),
+      set: makeEntitySet(state, entityConfig)
+    };
   });
   let chainIds = [];
   let chains = Object.create(null);
@@ -534,11 +505,14 @@ function createTestIndexer() {
           if (state.processInProgress) {
             Stdlib_JsError.throwWithMessage(`Cannot access ` + contract.name + `.addresses while indexer.process() is running. ` + "Wait for process() to complete before reading contract addresses.");
           }
-          return Stdlib_Array.filterMap(Stdlib_Option.getOr(getIndexingAddressesByChain(state)[ChainId.toString(chainConfig.id)], []), ia => {
-            if (ia.contractName === contract.name) {
-              return Primitive_option.some(ia.address);
+          let contractId = ContractMapping.idOfOrThrow(state.contractMapping, contract.name, undefined);
+          return renderRows(AddressRows.Table.rows(state.addresses).filter(row => {
+            if (row.chainId === chainConfig.id) {
+              return row.contractId === contractId;
+            } else {
+              return false;
             }
-          });
+          }), config);
         }
       });
       Object.defineProperty(chainObj, contract.name, {
@@ -608,8 +582,7 @@ function createTestIndexer() {
       let chainIdStr = param[0];
       let chains = {};
       chains[chainIdStr] = processChainConfig;
-      let indexingAddressesByChain = getIndexingAddressesByChain(state);
-      let initialState = makeInitialState(config, chains, indexingAddressesByChain);
+      let initialState = makeInitialState(config, chains, AddressRows.Table.groupByChain(state.addresses), state.contractMapping);
       let exitAfterFirstEventBlock = Stdlib_Option.isNone(processChainConfig.endBlock);
       let resolvedChainDict = {};
       resolvedChainDict["startBlock"] = processChainConfig.startBlock;
@@ -696,8 +669,8 @@ function createTestIndexer() {
 }
 
 export {
-  toIndexingAddress,
-  getIndexingAddressesByChain,
+  addressRowsByChain,
+  renderRows,
   rowKey,
   readChainId,
   handleLoad,

package/src/Utils.res

@@ -199,6 +199,13 @@ module Dict = {
     }
   `)
 
+  let clearInPlace: dict<'a> => unit = %raw(`(dict) => {
+      for (const key in dict) {
+        delete dict[key];
+      }
+    }
+  `)
+
   let unsafeDeleteUndefinedFieldsInPlace: 'a => unit = %raw(`(dict) => {
       for (var key in dict) {
         if (dict[key] === undefined) {

package/src/Utils.res.mjs

@@ -149,6 +149,12 @@ let deleteInPlace = ((dict, key) => {
       delete dict[key];
     });
 
+let clearInPlace = ((dict) => {
+      for (const key in dict) {
+        delete dict[key];
+      }
+    });
+
 let unsafeDeleteUndefinedFieldsInPlace = ((dict) => {
       for (var key in dict) {
         if (dict[key] === undefined) {
@@ -175,6 +181,7 @@ let Dict = {
   size: size,
   isEmpty: isEmpty,
   deleteInPlace: deleteInPlace,
+  clearInPlace: clearInPlace,
   unsafeDeleteUndefinedFieldsInPlace: unsafeDeleteUndefinedFieldsInPlace,
   updateImmutable: updateImmutable,
   shallowCopy: shallowCopy
@@ -249,7 +256,7 @@ function mergeSorted(f, xs, ys) {
   return result;
 }
 
-let clearInPlace = ((arr) => {
+let clearInPlace$1 = ((arr) => {
     arr.length = 0
   });
 
@@ -387,7 +394,7 @@ let $$Array$1 = {
   unzip: Stdlib_Array.unzip,
   immutableEmpty: immutableEmpty,
   mergeSorted: mergeSorted,
-  clearInPlace: clearInPlace,
+  clearInPlace: clearInPlace$1,
   setIndexImmutable: setIndexImmutable,
   transposeResults: transposeResults,
   includes: includes,