@aztec-labs/slasher 6.0.0-nightly.20260829

package/README.md

@@ -0,0 +1,232 @@
+# Slasher
+
+## Overview
+
+The slasher module implements validator slashing for the Aztec network. Slashing punishes validators who misbehave or are inactive by reducing their stake. This mechanism ensures network security and liveness.
+
+## Usage
+
+The slasher is integrated into the Aztec node and activates when:
+1. The node is configured as a validator
+2. The validator is selected as proposer for a slot
+3. Slashable offenses have been detected
+
+No manual intervention is required for normal operation. The slasher client handles:
+- Monitoring for offenses
+- Generating appropriate slash actions
+- Coordinating with the SequencerPublisher for L1 execution
+
+## Slashing Model
+
+The slashing model uses consensus-based voting where proposers vote on individual validator offenses. Time is divided into rounds, and during each round, proposers submit votes indicating which validators from a given past round should be slashed (eg round N votes to slash the validators from round N-2). Votes are encoded as bytes where each validator's vote is represented by 2 bits indicating the slash amount (0-3 slash units) for each validator. The L1 contract tallies votes and slashes validators that reach quorum.
+
+Key characteristics:
+- Proposers vote directly on validator offenses
+- Requires a slash offset to vote on validators from past rounds
+- Requires quorum to execute slashing
+- L1 contract determines which offenses reach consensus
+- Execution happens after a delay period for review
+- Slash payloads can be vetoed during the execution delay period
+
+## Architecture
+
+### Core Components
+
+#### SlasherClientInterface
+Interface implemented by the slasher client. Provides methods for:
+- `getProposerActions()`: Returns actions for the current proposer
+- `gatherOffensesForRound()`: Collects offenses for a specific round
+
+#### SlashOffensesCollector
+Collects slashable offenses from watchers and stores them in the offenses store. Features:
+- Subscribes to `WANT_TO_SLASH_EVENT` from watchers
+- Manages offense lifecycle and automatic expiration
+
+#### SlasherOffensesStore
+Persistent storage for offenses. Tracks:
+- Pending offenses awaiting slashing
+- Executed offenses to prevent double slashing
+- Round-based offense organization
+- Automatic expiration of old offenses based on configurable rounds
+
+#### SlashRoundMonitor
+Monitors slashing rounds and triggers actions on round transitions:
+- Tracks current round based on L2 slots
+- Emits events when rounds change
+
+#### ProposerSlashAction
+Actions returned by the slasher client to the SequencerPublisher:
+- `vote-offenses`: Vote on validator offenses
+- `execute-slash`: Execute slashing for a round that reached quorum
+
+### Integration Flow
+
+1. **Offense Detection**: Watchers monitor the network and emit `WANT_TO_SLASH_EVENT` when they detect violations
+2. **Offense Collection**: SlashOffensesCollector receives events and stores offenses in SlasherOffensesStore
+3. **Action Generation**: When a validator is proposer, the slasher client generates ProposerSlashActions
+4. **Action Execution**: SequencerPublisher receives actions and executes them on L1
+5. **Round Monitoring**: SlashRoundMonitor tracks rounds and triggers execution when conditions are met
+
+## Vetoing
+
+The slashing system includes a veto mechanism that allows designated vetoers to block slash payloads during the execution delay period. When a slash payload is ready for execution, the system first checks if it has been vetoed before proceeding.
+
+Key features:
+- Slash payloads can be vetoed by authorized addresses on the L1 slasher contract
+- Veto checks are performed automatically before execution attempts
+- The veto mechanism provides a safety valve for incorrectly proposed slashes
+
+## Slashable Offenses
+
+List of all slashable offenses in the system:
+
+### DATA_WITHHOLDING
+**Description**: The transaction data for a published checkpoint was not made available within the tolerance window.
+**Detection**: DataWithholdingWatcher checks each published checkpoint's txs against the local mempool once `slashDataWithholdingToleranceSlots` full slots have elapsed past the checkpoint's slot (i.e. at `slotStart(checkpoint.slot + slashDataWithholdingToleranceSlots + 1)`).
+**Target**: Validators who attested to the checkpoint.
+**Time Unit**: Slot-based offense (the checkpoint's slot).
+
+### INACTIVITY
+**Description**: A proposer failed to attest or propose blocks during their assigned slots.
+**Detection**: Sentinel tracks validator performance and identifies validators who miss attestations beyond threshold.
+**Target**: Individual inactive validator.
+**Time Unit**: Epoch-based offense.
+
+### BROADCASTED_INVALID_BLOCK_PROPOSAL
+**Description**: A proposer broadcast an invalid block proposal over the p2p network.
+**Detection**: Validators detect invalid proposals during attestation validation.
+**Target**: Proposer who broadcast the invalid block.
+**Time Unit**: Slot-based offense.
+
+### PROPOSED_INSUFFICIENT_ATTESTATIONS
+**Description**: A proposer submitted a block to L1 without sufficient committee attestations.
+**Detection**: AttestationsBlockWatcher checks L1 blocks for attestation count.
+**Target**: Block proposer.
+**Time Unit**: Slot-based offense.
+
+### PROPOSED_INCORRECT_ATTESTATIONS
+**Description**: A proposer submitted a block to L1 with signatures from non-committee members.
+**Detection**: AttestationsBlockWatcher validates attestation signatures against committee membership.
+**Target**: Block proposer.
+**Time Unit**: Slot-based offense.
+
+### PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS
+**Description**: A proposer published a checkpoint to L1 that builds on an invalid checkpoint (one with invalid or insufficient attestations).
+**Detection**: AttestationsBlockWatcher tracks invalid checkpoints and their descendants.
+**Target**: Proposer of the descendant checkpoint.
+**Time Unit**: Slot-based offense.
+
+### DUPLICATE_PROPOSAL
+**Description**: A proposer sent multiple block or checkpoint proposals for the same position (slot and indexWithinCheckpoint for blocks, or slot for checkpoints) with different content. Since each slot has exactly one designated proposer, sending conflicting proposals is equivocation. This also covers the case where a proposer broadcasts one checkpoint proposal via P2P but submits a different checkpoint to L1 for the same slot.
+**Detection**: Detected in two places. (1) The P2P layer flags duplicates when a second proposal arrives for the same position with a different archive; the AttestationPool tracks proposals by position and the first duplicate is propagated (Accept) so other validators can witness the offense. (2) CheckpointEquivocationWatcher compares the archive root of each L1-confirmed checkpoint against retained signed P2P checkpoint proposals from the same slot's proposer and flags any mismatch.
+**Target**: Proposer who broadcast the duplicate proposal.
+**Time Unit**: Slot-based offense.
+
+### DUPLICATE_ATTESTATION
+**Description**: A validator signed attestations for different checkpoint proposals (different archives) at the same slot. Validators must attest to at most one checkpoint per slot, so signing conflicting attestations is equivocation.
+**Detection**: The P2P AttestationPool tracks attestations by slot and signer. A second attestation from the same signer for a different proposal at the same slot triggers the duplicate-attestation callback; the duplicate is propagated (Accept) so other validators can witness the offense. The ValidatorClient emits the slash event.
+**Target**: The attester who equivocated.
+**Time Unit**: Slot-based offense.
+
+### ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL
+**Description**: A committee member attested to a checkpoint proposal in a slot where this node detected a slashable invalid block proposal.
+**Detection**: ValidatorClient marks slots with invalid block proposals detected via reexecution and slashes checkpoint attesters seen for that slot. If proposal equivocation is later detected for the slot, pending bad-attestation offenses are cleared.
+**Target**: Committee members who attested in the invalid proposal slot.
+**Time Unit**: Slot-based offense.
+
+### BROADCASTED_INVALID_CHECKPOINT_PROPOSAL
+**Description**: A proposer broadcast an invalid checkpoint proposal, either one that terminates before a higher-index block proposal signed by the same proposer in the same slot, one whose signed header does not match deterministic validator recomputation, or one with a malformed fee asset price modifier. The first case also covers AZIP-7's _Submitting Block Proposal After Checkpoint_: a later block signed by the same proposer in the same slot makes the prior checkpoint retroactively invalid.
+**Detection**: BroadcastedInvalidCheckpointProposalWatcher scans retained P2P proposal evidence and compares checkpoint archive roots to signed block proposals from the same slot and signer. ValidatorClient also validates checkpoint proposals during the all-nodes callback and emits this offense when checkpoint header recomputation fails or the signed fee asset price modifier is malformed.
+**Target**: Proposer who broadcast the invalid checkpoint proposal.
+**Time Unit**: Slot-based offense.
+
+## Configuration
+
+### L1 System Settings (L1ContractsConfig)
+These settings are deployed with the L1 contracts and apply system-wide to the protocol:
+
+- `slashingQuorumSize`: Votes required to slash (defaults to half the validators in a round, plus one)
+- `slashingRoundSizeInEpochs`: Number of epochs per slashing round
+- `slashingOffsetInRounds`: How many rounds to look back for offenses
+- `slashingExecutionDelayInRounds`: Rounds to wait before execution
+- `slashingLifetimeInRounds`: Maximum age of executable rounds
+- `slashingAmounts`: Valid values for each individual slash
+
+Considerations:
+
+- The `slashingQuorumSize` should be more than half and less than the total number of validators in a round, so that we require a majority to slash. The number of validators in a round is the committee size times the number of epochs in a round.
+- The bigger a `slashingRoundSizeInEpochs`, the bigger the upper bound on the quorum size. This increases security, as we need more validators to agree before slashing. However, it also makes slashing slower, and more expensive to execute in terms of gas.
+- The `slashingOffsetInRounds` is required because the validators in a given slashing round must vote for _past_ offenses. Otherwise, if someone commits an offense near the end of a round, they can get away with their offense without the validators being able to collect enough votes to slash them. The offset needs to be big enough so that all offenses are discoverable, so this value should be strictly greater than the data-withholding tolerance window so that there is time to detect missing data and vote.
+- The `slashingExecutionDelayInRounds` allows vetoers to stop an invalid slash. This should be large enough to give vetoers time to act, but strictly smaller than the validator exit window, so an offender cannot escape before they are slashed. It should also be small enough so that an offender that would be kicked out does not get picked up to be a committee member again before their slash is executed. In other words, if a validator commits a serious enough offense that we want them out of the validator set as soon as possible, the execution delay should not allow them to be chosen to participate in another committee.
+
+### Local Node Configuration (SlasherConfig)
+
+These settings are configured locally on each validator node:
+
+Block and checkpoint validation settings are expected to be the same across all validators. Slashing relies on
+validators making the same deterministic validity decisions for block and checkpoint proposals; operators should not run
+with divergent validation limits.
+
+- `slashGracePeriodL2Slots`: Number of initial L2 slots where slashing is disabled
+- `slashOffenseExpirationRounds`: Number of rounds after which pending offenses expire
+- `slashValidatorsAlways`: Array of validator addresses that should always be slashed
+- `slashValidatorsNever`: Array of validator addresses that should never be slashed (own validator addresses are automatically added to this list)
+- `slashInactivityTargetPercentage`: Percentage of misses during an epoch to be slashed for INACTIVITY
+- `slashInactivityConsecutiveEpochThreshold`: How many consecutive inactive epochs are needed to trigger an INACTIVITY slash on a validator
+- `slashDataWithholdingPenalty`: Penalty for DATA_WITHHOLDING
+- `slashDataWithholdingToleranceSlots`: Number of full L2 slots to wait after a checkpoint's slot before declaring its txs missing
+- `slashInactivityPenalty`: Penalty for INACTIVITY
+- `slashBroadcastedInvalidBlockPenalty`: Penalty for BROADCASTED_INVALID_BLOCK_PROPOSAL
+- `slashBroadcastedInvalidCheckpointProposalPenalty`: Penalty for BROADCASTED_INVALID_CHECKPOINT_PROPOSAL
+- `slashDuplicateProposalPenalty`: Penalty for DUPLICATE_PROPOSAL
+- `slashDuplicateAttestationPenalty`: Penalty for DUPLICATE_ATTESTATION
+- `slashProposeInvalidAttestationsPenalty`: Penalty for PROPOSED_INSUFFICIENT_ATTESTATIONS and PROPOSED_INCORRECT_ATTESTATIONS
+- `slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty`: Penalty for PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS
+- `slashAttestInvalidCheckpointProposalPenalty`: Penalty for ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL
+- `slashUnknownPenalty`: Default penalty for unknown offense types
+- `slashMaxPayloadSize`: Limits the number of **unique validators** (across all committees and epochs in a round) that receive non-zero votes. When this cap is hit, the lowest-severity validator-epoch pairs are zeroed out first, so the most severe slashes are always preserved. Note that multiple offenses for the same validator in the same epoch are summed and counted as a single validator entry against this limit.
+
+Considerations:
+
+- All penalties should map to one of the `slashingAmounts`. A penalty lower than the smallest slashing amount will not be executable, and a penalty greater than the maximum will be capped at the maximum value.
+- The `slashOffenseExpirationRounds` should be strictly larger than the `slashingOffsetInRounds`. This can be a relatively large value, as it's used only for data store cleanup.
+
+## Offenses In-Depth
+
+Details about specific offenses in the system:
+
+### Inactivity
+
+Inactivity slashing is one of the most critical, since it allows purging validators that are not fulfilling their duties, which could potentially bring the chain to a halt. This slashing must be aggressive enough to balance out the rate of the entry queue, in case the queue is filled with inactive validators. Furthermore, if enough inactive validators join the system, it may become impossible to gather enough quorum to pass any governance proposal.
+
+Inactivity slashing is handled by the `Sentinel` (in `aztec-node/src/sentinel/`), which monitors performance of all validators slot-by-slot. With the multiple-blocks-per-slot model, block proposals and checkpoints are distinct concepts: proposers build multiple blocks per slot, but attestations are only for checkpoints. After each slot, the sentinel assigns one of the following to the proposer for the slot, in highest-confidence order:
+
+- `checkpoint-mined` — a checkpoint covering this slot has landed on L1
+- `checkpoint-valid` — the local node re-executed a checkpoint proposal for this slot successfully
+- `checkpoint-invalid` — the local node re-executed a checkpoint proposal for this slot and rejected it (header / archive / out-hash mismatch, limit breach, etc.). Proposer-fault
+- `checkpoint-unvalidated` — a checkpoint proposal arrived but the local node could not validate it (missing blocks/txs, timeout). Treated as proposer-fault
+- `checkpoint-missed` — block proposals seen on P2P but no checkpoint proposal at all
+- `blocks-missed` — no block proposals seen for this slot at all
+
+Re-execution outcomes are read from the `CheckpointReexecutionTracker`, which the validator client populates at every early-return in `validateCheckpointProposal`. The same tracker is consumed by the data-withholding watcher via `hasReexecuted(checkpointNumber, archiveRoot)`.
+
+Each non-proposer committee member is assigned one of:
+- `attestation-sent` if their checkpoint attestation was seen on L1 or on the P2P network
+- `attestation-missed` if the proposer status was `checkpoint-mined` or `checkpoint-valid` but no checkpoint attestation was seen
+- none in any other case
+
+`blocks-missed`, `checkpoint-missed`, `checkpoint-invalid`, and `checkpoint-unvalidated` all count as proposer inactivity for the slot.
+
+The sentinel evaluates an epoch once `sentinelEpochEndBufferSlots` (default 2) L2 slots have elapsed past the epoch's last slot AND the per-slot recorder has covered that last slot. Epoch evaluation does not wait for an L1 proof — it relies on local-state evidence (the re-execution tracker plus L1 checkpoint landings) — so inactive validators are slashed promptly regardless of prover availability.
+
+At end-of-epoch evaluation, for each validator such that:
+
+```
+total_failures = count(blocks-missed) + count(checkpoint-missed)
+               + count(checkpoint-invalid) + count(checkpoint-unvalidated)
+               + count(attestation-missed)
+total = count(checkpoint-*) + count(blocks-*) + count(attestation-*)
+total_failures / total >= slashInactivityTargetPercentage
+```
+
+they are voted to be slashed for inactivity. If `slashInactivityConsecutiveEpochThreshold` is greater than one, the above must also hold for the last `threshold` times the validator was part of a committee.

package/dest/config.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigMappingsType } from '@aztec-labs/foundation/config';
+import type { SlasherConfig } from '@aztec-labs/stdlib/interfaces/server';
+export type { SlasherConfig };
+export declare const DefaultSlasherConfig: SlasherConfig;
+export declare const slasherConfigMappings: ConfigMappingsType<SlasherConfig>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFReEUsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFJMUUsWUFBWSxFQUFFLGFBQWEsRUFBRSxDQUFDO0FBRTlCLGVBQU8sTUFBTSxvQkFBb0IsRUFBRSxhQTBCbEMsQ0FBQztBQUVGLGVBQU8sTUFBTSxxQkFBcUIsRUFBRSxrQkFBa0IsQ0FBQyxhQUFhLENBc0luRSxDQUFDIn0=

