@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/block/attestation_info.ts

@@ -0,0 +1,62 @@
+import { recoverAddress } from '@aztec/foundation/crypto';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+import { ConsensusPayload } from '../p2p/consensus_payload.js';
+import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
+import type { L2Block } from './l2_block.js';
+import type { CommitteeAttestation } from './proposal/committee_attestation.js';
+
+/**
+ * Status indicating how the attestation address was determined
+ */
+export type AttestationStatus = 'recovered-from-signature' | 'provided-as-address' | 'invalid-signature' | 'empty';
+
+/**
+ * Information about an attestation extracted from a published block
+ */
+export type AttestationInfo =
+  | {
+      /** The validator's address, undefined if signature recovery failed or empty */
+      address?: undefined;
+      /** How the attestation address was determined */
+      status: Extract<AttestationStatus, 'invalid-signature' | 'empty'>;
+    }
+  | {
+      /** The validator's address */
+      address: EthAddress;
+      /** How the attestation address was determined */
+      status: Extract<AttestationStatus, 'provided-as-address' | 'recovered-from-signature'>;
+    };
+
+/**
+ * Extracts attestation information from a published L2 block.
+ * Returns info for each attestation, preserving array indices.
+ */
+export function getAttestationInfoFromPublishedL2Block(block: {
+  attestations: CommitteeAttestation[];
+  block: L2Block;
+}): AttestationInfo[] {
+  const payload = ConsensusPayload.fromBlock(block.block);
+  const hashedPayload = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+
+  return block.attestations.map(attestation => {
+    // If signature is empty, check if we have an address directly
+    if (attestation.signature.isEmpty()) {
+      if (attestation.address.isZero()) {
+        // No signature and no address - empty
+        return { status: 'empty' as const };
+      }
+      // Address provided without signature
+      return { address: attestation.address, status: 'provided-as-address' as const };
+    }
+
+    // Try to recover address from signature
+    try {
+      const recoveredAddress = recoverAddress(hashedPayload, attestation.signature);
+      return { address: recoveredAddress, status: 'recovered-from-signature' as const };
+    } catch {
+      // Signature present but recovery failed
+      return { status: 'invalid-signature' as const };
+    }
+  });
+}

package/src/block/block_hash.ts

@@ -1,5 +1,6 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
 
 import { schemas } from '../schemas/schemas.js';
 
@@ -16,6 +17,19 @@ export class L2BlockHash extends Buffer32 {
     return new L2BlockHash(Fr.random().toBuffer());
   }
 
+  static override fromNumber(num: number): L2BlockHash {
+    return new L2BlockHash(super.fromNumber(num).toBuffer());
+  }
+
+  static override fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new L2BlockHash(reader.readBytes(L2BlockHash.SIZE));
+  }
+
+  static override fromString(str: string): Buffer32 {
+    return new L2BlockHash(super.fromString(str).toBuffer());
+  }
+
   static get schema() {
     return schemas.BufferHex.transform(value => new L2BlockHash(value));
   }

package/src/block/body.ts

@@ -1,7 +1,7 @@
-import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB } from '@aztec/constants';
+import { createBlockEndMarker, getNumTxsFromBlockEndMarker, isBlockEndMarker } from '@aztec/blob-lib/encoding';
 import { timesParallel } from '@aztec/foundation/collection';
-import type { Fr } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -9,13 +9,21 @@ import { z } from 'zod';
 import type { ZodFor } from '../schemas/index.js';
 import { TxEffect } from '../tx/tx_effect.js';
 
