@aztec/sequencer-client 0.28.1 → 0.29.0

package/src/block_builder/solo_block_builder.ts

@@ -89,32 +89,28 @@ export class SoloBlockBuilder implements BlockBuilder {
    * Builds an L2 block with the given number containing the given txs, updating state trees.
    * @param globalVariables - Global variables to be used in the block.
    * @param txs - Processed transactions to include in the block.
-   * @param newModelL1ToL2Messages - L1 to L2 messages emitted by the new inbox.
-   * @param newL1ToL2Messages - L1 to L2 messages to be part of the block.
+   * @param l1ToL2Messages - L1 to L2 messages to be part of the block.
    * @param timestamp - Timestamp of the block.
    * @returns The new L2 block and a correctness proof as returned by the root rollup circuit.
    */
   public async buildL2Block(
     globalVariables: GlobalVariables,
     txs: ProcessedTx[],
-    newModelL1ToL2Messages: Fr[], // TODO(#4492): Rename this when purging the old inbox
-    newL1ToL2Messages: Fr[],
+    l1ToL2Messages: Fr[],
   ): Promise<[L2Block, Proof]> {
     // Check txs are good for processing by checking if all the tree snapshots in header are non-empty
     this.validateTxs(txs);
 
+    // We pad the messages as the circuits expect that.
+    const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+
     // We fill the tx batch with empty txs, we process only one tx at a time for now
-    const [circuitsOutput, proof] = await this.runCircuits(
-      globalVariables,
-      txs,
-      newModelL1ToL2Messages,
-      newL1ToL2Messages,
-    );
+    const [circuitsOutput, proof] = await this.runCircuits(globalVariables, txs, l1ToL2MessagesPadded);
 
     // Collect all new nullifiers, commitments, and contracts from all txs in this block
     const txEffects: TxEffect[] = txs.map(tx => toTxEffect(tx));
 
-    const blockBody = new Body(padArrayEnd(newL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP), txEffects);
+    const blockBody = new Body(l1ToL2MessagesPadded, txEffects);
 
     const l2Block = L2Block.fromFields({
       archive: circuitsOutput.archive,
@@ -160,8 +156,7 @@ export class SoloBlockBuilder implements BlockBuilder {
   protected async runCircuits(
     globalVariables: GlobalVariables,
     txs: ProcessedTx[],
-    newModelL1ToL2Messages: Fr[], // TODO(#4492): Rename this when purging the old inbox
-    newL1ToL2Messages: Fr[], // TODO(#4492): Nuke this when purging the old inbox
+    l1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
   ): Promise<[RootRollupPublicInputs, Proof]> {
     // Check that the length of the array of txs is a power of two
     // See https://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2
@@ -170,16 +165,13 @@ export class SoloBlockBuilder implements BlockBuilder {
     }
 
     // BASE PARITY CIRCUIT (run in parallel)
+    // Note: In the future we will want to cache the results of empty base and root parity circuits so that we don't
+    // have to run them. (It will most likely be quite common that some base parity circuits will be "empty")
     let baseParityInputs: BaseParityInputs[] = [];
     let elapsedBaseParityOutputsPromise: Promise<[number, RootParityInput[]]>;
     {
-      const newModelL1ToL2MessagesTuple = padArrayEnd(
-        newModelL1ToL2Messages,
-        Fr.ZERO,
-        NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-      );
       baseParityInputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }, (_, i) =>
-        BaseParityInputs.fromSlice(newModelL1ToL2MessagesTuple, i),
+        BaseParityInputs.fromSlice(l1ToL2Messages, i),
       );
 
       const baseParityOutputs: Promise<RootParityInput>[] = [];
@@ -189,9 +181,6 @@ export class SoloBlockBuilder implements BlockBuilder {
       elapsedBaseParityOutputsPromise = elapsed(() => Promise.all(baseParityOutputs));
     }
 
-    // padArrayEnd throws if the array is already full. Otherwise it pads till we reach the required size
-    const newL1ToL2MessagesTuple = padArrayEnd(newL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-
     // BASE ROLLUP CIRCUIT (run in parallel)
     let elapsedBaseRollupOutputsPromise: Promise<[number, [BaseOrMergeRollupPublicInputs, Proof][]]>;
     const baseRollupInputs: BaseRollupInputs[] = [];
@@ -302,7 +291,7 @@ export class SoloBlockBuilder implements BlockBuilder {
       outputSize: rootParityOutput.toBuffer().length,
     } satisfies CircuitSimulationStats);
 
-    return this.rootRollupCircuit(mergeOutputLeft, mergeOutputRight, rootParityOutput, newL1ToL2MessagesTuple);
+    return this.rootRollupCircuit(mergeOutputLeft, mergeOutputRight, rootParityOutput, l1ToL2Messages);
   }
 
   protected async baseParityCircuit(inputs: BaseParityInputs): Promise<RootParityInput> {
@@ -365,15 +354,15 @@ export class SoloBlockBuilder implements BlockBuilder {
     left: [BaseOrMergeRollupPublicInputs, Proof],
     right: [BaseOrMergeRollupPublicInputs, Proof],
     l1ToL2Roots: RootParityInput,
-    newL1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
+    l1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
   ): Promise<[RootRollupPublicInputs, Proof]> {
     this.debug(`Running root rollup circuit`);
-    const rootInput = await this.getRootRollupInput(...left, ...right, l1ToL2Roots, newL1ToL2Messages);
+    const rootInput = await this.getRootRollupInput(...left, ...right, l1ToL2Roots, l1ToL2Messages);
 
-    // Update the local trees to include the new l1 to l2 messages
+    // Update the local trees to include the l1 to l2 messages
     await this.db.appendLeaves(
       MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
-      newL1ToL2Messages.map(m => m.toBuffer()),
+      l1ToL2Messages.map(m => m.toBuffer()),
     );
 
     // Simulate and get proof for the root circuit
@@ -690,8 +679,8 @@ export class SoloBlockBuilder implements BlockBuilder {
     const newPublicDataReadsPreimages: Tuple<PublicDataTreeLeafPreimage, typeof MAX_PUBLIC_DATA_READS_PER_TX> =
       makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => PublicDataTreeLeafPreimage.empty());
 
-    for (const i in tx.data.combinedData.publicDataReads) {
-      const leafSlot = tx.data.combinedData.publicDataReads[i].leafSlot.value;
+    for (const i in tx.data.validationRequests.publicDataReads) {
+      const leafSlot = tx.data.validationRequests.publicDataReads[i].leafSlot.value;
       const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
       if (!lowLeafResult) {
         throw new Error(`Public data tree should have one initial leaf`);

package/src/client/sequencer-client.ts

@@ -1,6 +1,7 @@
-import { ContractDataSource, L1ToL2MessageSource, L2BlockSource } from '@aztec/circuit-types';
+import { L1ToL2MessageSource, L2BlockSource } from '@aztec/circuit-types';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { P2P } from '@aztec/p2p';
+import { ContractDataSource } from '@aztec/types/contracts';
 import { WorldStateSynchronizer } from '@aztec/world-state';
 
 import * as fs from 'fs/promises';

package/src/sequencer/abstract_phase_manager.ts

@@ -11,14 +11,13 @@ import {
   MAX_NEW_L2_TO_L1_MSGS_PER_CALL,
   MAX_NEW_NOTE_HASHES_PER_CALL,
   MAX_NEW_NULLIFIERS_PER_CALL,
-  MAX_NON_REVERTIBLE_PUBLIC_DATA_READS_PER_TX,
   MAX_NON_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
   MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
   MAX_PUBLIC_DATA_READS_PER_CALL,
+  MAX_PUBLIC_DATA_READS_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
-  MAX_REVERTIBLE_PUBLIC_DATA_READS_PER_TX,
   MAX_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MembershipWitness,
   PrivateKernelTailCircuitPublicInputs,
@@ -291,15 +290,14 @@ export abstract class AbstractPhaseManager {
     const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
 
     if (this.phase === PublicKernelPhase.TAIL) {
-      const { endNonRevertibleData, end } = previousOutput;
+      const { validationRequests, endNonRevertibleData, end } = previousOutput;
       const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
-        endNonRevertibleData.nullifierReadRequests,
-        end.nullifierReadRequests,
+        validationRequests.nullifierReadRequests,
         endNonRevertibleData.newNullifiers,
         end.newNullifiers,
       );
       const nullifierNonExistentReadRequestHints = await this.hintsBuilder.getNullifierNonExistentReadRequestHints(
-        endNonRevertibleData.nullifierNonExistentReadRequests,
+        validationRequests.nullifierNonExistentReadRequests,
         endNonRevertibleData.newNullifiers,
         end.newNullifiers,
       );
@@ -479,9 +477,8 @@ function patchPublicStorageActionOrdering(
   execResult: PublicExecutionResult,
   phase: PublicKernelPhase,
 ) {
-  const { publicDataReads, publicDataUpdateRequests } = PhaseIsRevertible[phase]
-    ? publicInputs.end
-    : publicInputs.endNonRevertibleData;
+  const { publicDataUpdateRequests } = PhaseIsRevertible[phase] ? publicInputs.end : publicInputs.endNonRevertibleData;
+  const { publicDataReads } = publicInputs.validationRequests;
 
   // Convert ContractStorage* objects to PublicData* objects and sort them in execution order.
   // Note, this only pulls simulated reads/writes from the current phase,
@@ -518,14 +515,14 @@ function patchPublicStorageActionOrdering(
 
   const numReadsInKernel = arrayNonEmptyLength(publicDataReads, f => f.isEmpty());
   const numReadsBeforeThisEnqueuedCall = numReadsInKernel - simPublicDataReads.length;
-  publicInputs[effectSet].publicDataReads = padArrayEnd(
+  publicInputs.validationRequests.publicDataReads = padArrayEnd(
     [
       // do not mess with items from previous top/enqueued calls in kernel output
-      ...publicInputs[effectSet].publicDataReads.slice(0, numReadsBeforeThisEnqueuedCall),
+      ...publicInputs.validationRequests.publicDataReads.slice(0, numReadsBeforeThisEnqueuedCall),
       ...simPublicDataReads,
     ],
     PublicDataRead.empty(),
-    PhaseIsRevertible[phase] ? MAX_REVERTIBLE_PUBLIC_DATA_READS_PER_TX : MAX_NON_REVERTIBLE_PUBLIC_DATA_READS_PER_TX,
+    MAX_PUBLIC_DATA_READS_PER_TX,
   );
 
   const numUpdatesInKernel = arrayNonEmptyLength(publicDataUpdateRequests, f => f.isEmpty());

package/src/sequencer/hints_builder.ts

@@ -13,7 +13,6 @@ import {
   buildNullifierNonExistentReadRequestHints,
   buildNullifierReadRequestHints,
   concatAccumulatedData,
-  mergeAccumulatedData,
 } from '@aztec/circuits.js';
 import { Tuple } from '@aztec/foundation/serialize';
 import { MerkleTreeOperations } from '@aztec/world-state';
@@ -22,18 +21,13 @@ export class HintsBuilder {
   constructor(private db: MerkleTreeOperations) {}
 
   getNullifierReadRequestHints(
-    nullifierReadRequestsNonRevertible: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-    nullifierReadRequestsRevertible: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+    nullifierReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
     nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX>,
     nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_REVERTIBLE_NULLIFIERS_PER_TX>,
   ) {
     return buildNullifierReadRequestHints(
       this,
-      mergeAccumulatedData(
-        MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-        nullifierReadRequestsNonRevertible,
-        nullifierReadRequestsRevertible,
-      ),
+      nullifierReadRequests,
       concatAccumulatedData(MAX_NEW_NULLIFIERS_PER_TX, nullifiersNonRevertible, nullifiersRevertible),
     );
   }

package/src/sequencer/processed_tx.ts

@@ -11,6 +11,7 @@ import {
   PublicKernelCircuitPublicInputs,
   SideEffect,
   SideEffectLinkedToNoteHash,
+  ValidationRequests,
   makeEmptyProof,
 } from '@aztec/circuits.js';
 import { Tuple, fromFieldsTuple } from '@aztec/foundation/serialize';
@@ -109,6 +110,7 @@ export function getPreviousOutputAndProof(
   } else {
     const publicKernelPublicInput = new PublicKernelCircuitPublicInputs(
       tx.data.aggregationObject,
+      ValidationRequests.empty(),
       PublicAccumulatedNonRevertibleData.fromPrivateAccumulatedNonRevertibleData(tx.data.endNonRevertibleData),
       PublicAccumulatedRevertibleData.fromPrivateAccumulatedRevertibleData(tx.data.end),
       tx.data.constants,

package/src/sequencer/public_processor.ts

@@ -1,9 +1,10 @@
-import { ContractDataSource, L1ToL2MessageSource, SimulationError, Tx } from '@aztec/circuit-types';
+import { L1ToL2MessageSource, SimulationError, Tx } from '@aztec/circuit-types';
 import { TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
 import { GlobalVariables, Header } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { PublicExecutor, PublicStateDB } from '@aztec/simulator';
+import { ContractDataSource } from '@aztec/types/contracts';
 import { MerkleTreeOperations } from '@aztec/world-state';
 
 import { EmptyPublicProver } from '../prover/empty.js';

package/src/sequencer/sequencer.ts

@@ -202,12 +202,10 @@ export class Sequencer {
 
       await assertBlockHeight();
 
-      const newModelL1ToL2Messages = await this.l1ToL2MessageSource.getNewL1ToL2Messages(BigInt(newBlockNumber));
-
       // Get l1 to l2 messages from the contract
       this.log('Requesting L1 to L2 messages from contract');
-      const l1ToL2Messages = await this.getPendingL1ToL2EntryKeys();
-      this.log('Successfully retrieved L1 to L2 messages from contract');
+      const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(newBlockNumber));
+      this.log(`Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newBlockNumber}`);
 
       // Build the new block by running the rollup circuits
       this.log(`Assembling block with txs ${processedValidTxs.map(tx => tx.hash).join(', ')}`);
@@ -216,7 +214,7 @@ export class Sequencer {
 
       const emptyTx = processor.makeEmptyProcessedTx();
       const [rollupCircuitsDuration, block] = await elapsed(() =>
-        this.buildBlock(processedValidTxs, newModelL1ToL2Messages, l1ToL2Messages, emptyTx, newGlobalVariables),
+        this.buildBlock(processedValidTxs, l1ToL2Messages, emptyTx, newGlobalVariables),
       );
 
       this.log(`Assembled block ${block.number}`, {
@@ -314,16 +312,14 @@ export class Sequencer {
   /**
    * Pads the set of txs to a power of two and assembles a block by calling the block builder.
    * @param txs - Processed txs to include in the next block.
-   * @param newModelL1ToL2Messages - L1 to L2 messages emitted by the new inbox.
-   * @param newL1ToL2Messages - L1 to L2 messages to be part of the block.
+   * @param l1ToL2Messages - L1 to L2 messages to be part of the block.
    * @param emptyTx - Empty tx to repeat at the end of the block to pad to a power of two.
    * @param globalVariables - Global variables to use in the block.
    * @returns The new block.
    */
   protected async buildBlock(
     txs: ProcessedTx[],
-    newModelL1ToL2Messages: Fr[], // TODO(#4492): Rename this when purging the old inbox
-    newL1ToL2Messages: Fr[], // TODO(#4492): Nuke this when purging the old inbox
+    l1ToL2Messages: Fr[],
     emptyTx: ProcessedTx,
     globalVariables: GlobalVariables,
   ) {
@@ -332,24 +328,10 @@ export class Sequencer {
     const emptyTxCount = txsTargetSize - txs.length;
 
     const allTxs = [...txs, ...times(emptyTxCount, () => emptyTx)];
-    this.log(`Building block ${globalVariables.blockNumber}`);
-
-    const [block] = await this.blockBuilder.buildL2Block(
-      globalVariables,
-      allTxs,
-      newModelL1ToL2Messages,
-      newL1ToL2Messages,
-    );
-    return block;
-  }
+    this.log(`Building block ${globalVariables.blockNumber.toBigInt()}`);
 
-  /**
-   * Calls the archiver to pull upto `NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP` entry keys
-   * (archiver returns the top messages sorted by fees)
-   * @returns An array of L1 to L2 messages' entryKeys
-   */
-  protected async getPendingL1ToL2EntryKeys(): Promise<Fr[]> {
-    return await this.l1ToL2MessageSource.getPendingL1ToL2EntryKeys();
+    const [block] = await this.blockBuilder.buildL2Block(globalVariables, allTxs, l1ToL2Messages);
+    return block;
   }
 
   /**

package/src/simulator/public_executor.ts

@@ -1,6 +1,4 @@
 import {
-  ContractDataSource,
-  ExtendedContractData,
   L1ToL2MessageSource,
   MerkleTreeId,
   NullifierMembershipWitness,
@@ -22,9 +20,8 @@ import {
 import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { ClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
-import { InstanceDeployerAddress } from '@aztec/protocol-contracts/instance-deployer';
 import { CommitmentsDB, MessageLoadOracleInputs, PublicContractsDB, PublicStateDB } from '@aztec/simulator';
-import { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/types/contracts';
+import { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { MerkleTreeOperations } from '@aztec/world-state';
 
 /**
@@ -32,7 +29,6 @@ import { MerkleTreeOperations } from '@aztec/world-state';
  * Progressively records contracts in transaction as they are processed in a block.
  */
 export class ContractsDataSourcePublicDB implements PublicContractsDB {
-  private cache = new Map<string, ExtendedContractData>();
   private instanceCache = new Map<string, ContractInstanceWithAddress>();
   private classCache = new Map<string, ContractClassPublic>();
 
@@ -51,7 +47,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
       this.log(`Adding class ${e.contractClassId.toString()} to public execution contract cache`);
       this.classCache.set(e.contractClassId.toString(), e.toContractClassPublic());
     });
-    ContractInstanceDeployedEvent.fromLogs(logs, InstanceDeployerAddress).forEach(e => {
+    ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => {
       this.log(
         `Adding instance ${e.address.toString()} with class ${e.contractClassId.toString()} to public execution contract cache`,
       );
@@ -73,9 +69,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     ContractClassRegisteredEvent.fromLogs(logs, ClassRegistererAddress).forEach(e =>
       this.classCache.delete(e.contractClassId.toString()),
     );
-    ContractInstanceDeployedEvent.fromLogs(logs, InstanceDeployerAddress).forEach(e =>
-      this.instanceCache.delete(e.address.toString()),
-    );
+    ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => this.instanceCache.delete(e.address.toString()));
     return Promise.resolve();
   }
 
@@ -83,46 +77,25 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     return this.instanceCache.get(address.toString()) ?? (await this.db.getContract(address));
   }
 
-  async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
-    const contract = await this.#getContract(address);
-    return contract?.getPublicFunction(selector)?.bytecode;
+  public async getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined> {
+    return this.classCache.get(contractClassId.toString()) ?? (await this.db.getContractClass(contractClassId));
   }
 
-  async getIsInternal(address: AztecAddress, selector: FunctionSelector): Promise<boolean | undefined> {
-    const contract = await this.#getContract(address);
-    return contract?.getPublicFunction(selector)?.isInternal;
-  }
-
-  async getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined> {
-    const contract = await this.#getContract(address);
-    return contract?.contractData.portalContractAddress;
-  }
-
-  async #getContract(address: AztecAddress): Promise<ExtendedContractData | undefined> {
-    return (
-      this.cache.get(address.toString()) ??
-      (await this.#makeExtendedContractDataFor(address)) ??
-      (await this.db.getExtendedContractData(address))
-    );
-  }
-
-  async #makeExtendedContractDataFor(address: AztecAddress): Promise<ExtendedContractData | undefined> {
-    const instance = this.instanceCache.get(address.toString());
+  async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
+    const instance = await this.getContractInstance(address);
     if (!instance) {
-      return undefined;
+      throw new Error(`Contract ${address.toString()} not found`);
     }
-
-    const contractClass =
-      this.classCache.get(instance.contractClassId.toString()) ??
-      (await this.db.getContractClass(instance.contractClassId));
+    const contractClass = await this.getContractClass(instance.contractClassId);
     if (!contractClass) {
-      this.log.warn(
-        `Contract class ${instance.contractClassId.toString()} for address ${address.toString()} not found`,
-      );
-      return undefined;
+      throw new Error(`Contract class ${instance.contractClassId.toString()} for ${address.toString()} not found`);
     }
+    return contractClass.publicFunctions.find(f => f.selector.equals(selector))?.bytecode;
+  }
 
-    return ExtendedContractData.fromClassAndInstance(contractClass, instance);
+  async getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined> {
+    const contract = await this.getContractInstance(address);
+    return contract?.portalContractAddress;
   }
 }