@aztec/slasher 0.0.1-commit.001888fc

package/dest/watchers/epoch_prune_watcher.js

@@ -0,0 +1,176 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { chunkBy, merge, pick } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { L2BlockSourceEvents } from '@aztec/stdlib/block';
+import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { computeCheckpointOutHash } from '@aztec/stdlib/messaging';
+import { OffenseType, getOffenseTypeName } from '@aztec/stdlib/slashing';
+import { ReExFailedTxsError, ReExStateMismatchError, TransactionsNotAvailableError, ValidatorError } from '@aztec/stdlib/validators';
+import EventEmitter from 'node:events';
+import { WANT_TO_SLASH_EVENT } from '../watcher.js';
+const EpochPruneWatcherPenaltiesConfigKeys = [
+    'slashPrunePenalty',
+    'slashDataWithholdingPenalty'
+];
+/**
+ * This watcher is responsible for detecting chain prunes and creating slashing arguments for the committee.
+ * It only wants to slash if:
+ * - the transactions are not available
+ * - OR the archive roots match when re-building all the blocks in the epoch (i.e. the epoch *could* have been proven)
+ */ export class EpochPruneWatcher extends EventEmitter {
+    l2BlockSource;
+    l1ToL2MessageSource;
+    epochCache;
+    txProvider;
+    checkpointsBuilder;
+    log;
+    // Store bound function reference for proper listener removal
+    boundHandlePruneL2Blocks;
+    penalties;
+    constructor(l2BlockSource, l1ToL2MessageSource, epochCache, txProvider, checkpointsBuilder, penalties){
+        super(), this.l2BlockSource = l2BlockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.epochCache = epochCache, this.txProvider = txProvider, this.checkpointsBuilder = checkpointsBuilder, this.log = createLogger('epoch-prune-watcher'), this.boundHandlePruneL2Blocks = this.handlePruneL2Blocks.bind(this);
+        this.penalties = pick(penalties, ...EpochPruneWatcherPenaltiesConfigKeys);
+        this.log.verbose(`EpochPruneWatcher initialized with penalties: valid epoch pruned=${penalties.slashPrunePenalty} data withholding=${penalties.slashDataWithholdingPenalty}`);
+    }
+    start() {
+        this.l2BlockSource.events.on(L2BlockSourceEvents.L2PruneUnproven, this.boundHandlePruneL2Blocks);
+        return Promise.resolve();
+    }
+    stop() {
+        this.l2BlockSource.events.removeListener(L2BlockSourceEvents.L2PruneUnproven, this.boundHandlePruneL2Blocks);
+        return Promise.resolve();
+    }
+    updateConfig(config) {
+        this.penalties = merge(this.penalties, pick(config, ...EpochPruneWatcherPenaltiesConfigKeys));
+        this.log.verbose('EpochPruneWatcher config updated', this.penalties);
+    }
+    handlePruneL2Blocks(event) {
+        const { blocks, epochNumber } = event;
+        void this.processPruneL2Blocks(blocks, epochNumber).catch((err)=>this.log.error('Error processing pruned L2 blocks', err, {
+                epochNumber
+            }));
+    }
+    async emitSlashForEpoch(offense, epochNumber) {
+        const validators = await this.getValidatorsForEpoch(epochNumber);
+        if (validators.length === 0) {
+            this.log.warn(`No validators found for epoch ${epochNumber} (cannot slash for ${getOffenseTypeName(offense)})`);
+            return;
+        }
+        const args = this.validatorsToSlashingArgs(validators, offense, epochNumber);
+        this.log.verbose(`Created slash for ${getOffenseTypeName(offense)} at epoch ${epochNumber}`, args);
+        this.emit(WANT_TO_SLASH_EVENT, args);
+    }
+    async processPruneL2Blocks(blocks, epochNumber) {
+        try {
+            const l1Constants = this.epochCache.getL1Constants();
+            const epochBlocks = blocks.filter((b)=>getEpochAtSlot(b.header.getSlot(), l1Constants) === epochNumber);
+            this.log.info(`Detected chain prune. Validating epoch ${epochNumber} with blocks ${epochBlocks[0]?.number} to ${epochBlocks[epochBlocks.length - 1]?.number}.`, {
+                blocks: epochBlocks.map((b)=>b.toBlockInfo())
+            });
+            await this.validateBlocks(epochBlocks, epochNumber);
+            this.log.info(`Pruned epoch ${epochNumber} was valid. Want to slash committee for not having it proven.`);
+            await this.emitSlashForEpoch(OffenseType.VALID_EPOCH_PRUNED, epochNumber);
+        } catch (error) {
+            if (error instanceof TransactionsNotAvailableError) {
+                this.log.info(`Data for pruned epoch ${epochNumber} was not available. Will want to slash.`, {
+                    message: error.message
+                });
+                await this.emitSlashForEpoch(OffenseType.DATA_WITHHOLDING, epochNumber);
+            } else {
+                this.log.error(`Error while validating pruned epoch ${epochNumber}. Will not want to slash.`, error);
+            }
+        }
+    }
+    async validateBlocks(blocks, epochNumber) {
+        if (blocks.length === 0) {
+            return;
+        }
+        // Sort blocks by block number and group by checkpoint
+        const sortedBlocks = [
+            ...blocks
+        ].sort((a, b)=>a.number - b.number);
+        const blocksByCheckpoint = chunkBy(sortedBlocks, (b)=>b.checkpointNumber);
+        // Get prior checkpoints in the epoch (in case this was a partial prune) to extract the out hashes
+        const priorCheckpointOutHashes = (await this.l2BlockSource.getCheckpointsDataForEpoch(epochNumber)).filter((c)=>c.checkpointNumber < sortedBlocks[0].checkpointNumber).map((c)=>c.checkpointOutHash);
+        let previousCheckpointOutHashes = [
+            ...priorCheckpointOutHashes
+        ];
+        const fork = await this.checkpointsBuilder.getFork(BlockNumber(sortedBlocks[0].header.globalVariables.blockNumber - 1));
+        try {
+            for (const checkpointBlocks of blocksByCheckpoint){
+                await this.validateCheckpoint(checkpointBlocks, previousCheckpointOutHashes, fork);
+                // Compute checkpoint out hash from all blocks in this checkpoint
+                const checkpointOutHash = computeCheckpointOutHash(checkpointBlocks.map((b)=>b.body.txEffects.map((tx)=>tx.l2ToL1Msgs)));
+                previousCheckpointOutHashes = [
+                    ...previousCheckpointOutHashes,
+                    checkpointOutHash
+                ];
+            }
+        } finally{
+            await fork.close();
+        }
+    }
+    async validateCheckpoint(checkpointBlocks, previousCheckpointOutHashes, fork) {
+        const checkpointNumber = checkpointBlocks[0].checkpointNumber;
+        this.log.debug(`Validating pruned checkpoint ${checkpointNumber} with ${checkpointBlocks.length} blocks`);
+        // Get L1ToL2Messages once for the entire checkpoint
+        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
+        // Build checkpoint constants from first block's global variables
+        const gv = checkpointBlocks[0].header.globalVariables;
+        const constants = {
+            chainId: gv.chainId,
+            version: gv.version,
+            slotNumber: gv.slotNumber,
+            timestamp: gv.timestamp,
+            coinbase: gv.coinbase,
+            feeRecipient: gv.feeRecipient,
+            gasFees: gv.gasFees
+        };
+        // Start checkpoint builder once for all blocks in this checkpoint
+        const checkpointBuilder = await this.checkpointsBuilder.startCheckpoint(checkpointNumber, constants, 0n, l1ToL2Messages, previousCheckpointOutHashes, fork, this.log.getBindings());
+        // Validate all blocks in the checkpoint sequentially
+        for (const block of checkpointBlocks){
+            await this.validateBlockInCheckpoint(block, checkpointBuilder);
+        }
+    }
+    async validateBlockInCheckpoint(blockFromL1, checkpointBuilder) {
+        this.log.debug(`Validating pruned block ${blockFromL1.header.globalVariables.blockNumber}`);
+        const txHashes = blockFromL1.body.txEffects.map((txEffect)=>txEffect.txHash);
+        // We load txs from the mempool directly, since the TxCollector running in the background has already been
+        // trying to fetch them from nodes or via reqresp. If we haven't managed to collect them by now,
+        // it's likely that they are not available in the network at all.
+        const { txs, missingTxs } = await this.txProvider.getAvailableTxs(txHashes);
+        if (missingTxs && missingTxs.length > 0) {
+            throw new TransactionsNotAvailableError(missingTxs);
+        }
+        const gv = blockFromL1.header.globalVariables;
+        const { block, failedTxs, numTxs } = await checkpointBuilder.buildBlock(txs, gv.blockNumber, gv.timestamp, {});
+        if (numTxs !== txs.length) {
+            // This should be detected by state mismatch, but this makes it easier to debug.
+            throw new ValidatorError(`Built block with ${numTxs} txs, expected ${txs.length}`);
+        }
+        if (failedTxs.length > 0) {
+            throw new ReExFailedTxsError(failedTxs.length);
+        }
+        if (!block.archive.root.equals(blockFromL1.archive.root)) {
+            throw new ReExStateMismatchError(blockFromL1.archive.root, block.archive.root);
+        }
+    }
+    async getValidatorsForEpoch(epochNumber) {
+        const { committee } = await this.epochCache.getCommitteeForEpoch(epochNumber);
+        if (!committee) {
+            this.log.trace(`No committee found for epoch ${epochNumber}`);
+            return [];
+        }
+        return committee;
+    }
+    validatorsToSlashingArgs(validators, offenseType, epochOrSlot) {
+        const penalty = offenseType === OffenseType.DATA_WITHHOLDING ? this.penalties.slashDataWithholdingPenalty : this.penalties.slashPrunePenalty;
+        return validators.map((v)=>({
+                validator: v,
+                amount: penalty,
+                offenseType,
+                epochOrSlot: BigInt(epochOrSlot)
+            }));
+    }
+}

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@aztec/slasher",
+  "version": "0.0.1-commit.001888fc",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./config": "./dest/config.js"
+  },
+  "inherits": [
+    "../package.common.json",
+    "./package.local.json"
+  ],
+  "scripts": {
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "bb": "node --no-warnings ./dest/bb/index.js",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "generate": "./scripts/generate.sh"
+  },
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/epoch-cache": "0.0.1-commit.001888fc",
+    "@aztec/ethereum": "0.0.1-commit.001888fc",
+    "@aztec/foundation": "0.0.1-commit.001888fc",
+    "@aztec/kv-store": "0.0.1-commit.001888fc",
+    "@aztec/l1-artifacts": "0.0.1-commit.001888fc",
+    "@aztec/stdlib": "0.0.1-commit.001888fc",
+    "@aztec/telemetry-client": "0.0.1-commit.001888fc",
+    "source-map-support": "^0.5.21",
+    "tslib": "^2.4.0",
+    "viem": "npm:@aztec/viem@2.38.2",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@aztec/aztec.js": "0.0.1-commit.001888fc",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
+    "@types/source-map-support": "^0.5.10",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/config.ts

