finesse

Author: sekuba

docs/architecture.md

@@ -43,6 +43,17 @@ It does not call the slashveto.me API, depend on a backend snapshot, or possess
 notification credentials. A user can enter their addresses again and recover
 the L1 portion of each case when the backend is unavailable.
 
+Execution history is progressive and RPC-aware. Monitor reads present contract
+state first, then scans `RoundExecuted` logs newest-to-oldest within the useful
+execution window. It starts with small ranges, grows fast successful ranges,
+shrinks provider-rejected ranges, and pauses on rate limits while retaining
+completed work for the page session. Each refresh scans only new blocks plus a
+small reorg overlap.
+The page displays exact coverage. Until a receipt is inspected, the case says
+that its outcome is still being scanned; it never treats missing coverage as
+proof that no `Slashed` log exists. A stronger user-supplied RPC can complete
+the same bounded scan faster without changing case semantics.
+
 Its unavoidable limitations are visible:
 
 - an L1-only case starts at voting; it cannot see duty misses or node
@@ -207,6 +218,9 @@ Visible sequencer addresses open the matching mainnet or testnet Dashtec page.
 The frontend must show source time and freshness independently. “Confirmed”
 means an L1 fact observed at the stated block and confirmation policy; it does
 not mean Ethereum-finalized unless the block itself is finalized.
+For Monitor, receipt coverage is also explicit: `scanning`, `paused`,
+`inspected`, and `complete without finding the expected event` are different
+states.
 
 ## Canonical contract discovery
 

docs/v3-plan.md

@@ -176,6 +176,11 @@ PINGME receives projected cases. Monitor feeds browser-collected L1
 observations through the same reducer. Raw evidence is progressive disclosure:
 users need not understand vote words, round offsets, or payload clones to read
 the headline, but those facts remain available and linked to Etherscan.
+Monitor loads current state first and progressively scans execution receipts
+newest-to-oldest. Successful RPC ranges grow, rejected ranges shrink, rate
+limits pause without discarding progress, and later polls cover only new blocks
+plus a reorg overlap. The UI reports scan coverage and keeps an uninspected
+receipt distinct from an inspected receipt with no `Slashed` log.
 Visible sequencer addresses link to the matching Dashtec network.
 Watchlist cases appear before the public case feed. PINGME places source health
 last because it describes the reliability of the whole page.

shared/protocol/cases.test.ts

@@ -101,6 +101,62 @@ describe('case projection', () => {
         });
     });
 