package/dest/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAQxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAI1E,YAAY,EAAE,aAAa,EAAE,CAAC;AAE9B,eAAO,MAAM,oBAAoB,EAAE,aA0BlC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,kBAAkB,CAAC,aAAa,CAsInE,CAAC"}

package/dest/config.js

@@ -0,0 +1,146 @@
+import { bigintConfigHelper, booleanConfigHelper, floatConfigHelper, numberConfigHelper } from '@aztec-labs/foundation/config';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { slasherDefaultEnv } from './generated/slasher-defaults.js';
+export const DefaultSlasherConfig = {
+    slashOverridePayload: undefined,
+    slashValidatorsAlways: [],
+    slashValidatorsNever: [],
+    slashDataWithholdingPenalty: BigInt(slasherDefaultEnv.SLASH_DATA_WITHHOLDING_PENALTY),
+    slashDataWithholdingToleranceSlots: slasherDefaultEnv.SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS,
+    slashInactivityTargetPercentage: slasherDefaultEnv.SLASH_INACTIVITY_TARGET_PERCENTAGE,
+    slashInactivityConsecutiveEpochThreshold: slasherDefaultEnv.SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD,
+    slashBroadcastedInvalidBlockPenalty: BigInt(slasherDefaultEnv.SLASH_INVALID_BLOCK_PENALTY),
+    slashBroadcastedInvalidCheckpointProposalPenalty: BigInt(slasherDefaultEnv.SLASH_INVALID_CHECKPOINT_PROPOSAL_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),
+    slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty: BigInt(slasherDefaultEnv.SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY),
+    slashAttestInvalidCheckpointProposalPenalty: BigInt(slasherDefaultEnv.SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_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 = {
+    slashOverridePayload: {
+        env: 'SLASH_OVERRIDE_PAYLOAD',
+        description: 'An Ethereum address for a slash payload to vote for unconditionally.',
+        parseEnv: (val)=>EthAddress.fromString(val),
+        defaultValue: DefaultSlasherConfig.slashOverridePayload
+    },
+    slashValidatorsAlways: {
+        env: 'SLASH_VALIDATORS_ALWAYS',
+        description: 'Comma-separated list of validator addresses that should always be slashed.',
+        parseEnv: (val)=>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)=>val.split(',').map((addr)=>addr.trim()).filter((addr)=>addr.length > 0).map((addr)=>EthAddress.fromString(addr)),
+        defaultValue: DefaultSlasherConfig.slashValidatorsNever
+    },
+    slashDataWithholdingPenalty: {
+        env: 'SLASH_DATA_WITHHOLDING_PENALTY',
+        description: 'Penalty for data withholding (0 records offenses without slash votes).',
+        ...bigintConfigHelper(DefaultSlasherConfig.slashDataWithholdingPenalty)
+    },
+    slashDataWithholdingToleranceSlots: {
+        env: 'SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS',
+        description: 'Number of full L2 slots that must elapse after a checkpoint slot before declaring its txs missing and slashing its attesters for data withholding.',
+        ...numberConfigHelper(DefaultSlasherConfig.slashDataWithholdingToleranceSlots)
+    },
+    slashBroadcastedInvalidBlockPenalty: {
+        env: 'SLASH_INVALID_BLOCK_PENALTY',
+        description: 'Penalty amount for slashing a validator for an invalid block proposed via p2p.',
+        ...bigintConfigHelper(DefaultSlasherConfig.slashBroadcastedInvalidBlockPenalty)
+    },
+    slashBroadcastedInvalidCheckpointProposalPenalty: {
+        env: 'SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY',
+        description: 'Penalty amount for slashing a validator for an invalid checkpoint proposal proposed via p2p.',
+        ...bigintConfigHelper(DefaultSlasherConfig.slashBroadcastedInvalidCheckpointProposalPenalty)
+    },
+    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)=>{
+            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 for an inactive validator (0 records offenses without slash votes).',
+        ...bigintConfigHelper(DefaultSlasherConfig.slashInactivityPenalty)
+    },
+    slashProposeInvalidAttestationsPenalty: {
+        env: 'SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY',
+        description: 'Penalty for proposing invalid attestations (0 records offenses without slash votes).',
+        ...bigintConfigHelper(DefaultSlasherConfig.slashProposeInvalidAttestationsPenalty)
+    },
+    slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty: {
+        env: 'SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY',
+        description: 'Penalty for publishing a checkpoint building on an invalid checkpoint (0 records offenses without slash votes).',
+        ...bigintConfigHelper(DefaultSlasherConfig.slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty)
+    },
+    slashAttestInvalidCheckpointProposalPenalty: {
+        env: 'SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY',
+        description: 'Penalty for attesting to an invalid checkpoint proposal (0 records offenses without slash votes).',
+        ...bigintConfigHelper(DefaultSlasherConfig.slashAttestInvalidCheckpointProposalPenalty)
+    },
+    slashUnknownPenalty: {
+        env: 'SLASH_UNKNOWN_PENALTY',
+        description: 'Penalty for an unknown offense (0 records offenses without slash votes).',
+        ...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)
+    }
+};