+export { createBlockEndMarker };
+
+export function getBlockBlobFields(txEffects: TxEffect[]) {
+  const blobFields = txEffects.flatMap(txEffect => txEffect.toBlobFields());
+  blobFields.push(createBlockEndMarker(txEffects.length));
+  return blobFields;
+}
+
 export class Body {
-  constructor(public txEffects: TxEffect[]) {
-    txEffects.forEach(txEffect => {
-      if (txEffect.isEmpty()) {
-        throw new Error('Empty tx effect not allowed in Body');
-      }
-    });
+  constructor(public txEffects: TxEffect[]) {}
+
+  equals(other: Body) {
+    return (
+      this.txEffects.length === other.txEffects.length && this.txEffects.every((te, i) => te.equals(other.txEffects[i]))
+    );
   }
 
   static get schema(): ZodFor<Body> {
@@ -48,36 +56,30 @@ export class Body {
    * Returns a flat packed array of fields of all tx effects - used for blobs.
    */
   toBlobFields() {
-    let flattened: Fr[] = [];
-    this.txEffects.forEach((effect: TxEffect) => {
-      flattened = flattened.concat(effect.toBlobFields());
-    });
-    if (flattened.length > BLOBS_PER_BLOCK * FIELDS_PER_BLOB) {
-      throw new Error(
-        `Attempted to overfill block's blobs with ${flattened.length} elements. The maximum is ${
-          BLOBS_PER_BLOCK * FIELDS_PER_BLOB
-        }`,
-      );
-    }
-
-    return flattened;
+    return getBlockBlobFields(this.txEffects);
   }
 
   /**
    * Decodes a block from blob fields.
    */
   static fromBlobFields(fields: Fr[]) {
-    const txEffectsFields: Fr[][] = [];
-    let checkedFields = 0;
-    while (checkedFields !== fields.length) {
-      if (!TxEffect.isFirstField(fields[checkedFields])) {
-        throw new Error('Invalid fields given to Body.fromBlobFields(): First field invalid.');
-      }
-      const len = TxEffect.decodeFirstField(fields[checkedFields]).length;
-      txEffectsFields.push(fields.slice(checkedFields, checkedFields + len));
-      checkedFields += len;
+    const txEffects: TxEffect[] = [];
+    const reader = new FieldReader(fields.slice(0, -1));
+    while (!reader.isFinished()) {
+      txEffects.push(TxEffect.fromBlobFields(reader));
     }
-    const txEffects = txEffectsFields.filter(effect => effect.length).map(effect => TxEffect.fromBlobFields(effect));
+
+    // If the fields are from a proven block, or are constructed by calling `toBlobFields`, the following errors should never throw.
+
+    if (!isBlockEndMarker(fields[fields.length - 1])) {
+      throw new Error('Block end marker not found');
+    }
+
+    const numTxs = getNumTxsFromBlockEndMarker(fields[fields.length - 1]);
+    if (numTxs !== txEffects.length) {
+      throw new Error(`Expected ${numTxs} txs, but got ${txEffects.length}`);
+    }
+
     return new this(txEffects);
   }
 
@@ -87,9 +89,14 @@ export class Body {
 }`;
   }
 
-  static async random(txsPerBlock = 4, numPublicCallsPerTx = 3, numPublicLogsPerCall = 1) {
+  static async random(
+    txsPerBlock = 4,
+    numPublicCallsPerTx = 3,
+    numPublicLogsPerCall = 1,
+    maxEffects: number | undefined = undefined,
+  ) {
     const txEffects = await timesParallel(txsPerBlock, () =>
-      TxEffect.random(numPublicCallsPerTx, numPublicLogsPerCall),
+      TxEffect.random(numPublicCallsPerTx, numPublicLogsPerCall, maxEffects),
     );
 
     return new Body(txEffects);

package/src/block/in_block.ts

@@ -1,13 +1,13 @@
-import { Fr } from '@aztec/foundation/fields';
-
 import { type ZodTypeAny, z } from 'zod';
 
 import { schemas } from '../schemas/index.js';
+import { L2BlockHash } from './block_hash.js';
 import type { L2Block } from './l2_block.js';
 
+// Note: If you expand this type with indexInBlock, then delete `IndexedTxEffect` and use this type instead.
 export type InBlock<T> = {
   l2BlockNumber: number;
-  l2BlockHash: string;
+  l2BlockHash: L2BlockHash;
   data: T;
 };
 
@@ -15,7 +15,7 @@ export function randomInBlock<T>(data: T): InBlock<T> {
   return {
     data,
     l2BlockNumber: Math.floor(Math.random() * 1000),
-    l2BlockHash: Fr.random().toString(),
+    l2BlockHash: L2BlockHash.random(),
   };
 }
 
@@ -23,7 +23,7 @@ export async function wrapInBlock<T>(data: T, block: L2Block): Promise<InBlock<T
   return {
     data,
     l2BlockNumber: block.number,
-    l2BlockHash: (await block.hash()).toString(),
+    l2BlockHash: L2BlockHash.fromField(await block.hash()),
   };
 }
 
@@ -31,6 +31,6 @@ export function inBlockSchemaFor<T extends ZodTypeAny>(schema: T) {
   return z.object({
     data: schema,
     l2BlockNumber: schemas.Integer,
-    l2BlockHash: z.string(),
+    l2BlockHash: L2BlockHash.schema,
   });
 }

package/src/block/index.ts

@@ -1,8 +1,13 @@
 export * from './l2_block.js';
-export * from './l2_block_downloader/index.js';
-export * from './nullifier_with_block_source.js';
+export * from './l2_block_header.js';
+export * from './l2_block_stream/index.js';
 export * from './in_block.js';
 export * from './body.js';
 export * from './l2_block_number.js';
 export * from './l2_block_source.js';
 export * from './block_hash.js';
+export * from './published_l2_block.js';
+export * from './proposal/index.js';
+export * from './validate_block_result.js';
+export * from './l2_block_info.js';
+export * from './attestation_info.js';

package/src/block/l2_block.ts

@@ -1,14 +1,16 @@
-import { sha256, sha256ToField } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { z } from 'zod';
 
+import { getCheckpointBlobFields } from '../checkpoint/checkpoint_body.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { BlockHeader } from '../tx/block_header.js';
+import type { BlockHeader } from '../tx/block_header.js';
 import { Body } from './body.js';
-import { makeAppendOnlyTreeSnapshot, makeHeader } from './l2_block_code_to_purge.js';
+import { makeAppendOnlyTreeSnapshot, makeL2BlockHeader } from './l2_block_code_to_purge.js';
+import { L2BlockHeader } from './l2_block_header.js';
+import type { L2BlockInfo } from './l2_block_info.js';
 
 /**
  * The data that makes up the rollup proof, with encoder decoder functions.
@@ -18,16 +20,17 @@ export class L2Block {
     /** Snapshot of archive tree after the block is applied. */
     public archive: AppendOnlyTreeSnapshot,
     /** L2 block header. */
-    public header: BlockHeader,
+    public header: L2BlockHeader,
     /** L2 block body. */
     public body: Body,
+    private blockHash: Fr | undefined = undefined,
   ) {}
 
   static get schema() {
     return z
       .object({
         archive: AppendOnlyTreeSnapshot.schema,
-        header: BlockHeader.schema,
+        header: L2BlockHeader.schema,
         body: Body.schema,
       })
       .transform(({ archive, header, body }) => new L2Block(archive, header, body));
@@ -39,7 +42,7 @@ export class L2Block {
    */
   static fromBuffer(buf: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buf);
-    const header = reader.readObject(BlockHeader);
+    const header = reader.readObject(L2BlockHeader);
     const archive = reader.readObject(AppendOnlyTreeSnapshot);
     const body = reader.readObject(Body);
 
@@ -85,14 +88,15 @@ export class L2Block {
     txsPerBlock = 4,
     numPublicCallsPerTx = 3,
     numPublicLogsPerCall = 1,
-    inHash: Buffer | undefined = undefined,
+    inHash: Fr | undefined = undefined,
     slotNumber: number | undefined = undefined,
+    maxEffects: number | undefined = undefined,
   ): Promise<L2Block> {
-    const body = await Body.random(txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall);
+    const body = await Body.random(txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall, maxEffects);
 
     return new L2Block(
       makeAppendOnlyTreeSnapshot(l2BlockNum + 1),
-      makeHeader(0, txsPerBlock, l2BlockNum, slotNumber ?? l2BlockNum, inHash),
+      makeL2BlockHeader(0, l2BlockNum, slotNumber ?? l2BlockNum, {}, inHash),
       body,
     );
   }
@@ -102,78 +106,53 @@ export class L2Block {
    * @returns The L2 block.
    */
   static empty(): L2Block {
-    return new L2Block(AppendOnlyTreeSnapshot.zero(), BlockHeader.empty(), Body.empty());
+    return new L2Block(AppendOnlyTreeSnapshot.empty(), L2BlockHeader.empty(), Body.empty());
   }
 
   get number(): number {
-    return Number(this.header.globalVariables.blockNumber.toBigInt());
+    return this.header.getBlockNumber();
+  }
+
+  get slot(): bigint {
+    return this.header.getSlot();
+  }
+
+  get timestamp(): bigint {
+    return this.header.globalVariables.timestamp;
   }
 
   /**
    * Returns the block's hash (hash of block header).
    * @returns The block's hash.
    */
-  public hash(): Promise<Fr> {
-    return this.header.hash();
+  public async hash(): Promise<Fr> {
+    if (this.blockHash === undefined) {
+      this.blockHash = await this.getBlockHeader().hash();
+    }
+    return this.blockHash;
   }
 
   /**
-   * Computes the public inputs hash for the L2 block.
-   * The same output as the hash of RootRollupPublicInputs.
-   * TODO(Miranda): Check where/if this is used (v diff now with epochs and blobs)
-   * @returns The public input hash for the L2 block as a field element.
+   * @deprecated
+   * This only works when there's one block per checkpoint.
+   * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
    */
-  // TODO(#4844)
-  getPublicInputsHash(): Fr {
-    const preimage = [
-      this.header.globalVariables,
-      AppendOnlyTreeSnapshot.zero(), // this.startNoteHashTreeSnapshot / commitments,
-      AppendOnlyTreeSnapshot.zero(), // this.startNullifierTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startPublicDataTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startL1ToL2MessageTreeSnapshot,
-      this.header.lastArchive,
-      this.header.state.partial.noteHashTree,
-      this.header.state.partial.nullifierTree,
-      this.header.state.partial.publicDataTree,
-      this.header.state.l1ToL2MessageTree,
-      this.archive,
-    ];
-
-    return sha256ToField(preimage);
+  public getCheckpointHeader() {
+    return this.header.toCheckpointHeader();
   }
 
-  /**
-   * Computes the start state hash (should equal contract data before block).
-   * @returns The start state hash for the L2 block.
-   */
-  // TODO(#4844)
-  getStartStateHash() {
-    const inputValue = serializeToBuffer(
-      new Fr(Number(this.header.globalVariables.blockNumber.toBigInt()) - 1),
-      AppendOnlyTreeSnapshot.zero(), // this.startNoteHashTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startNullifierTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startPublicDataTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startL1ToL2MessageTreeSnapshot,
-      this.header.lastArchive,
-    );
-    return sha256(inputValue);
+  // Temporary helper to get the actual block header.
+  public getBlockHeader(): BlockHeader {
+    return this.header.toBlockHeader();
   }
 
   /**
-   * Computes the end state hash (should equal contract data after block).
-   * @returns The end state hash for the L2 block.
+   * @deprecated
+   * This only works when there's one block per checkpoint.
+   * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
    */
-  // TODO(#4844)
-  getEndStateHash() {
-    const inputValue = serializeToBuffer(
-      this.header.globalVariables.blockNumber,
-      this.header.state.partial.noteHashTree,
-      this.header.state.partial.nullifierTree,
-      this.header.state.partial.publicDataTree,
-      this.header.state.l1ToL2MessageTree,
-      this.archive,
-    );
-    return sha256(inputValue);
+  public getCheckpointBlobFields() {
+    return getCheckpointBlobFields([this.body.txEffects]);
   }
 
   /**
@@ -190,7 +169,7 @@ export class L2Block {
       ),
       contractClassLogSize: this.body.txEffects.reduce(
         (totalLogSize, txEffect) =>
-          totalLogSize + txEffect.contractClassLogs.reduce((logSize, log) => logSize + log.getEmittedLength(), 0),
+          totalLogSize + txEffect.contractClassLogs.reduce((acc, log) => acc + log.emittedLength, 0),
         0,
       ),
     };
@@ -198,8 +177,24 @@ export class L2Block {
     return {
       txCount: this.body.txEffects.length,
       blockNumber: this.number,
-      blockTimestamp: this.header.globalVariables.timestamp.toNumber(),
+      blockTimestamp: Number(this.header.globalVariables.timestamp),
       ...logsStats,
     };
   }
+
+  toBlockInfo(): L2BlockInfo {
+    return {
+      blockHash: this.blockHash,
+      archive: this.archive.root,
+      lastArchive: this.header.lastArchive.root,
+      blockNumber: this.number,
+      slotNumber: Number(this.header.getSlot()),
+      txCount: this.body.txEffects.length,
+      timestamp: this.header.globalVariables.timestamp,
+    };
+  }
+
+  equals(other: L2Block) {
+    return this.archive.equals(other.archive) && this.header.equals(other.header) && this.body.equals(other.body);
+  }
 }

package/src/block/l2_block_code_to_purge.ts

@@ -1,33 +1,35 @@
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { compact } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { AztecAddress } from '../aztec-address/index.js';
 import { GasFees } from '../gas/gas_fees.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { BlockHeader } from '../tx/block_header.js';
-import { ContentCommitment, NUM_BYTES_PER_SHA256 } from '../tx/content_commitment.js';
+import { ContentCommitment } from '../tx/content_commitment.js';
 import { GlobalVariables } from '../tx/global_variables.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
 import { StateReference } from '../tx/state_reference.js';
+import { L2BlockHeader } from './l2_block_header.js';
 
-/**
- * Makes header.
- */
-export function makeHeader(
+export function makeL2BlockHeader(
   seed = 0,
-  numTxs: number | undefined = undefined,
-  blockNumber: number | undefined = undefined,
-  slotNumber: number | undefined = undefined,
-  inHash: Buffer | undefined = undefined,
-): BlockHeader {
-  return new BlockHeader(
+  blockNumber?: number,
+  slotNumber?: number,
+  overrides: Partial<FieldsOf<L2BlockHeader>> = {},
+  inHash?: Fr,
+) {
+  return new L2BlockHeader(
     makeAppendOnlyTreeSnapshot(seed + 0x100),
-    makeContentCommitment(seed + 0x200, numTxs, inHash),
-    makeStateReference(seed + 0x600),
-    makeGlobalVariables((seed += 0x700), blockNumber, slotNumber ?? blockNumber),
+    overrides?.contentCommitment ?? makeContentCommitment(seed + 0x200, inHash),
+    overrides?.state ?? makeStateReference(seed + 0x600),
+    makeGlobalVariables((seed += 0x700), {
+      ...(blockNumber ? { blockNumber } : {}),
+      ...(slotNumber ? { slotNumber: new Fr(slotNumber) } : {}),
+    }),
     new Fr(seed + 0x800),
     new Fr(seed + 0x900),
+    new Fr(seed + 0xa00),
   );
 }
 
@@ -43,17 +45,8 @@ export function makeAppendOnlyTreeSnapshot(seed = 1): AppendOnlyTreeSnapshot {
 /**
  * Makes content commitment
  */
-function makeContentCommitment(
-  seed = 0,
-  numTxs: number | undefined = undefined,
-  inHash: Buffer | undefined = undefined,
-): ContentCommitment {
-  return new ContentCommitment(
-    numTxs ? new Fr(numTxs) : new Fr(seed),
-    toBufferBE(BigInt(seed + 0x100), NUM_BYTES_PER_SHA256),
-    inHash ?? toBufferBE(BigInt(seed + 0x200), NUM_BYTES_PER_SHA256),
-    toBufferBE(BigInt(seed + 0x300), NUM_BYTES_PER_SHA256),
-  );
+function makeContentCommitment(seed = 0, inHash?: Fr): ContentCommitment {
+  return new ContentCommitment(new Fr(seed + 0x100), inHash ?? new Fr(seed + 0x200), new Fr(seed + 0x300));
 }
 
 /**
@@ -78,26 +71,16 @@ function makePartialStateReference(seed = 0): PartialStateReference {
   );
 }
 
-/**
- * Makes global variables.
- * @param seed - The seed to use for generating the global variables.
- * @param blockNumber - The block number to use for generating the global variables.
- * If blockNumber is undefined, it will be set to seed + 2.
- * @returns Global variables.
- */
-export function makeGlobalVariables(
-  seed = 1,
-  blockNumber: number | undefined = undefined,
-  slotNumber: number | undefined = undefined,
-): GlobalVariables {
-  return new GlobalVariables(
-    new Fr(seed),
-    new Fr(seed + 1),
-    new Fr(blockNumber ?? seed + 2),
-    new Fr(slotNumber ?? seed + 3),
-    new Fr(seed + 4),
-    EthAddress.fromField(new Fr(seed + 5)),
-    AztecAddress.fromField(new Fr(seed + 6)),
-    new GasFees(new Fr(seed + 7), new Fr(seed + 8)),
-  );
+function makeGlobalVariables(seed = 1, overrides: Partial<FieldsOf<GlobalVariables>> = {}): GlobalVariables {
+  return GlobalVariables.from({
+    chainId: new Fr(seed),
+    version: new Fr(seed + 1),
+    blockNumber: seed + 2,
+    slotNumber: new Fr(seed + 3),
+    timestamp: BigInt(seed + 4),
+    coinbase: EthAddress.fromField(new Fr(seed + 5)),
+    feeRecipient: AztecAddress.fromField(new Fr(seed + 6)),
+    gasFees: new GasFees(seed + 7, seed + 8),
+    ...compact(overrides),
+  });
 }