@aztec/stdlib 0.0.1-fake-ceab37513c → 0.0.2-commit.217f559981

package/src/p2p/attestation_utils.ts

@@ -1,7 +1,7 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
 
 import { CommitteeAttestation } from '../block/index.js';
-import type { BlockAttestation } from './block_attestation.js';
+import type { CheckpointAttestation } from './checkpoint_attestation.js';
 
 /**
  * Returns attestation signatures in the order of a series of provided ethereum addresses
@@ -9,10 +9,10 @@ import type { BlockAttestation } from './block_attestation.js';
  * @todo: perform this logic within the memory attestation store instead?
  */
 export function orderAttestations(
-  attestations: BlockAttestation[],
+  attestations: CheckpointAttestation[],
   orderAddresses: EthAddress[],
 ): CommitteeAttestation[] {
-  // Create a map of sender addresses to BlockAttestations
+  // Create a map of sender addresses to attestations
   const attestationMap = new Map<string, CommitteeAttestation>();
 
   for (const attestation of attestations) {

package/src/p2p/block_proposal.ts

@@ -1,20 +1,26 @@
+import { BlockNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
-import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+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 { DutyType, type SigningContext } from '../ha-signing/index.js';
+import { BlockHeader } from '../tx/block_header.js';
 import { TxHash } from '../tx/index.js';
-import { Tx } from '../tx/tx.js';
-import { ConsensusPayload } from './consensus_payload.js';
+import type { Tx } from '../tx/tx.js';
 import { Gossipable } from './gossipable.js';
 import {
   SignatureDomainSeparator,
   getHashedSignaturePayload,
   getHashedSignaturePayloadEthSignedMessage,
 } from './signature_utils.js';
+import { SignedTxs } from './signed_txs.js';
 import { TopicType } from './topic_type.js';
 
 export class BlockProposalHash extends Buffer32 {
@@ -24,14 +30,22 @@ export class BlockProposalHash extends Buffer32 {
 }
 
 export type BlockProposalOptions = {
-  publishFullTxs: boolean;
+  /**
+   * 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;
 };
 
 /**
- * BlockProposal
- *
- * A block proposal is created by the leader of the chain proposing a sequence of transactions to
- * be included in the head of the chain
+ * A block proposal is created by the leader of the chain proposing a sequence of transactions
+ * to be included in a block within a checkpoint. This is used for non-last blocks in a slot.
+ * The last block is sent as part of a CheckpointProposal.
  */
 export class BlockProposal extends Gossipable {
   static override p2pTopic = TopicType.block_proposal;
@@ -39,18 +53,26 @@ export class BlockProposal extends Gossipable {
   private sender: EthAddress | undefined;
 
   constructor(
-    /** The payload of the message, and what the signature is over */
-    public readonly payload: ConsensusPayload,
+    /** The per-block header containing block state and global variables */
+    public readonly blockHeader: BlockHeader,
 
-    /** The signer of the BlockProposal over the header of the new block*/
-    public readonly signature: Signature,
+    /** Index of this block within the checkpoint (0-indexed) */
+    public readonly indexWithinCheckpoint: IndexWithinCheckpoint,
+
+    /** Hash of L1 to L2 messages for this checkpoint (constant across all blocks in checkpoint) */
+    public readonly inHash: Fr,
+
+    /** Archive root after this block is applied */
+    public readonly archiveRoot: Fr,
 
     /** 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[],
+    /** The proposer's signature over the block data */
+    public readonly signature: Signature,
+
+    /** The signed transactions in the block (optional, for DA guarantees) */
+    public readonly signedTxs?: SignedTxs,
   ) {
     super();
   }
@@ -60,59 +82,133 @@ export class BlockProposal extends Gossipable {
   }
 
   get archive(): Fr {
-    return this.payload.archive;
+    return this.archiveRoot;
+  }
+
+  get slotNumber(): SlotNumber {
+    return this.blockHeader.getSlot();
+  }
+
+  get blockNumber(): BlockNumber {
+    return this.blockHeader.getBlockNumber();
   }
 
-  get slotNumber(): Fr {
-    return this.payload.header.slotNumber;
+  /** Convenience getter for txs from signedTxs */
+  get txs(): Tx[] | undefined {
+    return this.signedTxs?.txs;
   }
 
   toBlockInfo(): Omit<L2BlockInfo, 'blockNumber'> {
     return {
-      slotNumber: this.slotNumber.toNumber(),
-      lastArchive: this.payload.header.lastArchiveRoot,
-      timestamp: this.payload.header.timestamp,
-      archive: this.archive,
+      slotNumber: this.slotNumber,
+      lastArchive: this.blockHeader.lastArchive.root,
+      timestamp: this.blockHeader.globalVariables.timestamp,
+      archive: this.archiveRoot,
       txCount: this.txHashes.length,
     };
   }
 
+  /**
+   * Get the payload to sign for this block proposal.
+   * The signature is over: blockHeader + indexWithinCheckpoint + inHash + archiveRoot + txHashes
+   */
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    return serializeToBuffer([
+      domainSeparator,
+      this.blockHeader,
+      this.indexWithinCheckpoint,
+      this.inHash,
+      this.archiveRoot,
+      this.txHashes.length,
+      this.txHashes,
+    ]);
+  }
+
   static async createProposalFromSigner(
-    payload: ConsensusPayload,
+    blockHeader: BlockHeader,
+    indexWithinCheckpoint: IndexWithinCheckpoint,
+    inHash: Fr,
+    archiveRoot: Fr,
     txHashes: TxHash[],
-    // Note(md): Provided separately to tx hashes such that this function can be optional
     txs: Tx[] | undefined,
-    payloadSigner: (payload: Buffer32) => Promise<Signature>,
-  ) {
-    const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
-    const sig = await payloadSigner(hashed);
+    payloadSigner: (payload: Buffer32, context: SigningContext) => Promise<Signature>,
+  ): Promise<BlockProposal> {
+    // Create a temporary proposal to get the payload to sign
+    const tempProposal = new BlockProposal(
+      blockHeader,
+      indexWithinCheckpoint,
+      inHash,
+      archiveRoot,
+      txHashes,
+      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, blockContext);
+
+    // If txs are provided, sign them as well
+    let signedTxs: SignedTxs | undefined;
+    if (txs) {
+      const txsSigningContext: SigningContext = { dutyType: DutyType.TXS };
+      const txsSigner = (payload: Buffer32) => payloadSigner(payload, txsSigningContext);
+      signedTxs = await SignedTxs.createFromSigner(txs, txsSigner);
+    }
 
-    return new BlockProposal(payload, sig, txHashes, txs);
+    return new BlockProposal(blockHeader, indexWithinCheckpoint, inHash, archiveRoot, txHashes, sig, signedTxs);
   }
 
-  /**Get Sender
-   * Lazily evaluate the sender of the proposal; result is cached
-   * @returns The sender address, or undefined if signature recovery fails
+  /**
+   * Lazily evaluate the sender of the proposal; result is cached.
+   * If there's signedTxs, also verifies the signedTxs sender matches the block proposal sender.
+   * @returns The sender address, or undefined if signature recovery fails or senders don't match
    */
   getSender(): EthAddress | undefined {
     if (!this.sender) {
-      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockProposal);
+      const hashed = getHashedSignaturePayloadEthSignedMessage(this, SignatureDomainSeparator.blockProposal);
+      const blockSender = tryRecoverAddress(hashed, this.signature);
+
+      // If there's signedTxs, verify the sender matches
+      if (blockSender && this.signedTxs) {
+        const txsSender = this.signedTxs.getSender();
+        if (!txsSender || !txsSender.equals(blockSender)) {
+          return undefined; // Sender mismatch - fail
+        }
+      }
+
       // Cache the sender for later use
-      this.sender = tryRecoverAddress(hashed, this.signature);
+      this.sender = blockSender;
     }
 
     return this.sender;
   }
 
   getPayload() {
-    return this.payload.getPayloadToSign(SignatureDomainSeparator.blockProposal);
+    return this.getPayloadToSign(SignatureDomainSeparator.blockProposal);
   }
 
   toBuffer(): Buffer {
-    const buffer: any[] = [this.payload, this.signature, this.txHashes.length, this.txHashes];
-    if (this.txs) {
-      buffer.push(this.txs.length);
-      buffer.push(this.txs);
+    const buffer: any[] = [
+      this.blockHeader,
+      this.indexWithinCheckpoint,
+      this.inHash,
+      this.archiveRoot,
+      this.signature,
+      this.txHashes.length,
+      this.txHashes,
+    ];
+    if (this.signedTxs) {
+      buffer.push(1); // hasSignedTxs = true
+      buffer.push(this.signedTxs.toBuffer());
+    } else {
+      buffer.push(0); // hasSignedTxs = false
     }
     return serializeToBuffer(buffer);
   }
@@ -120,25 +216,98 @@ export class BlockProposal extends Gossipable {
   static fromBuffer(buf: Buffer | BufferReader): BlockProposal {
     const reader = BufferReader.asReader(buf);
 
-    const payload = reader.readObject(ConsensusPayload);
-    const sig = reader.readObject(Signature);
-    const txHashes = reader.readArray(reader.readNumber(), TxHash);
+    const blockHeader = reader.readObject(BlockHeader);
+    const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
+    const inHash = reader.readObject(Fr);
+    const archiveRoot = reader.readObject(Fr);
+    const signature = reader.readObject(Signature);
+    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 txs = reader.readArray(reader.readNumber(), Tx);
-      return new BlockProposal(payload, sig, txHashes, txs);
+      const hasSignedTxs = reader.readNumber();
+      if (hasSignedTxs) {
+        const signedTxs = SignedTxs.fromBuffer(reader);
+        return new BlockProposal(
+          blockHeader,
+          indexWithinCheckpoint,
+          inHash,
+          archiveRoot,
+          txHashes,
+          signature,
+          signedTxs,
+        );
+      }
     }
 
-    return new BlockProposal(payload, sig, txHashes);
+    return new BlockProposal(blockHeader, indexWithinCheckpoint, inHash, archiveRoot, txHashes, signature);
   }
 
   getSize(): number {
     return (
-      this.payload.getSize() +
+      this.blockHeader.getSize() +
+      4 /* indexWithinCheckpoint */ +
+      this.inHash.size +
+      this.archiveRoot.size +
       this.signature.getSize() +
       4 /* txHashes.length */ +
       this.txHashes.length * TxHash.SIZE +
-      (this.txs ? 4 /* txs.length */ + this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
+      4 /* hasSignedTxs flag */ +
+      (this.signedTxs ? this.signedTxs.getSize() : 0)
+    );
+  }
+
+  static empty(): BlockProposal {
+    return new BlockProposal(BlockHeader.empty(), IndexWithinCheckpoint(0), Fr.ZERO, Fr.ZERO, [], Signature.empty());
+  }
+
+  static random(): BlockProposal {
+    return new BlockProposal(
+      BlockHeader.random(),
+      IndexWithinCheckpoint(Math.floor(Math.random() * 5)),
+      Fr.random(),
+      Fr.random(),
+      [TxHash.random(), TxHash.random()],
+      Signature.random(),
+    );
+  }
+
+  toInspect() {
+    return {
+      blockHeader: this.blockHeader.toInspect(),
+      indexWithinCheckpoint: this.indexWithinCheckpoint,
+      inHash: this.inHash.toString(),
+      archiveRoot: this.archiveRoot.toString(),
+      signature: this.signature.toString(),
+      txHashes: this.txHashes.map(h => h.toString()),
+    };
+  }
+
+  /**
+   * Check if this proposal matches the given block.
+   * Compares the archive root and block header.
+   * @param block - The L2Block to compare against
+   * @returns True if the proposal matches the block
+   */
+  matchesBlock(block: L2Block): boolean {
+    return this.archiveRoot.equals(block.archive.root) && this.blockHeader.equals(block.header);
+  }
+
+  /**
+   * Returns a copy of this proposal without signedTxs.
+   * Used when storing proposals in attestation pool to avoid storing full tx data.
+   */
+  withoutSignedTxs(): BlockProposal {
+    return new BlockProposal(
+      this.blockHeader,
+      this.indexWithinCheckpoint,
+      this.inHash,
+      this.archiveRoot,
+      this.txHashes,
+      this.signature,
     );
   }
 }

package/src/p2p/{block_attestation.ts → checkpoint_attestation.ts}

@@ -1,32 +1,35 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
-import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
 import type { ZodFor } from '../schemas/index.js';
+import { CheckpointProposal } from './checkpoint_proposal.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from './signature_utils.js';
 import { TopicType } from './topic_type.js';
 
-export class BlockAttestationHash extends Buffer32 {
+export class CheckpointAttestationHash extends Buffer32 {
   constructor(hash: Buffer) {
     super(hash);
   }
 }
 
 /**
- * BlockAttestation
+ * CheckpointAttestation
  *
- * A validator that has attested to seeing the contents of a block
- * will produce a block attestation over the header of the block
+ * A validator that has attested to seeing all blocks in a checkpoint
+ * will produce a checkpoint attestation over the checkpoint header.
  */
-export class BlockAttestation extends Gossipable {
-  static override p2pTopic = TopicType.block_attestation;
+export class CheckpointAttestation extends Gossipable {
+  static override p2pTopic = TopicType.checkpoint_attestation;
 
   private sender: EthAddress | undefined;
   private proposer: EthAddress | undefined;
@@ -35,34 +38,34 @@ export class BlockAttestation extends Gossipable {
     /** The payload of the message, and what the signature is over */
     public readonly payload: ConsensusPayload,
 
-    /** The signature of the block attester */
+    /** The signature of the checkpoint attester */
     public readonly signature: Signature,
 
-    /** The signature from the block proposer */
+    /** The signature from the checkpoint proposer */
     public readonly proposerSignature: Signature,
   ) {
     super();
   }
 
-  static get schema(): ZodFor<BlockAttestation> {
+  static get schema(): ZodFor<CheckpointAttestation> {
     return z
       .object({
         payload: ConsensusPayload.schema,
         signature: Signature.schema,
         proposerSignature: Signature.schema,
       })
-      .transform(obj => new BlockAttestation(obj.payload, obj.signature, obj.proposerSignature));
+      .transform(obj => new CheckpointAttestation(obj.payload, obj.signature, obj.proposerSignature));
   }
 
   override generateP2PMessageIdentifier(): Promise<Buffer32> {
-    return Promise.resolve(new BlockAttestationHash(keccak256(this.signature.toBuffer())));
+    return Promise.resolve(new CheckpointAttestationHash(keccak256(this.signature.toBuffer())));
   }
 
   get archive(): Fr {
     return this.payload.archive;
   }
 
-  get slotNumber(): Fr {
+  get slotNumber(): SlotNumber {
     return this.payload.header.slotNumber;
   }
 
@@ -73,7 +76,10 @@ export class BlockAttestation extends Gossipable {
   getSender(): EthAddress | undefined {
     if (!this.sender) {
       // Recover the sender from the attestation
-      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockAttestation);
+      const hashed = getHashedSignaturePayloadEthSignedMessage(
+        this.payload,
+        SignatureDomainSeparator.checkpointAttestation,
+      );
       // Cache the sender for later use
       this.sender = tryRecoverAddress(hashed, this.signature);
     }
@@ -82,43 +88,50 @@ export class BlockAttestation extends Gossipable {
   }
 
   /**
-   * Lazily evaluate and cache the proposer of the block
-   * @returns The proposer of the block
+   * Lazily evaluate and cache the proposer of the checkpoint
+   * @returns The proposer of the checkpoint
    */
   getProposer(): EthAddress | undefined {
     if (!this.proposer) {
-      // Recover the proposer from the proposal signature
-      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockProposal);
+      // Create a temporary CheckpointProposal to recover the proposer address.
+      // We need to use CheckpointProposal because it has a different getPayloadToSign()
+      // implementation than ConsensusPayload (uses serializeToBuffer vs ABI encoding).
+      const proposal = new CheckpointProposal(
+        this.payload.header,
+        this.payload.archive,
+        this.payload.feeAssetPriceModifier,
+        this.proposerSignature,
+      );
       // Cache the proposer for later use
-      this.proposer = tryRecoverAddress(hashed, this.proposerSignature);
+      this.proposer = proposal.getSender();
     }
 
     return this.proposer;
   }
 
   getPayload(): Buffer {
-    return this.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation);
+    return this.payload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation);
   }
 
   toBuffer(): Buffer {
     return serializeToBuffer([this.payload, this.signature, this.proposerSignature]);
   }
 
-  static fromBuffer(buf: Buffer | BufferReader): BlockAttestation {
+  static fromBuffer(buf: Buffer | BufferReader): CheckpointAttestation {
     const reader = BufferReader.asReader(buf);
-    return new BlockAttestation(
+    return new CheckpointAttestation(
       reader.readObject(ConsensusPayload),
       reader.readObject(Signature),
       reader.readObject(Signature),
     );
   }
 
-  static empty(): BlockAttestation {
-    return new BlockAttestation(ConsensusPayload.empty(), Signature.empty(), Signature.empty());
+  static empty(): CheckpointAttestation {
+    return new CheckpointAttestation(ConsensusPayload.empty(), Signature.empty(), Signature.empty());
   }
 
-  static random(): BlockAttestation {
-    return new BlockAttestation(ConsensusPayload.random(), Signature.random(), Signature.random());
+  static random(): CheckpointAttestation {
+    return new CheckpointAttestation(ConsensusPayload.random(), Signature.random(), Signature.random());
   }
 
   getSize(): number {