package/dest/factory/create_facade.d.ts

@@ -0,0 +1,19 @@
+import { EpochCache } from '@aztec-labs/epoch-cache';
+import type { L1ReaderConfig } from '@aztec-labs/ethereum/l1-reader';
+import type { ViemClient } from '@aztec-labs/ethereum/types';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import type { SlasherConfig } from '@aztec-labs/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec-labs/stdlib/kv-store';
+import type { SlasherClientInterface } from '../slasher_client_interface.js';
+import type { Watcher } from '../watcher.js';
+/** Creates a slasher client facade that updates itself whenever the rollup slasher changes */
+export declare function createSlasherFacade(config: SlasherConfig & DataStoreConfig & {
+    ethereumSlotDuration: number;
+}, l1Contracts: Pick<L1ReaderConfig, 'rollupAddress' | 'registryAddress'>, l1Client: ViemClient, watchers: Watcher[], dateProvider: DateProvider, epochCache: EpochCache, 
+/**
+ * List of own validator addresses. Added to the slashValidatorNever list unless slashSelfAllowed is true, and used
+ * (independently of slashSelfAllowed) to warn and record metrics when they are targeted by onchain slashing.
+ */
+validatorAddresses?: EthAddress[], logger?: import("@aztec-labs/foundation/log").Logger): Promise<SlasherClientInterface>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlX2ZhY2FkZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ZhY3RvcnkvY3JlYXRlX2ZhY2FkZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFckQsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDckUsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFHN0QsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRWhFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUc1RCxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUMxRSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUduRSxPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRTdFLE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUU3Qyw4RkFBOEY7QUFDOUYsd0JBQXNCLG1CQUFtQixDQUN2QyxNQUFNLEVBQUUsYUFBYSxHQUFHLGVBQWUsR0FBRztJQUFFLG9CQUFvQixFQUFFLE1BQU0sQ0FBQTtDQUFFLEVBQzFFLFdBQVcsRUFBRSxJQUFJLENBQUMsY0FBYyxFQUFFLGVBQWUsR0FBRyxpQkFBaUIsQ0FBQyxFQUN0RSxRQUFRLEVBQUUsVUFBVSxFQUNwQixRQUFRLEVBQUUsT0FBTyxFQUFFLEVBQ25CLFlBQVksRUFBRSxZQUFZLEVBQzFCLFVBQVUsRUFBRSxVQUFVO0FBQ3RCOzs7R0FHRztBQUNILGtCQUFrQixHQUFFLFVBQVUsRUFBTyxFQUNyQyxNQUFNLDhDQUEwQixHQUMvQixPQUFPLENBQUMsc0JBQXNCLENBQUMsQ0FtRGpDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_facade.d.ts","sourceRoot":"","sources":["../../src/factory/create_facade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAG7D,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAEhE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAG5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAGnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAE7E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,8FAA8F;AAC9F,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,aAAa,GAAG,eAAe,GAAG;IAAE,oBAAoB,EAAE,MAAM,CAAA;CAAE,EAC1E,WAAW,EAAE,IAAI,CAAC,cAAc,EAAE,eAAe,GAAG,iBAAiB,CAAC,EACtE,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,OAAO,EAAE,EACnB,YAAY,EAAE,YAAY,EAC1B,UAAU,EAAE,UAAU;AACtB;;;GAGG;AACH,kBAAkB,GAAE,UAAU,EAAO,EACrC,MAAM,8CAA0B,GAC/B,OAAO,CAAC,sBAAsB,CAAC,CAmDjC"}

