@aztec/stdlib 0.0.1-commit.1142ef1 → 0.0.1-commit.18ccd8f0

package/src/interfaces/validator.ts

@@ -1,3 +1,4 @@
+import type { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import type { SecretValue } from '@aztec/foundation/config';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
@@ -14,6 +15,7 @@ import type {
 } from '@aztec/stdlib/p2p';
 import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
+import { type ValidatorHASignerConfig, ValidatorHASignerConfigSchema } from '@aztec/validator-ha-signer/config';
 
 import type { PeerId } from '@libp2p/interface';
 import { z } from 'zod';
@@ -24,7 +26,7 @@ import { AllowedElementSchema } from './allowed_element.js';
 /**
  * Validator client configuration
  */
-export interface ValidatorClientConfig {
+export type ValidatorClientConfig = ValidatorHASignerConfig & {
   /** The private keys of the validators participating in attestation duties */
   validatorPrivateKeys?: SecretValue<`0x${string}`[]>;
 
@@ -43,23 +45,18 @@ export interface ValidatorClientConfig {
   /** Whether to re-execute transactions in a block proposal before attesting */
   validatorReexecute: boolean;
 
-  /** Will re-execute until this many milliseconds are left in the slot */
-  validatorReexecuteDeadlineMs: number;
-
   /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the currnet committee */
   alwaysReexecuteBlockProposals?: boolean;
 
   /** 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;
-}
+};
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
   Pick<SequencerConfig, 'txPublicSetupAllowList' | 'broadcastInvalidBlockProposal'> &
@@ -72,13 +69,12 @@ export type ValidatorClientFullConfig = ValidatorClientConfig &
   };
 
 export const ValidatorClientConfigSchema = zodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>()(
-  z.object({
+  ValidatorHASignerConfigSchema.extend({
     validatorAddresses: z.array(schemas.EthAddress).optional(),
     disableValidator: z.boolean(),
     disabledValidators: z.array(schemas.EthAddress),
     attestationPollingIntervalMs: z.number().min(0),
     validatorReexecute: z.boolean(),
-    validatorReexecuteDeadlineMs: z.number().min(0),
     alwaysReexecuteBlockProposals: z.boolean().optional(),
     fishermanMode: z.boolean().optional(),
     skipCheckpointProposalValidation: z.boolean().optional(),
@@ -148,5 +144,7 @@ export interface Validator {
   signAttestationsAndSigners(
     attestationsAndSigners: CommitteeAttestationsAndSigners,
     proposer: EthAddress,
+    slot: SlotNumber,
+    blockNumber: BlockNumber | CheckpointNumber,
   ): Promise<Signature>;
 }

package/src/kernel/hints/build_note_hash_read_request_hints.ts

@@ -76,17 +76,28 @@ export async function buildNoteHashReadRequestHintsFromResetActions<PENDING exte
     builder.addPendingReadRequest(hint.readRequestIndex, hint.pendingValueIndex);
   });
 
+  // Collect all settled read requests
+  const settledRequests: { index: number; readRequest: ScopedReadRequest }[] = [];
   for (let i = 0; i < resetActions.actions.length; i++) {
     if (resetActions.actions[i] === ReadRequestActionEnum.READ_AS_SETTLED) {
-      const readRequest = noteHashReadRequests.array[i];
-      const membershipWitness = await oracle.getNoteHashMembershipWitness(readRequest.value);
-      if (!membershipWitness) {
-        throw new Error('Read request is reading an unknown note hash.');
-      }
-      builder.addSettledReadRequest(i, membershipWitness, readRequest.value);
+      settledRequests.push({ index: i, readRequest: noteHashReadRequests.array[i] });
     }
   }
 
+  // Fetch all membership witnesses in parallel
+  const membershipWitnesses = await Promise.all(
+    settledRequests.map(({ readRequest }) => oracle.getNoteHashMembershipWitness(readRequest.value)),
+  );
+
+  // Add settled read requests to builder
+  for (let i = 0; i < settledRequests.length; i++) {
+    const membershipWitness = membershipWitnesses[i];
+    if (!membershipWitness) {
+      throw new Error('Read request is reading an unknown note hash.');
+    }
+    builder.addSettledReadRequest(settledRequests[i].index, membershipWitness, settledRequests[i].readRequest.value);
+  }
+
   const noteHashMap: Map<bigint, { noteHash: ScopedNoteHash; index: number }[]> = new Map();
   noteHashes.getActiveItems().forEach((noteHash, index) => {
     const value = noteHash.value.toBigInt();

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);
 
@@ -82,21 +80,28 @@ export async function buildNullifierReadRequestHintsFromResetActions<PENDING ext
     builder.addPendingReadRequest(hint.readRequestIndex, hint.pendingValueIndex);
   });
 
+  // Collect all settled read requests
+  const settledRequests: { index: number; readRequest: ScopedReadRequest }[] = [];
   for (let i = 0; i < resetActions.actions.length; i++) {
     if (resetActions.actions[i] === ReadRequestActionEnum.READ_AS_SETTLED) {
-      const readRequest = nullifierReadRequests.array[i];
-      const siloedValue = siloed
-        ? readRequest.value
-        : await siloNullifier(readRequest.contractAddress, readRequest.value);
-      const membershipWitnessWithPreimage = await oracle.getNullifierMembershipWitness(siloedValue);
-      builder.addSettledReadRequest(
-        i,
-        membershipWitnessWithPreimage.membershipWitness,
-        membershipWitnessWithPreimage.leafPreimage,
-      );
+      settledRequests.push({ index: i, readRequest: nullifierReadRequests.array[i] });
     }
   }
 
+  const siloedValues = settledRequests.map(({ readRequest }) => readRequest.value);
+
+  // Fetch all membership witnesses in parallel
+  const membershipWitnesses = await Promise.all(siloedValues.map(value => oracle.getNullifierMembershipWitness(value)));
+
+  // Add settled read requests to builder
+  for (let i = 0; i < settledRequests.length; i++) {
+    builder.addSettledReadRequest(
+      settledRequests[i].index,
+      membershipWitnesses[i].membershipWitness,
+      membershipWitnesses[i].leafPreimage,
+    );
+  }
+
   return builder.toHints();
 }
 
@@ -109,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(
@@ -118,6 +122,5 @@ export async function buildNullifierReadRequestHints<PENDING extends number, SET
     resetActions,
     maxPending,
     maxSettled,
-    siloed,
   );
 }

package/src/logs/log_id.ts

@@ -5,7 +5,7 @@ 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';
 
 /** A globally unique log id. */
@@ -20,7 +20,7 @@ export class LogId {
     /** 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 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 +40,7 @@ export class LogId {
   static random() {
     return new LogId(
       BlockNumber(Math.floor(Math.random() * 1000) + 1),
-      L2BlockHash.random(),
+      BlockHash.random(),
       Math.floor(Math.random() * 1000),
       Math.floor(Math.random() * 100),
     );
@@ -50,7 +50,7 @@ export class LogId {
     return z
       .object({
         blockNumber: BlockNumberSchema,
-        blockHash: L2BlockHash.schema,
+        blockHash: BlockHash.schema,
         txIndex: schemas.Integer,
         logIndex: schemas.Integer,
       })
@@ -81,7 +81,7 @@ export class LogId {
     const reader = BufferReader.asReader(buffer);
 
     const blockNumber = BlockNumber(reader.readNumber());
-    const blockHash = reader.readObject(L2BlockHash);
+    const blockHash = reader.readObject(BlockHash);
     const txIndex = reader.readNumber();
     const logIndex = reader.readNumber();
 
@@ -104,7 +104,7 @@ export class LogId {
   static fromString(data: string): LogId {
     const [rawBlockNumber, rawTxIndex, rawLogIndex, rawBlockHash] = data.split('-');
     const blockNumber = BlockNumber(Number(rawBlockNumber));
-    const blockHash = L2BlockHash.fromString(rawBlockHash);
+    const blockHash = BlockHash.fromString(rawBlockHash);
     const txIndex = Number(rawTxIndex);
     const logIndex = Number(rawLogIndex);
 

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

@@ -1,4 +1,4 @@
-import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import { OUT_HASH_TREE_LEAF_COUNT } from '@aztec/constants';
 import type { EpochNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { SiblingPath, UnbalancedMerkleTreeCalculator, computeUnbalancedShaRoot } from '@aztec/foundation/trees';
@@ -165,10 +165,12 @@ export function computeL2ToL1MembershipWitnessFromMessagesInEpoch(
   });
   // Pad to AZTEC_MAX_EPOCH_DURATION with zeros.
   checkpointOutHashes = checkpointOutHashes.concat(
-    Array.from({ length: AZTEC_MAX_EPOCH_DURATION - messagesInEpoch.length }, () => Buffer.alloc(32)),
+    Array.from({ length: OUT_HASH_TREE_LEAF_COUNT - messagesInEpoch.length }, () => Buffer.alloc(32)),
   );
 
-  // Build the epoch tree with all the checkpoint out hashes, including the padded zeros
+  // Build the epoch tree with all the checkpoint out hashes, including the padded zeros.
+  // Note: The epoch tree is actually a balanced tree, but we use an unbalanced tree calculator here to avoid turning
+  // this function into async.
   const epochTree = UnbalancedMerkleTreeCalculator.create(checkpointOutHashes);
   // Get the sibling path of the checkpoint out hash in the epoch tree.
   const pathToCheckpointOutHashInEpochTree = epochTree.getSiblingPathByLeafIndex(checkpointIndex);

package/src/messaging/out_hash.ts

@@ -1,46 +1,77 @@
-import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import { OUT_HASH_TREE_LEAF_COUNT } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { computeCompressedUnbalancedShaRoot, computeUnbalancedShaRoot } from '@aztec/foundation/trees';
+import { computeBalancedShaRoot, computeUnbalancedShaRoot, computeWonkyShaRoot } from '@aztec/foundation/trees';
 
+/**
+ * Computes the out hash of a tx. It's the root of the unbalanced tree of all the L2-to-L1 messages emitted by the tx.
+ * @param messages - The L2-to-L1 messages emitted by the tx.
+ * @returns The out hash of the tx.
+ */
 export function computeTxOutHash(messages: Fr[]): Fr {
+  // Must match the implementation in `tx_base_public_inputs_composer.nr > compute_kernel_out_hash()`
   if (!messages.length) {
     return Fr.ZERO;
   }
-  // Tx out hash is the root of the unbalanced merkle tree of all the messages.
-  // Zero hashes (which should not happen) are not compressed.
+  // It's an unbalanced tree because zero hashes (which should not happen) will be included.
   return Fr.fromBuffer(computeUnbalancedShaRoot(messages.map(msg => msg.toBuffer())));
 }
 
-export function computeBlockOutHash(messagesPerBlock: Fr[][]): Fr {
-  const txOutHashes = messagesPerBlock.map(messages => computeTxOutHash(messages));
-  return aggregateOutHashes(txOutHashes);
+/**
+ * Computes the out hash of a block. It's the root of the wonky tree of all the tx out hashes.
+ * @param messagesPerTx - The L2-to-L1 messages emitted by the txs in the block. This is an array of message arrays.
+ * The array at index 0 contains the messages emitted by the first tx, the array at index 1 contains the messages
+ * emitted by the second tx, and so on.
+ * @returns The out hash of the block.
+ */
+export function computeBlockOutHash(messagesPerTx: Fr[][]): Fr {
+  // See how the tx out hashes are aggregated into a block out hash in `merge_tx_rollups.nr > accumulate_out_hash()`.
+  const txOutHashes = messagesPerTx.map(messages => computeTxOutHash(messages));
+  return Fr.fromBuffer(computeWonkyShaRoot(txOutHashes.map(hash => hash.toBuffer())));
 }
 
-export function computeCheckpointOutHash(messagesForAllTxs: Fr[][][]): Fr {
-  const blockOutHashes = messagesForAllTxs.map(block => computeBlockOutHash(block));
-  return aggregateOutHashes(blockOutHashes);
+/**
+ * Computes the out hash of a checkpoint. It's the root of the wonky tree of all the block out hashes.
+ * @param messagesPerBlock - The L2-to-L1 messages emitted by the txs in the blocks in the checkpoint. This is an array
+ * of arrays of messages. The array at index 0 contains the arrays of messages emitted by the first block, the array at
+ * index 1 contains the arrays of messages emitted by the second block, and so on.
+ * @returns The out hash of the checkpoint.
+ */
+export function computeCheckpointOutHash(messagesPerBlock: Fr[][][]): Fr {
+  // See how the block out hashes are aggregated into a checkpoint out hash in `merge_block_rollups.nr > accumulate_out_hash()`.
+  const blockOutHashes = messagesPerBlock.map(block => computeBlockOutHash(block));
+  return Fr.fromBuffer(computeWonkyShaRoot(blockOutHashes.map(hash => hash.toBuffer())));
 }
 
-export function computeEpochOutHash(messagesInEpoch: Fr[][][][]): Fr {
-  // Must match the implementation in `compute_epoch_out_hash.nr`.
-  const checkpointOutHashes = messagesInEpoch
-    .map(checkpoint => computeCheckpointOutHash(checkpoint))
-    .map(hash => hash.toBuffer());
-  if (checkpointOutHashes.every(hash => hash.equals(Buffer.alloc(32)))) {
-    return Fr.ZERO;
-  }
-
-  const paddedOutHashes = padArrayEnd(checkpointOutHashes, Buffer.alloc(32), AZTEC_MAX_EPOCH_DURATION);
-  return Fr.fromBuffer(computeUnbalancedShaRoot(paddedOutHashes));
+/**
+ * Computes the accumulated (epoch) out hash of a checkpoint. It's the root of the balanced tree of all the out hashes
+ * from the first checkpoint in an epoch to the current checkpoint.
+ * It's this value that's set to the checkpoint header and validated on L1 instead of the checkpoint out hash.
+ * @param checkpointOutHashes - The out hashes of all checkpoints in the epoch.
+ * @returns The accumulated (epoch) out hash.
+ */
+export function accumulateCheckpointOutHashes(checkpointOutHashes: Fr[]): Fr {
+  // See how the checkpoint out hashes are accumulated in `checkpoint_rollup_public_inputs_composer.nr > accumulate_checkpoint_out_hash()`.
+  const paddedOutHashes = padArrayEnd(
+    checkpointOutHashes.map(hash => hash.toBuffer()),
+    Buffer.alloc(32),
+    OUT_HASH_TREE_LEAF_COUNT,
+  );
+  return Fr.fromBuffer(computeBalancedShaRoot(paddedOutHashes));
 }
 
-// The root of this tree should match the `out_hash` calculated in the circuits. Zero hashes are compressed to reduce
-// cost if the non-zero leaves result in a shorter path.
-function aggregateOutHashes(outHashes: Fr[]): Fr {
-  if (!outHashes.length) {
-    return Fr.ZERO;
-  }
-
-  return Fr.fromBuffer(computeCompressedUnbalancedShaRoot(outHashes.map(hash => hash.toBuffer())));
+/**
+ * Computes the epoch out hash. It's the root of the balanced tree of all the checkpoint out hashes.
+ * It should match the **accumulated** out hash of the last checkpoint in the epoch.
+ * This value will be inserted into the Outbox on L1.
+ * @param messagesPerCheckpoint - The L2-to-L1 messages emitted by the txs in the blocks in the checkpoints in the epoch.
+ * This is an array of arrays of arrays of messages. The array at index 0 contains the arrays of arrays of messages
+ * emitted by the first checkpoint, the array at index 1 contains the arrays of arrays of messages emitted by the second
+ * checkpoint, and so on.
+ * @returns The epoch out hash.
+ */
+export function computeEpochOutHash(messagesPerCheckpoint: Fr[][][][]): Fr {
+  // See how the accumulated out hash is assigned to the root rollup's public inputs in `root_rollup.nr`.
+  const checkpointOutHashes = messagesPerCheckpoint.map(checkpoint => computeCheckpointOutHash(checkpoint));
+  return accumulateCheckpointOutHashes(checkpointOutHashes);
 }

package/src/note/note_dao.ts

@@ -1,4 +1,3 @@
-import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { Point } from '@aztec/foundation/curves/grumpkin';
@@ -56,8 +55,10 @@ export class NoteDao {
     /** The L2 block hash in which the tx with this note was included. Used for note management while processing
      * reorgs.*/
     public l2BlockHash: string,
-    /** The index of the leaf in the global note hash tree the note is stored at */
-    public index: bigint,
+    /** The index of the tx within the block, used for ordering notes. */
+    public txIndexInBlock: number,
+    /** The index of the note within the tx (based on note hash position), used for ordering notes. */
+    public noteIndexInTx: number,
   ) {}
 
   toBuffer(): Buffer {
@@ -73,7 +74,8 @@ export class NoteDao {
       this.txHash,
       this.l2BlockNumber,
       Fr.fromHexString(this.l2BlockHash),
-      this.index,
+      this.txIndexInBlock,
+      this.noteIndexInTx,
     ]);
   }
 
@@ -91,7 +93,8 @@ export class NoteDao {
     const txHash = reader.readObject(TxHash);
     const l2BlockNumber = BlockNumber(reader.readNumber());
     const l2BlockHash = Fr.fromBuffer(reader).toString();
-    const index = toBigIntBE(reader.readBytes(32));
+    const txIndexInBlock = reader.readNumber();
+    const noteIndexInTx = reader.readNumber();
 
     return new NoteDao(
       note,
@@ -105,7 +108,8 @@ export class NoteDao {
       txHash,
       l2BlockNumber,
       l2BlockHash,
-      index,
+      txIndexInBlock,
+      noteIndexInTx,
     );
   }
 
@@ -134,7 +138,8 @@ export class NoteDao {
       this.txHash.equals(other.txHash) &&
       this.l2BlockNumber === other.l2BlockNumber &&
       this.l2BlockHash === other.l2BlockHash &&
-      this.index === other.index
+      this.txIndexInBlock === other.txIndexInBlock &&
+      this.noteIndexInTx === other.noteIndexInTx
     );
   }
 
@@ -143,11 +148,9 @@ export class NoteDao {
    * @returns - Its size in bytes.
    */
   public getSize() {
-    const indexSize = Math.ceil(Math.log2(Number(this.index)));
     const noteSize = 4 + this.note.items.length * Fr.SIZE_IN_BYTES;
-    return (
-      noteSize + AztecAddress.SIZE_IN_BYTES * 2 + Fr.SIZE_IN_BYTES * 4 + TxHash.SIZE + Point.SIZE_IN_BYTES + indexSize
-    );
+    // 2 numbers for txIndexInBlock and noteIndexInTx (4 bytes each)
+    return noteSize + AztecAddress.SIZE_IN_BYTES * 2 + Fr.SIZE_IN_BYTES * 4 + TxHash.SIZE + Point.SIZE_IN_BYTES + 8;
   }
 
   static async random({
@@ -162,7 +165,8 @@ export class NoteDao {
     txHash = TxHash.random(),
     l2BlockNumber = BlockNumber(Math.floor(Math.random() * 1000)),
     l2BlockHash = Fr.random().toString(),
-    index = Fr.random().toBigInt(),
+    txIndexInBlock = Math.floor(Math.random() * 100),
+    noteIndexInTx = Math.floor(Math.random() * 100),
   }: Partial<NoteDao> = {}) {
     return new NoteDao(
       note,
@@ -176,7 +180,8 @@ export class NoteDao {
       txHash,
       l2BlockNumber,
       l2BlockHash,
-      index,
+      txIndexInBlock,
+      noteIndexInTx,
     );
   }
 }

package/src/p2p/block_proposal.ts

@@ -1,4 +1,4 @@
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256 } from '@aztec/foundation/crypto/keccak';
 import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
@@ -6,9 +6,11 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 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 { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { TxHash } from '../tx/index.js';
 import type { Tx } from '../tx/tx.js';
@@ -28,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;
 };
 
@@ -50,7 +59,7 @@ export class BlockProposal extends Gossipable {
     // TODO(palla/mbps): Is this really needed? Can we just derive it from the indexWithinCheckpoint of the parent block and the slot number?
     // See the block-proposal-handler, we have a lot of extra validations to check this is correct, so maybe we can avoid storing it here.
     /** Index of this block within the checkpoint (0-indexed) */
-    public readonly indexWithinCheckpoint: number,
+    public readonly indexWithinCheckpoint: IndexWithinCheckpoint,
 
     /** Hash of L1 to L2 messages for this checkpoint (constant across all blocks in checkpoint) */
     public readonly inHash: Fr,
@@ -119,12 +128,12 @@ export class BlockProposal extends Gossipable {
 
   static async createProposalFromSigner(
     blockHeader: BlockHeader,
-    indexWithinCheckpoint: number,
+    indexWithinCheckpoint: IndexWithinCheckpoint,
     inHash: Fr,
     archiveRoot: Fr,
     txHashes: TxHash[],
     txs: Tx[] | undefined,
-    payloadSigner: (payload: Buffer32) => Promise<Signature>,
+    payloadSigner: (payload: Buffer32, context: SigningContext) => Promise<Signature>,
   ): Promise<BlockProposal> {
     // Create a temporary proposal to get the payload to sign
     const tempProposal = new BlockProposal(
@@ -136,13 +145,23 @@ export class BlockProposal extends Gossipable {
       Signature.empty(),
     );
 
+    // Create the block signing context
+    const blockContext: SigningContext = {
+      slot: blockHeader.globalVariables.slotNumber,
+      blockNumber: blockHeader.globalVariables.blockNumber,
+      blockIndexWithinCheckpoint: indexWithinCheckpoint,
+      dutyType: DutyType.BLOCK_PROPOSAL,
+    };
+
     const hashed = getHashedSignaturePayload(tempProposal, SignatureDomainSeparator.blockProposal);
-    const sig = await payloadSigner(hashed);
+    const sig = await payloadSigner(hashed, blockContext);
 
     // If txs are provided, sign them as well
     let signedTxs: SignedTxs | undefined;
     if (txs) {
-      signedTxs = await SignedTxs.createFromSigner(txs, payloadSigner);
+      const txsSigningContext: SigningContext = { dutyType: DutyType.TXS };
+      const txsSigner = (payload: Buffer32) => payloadSigner(payload, txsSigningContext);
+      signedTxs = await SignedTxs.createFromSigner(txs, txsSigner);
     }
 
     return new BlockProposal(blockHeader, indexWithinCheckpoint, inHash, archiveRoot, txHashes, sig, signedTxs);
@@ -200,11 +219,15 @@ export class BlockProposal extends Gossipable {
     const reader = BufferReader.asReader(buf);
 
     const blockHeader = reader.readObject(BlockHeader);
-    const indexWithinCheckpoint = reader.readNumber();
+    const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
     const inHash = reader.readObject(Fr);
     const archiveRoot = reader.readObject(Fr);
     const signature = reader.readObject(Signature);
-    const txHashes = reader.readArray(reader.readNumber(), TxHash);
+    const txHashCount = reader.readNumber();
+    if (txHashCount > MAX_TXS_PER_BLOCK) {
+      throw new Error(`txHashes count ${txHashCount} exceeds maximum ${MAX_TXS_PER_BLOCK}`);
+    }
+    const txHashes = reader.readArray(txHashCount, TxHash);
 
     if (!reader.isEmpty()) {
       const hasSignedTxs = reader.readNumber();
@@ -240,13 +263,13 @@ export class BlockProposal extends Gossipable {
   }
 
   static empty(): BlockProposal {
-    return new BlockProposal(BlockHeader.empty(), 0, Fr.ZERO, Fr.ZERO, [], Signature.empty());
+    return new BlockProposal(BlockHeader.empty(), IndexWithinCheckpoint(0), Fr.ZERO, Fr.ZERO, [], Signature.empty());
   }
 
   static random(): BlockProposal {
     return new BlockProposal(
       BlockHeader.random(),
-      Math.floor(Math.random() * 5),
+      IndexWithinCheckpoint(Math.floor(Math.random() * 5)),
       Fr.random(),
       Fr.random(),
       [TxHash.random(), TxHash.random()],
@@ -272,7 +295,7 @@ export class BlockProposal extends Gossipable {
    * @returns True if the proposal matches the block
    */
   matchesBlock(block: L2Block): boolean {
-    return this.archiveRoot.equals(block.archive.root) && this.blockHeader.equals(block.getBlockHeader());
+    return this.archiveRoot.equals(block.archive.root) && this.blockHeader.equals(block.header);
   }
 
   /**