envio 3.8.0 → 3.9.0-resolvers.0

package/src/HandlerRegister.res.mjs

@@ -102,7 +102,7 @@ function buildOnEventRegistrationWith(config, chainId, eventConfig, isWildcard,
     case "fuel" :
       return EventConfigBuilder.buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock);
     case "svm" :
-      return EventConfigBuilder.buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, fieldSelection, startBlock);
+      return EventConfigBuilder.buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, where, fieldSelection, startBlock);
   }
 }
 
@@ -209,7 +209,7 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
         fieldSelection = EventConfigBuilder.resolveInlineFieldSelection(fields$1, contractName, eventName, registration.config.enableRawEvents);
         break;
       case "fuel" :
-        fieldSelection = Stdlib_JsError.throwWithMessage(`The fields option of the "` + eventName + `" event registration on contract "` + contractName + `" is only supported on EVM. Select the fields in your config instead.`);
+        fieldSelection = Stdlib_JsError.throwWithMessage(`The fields option of the "` + eventName + `" event registration on contract "` + contractName + `" is not supported on Fuel. Select the fields in your config instead.`);
         break;
       case "svm" :
         fieldSelection = EventConfigBuilder.resolveSvmInlineFieldSelection(fields$1, contractName, eventName);
@@ -243,13 +243,16 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
     if (Utils.$$Array.isEmpty(names)) {
       return empty;
     } else {
-      return names.join(", ");
+      return Utils.$$Array.quotedJoin(names);
     }
   };
+  let match$2 = registration.config.ecosystem;
+  let eventNoun = match$2.eventNoun;
+  let contractNoun = match$2.contractNoun;
   if (Utils.$$Array.isEmpty(eventNames)) {
-    return Stdlib_JsError.throwWithMessage(`Contract "` + contractName + `" is not configured on any chain, so its handler for "` + eventName + `" would never run. Add it to your config, or remove the registration. Configured contracts: ` + listOr(match$1[0], "none") + `.`);
+    return Stdlib_JsError.throwWithMessage(Utils.$$String.capitalize(contractNoun) + ` "` + contractName + `" is not configured on any chain, so its handler for "` + eventName + `" would never run. Add it to your config, or remove the registration. Configured ` + contractNoun + `s: ` + listOr(match$1[0], "none") + `.`);
   } else {
-    return Stdlib_JsError.throwWithMessage(`Event "` + eventName + `" is not configured on contract "` + contractName + `", so its handler would never run. Add it to your config, or remove the registration. Configured events on "` + contractName + `": ` + listOr(eventNames, "none") + `.`);
+    return Stdlib_JsError.throwWithMessage(Utils.$$String.capitalize(eventNoun) + ` "` + eventName + `" is not configured on ` + contractNoun + ` "` + contractName + `", so its handler would never run. Add it to your config, or remove the registration. Configured ` + eventNoun + `s on "` + contractName + `": ` + listOr(eventNames, "none") + `.`);
   }
 }
 

package/src/InMemoryStore.res

