@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/block/l2_block.ts

@@ -1,4 +1,3 @@
-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';
@@ -9,6 +8,7 @@ import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { Body } from './body.js';
 import { makeAppendOnlyTreeSnapshot, makeHeader } from './l2_block_code_to_purge.js';
+import type { L2BlockInfo } from './l2_block_info.js';
 
 /**
  * The data that makes up the rollup proof, with encoder decoder functions.
@@ -21,6 +21,7 @@ export class L2Block {
     public header: BlockHeader,
     /** L2 block body. */
     public body: Body,
+    private blockHash: Fr | undefined = undefined,
   ) {}
 
   static get schema() {
@@ -85,14 +86,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),
+      makeHeader(0, l2BlockNum, slotNumber ?? l2BlockNum, inHash),
       body,
     );
   }
@@ -102,78 +104,30 @@ export class L2Block {
    * @returns The L2 block.
    */
   static empty(): L2Block {
-    return new L2Block(AppendOnlyTreeSnapshot.zero(), BlockHeader.empty(), Body.empty());
+    return new L2Block(AppendOnlyTreeSnapshot.empty(), BlockHeader.empty(), Body.empty());
   }
 
   get number(): number {
-    return Number(this.header.globalVariables.blockNumber.toBigInt());
+    return this.header.getBlockNumber();
   }
 
-  /**
-   * Returns the block's hash (hash of block header).
-   * @returns The block's hash.
-   */
-  public hash(): Promise<Fr> {
-    return this.header.hash();
+  get slot(): bigint {
+    return this.header.getSlot();
   }
 
-  /**
-   * 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.
-   */
-  // 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);
-  }
-
-  /**
-   * 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);
+  get timestamp(): bigint {
+    return this.header.globalVariables.timestamp;
   }
 
   /**
-   * Computes the end state hash (should equal contract data after block).
-   * @returns The end state hash for the L2 block.
+   * Returns the block's hash (hash of block header).
+   * @returns The block's hash.
    */
-  // 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 async hash(): Promise<Fr> {
+    if (this.blockHash === undefined) {
+      this.blockHash = await this.header.hash();
+    }
+    return this.blockHash;
   }
 
   /**
@@ -190,7 +144,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 +152,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,4 +1,3 @@
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 
@@ -6,7 +5,7 @@ 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';
@@ -14,16 +13,10 @@ import { StateReference } from '../tx/state_reference.js';
 /**
  * Makes header.
  */
-export function makeHeader(
-  seed = 0,
-  numTxs: number | undefined = undefined,
-  blockNumber: number | undefined = undefined,
-  slotNumber: number | undefined = undefined,
-  inHash: Buffer | undefined = undefined,
-): BlockHeader {
+export function makeHeader(seed = 0, blockNumber?: number, slotNumber?: number, inHash?: Fr): BlockHeader {
   return new BlockHeader(
     makeAppendOnlyTreeSnapshot(seed + 0x100),
-    makeContentCommitment(seed + 0x200, numTxs, inHash),
+    makeContentCommitment(seed + 0x200, inHash),
     makeStateReference(seed + 0x600),
     makeGlobalVariables((seed += 0x700), blockNumber, slotNumber ?? blockNumber),
     new Fr(seed + 0x800),
@@ -43,17 +36,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));
 }
 
 /**
@@ -93,11 +77,11 @@ export function makeGlobalVariables(
   return new GlobalVariables(
     new Fr(seed),
     new Fr(seed + 1),
-    new Fr(blockNumber ?? seed + 2),
+    blockNumber ?? seed + 2,
     new Fr(slotNumber ?? seed + 3),
-    new Fr(seed + 4),
+    BigInt(seed + 4),
     EthAddress.fromField(new Fr(seed + 5)),
     AztecAddress.fromField(new Fr(seed + 6)),
-    new GasFees(new Fr(seed + 7), new Fr(seed + 8)),
+    new GasFees(seed + 7, seed + 8),
   );
 }

package/src/block/l2_block_info.ts

@@ -0,0 +1,63 @@
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+export type L2BlockInfo = {
+  blockHash?: Fr;
+  archive: Fr;
+  lastArchive: Fr;
+  blockNumber: number;
+  slotNumber: number;
+  txCount: number;
+  timestamp: bigint;
+};
+
+export function randomBlockInfo(blockNumber?: number): L2BlockInfo {
+  return {
+    blockHash: Fr.random(),
+    archive: Fr.random(),
+    lastArchive: Fr.random(),
+    blockNumber: blockNumber ?? Math.floor(Math.random() * 100000) + 1,
+    slotNumber: Math.floor(Math.random() * 100000) + 1,
+    txCount: Math.floor(Math.random() * 100),
+    timestamp: BigInt(Math.floor(Date.now() / 1000)),
+  };
+}
+
+export const BlockInfoSchema = z.object({
+  blockHash: schemas.Fr.optional(),
+  archive: schemas.Fr,
+  lastArchive: schemas.Fr,
+  blockNumber: z.number(),
+  slotNumber: z.number(),
+  txCount: z.number(),
+  timestamp: schemas.BigInt,
+});
+
+export function serializeBlockInfo(blockInfo: L2BlockInfo): Buffer {
+  return serializeToBuffer(
+    blockInfo.blockHash ?? Fr.ZERO,
+    blockInfo.archive,
+    blockInfo.lastArchive,
+    blockInfo.blockNumber,
+    blockInfo.slotNumber,
+    blockInfo.txCount,
+    blockInfo.timestamp,
+  );
+}
+
+export function deserializeBlockInfo(buffer: Buffer | BufferReader): L2BlockInfo {
+  const reader = BufferReader.asReader(buffer);
+  const blockHash = reader.readObject(Fr);
+  return {
+    blockHash: blockHash.equals(Fr.ZERO) ? undefined : blockHash,
+    archive: reader.readObject(Fr),
+    lastArchive: reader.readObject(Fr),
+    blockNumber: reader.readNumber(),
+    slotNumber: reader.readNumber(),
+    txCount: reader.readNumber(),
+    timestamp: reader.readBigInt(),
+  };
+}

package/src/block/l2_block_source.ts

@@ -1,15 +1,17 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Fr } from '@aztec/foundation/fields';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
 
-import type { EventEmitter } from 'events';
 import { z } from 'zod';
 
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
 import type { BlockHeader } from '../tx/block_header.js';
-import type { TxEffect } from '../tx/tx_effect.js';
+import type { IndexedTxEffect } from '../tx/indexed_tx_effect.js';
 import type { TxHash } from '../tx/tx_hash.js';
 import type { TxReceipt } from '../tx/tx_receipt.js';
-import type { InBlock } from './in_block.js';
 import type { L2Block } from './l2_block.js';
+import { PublishedL2Block } from './published_l2_block.js';
+import type { ValidateBlockNegativeResult, ValidateBlockResult } from './validate_block_result.js';
 
 /**
  * Interface of classes allowing for the retrieval of L2 blocks.
@@ -62,12 +64,43 @@ export interface L2BlockSource {
    */
   getBlocks(from: number, limit: number, proven?: boolean): Promise<L2Block[]>;
 
