envio 3.8.0 → 3.9.0

package/src/InMemoryStore.res.mjs

@@ -2,7 +2,6 @@
 
 import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
-import * as Config from "./Config.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as EffectState from "./EffectState.res.mjs";
@@ -107,8 +106,8 @@ function dropCommittedEffects(inMemTable, committedCheckpointId, keepLoadedFromD
   inMemTable.changesCount = inMemTable.changesCount - keysToDelete.length;
 }
 
-async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDiffCheckpointId, progressBlockNumberByChainId) {
-  IndexerState.beginRollbackDiff(state, rollbackTargetCheckpointId, rollbackDiffCheckpointId, progressBlockNumberByChainId);
+async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDiffCheckpointId, progressBlockNumberByChainId, rolledBackAddresses) {
+  IndexerState.beginRollbackDiff(state, rollbackTargetCheckpointId, rollbackDiffCheckpointId, progressBlockNumberByChainId, rolledBackAddresses);
   let persistence = IndexerState.persistence(state);
   let committedCheckpointId = IndexerState.committedCheckpointId(state);
   let deletedEntities = {};
@@ -142,8 +141,6 @@ async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDi
 }
 
 function setBatchDcs(state, batch) {
-  let inMemTable = getInMemTable(state, Config.EnvioAddresses.entityConfig, "crossChain");
-  let committedCheckpointId = IndexerState.committedCheckpointId(state);
   Utils.Dict.forEach(batch.progressedChainsById, progressedChain => {
     let chainId = progressedChain.fetchState.chainId;
     let chainState = IndexerState.getChainState(state, chainId);
@@ -158,24 +155,15 @@ function setBatchDcs(state, batch) {
         checkpointBlockNumbers.push(batch.checkpointBlockNumbers[idx]);
       }
     }
-    ChainState.drainAddressesForWrite(chainState, progressedChain.progressBlockNumber, checkpointBlockNumbers).forEach(dc => {
-      let entity_id = Config.EnvioAddresses.makeId(chainId, dc.address);
-      let entity_registration_block = dc.registrationBlock;
-      let entity_contract_name = dc.contractName;
-      let entity = {
-        id: entity_id,
-        chain_id: chainId,
-        registration_block: entity_registration_block,
-        registration_log_index: -1,
-        contract_name: entity_contract_name
-      };
-      InMemoryTable.Entity.set(inMemTable, committedCheckpointId, {
-        type: "SET",
-        entityId: entity_id,
-        entity: entity,
-        checkpointId: checkpointIds[dc.checkpointIdx]
-      });
-    });
+    batch.registeredAddresses.push(...ChainState.drainAddressesForWrite(chainState, progressedChain.progressBlockNumber, checkpointBlockNumbers).map(dc => ({
+      row: {
+        chainId: chainId,
+        address: dc.address,
+        contractId: dc.contractId,
+        registrationBlock: dc.registrationBlock
+      },
+      checkpointId: checkpointIds[dc.checkpointIdx]
+    })));
   });
 }
 

package/src/IndexerState.res

@@ -267,6 +267,7 @@ let makeFromDbState = (
         ~isInReorgThreshold,
         ~isRealtime,
         ~config,
+        ~contractMapping=initialState.contractMapping,
         ~registrationsByChainId,
         ~reducedPollingInterval?,
       ),
