envio 3.7.0 → 3.9.0

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)
-        },
-      )
-    )
-  )
-}
-
-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,
+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)
 }
 
-// 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,23 +184,37 @@ 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<
   Internal.entity,
 > => {
-  // Loads for non-entity tables (e.g. effect caches `envio_effect_<name>`) reach
-  // here too. Nothing persists those, so there's nothing to return — an empty
-  // result makes the effect recompute instead of crashing on a missing config.
+  // Effect caches (`envio_effect_<name>`) are loaded through the same call, and
+  // they have no entity config — they're served from the cache `writeBatch`
+  // filled, so a resumed indexer reuses cached outputs instead of recomputing
+  // them the way Postgres would.
   switch state.entityConfigs->Dict.get(tableName) {
-  | None => []
+  | None =>
+    switch state.effectCache->Dict.get(tableName) {
+    | None => []
+    | Some(cacheDict) =>
+      cacheDict
+      ->Dict.valuesToArray
+      ->Array.filter(item =>
+        filter->EntityFilter.matches(
+          ~entity=item->(Utils.magic: Internal.effectCacheItem => dict<EntityFilter.FieldValue.t>),
+        )
+      )
+      ->(Utils.magic: array<Internal.effectCacheItem> => array<Internal.entity>)
+    }
   | Some(entityConfig) =>
     let entityDict = state.entities->Dict.get(entityConfig.name)->Option.getOr(Dict.make())
     let matched =
@@ -292,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)) =>
@@ -308,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>>,
 ) => {
@@ -316,10 +297,24 @@ 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
+  // the same line, keyed on the diff's checkpoint id.
+  let diffCheckpointId = rollback->Option.map(({diffCheckpointId}) => diffCheckpointId)
+  let isDiff = (change: Change.t<Internal.entity>) =>
+    switch diffCheckpointId {
+    | Some(diffCheckpointId) => change->Change.getCheckpointId === diffCheckpointId
+    | None => false
+    }
+
   updatedEntities->Array.forEach(({entityConfig, scope, changes}: Persistence.updatedEntity) => {
     let entityDict = state->getEntityDict(~name=entityConfig.name)
     let historyRows = state->getHistory(~name=entityConfig.name)
@@ -327,9 +322,17 @@ let writeBatch = (
     // onto the stored entity the same way the Postgres write path does.
     let chainIdField = entityConfig.table->Table.getChainIdField
 
+    let idsWithDiff = Utils.Set.make()
+    changes->Array.forEach(change =>
+      if isDiff(change) {
+        idsWithDiff->Utils.Set.add(change->Change.getEntityId->EntityId.toKey)->ignore
+      }
+    )
+
     changes->Array.forEach(change => {
       let entityId = change->Change.getEntityId
-      if shouldSaveHistory {
+      let shouldSaveChangeHistory = shouldSaveHistory && !isDiff(change)
+      if shouldSaveHistory && !(idsWithDiff->Utils.Set.has(entityId->EntityId.toKey)) {
         state->backfillHistory(~entityConfig, ~scope, ~entityId, ~rows=historyRows)
       }
       switch change {
@@ -340,7 +343,7 @@ let writeBatch = (
         | _ => entity
         }
         entityDict->Dict.set(rowKey(~scope, ~entityId), storedEntity)
-        if shouldSaveHistory {
+        if shouldSaveChangeHistory {
           historyRows
           ->Array.push({
             entityId,
@@ -353,7 +356,7 @@ let writeBatch = (
         }
       | Delete({checkpointId}) =>
         entityDict->Utils.Dict.deleteInPlace(rowKey(~scope, ~entityId))
-        if shouldSaveHistory {
+        if shouldSaveChangeHistory {
           historyRows
           ->Array.push({
             entityId,
@@ -471,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->(Utils.magic: Internal.entity => unknown))->ignore
+    | Some({action: SET, entity: Some(entity)}) => restored->Array.push(entity)->ignore
     | Some({action: SET, entity: None}) => ()
     }
   })
@@ -521,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,
@@ -543,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)
@@ -562,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
   },
@@ -648,6 +651,7 @@ let toStorage = (state: t, ~config: Config.t): Persistence.storage => {
     ~allEntities as _,
     ~updatedEffectsCache,
     ~updatedEntities,
+    ~registeredAddresses,
     ~chainMetaData,
     ~onWrite as _,
   ) =>
@@ -657,6 +661,7 @@ let toStorage = (state: t, ~config: Config.t): Persistence.storage => {
       ~isInReorgThreshold,
       ~config,
       ~updatedEntities,
+      ~registeredAddresses,
       ~updatedEffectsCache,
       ~chainMetaData,
     ),

package/src/MemoryStorage.res.mjs

@@ -6,6 +6,8 @@ import * as Config from "./Config.res.mjs";
 import * as ChainId from "./ChainId.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 AddressRows from "./AddressRows.res.mjs";
 import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -26,6 +28,7 @@ function make() {
     cache: {},
     effectCache: {},
     envioInfo: undefined,
+    addresses: AddressRows.Table.make(),
     isInitialized: false
   };
 }
@@ -76,58 +79,17 @@ function registerEntities(state, entities) {
   });
 }
 
-function seedIndexingAddresses(state, chainConfigs) {
-  let dict = getEntityDict(state, Config.EnvioAddresses.name);
-  chainConfigs.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
-        };
-        dict[entity_id] = entity;
-      });
-    });
-  });
+function seedConfigAddresses(state, chainConfigs, contractMapping, ecosystem) {
+  AddressRows.Table.clear(state.addresses);
+  ChainState.seedConfigAddresses(state.addresses, chainConfigs, ecosystem, contractMapping);
 }
 
-function toIndexingAddress(dc) {
-  return {
-    address: Config.EnvioAddresses.getAddress(dc),
-    contractName: dc.contract_name,
-    registrationBlock: dc.registration_block
-  };
-}
-
-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 addressRowsByChain(state) {
+  return AddressRows.Table.groupByChain(state.addresses);
 }
 
 function toInitialChainStates(state) {
-  let addressesByChain = getIndexingAddressesByChain(state);
+  let addressesByChain = AddressRows.Table.groupByChain(state.addresses);
   return Object.values(state.chains).map(chain => ({
     id: chain.id,
     startBlock: chain.startBlock,
@@ -137,7 +99,7 @@ function toInitialChainStates(state) {
     numEventsProcessed: chain.numEventsProcessed,
     firstEventBlockNumber: chain.firstEventBlockNumber,
     timestampCaughtUpToHeadOrEndblock: chain.timestampCaughtUpToHeadOrEndblock,
-    indexingAddresses: Stdlib_Option.getOr(addressesByChain[ChainId.toString(chain.id)], []),
+    addressRows: Stdlib_Option.getOr(addressesByChain[ChainId.toString(chain.id)], AddressRows.emptySeedRows()),
     sourceBlockNumber: chain.sourceBlockNumber
   }));
 }
@@ -174,33 +136,39 @@ function reorgCheckpoints(state) {
   });
 }
 
