@aztec/stdlib 3.0.0-nightly.20251222 → 3.0.0-nightly.20251224

package/src/logs/tag.ts

@@ -0,0 +1,42 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { ZodFor } from '@aztec/foundation/schemas';
+
+import { schemas } from '../schemas/schemas.js';
+import type { PreTag } from './pre_tag.js';
+
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+
+export interface Tag {
+  /** Brand. */
+  _branding: 'Tag';
+}
+
+/**
+ * Represents a tag of a private log. This is not the tag that "appears" on the chain as this tag is first siloed
+ * with a contract address by kernels before being included in the final log.
+ */
+export class Tag {
+  constructor(public readonly value: Fr) {}
+
+  static async compute(preTag: PreTag): Promise<Tag> {
+    const tag = await poseidon2Hash([preTag.secret.value, preTag.index]);
+    return new Tag(tag);
+  }
+
+  toString(): string {
+    return this.value.toString();
+  }
+
+  toJSON(): string {
+    return this.value.toString();
+  }
+
+  equals(other: Tag): boolean {
+    return this.value.equals(other.value);
+  }
+
+  static get schema(): ZodFor<Tag> {
+    return schemas.Fr.transform((fr: Fr) => new Tag(fr));
+  }
+}

package/src/logs/tx_scoped_l2_log.ts

@@ -1,10 +1,12 @@
 import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
-import { BufferReader, boolToBuffer, numToUInt32BE } from '@aztec/foundation/serialize';
+import { BufferReader, bigintToUInt64BE, boolToBuffer, numToUInt32BE } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
 import { L2BlockHash } from '../block/block_hash.js';
+import { schemas } from '../schemas/schemas.js';
 import { TxHash } from '../tx/tx_hash.js';
+import type { UInt64 } from '../types/shared.js';
 import { PrivateLog } from './private_log.js';
 import { PublicLog } from './public_log.js';
 
@@ -33,6 +35,10 @@ export class TxScopedL2Log {
      * The block this log is included in
      */
     public blockHash: L2BlockHash,
+    /*
+     * The timestamp of the block this log is included in
+     */
+    public blockTimestamp: UInt64,
     /*
      * The log data as either a PrivateLog or PublicLog
      */
@@ -51,11 +57,12 @@ export class TxScopedL2Log {
         logIndexInTx: z.number(),
         blockNumber: BlockNumberSchema,
         blockHash: L2BlockHash.schema,
+        blockTimestamp: schemas.UInt64,
         log: z.union([PrivateLog.schema, PublicLog.schema]),
       })
       .transform(
-        ({ txHash, dataStartIndexForTx, logIndexInTx, blockNumber, blockHash, log }) =>
-          new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, blockHash, log),
+        ({ txHash, dataStartIndexForTx, logIndexInTx, blockNumber, blockHash, blockTimestamp, log }) =>
+          new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, blockHash, blockTimestamp, log),
       );
   }
 
@@ -66,6 +73,7 @@ export class TxScopedL2Log {
       numToUInt32BE(this.logIndexInTx),
       numToUInt32BE(this.blockNumber),
       this.blockHash.toBuffer(),
+      bigintToUInt64BE(this.blockTimestamp),
       boolToBuffer(this.isFromPublic),
       this.log.toBuffer(),
     ]);
