@aztec/slasher 0.0.1-commit.f504929 → 0.0.1-commit.f5a9928

package/dest/factory/get_settings.js

@@ -1,8 +1,8 @@
-export async function getTallySlasherSettings(rollup, slashingProposer) {
+export async function getSlasherSettings(rollup, slashingProposer) {
     if (!slashingProposer) {
         const rollupSlashingProposer = await rollup.getSlashingProposer();
-        if (!rollupSlashingProposer || rollupSlashingProposer.type !== 'tally') {
-            throw new Error('Rollup slashing proposer is not of type tally');
+        if (!rollupSlashingProposer) {
+            throw new Error('Rollup slashing proposer not found');
         }
         slashingProposer = rollupSlashingProposer;
     }

package/dest/factory/index.d.ts

@@ -1,3 +1,3 @@
 export { createSlasherFacade as createSlasher } from './create_facade.js';
-export { getTallySlasherSettings } from './get_settings.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mYWN0b3J5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxtQkFBbUIsSUFBSSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUMxRSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQyJ9
+export { getSlasherSettings } from './get_settings.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mYWN0b3J5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxtQkFBbUIsSUFBSSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUMxRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQyJ9

package/dest/factory/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/factory/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/factory/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC"}

package/dest/factory/index.js

@@ -1,2 +1,2 @@
 export { createSlasherFacade as createSlasher } from './create_facade.js';
-export { getTallySlasherSettings } from './get_settings.js';
+export { getSlasherSettings } from './get_settings.js';

package/dest/generated/slasher-defaults.d.ts

@@ -1,21 +1,21 @@
 /** Default slasher configuration values from network-defaults.yml */
 export declare const slasherDefaultEnv: {
-    readonly SLASH_MIN_PENALTY_PERCENTAGE: 0.5;
-    readonly SLASH_MAX_PENALTY_PERCENTAGE: 2;
     readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
     readonly SLASH_MAX_PAYLOAD_SIZE: 80;
     readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
-    readonly SLASH_PRUNE_PENALTY: 10000000000000000000;
     readonly SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000;
+    readonly SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3;
     readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9;
     readonly SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1;
     readonly SLASH_INACTIVITY_PENALTY: 10000000000000000000;
     readonly SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000;
-    readonly SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000;
+    readonly SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000;
+    readonly SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 10000000000000000000;
     readonly SLASH_DUPLICATE_PROPOSAL_PENALTY: 0;
     readonly SLASH_DUPLICATE_ATTESTATION_PENALTY: 0;
     readonly SLASH_UNKNOWN_PENALTY: 10000000000000000000;
     readonly SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000;
+    readonly SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0;
     readonly SLASH_GRACE_PERIOD_L2_SLOTS: 0;
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xhc2hlci1kZWZhdWx0cy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2dlbmVyYXRlZC9zbGFzaGVyLWRlZmF1bHRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLHFFQUFxRTtBQUNyRSxlQUFPLE1BQU0saUJBQWlCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0FrQnBCLENBQUMifQ==

package/dest/generated/slasher-defaults.js

@@ -1,21 +1,21 @@
 // Auto-generated from spartan/environments/network-defaults.yml
 // Do not edit manually - run yarn generate to regenerate
 /** Default slasher configuration values from network-defaults.yml */ export const slasherDefaultEnv = {
-    SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
-    SLASH_MAX_PENALTY_PERCENTAGE: 2,
     SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
     SLASH_MAX_PAYLOAD_SIZE: 80,
     SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
-    SLASH_PRUNE_PENALTY: 10000000000000000000,
     SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
+    SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3,
     SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
     SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
     SLASH_INACTIVITY_PENALTY: 10000000000000000000,
     SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
-    SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
+    SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
+    SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 10000000000000000000,
     SLASH_DUPLICATE_PROPOSAL_PENALTY: 0,
     SLASH_DUPLICATE_ATTESTATION_PENALTY: 0,
     SLASH_UNKNOWN_PENALTY: 10000000000000000000,
     SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+    SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0,
     SLASH_GRACE_PERIOD_L2_SLOTS: 0
 };

package/dest/index.d.ts

@@ -1,11 +1,13 @@
 export * from './config.js';
-export * from './watchers/epoch_prune_watcher.js';
+export * from './watchers/data_withholding_watcher.js';
 export * from './watchers/attestations_block_watcher.js';
-export * from './empire_slasher_client.js';
-export * from './tally_slasher_client.js';
+export * from './watchers/attested_invalid_proposal_watcher.js';
+export * from './watchers/broadcasted_invalid_checkpoint_proposal_watcher.js';
+export * from './watchers/checkpoint_equivocation_watcher.js';
+export * from './slasher_client.js';
 export * from './slash_offenses_collector.js';
 export * from './slasher_client_interface.js';
 export * from './factory/index.js';
 export * from './watcher.js';
 export * from '@aztec/stdlib/slashing';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsd0JBQXdCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLHdDQUF3QyxDQUFDO0FBQ3ZELGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLCtEQUErRCxDQUFDO0FBQzlFLGNBQWMsK0NBQStDLENBQUM7QUFDOUQsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLHdCQUF3QixDQUFDIn0=

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,mCAAmC,CAAC;AAClD,cAAc,0CAA0C,CAAC;AACzD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,iDAAiD,CAAC;AAChE,cAAc,+DAA+D,CAAC;AAC9E,cAAc,+CAA+C,CAAC;AAC9D,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,wBAAwB,CAAC"}

package/dest/index.js

@@ -1,8 +1,10 @@
 export * from './config.js';
-export * from './watchers/epoch_prune_watcher.js';
+export * from './watchers/data_withholding_watcher.js';
 export * from './watchers/attestations_block_watcher.js';
-export * from './empire_slasher_client.js';
-export * from './tally_slasher_client.js';
+export * from './watchers/attested_invalid_proposal_watcher.js';
+export * from './watchers/broadcasted_invalid_checkpoint_proposal_watcher.js';
+export * from './watchers/checkpoint_equivocation_watcher.js';
+export * from './slasher_client.js';
 export * from './slash_offenses_collector.js';
 export * from './slasher_client_interface.js';
 export * from './factory/index.js';

package/dest/metrics.d.ts

@@ -0,0 +1,23 @@
+import { type TelemetryClient } from '@aztec/telemetry-client';
+export declare class SlasherMetrics {
+    private readonly roundExecuted;
+    private readonly ownValidatorTargeted;
+    private readonly ownValidatorSlashedCount;
+    private readonly ownValidatorSlashedAmount;
+    private readonly ownValidatorCurrentRoundVotesMax;
+    private readonly quorumSize;
+    constructor(client: TelemetryClient, name?: string);
+    recordRoundExecuted(): void;
+    /** Records the quorum a validator must reach in a round to be slashed, so dashboards can plot the threshold. */
+    recordQuorumSize(quorum: number): void;
+    /** Records that an onchain slashing vote named one of the node's own validators as a target. */
+    recordOwnValidatorTargeted(): void;
+    /**
+     * Records how close the most-voted committee position held by the node's own validators is to quorum this round.
+     * Recorded as an absolute value rather than a delta so a vote seen across a round rollover cannot make it drift.
+     */
+    recordCurrentRoundVotesMax(votes: number): void;
+    /** Records an executed slash against one of the node's own validators. */
+    recordOwnValidatorSlashed(amount: bigint): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0cmljcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL21ldHJpY3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUdMLEtBQUssZUFBZSxFQUdyQixNQUFNLHlCQUF5QixDQUFDO0FBSWpDLHFCQUFhLGNBQWM7SUFDekIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxhQUFhLENBQWdCO0lBQzlDLE9BQU8sQ0FBQyxRQUFRLENBQUMsb0JBQW9CLENBQWdCO0lBQ3JELE9BQU8sQ0FBQyxRQUFRLENBQUMsd0JBQXdCLENBQWdCO0lBQ3pELE9BQU8sQ0FBQyxRQUFRLENBQUMseUJBQXlCLENBQWdCO0lBQzFELE9BQU8sQ0FBQyxRQUFRLENBQUMsZ0NBQWdDLENBQVE7SUFDekQsT0FBTyxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQVE7SUFFbkMsWUFBWSxNQUFNLEVBQUUsZUFBZSxFQUFFLElBQUksU0FBWSxFQVdwRDtJQUVNLG1CQUFtQixJQUFJLElBQUksQ0FFakM7SUFFRCxnSEFBZ0g7SUFDekcsZ0JBQWdCLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxJQUFJLENBRTVDO0lBRUQsZ0dBQWdHO0lBQ3pGLDBCQUEwQixJQUFJLElBQUksQ0FFeEM7SUFFRDs7O09BR0c7SUFDSSwwQkFBMEIsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FFckQ7SUFFRCwwRUFBMEU7SUFDbkUseUJBQXlCLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxJQUFJLENBR3JEO0NBQ0YifQ==

package/dest/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../src/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAIjC,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAgB;IACrD,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAgB;IACzD,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAgB;IAC1D,OAAO,CAAC,QAAQ,CAAC,gCAAgC,CAAQ;IACzD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IAEnC,YAAY,MAAM,EAAE,eAAe,EAAE,IAAI,SAAY,EAWpD;IAEM,mBAAmB,IAAI,IAAI,CAEjC;IAED,gHAAgH;IACzG,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE5C;IAED,gGAAgG;IACzF,0BAA0B,IAAI,IAAI,CAExC;IAED;;;OAGG;IACI,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAErD;IAED,0EAA0E;IACnE,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAGrD;CACF"}

package/dest/metrics.js

@@ -0,0 +1,38 @@
+import { Metrics, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
+import { formatEther } from 'viem/utils';
+export class SlasherMetrics {
+    roundExecuted;
+    ownValidatorTargeted;
+    ownValidatorSlashedCount;
+    ownValidatorSlashedAmount;
+    ownValidatorCurrentRoundVotesMax;
+    quorumSize;
+    constructor(client, name = 'Slasher'){
+        const meter = client.getMeter(name);
+        this.roundExecuted = createUpDownCounterWithDefault(meter, Metrics.SLASHER_ROUND_EXECUTED_COUNT);
+        this.ownValidatorTargeted = createUpDownCounterWithDefault(meter, Metrics.SLASHER_OWN_VALIDATOR_TARGETED_COUNT);
+        this.ownValidatorSlashedCount = createUpDownCounterWithDefault(meter, Metrics.SLASHER_OWN_VALIDATOR_SLASHED_COUNT);
+        this.ownValidatorSlashedAmount = createUpDownCounterWithDefault(meter, Metrics.SLASHER_OWN_VALIDATOR_SLASHED_AMOUNT);
+        this.ownValidatorCurrentRoundVotesMax = meter.createGauge(Metrics.SLASHER_OWN_VALIDATOR_CURRENT_ROUND_VOTES_MAX);
+        this.quorumSize = meter.createGauge(Metrics.SLASHER_QUORUM_SIZE);
+    }
+    recordRoundExecuted() {
+        this.roundExecuted.add(1);
+    }
+    /** Records the quorum a validator must reach in a round to be slashed, so dashboards can plot the threshold. */ recordQuorumSize(quorum) {
+        this.quorumSize.record(quorum);
+    }
+    /** Records that an onchain slashing vote named one of the node's own validators as a target. */ recordOwnValidatorTargeted() {
+        this.ownValidatorTargeted.add(1);
+    }
+    /**
+   * Records how close the most-voted committee position held by the node's own validators is to quorum this round.
+   * Recorded as an absolute value rather than a delta so a vote seen across a round rollover cannot make it drift.
+   */ recordCurrentRoundVotesMax(votes) {
+        this.ownValidatorCurrentRoundVotesMax.record(votes);
+    }
+    /** Records an executed slash against one of the node's own validators. */ recordOwnValidatorSlashed(amount) {
+        this.ownValidatorSlashedCount.add(1);
+        this.ownValidatorSlashedAmount.add(parseFloat(formatEther(amount)));
+    }
+}

package/dest/null_slasher_client.d.ts

@@ -1,5 +1,5 @@
 import type { SlotNumber } from '@aztec/foundation/branded-types';
-import type { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
+import type { Offense, ProposerSlashAction } from '@aztec/stdlib/slashing';
 import type { SlasherConfig } from './config.js';
 import type { SlasherClientInterface } from './slasher_client_interface.js';
 export declare class NullSlasherClient implements SlasherClientInterface {
@@ -7,11 +7,10 @@ export declare class NullSlasherClient implements SlasherClientInterface {
     constructor(config: SlasherConfig);
     start(): Promise<void>;
     stop(): Promise<void>;
-    getSlashPayloads(): Promise<SlashPayloadRound[]>;
     gatherOffensesForRound(_round?: bigint): Promise<Offense[]>;
-    getPendingOffenses(): Promise<Offense[]>;
+    getOffenses(): Promise<Offense[]>;
     updateConfig(config: Partial<SlasherConfig>): void;
     getProposerActions(_slotNumber: SlotNumber): Promise<ProposerSlashAction[]>;
     getConfig(): SlasherConfig;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbF9zbGFzaGVyX2NsaWVudC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL251bGxfc2xhc2hlcl9jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbEUsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLGlCQUFpQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFOUYsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ2pELE9BQU8sS0FBSyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFFNUUscUJBQWEsaUJBQWtCLFlBQVcsc0JBQXNCO0lBQ2xELE9BQU8sQ0FBQyxNQUFNO0lBQTFCLFlBQW9CLE1BQU0sRUFBRSxhQUFhLEVBQUk7SUFFdEMsS0FBSyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFNUI7SUFFTSxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUUzQjtJQUVNLGdCQUFnQixJQUFJLE9BQU8sQ0FBQyxpQkFBaUIsRUFBRSxDQUFDLENBRXREO0lBRU0sc0JBQXNCLENBQUMsTUFBTSxDQUFDLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUVqRTtJQUVNLGtCQUFrQixJQUFJLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUU5QztJQUVNLFlBQVksQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLGFBQWEsQ0FBQyxHQUFHLElBQUksQ0FFeEQ7SUFFTSxrQkFBa0IsQ0FBQyxXQUFXLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxtQkFBbUIsRUFBRSxDQUFDLENBRWpGO0lBRU0sU0FBUyxJQUFJLGFBQWEsQ0FFaEM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbF9zbGFzaGVyX2NsaWVudC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL251bGxfc2xhc2hlcl9jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbEUsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFM0UsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ2pELE9BQU8sS0FBSyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFFNUUscUJBQWEsaUJBQWtCLFlBQVcsc0JBQXNCO0lBQ2xELE9BQU8sQ0FBQyxNQUFNO0lBQTFCLFlBQW9CLE1BQU0sRUFBRSxhQUFhLEVBQUk7SUFFdEMsS0FBSyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFNUI7SUFFTSxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUUzQjtJQUVNLHNCQUFzQixDQUFDLE1BQU0sQ0FBQyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FFakU7SUFFTSxXQUFXLElBQUksT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBRXZDO0lBRU0sWUFBWSxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsYUFBYSxDQUFDLEdBQUcsSUFBSSxDQUV4RDtJQUVNLGtCQUFrQixDQUFDLFdBQVcsRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUFDLG1CQUFtQixFQUFFLENBQUMsQ0FFakY7SUFFTSxTQUFTLElBQUksYUFBYSxDQUVoQztDQUNGIn0=

package/dest/null_slasher_client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"null_slasher_client.d.ts","sourceRoot":"","sources":["../src/null_slasher_client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE9F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E,qBAAa,iBAAkB,YAAW,sBAAsB;IAClD,OAAO,CAAC,MAAM;IAA1B,YAAoB,MAAM,EAAE,aAAa,EAAI;IAEtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE5B;IAEM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;IAEM,gBAAgB,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAEtD;IAEM,sBAAsB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAEjE;IAEM,kBAAkB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAE9C;IAEM,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAExD;IAEM,kBAAkB,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAEjF;IAEM,SAAS,IAAI,aAAa,CAEhC;CACF"}
+{"version":3,"file":"null_slasher_client.d.ts","sourceRoot":"","sources":["../src/null_slasher_client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE3E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E,qBAAa,iBAAkB,YAAW,sBAAsB;IAClD,OAAO,CAAC,MAAM;IAA1B,YAAoB,MAAM,EAAE,aAAa,EAAI;IAEtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE5B;IAEM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;IAEM,sBAAsB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAEjE;IAEM,WAAW,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAEvC;IAEM,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAExD;IAEM,kBAAkB,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAEjF;IAEM,SAAS,IAAI,aAAa,CAEhC;CACF"}

package/dest/null_slasher_client.js

@@ -9,13 +9,10 @@ export class NullSlasherClient {
     stop() {
         return Promise.resolve();
     }
-    getSlashPayloads() {
-        return Promise.resolve([]);
-    }
     gatherOffensesForRound(_round) {
         return Promise.resolve([]);
     }
-    getPendingOffenses() {
+    getOffenses() {
         return Promise.resolve([]);
     }
     updateConfig(config) {

package/dest/own_validator_slash_monitor.d.ts

@@ -0,0 +1,66 @@
+import type { SlashingProposerContract } from '@aztec/ethereum/contracts';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Hex } from 'viem';
+import type { SlasherMetrics } from './metrics.js';
+/**
+ * Watches slashing activity that targets the node's own validators: warns and counts on every vote naming one of
+ * them, tracks how close the current round's tally is to quorum, and reports executed slashes. Does nothing when
+ * the node runs no validators. Lifecycle calls must be sequential: start() awaited before events are wired, and
+ * stop() awaited before any restart.
+ */
+export declare class OwnValidatorSlashMonitor {
+    private readonly slashingProposer;
+    private readonly settings;
+    private readonly ownValidators;
+    private readonly metrics;
+    private readonly log;
+    /**
+     * Tally for the single round being tracked (votes are only ever cast for the current round). `nextVoteIndex` is
+     * the cursor: the index of the first vote in the round not yet processed. It is undefined until the startup
+     * baseline read completes; if that read fails, the first event falls back to counting from the latest vote only,
+     * so votes cast before the node subscribed are never replayed into the cumulative metrics.
+     * The tally is per flattened committee position because that is the unit the contract tallies quorum by.
+     */
+    private state;
+    /**
+     * All vote processing (including the startup baseline) runs through this queue, one job at a time in arrival
+     * order. Serialization is what makes the cursor sound: without it, concurrent event handlers could process the
+     * same index twice or emit warnings with out-of-order running tallies. Replaced on every start(), since a queue
+     * that has been ended cannot run jobs again.
+     */
+    private queue;
+    private stopped;
+    constructor(slashingProposer: SlashingProposerContract, settings: {
+        slashingQuorumSize: number;
+    }, ownValidators: EthAddress[], metrics: SlasherMetrics, log?: import("@aztec/foundation/log").Logger);
+    private get enabled();
+    /**
+     * Starts tracking at the given round. Reads a baseline of the round's current vote count so votes cast before
+     * startup are skipped: replaying them would warn about votes the operator can no longer react to sooner, and
+     * would double-count cumulative counters across restarts. Await the returned promise before subscribing to vote
+     * events, so a vote cast after the baseline read always sits at an index past the cursor and is caught up by a
+     * later drain instead of being skipped as pre-startup. A failed baseline read resolves rather than rejects, and
+     * the first drain falls back to processing the latest vote only.
+     */
+    start(currentRound: bigint): Promise<void>;
+    /** Stops processing and waits for any in-flight drain, so no warning or metric is emitted after shutdown. */
+    stop(): Promise<void>;
+    /**
+     * Called by the round monitor clock. Strictly greater so the clock catching up to a round an event already rolled
+     * to keeps the tally.
+     */
+    handleNewRound(round: bigint): void;
+    /** Called on each VoteCast event. The event is only a trigger: the drain reads all not-yet-seen votes from L1. */
+    handleVoteCast(round: bigint): Promise<void>;
+    /** Reports executed slashes against own validators. Called with the Slashed events already fetched by the client. */
+    handleSlashes(round: bigint, slashes: {
+        attester: EthAddress;
+        amount: bigint;
+    }[], l1BlockHash: Hex): void;
+    private drainVotes;
+    private processVote;
+    /** Starts a fresh tally, zeroing the gauge so a quiet round does not keep the previous round's value. */
+    private rollTo;
+    private isOwnValidator;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3duX3ZhbGlkYXRvcl9zbGFzaF9tb25pdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvb3duX3ZhbGlkYXRvcl9zbGFzaF9tb25pdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFtQix3QkFBd0IsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRzNGLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBSWhFLE9BQU8sS0FBSyxFQUFFLEdBQUcsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUVoQyxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFbkQ7Ozs7O0dBS0c7QUFDSCxxQkFBYSx3QkFBd0I7SUF5QmpDLE9BQU8sQ0FBQyxRQUFRLENBQUMsZ0JBQWdCO0lBQ2pDLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUTtJQUN6QixPQUFPLENBQUMsUUFBUSxDQUFDLGFBQWE7SUFDOUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxPQUFPO0lBQ3hCLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRztJQTVCdEI7Ozs7OztPQU1HO0lBQ0gsT0FBTyxDQUFDLEtBQUssQ0FJWDtJQUVGOzs7OztPQUtHO0lBQ0gsT0FBTyxDQUFDLEtBQUssQ0FBcUI7SUFFbEMsT0FBTyxDQUFDLE9BQU8sQ0FBUztJQUV4QixZQUNtQixnQkFBZ0IsRUFBRSx3QkFBd0IsRUFDMUMsUUFBUSxFQUFFO1FBQUUsa0JBQWtCLEVBQUUsTUFBTSxDQUFBO0tBQUUsRUFDeEMsYUFBYSxFQUFFLFVBQVUsRUFBRSxFQUMzQixPQUFPLEVBQUUsY0FBYyxFQUN2QixHQUFHLHlDQUF5QyxFQUc5RDtJQUVELE9BQU8sS0FBSyxPQUFPLEdBRWxCO0lBRUQ7Ozs7Ozs7T0FPRztJQUNJLEtBQUssQ0FBQyxZQUFZLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FtQmhEO0lBRUQsNkdBQTZHO0lBQ2hHLElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBS2pDO0lBRUQ7OztPQUdHO0lBQ0ksY0FBYyxDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsSUFBSSxDQUl6QztJQUVELGtIQUFrSDtJQUMzRyxjQUFjLENBQUMsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBU2xEO0lBRUQscUhBQXFIO0lBQzlHLGFBQWEsQ0FBQyxLQUFLLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRTtRQUFFLFFBQVEsRUFBRSxVQUFVLENBQUM7UUFBQyxNQUFNLEVBQUUsTUFBTSxDQUFBO0tBQUUsRUFBRSxFQUFFLFdBQVcsRUFBRSxHQUFHLEdBQUcsSUFBSSxDQWEvRztZQUdhLFVBQVU7SUE2QnhCLE9BQU8sQ0FBQyxXQUFXO0lBd0JuQix5R0FBeUc7SUFDekcsT0FBTyxDQUFDLE1BQU07SUFNZCxPQUFPLENBQUMsY0FBYztDQUd2QiJ9

package/dest/own_validator_slash_monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"own_validator_slash_monitor.d.ts","sourceRoot":"","sources":["../src/own_validator_slash_monitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAG3F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAIhE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEhC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD;;;;;GAKG;AACH,qBAAa,wBAAwB;IAyBjC,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,GAAG;IA5BtB;;;;;;OAMG;IACH,OAAO,CAAC,KAAK,CAIX;IAEF;;;;;OAKG;IACH,OAAO,CAAC,KAAK,CAAqB;IAElC,OAAO,CAAC,OAAO,CAAS;IAExB,YACmB,gBAAgB,EAAE,wBAAwB,EAC1C,QAAQ,EAAE;QAAE,kBAAkB,EAAE,MAAM,CAAA;KAAE,EACxC,aAAa,EAAE,UAAU,EAAE,EAC3B,OAAO,EAAE,cAAc,EACvB,GAAG,yCAAyC,EAG9D;IAED,OAAO,KAAK,OAAO,GAElB;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBhD;IAED,6GAA6G;IAChG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAKjC;IAED;;;OAGG;IACI,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAIzC;IAED,kHAAkH;IAC3G,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CASlD;IAED,qHAAqH;IAC9G,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,QAAQ,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,EAAE,WAAW,EAAE,GAAG,GAAG,IAAI,CAa/G;YAGa,UAAU;IA6BxB,OAAO,CAAC,WAAW;IAwBnB,yGAAyG;IACzG,OAAO,CAAC,MAAM;IAMd,OAAO,CAAC,cAAc;CAGvB"}

package/dest/own_validator_slash_monitor.js

@@ -0,0 +1,172 @@
+import { maxBigint } from '@aztec/foundation/bigint';
+import { uniqueBy } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+/**
+ * Watches slashing activity that targets the node's own validators: warns and counts on every vote naming one of
+ * them, tracks how close the current round's tally is to quorum, and reports executed slashes. Does nothing when
+ * the node runs no validators. Lifecycle calls must be sequential: start() awaited before events are wired, and
+ * stop() awaited before any restart.
+ */ export class OwnValidatorSlashMonitor {
+    slashingProposer;
+    settings;
+    ownValidators;
+    metrics;
+    log;
+    /**
+   * Tally for the single round being tracked (votes are only ever cast for the current round). `nextVoteIndex` is
+   * the cursor: the index of the first vote in the round not yet processed. It is undefined until the startup
+   * baseline read completes; if that read fails, the first event falls back to counting from the latest vote only,
+   * so votes cast before the node subscribed are never replayed into the cumulative metrics.
+   * The tally is per flattened committee position because that is the unit the contract tallies quorum by.
+   */ state;
+    /**
+   * All vote processing (including the startup baseline) runs through this queue, one job at a time in arrival
+   * order. Serialization is what makes the cursor sound: without it, concurrent event handlers could process the
+   * same index twice or emit warnings with out-of-order running tallies. Replaced on every start(), since a queue
+   * that has been ended cannot run jobs again.
+   */ queue;
+    stopped;
+    constructor(slashingProposer, settings, ownValidators, metrics, log = createLogger('slasher:own-validators')){
+        this.slashingProposer = slashingProposer;
+        this.settings = settings;
+        this.ownValidators = ownValidators;
+        this.metrics = metrics;
+        this.log = log;
+        this.state = {
+            round: -1n,
+            nextVoteIndex: undefined,
+            countByPosition: new Map()
+        };
+        this.queue = new SerialQueue();
+        this.stopped = false;
+        this.queue.start();
+    }
+    get enabled() {
+        return this.ownValidators.length > 0;
+    }
+    /**
+   * Starts tracking at the given round. Reads a baseline of the round's current vote count so votes cast before
+   * startup are skipped: replaying them would warn about votes the operator can no longer react to sooner, and
+   * would double-count cumulative counters across restarts. Await the returned promise before subscribing to vote
+   * events, so a vote cast after the baseline read always sits at an index past the cursor and is caught up by a
+   * later drain instead of being skipped as pre-startup. A failed baseline read resolves rather than rejects, and
+   * the first drain falls back to processing the latest vote only.
+   */ start(currentRound) {
+        if (!this.enabled) {
+            return Promise.resolve();
+        }
+        this.stopped = false;
+        this.queue = new SerialQueue();
+        this.queue.start();
+        this.state = {
+            round: currentRound,
+            nextVoteIndex: undefined,
+            countByPosition: new Map()
+        };
+        this.metrics.recordQuorumSize(this.settings.slashingQuorumSize);
+        this.metrics.recordCurrentRoundVotesMax(0);
+        return this.queue.put(async ()=>{
+            const { voteCount } = await this.slashingProposer.getRound(currentRound);
+            // The round may have rolled while awaiting, in which case the cursor is already 0 for the new round
+            if (!this.stopped && this.state.round === currentRound && this.state.nextVoteIndex === undefined) {
+                this.state.nextVoteIndex = voteCount;
+            }
+        }).catch((err)=>this.log.error('Error processing slashing votes', err));
+    }
+    /** Stops processing and waits for any in-flight drain, so no warning or metric is emitted after shutdown. */ async stop() {
+        this.stopped = true;
+        // Jobs already queued are no-ops now that the flag is set, so end() runs through them at no cost while still
+        // settling the promises their callers hold, where cancel() would discard them and leave those promises pending.
+        await this.queue.end();
+    }
+    /**
+   * Called by the round monitor clock. Strictly greater so the clock catching up to a round an event already rolled
+   * to keeps the tally.
+   */ handleNewRound(round) {
+        if (this.enabled && round > this.state.round) {
+            this.rollTo(round);
+        }
+    }
+    /** Called on each VoteCast event. The event is only a trigger: the drain reads all not-yet-seen votes from L1. */ handleVoteCast(round) {
+        if (!this.enabled || this.stopped) {
+            return Promise.resolve();
+        }
+        // Errors are logged rather than propagated: callers fire and forget, and a failed read is retried by the drain
+        // the next event triggers.
+        return this.queue.put(()=>this.drainVotes(round)).catch((err)=>this.log.error('Error processing slashing votes', err));
+    }
+    /** Reports executed slashes against own validators. Called with the Slashed events already fetched by the client. */ handleSlashes(round, slashes, l1BlockHash) {
+        if (!this.enabled || this.stopped) {
+            return;
+        }
+        for (const { attester, amount } of slashes.filter((slash)=>this.isOwnValidator(slash.attester))){
+            this.log.warn(`Own validator ${attester} was slashed for ${amount}`, {
+                round,
+                validator: attester.toString(),
+                amount,
+                l1BlockHash
+            });
+            this.metrics.recordOwnValidatorSlashed(amount);
+        }
+    }
+    /** Processes votes [cursor, voteCount) of a round, in order, advancing the cursor after each success. */ async drainVotes(round) {
+        if (this.stopped) {
+            return; // enqueued before stop() but not yet started: emit nothing and read nothing after shutdown
+        }
+        if (round < this.state.round) {
+            return; // a vote for a round that already closed can no longer reach quorum
+        }
+        if (round > this.state.round) {
+            this.rollTo(round); // the event beat the round-monitor clock to the boundary
+        }
+        const { voteCount } = await this.slashingProposer.getRound(round);
+        if (this.stopped || round !== this.state.round) {
+            return; // stopped, or rolled to a newer round while awaiting
+        }
+        // If the startup baseline failed, start from the latest vote only: earlier votes predate the subscription
+        const from = this.state.nextVoteIndex ?? maxBigint(voteCount - 1n, 0n);
+        for(let index = from; index < voteCount; index++){
+            const vote = await this.slashingProposer.getVoteAt(round, index);
+            if (this.stopped || round !== this.state.round) {
+                return; // stopped, or rolled mid-drain: either way this vote must no longer be counted
+            }
+            this.processVote(round, vote);
+            // Advanced only after successful processing, so a failed read is retried on the next event
+            this.state.nextVoteIndex = index + 1n;
+        }
+    }
+    processVote(round, vote) {
+        const own = vote.filter((target)=>this.isOwnValidator(target.validator));
+        for (const { position } of own){
+            this.state.countByPosition.set(position, (this.state.countByPosition.get(position) ?? 0) + 1);
+        }
+        // Warn once per (vote, validator) at the validator's highest position tally: the operator cares about the
+        // validator, not which of its committee seats is being voted on. No slash amount (the amount voted is not
+        // necessarily the amount slashed) and no proposer (a catch-up drain cannot attribute votes to proposers).
+        const quorum = this.settings.slashingQuorumSize;
+        for (const { validator } of uniqueBy(own, (target)=>target.validator.toString())){
+            const votes = Math.max(...own.filter((t)=>t.validator.equals(validator)).map((t)=>this.state.countByPosition.get(t.position)));
+            this.metrics.recordOwnValidatorTargeted();
+            this.log.warn(`Own validator ${validator} targeted by slashing vote (${votes} of ${quorum} votes needed to slash)`, {
+                round,
+                validator: validator.toString(),
+                votes,
+                quorum
+            });
+        }
+        this.metrics.recordCurrentRoundVotesMax(Math.max(0, ...this.state.countByPosition.values()));
+    }
+    /** Starts a fresh tally, zeroing the gauge so a quiet round does not keep the previous round's value. */ rollTo(round) {
+        this.state = {
+            round,
+            nextVoteIndex: 0n,
+            countByPosition: new Map()
+        };
+        this.metrics.recordCurrentRoundVotesMax(0);
+        this.metrics.recordQuorumSize(this.settings.slashingQuorumSize); // keeps the gauge fresh across export cycles
+    }
+    isOwnValidator(address) {
+        return this.ownValidators.some((validator)=>validator.equals(address));
+    }
+}

package/dest/slash_offenses_collector.d.ts

@@ -2,9 +2,8 @@ import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { Prettify } from '@aztec/foundation/types';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
-import { type OffenseIdentifier } from '@aztec/stdlib/slashing';
 import type { SlasherOffensesStore } from './stores/offenses_store.js';
-import { type WantToSlashArgs, type Watcher } from './watcher.js';
+import { type WantToClearSlashArgs, type WantToSlashArgs, type Watcher } from './watcher.js';
 export type SlashOffensesCollectorConfig = Prettify<Pick<SlasherConfig, 'slashGracePeriodL2Slots'>>;
 export type SlashOffensesCollectorSettings = Prettify<Pick<L1RollupConstants, 'epochDuration'> & {
     slashingAmounts: [bigint, bigint, bigint] | undefined;
@@ -23,6 +22,7 @@ export declare class SlashOffensesCollector {
     private readonly offensesStore;
     private readonly log;
     private readonly unwatchCallbacks;
+    private readonly storeMutationQueue;
     constructor(config: SlashOffensesCollectorConfig, settings: SlashOffensesCollectorSettings, watchers: Watcher[], offensesStore: SlasherOffensesStore, log?: import("@aztec/foundation/log").Logger);
     start(): Promise<void>;
     stop(): Promise<void>;
@@ -32,17 +32,15 @@ export declare class SlashOffensesCollector {
      * @param args - the arguments from the watcher, including the validators, amounts, and offenses
      */
     handleWantToSlash(args: WantToSlashArgs[]): Promise<void>;
+    handleWantToClearSlash(args: WantToClearSlashArgs[]): Promise<void>;
     /**
      * Triggered on a time basis when we enter a new slashing round.
      * Clears expired offenses from stores.
      */
     handleNewRound(round: bigint): Promise<void>;
-    /**
-     * Marks offenses as slashed (no longer pending)
-     * @param offenses - The offenses to mark as slashed
-     */
-    markAsSlashed(offenses: OffenseIdentifier[]): Promise<void>;
     /** Returns whether to skip an offense if it happened during the grace period after the network upgrade */
     private shouldSkipOffense;
+    private getOffenseLogData;
+    private enqueueStoreMutation;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xhc2hfb2ZmZW5zZXNfY29sbGVjdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvc2xhc2hfb2ZmZW5zZXNfY29sbGVjdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRWxFLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3hELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDckUsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDckUsT0FBTyxFQUFnQixLQUFLLGlCQUFpQixFQUFxQixNQUFNLHdCQUF3QixDQUFDO0FBRWpHLE9BQU8sS0FBSyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDdkUsT0FBTyxFQUF1QixLQUFLLGVBQWUsRUFBRSxLQUFLLE9BQU8sRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUV2RixNQUFNLE1BQU0sNEJBQTRCLEdBQUcsUUFBUSxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUseUJBQXlCLENBQUMsQ0FBQyxDQUFDO0FBQ3BHLE1BQU0sTUFBTSw4QkFBOEIsR0FBRyxRQUFRLENBQ25ELElBQUksQ0FBQyxpQkFBaUIsRUFBRSxlQUFlLENBQUMsR0FBRztJQUN6QyxlQUFlLEVBQUUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxHQUFHLFNBQVMsQ0FBQztJQUN0RCxzSEFBc0g7SUFDdEgsd0JBQXdCLEVBQUUsVUFBVSxDQUFDO0NBQ3RDLENBQ0YsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCxxQkFBYSxzQkFBc0I7SUFJL0IsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNO0lBQ3ZCLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUTtJQUN6QixPQUFPLENBQUMsUUFBUSxDQUFDLFFBQVE7SUFDekIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxhQUFhO0lBQzlCLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRztJQVB0QixPQUFPLENBQUMsUUFBUSxDQUFDLGdCQUFnQixDQUFzQjtJQUV2RCxZQUNtQixNQUFNLEVBQUUsNEJBQTRCLEVBQ3BDLFFBQVEsRUFBRSw4QkFBOEIsRUFDeEMsUUFBUSxFQUFFLE9BQU8sRUFBRSxFQUNuQixhQUFhLEVBQUUsb0JBQW9CLEVBQ25DLEdBQUcseUNBQTZDLEVBQy9EO0lBRUcsS0FBSyxrQkFhWDtJQUVNLElBQUksa0JBU1Y7SUFFRDs7OztPQUlHO0lBQ1UsaUJBQWlCLENBQUMsSUFBSSxFQUFFLGVBQWUsRUFBRSxpQkE2QnJEO0lBRUQ7OztPQUdHO0lBQ1UsY0FBYyxDQUFDLEtBQUssRUFBRSxNQUFNLGlCQUt4QztJQUVEOzs7T0FHRztJQUNJLGFBQWEsQ0FBQyxRQUFRLEVBQUUsaUJBQWlCLEVBQUUsaUJBR2pEO0lBRUQsMEdBQTBHO0lBQzFHLE9BQU8sQ0FBQyxpQkFBaUI7Q0FJMUIifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xhc2hfb2ZmZW5zZXNfY29sbGVjdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvc2xhc2hfb2ZmZW5zZXNfY29sbGVjdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBR2xFLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3hELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDckUsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFHckUsT0FBTyxLQUFLLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUN2RSxPQUFPLEVBR0wsS0FBSyxvQkFBb0IsRUFDekIsS0FBSyxlQUFlLEVBQ3BCLEtBQUssT0FBTyxFQUNiLE1BQU0sY0FBYyxDQUFDO0FBRXRCLE1BQU0sTUFBTSw0QkFBNEIsR0FBRyxRQUFRLENBQUMsSUFBSSxDQUFDLGFBQWEsRUFBRSx5QkFBeUIsQ0FBQyxDQUFDLENBQUM7QUFDcEcsTUFBTSxNQUFNLDhCQUE4QixHQUFHLFFBQVEsQ0FDbkQsSUFBSSxDQUFDLGlCQUFpQixFQUFFLGVBQWUsQ0FBQyxHQUFHO0lBQ3pDLGVBQWUsRUFBRSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLEdBQUcsU0FBUyxDQUFDO0lBQ3RELHNIQUFzSDtJQUN0SCx3QkFBd0IsRUFBRSxVQUFVLENBQUM7Q0FDdEMsQ0FDRixDQUFDO0FBRUY7Ozs7R0FJRztBQUNILHFCQUFhLHNCQUFzQjtJQUsvQixPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07SUFDdkIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxRQUFRO0lBQ3pCLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUTtJQUN6QixPQUFPLENBQUMsUUFBUSxDQUFDLGFBQWE7SUFDOUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHO0lBUnRCLE9BQU8sQ0FBQyxRQUFRLENBQUMsZ0JBQWdCLENBQXNCO0lBQ3ZELE9BQU8sQ0FBQyxRQUFRLENBQUMsa0JBQWtCLENBQXFCO0lBRXhELFlBQ21CLE1BQU0sRUFBRSw0QkFBNEIsRUFDcEMsUUFBUSxFQUFFLDhCQUE4QixFQUN4QyxRQUFRLEVBQUUsT0FBTyxFQUFFLEVBQ25CLGFBQWEsRUFBRSxvQkFBb0IsRUFDbkMsR0FBRyx5Q0FBNkMsRUFDL0Q7SUFFRyxLQUFLLGtCQW1CWDtJQUVZLElBQUksa0JBVWhCO0lBRUQ7Ozs7T0FJRztJQUNVLGlCQUFpQixDQUFDLElBQUksRUFBRSxlQUFlLEVBQUUsaUJBK0JyRDtJQUVZLHNCQUFzQixDQUFDLElBQUksRUFBRSxvQkFBb0IsRUFBRSxpQkFXL0Q7SUFFRDs7O09BR0c7SUFDVSxjQUFjLENBQUMsS0FBSyxFQUFFLE1BQU0saUJBS3hDO0lBRUQsMEdBQTBHO0lBQzFHLE9BQU8sQ0FBQyxpQkFBaUI7SUFLekIsT0FBTyxDQUFDLGlCQUFpQjtJQVF6QixPQUFPLENBQUMsb0JBQW9CO0NBRzdCIn0=

package/dest/slash_offenses_collector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slash_offenses_collector.d.ts","sourceRoot":"","sources":["../src/slash_offenses_collector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAgB,KAAK,iBAAiB,EAAqB,MAAM,wBAAwB,CAAC;AAEjG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAuB,KAAK,eAAe,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvF,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,yBAAyB,CAAC,CAAC,CAAC;AACpG,MAAM,MAAM,8BAA8B,GAAG,QAAQ,CACnD,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,GAAG;IACzC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACtD,sHAAsH;IACtH,wBAAwB,EAAE,UAAU,CAAC;CACtC,CACF,CAAC;AAEF;;;;GAIG;AACH,qBAAa,sBAAsB;IAI/B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,GAAG;IAPtB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;IAEvD,YACmB,MAAM,EAAE,4BAA4B,EACpC,QAAQ,EAAE,8BAA8B,EACxC,QAAQ,EAAE,OAAO,EAAE,EACnB,aAAa,EAAE,oBAAoB,EACnC,GAAG,yCAA6C,EAC/D;IAEG,KAAK,kBAaX;IAEM,IAAI,kBASV;IAED;;;;OAIG;IACU,iBAAiB,CAAC,IAAI,EAAE,eAAe,EAAE,iBA6BrD;IAED;;;OAGG;IACU,cAAc,CAAC,KAAK,EAAE,MAAM,iBAKxC;IAED;;;OAGG;IACI,aAAa,CAAC,QAAQ,EAAE,iBAAiB,EAAE,iBAGjD;IAED,0GAA0G;IAC1G,OAAO,CAAC,iBAAiB;CAI1B"}
+{"version":3,"file":"slash_offenses_collector.d.ts","sourceRoot":"","sources":["../src/slash_offenses_collector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAGlE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAGrE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,OAAO,EACb,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,yBAAyB,CAAC,CAAC,CAAC;AACpG,MAAM,MAAM,8BAA8B,GAAG,QAAQ,CACnD,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,GAAG;IACzC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACtD,sHAAsH;IACtH,wBAAwB,EAAE,UAAU,CAAC;CACtC,CACF,CAAC;AAEF;;;;GAIG;AACH,qBAAa,sBAAsB;IAK/B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,GAAG;IARtB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;IACvD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqB;IAExD,YACmB,MAAM,EAAE,4BAA4B,EACpC,QAAQ,EAAE,8BAA8B,EACxC,QAAQ,EAAE,OAAO,EAAE,EACnB,aAAa,EAAE,oBAAoB,EACnC,GAAG,yCAA6C,EAC/D;IAEG,KAAK,kBAmBX;IAEY,IAAI,kBAUhB;IAED;;;;OAIG;IACU,iBAAiB,CAAC,IAAI,EAAE,eAAe,EAAE,iBA+BrD;IAEY,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,EAAE,iBAW/D;IAED;;;OAGG;IACU,cAAc,CAAC,KAAK,EAAE,MAAM,iBAKxC;IAED,0GAA0G;IAC1G,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,oBAAoB;CAG7B"}