package/dest/factory/create_facade.js

@@ -0,0 +1,49 @@
+import { RegistryContract, RollupContract } from '@aztec-labs/ethereum/contracts';
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { unique } from '@aztec-labs/foundation/collection';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { createStore } from '@aztec-labs/kv-store/lmdb-v2';
+import { getSlotAtTimestamp } from '@aztec-labs/stdlib/epoch-helpers';
+import { SlasherClientFacade } from '../slasher_client_facade.js';
+import { SCHEMA_VERSION } from '../stores/schema_version.js';
+/** Creates a slasher client facade that updates itself whenever the rollup slasher changes */ export async function createSlasherFacade(config, l1Contracts, l1Client, watchers, dateProvider, epochCache, /**
+   * List of own validator addresses. Added to the slashValidatorNever list unless slashSelfAllowed is true, and used
+   * (independently of slashSelfAllowed) to warn and record metrics when they are targeted by onchain slashing.
+   */ validatorAddresses = [], logger = createLogger('slasher')) {
+    if (!l1Contracts.rollupAddress || l1Contracts.rollupAddress.equals(EthAddress.ZERO)) {
+        throw new Error('Cannot initialize SlasherClient without a Rollup address');
+    }
+    const kvStore = await createStore('slasher', SCHEMA_VERSION, config, logger.getBindings());
+    const rollup = new RollupContract(l1Client, l1Contracts.rollupAddress);
+    // Compute and cache the L2 slot at which the rollup was registered as canonical
+    const settingsMap = kvStore.openMap('slasher-settings');
+    const cacheKey = `registeredSlot:${l1Contracts.rollupAddress}`;
+    let rollupRegisteredAtL2Slot = await settingsMap.getAsync(cacheKey);
+    if (rollupRegisteredAtL2Slot === undefined) {
+        const registry = new RegistryContract(l1Client, l1Contracts.registryAddress);
+        const l1StartBlock = await rollup.getL1StartBlock();
+        const registrationTimestamp = await registry.getCanonicalRollupRegistrationTimestamp(l1Contracts.rollupAddress, l1StartBlock);
+        if (registrationTimestamp !== undefined) {
+            const l1GenesisTime = await rollup.getL1GenesisTime();
+            const slotDuration = await rollup.getSlotDuration();
+            rollupRegisteredAtL2Slot = getSlotAtTimestamp(registrationTimestamp, {
+                l1GenesisTime,
+                slotDuration: Number(slotDuration)
+            });
+        } else {
+            rollupRegisteredAtL2Slot = SlotNumber(0);
+        }
+        await settingsMap.set(cacheKey, rollupRegisteredAtL2Slot);
+        logger.info(`Canonical rollup registered at L2 slot ${rollupRegisteredAtL2Slot}`);
+    }
+    const slashValidatorsNever = config.slashSelfAllowed ? config.slashValidatorsNever : unique([
+        ...config.slashValidatorsNever,
+        ...validatorAddresses
+    ].map((a)=>a.toString())).map(EthAddress.fromString);
+    const updatedConfig = {
+        ...config,
+        slashValidatorsNever
+    };
+    return new SlasherClientFacade(updatedConfig, rollup, l1Client, watchers, epochCache, dateProvider, kvStore, rollupRegisteredAtL2Slot, validatorAddresses, logger);
+}