+  /** Equivalent to getBlocks but includes publish data. */
+  getPublishedBlocks(from: number, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+
+  /**
+   * Gets a published block by its hash.
+   * @param blockHash - The block hash to retrieve.
+   * @returns The requested published block (or undefined if not found).
+   */
+  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined>;
+
+  /**
+   * Gets a published block by its archive root.
+   * @param archive - The archive root to retrieve.
+   * @returns The requested published block (or undefined if not found).
+   */
+  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined>;
+
+  /**
+   * Gets a block header by its hash.
+   * @param blockHash - The block hash to retrieve.
+   * @returns The requested block header (or undefined if not found).
+   */
+  getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined>;
+
+  /**
+   * Gets a block header by its archive root.
+   * @param archive - The archive root to retrieve.
+   * @returns The requested block header (or undefined if not found).
+   */
+  getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined>;
+
   /**
    * Gets a tx effect.
-   * @param txHash - The hash of a transaction which resulted in the returned tx effect.
-   * @returns The requested tx effect.
+   * @param txHash - The hash of the tx corresponding to the tx effect.
+   * @returns The requested tx effect with block info (or undefined if not found).
    */
-  getTxEffect(txHash: TxHash): Promise<InBlock<TxEffect> | undefined>;
+  getTxEffect(txHash: TxHash): Promise<IndexedTxEffect | undefined>;
 
   /**
    * Gets a receipt of a settled tx.
@@ -77,14 +110,14 @@ export interface L2BlockSource {
   getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
 
   /**
-   * Returns the current L2 slot number based on the current L1 timestamp.
+   * Returns the current L2 slot number based on the currently synced L1 timestamp.
    */
-  getL2SlotNumber(): Promise<bigint>;
+  getL2SlotNumber(): Promise<bigint | undefined>;
 
   /**
-   * Returns the current L2 epoch number based on the current L1 timestamp.
+   * Returns the current L2 epoch number based on the currently synced L1 timestamp.
    */
-  getL2EpochNumber(): Promise<bigint>;
+  getL2EpochNumber(): Promise<bigint | undefined>;
 
   /**
    * Returns all blocks for a given epoch.
@@ -93,6 +126,13 @@ export interface L2BlockSource {
    */
   getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]>;
 
+  /**
+   * Returns all block headers for a given epoch.
+   * @dev Use this method only with recent epochs, since it walks the block list backwards.
+   * @param epochNumber - The epoch number to return headers for.
+   */
+  getBlockHeadersForEpoch(epochNumber: bigint): Promise<BlockHeader[]>;
+
   /**
    * Returns whether the given epoch is completed on L1, based on the current L1 and L2 block numbers.
    * @param epochNumber - The epoch number to check.
@@ -108,13 +148,39 @@ export interface L2BlockSource {
    * Returns the rollup constants for the current chain.
    */
   getL1Constants(): Promise<L1RollupConstants>;
