@aztec/stdlib 3.0.3 → 4.0.0-devnet.1-patch.1

package/src/snapshots/types.ts

@@ -1,5 +1,5 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
@@ -38,33 +38,37 @@ export type SnapshotsIndex = SnapshotsIndexMetadata & {
 export type UploadSnapshotMetadata = Pick<SnapshotMetadata, 'l2BlockNumber' | 'l2BlockHash' | 'l1BlockNumber'> &
   Pick<SnapshotsIndex, 'l1ChainId' | 'rollupVersion' | 'rollupAddress'>;
 
-export const SnapshotsIndexSchema = z.object({
-  l1ChainId: z.number(),
-  rollupVersion: z.number(),
-  rollupAddress: schemas.EthAddress,
-  snapshots: z.array(
-    z.object({
-      l2BlockNumber: z.number(),
-      l2BlockHash: z.string(),
-      l1BlockNumber: z.number(),
-      timestamp: z.number(),
-      schemaVersions: z.object({
-        archiver: z.number(),
-        worldState: z.number(),
+export const SnapshotsIndexSchema = zodFor<SnapshotsIndex>()(
+  z.object({
+    l1ChainId: z.number(),
+    rollupVersion: z.number(),
+    rollupAddress: schemas.EthAddress,
+    snapshots: z.array(
+      z.object({
+        l2BlockNumber: z.number(),
+        l2BlockHash: z.string(),
+        l1BlockNumber: z.number(),
+        timestamp: z.number(),
+        schemaVersions: z.object({
+          archiver: z.number(),
+          worldState: z.number(),
+        }),
+        dataUrls: z
+          .record(z.enum(SnapshotDataKeys), z.string())
+          // See https://stackoverflow.com/questions/77958464/zod-record-with-required-keys
+          .refine((obj): obj is Required<typeof obj> => SnapshotDataKeys.every(key => !!obj[key])),
       }),
-      dataUrls: z
-        .record(z.enum(SnapshotDataKeys), z.string())
-        // See https://stackoverflow.com/questions/77958464/zod-record-with-required-keys
-        .refine((obj): obj is Required<typeof obj> => SnapshotDataKeys.every(key => !!obj[key])),
-    }),
-  ),
-}) satisfies ZodFor<SnapshotsIndex>;
+    ),
+  }),
+);
 
-export const UploadSnapshotMetadataSchema = z.object({
-  l2BlockNumber: z.number(),
-  l2BlockHash: z.string(),
-  l1BlockNumber: z.number(),
-  l1ChainId: z.number(),
-  rollupVersion: z.number(),
-  rollupAddress: schemas.EthAddress,
-}) satisfies ZodFor<UploadSnapshotMetadata>;
+export const UploadSnapshotMetadataSchema = zodFor<UploadSnapshotMetadata>()(
+  z.object({
+    l2BlockNumber: z.number(),
+    l2BlockHash: z.string(),
+    l1BlockNumber: z.number(),
+    l1ChainId: z.number(),
+    rollupVersion: z.number(),
+    rollupAddress: schemas.EthAddress,
+  }),
+);

package/src/stats/stats.ts

@@ -20,6 +20,13 @@ export type L2BlockStats = {
   publicLogCount?: number;
 };
 
+export type CheckpointStats = {
+  /** Number of transactions in the checkpoint */
+  txCount: number;
+  /** Number of blocks in the checkpoint */
+  blockCount: number;
+};
+
 /** Stats logged for each L1 publish tx.*/
 export type L1PublishStats = {
   /** Address of the sender. */
@@ -45,11 +52,11 @@ export type L1PublishStats = {
 };
 
 /** Stats logged for each L1 rollup publish tx.*/
-export type L1PublishBlockStats = {
+export type L1PublishCheckpointStats = {
   /** Name of the event for metrics purposes */
   eventName: 'rollup-published-to-l1';
 } & L1PublishStats &
-  L2BlockStats;
+  CheckpointStats;
 
 /** Stats logged for each L1 rollup publish tx.*/
 export type L1PublishProofStats = {
@@ -189,16 +196,12 @@ export type CircuitVerificationStats = {
 
 /** Stats for an L2 block built by a sequencer. */
 export type L2BlockBuiltStats = {
-  /** The creator of the block */
-  creator: string;
   /** Name of the event. */
   eventName: 'l2-block-built';
   /** Total duration in ms. */
   duration: number;
   /** Time for processing public txs in ms. */
   publicProcessDuration: number;
-  /** Time for running rollup circuits in ms.  */
-  rollupCircuitsDuration: number;
 } & L2BlockStats;
 
 /** Stats for an L2 block processed by the world state synchronizer. */
@@ -272,7 +275,7 @@ export type Stats =
   | CircuitSimulationStats
   | CircuitWitnessGenerationStats
   | PublicDBAccessStats
-  | L1PublishBlockStats
+  | L1PublishCheckpointStats
   | L1PublishProofStats
   | L2BlockBuiltStats
   | L2BlockHandledStats

package/src/tests/factories.ts

@@ -7,11 +7,11 @@ import {
 import {
   ARCHIVE_HEIGHT,
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
-  AZTEC_MAX_EPOCH_DURATION,
   CHONK_PROOF_LENGTH,
   CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
   GeneratorIndex,
   L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  MAX_CHECKPOINTS_PER_EPOCH,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_ENQUEUED_CALLS_PER_CALL,
   MAX_ENQUEUED_CALLS_PER_TX,
@@ -43,7 +43,7 @@ import {
   VK_TREE_HEIGHT,
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { compact } from '@aztec/foundation/collection';
 import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
@@ -87,7 +87,7 @@ import {
 import { PublicDataRead } from '../avm/public_data_read.js';
 import { PublicDataWrite } from '../avm/public_data_write.js';
 import { AztecAddress } from '../aztec-address/index.js';
-import { L2BlockHeader } from '../block/l2_block_header.js';
+import type { L2Tips } from '../block/l2_block_source.js';
 import {
   type ContractClassPublic,
   ContractDeploymentData,
@@ -131,6 +131,7 @@ import { PublicKeys, computeAddress } from '../keys/index.js';
 import { ContractClassLog, ContractClassLogFields } from '../logs/index.js';
 import { PrivateLog } from '../logs/private_log.js';
 import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
+import { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
 import { CountedL2ToL1Message, L2ToL1Message, ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
@@ -163,7 +164,6 @@ import { NullifierLeaf, NullifierLeafPreimage } from '../trees/nullifier_leaf.js
 import { PublicDataTreeLeaf, PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { CallContext } from '../tx/call_context.js';
-import { ContentCommitment } from '../tx/content_commitment.js';
 import { FunctionData } from '../tx/function_data.js';
 import { GlobalVariables } from '../tx/global_variables.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
@@ -173,6 +173,7 @@ import { StateReference } from '../tx/state_reference.js';
 import { TreeSnapshots } from '../tx/tree_snapshots.js';
 import { TxConstantData } from '../tx/tx_constant_data.js';
 import { TxContext } from '../tx/tx_context.js';
+import { TxHash } from '../tx/tx_hash.js';
 import { TxRequest } from '../tx/tx_request.js';
 import { Vector } from '../types/index.js';
 import { VkData } from '../vks/index.js';
@@ -835,7 +836,6 @@ export function makeBlockRollupPublicInputs(seed = 0): BlockRollupPublicInputs {
     makeSpongeBlob(seed + 0x600),
     makeSpongeBlob(seed + 0x700),
     BigInt(seed + 0x800),
-    BigInt(seed + 0x810),
     fr(seed + 0x820),
     fr(seed + 0x830),
     fr(seed + 0x840),
@@ -849,11 +849,13 @@ export function makeCheckpointRollupPublicInputs(seed = 0) {
     makeEpochConstantData(seed),
     makeAppendOnlyTreeSnapshot(seed + 0x100),
     makeAppendOnlyTreeSnapshot(seed + 0x200),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x300),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x400),
-    makeBlobAccumulator(seed + 0x500),
+    makeAppendOnlyTreeSnapshot(seed + 0x300),
+    makeAppendOnlyTreeSnapshot(seed + 0x350),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => fr(seed), 0x400),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => makeFeeRecipient(seed), 0x500),
     makeBlobAccumulator(seed + 0x600),
-    makeFinalBlobBatchingChallenges(seed + 0x700),
+    makeBlobAccumulator(seed + 0x700),
+    makeFinalBlobBatchingChallenges(seed + 0x800),
   );
 }
 
@@ -885,20 +887,14 @@ export function makeRootRollupPublicInputs(seed = 0): RootRollupPublicInputs {
   return new RootRollupPublicInputs(
     fr(seed + 0x100),
     fr(seed + 0x200),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x300),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x500),
+    fr(seed + 0x300),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => fr(seed), 0x400),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => makeFeeRecipient(seed), 0x500),
     makeEpochConstantData(seed + 0x600),
     makeFinalBlobAccumulator(seed + 0x700),
   );
 }
 
-/**
- * Makes content commitment
- */
-export function makeContentCommitment(seed = 0): ContentCommitment {
-  return new ContentCommitment(fr(seed + 0x100), fr(seed + 0x200), fr(seed + 0x300));
-}
-
 export function makeBlockHeader(
   seed = 0,
   overrides: Partial<FieldsOf<Omit<BlockHeader, 'globalVariables'>>> & Partial<FieldsOf<GlobalVariables>> = {},
@@ -914,38 +910,20 @@ export function makeBlockHeader(
   });
 }
 
-export function makeL2BlockHeader(
-  seed = 0,
-  blockNumber?: number,
-  slotNumber?: number,
-  overrides: Partial<FieldsOf<L2BlockHeader>> = {},
-) {
-  return new L2BlockHeader(
-    makeAppendOnlyTreeSnapshot(seed + 0x100),
-    overrides?.contentCommitment ?? makeContentCommitment(seed + 0x200),
-    overrides?.state ?? makeStateReference(seed + 0x600),
-    makeGlobalVariables((seed += 0x700), {
-      ...(blockNumber !== undefined ? { blockNumber: BlockNumber(blockNumber) } : {}),
-      ...(slotNumber !== undefined ? { slotNumber: SlotNumber(slotNumber) } : {}),
-    }),
-    new Fr(seed + 0x800),
-    new Fr(seed + 0x900),
-    new Fr(seed + 0xa00),
-    new Fr(seed + 0xb00),
-  );
-}
-
-export function makeCheckpointHeader(seed = 0) {
+export function makeCheckpointHeader(seed = 0, overrides: Partial<FieldsOf<CheckpointHeader>> = {}) {
   return CheckpointHeader.from({
     lastArchiveRoot: fr(seed + 0x100),
     blockHeadersHash: fr(seed + 0x150),
-    contentCommitment: makeContentCommitment(seed + 0x200),
+    blobsHash: fr(seed + 0x200),
+    inHash: fr(seed + 0x210),
+    epochOutHash: fr(seed + 0x220),
     slotNumber: SlotNumber(seed + 0x300),
     timestamp: BigInt(seed + 0x400),
     coinbase: makeEthAddress(seed + 0x500),
     feeRecipient: makeAztecAddress(seed + 0x600),
     gasFees: makeGasFees(seed + 0x700),
     totalManaUsed: fr(seed + 0x800),
+    ...overrides,
   });
 }
 
@@ -986,7 +964,7 @@ function makeCountedL2ToL1Message(seed = 0) {
   return new CountedL2ToL1Message(makeL2ToL1Message(seed), seed + 2);
 }
 
-function makeScopedL2ToL1Message(seed = 1) {
+export function makeScopedL2ToL1Message(seed = 1) {
   return new ScopedL2ToL1Message(makeL2ToL1Message(seed), makeAztecAddress(seed + 3));
 }
 
@@ -1696,3 +1674,86 @@ export async function makeAvmCircuitInputs(
 export function fr(n: number): Fr {
   return new Fr(BigInt(n));
 }
+
+/**
+ * Creates a random TxScopedL2Log with private log data.
+ */
+export function randomTxScopedPrivateL2Log(opts?: {
+  tag?: Fr;
+  txHash?: TxHash;
+  blockNumber?: number;
+  blockTimestamp?: bigint;
+  noteHashes?: Fr[];
+  firstNullifier?: Fr;
+}) {
+  const log = PrivateLog.random(opts?.tag);
+  return new TxScopedL2Log(
+    opts?.txHash ?? TxHash.random(),
+    BlockNumber(opts?.blockNumber ?? 1),
+    opts?.blockTimestamp ?? 1n,
+    log.getEmittedFields(),
+    opts?.noteHashes ?? [Fr.random(), Fr.random()],
+    opts?.firstNullifier ?? Fr.random(),
+  );
+}
+
+/**
+ * Creates a random TxScopedL2Log with public log data.
+ */
+export async function randomTxScopedPublicL2Log(opts?: {
+  txHash?: TxHash;
+  blockNumber?: number;
+  blockTimestamp?: bigint;
+  noteHashes?: Fr[];
+  firstNullifier?: Fr;
+}) {
+  const log = await PublicLog.random();
+  return new TxScopedL2Log(
+    opts?.txHash ?? TxHash.random(),
+    BlockNumber(opts?.blockNumber ?? 1),
+    opts?.blockTimestamp ?? 1n,
+    log.getEmittedFields(),
+    opts?.noteHashes ?? [Fr.random(), Fr.random()],
+    opts?.firstNullifier ?? Fr.random(),
+  );
+}
+
+/**
+ * Creates L2Tips with all tips pointing to the same block number.
+ * Useful for mocking aztecNode.getL2Tips() in tests.
+ * @param blockNumber - The block number to use for all tips.
+ * @param hash - Optional hash for the block (defaults to empty string).
+ * @param checkpointNumber - Optional checkpoint number (defaults to blockNumber).
+ * @param checkpointHash - Optional checkpoint hash (defaults to block hash).
+ * @returns L2Tips object with all tips at the same block.
+ */
+export function makeL2Tips(
+  blockNumber: number | BlockNumber,
+  hash = '',
+  checkpointNumber?: number | CheckpointNumber,
+  checkpointHash?: string,
+): L2Tips {
+  const bn = typeof blockNumber === 'number' ? BlockNumber(blockNumber) : blockNumber;
+  const cpn =
+    checkpointNumber !== undefined
+      ? typeof checkpointNumber === 'number'
+        ? CheckpointNumber(checkpointNumber)
+        : checkpointNumber
+      : CheckpointNumber.fromBlockNumber(bn);
+  const cph = checkpointHash ?? hash;
+  return {
+    proposed: { number: bn, hash },
+    checkpointed: {
+      block: { number: bn, hash },
+      checkpoint: { number: cpn, hash: cph },
+    },
+    proven: {
+      block: { number: bn, hash },
+      checkpoint: { number: cpn, hash: cph },
+    },
+    finalized: {
+      block: { number: bn, hash },
+      checkpoint: { number: cpn, hash: cph },
+    },
+  };
+}

package/src/tests/jest.ts

@@ -20,7 +20,7 @@ export function equalL2Blocks(a: any, b: any) {
     // use a custom comparator because the blockHash property is lazily computed and one instance might not have it
     return aAsL2Block.toBuffer().equals(bAsL2Block.toBuffer());
   } else if (aAsL2Block || bAsL2Block) {
-    // one value is an L2block and the other isn't. Definitely not equal.
+    // one value is an L2Block and the other isn't. Definitely not equal.
     return false;
   } else {
     // we don't know what they are, tell Jest to keep looking