@@ -0,0 +1,172 @@
+import type { ConfigMappingsType } from '@aztec/foundation/config';
+import {
+  bigintConfigHelper,
+  booleanConfigHelper,
+  floatConfigHelper,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+
+import { slasherDefaultEnv } from './generated/slasher-defaults.js';
+
+export type { SlasherConfig };
+
+export const DefaultSlasherConfig: SlasherConfig = {
+  slashOverridePayload: undefined,
+  slashMinPenaltyPercentage: slasherDefaultEnv.SLASH_MIN_PENALTY_PERCENTAGE,
+  slashMaxPenaltyPercentage: slasherDefaultEnv.SLASH_MAX_PENALTY_PERCENTAGE,
+  slashValidatorsAlways: [], // Empty by default
+  slashValidatorsNever: [], // Empty by default
+  slashPrunePenalty: BigInt(slasherDefaultEnv.SLASH_PRUNE_PENALTY),
+  slashDataWithholdingPenalty: BigInt(slasherDefaultEnv.SLASH_DATA_WITHHOLDING_PENALTY),
+  slashInactivityTargetPercentage: slasherDefaultEnv.SLASH_INACTIVITY_TARGET_PERCENTAGE,
+  slashInactivityConsecutiveEpochThreshold: slasherDefaultEnv.SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD,
+  slashBroadcastedInvalidBlockPenalty: BigInt(slasherDefaultEnv.SLASH_INVALID_BLOCK_PENALTY),
+  slashDuplicateProposalPenalty: BigInt(slasherDefaultEnv.SLASH_DUPLICATE_PROPOSAL_PENALTY),
+  slashDuplicateAttestationPenalty: BigInt(slasherDefaultEnv.SLASH_DUPLICATE_ATTESTATION_PENALTY),
+  slashInactivityPenalty: BigInt(slasherDefaultEnv.SLASH_INACTIVITY_PENALTY),
+  slashProposeInvalidAttestationsPenalty: BigInt(slasherDefaultEnv.SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY),
+  slashAttestDescendantOfInvalidPenalty: BigInt(slasherDefaultEnv.SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY),
+  slashUnknownPenalty: BigInt(slasherDefaultEnv.SLASH_UNKNOWN_PENALTY),
+  slashOffenseExpirationRounds: slasherDefaultEnv.SLASH_OFFENSE_EXPIRATION_ROUNDS,
+  slashMaxPayloadSize: slasherDefaultEnv.SLASH_MAX_PAYLOAD_SIZE,
+  slashGracePeriodL2Slots: slasherDefaultEnv.SLASH_GRACE_PERIOD_L2_SLOTS,
+  slashExecuteRoundsLookBack: slasherDefaultEnv.SLASH_EXECUTE_ROUNDS_LOOK_BACK,
+  slashSelfAllowed: false,
+};
+
+export const slasherConfigMappings: ConfigMappingsType<SlasherConfig> = {
+  slashOverridePayload: {
+    env: 'SLASH_OVERRIDE_PAYLOAD',
+    description: 'An Ethereum address for a slash payload to vote for unconditionally.',
+    parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
+    defaultValue: DefaultSlasherConfig.slashOverridePayload,
+  },
+  slashMinPenaltyPercentage: {
+    env: 'SLASH_MIN_PENALTY_PERCENTAGE',
+    description: 'Minimum penalty percentage for slashing offenses (0.1 is 10%).',
+    ...floatConfigHelper(DefaultSlasherConfig.slashMinPenaltyPercentage),
+  },
+  slashMaxPenaltyPercentage: {
+    env: 'SLASH_MAX_PENALTY_PERCENTAGE',
+    description: 'Maximum penalty percentage for slashing offenses (2.0 is 200%).',
+    ...floatConfigHelper(DefaultSlasherConfig.slashMaxPenaltyPercentage),
+  },
+  slashValidatorsAlways: {
+    env: 'SLASH_VALIDATORS_ALWAYS',
+    description: 'Comma-separated list of validator addresses that should always be slashed.',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(addr => addr.trim())
+        .filter(addr => addr.length > 0)
+        .map(addr => EthAddress.fromString(addr)),
+    defaultValue: DefaultSlasherConfig.slashValidatorsAlways,
+  },
+  slashValidatorsNever: {
+    env: 'SLASH_VALIDATORS_NEVER',
+    description: 'Comma-separated list of validator addresses that should never be slashed.',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(addr => addr.trim())
+        .filter(addr => addr.length > 0)
+        .map(addr => EthAddress.fromString(addr)),
+    defaultValue: DefaultSlasherConfig.slashValidatorsNever,
+  },
+  slashPrunePenalty: {
+    env: 'SLASH_PRUNE_PENALTY',
+    description: 'Penalty amount for slashing validators of a valid pruned epoch (set to 0 to disable).',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashPrunePenalty),
+  },
+  slashDataWithholdingPenalty: {
+    env: 'SLASH_DATA_WITHHOLDING_PENALTY',
+    description: 'Penalty amount for slashing validators for data withholding (set to 0 to disable).',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashDataWithholdingPenalty),
+  },
+  slashBroadcastedInvalidBlockPenalty: {
+    env: 'SLASH_INVALID_BLOCK_PENALTY',
+    description: 'Penalty amount for slashing a validator for an invalid block proposed via p2p.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashBroadcastedInvalidBlockPenalty),
+  },
+  slashDuplicateProposalPenalty: {
+    env: 'SLASH_DUPLICATE_PROPOSAL_PENALTY',
+    description: 'Penalty amount for slashing a validator for sending duplicate proposals.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashDuplicateProposalPenalty),
+  },
+  slashDuplicateAttestationPenalty: {
+    env: 'SLASH_DUPLICATE_ATTESTATION_PENALTY',
+    description:
+      'Penalty amount for slashing a validator for signing attestations for different proposals at the same slot.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashDuplicateAttestationPenalty),
+  },
+  slashInactivityTargetPercentage: {
+    env: 'SLASH_INACTIVITY_TARGET_PERCENTAGE',
+    description:
+      'Missed attestation percentage to trigger creation of inactivity slash payload (0, 1]. Must be greater than 0',
+    ...floatConfigHelper(DefaultSlasherConfig.slashInactivityTargetPercentage, v => {
+      if (v <= 0 || v > 1) {
+        throw new RangeError(`SLASH_INACTIVITY_TARGET_PERCENTAGE out of range. Expected (0, 1] got ${v}`);
+      }
+    }),
+  },
+  slashInactivityConsecutiveEpochThreshold: {
+    env: 'SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD',
+    description: 'Number of consecutive epochs a validator must be inactive before slashing (minimum 1).',
+    ...numberConfigHelper(DefaultSlasherConfig.slashInactivityConsecutiveEpochThreshold),
+    parseEnv: (val: string) => {
+      const parsed = parseInt(val, 10);
+      if (parsed < 1) {
+        throw new RangeError(`SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD must be at least 1 (got ${parsed})`);
+      }
+      return parsed;
+    },
+  },
+  slashInactivityPenalty: {
+    env: 'SLASH_INACTIVITY_PENALTY',
+    description: 'Penalty amount for slashing an inactive validator (set to 0 to disable).',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashInactivityPenalty),
+  },
+  slashProposeInvalidAttestationsPenalty: {
+    env: 'SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY',
+    description: 'Penalty amount for slashing a proposer that proposed invalid attestations (set to 0 to disable).',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashProposeInvalidAttestationsPenalty),
+  },
+  slashAttestDescendantOfInvalidPenalty: {
+    env: 'SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY',
+    description:
+      'Penalty amount for slashing a validator that attested to a descendant of an invalid block (set to 0 to disable).',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashAttestDescendantOfInvalidPenalty),
+  },
+  slashUnknownPenalty: {
+    env: 'SLASH_UNKNOWN_PENALTY',
+    description: 'Penalty amount for slashing a validator for an unknown offense (set to 0 to disable).',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashUnknownPenalty),
+  },
+  slashOffenseExpirationRounds: {
+    env: 'SLASH_OFFENSE_EXPIRATION_ROUNDS',
+    description: 'Number of rounds after which pending offenses expire.',
+    ...numberConfigHelper(DefaultSlasherConfig.slashOffenseExpirationRounds),
+  },
+  slashMaxPayloadSize: {
+    env: 'SLASH_MAX_PAYLOAD_SIZE',
+    description: 'Maximum number of offenses to include in a single slash payload.',
+    ...numberConfigHelper(DefaultSlasherConfig.slashMaxPayloadSize),
+  },
+  slashGracePeriodL2Slots: {
+    description:
+      'Number of L2 slots after the network upgrade during which slashing offenses are ignored. The upgrade time is determined from the CanonicalRollupUpdated event.',
+    env: 'SLASH_GRACE_PERIOD_L2_SLOTS',
+    ...numberConfigHelper(DefaultSlasherConfig.slashGracePeriodL2Slots),
+  },
+  slashExecuteRoundsLookBack: {
+    env: 'SLASH_EXECUTE_ROUNDS_LOOK_BACK',
+    description: 'How many rounds to look back when searching for a round to execute.',
+    ...numberConfigHelper(DefaultSlasherConfig.slashExecuteRoundsLookBack),
+  },
+  slashSelfAllowed: {
+    description: 'Whether to allow slashes to own validators',
+    ...booleanConfigHelper(DefaultSlasherConfig.slashSelfAllowed),
+  },
+};