backfill and FE scan fix

Author: sekuba

collector/.env.example

@@ -17,6 +17,9 @@ AZTEC_SENTINEL_VALIDATOR_MAX_RESPONSE_BYTES=2097152
 # One Ethereum RPC. The network selects the chain and Registry.
 L1_RPC_URL=http://127.0.0.1:8545
 # L1_REGISTRY_ADDRESS=
+# Exact mainnet v5 history. Requires an archive RPC.
+# L1_SLASH_LOG_START_BLOCK=25533241
+# Used only when no exact start block is configured.
 L1_SLASH_LOG_LOOKBACK_BLOCKS=50000
 
 # Enable Telegram only when both values are set.

collector/README.md

@@ -28,7 +28,7 @@ Node 24 is required. The main settings are:
 | --- | --- |
 | Identity | `SLASHMON_NETWORK`, `SLASHMON_PUBLIC_URL` |
 | Aztec node | `AZTEC_NODE_URL`, `AZTEC_NODE_API_KEY`, `AZTEC_ADMIN_URL`, `AZTEC_ADMIN_API_KEY` |
-| Ethereum | one `L1_RPC_URL`; optional Registry and log-lookback overrides |
+| Ethereum | one `L1_RPC_URL`; optional Registry and log-history overrides |
 | Notifications | optional complete VAPID keypair and/or Telegram bot |
 | Process | database path, bind host/port, exact CORS origin, proxy trust, log level |
 

collector/deploy/slashmon-backend-testing.env.example

@@ -28,6 +28,9 @@ AZTEC_SENTINEL_VALIDATOR_MAX_RESPONSE_BYTES=2097152
 
 L1_RPC_URL=http://127.0.0.1:8545
 # L1_REGISTRY_ADDRESS=
+# Exact mainnet v5 history. Requires an archive RPC.
+# L1_SLASH_LOG_START_BLOCK=25533241
+# Used only when no exact start block is configured.
 L1_SLASH_LOG_LOOKBACK_BLOCKS=50000
 
 # Use testing-only notification credentials. In particular, Telegram long

collector/deploy/slashmon-backend.env.example

@@ -25,6 +25,9 @@ AZTEC_SENTINEL_VALIDATOR_MAX_RESPONSE_BYTES=2097152
 # One Ethereum RPC. The network selects the chain and Registry.
 L1_RPC_URL=http://127.0.0.1:8545
 # L1_REGISTRY_ADDRESS=
+# Exact mainnet v5 history. Requires an archive RPC.
+# L1_SLASH_LOG_START_BLOCK=25533241
+# Used only when no exact start block is configured.
 L1_SLASH_LOG_LOOKBACK_BLOCKS=50000
 
 # Optional notification channels.

collector/src/case-repository.mjs

