@aztec/sequencer-client 0.1.0-alpha23 → 0.1.0-alpha40

package/src/sequencer/public_processor.ts

@@ -6,14 +6,15 @@ import {
   ContractStorageUpdateRequest,
   Fr,
   GlobalVariables,
-  MAX_PUBLIC_DATA_READS_PER_CALL,
-  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
+  HistoricBlockData,
   KernelCircuitPublicInputs,
-  MembershipWitness,
   MAX_NEW_COMMITMENTS_PER_CALL,
   MAX_NEW_L2_TO_L1_MSGS_PER_CALL,
   MAX_NEW_NULLIFIERS_PER_CALL,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
+  MAX_PUBLIC_DATA_READS_PER_CALL,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
+  MembershipWitness,
   PreviousKernelData,
   Proof,
   PublicCallData,
@@ -30,6 +31,7 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { Tuple, mapTuple, to2Fields } from '@aztec/foundation/serialize';
 import { ContractDataSource, FunctionL2Logs, L1ToL2MessageSource, MerkleTreeId, Tx } from '@aztec/types';
 import { MerkleTreeOperations } from '@aztec/world-state';
+
 import { getVerificationKeys } from '../index.js';
 import { EmptyPublicProver } from '../prover/empty.js';
 import { PublicProver } from '../prover/index.js';
@@ -37,7 +39,7 @@ import { PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { getPublicExecutor } from '../simulator/public_executor.js';
 import { WasmPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
 import { ProcessedTx, makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
-import { getCombinedHistoricTreeRoots } from './utils.js';
+import { getHistoricBlockData } from './utils.js';
 
 /**
  * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
@@ -51,15 +53,23 @@ export class PublicProcessorFactory {
 
   /**
    * Creates a new instance of a PublicProcessor.
+   * @param prevGlobalVariables - The global variables for the previous block, used to calculate the prev global variables hash.
+   * @param globalVariables - The global variables for the block being processed.
    * @returns A new instance of a PublicProcessor.
    */
-  public create() {
+  public async create(
+    prevGlobalVariables: GlobalVariables,
+    globalVariables: GlobalVariables,
+  ): Promise<PublicProcessor> {
+    const blockData = await getHistoricBlockData(this.merkleTree, prevGlobalVariables);
     return new PublicProcessor(
       this.merkleTree,
-      getPublicExecutor(this.merkleTree, this.contractDataSource, this.l1Tol2MessagesDataSource),
+      getPublicExecutor(this.merkleTree, this.contractDataSource, this.l1Tol2MessagesDataSource, blockData),
       new WasmPublicKernelCircuitSimulator(),
       new EmptyPublicProver(),
       this.contractDataSource,
+      globalVariables,
+      blockData,
     );
   }
 }
@@ -75,6 +85,8 @@ export class PublicProcessor {
     protected publicKernel: PublicKernelCircuitSimulator,
     protected publicProver: PublicProver,
     protected contractDataSource: ContractDataSource,
+    protected globalVariables: GlobalVariables,
+    protected blockData: HistoricBlockData,
 
     private log = createDebugLogger('aztec:sequencer:public-processor'),
   ) {}
@@ -82,17 +94,16 @@ export class PublicProcessor {
   /**
    * Run each tx through the public circuit and the public kernel circuit if needed.
    * @param txs - Txs to process.
-   * @param globalVariables - The global variables for the block.
    * @returns The list of processed txs with their circuit simulation outputs.
    */
-  public async process(txs: Tx[], globalVariables: GlobalVariables): Promise<[ProcessedTx[], Tx[]]> {
+  public async process(txs: Tx[]): Promise<[ProcessedTx[], Tx[]]> {
     const result: ProcessedTx[] = [];
     const failed: Tx[] = [];
 
     for (const tx of txs) {
       this.log(`Processing tx ${await tx.getTxHash()}`);
       try {
-        result.push(await this.processTx(tx, globalVariables));
+        result.push(await this.processTx(tx));
       } catch (err) {
         this.log(`Error processing tx ${await tx.getTxHash()}: ${err}`);
         failed.push(tx);
@@ -103,20 +114,17 @@ export class PublicProcessor {
 
   /**
    * Makes an empty processed tx. Useful for padding a block to a power of two number of txs.
-   * @param chainId - The chain id of the rollup.
-   * @param version - The version of the rollup.
    * @returns A processed tx with empty data.
    */
-  public async makeEmptyProcessedTx(chainId: Fr, version: Fr): Promise<ProcessedTx> {
-    const historicTreeRoots = await getCombinedHistoricTreeRoots(this.db);
-    return makeEmptyProcessedTx(historicTreeRoots, chainId, version);
+  public makeEmptyProcessedTx(): Promise<ProcessedTx> {
+    const { chainId, version } = this.globalVariables;
+    return makeEmptyProcessedTx(this.blockData, chainId, version);
   }
 
-  protected async processTx(tx: Tx, globalVariables: GlobalVariables): Promise<ProcessedTx> {
+  protected async processTx(tx: Tx): Promise<ProcessedTx> {
     if (!isArrayEmpty(tx.data.end.publicCallStack, item => item.isZero())) {
       const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(
         tx,
-        globalVariables,
       );
       tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
 
@@ -126,10 +134,7 @@ export class PublicProcessor {
     }
   }
 
-  protected async processEnqueuedPublicCalls(
-    tx: Tx,
-    globalVariables: GlobalVariables,
-  ): Promise<[PublicKernelPublicInputs, Proof, FunctionL2Logs[]]> {
+  protected async processEnqueuedPublicCalls(tx: Tx): Promise<[PublicKernelPublicInputs, Proof, FunctionL2Logs[]]> {
     this.log(`Executing enqueued public calls for tx ${await tx.getTxHash()}`);
     if (!tx.enqueuedPublicFunctionCalls) throw new Error(`Missing preimages for enqueued public calls`);
 
@@ -143,13 +148,14 @@ export class PublicProcessor {
     while (executionStack.length) {
       const current = executionStack.pop()!;
       const isExecutionRequest = !isPublicExecutionResult(current);
-      const result = isExecutionRequest ? await this.publicExecutor.execute(current, globalVariables) : current;
+      const result = isExecutionRequest ? await this.publicExecutor.execute(current, this.globalVariables) : current;
       newUnencryptedFunctionLogs.push(result.unencryptedLogs);
       const functionSelector = result.execution.functionData.functionSelectorBuffer.toString('hex');
       this.log(`Running public kernel circuit for ${functionSelector}@${result.execution.contractAddress.toString()}`);
       executionStack.push(...result.nestedExecutions);
       const preimages = await this.getPublicCallStackPreimages(result);
       const callData = await this.getPublicCallData(result, preimages, isExecutionRequest);
+
       [kernelOutput, kernelProof] = await this.runKernelCircuit(callData, kernelOutput, kernelProof);
     }
 
@@ -195,20 +201,22 @@ export class PublicProcessor {
 
   protected async getPublicCircuitPublicInputs(result: PublicExecutionResult) {
     const publicDataTreeInfo = await this.db.getTreeInfo(MerkleTreeId.PUBLIC_DATA_TREE);
-    const historicPublicDataTreeRoot = Fr.fromBuffer(publicDataTreeInfo.root);
+    this.blockData.publicDataTreeRoot = Fr.fromBuffer(publicDataTreeInfo.root);
+
     const callStackPreimages = await this.getPublicCallStackPreimages(result);
     const wasm = await CircuitsWasm.get();
+
     const publicCallStack = mapTuple(callStackPreimages, item =>
       item.isEmpty() ? Fr.zero() : computeCallStackItemHash(wasm, item),
     );
 
-    // TODO(#1347): Noir fails with too many unknowns error when public inputs struct contains too many members.
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165) --> set this in Noir
     const unencryptedLogsHash = to2Fields(result.unencryptedLogs.hash());
     const unencryptedLogPreimagesLength = new Fr(result.unencryptedLogs.getSerializedLength());
 
     return PublicCircuitPublicInputs.from({
       callContext: result.execution.callContext,
-      proverAddress: AztecAddress.random(),
+      proverAddress: AztecAddress.ZERO,
       argsHash: await computeVarArgsHash(wasm, result.execution.args),
       newCommitments: padArrayEnd(result.newCommitments, Fr.ZERO, MAX_NEW_COMMITMENTS_PER_CALL),
       newNullifiers: padArrayEnd(result.newNullifiers, Fr.ZERO, MAX_NEW_NULLIFIERS_PER_CALL),
@@ -227,7 +235,7 @@ export class PublicProcessor {
       publicCallStack,
       unencryptedLogsHash,
       unencryptedLogPreimagesLength,
-      historicPublicDataTreeRoot,
+      historicBlockData: this.blockData,
     });
   }
 

package/src/sequencer/sequencer.test.ts

@@ -1,21 +1,23 @@
 import {
-  CombinedHistoricTreeRoots,
   Fr,
   GlobalVariables,
+  HistoricBlockData,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   makeEmptyProof,
 } from '@aztec/circuits.js';
 import { P2P, P2PClientState } from '@aztec/p2p';
-import { L1ToL2MessageSource, L2Block, L2BlockSource, MerkleTreeId, mockTx, Tx, TxHash } from '@aztec/types';
+import { L1ToL2MessageSource, L2Block, L2BlockSource, MerkleTreeId, Tx, TxHash, mockTx } from '@aztec/types';
 import { MerkleTreeOperations, WorldStateRunningState, WorldStateSynchroniser } from '@aztec/world-state';
+
 import { MockProxy, mock } from 'jest-mock-extended';
 import times from 'lodash.times';
+
 import { BlockBuilder } from '../block_builder/index.js';
+import { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import { L1Publisher } from '../index.js';
 import { makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
 import { PublicProcessor, PublicProcessorFactory } from './public_processor.js';
 import { Sequencer } from './sequencer.js';
-import { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 
 describe('sequencer', () => {
   let publisher: MockProxy<L1Publisher>;
@@ -55,11 +57,11 @@ describe('sequencer', () => {
 
     publicProcessor = mock<PublicProcessor>({
       process: async txs => [await Promise.all(txs.map(tx => makeProcessedTx(tx))), []],
-      makeEmptyProcessedTx: () => makeEmptyProcessedTx(CombinedHistoricTreeRoots.empty(), chainId, version),
+      makeEmptyProcessedTx: () => makeEmptyProcessedTx(HistoricBlockData.empty(), chainId, version),
     });
 
     publicProcessorFactory = mock<PublicProcessorFactory>({
-      create: () => publicProcessor,
+      create: (_, __) => Promise.resolve(publicProcessor),
     });
 
     l2BlockSource = mock<L2BlockSource>({

package/src/sequencer/sequencer.ts

@@ -1,10 +1,11 @@
+import { GlobalVariables } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { P2P } from '@aztec/p2p';
 import {
   ContractData,
-  ContractPublicData,
+  ContractDataAndBytecode,
   L1ToL2MessageSource,
   L2Block,
   L2BlockSource,
@@ -12,15 +13,16 @@ import {
   Tx,
 } from '@aztec/types';
 import { WorldStateStatus, WorldStateSynchroniser } from '@aztec/world-state';
+
 import times from 'lodash.times';
+
 import { BlockBuilder } from '../block_builder/index.js';
+import { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import { L1Publisher } from '../publisher/l1-publisher.js';
 import { ceilPowerOfTwo } from '../utils.js';
 import { SequencerConfig } from './config.js';
 import { ProcessedTx } from './processed_tx.js';
 import { PublicProcessorFactory } from './public_processor.js';
-import { GlobalVariables } from '@aztec/circuits.js';
-import { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 
 /**
  * Sequencer client
@@ -53,7 +55,7 @@ export class Sequencer {
     config: SequencerConfig,
     private log = createDebugLogger('aztec:sequencer'),
   ) {
-    this.pollingIntervalMs = config.transactionPollingInterval ?? 1_000;
+    this.pollingIntervalMs = config.transactionPollingIntervalMS ?? 1_000;
     if (config.maxTxsPerBlock) {
       this.maxTxsPerBlock = config.maxTxsPerBlock;
     }
@@ -139,12 +141,13 @@ export class Sequencer {
       this.state = SequencerState.CREATING_BLOCK;
 
       const blockNumber = (await this.l2BlockSource.getBlockHeight()) + 1;
-      const globalVariables = await this.globalsBuilder.buildGlobalVariables(new Fr(blockNumber));
+      const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(new Fr(blockNumber));
+      const prevGlobalVariables = (await this.l2BlockSource.getL2Block(-1))?.globalVariables ?? GlobalVariables.empty();
 
       // Process txs and drop the ones that fail processing
       // We create a fresh processor each time to reset any cached state (eg storage writes)
-      const processor = this.publicProcessorFactory.create();
-      const [processedTxs, failedTxs] = await processor.process(validTxs, globalVariables);
+      const processor = await this.publicProcessorFactory.create(prevGlobalVariables, newGlobalVariables);
+      const [processedTxs, failedTxs] = await processor.process(validTxs);
       if (failedTxs.length > 0) {
         this.log(`Dropping failed txs ${(await Tx.getHashes(failedTxs)).join(', ')}`);
         await this.p2pClient.deleteTxs(await Tx.getHashes(failedTxs));
@@ -162,27 +165,28 @@ export class Sequencer {
 
       // Build the new block by running the rollup circuits
       this.log(`Assembling block with txs ${processedTxs.map(tx => tx.hash).join(', ')}`);
-      const emptyTx = await processor.makeEmptyProcessedTx(this.chainId, this.version);
 
-      const block = await this.buildBlock(processedTxs, l1ToL2Messages, emptyTx, globalVariables);
+      const emptyTx = await processor.makeEmptyProcessedTx();
+      const block = await this.buildBlock(processedTxs, l1ToL2Messages, emptyTx, newGlobalVariables);
       this.log(`Assembled block ${block.number}`);
 
-      await this.publishContractPublicData(validTxs, block);
+      await this.publishContractDataAndBytecode(validTxs, block);
 
       await this.publishL2Block(block);
+      this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
     } catch (err) {
-      this.log(err);
-      this.log(`Rolling back world state DB`);
+      this.log.error(err);
+      this.log.error(`Rolling back world state DB`);
       await this.worldState.getLatest().rollback();
     }
   }
 
   /**
-   * Gets new contract public data from the txs and publishes it on chain.
+   * Gets new contract data and bytecode from the txs and publishes it on chain.
    * @param validTxs - The set of real transactions being published as part of the block.
    * @param block - The L2Block to be published.
    */
-  protected async publishContractPublicData(validTxs: Tx[], block: L2Block) {
+  protected async publishContractDataAndBytecode(validTxs: Tx[], block: L2Block) {
     // Publishes contract data for txs to the network and awaits the tx to be mined
     this.state = SequencerState.PUBLISHING_CONTRACT_DATA;
     const newContractData = validTxs
@@ -190,7 +194,7 @@ export class Sequencer {
         // Currently can only have 1 new contract per tx
         const newContract = tx.data?.end.newContracts[0];
         if (newContract && tx.newContractPublicFunctions?.length) {
-          return new ContractPublicData(
+          return new ContractDataAndBytecode(
             new ContractData(newContract.contractAddress, newContract.portalContractAddress),
             tx.newContractPublicFunctions,
           );
@@ -199,7 +203,7 @@ export class Sequencer {
       .filter((cd): cd is Exclude<typeof cd, undefined> => cd !== undefined);
 
     const blockHash = block.getCalldataHash();
-    this.log(`Publishing contract public data with block hash ${blockHash.toString('hex')}`);
+    this.log(`Publishing contract data and bytecode with block hash ${blockHash.toString('hex')}`);
 
     const publishedContractData = await this.publisher.processNewContractData(block.number, blockHash, newContractData);
     if (publishedContractData) {

package/src/sequencer/utils.ts

@@ -1,18 +1,26 @@
-import { CombinedHistoricTreeRoots, Fr, PrivateHistoricTreeRoots } from '@aztec/circuits.js';
-import { MerkleTreeId } from '@aztec/types';
+import { CircuitsWasm, Fr, GlobalVariables, HistoricBlockData } from '@aztec/circuits.js';
+import { computeGlobalsHash } from '@aztec/circuits.js/abis';
 import { MerkleTreeOperations } from '@aztec/world-state';
 
 /**
  * Fetches the private, nullifier, contract tree and l1 to l2 messages tree roots from a given db and assembles a CombinedHistoricTreeRoots object.
  */
-export async function getCombinedHistoricTreeRoots(db: MerkleTreeOperations) {
-  return new CombinedHistoricTreeRoots(
-    new PrivateHistoricTreeRoots(
-      Fr.fromBuffer((await db.getTreeInfo(MerkleTreeId.PRIVATE_DATA_TREE)).root),
-      Fr.fromBuffer((await db.getTreeInfo(MerkleTreeId.NULLIFIER_TREE)).root),
-      Fr.fromBuffer((await db.getTreeInfo(MerkleTreeId.CONTRACT_TREE)).root),
-      Fr.fromBuffer((await db.getTreeInfo(MerkleTreeId.L1_TO_L2_MESSAGES_TREE)).root),
-      Fr.ZERO,
-    ),
+export async function getHistoricBlockData(
+  db: MerkleTreeOperations,
+  prevBlockGlobalVariables: GlobalVariables = GlobalVariables.empty(),
+) {
+  const wasm = await CircuitsWasm.get();
+  const prevGlobalsHash = computeGlobalsHash(wasm, prevBlockGlobalVariables);
+  const roots = db.getTreeRoots();
+
+  return new HistoricBlockData(
+    Fr.fromBuffer(roots.privateDataTreeRoot),
+    Fr.fromBuffer(roots.nullifierTreeRoot),
+    Fr.fromBuffer(roots.contractDataTreeRoot),
+    Fr.fromBuffer(roots.l1Tol2MessagesTreeRoot),
+    Fr.fromBuffer(roots.blocksTreeRoot),
+    Fr.ZERO,
+    Fr.fromBuffer(roots.publicDataTreeRoot),
+    prevGlobalsHash,
   );
 }

package/src/simulator/index.ts

@@ -38,13 +38,13 @@ export interface RollupSimulator {
 export interface PublicKernelCircuitSimulator {
   /**
    * Simulates the public kernel circuit (with a previous private kernel circuit run) from its inputs.
-   * @param input - Inputs to the circuit.
+   * @param inputs - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
   publicKernelCircuitPrivateInput(inputs: PublicKernelInputs): Promise<PublicKernelPublicInputs>;
   /**
    * Simulates the public kernel circuit (with no previous public kernel circuit run) from its inputs.
-   * @param input - Inputs to the circuit.
+   * @param inputs - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
   publicKernelCircuitNonFirstIteration(inputs: PublicKernelInputs): Promise<PublicKernelPublicInputs>;

package/src/simulator/public_executor.ts

@@ -6,7 +6,7 @@ import {
   PublicExecutor,
   PublicStateDB,
 } from '@aztec/acir-simulator';
-import { AztecAddress, CircuitsWasm, EthAddress, Fr, PrivateHistoricTreeRoots } from '@aztec/circuits.js';
+import { AztecAddress, CircuitsWasm, EthAddress, Fr, HistoricBlockData } from '@aztec/circuits.js';
 import { siloCommitment } from '@aztec/circuits.js/abis';
 import { ContractDataSource, L1ToL2MessageSource, MerkleTreeId } from '@aztec/types';
 import { MerkleTreeOperations, computePublicDataTreeLeafIndex } from '@aztec/world-state';
@@ -21,11 +21,13 @@ export function getPublicExecutor(
   merkleTree: MerkleTreeOperations,
   contractDataSource: ContractDataSource,
   l1toL2MessageSource: L1ToL2MessageSource,
+  blockData: HistoricBlockData,
 ) {
   return new PublicExecutor(
     new WorldStatePublicDB(merkleTree),
     new ContractsDataSourcePublicDB(contractDataSource),
     new WorldStateDB(merkleTree, l1toL2MessageSource),
+    blockData,
   );
 }
 
@@ -37,8 +39,11 @@ class ContractsDataSourcePublicDB implements PublicContractsDB {
   async getBytecode(address: AztecAddress, functionSelector: Buffer): Promise<Buffer | undefined> {
     return (await this.db.getPublicFunction(address, functionSelector))?.bytecode;
   }
+  async getIsInternal(address: AztecAddress, functionSelector: Buffer): Promise<boolean | undefined> {
+    return (await this.db.getPublicFunction(address, functionSelector))?.isInternal;
+  }
   async getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined> {
-    return (await this.db.getL2ContractInfo(address))?.portalContractAddress;
+    return (await this.db.getContractData(address))?.portalContractAddress;
   }
 }
 
@@ -82,12 +87,6 @@ class WorldStatePublicDB implements PublicStateDB {
 export class WorldStateDB implements CommitmentsDB {
   constructor(private db: MerkleTreeOperations, private l1ToL2MessageSource: L1ToL2MessageSource) {}
 
-  /**
-   * Gets a confirmed L1 to L2 message for the given message key.
-   * TODO(Maddiaa): Can be combined with aztec-node method that does the same thing.
-   * @param messageKey - The message Key.
-   * @returns - The l1 to l2 message object
-   */
   public async getL1ToL2Message(messageKey: Fr): Promise<MessageLoadOracleInputs> {
     // todo: #697 - make this one lookup.
     const message = await this.l1ToL2MessageSource.getConfirmedL1ToL2Message(messageKey);
@@ -96,42 +95,24 @@ export class WorldStateDB implements CommitmentsDB {
 
     return {
       message: message.toFieldArray(),
-      index,
       siblingPath: siblingPath.toFieldArray(),
+      index,
     };
   }
 
-  /**
-   * Gets a message index and sibling path to some commitment in the private data tree.
-   * @param address - The contract address owning storage.
-   * @param commitment - The preimage of the siloed data.
-   * @returns - The Commitment data oracle object
-   */
-  public async getCommitmentOracle(address: AztecAddress, commitment: Fr): Promise<CommitmentDataOracleInputs> {
-    const siloedCommitment = siloCommitment(await CircuitsWasm.get(), address, commitment);
+  public async getCommitmentOracle(address: AztecAddress, innerCommitment: Fr): Promise<CommitmentDataOracleInputs> {
+    const siloedCommitment = siloCommitment(await CircuitsWasm.get(), address, innerCommitment);
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386): shoild be
+    // unique commitment that exists in tree (should be siloed and then made unique via
+    // nonce).  Once public kernel or base rollup circuit injects nonces, this can be updated
+    // to use uniqueSiloedCommitment.
     const index = (await this.db.findLeafIndex(MerkleTreeId.PRIVATE_DATA_TREE, siloedCommitment.toBuffer()))!;
     const siblingPath = await this.db.getSiblingPath(MerkleTreeId.PRIVATE_DATA_TREE, index);
 
     return {
       commitment: siloedCommitment,
-      index,
       siblingPath: siblingPath.toFieldArray(),
+      index,
     };
   }
-
-  /**
-   * Gets the current tree roots from the merkle db.
-   * @returns current tree roots.
-   */
-  public getTreeRoots(): PrivateHistoricTreeRoots {
-    const roots = this.db.getCommitmentTreeRoots();
-
-    return PrivateHistoricTreeRoots.from({
-      privateKernelVkTreeRoot: Fr.ZERO,
-      privateDataTreeRoot: Fr.fromBuffer(roots.privateDataTreeRoot),
-      contractTreeRoot: Fr.fromBuffer(roots.contractDataTreeRoot),
-      nullifierTreeRoot: Fr.fromBuffer(roots.nullifierTreeRoot),
-      l1ToL2MessagesTreeRoot: Fr.fromBuffer(roots.l1Tol2MessagesTreeRoot),
-    });
-  }
 }

package/src/simulator/public_kernel.ts

@@ -1,4 +1,5 @@
 import { PublicKernelInputs, PublicKernelPublicInputs, simulatePublicKernelCircuit } from '@aztec/circuits.js';
+
 import { PublicKernelCircuitSimulator } from './index.js';
 
 /**

package/src/simulator/rollup.ts

@@ -7,6 +7,7 @@ import {
   RootRollupInputs,
   RootRollupPublicInputs,
 } from '@aztec/circuits.js';
+
 import { RollupSimulator } from './index.js';
 
 /**