@aztec/stdlib 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/block/body.ts

@@ -1,6 +1,6 @@
-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 { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
@@ -9,14 +9,16 @@ 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 (
@@ -54,19 +56,7 @@ 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);
   }
 
   /**
@@ -74,10 +64,22 @@ export class Body {
    */
   static fromBlobFields(fields: Fr[]) {
     const txEffects: TxEffect[] = [];
-    const reader = new FieldReader(fields);
+    const reader = new FieldReader(fields.slice(0, -1));
     while (!reader.isFinished()) {
       txEffects.push(TxEffect.fromBlobFields(reader));
     }
+
+    // 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);
   }
 

package/src/block/index.ts

@@ -1,4 +1,5 @@
 export * from './l2_block.js';
+export * from './l2_block_header.js';
 export * from './l2_block_stream/index.js';
 export * from './in_block.js';
 export * from './body.js';
@@ -9,3 +10,4 @@ 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

@@ -4,10 +4,12 @@ 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';
 
 /**
@@ -18,7 +20,7 @@ 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,
@@ -28,7 +30,7 @@ export class L2Block {
     return z
       .object({
         archive: AppendOnlyTreeSnapshot.schema,
-        header: BlockHeader.schema,
+        header: L2BlockHeader.schema,
         body: Body.schema,
       })
       .transform(({ archive, header, body }) => new L2Block(archive, header, body));
@@ -40,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);
 
@@ -94,7 +96,7 @@ export class L2Block {
 
     return new L2Block(
       makeAppendOnlyTreeSnapshot(l2BlockNum + 1),
-      makeHeader(0, l2BlockNum, slotNumber ?? l2BlockNum, inHash),
+      makeL2BlockHeader(0, l2BlockNum, slotNumber ?? l2BlockNum, {}, inHash),
       body,
     );
   }
@@ -104,7 +106,7 @@ export class L2Block {
    * @returns The L2 block.
    */
   static empty(): L2Block {
-    return new L2Block(AppendOnlyTreeSnapshot.empty(), BlockHeader.empty(), Body.empty());
+    return new L2Block(AppendOnlyTreeSnapshot.empty(), L2BlockHeader.empty(), Body.empty());
   }
 
   get number(): number {
@@ -125,11 +127,34 @@ export class L2Block {
    */
   public async hash(): Promise<Fr> {
     if (this.blockHash === undefined) {
-      this.blockHash = await this.header.hash();
+      this.blockHash = await this.getBlockHeader().hash();
     }
     return this.blockHash;
   }
 
+  /**
+   * @deprecated
+   * This only works when there's one block per checkpoint.
+   * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
+   */
+  public getCheckpointHeader() {
+    return this.header.toCheckpointHeader();
+  }
+
+  // Temporary helper to get the actual block header.
+  public getBlockHeader(): BlockHeader {
+    return this.header.toBlockHeader();
+  }
+
+  /**
+   * @deprecated
+   * This only works when there's one block per checkpoint.
+   * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
+   */
+  public getCheckpointBlobFields() {
+    return getCheckpointBlobFields([this.body.txEffects]);
+  }
+
   /**
    * Returns stats used for logging.
    * @returns Stats on tx count, number, and log size and count.

package/src/block/l2_block_code_to_purge.ts

@@ -1,26 +1,35 @@
+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 } 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(seed = 0, blockNumber?: number, slotNumber?: number, inHash?: Fr): BlockHeader {
-  return new BlockHeader(
+export function makeL2BlockHeader(
+  seed = 0,
+  blockNumber?: number,
+  slotNumber?: number,
+  overrides: Partial<FieldsOf<L2BlockHeader>> = {},
+  inHash?: Fr,
+) {
+  return new L2BlockHeader(
     makeAppendOnlyTreeSnapshot(seed + 0x100),
-    makeContentCommitment(seed + 0x200, 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),
   );
 }
 
@@ -62,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),
-    blockNumber ?? seed + 2,
-    new Fr(slotNumber ?? seed + 3),
-    BigInt(seed + 4),
-    EthAddress.fromField(new Fr(seed + 5)),
-    AztecAddress.fromField(new Fr(seed + 6)),
-    new GasFees(seed + 7, 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),
+  });
 }

package/src/block/l2_block_header.ts

@@ -0,0 +1,232 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { inspect } from 'util';
+import { z } from 'zod';
+
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { BlockHeader, ContentCommitment, GlobalVariables, StateReference } from '../tx/index.js';
+
+/**
+ * TO BE DELETED
+ *
+ * A header of an L2 block combining the block header and the checkpoint header.
+ * This is a temporary workaround to avoid changing too many things before building in chunks is properly implemented.
+ * This works for now because we only have one block per checkpoint.
+ *
+ * @deprecated Use BlockHeader or CheckpointHeader instead.
+ */
+export class L2BlockHeader {
+  constructor(
+    /** Snapshot of archive before the block is applied. */
+    public lastArchive: AppendOnlyTreeSnapshot,
+    /** Hash of the body of an L2 block. */
+    public contentCommitment: ContentCommitment,
+    /** State reference. */
+    public state: StateReference,
+    /** Global variables of an L2 block. */
+    public globalVariables: GlobalVariables,
+    /** Total fees in the block, computed by the root rollup circuit */
+    public totalFees: Fr,
+    /** Total mana used in the block, computed by the root rollup circuit */
+    public totalManaUsed: Fr,
+    /** Hash of the sponge blob of the block. */
+    public spongeBlobHash: Fr,
+  ) {}
+
+  static get schema(): ZodFor<L2BlockHeader> {
+    return z
+      .object({
+        lastArchive: AppendOnlyTreeSnapshot.schema,
+        contentCommitment: ContentCommitment.schema,
+        state: StateReference.schema,
+        globalVariables: GlobalVariables.schema,
+        totalFees: schemas.Fr,
+        totalManaUsed: schemas.Fr,
+        spongeBlobHash: schemas.Fr,
+      })
+      .transform(L2BlockHeader.from);
+  }
+
+  static getFields(fields: FieldsOf<L2BlockHeader>) {
+    return [
+      fields.lastArchive,
+      fields.contentCommitment,
+      fields.state,
+      fields.globalVariables,
+      fields.totalFees,
+      fields.totalManaUsed,
+      fields.spongeBlobHash,
+    ] as const;
+  }
+
+  static from(fields: FieldsOf<L2BlockHeader>) {
+    return new L2BlockHeader(...L2BlockHeader.getFields(fields));
+  }
+
+  getSlot() {
+    return this.globalVariables.slotNumber.toBigInt();
+  }
+
+  getBlockNumber() {
+    return this.globalVariables.blockNumber;
+  }
+
+  getSize() {
+    return (
+      this.lastArchive.getSize() +
+      this.contentCommitment.getSize() +
+      this.state.getSize() +
+      this.globalVariables.getSize() +
+      this.totalFees.size +
+      this.totalManaUsed.size +
+      this.spongeBlobHash.size
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...L2BlockHeader.getFields(this));
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...L2BlockHeader.getFields(this));
+  }
+
+  clone() {
+    return L2BlockHeader.fromBuffer(this.toBuffer());
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+
+    return new L2BlockHeader(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(ContentCommitment),
+      reader.readObject(StateReference),
+      reader.readObject(GlobalVariables),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+    );
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+
+    return new L2BlockHeader(
+      AppendOnlyTreeSnapshot.fromFields(reader),
+      ContentCommitment.fromFields(reader),
+      StateReference.fromFields(reader),
+      GlobalVariables.fromFields(reader),
+      reader.readField(),
+      reader.readField(),
+      reader.readField(),
+    );
+  }
+
+  static empty(fields: Partial<FieldsOf<L2BlockHeader>> = {}) {
+    return L2BlockHeader.from({
+      lastArchive: AppendOnlyTreeSnapshot.empty(),
+      contentCommitment: ContentCommitment.empty(),
+      state: StateReference.empty(),
+      globalVariables: GlobalVariables.empty(),
+      totalFees: Fr.ZERO,
+      totalManaUsed: Fr.ZERO,
+      spongeBlobHash: Fr.ZERO,
+      ...fields,
+    });
+  }
+
+  isEmpty(): boolean {
+    return (
+      this.lastArchive.isEmpty() &&
+      this.contentCommitment.isEmpty() &&
+      this.state.isEmpty() &&
+      this.globalVariables.isEmpty() &&
+      this.totalFees.isZero() &&
+      this.totalManaUsed.isZero() &&
+      this.spongeBlobHash.isZero()
+    );
+  }
+
+  /**
+   * Serializes this instance into a string.
+   * @returns Encoded string.
+   */
+  public toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return L2BlockHeader.fromBuffer(hexToBuffer(str));
+  }
+
+  toCheckpointHeader() {
+    return new CheckpointHeader(
+      this.lastArchive.root,
+      this.contentCommitment,
+      this.globalVariables.slotNumber,
+      this.globalVariables.timestamp,
+      this.globalVariables.coinbase,
+      this.globalVariables.feeRecipient,
+      this.globalVariables.gasFees,
+      this.totalManaUsed,
+    );
+  }
+
+  toBlockHeader() {
+    return new BlockHeader(
+      this.lastArchive,
+      this.state,
+      this.spongeBlobHash,
+      this.globalVariables,
+      this.totalFees,
+      this.totalManaUsed,
+    );
+  }
+
+  toInspect() {
+    return {
+      lastArchive: this.lastArchive.root.toString(),
+      contentCommitment: this.contentCommitment.toInspect(),
+      state: this.state.toInspect(),
+      globalVariables: this.globalVariables.toInspect(),
+      totalFees: this.totalFees.toBigInt(),
+      totalManaUsed: this.totalManaUsed.toBigInt(),
+      spongeBlobHash: this.spongeBlobHash.toString(),
+    };
+  }
+
+  [inspect.custom]() {
+    return `L2BlockHeader {
+  lastArchive: ${inspect(this.lastArchive)},
+  contentCommitment.blobsHash: ${inspect(this.contentCommitment.blobsHash)},
+  contentCommitment.inHash: ${inspect(this.contentCommitment.inHash)},
+  contentCommitment.outHash: ${inspect(this.contentCommitment.outHash)},
+  state.l1ToL2MessageTree: ${inspect(this.state.l1ToL2MessageTree)},
+  state.noteHashTree: ${inspect(this.state.partial.noteHashTree)},
+  state.nullifierTree: ${inspect(this.state.partial.nullifierTree)},
+  state.publicDataTree: ${inspect(this.state.partial.publicDataTree)},
+  globalVariables: ${inspect(this.globalVariables)},
+  totalFees: ${this.totalFees},
+  totalManaUsed: ${this.totalManaUsed},
+  spongeBlobHash: ${this.spongeBlobHash},
+}`;
+  }
+
+  public equals(other: this): boolean {
+    return (
+      this.contentCommitment.equals(other.contentCommitment) &&
+      this.state.equals(other.state) &&
+      this.globalVariables.equals(other.globalVariables) &&
+      this.totalFees.equals(other.totalFees) &&
+      this.totalManaUsed.equals(other.totalManaUsed) &&
+      this.lastArchive.equals(other.lastArchive) &&
+      this.spongeBlobHash.equals(other.spongeBlobHash)
+    );
+  }
+}