package/dest/factory/create_implementation.d.ts

@@ -0,0 +1,17 @@
+import { EpochCache } from '@aztec-labs/epoch-cache';
+import { RollupContract } from '@aztec-labs/ethereum/contracts';
+import type { ViemClient } from '@aztec-labs/ethereum/types';
+import type { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { AztecLMDBStoreV2 } from '@aztec-labs/kv-store/lmdb-v2';
+import type { SlasherConfig } from '@aztec-labs/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec-labs/stdlib/kv-store';
+import { NullSlasherClient } from '../null_slasher_client.js';
+import { SlasherClient } from '../slasher_client.js';
+import type { Watcher } from '../watcher.js';
+/** Creates a slasher client implementation based on the slasher proposer type in the rollup */
+export declare function createSlasherImplementation(config: SlasherConfig & DataStoreConfig & {
+    ethereumSlotDuration: number;
+}, rollup: RollupContract, l1Client: ViemClient, watchers: Watcher[], epochCache: EpochCache, dateProvider: DateProvider, kvStore: AztecLMDBStoreV2, rollupRegisteredAtL2Slot: SlotNumber, ownValidators?: EthAddress[], logger?: import("@aztec-labs/foundation/log").Logger): Promise<NullSlasherClient | SlasherClient>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlX2ltcGxlbWVudGF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmFjdG9yeS9jcmVhdGVfaW1wbGVtZW50YXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3JELE9BQU8sRUFBRSxjQUFjLEVBQTRCLE1BQU0sZ0NBQWdDLENBQUM7QUFDMUYsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDN0QsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDdkUsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFFckUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQzVELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQzFFLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRW5FLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQzlELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVyRCxPQUFPLEtBQUssRUFBRSxPQUFPLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHN0MsK0ZBQStGO0FBQy9GLHdCQUFzQiwyQkFBMkIsQ0FDL0MsTUFBTSxFQUFFLGFBQWEsR0FBRyxlQUFlLEdBQUc7SUFBRSxvQkFBb0IsRUFBRSxNQUFNLENBQUE7Q0FBRSxFQUMxRSxNQUFNLEVBQUUsY0FBYyxFQUN0QixRQUFRLEVBQUUsVUFBVSxFQUNwQixRQUFRLEVBQUUsT0FBTyxFQUFFLEVBQ25CLFVBQVUsRUFBRSxVQUFVLEVBQ3RCLFlBQVksRUFBRSxZQUFZLEVBQzFCLE9BQU8sRUFBRSxnQkFBZ0IsRUFDekIsd0JBQXdCLEVBQUUsVUFBVSxFQUNwQyxhQUFhLEdBQUUsVUFBVSxFQUFPLEVBQ2hDLE1BQU0sOENBQTBCLDhDQW1CakMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_implementation.d.ts","sourceRoot":"","sources":["../../src/factory/create_implementation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,cAAc,EAA4B,MAAM,gCAAgC,CAAC;AAC1F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAErE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7C,+FAA+F;AAC/F,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,aAAa,GAAG,eAAe,GAAG;IAAE,oBAAoB,EAAE,MAAM,CAAA;CAAE,EAC1E,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,OAAO,EAAE,EACnB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,gBAAgB,EACzB,wBAAwB,EAAE,UAAU,EACpC,aAAa,GAAE,UAAU,EAAO,EAChC,MAAM,8CAA0B,8CAmBjC"}

package/dest/factory/create_implementation.js

@@ -0,0 +1,25 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { NullSlasherClient } from '../null_slasher_client.js';
+import { SlasherClient } from '../slasher_client.js';
+import { SlasherOffensesStore } from '../stores/offenses_store.js';
+import { getSlasherSettings } from './get_settings.js';
+/** Creates a slasher client implementation based on the slasher proposer type in the rollup */ export async function createSlasherImplementation(config, rollup, l1Client, watchers, epochCache, dateProvider, kvStore, rollupRegisteredAtL2Slot, ownValidators = [], logger = createLogger('slasher')) {
+    const proposer = await rollup.getSlashingProposer();
+    if (!proposer) {
+        return new NullSlasherClient(config);
+    } else {
+        return createSlasher(config, rollup, proposer, watchers, dateProvider, epochCache, kvStore, rollupRegisteredAtL2Slot, ownValidators, logger);
+    }
+}
+async function createSlasher(config, rollup, slashingProposer, watchers, dateProvider, epochCache, kvStore, rollupRegisteredAtL2Slot, ownValidators = [], logger = createLogger('slasher')) {
+    const settings = {
+        ...await getSlasherSettings(rollup, slashingProposer),
+        rollupRegisteredAtL2Slot
+    };
+    const slasher = await rollup.getSlasherContract();
+    const offensesStore = new SlasherOffensesStore(kvStore, {
+        ...settings,
+        slashOffenseExpirationRounds: config.slashOffenseExpirationRounds
+    });
+    return new SlasherClient(config, settings, slashingProposer, slasher, rollup, watchers, epochCache, dateProvider, offensesStore, ownValidators, logger);
+}

package/dest/factory/get_settings.d.ts

@@ -0,0 +1,4 @@
+import type { RollupContract, SlashingProposerContract } from '@aztec-labs/ethereum/contracts';
+import type { SlasherSettings } from '../slasher_client.js';
+export declare function getSlasherSettings(rollup: RollupContract, slashingProposer?: SlashingProposerContract): Promise<Omit<SlasherSettings, 'rollupRegisteredAtL2Slot'>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X3NldHRpbmdzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmFjdG9yeS9nZXRfc2V0dGluZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFL0YsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFNUQsd0JBQXNCLGtCQUFrQixDQUN0QyxNQUFNLEVBQUUsY0FBYyxFQUN0QixnQkFBZ0IsQ0FBQyxFQUFFLHdCQUF3QixHQUMxQyxPQUFPLENBQUMsSUFBSSxDQUFDLGVBQWUsRUFBRSwwQkFBMEIsQ0FBQyxDQUFDLENBa0Q1RCJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"get_settings.d.ts","sourceRoot":"","sources":["../../src/factory/get_settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAE/F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,cAAc,EACtB,gBAAgB,CAAC,EAAE,wBAAwB,GAC1C,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,0BAA0B,CAAC,CAAC,CAkD5D"}

package/dest/factory/get_settings.js

@@ -0,0 +1,36 @@
+export async function getSlasherSettings(rollup, slashingProposer) {
+    if (!slashingProposer) {
+        const rollupSlashingProposer = await rollup.getSlashingProposer();
+        if (!rollupSlashingProposer) {
+            throw new Error('Rollup slashing proposer not found');
+        }
+        slashingProposer = rollupSlashingProposer;
+    }
+    const [slashingExecutionDelayInRounds, slashingRoundSize, slashingRoundSizeInEpochs, slashingLifetimeInRounds, slashingOffsetInRounds, slashingAmounts, slashingQuorumSize, epochDuration, l1GenesisTime, slotDuration, targetCommitteeSize] = await Promise.all([
+        slashingProposer.getExecutionDelayInRounds(),
+        slashingProposer.getRoundSize(),
+        slashingProposer.getRoundSizeInEpochs(),
+        slashingProposer.getLifetimeInRounds(),
+        slashingProposer.getSlashOffsetInRounds(),
+        slashingProposer.getSlashingAmounts(),
+        slashingProposer.getQuorumSize(),
+        rollup.getEpochDuration(),
+        rollup.getL1GenesisTime(),
+        rollup.getSlotDuration(),
+        rollup.getTargetCommitteeSize()
+    ]);
+    const settings = {
+        slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
+        slashingRoundSize: Number(slashingRoundSize),
+        slashingRoundSizeInEpochs: Number(slashingRoundSizeInEpochs),
+        slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
+        slashingQuorumSize: Number(slashingQuorumSize),
+        epochDuration: Number(epochDuration),
+        l1GenesisTime: l1GenesisTime,
+        slotDuration: Number(slotDuration),
+        slashingOffsetInRounds: Number(slashingOffsetInRounds),
+        slashingAmounts,
+        targetCommitteeSize: Number(targetCommitteeSize)
+    };
+    return settings;
+}

package/dest/factory/index.d.ts

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

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

@@ -0,0 +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,kBAAkB,EAAE,MAAM,mBAAmB,CAAC"}

package/dest/factory/index.js

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

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

@@ -0,0 +1,21 @@
+/** Default slasher configuration values from network-defaults.yml */
+export declare const slasherDefaultEnv: {
+    readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
+    readonly SLASH_MAX_PAYLOAD_SIZE: 80;
+    readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
+    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_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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slasher-defaults.d.ts","sourceRoot":"","sources":["../../src/generated/slasher-defaults.ts"],"names":[],"mappings":"AAGA,qEAAqE;AACrE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;CAkBpB,CAAC"}