@@ -757,6 +758,7 @@ let drainBatchRun = (state: t): Batch.t => {
   let checkpointBlockNumbers = []
   let checkpointBlockHashes = []
   let checkpointEventsProcessed = []
+  let registeredAddresses = []
   all->Array.forEach(batch => {
     // Once one batch lands in rest, all later ones follow it, preserving order.
     if rest->Utils.Array.isEmpty && batch.isInReorgThreshold == isInReorgThreshold {
@@ -770,6 +772,7 @@ let drainBatchRun = (state: t): Batch.t => {
       checkpointBlockNumbers->Array.pushMany(batch.checkpointBlockNumbers)
       checkpointBlockHashes->Array.pushMany(batch.checkpointBlockHashes)
       checkpointEventsProcessed->Array.pushMany(batch.checkpointEventsProcessed)
+      registeredAddresses->Array.pushMany(batch.registeredAddresses)
     } else {
       rest->Array.push(batch)
     }
@@ -786,6 +789,7 @@ let drainBatchRun = (state: t): Batch.t => {
     checkpointBlockNumbers,
     checkpointBlockHashes,
     checkpointEventsProcessed,
+    registeredAddresses,
   }
 }
 
@@ -797,7 +801,13 @@ let takeRollback = (state: t): option<Persistence.rollback> => {
 }
 
 // Advance the committed (durably persisted) frontier after a successful write.
-let markCommitted = (state: t, ~upToCheckpointId) => state.committedCheckpointId = upToCheckpointId
+// Written rows leave the buffer only once the transaction that holds them has
+// committed. A failed write keeps them, and re-inserting a row the database
+// already has is a no-op. Rows staged while the write was in flight belong to
+// later checkpoints — ids only ever grow — so this can't drop one unwritten.
+let markCommitted = (state: t, ~upToCheckpointId) => {
+  state.committedCheckpointId = upToCheckpointId
+}
 
 // Reset the in-memory tables and arm the rollback diff that the next write commits.
 let beginRollbackDiff = (
@@ -805,15 +815,25 @@ let beginRollbackDiff = (
   ~targetCheckpointId,
   ~diffCheckpointId,
   ~progressBlockNumberByChainId,
+  ~rolledBackAddresses,
 ) => {
   let perChainEntities = state.allEntities->EntityTables.perChain
   state.entities = EntityTables.make(state.allEntities->EntityTables.crossChain)
   state->chainStates->Utils.Dict.forEach(cs => cs->ChainState.resetEntities(~perChainEntities))
   state.effectState->EffectState.resetForRollback
+  // The address store reports only what each rollback killed, and never
+  // re-reports a registration it already tombstoned. A rollback that lands
+  // before the previous one has been written must therefore carry the earlier
+  // keys too, or their rows outlive every rollback that could delete them.
+  let rolledBackAddresses = switch state.rollback {
+  | Some({rolledBackAddresses: pending}) => pending->Array.concat(rolledBackAddresses)
+  | None => rolledBackAddresses
+  }
   state.rollback = Some({
     targetCheckpointId,
     diffCheckpointId,
     progressBlockNumberByChainId,
+    rolledBackAddresses,
   })
 }
 

package/src/IndexerState.res.mjs

@@ -100,7 +100,7 @@ function makeFromDbState(config, persistence, initialState, registrationsByChain
   initialState.chains.forEach(resumedChainState => {
     let chainId = Config.getChain(config, resumedChainState.id);
     let chainConfig = ChainMap.get(config.chainMap, chainId);
-    chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrationsByChainId, reducedPollingInterval);
+    chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, initialState.contractMapping, registrationsByChainId, reducedPollingInterval);
   });
   let state = make(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSize, initialState.checkpointId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError, onExit);
   CrossChainState.markCaughtUpOnResume(state.crossChainState);
@@ -625,6 +625,7 @@ function drainBatchRun(state) {
   let checkpointBlockNumbers = [];
   let checkpointBlockHashes = [];
   let checkpointEventsProcessed = [];
+  let registeredAddresses = [];
   all.forEach(batch => {
     if (Utils.$$Array.isEmpty(rest) && batch.isInReorgThreshold === isInReorgThreshold) {
       Utils.Dict.forEachWithKey(batch.progressedChainsById, (chainAfterBatch, key) => {
@@ -637,6 +638,7 @@ function drainBatchRun(state) {
       checkpointBlockNumbers.push(...batch.checkpointBlockNumbers);
       checkpointBlockHashes.push(...batch.checkpointBlockHashes);
       checkpointEventsProcessed.push(...batch.checkpointEventsProcessed);
+      registeredAddresses.push(...batch.registeredAddresses);
     } else {
       rest.push(batch);
     }
@@ -651,7 +653,8 @@ function drainBatchRun(state) {
     checkpointChainIds: checkpointChainIds,
     checkpointBlockNumbers: checkpointBlockNumbers,
     checkpointBlockHashes: checkpointBlockHashes,
-    checkpointEventsProcessed: checkpointEventsProcessed
+    checkpointEventsProcessed: checkpointEventsProcessed,
+    registeredAddresses: registeredAddresses
   };
 }
 
@@ -665,14 +668,17 @@ function markCommitted(state, upToCheckpointId) {
   state.committedCheckpointId = upToCheckpointId;
 }
 
-function beginRollbackDiff(state, targetCheckpointId, diffCheckpointId, progressBlockNumberByChainId) {
+function beginRollbackDiff(state, targetCheckpointId, diffCheckpointId, progressBlockNumberByChainId, rolledBackAddresses) {
   let perChainEntities = EntityTables.perChain(state.allEntities);
   state.entities = EntityTables.make(EntityTables.crossChain(state.allEntities));
   Utils.Dict.forEach(CrossChainState.chainStates(state.crossChainState), cs => ChainState.resetEntities(cs, perChainEntities));
   EffectState.resetForRollback(state.effectState);
+  let match = state.rollback;
+  let rolledBackAddresses$1 = match !== undefined ? match.rolledBackAddresses.concat(rolledBackAddresses) : rolledBackAddresses;
   state.rollback = {
     targetCheckpointId: targetCheckpointId,
     diffCheckpointId: diffCheckpointId,
+    rolledBackAddresses: rolledBackAddresses$1,
     progressBlockNumberByChainId: progressBlockNumberByChainId
   };
 }

package/src/IndexerState.resi

@@ -143,6 +143,7 @@ let beginRollbackDiff: (
   ~targetCheckpointId: Internal.checkpointId,
   ~diffCheckpointId: Internal.checkpointId,
   ~progressBlockNumberByChainId: dict<int>,
+  ~rolledBackAddresses: array<AddressRows.key>,
 ) => unit
 let recordWriteFailure: (t, exn) => unit
 let beginWriteFiber: (t, promise<unit>) => unit

package/src/Main.res

@@ -88,17 +88,22 @@ let getGlobalPersistence = () =>
 let setGlobalPersistence = (persistence: Persistence.t) =>
   EnvioGlobal.value.persistence = Some(persistence->(Utils.magic: Persistence.t => unknown))
 
-let getInitialChainState = (~chainId: ChainId.t): option<Persistence.initialChainState> => {
+let getInitialState = (): option<Persistence.initialState> => {
   switch getGlobalPersistence() {
   | Some(persistence) =>
     switch persistence.storageStatus {
-    | Ready(initialState) => initialState.chains->Array.find(c => c.id === chainId)
+    | Ready(initialState) => Some(initialState)
     | _ => None
     }
   | None => None
   }
 }
 
+let getInitialChainState = (~chainId: ChainId.t): option<Persistence.initialChainState> =>
+  getInitialState()->Option.flatMap(initialState =>
+    initialState.chains->Array.find(c => c.id === chainId)
+  )
+
 // Importing `generated` must not trigger `Config.load()`,
 // so the exported indexer calls this lazily on first `indexer.chains` access.
 let buildChainsObject = (~config: Config.t) => {
@@ -184,20 +189,23 @@ let buildChainsObject = (~config: Config.t) => {
                 chainState->ChainState.contractAddresses(~contractName=contract.name)
               }
             // Before the global state is available (eg during handler
-            // module load after resume), combine static addresses from config
-            // with dynamic contracts persisted in the database.
+            // module load after resume), read them off what persistence
+            // restored — which already holds the config's own addresses
+            // alongside the dynamically registered ones.
             | None =>
-              switch getInitialChainState(~chainId=chainConfig.id) {
-              | Some(chainState) =>
-                let addresses = contract.addresses->Array.copy
-                chainState.indexingAddresses->Array.forEach(
-                  dc => {
-                    if dc.contractName === contract.name {
-                      addresses->Array.push(dc.address)->ignore
-                    }
-                  },
-                )
-                addresses
+              switch getInitialState() {
+              | Some(initialState) =>
+                switch initialState.chains->Array.find(c => c.id === chainConfig.id) {
+                | Some(chainState) =>
+                  chainState.addressRows->AddressRows.renderOfContract(
+                    ~ecosystem=(config.ecosystem.name :> string),
+                    ~shouldChecksum=!config.lowercaseAddresses,
+                    ~contractId=initialState.contractMapping->ContractMapping.idOfOrThrow(
+                      contract.name,
+                    ),
+                  )
+                | None => contract.addresses
+                }
               | None => contract.addresses
               }
             }
@@ -577,6 +585,7 @@ let migrate = async (~reset) => {
   await persistence->Persistence.init(
     ~reset,
     ~chainConfigs=config.chainMap->ChainMap.values,
+    ~contractMapping=config.contractMapping,
     ~envioInfo=getEnvioInfo(),
     ~resetCommand="envio local db-migrate setup",
     ~runCommand=None,
@@ -628,6 +637,7 @@ let start = async (
   await persistence->Persistence.init(
     ~reset,
     ~chainConfigs=config.chainMap->ChainMap.values,
+    ~contractMapping=config.contractMapping,
     ~envioInfo=getEnvioInfo(),
     ~resetCommand=isDevelopmentMode ? "envio dev -r" : "envio start -r",
     ~runCommand=Some(isDevelopmentMode ? "envio dev" : "envio start"),

package/src/Main.res.mjs

@@ -13,6 +13,7 @@ import * as Process from "process";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as PgStorage from "./PgStorage.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
+import * as AddressRows from "./AddressRows.res.mjs";
 import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 import * as IndexerLoop from "./IndexerLoop.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
@@ -24,6 +25,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Helpers from "yargs/helpers";
 import * as RollbackCommit from "./RollbackCommit.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as ContractMapping from "./ContractMapping.res.mjs";
 import * as HandlerRegister from "./HandlerRegister.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";
@@ -94,7 +96,7 @@ function setGlobalPersistence(persistence) {
   EnvioGlobal.value.persistence = Primitive_option.some(persistence);
 }
 
-function getInitialChainState(chainId) {
+function getInitialState() {
   let persistence = EnvioGlobal.value.persistence;
   if (persistence === undefined) {
     return;
@@ -103,10 +105,14 @@ function getInitialChainState(chainId) {
   if (typeof initialState !== "object" || initialState.TAG === "Initializing") {
     return;
   } else {
-    return initialState._0.chains.find(c => c.id === chainId);
+    return initialState._0;
   }
 }
 
+function getInitialChainState(chainId) {
+  return Stdlib_Option.flatMap(getInitialState(), initialState => initialState.chains.find(c => c.id === chainId));
+}
+
 function buildChainsObject(config) {
   let chainIds = [];
   let chains = Object.create(null);
@@ -178,18 +184,16 @@ function buildChainsObject(config) {
             let chainState = IndexerState.getChainState(Primitive_option.valFromOption(state), chainConfig.id);
             return ChainState.contractAddresses(chainState, contract.name);
           }
-          let chainState$1 = getInitialChainState(chainConfig.id);
-          if (chainState$1 === undefined) {
+          let initialState = getInitialState();
+          if (initialState === undefined) {
+            return contract.addresses;
+          }
+          let chainState$1 = initialState.chains.find(c => c.id === chainConfig.id);
+          if (chainState$1 !== undefined) {
+            return AddressRows.renderOfContract(chainState$1.addressRows, config.ecosystem.name, !config.lowercaseAddresses, ContractMapping.idOfOrThrow(initialState.contractMapping, contract.name, undefined));
+          } else {
             return contract.addresses;
           }
-          let addresses = contract.addresses.slice();
-          chainState$1.indexingAddresses.forEach(dc => {
-            if (dc.contractName === contract.name) {
-              addresses.push(dc.address);
-              return;
-            }
-          });
-          return addresses;
         }
       });
       Object.defineProperty(chainObj, contract.name, {
@@ -463,7 +467,7 @@ function getEnvioInfo() {
 async function migrate(reset) {
   let config = Config.load();
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
-  await Persistence.init(persistence, ChainMap.values(config.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), "envio local db-migrate setup", undefined, reset);
+  await Persistence.init(persistence, ChainMap.values(config.chainMap), config.contractMapping, Config.stripSensitiveData(Config.getPublicConfigJson()), "envio local db-migrate setup", undefined, reset);
   return await persistence.storage.close();
 }
 
@@ -490,7 +494,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   let isDevelopmentMode = !isTest && config.isDev;
   let persistence$1 = persistence !== undefined ? persistence : PgStorage.makePersistenceFromConfig(config, undefined);
   EnvioGlobal.value.persistence = Primitive_option.some(persistence$1);
-  await Persistence.init(persistence$1, ChainMap.values(config.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", isDevelopmentMode ? "envio dev" : "envio start", reset);
+  await Persistence.init(persistence$1, ChainMap.values(config.chainMap), config.contractMapping, Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", isDevelopmentMode ? "envio dev" : "envio start", reset);
   let registrationsByChainId = await HandlerLoader.registerAllHandlers(config);
   let config$1;
   if (isTest) {
@@ -552,6 +556,7 @@ export {
   setIndexerState,
   getGlobalPersistence,
   setGlobalPersistence,
+  getInitialState,
   getInitialChainState,
   buildChainsObject,
   getGlobalIndexer,

package/src/MemoryStorage.res

@@ -49,6 +49,7 @@ type t = {
   cache: dict<Persistence.effectCacheRecord>,
   effectCache: dict<dict<Internal.effectCacheItem>>,
   mutable envioInfo: option<JSON.t>,
+  addresses: AddressRows.Table.t,
   mutable isInitialized: bool,
 }
 
@@ -61,6 +62,7 @@ let make = (): t => {
   cache: Dict.make(),
   effectCache: Dict.make(),
   envioInfo: None,
+  addresses: AddressRows.Table.make(),
   isInitialized: false,
 }
 
@@ -117,61 +119,23 @@ let registerEntities = (state: t, ~entities: array<Internal.entityConfig>) =>
 
 // Seeds the config's contract addresses, mirroring what PgStorage.initialize
 // writes into `envio_addresses`.
-let seedIndexingAddresses = (state: t, ~chainConfigs: array<Config.chain>) => {
-  let dict = state->getEntityDict(~name=InternalTable.EnvioAddresses.name)
-  chainConfigs->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,
-          }
-          dict->Dict.set(entity.id, entity->Config.EnvioAddresses.castToInternal)
-        },
-      )
-    )
-  )
+let seedConfigAddresses = (
+  state: t,
+  ~chainConfigs: array<Config.chain>,
+  ~contractMapping,
+  ~ecosystem,
+) => {
+  // Initialize starts from an empty schema — the Postgres DDL drops and
+  // recreates one — so a re-initialize must not stack a second copy of the
+  // config's addresses on what a previous one left behind.
+  state.addresses->AddressRows.Table.clear
+  state.addresses->ChainState.seedConfigAddresses(~chainConfigs, ~ecosystem, ~contractMapping)
 }
 
-external castToEnvioAddresses: Internal.entity => InternalTable.EnvioAddresses.t = "%identity"
-
-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: t): 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 addressRowsByChain = (state: t) => state.addresses->AddressRows.Table.groupByChain
 
 let toInitialChainStates = (state: t): array<Persistence.initialChainState> => {
-  let addressesByChain = state->getIndexingAddressesByChain
+  let addressesByChain = state->addressRowsByChain
   state.chains
   ->Dict.valuesToArray
   ->Array.map((chain): Persistence.initialChainState => {
@@ -183,9 +147,9 @@ let toInitialChainStates = (state: t): array<Persistence.initialChainState> => {
     numEventsProcessed: chain.numEventsProcessed,
     firstEventBlockNumber: chain.firstEventBlockNumber,
     timestampCaughtUpToHeadOrEndblock: chain.timestampCaughtUpToHeadOrEndblock,
-    indexingAddresses: addressesByChain
-    ->Dict.get(chain.id->ChainId.toString)
-    ->Option.getOr([]),
+    addressRows: addressesByChain
+    ->Utils.Dict.dangerouslyGetNonOption(chain.id->ChainId.toString)
+    ->Option.getOr(AddressRows.emptySeedRows()),
     sourceBlockNumber: chain.sourceBlockNumber,
   })
 }
@@ -220,13 +184,14 @@ let reorgCheckpoints = (state: t): array<Internal.reorgCheckpoint> =>
     }
   )
 
-let toInitialState = (state: t, ~cleanRun): Persistence.initialState => {
+let toInitialState = (state: t, ~cleanRun, ~contractMapping): Persistence.initialState => {
   cleanRun,
+  contractMapping,
+  envioInfo: state.envioInfo,
   cache: state.cache,
   chains: state->toInitialChainStates,
   checkpointId: state->committedCheckpointId,
   reorgCheckpoints: state->reorgCheckpoints,
-  envioInfo: state.envioInfo,
 }
 
 let handleLoad = (state: t, ~tableName: string, ~filter: EntityFilter.t): array<
@@ -305,8 +270,10 @@ let backfillHistory = (
   }
 }
 
-let applyRollback = (state: t, ~targetCheckpointId) => {
+let applyRollback = (state: t, ~targetCheckpointId, ~rolledBackAddresses) => {
   state.checkpoints = state.checkpoints->Array.filter(cp => cp.id <= targetCheckpointId)
+  // Addresses are removed by primary key, exactly like the Postgres delete.
+  rolledBackAddresses->Array.forEach(key => state.addresses->AddressRows.Table.delete(key))
   state.history
   ->Dict.toArray
   ->Array.forEach(((name, rows)) =>
@@ -321,6 +288,7 @@ let writeBatch = (
   ~isInReorgThreshold,
   ~config: Config.t,
   ~updatedEntities: array<Persistence.updatedEntity>,
+  ~registeredAddresses: array<AddressRows.staged>,
   ~updatedEffectsCache: array<Persistence.updatedEffectCache>,
   ~chainMetaData: option<dict<InternalTable.Chains.metaFields>>,
 ) => {
@@ -329,10 +297,13 @@ let writeBatch = (
   // Rollback first, exactly like the Postgres transaction: the batch being
   // written is the reprocessed one, so its rows must land on the reverted state.
   switch rollback {
-  | Some({targetCheckpointId}) => state->applyRollback(~targetCheckpointId)
+  | Some({targetCheckpointId, rolledBackAddresses}) =>
+    state->applyRollback(~targetCheckpointId, ~rolledBackAddresses)
   | None => ()
   }
 
+  registeredAddresses->Array.forEach(({row}) => state.addresses->AddressRows.Table.insert(row))
+
   // The rollback diff restates what the reverted state already is, so it is not
   // a change history should record — and an id it touches needs no backfill
   // either, because the diff already carries its reverted value. Postgres draws
@@ -503,8 +474,7 @@ let getRollbackData = (
       ->ignore
     | Some({action: DELETE, entityId, scope}) =>
       removals->Array.push({Persistence.entityId, scope})->ignore
-    | Some({action: SET, entity: Some(entity)}) =>
-      restored->Array.push(entity)->ignore
+    | Some({action: SET, entity: Some(entity)}) => restored->Array.push(entity)->ignore
     | Some({action: SET, entity: None}) => ()
     }
   })
@@ -553,9 +523,9 @@ let getRollbackProgressDiff = (state: t, ~rollbackTargetCheckpointId) => {
 let toStorage = (state: t, ~config: Config.t): Persistence.storage => {
   name: "memory",
   isInitialized: async () => state.isInitialized,
-  initialize: async (~chainConfigs=[], ~entities=[], ~enums as _=[], ~envioInfo) => {
+  initialize: async (~chainConfigs=[], ~entities=[], ~enums as _=[], ~contractMapping, ~envioInfo) => {
     state->registerEntities(~entities)
-    state->seedIndexingAddresses(~chainConfigs)
+    state->seedConfigAddresses(~chainConfigs, ~contractMapping, ~ecosystem=config.ecosystem.name)
     chainConfigs->Array.forEach(chainConfig =>
       state.chains->Dict.set(
         chainConfig.id->ChainId.toString,
@@ -575,9 +545,10 @@ let toStorage = (state: t, ~config: Config.t): Persistence.storage => {
     )
     state.envioInfo = Some(envioInfo)
     state.isInitialized = true
-    state->toInitialState(~cleanRun=true)
+    state->toInitialState(~cleanRun=true, ~contractMapping)
   },
-  resumeInitialState: async () => state->toInitialState(~cleanRun=false),
+  resumeInitialState: async () =>
+    state->toInitialState(~cleanRun=false, ~contractMapping=config.contractMapping),
   loadOrThrow: async (~filter, ~table: Table.table) =>
     state
     ->handleLoad(~tableName=table.tableName, ~filter)
@@ -594,14 +565,14 @@ let toStorage = (state: t, ~config: Config.t): Persistence.storage => {
     ),
   dumpEffectCache: async () => (),
   reset: async () => {
-    let clear = dict =>
-      dict->Dict.keysToArray->Array.forEach(key => dict->Utils.Dict.deleteInPlace(key))
+    let clear = Utils.Dict.clearInPlace
     state.entities->clear
     state.history->clear
     state.chains->clear
     state.effectCache->clear
     state.cache->clear
     state.checkpoints = []
+    state.addresses->AddressRows.Table.clear
     state.envioInfo = None
     state.isInitialized = false
   },
@@ -680,6 +651,7 @@ let toStorage = (state: t, ~config: Config.t): Persistence.storage => {
     ~allEntities as _,
     ~updatedEffectsCache,
     ~updatedEntities,
+    ~registeredAddresses,
     ~chainMetaData,
     ~onWrite as _,
   ) =>
@@ -689,6 +661,7 @@ let toStorage = (state: t, ~config: Config.t): Persistence.storage => {
       ~isInReorgThreshold,
       ~config,
       ~updatedEntities,
+      ~registeredAddresses,
       ~updatedEffectsCache,
       ~chainMetaData,
     ),