@aztec/stdlib 1.2.1 → 2.0.0-nightly.20250813

package/src/kernel/private_to_rollup_kernel_circuit_public_inputs.ts

@@ -2,14 +2,14 @@ import { GeneratorIndex, PRIVATE_TO_ROLLUP_KERNEL_CIRCUIT_PUBLIC_INPUTS_LENGTH }
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import type { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
-import { BufferReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { AztecAddress } from '../aztec-address/index.js';
 import { Gas } from '../gas/gas.js';
 import { TxConstantData } from '../tx/tx_constant_data.js';
-import { RollupValidationRequests } from './hints/rollup_validation_requests.js';
+import type { UInt64 } from '../types/index.js';
 import { PrivateToRollupAccumulatedData } from './private_to_rollup_accumulated_data.js';
 
 /**
@@ -22,10 +22,6 @@ export class PrivateToRollupKernelCircuitPublicInputs {
      * Data which is not modified by the circuits.
      */
     public constants: TxConstantData,
-    /**
-     * Validation requests accumulated from private and public execution to be completed by the rollup.
-     */
-    public rollupValidationRequests: RollupValidationRequests,
     /**
      * Data accumulated from both public and private circuits.
      */
@@ -38,6 +34,10 @@ export class PrivateToRollupKernelCircuitPublicInputs {
      * The address of the fee payer for the transaction.
      */
     public feePayer: AztecAddress,
+    /**
+     * The timestamp by which the transaction must be included in a block.
+     */
+    public includeByTimestamp: UInt64,
   ) {}
 
   getNonEmptyNullifiers() {
@@ -45,7 +45,13 @@ export class PrivateToRollupKernelCircuitPublicInputs {
   }
 
   toBuffer() {
-    return serializeToBuffer(this.constants, this.rollupValidationRequests, this.end, this.gasUsed, this.feePayer);
+    return serializeToBuffer(
+      this.constants,
+      this.end,
+      this.gasUsed,
+      this.feePayer,
+      bigintToUInt64BE(this.includeByTimestamp),
+    );
   }
 
   /**
@@ -57,20 +63,20 @@ export class PrivateToRollupKernelCircuitPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new PrivateToRollupKernelCircuitPublicInputs(
       reader.readObject(TxConstantData),
-      reader.readObject(RollupValidationRequests),
       reader.readObject(PrivateToRollupAccumulatedData),
       reader.readObject(Gas),
       reader.readObject(AztecAddress),
+      reader.readUInt64(),
     );
   }
 
   static empty() {
     return new PrivateToRollupKernelCircuitPublicInputs(
       TxConstantData.empty(),
-      RollupValidationRequests.empty(),
       PrivateToRollupAccumulatedData.empty(),
       Gas.empty(),
       AztecAddress.ZERO,
+      0n,
     );
   }
 
@@ -88,7 +94,7 @@ export class PrivateToRollupKernelCircuitPublicInputs {
   }
 
   static getFields(fields: FieldsOf<PrivateToRollupKernelCircuitPublicInputs>) {
-    return [fields.constants, fields.rollupValidationRequests, fields.end, fields.gasUsed, fields.feePayer] as const;
+    return [fields.constants, fields.end, fields.gasUsed, fields.feePayer, fields.includeByTimestamp] as const;
   }
 
   /** Creates an instance from a hex string. */

package/src/kernel/private_validation_requests.ts

@@ -3,17 +3,14 @@ import {
   MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
 } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
-import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
-import type { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
 
 import { ScopedKeyValidationRequestAndGenerator } from '../kernel/hints/scoped_key_validation_request_and_generator.js';
+import { ClaimedLengthArray, ClaimedLengthArrayFromBuffer } from './claimed_length_array.js';
 import { ScopedReadRequest } from './hints/read_request.js';
-import { RollupValidationRequests } from './hints/rollup_validation_requests.js';
 import { OptionalNumber } from './utils/optional_number.js';
 
 /**
@@ -21,23 +18,18 @@ import { OptionalNumber } from './utils/optional_number.js';
  */
 export class PrivateValidationRequests {
   constructor(
-    /**
-     * Validation requests that cannot be fulfilled in the current context (private or public), and must be instead be
-     * forwarded to the rollup for it to take care of them.
-     */
-    public forRollup: RollupValidationRequests,
     /**
      * All the read requests made in this transaction.
      */
-    public noteHashReadRequests: Tuple<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
+    public noteHashReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
     /**
      * All the nullifier read requests made in this transaction.
      */
-    public nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+    public nullifierReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
     /**
      * All the key validation requests made in this transaction.
      */
-    public scopedKeyValidationRequestsAndGenerators: Tuple<
+    public scopedKeyValidationRequestsAndGenerators: ClaimedLengthArray<
       ScopedKeyValidationRequestAndGenerator,
       typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX
     >,
@@ -51,17 +43,15 @@ export class PrivateValidationRequests {
 
   getSize() {
     return (
-      this.forRollup.getSize() +
-      arraySerializedSizeOfNonEmpty(this.noteHashReadRequests) +
-      arraySerializedSizeOfNonEmpty(this.nullifierReadRequests) +
-      arraySerializedSizeOfNonEmpty(this.scopedKeyValidationRequestsAndGenerators) +
+      this.noteHashReadRequests.getSize() +
+      this.nullifierReadRequests.getSize() +
+      this.scopedKeyValidationRequestsAndGenerators.getSize() +
       this.splitCounter.getSize()
     );
   }
 
   toBuffer() {
     return serializeToBuffer(
-      this.forRollup,
       this.noteHashReadRequests,
       this.nullifierReadRequests,
       this.scopedKeyValidationRequestsAndGenerators,
@@ -73,17 +63,6 @@ export class PrivateValidationRequests {
     return bufferToHex(this.toBuffer());
   }
 
-  static fromFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    return new PrivateValidationRequests(
-      reader.readObject(RollupValidationRequests),
-      reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest),
-      reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest),
-      reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator),
-      reader.readObject(OptionalNumber),
-    );
-  }
-
   /**
    * Deserializes from a buffer or reader, corresponding to a write in cpp.
    * @param buffer - Buffer or reader to read from.
@@ -92,10 +71,11 @@ export class PrivateValidationRequests {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PrivateValidationRequests(
-      reader.readObject(RollupValidationRequests),
-      reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest),
-      reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest),
-      reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_TX)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_TX)),
+      reader.readObject(
+        ClaimedLengthArrayFromBuffer(ScopedKeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_TX),
+      ),
       reader.readObject(OptionalNumber),
     );
   }
@@ -111,29 +91,18 @@ export class PrivateValidationRequests {
 
   static empty() {
     return new PrivateValidationRequests(
-      RollupValidationRequests.empty(),
-      makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest.empty),
-      makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest.empty),
-      makeTuple(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator.empty),
+      ClaimedLengthArray.empty(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_TX),
+      ClaimedLengthArray.empty(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_TX),
+      ClaimedLengthArray.empty(ScopedKeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_TX),
       OptionalNumber.empty(),
     );
   }
 
   [inspect.custom]() {
     return `PrivateValidationRequests {
-  forRollup: ${inspect(this.forRollup)},
-  noteHashReadRequests: [${this.noteHashReadRequests
-    .filter(x => !x.isEmpty())
-    .map(h => inspect(h))
-    .join(', ')}],
-  nullifierReadRequests: [${this.nullifierReadRequests
-    .filter(x => !x.isEmpty())
-    .map(h => inspect(h))
-    .join(', ')}],
-  scopedKeyValidationRequestsAndGenerators: [${this.scopedKeyValidationRequestsAndGenerators
-    .filter(x => !x.isEmpty())
-    .map(h => inspect(h))
-    .join(', ')}],
+  noteHashReadRequests: ${inspect(this.noteHashReadRequests)},
+  nullifierReadRequests: ${inspect(this.nullifierReadRequests)},
+  scopedKeyValidationRequestsAndGenerators: ${inspect(this.scopedKeyValidationRequestsAndGenerators)},
   splitCounter: ${this.splitCounter.getSize()}
   `;
   }

package/src/kernel/utils/order_and_comparison.ts

@@ -17,23 +17,6 @@ export function countAccumulatedItems<T extends IsEmpty>(arr: T[]) {
   }, 0);
 }
 
-// Merges two arrays of length N into an array of length N.
-export function mergeAccumulatedData<T extends IsEmpty, N extends number>(
-  arr0: Tuple<T, N>,
-  arr1: Tuple<T, N>,
-  length: N = arr0.length as N, // Need this for ts to infer the return Tuple length.
-): Tuple<T, N> {
-  const numNonEmptyItems0 = countAccumulatedItems(arr0);
-  const numNonEmptyItems1 = countAccumulatedItems(arr1);
-  if (numNonEmptyItems0 + numNonEmptyItems1 > length) {
-    throw new Error('Combined non-empty items exceeded the maximum allowed.');
-  }
-
-  const arr = [...arr0] as Tuple<T, N>;
-  arr1.slice(0, numNonEmptyItems1).forEach((item, i) => (arr[i + numNonEmptyItems0] = item));
-  return arr;
-}
-
 // Sort items by a provided compare function. All empty items are padded to the right.
 function genericSort<T extends IsEmpty, N extends number>(
   arr: Tuple<T, N>,
@@ -61,11 +44,3 @@ export function sortByCounter<T extends Ordered & IsEmpty, N extends number>(
 ): Tuple<T, N> {
   return genericSort(arr, compareByCounter, ascending);
 }
-
-export function isEmptyArray<T extends IsEmpty>(arr: T[]): boolean {
-  return arr.every(item => item.isEmpty());
-}
-
-export function getNonEmptyItems<T extends IsEmpty>(arr: T[]): T[] {
-  return arr.filter(item => !item.isEmpty());
-}

package/src/logs/shared_secret_derivation.ts

@@ -13,7 +13,7 @@ import type { PublicKey } from '../keys/public_key.js';
  * @returns A derived shared secret.
  * @throws If the publicKey is zero.
  *
- * TODO(#12656): This function is kept around because of the getSharedSecret oracle. Nuke this once returning
+ * TODO(#12656): This function is kept around because of the utilityGetSharedSecret oracle. Nuke this once returning
  * the app-siloed secret.
  */
 export async function deriveEcdhSharedSecret(secretKey: GrumpkinScalar, publicKey: PublicKey): Promise<Point> {

package/src/messaging/l2_to_l1_membership.ts

@@ -1,13 +1,26 @@
-import { SHA256Trunc } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
-import { MerkleTreeCalculator, SiblingPath, UnbalancedMerkleTreeCalculator } from '@aztec/foundation/trees';
+import {
+  SiblingPath,
+  UnbalancedMerkleTreeCalculator,
+  computeUnbalancedMerkleTreeRoot,
+  findLeafLevelAndIndex,
+  getMaxUnbalancedTreeDepth,
+} from '@aztec/foundation/trees';
+
+async function createOutHashTree(messages: Fr[]) {
+  const messageSubtreeHeight = getMaxUnbalancedTreeDepth(messages.length);
+  const calculator = UnbalancedMerkleTreeCalculator.create(messageSubtreeHeight);
+  await calculator.appendLeaves(messages.map(msg => msg.toBuffer()));
+  return calculator;
+}
 
 export interface MessageRetrieval {
   getL2ToL1Messages(l2BlockNumber: number): Promise<Fr[][] | undefined>;
 }
 
 export type L2ToL1MembershipWitness = {
-  l2MessageIndex: bigint;
+  root: Fr;
+  leafIndex: bigint;
   siblingPath: SiblingPath<number>;
 };
 
@@ -16,98 +29,76 @@ export async function computeL2ToL1MembershipWitness(
   l2BlockNumber: number,
   message: Fr,
 ): Promise<L2ToL1MembershipWitness | undefined> {
-  const messagesPerTx = await messageRetriever.getL2ToL1Messages(l2BlockNumber);
-  if (!messagesPerTx) {
+  const messagesForAllTxs = await messageRetriever.getL2ToL1Messages(l2BlockNumber);
+  if (!messagesForAllTxs) {
     return undefined;
   }
 
-  // Find index of message in subtree and index of tx in a block
-  let messageIndexInTx = -1,
-    txIndex = -1;
-  {
-    txIndex = messagesPerTx.findIndex(messages => {
-      const idx = messages.findIndex(msg => msg.equals(message));
-      messageIndexInTx = Math.max(messageIndexInTx, idx);
-      return idx !== -1;
-    });
-  }
+  return computeL2ToL1MembershipWitnessFromMessagesForAllTxs(messagesForAllTxs, message);
+}
+
+export async function computeL2ToL1MembershipWitnessFromMessagesForAllTxs(
+  messagesForAllTxs: Fr[][],
+  message: Fr,
+): Promise<L2ToL1MembershipWitness> {
+  // Find index of message in subtree and index of tx in a block.
+  let messageIndexInTx = -1;
+  const txIndex = messagesForAllTxs.findIndex(messages => {
+    messageIndexInTx = messages.findIndex(msg => msg.equals(message));
+    return messageIndexInTx !== -1;
+  });
 
   if (txIndex === -1) {
     throw new Error('The L2ToL1Message you are trying to prove inclusion of does not exist');
   }
 
-  const hasher = new SHA256Trunc();
-
-  // Get the message path in subtree and message subtree height
-  let messagePathInSubtree: SiblingPath<number>;
-  let messageSubtreeHeight: number;
-  {
-    const txMessages = messagesPerTx[txIndex];
-    messageSubtreeHeight = txMessages.length <= 1 ? 1 : Math.ceil(Math.log2(txMessages.length));
-    const calculator: MerkleTreeCalculator = await MerkleTreeCalculator.create(
-      messageSubtreeHeight,
-      Buffer.alloc(32, 0), // Zero leaf
-      (lhs: Buffer, rhs: Buffer) => Promise.resolve(hasher.hash(lhs, rhs)),
-    );
-
-    const tree = await calculator.computeTree(txMessages.map(msg => msg.toBuffer()));
-    const tempPath = tree.getSiblingPath(messageIndexInTx);
-    messagePathInSubtree = new SiblingPath(tempPath.length, tempPath);
-  }
-
-  // If the number of txs is 1 we are dealing with a special case where the tx subtree itself is the whole block's
-  // l2 to l1 message tree.
-  const numTransactions = messagesPerTx.length;
-  if (numTransactions === 1) {
-    return {
-      l2MessageIndex: BigInt(messageIndexInTx),
-      siblingPath: messagePathInSubtree,
-    };
-  }
-
-  // Calculate roots for all tx subtrees
-  const txSubtreeRoots = await Promise.all(
-    messagesPerTx.map(async (messages, _) => {
-      // For a tx with no messages, we have to set an out hash of 0 to match what the circuit does.
-      if (messages.length === 0) {
-        return Fr.ZERO;
-      }
-
-      const txTreeHeight = messages.length <= 1 ? 1 : Math.ceil(Math.log2(messages.length));
-      const calculator: MerkleTreeCalculator = await MerkleTreeCalculator.create(
-        txTreeHeight,
-        Buffer.alloc(32, 0), // Zero leaf
-        (lhs: Buffer, rhs: Buffer) => Promise.resolve(hasher.hash(lhs, rhs)),
-      );
-
-      const root = await calculator.computeTreeRoot(messages.map(msg => msg.toBuffer()));
-      return Fr.fromBuffer(root);
-    }),
-  );
-
-  // Construct the top tree and compute the combined path
-  let combinedPath: Buffer[];
-  {
-    const topTreeHeight = Math.ceil(Math.log2(txSubtreeRoots.length));
-    // The root of this tree is the out_hash calculated in Noir => we truncate to match Noir's SHA
-    const topTree = UnbalancedMerkleTreeCalculator.create(topTreeHeight, (lhs: Buffer, rhs: Buffer) =>
-      Promise.resolve(hasher.hash(lhs, rhs)),
-    );
-    await topTree.appendLeaves(txSubtreeRoots.map(f => f.toBuffer()));
-
-    const txPathInTopTree = await topTree.getSiblingPath(txSubtreeRoots[txIndex].toBigInt());
-    // Append subtree path to top tree path
-    combinedPath = messagePathInSubtree.toBufferArray().concat(txPathInTopTree.toBufferArray());
-  }
-
-  // Append binary index of subtree path to binary index of top tree path
-  const combinedIndex = parseInt(
-    txIndex.toString(2).concat(messageIndexInTx.toString(2).padStart(messageSubtreeHeight, '0')),
-    2,
-  );
+  // Get the txOutHash and the sibling path of the message in the tx subtree.
+  const txMessages = messagesForAllTxs[txIndex];
+  const txOutHashTree = await createOutHashTree(txMessages);
+  const txOutHash = txOutHashTree.getRoot();
+  const messagePathInSubtree = await txOutHashTree.getSiblingPath(message);
+
+  // Calculate txOutHash for all txs.
+  const txSubtreeRoots = messagesForAllTxs.map((messages, i) => {
+    // For a tx with no messages, we have to set an out hash of 0 to match what the circuit does.
+    if (messages.length === 0) {
+      return Fr.ZERO;
+    }
+
+    if (i === txIndex) {
+      return Fr.fromBuffer(txOutHash);
+    }
+
+    const root = computeUnbalancedMerkleTreeRoot(messages.map(msg => msg.toBuffer()));
+    return Fr.fromBuffer(root);
+  });
+
+  // Construct the top tree.
+  // The leaves of this tree are the txOutHashes.
+  // The root of this tree is the out_hash calculated in the circuit.
+  const topTree = await createOutHashTree(txSubtreeRoots);
+  const root = Fr.fromBuffer(topTree.getRoot());
+
+  // Compute the combined sibling path by appending the tx subtree path to the top tree path.
+  const txPathInTopTree = await topTree.getSiblingPath(txOutHash);
+  const combinedPath = messagePathInSubtree.toBufferArray().concat(txPathInTopTree.toBufferArray());
+
+  // Compute the combined index.
+  // It is the index of the message in the balanced tree at its current height.
+  const txLeafPosition = findLeafLevelAndIndex(messagesForAllTxs.length, txIndex);
+  const messageLeafPosition = findLeafLevelAndIndex(txMessages.length, messageIndexInTx);
+  const numLeavesInLeftSubtrees = txLeafPosition.indexAtLevel * (1 << messageLeafPosition.level);
+  const combinedIndex = numLeavesInLeftSubtrees + messageLeafPosition.indexAtLevel;
 
   return {
-    l2MessageIndex: BigInt(combinedIndex),
+    root,
+    leafIndex: BigInt(combinedIndex),
     siblingPath: new SiblingPath(combinedPath.length, combinedPath),
   };
 }
+
+export function getL2ToL1MessageLeafId(
+  membershipWitness: Pick<L2ToL1MembershipWitness, 'leafIndex' | 'siblingPath'>,
+): bigint {
+  return 2n ** BigInt(membershipWitness.siblingPath.pathSize) + membershipWitness.leafIndex;
+}

package/src/messaging/l2_to_l1_message.ts

@@ -203,4 +203,13 @@ export class ScopedCountedL2ToL1Message {
   toBuffer(): Buffer {
     return serializeToBuffer(this.inner, this.contractAddress);
   }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new ScopedCountedL2ToL1Message(reader.readObject(CountedL2ToL1Message), reader.readObject(AztecAddress));
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(this.inner, this.contractAddress);
+  }
 }

package/src/note/notes_filter.ts

@@ -12,10 +12,13 @@ import { NoteStatus } from './note_status.js';
  * @remarks This filter is applied as an intersection of all its params.
  */
 export type NotesFilter = {
+  /**
+   * The contract address the note belongs to.
+   * @remarks Providing a contract address is required as we need that information to trigger private state sync.
+   */
+  contractAddress: AztecAddress;
   /** Hash of a transaction from which to fetch the notes. */
   txHash?: TxHash;
-  /** The contract address the note belongs to. */
-  contractAddress?: AztecAddress;
   /** The specific storage location of the note on the contract. */
   storageSlot?: Fr;
   /** The recipient of the note (whose public key was used to encrypt the note). */
@@ -29,8 +32,8 @@ export type NotesFilter = {
 };
 
 export const NotesFilterSchema: ZodFor<NotesFilter> = z.object({
+  contractAddress: schemas.AztecAddress,
   txHash: TxHash.schema.optional(),
-  contractAddress: schemas.AztecAddress.optional(),
   storageSlot: schemas.Fr.optional(),
   recipient: schemas.AztecAddress.optional(),
   status: z.nativeEnum(NoteStatus).optional(),

package/src/p2p/attestation_utils.ts

@@ -0,0 +1,35 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+import { CommitteeAttestation } from '../block/index.js';
+import type { BlockAttestation } from './block_attestation.js';
+
+/**
+ * Returns attestation signatures in the order of a series of provided ethereum addresses
+ * The rollup smart contract expects attestations to appear in the order of the committee
+ * @todo: perform this logic within the memory attestation store instead?
+ */
+export function orderAttestations(
+  attestations: BlockAttestation[],
+  orderAddresses: EthAddress[],
+): CommitteeAttestation[] {
+  // Create a map of sender addresses to BlockAttestations
+  const attestationMap = new Map<string, CommitteeAttestation>();
+
+  for (const attestation of attestations) {
+    const sender = attestation.getSender();
+    if (sender) {
+      attestationMap.set(
+        sender.toString(),
+        CommitteeAttestation.fromAddressAndSignature(sender, attestation.signature),
+      );
+    }
+  }
+
+  // Create the ordered array based on the orderAddresses, else return an empty attestation
+  const orderedAttestations = orderAddresses.map(address => {
+    const addressString = address.toString();
+    return attestationMap.get(addressString) || CommitteeAttestation.fromAddress(address);
+  });
+
+  return orderedAttestations;
+}

package/src/p2p/block_attestation.ts

@@ -66,10 +66,9 @@ export class BlockAttestation extends Gossipable {
     return this.payload.header.slotNumber;
   }
 
-  /**Get sender
-   *
-   * Lazily evaluate and cache the sender of the attestation
-   * @returns The sender of the attestation
+  /**
+   * Lazily evaluate and cache the signer of the attestation
+   * @returns The signer of the attestation
    */
   getSender(): EthAddress {
     if (!this.sender) {

package/src/p2p/block_proposal.ts

@@ -5,6 +5,8 @@ import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import type { BlockInfo } from '../block/l2_block.js';
+import { TxHash } from '../tx/index.js';
 import { Tx } from '../tx/tx.js';
 import type { UInt32 } from '../types/index.js';
 import { ConsensusPayload } from './consensus_payload.js';
@@ -47,6 +49,9 @@ export class BlockProposal extends Gossipable {
     /** The signer of the BlockProposal over the header of the new block*/
     public readonly signature: Signature,
 
+    /** The sequence of transactions in the block */
+    public readonly txHashes: TxHash[],
+
     // Note(md): this is placed after the txs payload in order to be backwards compatible with previous versions
     /** The transactions in the block */
     public readonly txs?: Tx[],
@@ -66,9 +71,19 @@ export class BlockProposal extends Gossipable {
     return this.payload.header.slotNumber;
   }
 
+  toBlockInfo(): BlockInfo {
+    return {
+      blockNumber: this.blockNumber,
+      slotNumber: this.slotNumber.toNumber(),
+      archive: this.archive.toString(),
+      txCount: this.txHashes.length,
+    };
+  }
+
   static async createProposalFromSigner(
     blockNumber: UInt32,
     payload: ConsensusPayload,
+    txHashes: TxHash[],
     // Note(md): Provided separately to tx hashes such that this function can be optional
     txs: Tx[] | undefined,
     payloadSigner: (payload: Buffer32) => Promise<Signature>,
@@ -76,7 +91,7 @@ export class BlockProposal extends Gossipable {
     const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
     const sig = await payloadSigner(hashed);
 
-    return new BlockProposal(blockNumber, payload, sig, txs);
+    return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
   }
 
   /**Get Sender
@@ -97,7 +112,7 @@ export class BlockProposal extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    const buffer: any[] = [this.blockNumber, this.payload, this.signature];
+    const buffer: any[] = [this.blockNumber, this.payload, this.signature, this.txHashes.length, this.txHashes];
     if (this.txs) {
       buffer.push(this.txs.length);
       buffer.push(this.txs);
@@ -111,13 +126,14 @@ export class BlockProposal extends Gossipable {
     const blockNumber = reader.readNumber();
     const payload = reader.readObject(ConsensusPayload);
     const sig = reader.readObject(Signature);
+    const txHashes = reader.readArray(reader.readNumber(), TxHash);
 
     if (!reader.isEmpty()) {
       const txs = reader.readArray(reader.readNumber(), Tx);
-      return new BlockProposal(blockNumber, payload, sig, txs);
+      return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
     }
 
-    return new BlockProposal(blockNumber, payload, sig);
+    return new BlockProposal(blockNumber, payload, sig, txHashes);
   }
 
   getSize(): number {
@@ -125,7 +141,9 @@ export class BlockProposal extends Gossipable {
       4 /* blockNumber */ +
       this.payload.getSize() +
       this.signature.getSize() +
-      (this.txs ? this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
+      4 /* txHashes.length */ +
+      this.txHashes.length * TxHash.SIZE +
+      (this.txs ? 4 /* txs.length */ + this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
     );
   }
 }