@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.d3ec352c

package/src/avm/avm_accumulated_data.ts

@@ -149,6 +149,35 @@ export class AvmAccumulatedData {
     );
   }
 
+  /**
+   * Creates an AvmAccumulatedData instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmAccumulatedData fields
+   * @returns An AvmAccumulatedData instance
+   */
+  static fromPlainObject(obj: any): AvmAccumulatedData {
+    return new AvmAccumulatedData(
+      assertLength(
+        obj.noteHashes.map((h: any) => Fr.fromPlainObject(h)),
+        MAX_NOTE_HASHES_PER_TX,
+      ),
+      assertLength(
+        obj.nullifiers.map((n: any) => Fr.fromPlainObject(n)),
+        MAX_NULLIFIERS_PER_TX,
+      ),
+      assertLength(
+        obj.l2ToL1Msgs.map((m: any) => ScopedL2ToL1Message.fromPlainObject(m)),
+        MAX_L2_TO_L1_MSGS_PER_TX,
+      ),
+      FlatPublicLogs.fromPlainObject(obj.publicLogs),
+      assertLength(
+        obj.publicDataWrites.map((w: any) => PublicDataWrite.fromPlainObject(w)),
+        MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+      ),
+    );
+  }
+
   isEmpty(): boolean {
     return (
       this.noteHashes.every(x => x.isZero()) &&
@@ -265,6 +294,17 @@ export class AvmAccumulatedDataArrayLengths {
     return new AvmAccumulatedDataArrayLengths(0, 0, 0, 0);
   }
 
+  /**
+   * Creates an AvmAccumulatedDataArrayLengths instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmAccumulatedDataArrayLengths fields
+   * @returns An AvmAccumulatedDataArrayLengths instance
+   */
+  static fromPlainObject(obj: any): AvmAccumulatedDataArrayLengths {
+    return new AvmAccumulatedDataArrayLengths(obj.noteHashes, obj.nullifiers, obj.l2ToL1Msgs, obj.publicDataWrites);
+  }
+
   [inspect.custom]() {
     return `AvmAccumulatedDataArrayLengths {
   noteHashes: ${this.noteHashes},

package/src/avm/avm_circuit_public_inputs.ts

@@ -276,6 +276,46 @@ export class AvmCircuitPublicInputs {
     );
   }
 
+  /**
+   * Creates an AvmCircuitPublicInputs instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmCircuitPublicInputs fields
+   * @returns An AvmCircuitPublicInputs instance
+   */
+  static fromPlainObject(obj: any): AvmCircuitPublicInputs {
+    return new AvmCircuitPublicInputs(
+      GlobalVariables.fromPlainObject(obj.globalVariables),
+      ProtocolContracts.fromPlainObject(obj.protocolContracts),
+      TreeSnapshots.fromPlainObject(obj.startTreeSnapshots),
+      Gas.fromPlainObject(obj.startGasUsed),
+      GasSettings.fromPlainObject(obj.gasSettings),
+      GasFees.fromPlainObject(obj.effectiveGasFees),
+      AztecAddress.fromPlainObject(obj.feePayer),
+      Fr.fromPlainObject(obj.proverId),
+      PublicCallRequestArrayLengths.fromPlainObject(obj.publicCallRequestArrayLengths),
+      assertLength(
+        obj.publicSetupCallRequests.map((r: any) => PublicCallRequest.fromPlainObject(r)),
+        MAX_ENQUEUED_CALLS_PER_TX,
+      ),
+      assertLength(
+        obj.publicAppLogicCallRequests.map((r: any) => PublicCallRequest.fromPlainObject(r)),
+        MAX_ENQUEUED_CALLS_PER_TX,
+      ),
+      PublicCallRequest.fromPlainObject(obj.publicTeardownCallRequest),
+      PrivateToAvmAccumulatedDataArrayLengths.fromPlainObject(obj.previousNonRevertibleAccumulatedDataArrayLengths),
+      PrivateToAvmAccumulatedDataArrayLengths.fromPlainObject(obj.previousRevertibleAccumulatedDataArrayLengths),
+      PrivateToAvmAccumulatedData.fromPlainObject(obj.previousNonRevertibleAccumulatedData),
+      PrivateToAvmAccumulatedData.fromPlainObject(obj.previousRevertibleAccumulatedData),
+      TreeSnapshots.fromPlainObject(obj.endTreeSnapshots),
+      Gas.fromPlainObject(obj.endGasUsed),
+      AvmAccumulatedDataArrayLengths.fromPlainObject(obj.accumulatedDataArrayLengths),
+      AvmAccumulatedData.fromPlainObject(obj.accumulatedData),
+      Fr.fromPlainObject(obj.transactionFee),
+      obj.reverted,
+    );
+  }
+
   public serializeWithMessagePack(): Buffer {
     return serializeWithMessagePack(this);
   }

package/src/avm/message_pack.ts

@@ -18,7 +18,10 @@ export function serializeWithMessagePack(obj: any): Buffer {
   return encoder.encode(obj);
 }
 
-export function deserializeFromMessagePack<T>(buffer: Buffer): T {
+// This deserializes into a JS object. If you want a specific
+// class, you need to use zod to parse it into the specific class.
+// You can use T.schema.parse() for that.
+export function deserializeFromMessagePack(buffer: Buffer): any {
   setUpMessagePackExtensions();
   const decoder = new Decoder({
     useRecords: false,

package/src/avm/public_data_write.ts

@@ -61,7 +61,7 @@ export class PublicDataWrite {
     return new PublicDataWrite(reader.readField(), reader.readField());
   }
 
-  toBlobFields(): Fr[] {
+  toBlobFields(): [Fr, Fr] {
     return [this.leafSlot, this.value];
   }
 
@@ -86,6 +86,17 @@ export class PublicDataWrite {
     return new PublicDataWrite(Fr.ZERO, Fr.ZERO);
   }
 
+  /**
+   * Creates a PublicDataWrite instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicDataWrite fields
+   * @returns A PublicDataWrite instance
+   */
+  static fromPlainObject(obj: any): PublicDataWrite {
+    return new PublicDataWrite(Fr.fromPlainObject(obj.leafSlot), Fr.fromPlainObject(obj.value));
+  }
+
   static random() {
     return new PublicDataWrite(Fr.random(), Fr.random());
   }

package/src/avm/revert_code.ts

@@ -1,4 +1,5 @@
 import { Fr } from '@aztec/foundation/fields';
+import type { ZodFor } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
@@ -64,10 +65,28 @@ export class RevertCode {
     return this.code;
   }
 
-  static get schema() {
+  static get schema(): ZodFor<RevertCode> {
     return z.nativeEnum(RevertCodeEnum).transform(value => new RevertCode(value));
   }
 
+  /**
+   * Creates a RevertCode from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object, number, or RevertCode instance
+   * @returns A RevertCode instance
+   */
+  static fromPlainObject(obj: any): RevertCode {
+    if (obj instanceof RevertCode) {
+      return obj;
+    }
+    const code = typeof obj === 'number' ? obj : (obj.code ?? obj);
+    if (!isRevertCodeEnum(code)) {
+      throw new Error(`Invalid RevertCode: ${code}`);
+    }
+    return new RevertCode(code);
+  }
+
   /**
    * Having different serialization methods allows for
    * decoupling the serialization for producing the content commitment hash
@@ -96,11 +115,15 @@ export class RevertCode {
     return this.toBuffer().length;
   }
 
-  public static fromField(fr: Fr): RevertCode {
-    if (!isRevertCodeEnum(fr.toNumber())) {
-      throw new Error(`Invalid RevertCode: ${fr.toNumber()}`);
+  public static fromNumber(code: number): RevertCode {
+    if (!isRevertCodeEnum(code)) {
+      throw new Error(`Invalid RevertCode: ${code}`);
     }
-    return new RevertCode(fr.toNumber());
+    return new RevertCode(code);
+  }
+
+  public static fromField(field: Fr): RevertCode {
+    return RevertCode.fromNumber(field.toNumber());
   }
 
   public static fromFields(fields: Fr[] | FieldReader): RevertCode {
@@ -111,10 +134,7 @@ export class RevertCode {
   public static fromBuffer(buffer: Buffer | BufferReader): RevertCode {
     const reader = BufferReader.asReader(buffer);
     const code = reader.readBytes(RevertCode.PACKED_SIZE_IN_BYTES).readUInt8(0);
-    if (!isRevertCodeEnum(code)) {
-      throw new Error(`Invalid RevertCode: ${code}`);
-    }
-    return new RevertCode(code);
+    return RevertCode.fromNumber(code);
   }
 
   private static readonly NUM_OPTIONS = 4;

package/src/aztec-address/index.ts

@@ -1,10 +1,11 @@
 /* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
 import { Fr, Point, fromBuffer } from '@aztec/foundation/fields';
-import { type ZodFor, hexSchemaFor } from '@aztec/foundation/schemas';
+import { type ZodFor, bufferSchemaFor, hexSchemaFor } from '@aztec/foundation/schemas';
 import { type BufferReader, FieldReader, TypeRegistry } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
+import { z } from 'zod';
 
 /** Branding to ensure fields are not interchangeable types. */
 export interface AztecAddress {
@@ -71,6 +72,24 @@ export class AztecAddress {
     return new AztecAddress(hexToBuffer(buf));
   }
 
+  /**
+   * Creates an AztecAddress from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * Handles buffers, strings, or existing instances.
+   * @param obj - Plain object, buffer, string, or AztecAddress instance
+   * @returns An AztecAddress instance
+   */
+  static fromPlainObject(obj: any): AztecAddress {
+    if (obj instanceof AztecAddress) {
+      return obj;
+    }
+    if (obj instanceof Buffer || Buffer.isBuffer(obj)) {
+      return new AztecAddress(obj);
+    }
+    return AztecAddress.fromString(obj);
+  }
+
   /**
    * @returns a random valid address (i.e. one that can be encrypted to).
    */
@@ -137,7 +156,12 @@ export class AztecAddress {
   }
 
   static get schema(): ZodFor<AztecAddress> {
-    return hexSchemaFor(AztecAddress, AztecAddress.isAddress);
+    return z.union([
+      // Serialization from hex string.
+      hexSchemaFor(AztecAddress, AztecAddress.isAddress),
+      // Serialization from buffer.
+      bufferSchemaFor(AztecAddress, buf => buf.length === 32),
+    ]);
   }
 }
 

package/src/block/attestation_info.ts

@@ -37,9 +37,16 @@ export function getAttestationInfoFromPublishedL2Block(block: {
   block: L2Block;
 }): AttestationInfo[] {
   const payload = ConsensusPayload.fromBlock(block.block);
+  return getAttestationInfoFromPayload(payload, block.attestations);
+}
+
+export function getAttestationInfoFromPayload(
+  payload: ConsensusPayload,
+  attestations: CommitteeAttestation[],
+): AttestationInfo[] {
   const hashedPayload = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
 
-  return block.attestations.map(attestation => {
+  return attestations.map(attestation => {
     // If signature is empty, check if we have an address directly
     if (attestation.signature.isEmpty()) {
       if (attestation.address.isZero()) {

package/src/block/block_parameter.ts

@@ -0,0 +1,8 @@
+import { BlockNumberSchema } from '@aztec/foundation/branded-types';
+
+import { z } from 'zod';
+
+export const BlockParameterSchema = z.union([BlockNumberSchema, z.literal('latest')]);
+
+/** Block parameter - either a specific BlockNumber or 'latest' */
+export type BlockParameter = z.infer<typeof BlockParameterSchema>;

package/src/block/body.ts

@@ -1,7 +1,6 @@
-import { createBlockEndMarker, getNumTxsFromBlockEndMarker, isBlockEndMarker } from '@aztec/blob-lib/encoding';
+import type { TxBlobData } from '@aztec/blob-lib/encoding';
 import { timesParallel } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -9,14 +8,6 @@ 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[]) {}
 
@@ -55,32 +46,16 @@ export class Body {
   /**
    * Returns a flat packed array of fields of all tx effects - used for blobs.
    */
-  toBlobFields() {
-    return getBlockBlobFields(this.txEffects);
+  toTxBlobData(): TxBlobData[] {
+    return this.txEffects.map(txEffect => txEffect.toTxBlobData());
   }
 
   /**
    * Decodes a block from blob fields.
    */
-  static fromBlobFields(fields: Fr[]) {
-    const txEffects: TxEffect[] = [];
-    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);
+  static fromTxBlobData(txBlobData: TxBlobData[]): Body {
+    const txEffects = txBlobData.map(data => TxEffect.fromTxBlobData(data));
+    return new Body(txEffects);
   }
 
   [inspect.custom]() {
@@ -89,14 +64,16 @@ export class Body {
 }`;
   }
 
-  static async random(
+  static async random({
     txsPerBlock = 4,
-    numPublicCallsPerTx = 3,
-    numPublicLogsPerCall = 1,
-    maxEffects: number | undefined = undefined,
-  ) {
-    const txEffects = await timesParallel(txsPerBlock, () =>
-      TxEffect.random(numPublicCallsPerTx, numPublicLogsPerCall, maxEffects),
+    makeTxOptions = () => ({}),
+    ...txEffectOptions
+  }: {
+    txsPerBlock?: number;
+    makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof TxEffect.random>[0]>;
+  } & Partial<Parameters<typeof TxEffect.random>[0]> = {}) {
+    const txEffects = await timesParallel(txsPerBlock, txIndex =>
+      TxEffect.random({ ...makeTxOptions(txIndex), ...txEffectOptions }),
     );
 
     return new Body(txEffects);

package/src/block/in_block.ts

@@ -1,25 +1,29 @@
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+
 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;
+export type InBlock = {
+  l2BlockNumber: BlockNumber;
   l2BlockHash: L2BlockHash;
-  data: T;
 };
 
-export function randomInBlock<T>(data: T): InBlock<T> {
+// Note: If you expand this type with indexInBlock, then delete `IndexedTxEffect` and use this type instead.
+export type DataInBlock<T> = {
+  data: T;
+} & InBlock;
+
+export function randomInBlock<T>(data: T): DataInBlock<T> {
   return {
     data,
-    l2BlockNumber: Math.floor(Math.random() * 1000),
+    l2BlockNumber: BlockNumber(Math.floor(Math.random() * 1000)),
     l2BlockHash: L2BlockHash.random(),
   };
 }
 
-export async function wrapInBlock<T>(data: T, block: L2Block): Promise<InBlock<T>> {
+export async function wrapInBlock<T>(data: T, block: L2Block): Promise<DataInBlock<T>> {
   return {
     data,
     l2BlockNumber: block.number,
@@ -30,7 +34,7 @@ export async function wrapInBlock<T>(data: T, block: L2Block): Promise<InBlock<T
 export function inBlockSchemaFor<T extends ZodTypeAny>(schema: T) {
   return z.object({
     data: schema,
-    l2BlockNumber: schemas.Integer,
+    l2BlockNumber: BlockNumberSchema,
     l2BlockHash: L2BlockHash.schema,
   });
 }

package/src/block/index.ts

@@ -1,9 +1,10 @@
 export * from './l2_block.js';
+export * from './l2_block_new.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 './block_parameter.js';
 export * from './l2_block_source.js';
 export * from './block_hash.js';
 export * from './published_l2_block.js';

package/src/block/l2_block.ts

@@ -1,19 +1,24 @@
+import { type BlockBlobData, encodeBlockBlobData, encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 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 { Checkpoint } from '../checkpoint/checkpoint.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import { Body } from './body.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';
+import { L2BlockNew } from './l2_block_new.js';
 
 /**
  * The data that makes up the rollup proof, with encoder decoder functions.
+ *
+ * @deprecated Use `L2BlockNew` instead.
  */
 export class L2Block {
   constructor(
@@ -84,7 +89,7 @@ export class L2Block {
    * @returns The L2 block.
    */
   static async random(
-    l2BlockNum: number,
+    l2BlockNum: BlockNumber,
     txsPerBlock = 4,
     numPublicCallsPerTx = 3,
     numPublicLogsPerCall = 1,
@@ -92,7 +97,7 @@ export class L2Block {
     slotNumber: number | undefined = undefined,
     maxEffects: number | undefined = undefined,
   ): Promise<L2Block> {
-    const body = await Body.random(txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall, maxEffects);
+    const body = await Body.random({ txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall, maxEffects });
 
     return new L2Block(
       makeAppendOnlyTreeSnapshot(l2BlockNum + 1),
@@ -109,11 +114,11 @@ export class L2Block {
     return new L2Block(AppendOnlyTreeSnapshot.empty(), L2BlockHeader.empty(), Body.empty());
   }
 
-  get number(): number {
+  get number(): BlockNumber {
     return this.header.getBlockNumber();
   }
 
-  get slot(): bigint {
+  get slot(): SlotNumber {
     return this.header.getSlot();
   }
 
@@ -146,13 +151,71 @@ export class L2Block {
     return this.header.toBlockHeader();
   }
 
+  public toL2Block() {
+    return new L2BlockNew(this.archive, this.getBlockHeader(), this.body);
+  }
+
+  public toCheckpoint() {
+    return new Checkpoint(
+      this.archive,
+      this.getCheckpointHeader(),
+      [this.toL2Block()],
+      CheckpointNumber.fromBlockNumber(this.number),
+    );
+  }
+
+  static fromCheckpoint(checkpoint: Checkpoint) {
+    const checkpointHeader = checkpoint.header;
+    const block = checkpoint.blocks.at(-1)!;
+    const header = new L2BlockHeader(
+      new AppendOnlyTreeSnapshot(checkpointHeader.lastArchiveRoot, block.number),
+      checkpointHeader.contentCommitment,
+      block.header.state,
+      block.header.globalVariables,
+      block.header.totalFees,
+      checkpointHeader.totalManaUsed,
+      block.header.spongeBlobHash,
+      checkpointHeader.blockHeadersHash,
+    );
+    return new L2Block(checkpoint.archive, header, block.body);
+  }
+
   /**
    * @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]);
+    const blockBlobData = this.toBlockBlobData(true);
+    return encodeCheckpointBlobDataFromBlocks([blockBlobData]);
+  }
+
+  public toBlobFields(isFirstBlock: boolean): Fr[] {
+    const blockBlobData = this.toBlockBlobData(isFirstBlock);
+    return encodeBlockBlobData(blockBlobData);
+  }
+
+  public toBlockBlobData(isFirstBlock: boolean): BlockBlobData {
+    return {
+      blockEndMarker: {
+        numTxs: this.body.txEffects.length,
+        timestamp: this.header.globalVariables.timestamp,
+        blockNumber: this.number,
+      },
+      blockEndStateField: {
+        l1ToL2MessageNextAvailableLeafIndex: this.header.state.l1ToL2MessageTree.nextAvailableLeafIndex,
+        noteHashNextAvailableLeafIndex: this.header.state.partial.noteHashTree.nextAvailableLeafIndex,
+        nullifierNextAvailableLeafIndex: this.header.state.partial.nullifierTree.nextAvailableLeafIndex,
+        publicDataNextAvailableLeafIndex: this.header.state.partial.publicDataTree.nextAvailableLeafIndex,
+        totalManaUsed: this.header.totalManaUsed.toBigInt(),
+      },
+      lastArchiveRoot: this.header.lastArchive.root,
+      noteHashRoot: this.header.state.partial.noteHashTree.root,
+      nullifierRoot: this.header.state.partial.nullifierTree.root,
+      publicDataRoot: this.header.state.partial.publicDataTree.root,
+      l1ToL2MessageRoot: isFirstBlock ? this.header.state.l1ToL2MessageTree.root : undefined,
+      txs: this.body.toTxBlobData(),
+    };
   }
 
   /**
@@ -188,7 +251,7 @@ export class L2Block {
       archive: this.archive.root,
       lastArchive: this.header.lastArchive.root,
       blockNumber: this.number,
-      slotNumber: Number(this.header.getSlot()),
+      slotNumber: this.header.getSlot(),
       txCount: this.body.txEffects.length,
       timestamp: this.header.globalVariables.timestamp,
     };

package/src/block/l2_block_code_to_purge.ts

@@ -1,3 +1,4 @@
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { compact } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -24,9 +25,10 @@ export function makeL2BlockHeader(
     overrides?.contentCommitment ?? makeContentCommitment(seed + 0x200, inHash),
     overrides?.state ?? makeStateReference(seed + 0x600),
     makeGlobalVariables((seed += 0x700), {
-      ...(blockNumber ? { blockNumber } : {}),
-      ...(slotNumber ? { slotNumber: new Fr(slotNumber) } : {}),
+      ...(blockNumber ? { blockNumber: BlockNumber(blockNumber) } : {}),
+      ...(slotNumber ? { slotNumber: SlotNumber(slotNumber) } : {}),
     }),
+    new Fr(seed + 0x300),
     new Fr(seed + 0x800),
     new Fr(seed + 0x900),
     new Fr(seed + 0xa00),
@@ -75,8 +77,8 @@ function makeGlobalVariables(seed = 1, overrides: Partial<FieldsOf<GlobalVariabl
   return GlobalVariables.from({
     chainId: new Fr(seed),
     version: new Fr(seed + 1),
-    blockNumber: seed + 2,
-    slotNumber: new Fr(seed + 3),
+    blockNumber: BlockNumber(seed + 2),
+    slotNumber: SlotNumber(seed + 3),
     timestamp: BigInt(seed + 4),
     coinbase: EthAddress.fromField(new Fr(seed + 5)),
     feeRecipient: AztecAddress.fromField(new Fr(seed + 6)),