+    it('keeps a requested amount visible while the browser scans the receipt', () => {
+        const cases = projectCases([
+            observation('executed', 'l1_round', {
+                round: '12',
+                status: 'executed',
+                isExecuted: true,
+                amount: '2000000000000000000000',
+                executionReceiptStatus: 'scanning',
+            }, 'ethereum_l1'),
+        ], protocol());
+
+        expect(cases[0].state).toMatchObject({
+            stage: 'executed',
+            headline: 'Round executed · 2,000 AZTEC requested',
+            requestedAmount: '2000000000000000000000',
+        });
+        expect(cases[0].state.explanation).toContain(
+            'scanning for its execution receipt',
+        );
+    });
+
+    it('uses an inspected execution receipt as a terminal non-slash outcome', () => {
+        const cases = projectCases([
+            observation('executed', 'l1_round', {
+                round: '12',
+                status: 'executed',
+                isExecuted: true,
+                amount: '2000000000000000000000',
+                executionReceiptStatus: 'inspected',
+            }, 'ethereum_l1'),
+            {
+                ...observation('receipt', 'l1_execution', {
+                    round: '12',
+                    slashCount: '1',
+                    actionIndex: 0,
+                }, 'ethereum_l1'),
+                provenance: {
+                    observedAt: '2026-07-29T12:01:00.000Z',
+                    blockNumber: '123',
+                    blockHash: `0x${'12'.repeat(32)}`,
+                    transactionHash: `0x${'34'.repeat(32)}`,
+                    canonical: true,
+                },
+            },
+        ], protocol());
+
+        expect(cases[0].state).toMatchObject({
+            stage: 'resolved',
+            headline: 'Round executed · 2,000 AZTEC requested',
+            active: false,
+        });
+        expect(cases[0].state.explanation).toContain(
+            'contains no Rollup Slashed log',
+        );
+    });
+
     it('treats escape-hatch exclusion as a terminal non-slash outcome', () => {
         const cases = projectCases([
             observation('escaped', 'l1_round', {

shared/protocol/cases.ts

@@ -245,9 +245,10 @@ function deriveState(
         );
     }
 
+    const execution = latest(canonical, 'l1_execution');
     const round = latest(canonical, 'l1_round');
     if (round) {
-        return roundState(round, reason);
+        return roundState(round, reason, execution ?? undefined);
     }
 
     const offense = latest(canonical, 'node_offense');
@@ -313,7 +314,11 @@ function deriveState(
     );
 }
 
-function roundState(observation: Observation, reason: CaseReason): CaseState {
+function roundState(
+    observation: Observation,
+    reason: CaseReason,
+    execution?: Observation,
+): CaseState {
     const data = observation.data;
     const round = readString(data.round) ?? observation.round ?? null;
     const amount = readString(data.amount);
@@ -351,10 +356,55 @@ function roundState(observation: Observation, reason: CaseReason): CaseState {
                 common,
             );
         }
+        if (execution) {
+            return state(
+                'resolved',
+                'normal',
+                `Round executed · ${formatAztec(amount)} AZTEC requested`,
+                'The execution receipt was inspected and contains no Rollup Slashed log for this sequencer.',
+                reason,
+                false,
+                common,
+            );
+        }
+        const receiptStatus = readString(data.executionReceiptStatus);
+        if (receiptStatus === 'scanning') {
+            return state(
+                'executed',
+                'critical',
+                `Round executed · ${formatAztec(amount)} AZTEC requested`,
+                'Contract state marks this round executed. This page is scanning for its execution receipt.',
+                reason,
+                false,
+                common,
+            );
+        }
+        if (receiptStatus === 'paused') {
+            return state(
+                'executed',
+                'critical',
+                `Round executed · ${formatAztec(amount)} AZTEC requested`,
+                'Contract state marks this round executed. The RPC paused before this page located its execution receipt.',
+                reason,
+                false,
+                common,
+            );
+        }
+        if (receiptStatus === 'unavailable') {
+            return state(
+                'executed',
+                'critical',
+                `Round executed · ${formatAztec(amount)} AZTEC requested`,
+                'Contract state marks this round executed, but its receipt was not found inside the completed history window.',
+                reason,
+                false,
+                common,
+            );
+        }
         return state(
             'executed',
             'critical',
-            'Slashing round executed',
+            `Round executed · ${formatAztec(amount)} AZTEC requested`,
             'The action payload was called. A Rollup Slashed log is still required to confirm this sequencer’s deduction.',
             reason,
             false,

shared/protocol/types.ts

@@ -7,6 +7,7 @@ export type ObservationKind =
     | 'inactivity_epoch'
     | 'node_offense'
     | 'l1_round'
+    | 'l1_execution'
     | 'l1_slash'
     | 'stake_status';
 

src/components/CaseFeed.tsx

@@ -16,7 +16,6 @@ export function CaseFeed({
     cases,
     protocol,
     selectedCaseId,
-    evidenceMode,
     onOpenProtocolGuide,
 }: {
     cases: SlashingCase[];
@@ -38,12 +37,6 @@ export function CaseFeed({
                     <h2 className="text-3xl font-black text-whisper-white">
                         Case feed
                     </h2>
-                    <p className="mt-2 max-w-4xl text-sm font-bold text-whisper-white/70">
-                        {evidenceMode === 'backend'
-                            ? 'Node evidence and L1 status from PINGME.'
-                            : 'L1 votes, candidates, execution, and stake outcomes from this browser.'}
-                        {' '}Open cases are followed by recent execution outcomes.
-                    </p>
                 </div>
                 <div className="w-full sm:w-auto sm:min-w-72">
                     <span className="block w-fit border-3 border-brand-black bg-vermillion px-3 py-2 text-sm font-black uppercase text-brand-black sm:ml-auto">
@@ -149,7 +142,7 @@ function PayloadCaseGroup({
                             {group.payloadAddress
                                 ? `${sequencerCount} sequencer${sequencerCount === 1 ? '' : 's'} targeted${
                                     requestedAmount !== null
-                                        ? ` · ${formatAztec(requestedAmount)} AZTEC requested`
+                                        ? ` · ${formatAztec(requestedAmount)} AZTEC`
                                         : ''
                                 }`
                                 : primary.state.headline}

src/components/Dashboard.tsx

@@ -15,7 +15,10 @@ import { selectCaseFeed } from '@/lib/caseFeed';
 import { urlForWatchlist } from '@/lib/navigation';
 import { summarizeNetwork } from '../../shared/protocol/index.ts';
 import { useSlashingStore } from '@/store/slashingStore';
-import type { MonitorConfigInput } from '@/types/slashing';
+import type {
+    ExecutionHistoryScan,
+    MonitorConfigInput,
+} from '@/types/slashing';
 import type { ProtocolSnapshot } from '../../shared/protocol/index.ts';
 
 interface DashboardProps {
@@ -58,7 +61,9 @@ export function Dashboard({
             config: store.config,
             state: store,
             slashings: [...store.detectedSlashings.values()],
+            confirmedExecutions: store.confirmedExecutions,
             confirmedSlashes: store.confirmedSlashes,
+            executionScan: store.executionScan,
         });
     })();
 
@@ -200,7 +205,9 @@ export function Dashboard({
                 />
             )}
 
-            {store.isScanning && (
+            {store.executionScan.status !== 'idle' ? (
+                <ExecutionHistoryStatus scan={store.executionScan} />
+            ) : store.isScanning && (
                 <div className="mb-8 border-5 border-aqua bg-lapis p-5 shadow-brutal-aqua">
                     <p className="font-black uppercase text-aqua">
                         Scanning live and historical slashing rounds…
@@ -239,16 +246,6 @@ export function Dashboard({
                 ))}
             </div>
 
-            {addresses.length === 0 && (
-                <section className="mb-8 border-5 border-orchid bg-aubergine p-6 shadow-brutal-orchid">
-                    <h2 className="text-2xl font-black text-orchid">Add an address above</h2>
-                    <p className="mt-2 text-sm font-bold text-whisper-white/75">
-                        The network overview is public. Address cards make the protocol
-                        path actionable for your own sequencers.
-                    </p>
-                </section>
-            )}
-
             {projected && (
                 <CaseFeed
                     cases={projected.cases}
@@ -261,3 +258,61 @@ export function Dashboard({
         </main>
     );
 }
+
+function ExecutionHistoryStatus({ scan }: { scan: ExecutionHistoryScan }) {
+    const percentage = scan.totalBlocks === 0n
+        ? 100
+        : Math.min(
+            100,
+            Number(scan.scannedBlocks * 10_000n / scan.totalBlocks) / 100,
+        );
+    const complete = scan.status === 'complete';
+    const paused = scan.status === 'paused';
+    return (
+        <section className={`mb-8 border-5 p-4 ${
+            complete
+                ? 'border-chartreuse bg-malachite shadow-brutal-chartreuse'
+                : paused
+                    ? 'border-orchid bg-aubergine shadow-brutal-orchid'
+                    : 'border-aqua bg-lapis shadow-brutal-aqua'
+        }`}>
+            <div className="flex flex-wrap items-center justify-between gap-2">
+                <h2 className={`text-lg font-black ${
+                    complete
+                        ? 'text-chartreuse'
+                        : paused ? 'text-orchid' : 'text-aqua'
+                }`}>
+                    {complete
+                        ? 'Execution history complete'
+                        : paused
+                            ? 'Execution history paused'
+                            : 'Scanning execution history'}
+                </h2>
+                <span className="font-mono text-xs font-black text-whisper-white/65">
+                    {scan.scannedBlocks.toString()} / {scan.totalBlocks.toString()} blocks
+                </span>
+            </div>
+            <div
+                role="progressbar"
+                aria-label="Execution history scan coverage"
+                aria-valuemin={0}
+                aria-valuemax={100}
+                aria-valuenow={percentage}
+                className="mt-3 h-4 border-3 border-whisper-white/40 bg-brand-black"
+            >
+                <div
+                    className={`h-full ${
+                        complete
+                            ? 'bg-chartreuse'
+                            : paused ? 'bg-orchid' : 'bg-aqua'
+                    }`}
+                    style={{ width: `${percentage}%` }}
+                />
+            </div>
+            <p className="mt-2 text-xs font-bold text-whisper-white/65">
+                RPC chunk {scan.chunkSize.toString()} blocks
+                {paused ? ' · The next refresh will retry, or you can use another RPC.' : ''}
+            </p>
+        </section>
+    );
+}

src/components/Header.tsx

@@ -22,7 +22,7 @@ export function Header({
             </div>
             <div className="min-w-0">
               <h1 className="text-2xl font-black text-chartreuse tracking-tight sm:text-3xl">AZTEC SLASHING MONITOR</h1>
-              <p className="text-xs text-aqua font-bold uppercase tracking-wider sm:text-sm">Early warning · exact L1 status · operator education</p>
+              <p className="text-xs text-aqua font-bold uppercase tracking-wider sm:text-sm">Early warning · exact L1 status · operator info</p>
             </div>
           </div>
 

src/components/MonitorDetails.tsx

@@ -117,8 +117,8 @@ export function MonitorDetails({ configInput, network, onResetRpc, onToggleNetwo
                 <MetadataSection title="Deployment">
                     <Metadata label="Chain ID" value={configInput.chainId.toString()} />
                     <Metadata label="Registry" value={configInput.registryAddress} />
-                    <Metadata label="Resolved at block" value={config?.deploymentBlockNumber.toString() ?? unavailable} />
-                    <Metadata label="Resolved at time" value={formatTimestamp(config?.deploymentTimestamp, unavailable)} />
+                    <Metadata label="Resolved at block" value={config?.resolvedAtBlockNumber.toString() ?? unavailable} />
+                    <Metadata label="Resolved at time" value={formatTimestamp(config?.resolvedAtTimestamp, unavailable)} />
                     <Metadata label="Rollup" value={config?.rollupAddress ?? unavailable} />
                     <Metadata label="Rollup version" value={config?.rollupVersion.toString() ?? unavailable} />
                     <Metadata label="Active Slasher" value={config?.slasherAddress ?? unavailable} />