package/src/block/l2_block_source.ts

@@ -1,4 +1,5 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Fr } from '@aztec/foundation/fields';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 
 import { z } from 'zod';
@@ -66,6 +67,34 @@ export interface L2BlockSource {
   /** 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 the tx corresponding to the tx effect.
@@ -120,6 +149,9 @@ export interface L2BlockSource {
    */
   getL1Constants(): Promise<L1RollupConstants>;
 
+  /** Returns values for the genesis block */
+  getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }>;
+
   /** Latest synced L1 timestamp. */
   getL1Timestamp(): Promise<bigint>;
 

package/src/block/l2_block_stream/l2_tips_memory_store.ts

@@ -70,6 +70,6 @@ export class L2TipsMemoryStore implements L2BlockStreamEventHandler, L2BlockStre
   }
 
   protected computeBlockHash(block: L2Block) {
-    return block.header.hash().then(hash => hash.toString());
+    return block.hash().then(hash => hash.toString());
   }
 }

package/src/block/proposal/attestations_and_signers.ts

@@ -36,7 +36,7 @@ export class CommitteeAttestationsAndSigners implements Signable {
   }
 
   toString() {
-    return `CommitteeAttestationsAndSigners(${this.attestations.map(a => a.toString()).join(',')})`;
+    throw new Error('Not implemented');
   }
 
   getSigners() {

package/src/block/proposal/committee_attestation.ts

@@ -111,10 +111,6 @@ export class CommitteeAttestation {
     return this.address.equals(other.address) && this.signature.equals(other.signature);
   }
 
-  toString(): string {
-    return `CommitteeAttestation(${this.address.toString()}, ${this.signature.toString()})`;
-  }
-
   toViem(): ViemCommitteeAttestation {
     return {
       addr: this.address.toString(),

package/src/block/published_l2_block.ts

@@ -7,8 +7,6 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { BlockAttestation } from '../p2p/block_attestation.js';
-import { ConsensusPayload } from '../p2p/consensus_payload.js';
 import { L2Block } from './l2_block.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 
@@ -82,18 +80,3 @@ export class PublishedL2Block {
     );
   }
 }
-
-/**
- * Extracts block attestations from a published L2 block.
- * Returns undefined for attestations with empty signatures, preserving array indices.
- */
-export function getAttestationsFromPublishedL2Block(
-  block: Pick<PublishedL2Block, 'attestations' | 'block'>,
-): (BlockAttestation | undefined)[] {
-  const payload = ConsensusPayload.fromBlock(block.block);
-  return block.attestations.map(attestation =>
-    attestation.signature.isEmpty()
-      ? undefined
-      : new BlockAttestation(block.block.number, payload, attestation.signature),
-  );
-}

package/src/block/test/l2_tips_store_test_suite.ts

@@ -1,7 +1,6 @@
 import { times } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { type L2Block, type L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
-import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import { jestExpect as expect } from '@jest/expect';
 
@@ -16,7 +15,7 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
 
   const makeBlock = (number: number): PublishedL2Block =>
     PublishedL2Block.fromFields({
-      block: { number, header: { hash: () => Promise.resolve(new Fr(number)) } as BlockHeader } as L2Block,
+      block: { number, hash: () => Promise.resolve(new Fr(number)) } as L2Block,
       l1: { blockNumber: BigInt(number), blockHash: `0x${number}`, timestamp: BigInt(number) },
       attestations: [],
     });

package/src/checkpoint/checkpoint_body.ts

@@ -0,0 +1,10 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import { getBlockBlobFields } from '../block/body.js';
+import type { TxEffect } from '../tx/tx_effect.js';
+
+export function getCheckpointBlobFields(txEffectsInBlocks: TxEffect[][]) {
+  const blockBlobFields = txEffectsInBlocks.map(blockTxEffects => getBlockBlobFields(blockTxEffects)).flat();
+  const totalNumBlobFields = blockBlobFields.length + 1; // +1 for the prefix indicating the number of total blob fields in a checkpoint.
+  return [new Fr(totalNumBlobFields)].concat(blockBlobFields);
+}

package/src/checkpoint/index.ts

@@ -0,0 +1 @@
+export * from './checkpoint_body.js';

package/src/config/node-rpc-config.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
 import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
 
 export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
@@ -6,6 +7,12 @@ export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
     description: 'Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`.',
     ...numberConfigHelper(10e9),
   },
+  rpcSimulatePublicMaxDebugLogMemoryReads: {
+    env: 'RPC_SIMULATE_PUBLIC_MAX_DEBUG_LOG_MEMORY_READS',
+    description:
+      'Maximum memory reads for debug logs performed for public tx simulation in the node on `simulatePublicCalls`. ',
+    ...numberConfigHelper(DEFAULT_MAX_DEBUG_LOG_MEMORY_READS),
+  },
   rpcMaxBatchSize: {
     env: 'RPC_MAX_BATCH_SIZE',
     description: 'Maximum allowed batch size for JSON RPC batch requests.',
@@ -21,6 +28,8 @@ export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
 export type NodeRPCConfig = {
   /** Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`. */
   rpcSimulatePublicMaxGasLimit: number;
+  /** Maximum memory reads for debug logs performed for public tx simulation in the node on `simulatePublicCalls`. */
+  rpcSimulatePublicMaxDebugLogMemoryReads: number;
   /** Maximum allowed batch size for JSON RPC batch requests. */
   rpcMaxBatchSize: number;
   /** The maximum body size the RPC server will accept */

package/src/contract/contract_address.ts

@@ -11,7 +11,7 @@ import type { ContractInstance } from './interfaces/contract_instance.js';
 // TODO(@spalladino): Review all generator indices in this file
 
 /**
- * Returns the deployment address for a given contract instance as defined on the [Protocol Specs](../../../../docs/docs/protocol-specs/addresses-and-keys/specification.md).
+ * Returns the deployment address for a given contract instance.
  * ```
  * salted_initialization_hash = pedersen([salt, initialization_hash, deployer], GENERATOR__SALTED_INITIALIZATION_HASH)
  * partial_address = pedersen([contract_class_id, salted_initialization_hash], GENERATOR__CONTRACT_PARTIAL_ADDRESS_V1)