@@ -1016,6 +1016,7 @@ export class CaseRepository {
       });
       this.recordSourceSuccess('l1_slash_logs', {
         initialBackfill: Boolean(chunk.initialBackfill && chunk.hasMore),
+        backfillStartBlock: chunk.backfillStartBlock ?? null,
         confirmedBlockNumber: chunk.confirmedBlockNumber,
         rollupAddresses: chunk.rollupAddresses,
       }, observedAt, {

collector/src/config.mjs

@@ -100,6 +100,12 @@ export function loadConfig(env = process.env, cwd = process.cwd()) {
     l1MaxHeadAgeMs: 15 * 60_000,
     l1MaxHeadStallMs: 2 * 60_000,
     l1MaxFutureSkewMs: 2 * 60_000,
+    l1SlashLogStartBlock: readOptionalInteger(
+      env,
+      'L1_SLASH_LOG_START_BLOCK',
+      0,
+      1_000_000_000,
+    ),
     l1SlashLogLookbackBlocks: readInteger(
       env,
       'L1_SLASH_LOG_LOOKBACK_BLOCKS',
@@ -260,6 +266,12 @@ function readInteger(env, name, defaultValue, min, max) {
   return value;
 }
 
+function readOptionalInteger(env, name, min, max) {
+  const raw = env[name];
+  if (raw === undefined || raw === '') return undefined;
+  return readInteger(env, name, undefined, min, max);
+}
+
 function readHttpUrl(raw, name) {
   let url;
   try {

collector/src/l1-scanner.mjs

@@ -31,6 +31,7 @@ export class L1Scanner {
     maxHeadAgeMs = 15 * 60_000,
     maxHeadStallMs = 2 * 60_000,
     maxFutureSkewMs = 2 * 60_000,
+    slashLogStartBlock,
     slashLogLookbackBlocks = 600,
     slashLogChunkSize = 1_000,
     slashLogOverlapBlocks = 12,
@@ -48,6 +49,9 @@ export class L1Scanner {
     this.maxHeadAgeMs = maxHeadAgeMs;
     this.maxHeadStallMs = maxHeadStallMs;
     this.maxFutureSkewMs = maxFutureSkewMs;
+    this.slashLogStartBlock = slashLogStartBlock === undefined
+      ? undefined
+      : BigInt(slashLogStartBlock);
     this.slashLogLookbackBlocks = BigInt(slashLogLookbackBlocks);
     this.slashLogChunkSize = BigInt(slashLogChunkSize);
     this.slashLogOverlapBlocks = BigInt(slashLogOverlapBlocks);
@@ -63,6 +67,9 @@ export class L1Scanner {
         fetchOptions: { signal },
       }),
     }));
+    if (this.slashLogStartBlock !== undefined && this.slashLogStartBlock < 0n) {
+      throw new RangeError('slash log start block must be non-negative');
+    }
     if (this.slashLogLookbackBlocks < 1n) throw new RangeError('slash log lookback must be positive');
     if (this.slashLogChunkSize < 2n) throw new RangeError('slash log chunk size must be at least 2');
     if (this.slashLogOverlapBlocks < 1n || this.slashLogOverlapBlocks >= this.slashLogChunkSize) {
@@ -252,9 +259,24 @@ export class L1Scanner {
     if ((cursorNumber === undefined) !== !cursorHash) {
       throw new Error('persisted slash log checkpoint is incomplete');
     }
+    if (
+      this.slashLogStartBlock !== undefined &&
+      this.slashLogStartBlock > confirmedBlockNumber
+    ) {
+      throw new Error(
+        `configured slash log start block ${this.slashLogStartBlock} is above confirmed L1 head ${confirmedBlockNumber}`,
+      );
+    }
+    const persistedStartBlock = readOptionalBigInt(
+      previous.metadata?.backfillStartBlock,
+    );
+    const restartFromConfiguredStart =
+      cursorNumber !== undefined &&
+      this.slashLogStartBlock !== undefined &&
+      persistedStartBlock !== this.slashLogStartBlock;
 
     let reorgDetected = false;
-    if (cursorNumber !== undefined) {
+    if (cursorNumber !== undefined && !restartFromConfiguredStart) {
       if (cursorNumber > confirmedBlockNumber) {
         reorgDetected = true;
       } else {
@@ -268,10 +290,12 @@ export class L1Scanner {
     }
 
     let fromBlock;
-    if (cursorNumber === undefined) {
-      fromBlock = confirmedBlockNumber + 1n > this.slashLogLookbackBlocks
-        ? confirmedBlockNumber + 1n - this.slashLogLookbackBlocks
-        : 0n;
+    if (cursorNumber === undefined || restartFromConfiguredStart) {
+      fromBlock = this.slashLogStartBlock ?? (
+        confirmedBlockNumber + 1n > this.slashLogLookbackBlocks
+          ? confirmedBlockNumber + 1n - this.slashLogLookbackBlocks
+          : 0n
+      );
     } else if (reorgDetected) {
       fromBlock = cursorNumber + 1n > this.slashLogReorgRewindBlocks
         ? cursorNumber + 1n - this.slashLogReorgRewindBlocks
@@ -282,6 +306,12 @@ export class L1Scanner {
         ? cursorNumber + 1n - this.slashLogOverlapBlocks
         : 0n;
     }
+    if (
+      this.slashLogStartBlock !== undefined &&
+      fromBlock < this.slashLogStartBlock
+    ) {
+      fromBlock = this.slashLogStartBlock;
+    }
     const toBlock = minBigInt(confirmedBlockNumber, fromBlock + this.slashLogChunkSize - 1n);
     const checkpointBlock = toBlock === confirmedBlockNumber
       ? confirmedBlock
@@ -364,8 +394,12 @@ export class L1Scanner {
       toBlockHash: checkpointBlock.hash,
       confirmedBlockNumber: confirmedBlockNumber.toString(),
       reorgDetected,
-      initial: cursorNumber === undefined,
-      initialBackfill: cursorNumber === undefined || previous.metadata?.initialBackfill === true,
+      initial: cursorNumber === undefined || restartFromConfiguredStart,
+      initialBackfill:
+        cursorNumber === undefined ||
+        restartFromConfiguredStart ||
+        previous.metadata?.initialBackfill === true,
+      backfillStartBlock: this.slashLogStartBlock?.toString() ?? null,
       hasMore: toBlock < confirmedBlockNumber,
       registryAddress: this.registryAddress,
       rollupAddresses: [...knownRollups].sort(),

collector/src/main.mjs

@@ -65,6 +65,7 @@ async function main() {
     maxHeadAgeMs: config.l1MaxHeadAgeMs,
     maxHeadStallMs: config.l1MaxHeadStallMs,
     maxFutureSkewMs: config.l1MaxFutureSkewMs,
+    slashLogStartBlock: config.l1SlashLogStartBlock,
     slashLogLookbackBlocks: config.l1SlashLogLookbackBlocks,
     slashLogChunkSize: config.l1SlashLogChunkSize,
     slashLogOverlapBlocks: config.l1SlashLogOverlapBlocks,

collector/test/config.test.mjs

@@ -20,7 +20,9 @@ test('loadConfig provides a complete local configuration', () => {
   assert.equal(config.port, 8790);
   assert.equal(config.l1ChainId, 1);
   assert.equal(config.l1RegistryAddress, '0x35b22e09Ee0390539439E24f06Da43D83f90e298');
+  assert.equal(config.l1SlashLogStartBlock, undefined);
   assert.equal(config.l1SlashLogLookbackBlocks, 50_000);
+  assert.equal(config.l1SlashLogChunkSize, 1_000);
   assert.equal(config.sentinelPollIntervalMs, 60_000);
   assert.equal(config.sentinelLookbackEpochs, 3);
   assert.equal(config.sentinelEpochEndBufferSlots, 2);
@@ -84,13 +86,18 @@ test('operator-facing URLs and process settings are validated', () => {
     () => loadConfig({ AZTEC_SENTINEL_VALIDATOR_CONCURRENCY: '0' }),
     /between 1 and 128/,
   );
+  assert.throws(
+    () => loadConfig({ L1_SLASH_LOG_START_BLOCK: '-1' }),
+    /between 0 and 1000000000/,
+  );
   assert.throws(() => loadConfig({ BACKEND_TRUST_PROXY: 'yes' }), /must be true or false/);
   assert.throws(() => loadConfig({ BACKEND_LOG_LEVEL: 'trace' }), /debug, info, warn, or error/);
 
   const config = loadConfig({
     SLASHMON_PUBLIC_URL: 'https://slashveto.example/app',
     BACKEND_CORS_ORIGIN: 'https://slashveto.example',
     L1_RPC_URL: 'https://rpc-one.example/path',
+    L1_SLASH_LOG_START_BLOCK: '25533241',
     L1_SLASH_LOG_LOOKBACK_BLOCKS: '75000',
     BACKEND_DATABASE_PATH: '../state/slashmon.sqlite',
     BACKEND_PORT: '9000',
@@ -102,6 +109,7 @@ test('operator-facing URLs and process settings are validated', () => {
   assert.equal(config.publicUrl, 'https://slashveto.example/app/');
   assert.equal(config.corsOrigin, 'https://slashveto.example');
   assert.deepEqual(config.l1RpcUrls, ['https://rpc-one.example/path']);
+  assert.equal(config.l1SlashLogStartBlock, 25_533_241);
   assert.equal(config.l1SlashLogLookbackBlocks, 75_000);
   assert.equal(config.databasePath, '/srv/state/slashmon.sqlite');
   assert.equal(config.port, 9000);

collector/test/l1-collector-v3.test.mjs

@@ -32,10 +32,19 @@ test('confirmed Slashed logs attach only to an exact execution case', async () =
           logs: [slashLog(1)],
           initial: true,
           initialBackfill: true,
+          backfillStartBlock: 1,
         });
       }
       assert.equal(previous.lastBlockNumber, '2');
-      return slashChunk({ from: 3, to: 4, confirmed: 4, hasMore: false, logs: [] });
+      return slashChunk({
+        from: 3,
+        to: 4,
+        confirmed: 4,
+        hasMore: false,
+        logs: [],
+        initialBackfill: true,
+        backfillStartBlock: 1,
+      });
     },
   };
   const collector = new L1Collector({
@@ -54,7 +63,10 @@ test('confirmed Slashed logs attach only to an exact execution case', async () =
   assert.equal(result.ok, true);
   assert.equal(result.slashLogs.inserted, 1);
   assert.equal(logCalls, 2);
-  assert.equal(repository.getSourceState('l1_slash_logs').lastBlockNumber, '4');
+  const source = repository.getSourceState('l1_slash_logs');
+  assert.equal(source.lastBlockNumber, '4');
+  assert.equal(source.metadata.initialBackfill, false);
+  assert.equal(source.metadata.backfillStartBlock, '1');
   const [item] = repository.getSequencerRecord(SEQUENCER_A, 'mainnet').cases;
   assert.equal(item.targetEpoch, '24');
   assert.equal(item.state.stage, 'stake_removed');
@@ -108,7 +120,16 @@ function createRepository() {
   return repository;
 }
 
-function slashChunk({ from, to, confirmed, logs, hasMore, initial = false, initialBackfill = false }) {
+function slashChunk({
+  from,
+  to,
+  confirmed,
+  logs,
+  hasMore,
+  initial = false,
+  initialBackfill = false,
+  backfillStartBlock = null,
+}) {
   return {
     chainId: 1,
     fromBlock: String(from),
@@ -121,6 +142,9 @@ function slashChunk({ from, to, confirmed, logs, hasMore, initial = false, initi
     hasMore,
     initial,
     initialBackfill,
+    backfillStartBlock: backfillStartBlock === null
+      ? null
+      : String(backfillStartBlock),
     reorgDetected: false,
   };
 }