-function toInitialState(state, cleanRun) {
+function toInitialState(state, cleanRun, contractMapping) {
   return {
     cleanRun: cleanRun,
+    contractMapping: contractMapping,
+    envioInfo: state.envioInfo,
     cache: state.cache,
     chains: toInitialChainStates(state),
     checkpointId: committedCheckpointId(state),
-    reorgCheckpoints: reorgCheckpoints(state),
-    envioInfo: state.envioInfo
+    reorgCheckpoints: reorgCheckpoints(state)
   };
 }
 
 function handleLoad(state, tableName, filter) {
   let entityConfig = state.entityConfigs[tableName];
-  if (entityConfig === undefined) {
-    return [];
+  if (entityConfig !== undefined) {
+    let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
+    let matched = Object.values(entityDict).filter(entity => EntityFilter.matches(filter, entity));
+    let field = Table.getChainIdField(entityConfig.table);
+    if (field !== undefined) {
+      return matched.map(entity => {
+        let copy = Utils.Dict.shallowCopy(entity);
+        Utils.Dict.deleteInPlace(copy, field.fieldName);
+        return copy;
+      });
+    } else {
+      return matched;
+    }
   }
-  let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
-  let matched = Object.values(entityDict).filter(entity => EntityFilter.matches(filter, entity));
-  let field = Table.getChainIdField(entityConfig.table);
-  if (field !== undefined) {
-    return matched.map(entity => {
-      let copy = Utils.Dict.shallowCopy(entity);
-      Utils.Dict.deleteInPlace(copy, field.fieldName);
-      return copy;
-    });
+  let cacheDict = state.effectCache[tableName];
+  if (cacheDict !== undefined) {
+    return Object.values(cacheDict).filter(item => EntityFilter.matches(filter, item));
   } else {
-    return matched;
+    return [];
   }
 }
 
@@ -222,27 +190,46 @@ function backfillHistory(state, entityConfig, scope, entityId, rows) {
   }
 }
 
-function applyRollback(state, targetCheckpointId) {
+function applyRollback(state, targetCheckpointId, rolledBackAddresses) {
   state.checkpoints = state.checkpoints.filter(cp => cp.id <= targetCheckpointId);
+  rolledBackAddresses.forEach(key => AddressRows.Table.$$delete(state.addresses, key));
   Object.entries(state.history).forEach(param => {
     state.history[param[0]] = param[1].filter(row => row.checkpointId <= targetCheckpointId);
   });
 }
 
-function writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedEntities, updatedEffectsCache, chainMetaData) {
+function writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedEntities, registeredAddresses, updatedEffectsCache, chainMetaData) {
   let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
   if (rollback !== undefined) {
-    applyRollback(state, rollback.targetCheckpointId);
+    applyRollback(state, rollback.targetCheckpointId, rollback.rolledBackAddresses);
   }
+  registeredAddresses.forEach(param => AddressRows.Table.insert(state.addresses, param.row));
+  let diffCheckpointId = Stdlib_Option.map(rollback, param => param.diffCheckpointId);
+  let isDiff = change => {
+    if (diffCheckpointId !== undefined) {
+      return change.checkpointId === diffCheckpointId;
+    } else {
+      return false;
+    }
+  };
   updatedEntities.forEach(param => {
+    let changes = param.changes;
     let scope = param.scope;
     let entityConfig = param.entityConfig;
     let entityDict = getEntityDict(state, entityConfig.name);
     let historyRows = getHistory(state, entityConfig.name);
     let chainIdField = Table.getChainIdField(entityConfig.table);
-    param.changes.forEach(change => {
+    let idsWithDiff = new Set();
+    changes.forEach(change => {
+      if (isDiff(change)) {
+        idsWithDiff.add(EntityId.toKey(change.entityId));
+        return;
+      }
+    });
+    changes.forEach(change => {
       let entityId = change.entityId;
-      if (shouldSaveHistory) {
+      let shouldSaveChangeHistory = shouldSaveHistory && !isDiff(change);
+      if (shouldSaveHistory && !idsWithDiff.has(EntityId.toKey(entityId))) {
         backfillHistory(state, entityConfig, scope, entityId, historyRows);
       }
       if (change.type === "SET") {
@@ -250,7 +237,7 @@ function writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedE
         let match = Internal.chainScopeChainId(scope);
         let storedEntity = chainIdField !== undefined && match !== undefined ? Internal.stampChainId(entity, chainIdField.fieldName, Primitive_option.valFromOption(match)) : entity;
         entityDict[rowKey(scope, entityId)] = storedEntity;
-        if (shouldSaveHistory) {
+        if (shouldSaveChangeHistory) {
           historyRows.push({
             entityId: entityId,
             scope: scope,
@@ -264,7 +251,7 @@ function writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedE
         }
       }
       Utils.Dict.deleteInPlace(entityDict, rowKey(scope, entityId));
-      if (shouldSaveHistory) {
+      if (shouldSaveChangeHistory) {
         historyRows.push({
           entityId: entityId,
           scope: scope,
@@ -409,12 +396,12 @@ function toStorage(state, config) {
   return {
     name: "memory",
     isInitialized: async () => state.isInitialized,
-    initialize: async (chainConfigsOpt, entitiesOpt, $staropt$star, envioInfo) => {
+    initialize: async (chainConfigsOpt, entitiesOpt, $staropt$star, contractMapping, envioInfo) => {
       let chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
       let entities = entitiesOpt !== undefined ? entitiesOpt : [];
       $staropt$star !== undefined;
       registerEntities(state, entities);
-      seedIndexingAddresses(state, chainConfigs);
+      seedConfigAddresses(state, chainConfigs, contractMapping, config.ecosystem.name);
       chainConfigs.forEach(chainConfig => {
         state.chains[ChainId.toString(chainConfig.id)] = {
           id: chainConfig.id,
@@ -431,9 +418,9 @@ function toStorage(state, config) {
       });
       state.envioInfo = envioInfo;
       state.isInitialized = true;
-      return toInitialState(state, true);
+      return toInitialState(state, true, contractMapping);
     },
-    resumeInitialState: async () => toInitialState(state, false),
+    resumeInitialState: async () => toInitialState(state, false, config.contractMapping),
     loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
     ensureQueryIndexes: async (param, param$1) => {},
     ensureSchemaIndexes: async param => {},
@@ -448,15 +435,14 @@ function toStorage(state, config) {
     },
     dumpEffectCache: async () => {},
     reset: async () => {
-      let clear = dict => {
-        Object.keys(dict).forEach(key => Utils.Dict.deleteInPlace(dict, key));
-      };
+      let clear = Utils.Dict.clearInPlace;
       clear(state.entities);
       clear(state.history);
       clear(state.chains);
       clear(state.effectCache);
       clear(state.cache);
       state.checkpoints = [];
+      AddressRows.Table.clear(state.addresses);
       state.envioInfo = undefined;
       state.isInitialized = false;
     },
@@ -517,7 +503,7 @@ function toStorage(state, config) {
     }),
     getRollbackProgressDiff: async rollbackTargetCheckpointId => getRollbackProgressDiff(state, rollbackTargetCheckpointId),
     getRollbackData: async (entityConfig, rollbackTargetCheckpointId) => getRollbackData(state, entityConfig, rollbackTargetCheckpointId),
-    writeBatch: async (batch, rollback, isInReorgThreshold, param, param$1, updatedEffectsCache, updatedEntities, chainMetaData, param$2) => writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedEntities, updatedEffectsCache, chainMetaData),
+    writeBatch: async (batch, rollback, isInReorgThreshold, param, param$1, updatedEffectsCache, updatedEntities, registeredAddresses, chainMetaData, param$2) => writeBatch(state, batch, rollback, isInReorgThreshold, config, updatedEntities, registeredAddresses, updatedEffectsCache, chainMetaData),
     close: async () => {}
   };
 }
@@ -579,9 +565,8 @@ export {
   getEntityDict,
   getHistory,
   registerEntities,
-  seedIndexingAddresses,
-  toIndexingAddress,
-  getIndexingAddressesByChain,
+  seedConfigAddresses,
+  addressRowsByChain,
   toInitialChainStates,
   committedCheckpointId,
   reorgCheckpoints,