@@ -127,14 +127,18 @@ let dropCommittedEffects = (
 
 let prepareRollbackDiff = async (
   state: IndexerState.t,
+  ~rollbackScope: RollbackScope.t,
   ~rollbackTargetCheckpointId,
   ~rollbackDiffCheckpointId,
-  ~progressBlockNumberByChainId,
+  ~progressedChains,
+  ~rolledBackAddresses,
 ) => {
   state->IndexerState.beginRollbackDiff(
     ~targetCheckpointId=rollbackTargetCheckpointId,
     ~diffCheckpointId=rollbackDiffCheckpointId,
-    ~progressBlockNumberByChainId,
+    ~scope=rollbackScope,
+    ~progressedChains,
+    ~rolledBackAddresses,
   )
   let persistence = state->IndexerState.persistence
   let committedCheckpointId = state->IndexerState.committedCheckpointId
@@ -150,6 +154,7 @@ let prepareRollbackDiff = async (
   ->Array.map(async entityConfig => {
     let (removals, restoredEntities) = await persistence.storage.getRollbackData(
       ~entityConfig,
+      ~scope=rollbackScope,
       ~rollbackTargetCheckpointId,
     )
 
@@ -194,12 +199,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)
@@ -219,31 +218,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";
@@ -107,14 +106,14 @@ 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, rollbackScope, rollbackTargetCheckpointId, rollbackDiffCheckpointId, progressedChains, rolledBackAddresses) {
+  IndexerState.beginRollbackDiff(state, rollbackTargetCheckpointId, rollbackDiffCheckpointId, rollbackScope, progressedChains, rolledBackAddresses);
   let persistence = IndexerState.persistence(state);
   let committedCheckpointId = IndexerState.committedCheckpointId(state);
   let deletedEntities = {};
   let setEntities = {};
   await Promise.all(persistence.allEntities.filter(entityConfig => entityConfig.storage.postgres).map(async entityConfig => {
-    let match = await persistence.storage.getRollbackData(entityConfig, rollbackTargetCheckpointId);
+    let match = await persistence.storage.getRollbackData(entityConfig, rollbackScope, rollbackTargetCheckpointId);
     match[0].forEach(param => {
       let entityId = param.entityId;
       Utils.Dict.push(deletedEntities, entityConfig.name, entityId);
@@ -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,9 +789,12 @@ let drainBatchRun = (state: t): Batch.t => {
     checkpointBlockNumbers,
     checkpointBlockHashes,
     checkpointEventsProcessed,
+    registeredAddresses,
   }
 }
 
+let pendingRollback = (state: t): option<Persistence.rollback> => state.rollback
+
 // Take the pending rollback diff to write, clearing it from the store.
 let takeRollback = (state: t): option<Persistence.rollback> => {
   let rollback = state.rollback
@@ -797,23 +803,54 @@ 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 = (
   state: t,
   ~targetCheckpointId,
   ~diffCheckpointId,
-  ~progressBlockNumberByChainId,
+  ~scope,
+  ~progressedChains: array<InternalTable.Chains.progressedChain>,
+  ~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
+  }
+  // Same for the chains: this rollback recomputes progress from the checkpoints,
+  // so a chain the pending diff already moved can land on exactly the block it
+  // is now at and go unreported here. Its stored progress still needs
+  // correcting, so the pending rows carry over — this rollback's row for a
+  // chain wins, being the later reading of the same chain state.
+  let progressedChains = switch state.rollback {
+  | Some({progressedChains: pending}) =>
+    let byChainId = Dict.make()
+    pending->Array.forEach(chain => byChainId->ChainId.Dict.set(chain.chainId, chain))
+    progressedChains->Array.forEach(chain => byChainId->ChainId.Dict.set(chain.chainId, chain))
+    byChainId->Dict.valuesToArray
+  | None => progressedChains
+  }
   state.rollback = Some({
     targetCheckpointId,
     diffCheckpointId,
-    progressBlockNumberByChainId,
+    scope,
+    progressedChains,
+    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,10 +653,15 @@ function drainBatchRun(state) {
     checkpointChainIds: checkpointChainIds,
     checkpointBlockNumbers: checkpointBlockNumbers,
     checkpointBlockHashes: checkpointBlockHashes,
-    checkpointEventsProcessed: checkpointEventsProcessed
+    checkpointEventsProcessed: checkpointEventsProcessed,
+    registeredAddresses: registeredAddresses
   };
 }
 
+function pendingRollback(state) {
+  return state.rollback;
+}
+
 function takeRollback(state) {
   let rollback = state.rollback;
   state.rollback = undefined;
@@ -665,15 +672,33 @@ function markCommitted(state, upToCheckpointId) {
   state.committedCheckpointId = upToCheckpointId;
 }
 
-function beginRollbackDiff(state, targetCheckpointId, diffCheckpointId, progressBlockNumberByChainId) {
+function beginRollbackDiff(state, targetCheckpointId, diffCheckpointId, scope, progressedChains, 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;
+  let match$1 = state.rollback;
+  let progressedChains$1;
+  if (match$1 !== undefined) {
+    let byChainId = {};
+    match$1.progressedChains.forEach(chain => {
+      byChainId[chain.chainId] = chain;
+    });
+    progressedChains.forEach(chain => {
+      byChainId[chain.chainId] = chain;
+    });
+    progressedChains$1 = Object.values(byChainId);
+  } else {
+    progressedChains$1 = progressedChains;
+  }
   state.rollback = {
     targetCheckpointId: targetCheckpointId,
     diffCheckpointId: diffCheckpointId,
-    progressBlockNumberByChainId: progressBlockNumberByChainId
+    scope: scope,
+    rolledBackAddresses: rolledBackAddresses$1,
+    progressedChains: progressedChains$1
   };
 }
 
@@ -806,6 +831,7 @@ export {
   recordRollbackSuccess,
   queueProcessedBatch,
   drainBatchRun,
+  pendingRollback,
   takeRollback,
   markCommitted,
   beginRollbackDiff,

package/src/IndexerState.resi

@@ -136,13 +136,16 @@ let recordRollbackSuccess: (t, ~timeSeconds: float, ~rollbackedProcessedEvents:
 // Store domain operations.
 let queueProcessedBatch: (t, ~batch: Batch.t) => unit
 let drainBatchRun: t => Batch.t
+let pendingRollback: t => option<Persistence.rollback>
 let takeRollback: t => option<Persistence.rollback>
 let markCommitted: (t, ~upToCheckpointId: Internal.checkpointId) => unit
 let beginRollbackDiff: (
   t,
   ~targetCheckpointId: Internal.checkpointId,
   ~diffCheckpointId: Internal.checkpointId,
-  ~progressBlockNumberByChainId: dict<int>,
+  ~scope: RollbackScope.t,
+  ~progressedChains: array<InternalTable.Chains.progressedChain>,
+  ~rolledBackAddresses: array<AddressRows.key>,
 ) => unit
 let recordWriteFailure: (t, exn) => unit
 let beginWriteFiber: (t, promise<unit>) => unit

package/src/Internal.res

@@ -573,15 +573,6 @@ type svmInstructionEventConfig = {
   programId: SvmTypes.Pubkey.t,
   /** Hex-encoded discriminator. `None` matches every instruction in the program. */
   discriminator: option<string>,
-  /** Length of the discriminator in bytes (0 / 1 / 2 / 4 / 8). Drives the
-   `dN` selector at query time and the dispatch-key precomputation in the
-   router. */
-  discriminatorByteLen: int,
-  /** 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>,
-  /** `None` matches both outer and inner (CPI-invoked) instructions. */
-  isInner: option<bool>,
   /** Positional account names from the Borsh schema, in declared order.
    `[]` means no schema is attached for this instruction. */
   accounts: array<string>,
@@ -597,10 +588,11 @@ type svmInstructionEventConfig = {
 // Per-(event, chain) registration produced when user handler code registers an
 // event (`onEvent`) or a dynamic contract registers. References its definition
 // by value as `.eventConfig` and adds the handler binding plus the
-// registration/`where`-derived fetch state. Not `private`: Fuel/SVM
-// registrations add no ecosystem-specific fields (so they're bare aliases that
-// must stay directly constructable), and the evm→base cast in sources is sound
-// by ecosystem homogeneity — an EVM chain only ever holds `evmOnEventRegistration`s.
+// registration/`where`-derived fetch state. Not `private`: Fuel registrations
+// add no ecosystem-specific fields (so the alias must stay directly
+// constructable), and the ecosystem→base casts in sources are sound by
+// ecosystem homogeneity — an EVM chain only ever holds
+// `evmOnEventRegistration`s.
 type onEventRegistration = {
   // Chain-scoped sequential index — the registration's position in the
   // chain's onEventRegistrations array, assigned when registration finishes
@@ -639,11 +631,18 @@ type evmOnEventRegistration = {
   resolvedWhere: resolvedWhere,
 }
 
-// Fuel and SVM registrations add no ecosystem-specific fetch state (their
-// filters are config-derived and live on the definition), so they're bare
-// aliases of the base registration.
+// Fuel registrations add no ecosystem-specific fetch state, so it's a bare
+// alias of the base registration.
 type fuelOnEventRegistration = onEventRegistration
-type svmOnEventRegistration = onEventRegistration
+
+type svmOnEventRegistration = {
+  ...onEventRegistration,
+  /** 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>,
+  /** `None` matches both outer and inner (CPI-invoked) instructions. */
+  isInner: option<bool>,
+}
 
 type svmProgramConfig = {
   name: string,

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/Metrics.res

@@ -12,6 +12,8 @@ type chainMetrics = {
   startBlock: int,
   endBlock: option<int>,
   numAddresses: int,
+  // Per-contract registration counts, in the chain's contract-id order.
+  addressesByContract: array<(string, int)>,
   isReady: bool,
   // Raw source height, unlike knownHeight which is clamped to endBlock.
   sourceBlockNumber: int,
@@ -694,11 +696,23 @@ let renderMetrics = (b: builder, metrics: t) => {
   )
   b->series(
     ~name="envio_indexing_addresses",
-    ~help="The number of addresses indexed on chain. Includes both static and dynamic addresses.",
+    ~help="The number of address registrations on chain, static and dynamic. An address shared by N contracts counts N times.",
     ~kind="gauge",
     ~entries=chains,
     ~value=m => m.numAddresses->Int.toFloat,
   )
+  b->series(
+    ~name="envio_indexing_contract_addresses",
+    ~help="The number of address registrations per contract on chain, static and dynamic. An address shared by N contracts counts N times.",
+    ~kind="gauge",
+    ~entries=metrics.chains->Array.flatMap(m =>
+      m.addressesByContract->Array.map(((contract, count)) => (
+        `{chainId="${m.chainId->ChainId.toString}",contract="${contract->escapeLabelValue}"}`,
+        count,
+      ))
+    ),
+    ~value=count => count->Int.toFloat,
+  )
 }
 
 let contentType = "text/plain; version=0.0.4; charset=utf-8"