@aztec/stdlib 0.0.1-commit.f295ac2 → 0.0.1-commit.f8ca9b2f3

package/src/interfaces/validator.ts

@@ -51,18 +51,22 @@ export type ValidatorClientConfig = ValidatorHASignerConfig & {
   /** Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus */
   fishermanMode?: boolean;
 
-  // TODO(palla/mbps): Change default to false once checkpoint validation is stable
-  /** Skip checkpoint proposal validation and always attest (default: true) */
+  /** Skip checkpoint proposal validation and always attest (default: false) */
   skipCheckpointProposalValidation?: boolean;
 
-  // TODO(palla/mbps): Change default to false once block sync is stable
-  /** Skip pushing re-executed blocks to archiver (default: true) */
+  /** Skip pushing re-executed blocks to archiver (default: false) */
   skipPushProposedBlocksToArchiver?: boolean;
+
+  /** Agree to attest to equivocated checkpoint proposals (for testing purposes only) */
+  attestToEquivocatedProposals?: boolean;
 };
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
   Pick<SequencerConfig, 'txPublicSetupAllowList' | 'broadcastInvalidBlockProposal'> &
-  Pick<SlasherConfig, 'slashBroadcastedInvalidBlockPenalty'> & {
+  Pick<
+    SlasherConfig,
+    'slashBroadcastedInvalidBlockPenalty' | 'slashDuplicateProposalPenalty' | 'slashDuplicateAttestationPenalty'
+  > & {
     /**
      * Whether transactions are disabled for this node
      * @remarks This should match the property in P2PConfig. It's not picked from there to avoid circular dependencies.
@@ -81,6 +85,7 @@ export const ValidatorClientConfigSchema = zodFor<Omit<ValidatorClientConfig, 'v
     fishermanMode: z.boolean().optional(),
     skipCheckpointProposalValidation: z.boolean().optional(),
     skipPushProposedBlocksToArchiver: z.boolean().optional(),
+    attestToEquivocatedProposals: z.boolean().optional(),
   }),
 );
 
@@ -89,6 +94,8 @@ export const ValidatorClientFullConfigSchema = zodFor<Omit<ValidatorClientFullCo
     txPublicSetupAllowList: z.array(AllowedElementSchema).optional(),
     broadcastInvalidBlockProposal: z.boolean().optional(),
     slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+    slashDuplicateProposalPenalty: schemas.BigInt,
+    slashDuplicateAttestationPenalty: schemas.BigInt,
     disableTransactions: z.boolean().optional(),
   }),
 );

package/src/kernel/hints/build_nullifier_read_request_hints.ts

@@ -6,7 +6,6 @@ import {
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { MembershipWitness } from '@aztec/foundation/trees';
 
-import { siloNullifier } from '../../hash/hash.js';
 import type { NullifierLeafPreimage } from '../../trees/nullifier_leaf.js';
 import type { ClaimedLengthArray } from '../claimed_length_array.js';
 import type { ScopedNullifier } from '../nullifier.js';
@@ -74,7 +73,6 @@ export async function buildNullifierReadRequestHintsFromResetActions<PENDING ext
   resetActions: ReadRequestResetActions<typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
   maxPending: PENDING = MAX_NULLIFIER_READ_REQUESTS_PER_TX as PENDING,
   maxSettled: SETTLED = MAX_NULLIFIER_READ_REQUESTS_PER_TX as SETTLED,
-  siloed = false,
 ) {
   const builder = new NullifierReadRequestHintsBuilder(maxPending, maxSettled);
 
@@ -90,12 +88,7 @@ export async function buildNullifierReadRequestHintsFromResetActions<PENDING ext
     }
   }
 
-  // Compute siloed values in parallel (if not already siloed)
-  const siloedValues = siloed
-    ? settledRequests.map(({ readRequest }) => readRequest.value)
-    : await Promise.all(
-        settledRequests.map(({ readRequest }) => siloNullifier(readRequest.contractAddress, readRequest.value)),
-      );
+  const siloedValues = settledRequests.map(({ readRequest }) => readRequest.value);
 
   // Fetch all membership witnesses in parallel
   const membershipWitnesses = await Promise.all(siloedValues.map(value => oracle.getNullifierMembershipWitness(value)));
@@ -121,7 +114,6 @@ export async function buildNullifierReadRequestHints<PENDING extends number, SET
   futureNullifiers: ScopedNullifier[],
   maxPending: PENDING = MAX_NULLIFIER_READ_REQUESTS_PER_TX as PENDING,
   maxSettled: SETTLED = MAX_NULLIFIER_READ_REQUESTS_PER_TX as SETTLED,
-  siloed = false,
 ) {
   const resetActions = getNullifierReadRequestResetActions(nullifierReadRequests, nullifiers, futureNullifiers);
   return await buildNullifierReadRequestHintsFromResetActions(
@@ -130,6 +122,5 @@ export async function buildNullifierReadRequestHints<PENDING extends number, SET
     resetActions,
     maxPending,
     maxSettled,
-    siloed,
   );
 }

package/src/keys/derivation.ts

@@ -10,8 +10,8 @@ import type { KeyPrefix } from './key_types.js';
 import { PublicKeys } from './public_keys.js';
 import { getKeyGenerator } from './utils.js';
 
-export function computeAppNullifierSecretKey(masterNullifierSecretKey: GrumpkinScalar, app: AztecAddress): Promise<Fr> {
-  return computeAppSecretKey(masterNullifierSecretKey, app, 'n'); // 'n' is the key prefix for nullifier secret key
+export function computeAppNullifierHidingKey(masterNullifierHidingKey: GrumpkinScalar, app: AztecAddress): Promise<Fr> {
+  return computeAppSecretKey(masterNullifierHidingKey, app, 'n'); // 'n' is the key prefix for nullifier hiding key
 }
 
 export function computeAppSecretKey(skM: GrumpkinScalar, app: AztecAddress, keyPrefix: KeyPrefix): Promise<Fr> {
@@ -26,8 +26,8 @@ export async function computeOvskApp(ovsk: GrumpkinScalar, app: AztecAddress): P
   return GrumpkinScalar.fromBuffer(ovskAppFr.toBuffer());
 }
 
-export function deriveMasterNullifierSecretKey(secretKey: Fr): GrumpkinScalar {
-  return sha512ToGrumpkinScalar([secretKey, GeneratorIndex.NSK_M]);
+export function deriveMasterNullifierHidingKey(secretKey: Fr): GrumpkinScalar {
+  return sha512ToGrumpkinScalar([secretKey, GeneratorIndex.NHK_M]);
 }
 
 export function deriveMasterIncomingViewingSecretKey(secretKey: Fr): GrumpkinScalar {
@@ -93,15 +93,15 @@ export function derivePublicKeyFromSecretKey(secretKey: Fq) {
  * @returns The derived keys.
  */
 export async function deriveKeys(secretKey: Fr) {
-  // First we derive master secret keys -  we use sha512 here because this derivation will never take place
+  // First we derive master secret/hiding keys -  we use sha512 here because this derivation will never take place
   // in a circuit
-  const masterNullifierSecretKey = deriveMasterNullifierSecretKey(secretKey);
+  const masterNullifierHidingKey = deriveMasterNullifierHidingKey(secretKey);
   const masterIncomingViewingSecretKey = deriveMasterIncomingViewingSecretKey(secretKey);
   const masterOutgoingViewingSecretKey = deriveMasterOutgoingViewingSecretKey(secretKey);
   const masterTaggingSecretKey = sha512ToGrumpkinScalar([secretKey, GeneratorIndex.TSK_M]);
 
   // Then we derive master public keys
-  const masterNullifierPublicKey = await derivePublicKeyFromSecretKey(masterNullifierSecretKey);
+  const masterNullifierPublicKey = await derivePublicKeyFromSecretKey(masterNullifierHidingKey);
   const masterIncomingViewingPublicKey = await derivePublicKeyFromSecretKey(masterIncomingViewingSecretKey);
   const masterOutgoingViewingPublicKey = await derivePublicKeyFromSecretKey(masterOutgoingViewingSecretKey);
   const masterTaggingPublicKey = await derivePublicKeyFromSecretKey(masterTaggingSecretKey);
@@ -115,7 +115,7 @@ export async function deriveKeys(secretKey: Fr) {
   );
 
   return {
-    masterNullifierSecretKey,
+    masterNullifierHidingKey,
     masterIncomingViewingSecretKey,
     masterOutgoingViewingSecretKey,
     masterTaggingSecretKey,

package/src/keys/key_types.ts

@@ -1,5 +1,5 @@
 import type { GeneratorIndex } from '@aztec/constants';
 
-export type KeyGenerator = GeneratorIndex.NSK_M | GeneratorIndex.IVSK_M | GeneratorIndex.OVSK_M | GeneratorIndex.TSK_M;
+export type KeyGenerator = GeneratorIndex.NHK_M | GeneratorIndex.IVSK_M | GeneratorIndex.OVSK_M | GeneratorIndex.TSK_M;
 export type KeyPrefix = 'n' | 'iv' | 'ov' | 't';
 export const KEY_PREFIXES: KeyPrefix[] = ['n', 'iv', 'ov', 't'];

package/src/keys/utils.ts

@@ -3,7 +3,11 @@ import { GeneratorIndex } from '@aztec/constants';
 import type { KeyGenerator, KeyPrefix } from './key_types.js';
 
 export function getKeyGenerator(prefix: KeyPrefix): KeyGenerator {
-  // We get enum key by capitalizing key prefix and concatenating it with 'SK_M'
-  const enumKey = `${prefix.toUpperCase()}SK_M`;
-  return GeneratorIndex[enumKey as keyof typeof GeneratorIndex] as KeyGenerator;
+  const map: Record<KeyPrefix, KeyGenerator> = {
+    n: GeneratorIndex.NHK_M,
+    iv: GeneratorIndex.IVSK_M,
+    ov: GeneratorIndex.OVSK_M,
+    t: GeneratorIndex.TSK_M,
+  };
+  return map[prefix];
 }

package/src/l1-contracts/slash_factory.ts

@@ -41,6 +41,7 @@ export class SlashFactoryContract {
 
     return {
       to: this.contract.address,
+      abi: SlashFactoryAbi,
       data: encodeFunctionData({
         abi: SlashFactoryAbi,
         functionName: 'createSlashPayload',

package/src/logs/log_id.ts

@@ -1,26 +1,24 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
-import { L2BlockHash } from '../block/block_hash.js';
+import { BlockHash } from '../block/block_hash.js';
 import { schemas } from '../schemas/index.js';
+import { TxHash } from '../tx/tx_hash.js';
 
 /** A globally unique log id. */
 export class LogId {
-  /**
-   * Parses a log id from a string.
-   * @param blockNumber - The block number.
-   * @param txIndex - The transaction index.
-   * @param logIndex - The log index.
-   */
   constructor(
     /** The block number the log was emitted in. */
     public readonly blockNumber: BlockNumber,
     /** The hash of the block the log was emitted in. */
-    public readonly blockHash: L2BlockHash,
+    public readonly blockHash: BlockHash,
+    /** The hash of the transaction the log was emitted in. */
+    public readonly txHash: TxHash,
     /** The index of a tx in a block the log was emitted in. */
     public readonly txIndex: number,
     /** The index of a log the tx was emitted in. */
@@ -40,7 +38,8 @@ export class LogId {
   static random() {
     return new LogId(
       BlockNumber(Math.floor(Math.random() * 1000) + 1),
-      L2BlockHash.random(),
+      BlockHash.random(),
+      TxHash.random(),
       Math.floor(Math.random() * 1000),
       Math.floor(Math.random() * 100),
     );
@@ -50,12 +49,14 @@ export class LogId {
     return z
       .object({
         blockNumber: BlockNumberSchema,
-        blockHash: L2BlockHash.schema,
+        blockHash: BlockHash.schema,
+        txHash: TxHash.schema,
         txIndex: schemas.Integer,
         logIndex: schemas.Integer,
       })
       .transform(
-        ({ blockNumber, blockHash, txIndex, logIndex }) => new LogId(blockNumber, blockHash, txIndex, logIndex),
+        ({ blockNumber, blockHash, txHash, txIndex, logIndex }) =>
+          new LogId(blockNumber, blockHash, txHash, txIndex, logIndex),
       );
   }
 
@@ -67,6 +68,7 @@ export class LogId {
     return Buffer.concat([
       toBufferBE(BigInt(this.blockNumber), 4),
       this.blockHash.toBuffer(),
+      this.txHash.toBuffer(),
       toBufferBE(BigInt(this.txIndex), 4),
       toBufferBE(BigInt(this.logIndex), 4),
     ]);
@@ -81,11 +83,12 @@ export class LogId {
     const reader = BufferReader.asReader(buffer);
 
     const blockNumber = BlockNumber(reader.readNumber());
-    const blockHash = reader.readObject(L2BlockHash);
+    const blockHash = new BlockHash(reader.readObject(Fr));
+    const txHash = reader.readObject(TxHash);
     const txIndex = reader.readNumber();
     const logIndex = reader.readNumber();
 
-    return new LogId(blockNumber, blockHash, txIndex, logIndex);
+    return new LogId(blockNumber, blockHash, txHash, txIndex, logIndex);
   }
 
   /**
@@ -93,7 +96,7 @@ export class LogId {
    * @returns A string representation of the log id.
    */
   public toString(): string {
-    return `${this.blockNumber}-${this.txIndex}-${this.logIndex}-${this.blockHash.toString()}`;
+    return `${this.blockNumber}-${this.txIndex}-${this.logIndex}-${this.blockHash.toString()}-${this.txHash.toString()}`;
   }
 
   /**
@@ -102,13 +105,14 @@ export class LogId {
    * @returns A log id.
    */
   static fromString(data: string): LogId {
-    const [rawBlockNumber, rawTxIndex, rawLogIndex, rawBlockHash] = data.split('-');
+    const [rawBlockNumber, rawTxIndex, rawLogIndex, rawBlockHash, rawTxHash] = data.split('-');
     const blockNumber = BlockNumber(Number(rawBlockNumber));
-    const blockHash = L2BlockHash.fromString(rawBlockHash);
+    const blockHash = BlockHash.fromString(rawBlockHash);
+    const txHash = TxHash.fromString(rawTxHash);
     const txIndex = Number(rawTxIndex);
     const logIndex = Number(rawLogIndex);
 
-    return new LogId(blockNumber, blockHash, txIndex, logIndex);
+    return new LogId(blockNumber, blockHash, txHash, txIndex, logIndex);
   }
 
   /**
@@ -116,6 +120,6 @@ export class LogId {
    * @returns A human readable representation of the log id.
    */
   public toHumanReadable(): string {
-    return `logId: (blockNumber: ${this.blockNumber}, blockHash: ${this.blockHash.toString()}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
+    return `logId: (blockNumber: ${this.blockNumber}, blockHash: ${this.blockHash.toString()}, txHash: ${this.txHash.toString()}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
   }
 }

package/src/logs/siloed_tag.ts

@@ -1,4 +1,5 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { GeneratorIndex } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { ZodFor } from '@aztec/foundation/schemas';
 
@@ -22,7 +23,7 @@ export class SiloedTag {
   constructor(public readonly value: Fr) {}
 
   static async compute(tag: Tag, app: AztecAddress): Promise<SiloedTag> {
-    const siloedTag = await poseidon2Hash([app, tag.value]);
+    const siloedTag = await poseidon2HashWithSeparator([app, tag.value], GeneratorIndex.PRIVATE_LOG_FIRST_FIELD);
     return new SiloedTag(siloedTag);
   }
 

package/src/messaging/l2_to_l1_membership.ts

@@ -32,10 +32,10 @@ import { SiblingPath, UnbalancedMerkleTreeCalculator, computeUnbalancedShaRoot }
  *    - Compression: If a block has no messages (out hash = 0), that branch is ignored
  *
  * 4. **Epoch Tree**
- *    - Leaves: Checkpoint out hashes from all checkpoints in an epoch (padded to AZTEC_MAX_EPOCH_DURATION)
+ *    - Leaves: Checkpoint out hashes from all checkpoints in an epoch (padded to OUT_HASH_TREE_LEAF_COUNT)
  *    - Root: Epoch out hash (set in the root rollup's public inputs and inserted into the Outbox on L1 when the epoch is proven)
  *    - Type: Unbalanced, non-compressed
- *    - **Important**: Padded with zeros up to AZTEC_MAX_EPOCH_DURATION to allow for proofs of partial epochs
+ *    - **Important**: Padded with zeros up to OUT_HASH_TREE_LEAF_COUNT to allow for proofs of partial epochs
  *
  * ## Combined Membership Proof
  * To prove a message exists in an epoch, we combine the sibling paths from all 4 trees:
@@ -163,7 +163,7 @@ export function computeL2ToL1MembershipWitnessFromMessagesInEpoch(
     }
     return buildCheckpointTree(messagesInCheckpoint).getRoot();
   });
-  // Pad to AZTEC_MAX_EPOCH_DURATION with zeros.
+  // Pad to OUT_HASH_TREE_LEAF_COUNT with zeros.
   checkpointOutHashes = checkpointOutHashes.concat(
     Array.from({ length: OUT_HASH_TREE_LEAF_COUNT - messagesInEpoch.length }, () => Buffer.alloc(32)),
   );

package/src/p2p/block_proposal.ts

@@ -8,8 +8,8 @@ import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
 
+import type { L2Block } from '../block/l2_block.js';
 import type { L2BlockInfo } from '../block/l2_block_info.js';
-import type { L2BlockNew } from '../block/l2_block_new.js';
 import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { TxHash } from '../tx/index.js';
@@ -30,8 +30,15 @@ export class BlockProposalHash extends Buffer32 {
 }
 
 export type BlockProposalOptions = {
-  publishFullTxs: boolean;
-  /** Whether to generate an invalid block proposal for broadcasting. Use only for testing. */
+  /**
+   * Whether to include the tx objects along with the block proposal.
+   * Dramatically increases size of the payload but eliminates failed reexecutions due to missing txs.
+   */
+  publishFullTxs?: boolean;
+  /**
+   * Whether to generate an invalid block proposal for broadcasting.
+   * Use only for testing.
+   */
   broadcastInvalidBlockProposal?: boolean;
 };
 
@@ -284,10 +291,10 @@ export class BlockProposal extends Gossipable {
   /**
    * Check if this proposal matches the given block.
    * Compares the archive root and block header.
-   * @param block - The L2BlockNew to compare against
+   * @param block - The L2Block to compare against
    * @returns True if the proposal matches the block
    */
-  matchesBlock(block: L2BlockNew): boolean {
+  matchesBlock(block: L2Block): boolean {
     return this.archiveRoot.equals(block.archive.root) && this.blockHeader.equals(block.header);
   }
 

package/src/p2p/checkpoint_proposal.ts

@@ -32,8 +32,15 @@ export class CheckpointProposalHash extends Buffer32 {
 }
 
 export type CheckpointProposalOptions = {
-  publishFullTxs: boolean;
-  /** Whether to generate an invalid checkpoint proposal for broadcasting. Use only for testing. */
+  /**
+   * Whether to include the tx objects along with the block proposal.
+   * Dramatically increases size of the payload but eliminates failed reexecutions due to missing txs.
+   */
+  publishFullTxs?: boolean;
+  /**
+   * Whether to generate an invalid checkpoint proposal for broadcasting.
+   * Use only for testing.
+   */
   broadcastInvalidCheckpointProposal?: boolean;
 };
 
@@ -141,6 +148,16 @@ export class CheckpointProposal extends Gossipable {
     };
   }
 
+  toCheckpointInfo() {
+    return {
+      slotNumber: this.slotNumber,
+      archive: this.archive,
+      lastBlockNumber: this.lastBlock?.blockHeader.getBlockNumber(),
+      lastBlockIndex: this.lastBlock?.indexWithinCheckpoint,
+      blockHeadersHash: this.checkpointHeader.blockHeadersHash,
+    };
+  }
+
   /**
    * Get the payload to sign for this checkpoint proposal.
    * The signature is over the checkpoint header + archive root (for consensus).

package/src/p2p/constants.ts

@@ -0,0 +1,6 @@
+export const MAX_TX_SIZE_KB: number = 512;
+
+export const MAX_MESSAGE_SIZE_KB: number = 10 * 1024;
+
+/** Maximum size for L2Block response (contains TxEffects, not full Txs with proofs) */
+export const MAX_L2_BLOCK_SIZE_KB: number = 3 * 1024; // 3 MB

package/src/p2p/index.ts

@@ -11,3 +11,4 @@ export * from './topic_type.js';
 export * from './client_type.js';
 export * from './message_validator.js';
 export * from './peer_error.js';
+export * from './constants.js';

package/src/p2p/message_validator.ts

@@ -1,10 +1,22 @@
 import type { PeerErrorSeverity } from './peer_error.js';
 
+/**
+ * Result of validating a P2P message.
+ * - 'accept': Message is valid and should be accepted and processed
+ * - 'ignore': Message should be ignored (not propagated or processed, but sender not penalized)
+ * - 'reject': Message is invalid (rejected and sender penalized)
+ */
+export type ValidationResult =
+  | { result: 'accept' }
+  | { result: 'ignore' }
+  | { result: 'reject'; severity: PeerErrorSeverity };
+
 /**
  * P2PValidator
  *
- * A validator for P2P messages, which returns a severity of error to be applied to the peer
+ * A validator for P2P messages, which returns a ValidationResult indicating
+ * whether to accept, ignore, or reject the message
  */
 export interface P2PValidator<T> {
-  validate(message: T): Promise<PeerErrorSeverity | undefined>;
+  validate(message: T): Promise<ValidationResult>;
 }

package/src/rollup/checkpoint_rollup_public_inputs.ts

@@ -1,5 +1,5 @@
 import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
-import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import { MAX_CHECKPOINTS_PER_EPOCH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
@@ -38,11 +38,11 @@ export class CheckpointRollupPublicInputs {
     /**
      * The hashes of the headers of the constituent checkpoints.
      */
-    public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public checkpointHeaderHashes: Tuple<Fr, typeof MAX_CHECKPOINTS_PER_EPOCH>,
     /**
      * The summed transaction fees and recipients of the constituent checkpoints.
      */
-    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public fees: Tuple<FeeRecipient, typeof MAX_CHECKPOINTS_PER_EPOCH>,
     /**
      * Accumulated opening proofs for all blobs before this checkpoint range.
      */
@@ -65,8 +65,8 @@ export class CheckpointRollupPublicInputs {
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
       reader.readObject(BlobAccumulator),
       reader.readObject(BlobAccumulator),
       reader.readObject(FinalBlobBatchingChallenges),

package/src/rollup/root_rollup_public_inputs.ts

@@ -1,5 +1,5 @@
 import { FinalBlobAccumulator } from '@aztec/blob-lib/types';
-import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import { MAX_CHECKPOINTS_PER_EPOCH } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
@@ -27,8 +27,8 @@ export class RootRollupPublicInputs {
      */
     public outHash: Fr,
     /** Hashes of checkpoint headers for this rollup. */
-    public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
-    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public checkpointHeaderHashes: Tuple<Fr, typeof MAX_CHECKPOINTS_PER_EPOCH>,
+    public fees: Tuple<FeeRecipient, typeof MAX_CHECKPOINTS_PER_EPOCH>,
     public constants: EpochConstantData,
     public blobPublicInputs: FinalBlobAccumulator,
   ) {}
@@ -68,8 +68,8 @@ export class RootRollupPublicInputs {
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
       EpochConstantData.fromBuffer(reader),
       reader.readObject(FinalBlobAccumulator),
     );
@@ -99,8 +99,8 @@ export class RootRollupPublicInputs {
       Fr.random(),
       Fr.random(),
       Fr.random(),
-      makeTuple(AZTEC_MAX_EPOCH_DURATION, Fr.random),
-      makeTuple(AZTEC_MAX_EPOCH_DURATION, FeeRecipient.random),
+      makeTuple(MAX_CHECKPOINTS_PER_EPOCH, Fr.random),
+      makeTuple(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient.random),
       new EpochConstantData(Fr.random(), Fr.random(), Fr.random(), Fr.random(), Fr.random()),
       FinalBlobAccumulator.random(),
     );

package/src/slashing/empire.ts

@@ -83,7 +83,9 @@ export function getFirstEligibleRoundForOffense(
     case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
     case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
     case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
-    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL: {
+    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+    case OffenseType.DUPLICATE_PROPOSAL:
+    case OffenseType.DUPLICATE_ATTESTATION: {
       const slot = offense.epochOrSlot;
       const detectedSlot = SlotNumber.fromBigInt(slot + 1n);
       return getRoundForSlot(detectedSlot, constants).round + 1n;

package/src/slashing/helpers.ts

@@ -50,6 +50,8 @@ export function getPenaltyForOffense(
     SlasherConfig,
     | 'slashAttestDescendantOfInvalidPenalty'
     | 'slashBroadcastedInvalidBlockPenalty'
+    | 'slashDuplicateProposalPenalty'
+    | 'slashDuplicateAttestationPenalty'
     | 'slashPrunePenalty'
     | 'slashDataWithholdingPenalty'
     | 'slashUnknownPenalty'
@@ -71,6 +73,10 @@ export function getPenaltyForOffense(
       return config.slashAttestDescendantOfInvalidPenalty;
     case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
       return config.slashBroadcastedInvalidBlockPenalty;
+    case OffenseType.DUPLICATE_PROPOSAL:
+      return config.slashDuplicateProposalPenalty;
+    case OffenseType.DUPLICATE_ATTESTATION:
+      return config.slashDuplicateAttestationPenalty;
     case OffenseType.UNKNOWN:
       return config.slashUnknownPenalty;
     default: {
@@ -85,6 +91,8 @@ export function getTimeUnitForOffense(offense: OffenseType): 'epoch' | 'slot' {
   switch (offense) {
     case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
     case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+    case OffenseType.DUPLICATE_PROPOSAL:
+    case OffenseType.DUPLICATE_ATTESTATION:
     case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
     case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
       return 'slot';

package/src/slashing/tally.ts

@@ -1,4 +1,5 @@
 import { sumBigint } from '@aztec/foundation/bigint';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { PartialBy } from '@aztec/foundation/types';
 
@@ -20,9 +21,10 @@ export function getSlashConsensusVotesFromOffenses(
   settings: {
     slashingAmounts: [bigint, bigint, bigint];
     epochDuration: number;
+    targetCommitteeSize: number;
   },
 ): ValidatorSlashVote[] {
-  const { slashingAmounts } = settings;
+  const { slashingAmounts, targetCommitteeSize } = settings;
 
   if (committees.length !== epochsForCommittees.length) {
     throw new Error('committees and epochsForCommittees must have the same length');
@@ -31,7 +33,9 @@ export function getSlashConsensusVotesFromOffenses(
   const votes = committees.flatMap((committee, committeeIndex) => {
     const committeeEpoch = epochsForCommittees[committeeIndex];
 
-    return committee.map(validator => {
+    // Map over actual committee members, then pad to targetCommitteeSize.
+    // Padding handles cases where committees may be empty (e.g., when there aren't enough validators to fill the committee size during network startup).
+    const votes = committee.map(validator => {
       // Find offenses for this validator in this specific epoch.
       // If an offense has no epoch, it is considered for all epochs due to a slashAlways setting.
       const validatorOffenses = offenses.filter(
@@ -45,6 +49,8 @@ export function getSlashConsensusVotesFromOffenses(
       const slashUnits = getSlashUnitsForAmount(slashAmount, slashingAmounts);
       return Number(slashUnits);
     });
+
+    return padArrayEnd(votes, 0, targetCommitteeSize);
   });
 
   return votes;

package/src/slashing/types.ts

@@ -20,6 +20,10 @@ export enum OffenseType {
   PROPOSED_INCORRECT_ATTESTATIONS = 6,
   /** A committee member attested to a block that was built as a descendent of an invalid block (as in a block with invalid attestations) */
   ATTESTED_DESCENDANT_OF_INVALID = 7,
+  /** A proposer sent duplicate proposals for the same position (slot, indexWithinCheckpoint for blocks or slot for checkpoints) */
+  DUPLICATE_PROPOSAL = 8,
+  /** A validator signed attestations for different proposals at the same slot (equivocation) */
+  DUPLICATE_ATTESTATION = 9,
 }
 
 export function getOffenseTypeName(offense: OffenseType) {
@@ -40,6 +44,10 @@ export function getOffenseTypeName(offense: OffenseType) {
       return 'proposed_incorrect_attestations';
     case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
       return 'attested_descendant_of_invalid';
+    case OffenseType.DUPLICATE_PROPOSAL:
+      return 'duplicate_proposal';
+    case OffenseType.DUPLICATE_ATTESTATION:
+      return 'duplicate_attestation';
     default:
       throw new Error(`Unknown offense type: ${offense}`);
   }
@@ -56,6 +64,8 @@ export const OffenseToBigInt: Record<OffenseType, bigint> = {
   [OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS]: 5n,
   [OffenseType.PROPOSED_INCORRECT_ATTESTATIONS]: 6n,
   [OffenseType.ATTESTED_DESCENDANT_OF_INVALID]: 7n,
+  [OffenseType.DUPLICATE_PROPOSAL]: 8n,
+  [OffenseType.DUPLICATE_ATTESTATION]: 9n,
 };
 
 export function bigIntToOffense(offense: bigint): OffenseType {
@@ -76,6 +86,10 @@ export function bigIntToOffense(offense: bigint): OffenseType {
       return OffenseType.PROPOSED_INCORRECT_ATTESTATIONS;
     case 7n:
       return OffenseType.ATTESTED_DESCENDANT_OF_INVALID;
+    case 8n:
+      return OffenseType.DUPLICATE_PROPOSAL;
+    case 9n:
+      return OffenseType.DUPLICATE_ATTESTATION;
     default:
       throw new Error(`Unknown offense: ${offense}`);
   }

package/src/stats/stats.ts

@@ -202,8 +202,6 @@ export type L2BlockBuiltStats = {
   duration: number;
   /** Time for processing public txs in ms. */
   publicProcessDuration: number;
-  /** Time for running rollup circuits in ms.  */
-  rollupCircuitsDuration: number;
 } & L2BlockStats;
 
 /** Stats for an L2 block processed by the world state synchronizer. */