@aztec/stdlib 1.0.0-nightly.20250708 → 1.0.0-staging.0

package/src/kernel/private_to_rollup_kernel_circuit_public_inputs.ts

@@ -2,14 +2,14 @@ import { GeneratorIndex, PRIVATE_TO_ROLLUP_KERNEL_CIRCUIT_PUBLIC_INPUTS_LENGTH }
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import type { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
-import { BufferReader, bigintToUInt64BE, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { BufferReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { AztecAddress } from '../aztec-address/index.js';
 import { Gas } from '../gas/gas.js';
 import { TxConstantData } from '../tx/tx_constant_data.js';
-import type { UInt64 } from '../types/index.js';
+import { RollupValidationRequests } from './hints/rollup_validation_requests.js';
 import { PrivateToRollupAccumulatedData } from './private_to_rollup_accumulated_data.js';
 
 /**
@@ -22,6 +22,10 @@ export class PrivateToRollupKernelCircuitPublicInputs {
      * Data which is not modified by the circuits.
      */
     public constants: TxConstantData,
+    /**
+     * Validation requests accumulated from private and public execution to be completed by the rollup.
+     */
+    public rollupValidationRequests: RollupValidationRequests,
     /**
      * Data accumulated from both public and private circuits.
      */
@@ -34,10 +38,6 @@ export class PrivateToRollupKernelCircuitPublicInputs {
      * The address of the fee payer for the transaction.
      */
     public feePayer: AztecAddress,
-    /**
-     * The timestamp by which the transaction must be included in a block.
-     */
-    public includeByTimestamp: UInt64,
   ) {}
 
   getNonEmptyNullifiers() {
@@ -45,13 +45,7 @@ export class PrivateToRollupKernelCircuitPublicInputs {
   }
 
   toBuffer() {
-    return serializeToBuffer(
-      this.constants,
-      this.end,
-      this.gasUsed,
-      this.feePayer,
-      bigintToUInt64BE(this.includeByTimestamp),
-    );
+    return serializeToBuffer(this.constants, this.rollupValidationRequests, this.end, this.gasUsed, this.feePayer);
   }
 
   /**
@@ -63,20 +57,20 @@ export class PrivateToRollupKernelCircuitPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new PrivateToRollupKernelCircuitPublicInputs(
       reader.readObject(TxConstantData),
+      reader.readObject(RollupValidationRequests),
       reader.readObject(PrivateToRollupAccumulatedData),
       reader.readObject(Gas),
       reader.readObject(AztecAddress),
-      reader.readUInt64(),
     );
   }
 
   static empty() {
     return new PrivateToRollupKernelCircuitPublicInputs(
       TxConstantData.empty(),
+      RollupValidationRequests.empty(),
       PrivateToRollupAccumulatedData.empty(),
       Gas.empty(),
       AztecAddress.ZERO,
-      0n,
     );
   }
 
@@ -94,7 +88,7 @@ export class PrivateToRollupKernelCircuitPublicInputs {
   }
 
   static getFields(fields: FieldsOf<PrivateToRollupKernelCircuitPublicInputs>) {
-    return [fields.constants, fields.end, fields.gasUsed, fields.feePayer, fields.includeByTimestamp] as const;
+    return [fields.constants, fields.rollupValidationRequests, fields.end, fields.gasUsed, fields.feePayer] as const;
   }
 
   /** Creates an instance from a hex string. */

package/src/kernel/private_validation_requests.ts

@@ -3,14 +3,17 @@ import {
   MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
 } from '@aztec/constants';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { makeTuple } from '@aztec/foundation/array';
+import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
+import type { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
 
 import { ScopedKeyValidationRequestAndGenerator } from '../kernel/hints/scoped_key_validation_request_and_generator.js';
-import { ClaimedLengthArray, ClaimedLengthArrayFromBuffer } from './claimed_length_array.js';
 import { ScopedReadRequest } from './hints/read_request.js';
+import { RollupValidationRequests } from './hints/rollup_validation_requests.js';
 import { OptionalNumber } from './utils/optional_number.js';
 
 /**
@@ -18,18 +21,23 @@ import { OptionalNumber } from './utils/optional_number.js';
  */
 export class PrivateValidationRequests {
   constructor(
+    /**
+     * Validation requests that cannot be fulfilled in the current context (private or public), and must be instead be
+     * forwarded to the rollup for it to take care of them.
+     */
+    public forRollup: RollupValidationRequests,
     /**
      * All the read requests made in this transaction.
      */
-    public noteHashReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
+    public noteHashReadRequests: Tuple<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
     /**
      * All the nullifier read requests made in this transaction.
      */
-    public nullifierReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+    public nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
     /**
      * All the key validation requests made in this transaction.
      */
-    public scopedKeyValidationRequestsAndGenerators: ClaimedLengthArray<
+    public scopedKeyValidationRequestsAndGenerators: Tuple<
       ScopedKeyValidationRequestAndGenerator,
       typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX
     >,
@@ -43,15 +51,17 @@ export class PrivateValidationRequests {
 
   getSize() {
     return (
-      this.noteHashReadRequests.getSize() +
-      this.nullifierReadRequests.getSize() +
-      this.scopedKeyValidationRequestsAndGenerators.getSize() +
+      this.forRollup.getSize() +
+      arraySerializedSizeOfNonEmpty(this.noteHashReadRequests) +
+      arraySerializedSizeOfNonEmpty(this.nullifierReadRequests) +
+      arraySerializedSizeOfNonEmpty(this.scopedKeyValidationRequestsAndGenerators) +
       this.splitCounter.getSize()
     );
   }
 
   toBuffer() {
     return serializeToBuffer(
+      this.forRollup,
       this.noteHashReadRequests,
       this.nullifierReadRequests,
       this.scopedKeyValidationRequestsAndGenerators,
@@ -63,6 +73,17 @@ export class PrivateValidationRequests {
     return bufferToHex(this.toBuffer());
   }
 
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new PrivateValidationRequests(
+      reader.readObject(RollupValidationRequests),
+      reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest),
+      reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest),
+      reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator),
+      reader.readObject(OptionalNumber),
+    );
+  }
+
   /**
    * Deserializes from a buffer or reader, corresponding to a write in cpp.
    * @param buffer - Buffer or reader to read from.
@@ -71,11 +92,10 @@ export class PrivateValidationRequests {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PrivateValidationRequests(
-      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_TX)),
-      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_TX)),
-      reader.readObject(
-        ClaimedLengthArrayFromBuffer(ScopedKeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_TX),
-      ),
+      reader.readObject(RollupValidationRequests),
+      reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest),
+      reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest),
+      reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator),
       reader.readObject(OptionalNumber),
     );
   }
@@ -91,18 +111,29 @@ export class PrivateValidationRequests {
 
   static empty() {
     return new PrivateValidationRequests(
-      ClaimedLengthArray.empty(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_TX),
-      ClaimedLengthArray.empty(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_TX),
-      ClaimedLengthArray.empty(ScopedKeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_TX),
+      RollupValidationRequests.empty(),
+      makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ScopedReadRequest.empty),
+      makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ScopedReadRequest.empty),
+      makeTuple(MAX_KEY_VALIDATION_REQUESTS_PER_TX, ScopedKeyValidationRequestAndGenerator.empty),
       OptionalNumber.empty(),
     );
   }
 
   [inspect.custom]() {
     return `PrivateValidationRequests {
-  noteHashReadRequests: ${inspect(this.noteHashReadRequests)},
-  nullifierReadRequests: ${inspect(this.nullifierReadRequests)},
-  scopedKeyValidationRequestsAndGenerators: ${inspect(this.scopedKeyValidationRequestsAndGenerators)},
+  forRollup: ${inspect(this.forRollup)},
+  noteHashReadRequests: [${this.noteHashReadRequests
+    .filter(x => !x.isEmpty())
+    .map(h => inspect(h))
+    .join(', ')}],
+  nullifierReadRequests: [${this.nullifierReadRequests
+    .filter(x => !x.isEmpty())
+    .map(h => inspect(h))
+    .join(', ')}],
+  scopedKeyValidationRequestsAndGenerators: [${this.scopedKeyValidationRequestsAndGenerators
+    .filter(x => !x.isEmpty())
+    .map(h => inspect(h))
+    .join(', ')}],
   splitCounter: ${this.splitCounter.getSize()}
   `;
   }

package/src/kernel/utils/order_and_comparison.ts

@@ -17,6 +17,23 @@ export function countAccumulatedItems<T extends IsEmpty>(arr: T[]) {
   }, 0);
 }
 
+// Merges two arrays of length N into an array of length N.
+export function mergeAccumulatedData<T extends IsEmpty, N extends number>(
+  arr0: Tuple<T, N>,
+  arr1: Tuple<T, N>,
+  length: N = arr0.length as N, // Need this for ts to infer the return Tuple length.
+): Tuple<T, N> {
+  const numNonEmptyItems0 = countAccumulatedItems(arr0);
+  const numNonEmptyItems1 = countAccumulatedItems(arr1);
+  if (numNonEmptyItems0 + numNonEmptyItems1 > length) {
+    throw new Error('Combined non-empty items exceeded the maximum allowed.');
+  }
+
+  const arr = [...arr0] as Tuple<T, N>;
+  arr1.slice(0, numNonEmptyItems1).forEach((item, i) => (arr[i + numNonEmptyItems0] = item));
+  return arr;
+}
+
 // Sort items by a provided compare function. All empty items are padded to the right.
 function genericSort<T extends IsEmpty, N extends number>(
   arr: Tuple<T, N>,
@@ -44,3 +61,11 @@ export function sortByCounter<T extends Ordered & IsEmpty, N extends number>(
 ): Tuple<T, N> {
   return genericSort(arr, compareByCounter, ascending);
 }
+
+export function isEmptyArray<T extends IsEmpty>(arr: T[]): boolean {
+  return arr.every(item => item.isEmpty());
+}
+
+export function getNonEmptyItems<T extends IsEmpty>(arr: T[]): T[] {
+  return arr.filter(item => !item.isEmpty());
+}

package/src/messaging/l2_to_l1_message.ts

@@ -203,13 +203,4 @@ export class ScopedCountedL2ToL1Message {
   toBuffer(): Buffer {
     return serializeToBuffer(this.inner, this.contractAddress);
   }
-
-  static fromFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    return new ScopedCountedL2ToL1Message(reader.readObject(CountedL2ToL1Message), reader.readObject(AztecAddress));
-  }
-
-  toFields(): Fr[] {
-    return serializeToFields(this.inner, this.contractAddress);
-  }
 }

package/src/p2p/block_proposal.ts

@@ -5,8 +5,6 @@ import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import type { BlockInfo } from '../block/l2_block.js';
-import { TxHash } from '../tx/index.js';
 import { Tx } from '../tx/tx.js';
 import type { UInt32 } from '../types/index.js';
 import { ConsensusPayload } from './consensus_payload.js';
@@ -49,9 +47,6 @@ export class BlockProposal extends Gossipable {
     /** The signer of the BlockProposal over the header of the new block*/
     public readonly signature: Signature,
 
-    /** The sequence of transactions in the block */
-    public readonly txHashes: TxHash[],
-
     // Note(md): this is placed after the txs payload in order to be backwards compatible with previous versions
     /** The transactions in the block */
     public readonly txs?: Tx[],
@@ -71,19 +66,9 @@ export class BlockProposal extends Gossipable {
     return this.payload.header.slotNumber;
   }
 
-  toBlockInfo(): BlockInfo {
-    return {
-      blockNumber: this.blockNumber,
-      slotNumber: this.slotNumber.toNumber(),
-      archive: this.archive.toString(),
-      txCount: this.txHashes.length,
-    };
-  }
-
   static async createProposalFromSigner(
     blockNumber: UInt32,
     payload: ConsensusPayload,
-    txHashes: TxHash[],
     // Note(md): Provided separately to tx hashes such that this function can be optional
     txs: Tx[] | undefined,
     payloadSigner: (payload: Buffer32) => Promise<Signature>,
@@ -91,7 +76,7 @@ export class BlockProposal extends Gossipable {
     const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
     const sig = await payloadSigner(hashed);
 
-    return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
+    return new BlockProposal(blockNumber, payload, sig, txs);
   }
 
   /**Get Sender
@@ -112,7 +97,7 @@ export class BlockProposal extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    const buffer: any[] = [this.blockNumber, this.payload, this.signature, this.txHashes.length, this.txHashes];
+    const buffer: any[] = [this.blockNumber, this.payload, this.signature];
     if (this.txs) {
       buffer.push(this.txs.length);
       buffer.push(this.txs);
@@ -126,14 +111,13 @@ export class BlockProposal extends Gossipable {
     const blockNumber = reader.readNumber();
     const payload = reader.readObject(ConsensusPayload);
     const sig = reader.readObject(Signature);
-    const txHashes = reader.readArray(reader.readNumber(), TxHash);
 
     if (!reader.isEmpty()) {
       const txs = reader.readArray(reader.readNumber(), Tx);
-      return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
+      return new BlockProposal(blockNumber, payload, sig, txs);
     }
 
-    return new BlockProposal(blockNumber, payload, sig, txHashes);
+    return new BlockProposal(blockNumber, payload, sig);
   }
 
   getSize(): number {
@@ -141,9 +125,7 @@ export class BlockProposal extends Gossipable {
       4 /* blockNumber */ +
       this.payload.getSize() +
       this.signature.getSize() +
-      4 /* txHashes.length */ +
-      this.txHashes.length * TxHash.SIZE +
-      (this.txs ? 4 /* txs.length */ + this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
+      (this.txs ? this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
     );
   }
 }

package/src/p2p/consensus_payload.ts

@@ -8,7 +8,7 @@ import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
 import type { L2Block } from '../block/l2_block.js';
-import { ProposedBlockHeader, StateReference } from '../tx/index.js';
+import { ProposedBlockHeader, StateReference, TxHash } from '../tx/index.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
 
 export class ConsensusPayload implements Signable {
@@ -21,6 +21,8 @@ export class ConsensusPayload implements Signable {
     public readonly archive: Fr,
     /** The state reference after the block is added */
     public readonly stateReference: StateReference,
+    /** The sequence of transactions in the block */
+    public readonly txHashes: TxHash[],
   ) {}
 
   static get schema() {
@@ -29,12 +31,13 @@ export class ConsensusPayload implements Signable {
         header: ProposedBlockHeader.schema,
         archive: schemas.Fr,
         stateReference: StateReference.schema,
+        txHashes: z.array(TxHash.schema),
       })
-      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.stateReference));
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.stateReference, obj.txHashes));
   }
 
   static getFields(fields: FieldsOf<ConsensusPayload>) {
-    return [fields.header, fields.archive, fields.stateReference] as const;
+    return [fields.header, fields.archive, fields.stateReference, fields.txHashes] as const;
   }
 
   getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
@@ -44,23 +47,31 @@ export class ConsensusPayload implements Signable {
         'bytes32, ' + // archive
         '((bytes32,uint32),((bytes32,uint32),(bytes32,uint32),(bytes32,uint32))), ' + // stateReference
         '(int256), ' + // oracleInput
-        'bytes32' + // headerHash
+        'bytes32, ' + // headerHash
+        'bytes32[]' + // txHashes
         ')',
     );
     const archiveRoot = this.archive.toString();
     const stateReference = this.stateReference.toAbi();
 
     const headerHash = this.header.hash().toString();
+    const txArray = this.txHashes.map(tx => tx.toString());
     const encodedData = encodeAbiParameters(abi, [
       domainSeparator,
-      [archiveRoot, stateReference, [0n] /* @todo See #9963 */, headerHash],
+      [archiveRoot, stateReference, [0n] /* @todo See #9963 */, headerHash, txArray],
     ] as const);
 
     return hexToBuffer(encodedData);
   }
 
   toBuffer(): Buffer {
-    const buffer = serializeToBuffer([this.header, this.archive, this.stateReference]);
+    const buffer = serializeToBuffer([
+      this.header,
+      this.archive,
+      this.stateReference,
+      this.txHashes.length,
+      this.txHashes,
+    ]);
     this.size = buffer.length;
     return buffer;
   }
@@ -71,19 +82,25 @@ export class ConsensusPayload implements Signable {
       reader.readObject(ProposedBlockHeader),
       reader.readObject(Fr),
       reader.readObject(StateReference),
+      reader.readArray(reader.readNumber(), TxHash),
     );
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
-    return new ConsensusPayload(fields.header, fields.archive, fields.stateReference);
+    return new ConsensusPayload(fields.header, fields.archive, fields.stateReference, fields.txHashes);
   }
 
   static fromBlock(block: L2Block): ConsensusPayload {
-    return new ConsensusPayload(block.header.toPropose(), block.archive.root, block.header.state);
+    return new ConsensusPayload(
+      block.header.toPropose(),
+      block.archive.root,
+      block.header.state,
+      block.body.txEffects.map(tx => tx.txHash),
+    );
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty());
+    return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty(), []);
   }
 
   /**
@@ -100,6 +117,8 @@ export class ConsensusPayload implements Signable {
   }
 
   toString() {
-    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}`;
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}, txHashes: ${this.txHashes.join(
+      ', ',
+    )}`;
   }
 }

package/src/p2p/topic_type.ts

@@ -24,10 +24,8 @@ export function getTopicTypeForClientType(clientType: P2PClientType) {
     return Object.values(TopicType);
   } else if (clientType === P2PClientType.Prover) {
     return [TopicType.tx, TopicType.block_proposal];
-  } else {
-    const _: never = clientType;
-    return [TopicType.tx];
   }
+  return [TopicType.tx];
 }
 
 /**

package/src/proofs/proving_request_type.ts

@@ -5,7 +5,6 @@ export enum ProvingRequestType {
   PUBLIC_BASE_ROLLUP,
   MERGE_ROLLUP,
   EMPTY_BLOCK_ROOT_ROLLUP,
-  PADDING_BLOCK_ROOT_ROLLUP,
   BLOCK_ROOT_ROLLUP,
   SINGLE_TX_BLOCK_ROOT_ROLLUP,
   BLOCK_MERGE_ROLLUP,

package/src/rollup/base_or_merge_rollup_public_inputs.ts

@@ -5,6 +5,7 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { PartialStateReference } from '../tx/partial_state_reference.js';
+import { RollupTypes } from '../types/shared.js';
 import { BlockConstantData } from './block_constant_data.js';
 
 /**
@@ -12,6 +13,10 @@ import { BlockConstantData } from './block_constant_data.js';
  */
 export class BaseOrMergeRollupPublicInputs {
   constructor(
+    /**
+     * Specifies from which type of rollup circuit these inputs are from.
+     */
+    public rollupType: RollupTypes,
     /**
      * Number of txs in this rollup.
      */
@@ -54,6 +59,7 @@ export class BaseOrMergeRollupPublicInputs {
   /** Returns an empty instance. */
   static empty() {
     return new BaseOrMergeRollupPublicInputs(
+      RollupTypes.Base,
       0,
       BlockConstantData.empty(),
       PartialStateReference.empty(),
@@ -75,6 +81,7 @@ export class BaseOrMergeRollupPublicInputs {
   static fromBuffer(buffer: Buffer | BufferReader): BaseOrMergeRollupPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new BaseOrMergeRollupPublicInputs(
+      reader.readNumber(),
       reader.readNumber(),
       reader.readObject(BlockConstantData),
       reader.readObject(PartialStateReference),
@@ -93,6 +100,7 @@ export class BaseOrMergeRollupPublicInputs {
    */
   toBuffer() {
     return serializeToBuffer(
+      this.rollupType,
       this.numTxs,
       this.constants,
 

package/src/rollup/empty_block_root_rollup_inputs.ts

@@ -13,6 +13,7 @@ export class EmptyBlockRootRollupInputs {
   constructor(
     public readonly data: BlockRootRollupData,
     public readonly constants: BlockConstantData,
+    public readonly isPadding: boolean,
   ) {}
 
   /**
@@ -46,7 +47,7 @@ export class EmptyBlockRootRollupInputs {
    * @returns An array of fields.
    */
   static getFields(fields: FieldsOf<EmptyBlockRootRollupInputs>) {
-    return [fields.data, fields.constants] as const;
+    return [fields.data, fields.constants, fields.isPadding] as const;
   }
 
   /**
@@ -56,7 +57,11 @@ export class EmptyBlockRootRollupInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader): EmptyBlockRootRollupInputs {
     const reader = BufferReader.asReader(buffer);
-    return new EmptyBlockRootRollupInputs(reader.readObject(BlockRootRollupData), reader.readObject(BlockConstantData));
+    return new EmptyBlockRootRollupInputs(
+      reader.readObject(BlockRootRollupData),
+      reader.readObject(BlockConstantData),
+      reader.readBoolean(),
+    );
   }
 
   /**

package/src/rollup/index.ts

@@ -8,7 +8,6 @@ export * from './empty_block_root_rollup_inputs.js';
 export * from './epoch_constant_data.js';
 export * from './block_root_rollup.js';
 export * from './merge_rollup.js';
-export * from './padding_block_root_rollup_inputs.js';
 export * from './previous_rollup_block_data.js';
 export * from './previous_rollup_data.js';
 export * from './private_base_rollup_inputs.js';

package/src/shared_mutable/scheduled_delay_change.ts

@@ -1,17 +1,17 @@
-import type { UInt64 } from '../types/shared.js';
+import type { UInt32 } from '../types/shared.js';
 
 export class ScheduledDelayChange {
   constructor(
-    public pre: UInt64 | undefined,
-    public post: UInt64 | undefined,
-    public timestampOfChange: UInt64,
+    public pre: UInt32 | undefined,
+    public post: UInt32 | undefined,
+    public blockOfChange: UInt32,
   ) {}
 
   static empty() {
-    return new this(undefined, undefined, 0n);
+    return new this(undefined, undefined, 0);
   }
 
   isEmpty(): boolean {
-    return this.pre === undefined && this.post === undefined && this.timestampOfChange === 0n;
+    return this.pre === undefined && this.post === undefined && this.blockOfChange === 0;
   }
 }

package/src/shared_mutable/scheduled_value_change.ts

@@ -1,12 +1,10 @@
 import { Fr } from '@aztec/foundation/fields';
 
-import type { UInt64 } from '../types/shared.js';
-
 export class ScheduledValueChange {
   constructor(
     public previous: Fr[],
     public post: Fr[],
-    public timestampOfChange: UInt64,
+    public blockOfChange: number,
   ) {
     if (this.previous.length !== this.post.length) {
       throw new Error('Previous and post must have the same length');
@@ -14,15 +12,15 @@ export class ScheduledValueChange {
   }
 
   static empty(valueSize: number) {
-    return new this(Array(valueSize).fill(new Fr(0)), Array(valueSize).fill(new Fr(0)), 0n);
+    return new this(Array(valueSize).fill(new Fr(0)), Array(valueSize).fill(new Fr(0)), 0);
   }
 
   isEmpty(): boolean {
-    return this.previous.every(v => v.isZero()) && this.post.every(v => v.isZero()) && this.timestampOfChange === 0n;
+    return this.previous.every(v => v.isZero()) && this.post.every(v => v.isZero()) && this.blockOfChange === 0;
   }
 
-  getCurrentAt(timestamp: UInt64) {
-    if (timestamp < this.timestampOfChange) {
+  getCurrentAt(blockNumber: number) {
+    if (blockNumber < this.blockOfChange) {
       return this.previous;
     } else {
       return this.post;

package/src/shared_mutable/shared_mutable_values.ts

@@ -22,20 +22,20 @@ export class SharedMutableValues {
     // Extract fields for ScheduledValueChange
     const svcPre = reader.readFieldArray(UPDATES_VALUE_SIZE);
     const svcPost = reader.readFieldArray(UPDATES_VALUE_SIZE);
-    const svcTimestampOfChange = firstField & 0xffffffffn;
-    const svc = new ScheduledValueChange(svcPre, svcPost, svcTimestampOfChange);
+    const svcBlockOfChange = firstField & 0xffffffffn;
+    const svc = new ScheduledValueChange(svcPre, svcPost, Number(svcBlockOfChange));
 
     // Extract fields for ScheduledDelayChange from first field
-    const sdcTimestampOfChange = (firstField >> 32n) & 0xffffffffn;
+    const sdcBlockOfChange = (firstField >> 32n) & 0xffffffffn;
     const sdcIsPostSome = (firstField >> 64n) & 1n;
     const sdcPost = (firstField >> 72n) & 0xffffffffn;
     const sdcIsPreSome = (firstField >> 104n) & 1n;
     const sdcPre = (firstField >> 112n) & 0xffffffffn;
 
     const sdc = new ScheduledDelayChange(
-      sdcIsPreSome ? sdcPre : undefined,
-      sdcIsPostSome ? sdcPost : undefined,
-      sdcTimestampOfChange,
+      sdcIsPreSome ? Number(sdcPre) : undefined,
+      sdcIsPostSome ? Number(sdcPost) : undefined,
+      Number(sdcBlockOfChange),
     );
 
     return new this(svc, sdc);
@@ -43,9 +43,9 @@ export class SharedMutableValues {
 
   toFields(): Fr[] {
     // Pack format matches Noir implementation:
-    // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]
-    let firstField = this.svc.timestampOfChange;
-    firstField |= this.sdc.timestampOfChange << 32n;
+    // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.block_of_change: u32 | svc.block_of_change: u32 ]
+    let firstField = BigInt(this.svc.blockOfChange);
+    firstField |= BigInt(this.sdc.blockOfChange) << 32n;
     firstField |= (this.sdc.post === undefined ? 0n : 1n) << 64n;
     firstField |= BigInt(this.sdc.post || 0) << 72n;
     firstField |= (this.sdc.pre === undefined ? 0n : 1n) << 104n;