envio 3.7.0 → 3.9.0

package/src/InMemoryStore.res

@@ -130,11 +130,13 @@ let prepareRollbackDiff = async (
   ~rollbackTargetCheckpointId,
   ~rollbackDiffCheckpointId,
   ~progressBlockNumberByChainId,
+  ~rolledBackAddresses,
 ) => {
   state->IndexerState.beginRollbackDiff(
     ~targetCheckpointId=rollbackTargetCheckpointId,
     ~diffCheckpointId=rollbackDiffCheckpointId,
     ~progressBlockNumberByChainId,
+    ~rolledBackAddresses,
   )
   let persistence = state->IndexerState.persistence
   let committedCheckpointId = state->IndexerState.committedCheckpointId
@@ -148,7 +150,7 @@ let prepareRollbackDiff = async (
   let _ = await persistence.allEntities
   ->Array.filter(entityConfig => entityConfig.storage.postgres)
   ->Array.map(async entityConfig => {
-    let (removals, restoredEntitiesResult) = await persistence.storage.getRollbackData(
+    let (removals, restoredEntities) = await persistence.storage.getRollbackData(
       ~entityConfig,
       ~rollbackTargetCheckpointId,
     )
@@ -166,11 +168,6 @@ let prepareRollbackDiff = async (
       )
     })
 
-    let restoredEntities =
-      restoredEntitiesResult
-      ->S.parseOrThrow(entityConfig.table->Table.pgRowsSchema)
-      ->(Utils.magic: array<unknown> => array<Internal.entity>)
-
     restoredEntities->Array.forEach((entity: Internal.entity) => {
       let scope = entity->takeRowScope(~entityConfig)
       setEntities->Utils.Dict.push(entityConfig.name, entity.id)
@@ -199,12 +196,6 @@ let prepareRollbackDiff = async (
 // registered them: the store is where they already live, and it knows which
 // ones the database hasn't seen yet.
 let setBatchDcs = (state: IndexerState.t, ~batch: Batch.t) => {
-  let inMemTable = state->getInMemTable(
-    ~entityConfig=InternalTable.EnvioAddresses.entityConfig,
-    ~scope=CrossChain,
-  )
-  let committedCheckpointId = state->IndexerState.committedCheckpointId
-
   batch.progressedChainsById->Utils.Dict.forEach(progressedChain => {
     let chainId = progressedChain.fetchState.chainId
     let chainState = state->IndexerState.getChainState(~chainId)
@@ -224,31 +215,22 @@ let setBatchDcs = (state: IndexerState.t, ~batch: Batch.t) => {
         }
       }
 
-      chainState
-      ->ChainState.drainAddressesForWrite(
-        ~toBlockInclusive=progressedChain.progressBlockNumber,
-        ~checkpointBlockNumbers,
-      )
-      ->Array.forEach(dc => {
-        let entity: InternalTable.EnvioAddresses.t = {
-          id: InternalTable.EnvioAddresses.makeId(~chainId, ~address=dc.address),
-          chainId,
-          contractName: dc.contractName,
-          registrationBlock: dc.registrationBlock,
-          // Only ever written, never read back. Kept on the table so the column
-          // doesn't need a migration.
-          registrationLogIndex: -1,
-        }
-
-        inMemTable->InMemoryTable.Entity.set(
-          ~committedCheckpointId,
-          Set({
-            entityId: entity.id->EntityId.unsafeOfString,
-            checkpointId: checkpointIds->Array.getUnsafe(dc.checkpointIdx),
-            entity: entity->InternalTable.EnvioAddresses.castToInternal,
-          }),
+      batch.registeredAddresses->Array.pushMany(
+        chainState
+        ->ChainState.drainAddressesForWrite(
+          ~toBlockInclusive=progressedChain.progressBlockNumber,
+          ~checkpointBlockNumbers,
         )
-      })
+        ->Array.map((dc): AddressRows.staged => {
+          row: {
+            chainId,
+            address: dc.address,
+            contractId: dc.contractId,
+            registrationBlock: dc.registrationBlock,
+          },
+          checkpointId: checkpointIds->Array.getUnsafe(dc.checkpointIdx),
+        }),
+      )->ignore
     }
   })
 }

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";
@@ -12,7 +11,6 @@ import * as InMemoryTable from "./InMemoryTable.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 Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
 function getInMemTable(state, entityConfig, scope) {
   let tmp;
@@ -108,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 = {};
@@ -125,8 +123,7 @@ async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDi
         checkpointId: rollbackDiffCheckpointId
       });
     });
-    let restoredEntities = S$RescriptSchema.parseOrThrow(match[1], Table.pgRowsSchema(entityConfig.table));
-    restoredEntities.forEach(entity => {
+    match[1].forEach(entity => {
       let scope = takeRowScope(entity, entityConfig);
       Utils.Dict.push(setEntities, entityConfig.name, entity.id);
       InMemoryTable.Entity.set(getInMemTable(state, entityConfig, scope), committedCheckpointId, {
@@ -144,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);
@@ -160,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/Internal.res

@@ -149,8 +149,8 @@ type svmTransactionField =
   | @as("accountKeys") AccountKeys
   | @as("recentBlockhash") RecentBlockhash
   | @as("version") Version
-  | @as("tokenBalances") TokenBalances
   | @as("allSignatures") AllSignatures
+  | @as("accountActivities") AccountActivities
 
 let allSvmTransactionFields: array<svmTransactionField> = [
   TransactionIndex,
@@ -163,13 +163,12 @@ let allSvmTransactionFields: array<svmTransactionField> = [
   AccountKeys,
   RecentBlockhash,
   Version,
-  TokenBalances,
   AllSignatures,
+  AccountActivities,
 ]
-let svmTransactionFieldSchema = S.enum(allSvmTransactionFields)
 
-// All SVM block fields. `slot`/`time`/`hash` are always included; the rest are
-// selectable via `field_selection.block_fields` (see `allSvmBlockFields`).
+// All SVM block fields. `slot` is always included (the item's key); the rest
+// are selectable via handler `fields.block`.
 type svmBlockField =
   | @as("slot") Slot
   | @as("time") Time
@@ -178,9 +177,6 @@ type svmBlockField =
   | @as("parentSlot") ParentSlot
   | @as("parentHash") ParentHash
 
-let allSvmBlockFields: array<svmBlockField> = [Height, ParentSlot, ParentHash]
-let svmBlockFieldSchema = S.enum(allSvmBlockFields)
-
 // Static sets of field names whose source schemas must be wrapped with S.nullable.
 let evmNullableBlockFields = Utils.Set.fromArray(
   (
@@ -427,6 +423,9 @@ type indexingContract = {
 type fieldSelection = {
   blockFields: Utils.Set.t<string>,
   transactionFields: Utils.Set.t<string>,
+  instructionFields: Utils.Set.t<string>,
+  accountActivityFields: Utils.Set.t<string>,
+  logFields: Utils.Set.t<string>,
   // The sets precompiled to the store selections `ChainState` materialises with.
   blockMask: float,
   transactionMask: float,
@@ -438,11 +437,17 @@ type fieldSelection = {
 let makeFieldSelection = (
   ~blockFields: Utils.Set.t<string>,
   ~transactionFields: Utils.Set.t<string>,
+  ~instructionFields: Utils.Set.t<string>=Utils.Set.make(),
+  ~accountActivityFields: Utils.Set.t<string>=Utils.Set.make(),
+  ~logFields: Utils.Set.t<string>=Utils.Set.make(),
   ~blockMaskFn: Utils.Set.t<string> => float,
   ~transactionMaskFn: Utils.Set.t<string> => float,
 ): fieldSelection => {
   blockFields,
   transactionFields,
+  instructionFields,
+  accountActivityFields,
+  logFields,
   blockMask: blockMaskFn(blockFields),
   transactionMask: transactionMaskFn(transactionFields),
 }
@@ -459,6 +464,9 @@ let unionFields = (a, b) => a === b ? a : a->Utils.Set.union(b)
 let unionFieldSelection = (a: fieldSelection, b: fieldSelection): fieldSelection => {
   blockFields: unionFields(a.blockFields, b.blockFields),
   transactionFields: unionFields(a.transactionFields, b.transactionFields),
+  instructionFields: unionFields(a.instructionFields, b.instructionFields),
+  accountActivityFields: unionFields(a.accountActivityFields, b.accountActivityFields),
+  logFields: unionFields(a.logFields, b.logFields),
   blockMask: FieldMask.orMask(a.blockMask, b.blockMask),
   transactionMask: FieldMask.orMask(a.transactionMask, b.transactionMask),
 }
@@ -569,7 +577,6 @@ type svmInstructionEventConfig = {
    `dN` selector at query time and the dispatch-key precomputation in the
    router. */
   discriminatorByteLen: int,
-  includeLogs: bool,
   /** Disjunctive normal form: outer array is OR of AND-groups, inner array is
    AND across positions. Empty outer array means "no account filter". */
   accountFilters: array<svmAccountFilterGroup>,
@@ -747,9 +754,8 @@ let getItemChainId = item =>
   | Block({onBlockRegistration: {chainId}}) => chainId
   }
 
-// The `fields` option of an EVM `onEvent`/`contractRegister` registration:
-// the block and transaction fields the handler reads. Replaces the config
-// `field_selection` for this registration.
+// EVM `fields` bag. Parsed from the JS object as `unknown` at registration;
+// this record exists so ReScript tests can construct a typed EVM selection.
 type evmFieldsSelection = {
   block?: array<string>,
   transaction?: array<string>,
@@ -758,7 +764,7 @@ type evmFieldsSelection = {
 type eventOptions<'where> = {
   wildcard?: bool,
   where?: 'where,
-  fields?: evmFieldsSelection,
+  fields?: unknown,
 }
 
 type fuelSupplyParams = {
@@ -782,12 +788,23 @@ let fuelTransferParamsSchema = S.schema(s => {
 
 type entity = private {id: string}
 
+// A data skipping index emitted into the history table DDL as
+// `INDEX <name> <expr> TYPE <type> GRANULARITY <granularity>`.
+type clickhouseSkippingIndex = {
+  name: string,
+  expr: string,
+  @as("type")
+  type_: string,
+  granularity?: int,
+}
+
 // Raw ClickHouse expressions/field names from the entity's
 // @storage(clickhouse: {...}) directive, applied to the history table DDL.
 type clickhouseTableOptions = {
   partitionBy?: string,
   orderBy?: array<string>,
   ttl?: string,
+  skippingIndexes?: array<clickhouseSkippingIndex>,
 }
 
 // Per-entity storage resolved at parse time against the global storage
@@ -808,6 +825,9 @@ type genericEntityConfig<'entity> = {
   // entity's `@crossChain`. When false the table carries a chain-id column in
   // its primary key and every row belongs to exactly one chain.
   crossChain: bool,
+  // `@internal` on the entity: stored and usable in handlers as normal, but
+  // never exposed through the GraphQL API (no Hasura tracking).
+  internal: bool,
 }
 type entityConfig = genericEntityConfig<entity>
 external fromGenericEntityConfig: genericEntityConfig<'entity> => entityConfig = "%identity"

package/src/Internal.res.mjs

@@ -88,20 +88,10 @@ let allSvmTransactionFields = [
   "accountKeys",
   "recentBlockhash",
   "version",
-  "tokenBalances",
-  "allSignatures"
+  "allSignatures",
+  "accountActivities"
 ];
 
-let svmTransactionFieldSchema = S$RescriptSchema.$$enum(allSvmTransactionFields);
-
-let allSvmBlockFields = [
-  "height",
-  "parentSlot",
-  "parentHash"
-];
-
-let svmBlockFieldSchema = S$RescriptSchema.$$enum(allSvmBlockFields);
-
 let evmNullableBlockFields = new Set([
   "nonce",
   "difficulty",
@@ -141,10 +131,16 @@ let evmNullableTransactionFields = new Set([
   "type"
 ]);
 
-function makeFieldSelection(blockFields, transactionFields, blockMaskFn, transactionMaskFn) {
+function makeFieldSelection(blockFields, transactionFields, instructionFieldsOpt, accountActivityFieldsOpt, logFieldsOpt, blockMaskFn, transactionMaskFn) {
+  let instructionFields = instructionFieldsOpt !== undefined ? Primitive_option.valFromOption(instructionFieldsOpt) : new Set();
+  let accountActivityFields = accountActivityFieldsOpt !== undefined ? Primitive_option.valFromOption(accountActivityFieldsOpt) : new Set();
+  let logFields = logFieldsOpt !== undefined ? Primitive_option.valFromOption(logFieldsOpt) : new Set();
   return {
     blockFields: blockFields,
     transactionFields: transactionFields,
+    instructionFields: instructionFields,
+    accountActivityFields: accountActivityFields,
+    logFields: logFields,
     blockMask: blockMaskFn(blockFields),
     transactionMask: transactionMaskFn(transactionFields)
   };
@@ -162,6 +158,9 @@ function unionFieldSelection(a, b) {
   return {
     blockFields: unionFields(a.blockFields, b.blockFields),
     transactionFields: unionFields(a.transactionFields, b.transactionFields),
+    instructionFields: unionFields(a.instructionFields, b.instructionFields),
+    accountActivityFields: unionFields(a.accountActivityFields, b.accountActivityFields),
+    logFields: unionFields(a.logFields, b.logFields),
     blockMask: FieldMask.orMask(a.blockMask, b.blockMask),
     transactionMask: FieldMask.orMask(a.transactionMask, b.transactionMask)
   };
@@ -329,9 +328,6 @@ export {
   allEvmTransactionFields,
   evmTransactionFieldSchema,
   allSvmTransactionFields,
-  svmTransactionFieldSchema,
-  allSvmBlockFields,
-  svmBlockFieldSchema,
   evmNullableBlockFields,
   evmNullableTransactionFields,
   makeFieldSelection,

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
               }
             }
@@ -239,7 +247,7 @@ let getGlobalIndexer = (): 'indexer => {
           "event": unknown,
           "wildcard": option<bool>,
           "where": option<JSON.t>,
-          "fields": option<Internal.evmFieldsSelection>,
+          "fields": option<unknown>,
         }
       )
     // Detect format: if "contract" is a string, it's the TS format
@@ -295,7 +303,7 @@ let getGlobalIndexer = (): 'indexer => {
           "program": unknown,
           "instruction": unknown,
           "where": option<JSON.t>,
-          "fields": option<Internal.evmFieldsSelection>,
+          "fields": option<unknown>,
         }
       )
     let (programName, instructionName) = if typeof(raw["program"]) === #string {
@@ -308,9 +316,6 @@ let getGlobalIndexer = (): 'indexer => {
       (inst["contract"], inst["_0"])
     }
     let where = raw["where"]
-    // SVM takes its selection from the config, so `fields` is carried through
-    // only to be rejected by the registration — dropping it here would leave a
-    // plain-JS caller with a silently ignored option.
     let fields = raw["fields"]
     let eventOptions: option<Internal.eventOptions<_>> = switch (where, fields) {
     | (None, None) => None
@@ -580,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,
@@ -631,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"),