+
+  /** Returns values for the genesis block */
+  getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }>;
+
+  /** Latest synced L1 timestamp. */
+  getL1Timestamp(): Promise<bigint | undefined>;
+
+  /**
+   * Returns whether the latest block in the pending chain on L1 is invalid (ie its attestations are incorrect).
+   * Note that invalid blocks do not get synced, so the latest block returned by the block source is always a valid one.
+   */
+  isPendingChainInvalid(): Promise<boolean>;
+
+  /**
+   * Returns the status of the pending chain validation. If the chain is invalid, reports the earliest consecutive block
+   * that is invalid, along with the reason for being invalid, which can be used to trigger an invalidation.
+   */
+  getPendingChainValidationStatus(): Promise<ValidateBlockResult>;
+
+  /** Force a sync. */
+  syncImmediate(): Promise<void>;
 }
 
 /**
  * L2BlockSource that emits events upon pending / proven chain changes.
  * see L2BlockSourceEvents for the events emitted.
  */
-export interface L2BlockSourceEventEmitter extends L2BlockSource, EventEmitter {}
+export type ArchiverEmitter = TypedEventEmitter<{
+  [L2BlockSourceEvents.L2PruneDetected]: (args: L2BlockPruneEvent) => void;
+  [L2BlockSourceEvents.L2BlockProven]: (args: L2BlockProvenEvent) => void;
+  [L2BlockSourceEvents.InvalidAttestationsBlockDetected]: (args: InvalidBlockDetectedEvent) => void;
+}>;
+export interface L2BlockSourceEventEmitter extends L2BlockSource, ArchiverEmitter {}
 
 /**
  * Identifier for L2 block tags.
@@ -130,6 +196,14 @@ export type L2Tips = Record<L2BlockTag, L2BlockId>;
 /** Identifies a block by number and hash. */
 export type L2BlockId = z.infer<typeof L2BlockIdSchema>;
 
+/** Creates an L2 block id */
+export function makeL2BlockId(number: number, hash?: string): L2BlockId {
+  if (number !== 0 && !hash) {
+    throw new Error(`Hash is required for non-genesis blocks (got block number ${number})`);
+  }
+  return { number, hash: hash! };
+}
+
 // TODO(palla/schemas): This package should know what is the block hash of the genesis block 0.
 const L2BlockIdSchema = z.union([
   z.object({
@@ -150,11 +224,24 @@ export const L2TipsSchema = z.object({
 
 export enum L2BlockSourceEvents {
   L2PruneDetected = 'l2PruneDetected',
+  L2BlockProven = 'l2BlockProven',
+  InvalidAttestationsBlockDetected = 'invalidBlockDetected',
 }
 
-export type L2BlockSourceEvent = {
-  type: 'l2PruneDetected';
+export type L2BlockProvenEvent = {
+  type: 'l2BlockProven';
   blockNumber: bigint;
   slotNumber: bigint;
   epochNumber: bigint;
 };
+
+export type L2BlockPruneEvent = {
+  type: 'l2PruneDetected';
+  epochNumber: bigint;
+  blocks: L2Block[];
+};
+
+export type InvalidBlockDetectedEvent = {
+  type: 'invalidBlockDetected';
+  validationResult: ValidateBlockNegativeResult;
+};

package/src/block/l2_block_stream/index.ts

@@ -0,0 +1,3 @@
+export * from './interfaces.js';
+export * from './l2_block_stream.js';
+export * from './l2_tips_memory_store.js';

package/src/block/l2_block_stream/interfaces.ts

@@ -0,0 +1,33 @@
+import type { L2BlockId, L2Tips } from '../l2_block_source.js';
+import type { PublishedL2Block } from '../published_l2_block.js';
+
+/** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
+export interface L2BlockStreamLocalDataProvider {
+  getL2BlockHash(number: number): Promise<string | undefined>;
+  getL2Tips(): Promise<L2Tips>;
+}
+
+/** Interface to a handler of events emitted. */
+export interface L2BlockStreamEventHandler {
+  handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
+}
+
+export type L2BlockStreamEvent =
+  | /** Emits blocks added to the chain. */ {
+      type: 'blocks-added';
+      blocks: PublishedL2Block[];
+    }
+  | /** Reports last correct block (new tip of the unproven chain). */ {
+      type: 'chain-pruned';
+      block: L2BlockId;
+    }
+  | /** Reports new proven block. */ {
+      type: 'chain-proven';
+      block: L2BlockId;
+    }
+  | /** Reports new finalized block (proven and finalized on L1). */ {
+      type: 'chain-finalized';
+      block: L2BlockId;
+    };
+
+export type L2TipsStore = L2BlockStreamEventHandler & L2BlockStreamLocalDataProvider;