@@ -78,15 +86,16 @@ export class TxScopedL2Log {
     const logIndexInTx = reader.readNumber();
     const blockNumber = BlockNumber(reader.readNumber());
     const blockHash = reader.readObject(L2BlockHash);
+    const blockTimestamp = reader.readUInt64();
     const isFromPublic = reader.readBoolean();
     const log = isFromPublic ? PublicLog.fromBuffer(reader) : PrivateLog.fromBuffer(reader);
 
-    return new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, blockHash, log);
+    return new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, blockHash, blockTimestamp, log);
   }
 
   static async random(isFromPublic = Math.random() < 0.5) {
     const log = isFromPublic ? await PublicLog.random() : PrivateLog.random();
-    return new TxScopedL2Log(TxHash.random(), 1, 1, BlockNumber(1), L2BlockHash.random(), log);
+    return new TxScopedL2Log(TxHash.random(), 1, 1, BlockNumber(1), L2BlockHash.random(), 1n, log);
   }
 
   equals(other: TxScopedL2Log) {
@@ -96,6 +105,7 @@ export class TxScopedL2Log {
       this.logIndexInTx === other.logIndexInTx &&
       this.blockNumber === other.blockNumber &&
       this.blockHash.equals(other.blockHash) &&
+      this.blockTimestamp === other.blockTimestamp &&
       ((this.log instanceof PublicLog && other.log instanceof PublicLog) ||
         (this.log instanceof PrivateLog && other.log instanceof PrivateLog)) &&
       this.log.equals(other.log as any)

package/src/messaging/l1_to_l2_message.ts

@@ -84,6 +84,7 @@ export async function getNonNullifiedL1ToL2MessageWitness(
   if (!response) {
     throw new Error(`No L1 to L2 message found for message hash ${messageHash.toString()}`);
   }
+
   const [messageIndex, siblingPath] = response;
 
   const messageNullifier = await computeL1ToL2MessageNullifier(contractAddress, messageHash, secret);

package/src/rollup/checkpoint_constant_data.ts

@@ -11,6 +11,7 @@ import { GasFees } from '../gas/gas_fees.js';
 
 /**
  * Constants that are the same for the entire checkpoint.
+ * Used in circuits during rollup proving.
  */
 export class CheckpointConstantData {
   constructor(

package/src/rollup/checkpoint_header.ts

@@ -17,6 +17,10 @@ import { schemas } from '../schemas/index.js';
 import { ContentCommitment } from '../tx/content_commitment.js';
 import type { UInt64 } from '../types/shared.js';
 
+/**
+ * Header of a checkpoint. A checkpoint is a collection of blocks submitted to L1 all within the same slot.
+ * TODO(palla/mbps): Should this include chainId and version as well? Is this used just in circuits?
+ */
 export class CheckpointHeader {
   constructor(
     /** Root of the archive tree before this block is added. */

package/src/schemas/schemas.ts

@@ -40,6 +40,9 @@ export const schemas = {
   /** Coerces input to UInt32. */
   UInt32: foundationSchemas.UInt32,
 
+  /** Coerces input to UInt64. */
+  UInt64: foundationSchemas.UInt64,
+
   /** Accepts a hex string as a Buffer32 type. */
   Buffer32: foundationSchemas.Buffer32 as ZodFor<Buffer32>,
 

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,8 +196,6 @@ 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. */
@@ -272,7 +277,7 @@ export type Stats =
   | CircuitSimulationStats
   | CircuitWitnessGenerationStats
   | PublicDBAccessStats
-  | L1PublishBlockStats
+  | L1PublishCheckpointStats
   | L1PublishProofStats
   | L2BlockBuiltStats
   | L2BlockHandledStats

package/src/tx/global_variable_builder.ts

@@ -4,7 +4,7 @@ import type { SlotNumber } from '@aztec/foundation/schemas';
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { GasFees } from '../gas/gas_fees.js';
 import type { UInt32 } from '../types/index.js';
-import type { GlobalVariables } from './global_variables.js';
+import type { CheckpointGlobalVariables, GlobalVariables } from './global_variables.js';
 
 /**
  * Interface for building global variables for Aztec blocks.
@@ -26,4 +26,11 @@ export interface GlobalVariableBuilder {
     feeRecipient: AztecAddress,
     slotNumber?: SlotNumber,
   ): Promise<GlobalVariables>;
+
+  /** Builds global variables that are constant throughout a checkpoint. */
+  buildCheckpointGlobalVariables(
+    coinbase: EthAddress,
+    feeRecipient: AztecAddress,
+    slotNumber: SlotNumber,
+  ): Promise<CheckpointGlobalVariables>;
 }

package/src/tx/global_variables.ts

@@ -21,6 +21,12 @@ import { GasFees } from '../gas/gas_fees.js';
 import { schemas } from '../schemas/index.js';
 import type { UInt64 } from '../types/index.js';
 
+/**
+ * Global variables that are constant across the entire slot.
+ * TODO(palla/mbps): Should timestamp be included here as well?
+ */
+export type CheckpointGlobalVariables = Omit<FieldsOf<GlobalVariables>, 'blockNumber' | 'timestamp'>;
+
 /**
  * Global variables of the L2 block.
  */