@aztec/sequencer-client 0.7.9 → 0.8.6

package/src/publisher/l1-publisher.ts

@@ -2,21 +2,36 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { InterruptableSleep } from '@aztec/foundation/sleep';
 import { ExtendedContractData, L2Block } from '@aztec/types';
 
+import pick from 'lodash.pick';
+
 import { L2BlockReceiver } from '../receiver.js';
 import { PublisherConfig } from './config.js';
+import { L1PublishStats } from './index.js';
+
+/**
+ * Stats for a sent transaction.
+ */
+export type TransactionStats = {
+  /** Hash of the transaction. */
+  transactionHash: string;
+  /** Size in bytes of the tx calldata */
+  calldataSize: number;
+  /** Gas required to pay for the calldata inclusion (depends on size and number of zeros)  */
+  calldataGas: number;
+};
 
 /**
  * Minimal information from a tx receipt returned by an L1PublisherTxSender.
  */
 export type MinimalTransactionReceipt = {
-  /**
-   * True if the tx was successful, false if reverted.
-   */
+  /** True if the tx was successful, false if reverted. */
   status: boolean;
-  /**
-   * Hash of the transaction.
-   */
+  /** Hash of the transaction. */
   transactionHash: string;
+  /** Effective gas used by the tx */
+  gasUsed: bigint;
+  /** Effective gas price paid by the tx */
+  gasPrice: bigint;
 };
 
 /**
@@ -38,10 +53,7 @@ export interface L1PublisherTxSender {
    * @param publicKeys - The public keys of the deployed contract
    * @param newExtendedContractData - Data to publish.
    * @returns The hash of the mined tx.
-   * @remarks Partial addresses, public keys and contract data has to be in the same order.
-   * @remarks See the link bellow for more info on partial address and public key:
-   * https://github.com/AztecProtocol/aztec-packages/blob/master/docs/docs/concepts/foundation/accounts/keys.md#addresses-partial-addresses-and-public-keys
-   * TODO: replace the link above with the link to deployed docs
+   * @remarks Partial addresses, public keys and contract data has to be in the same order. Read more {@link https://docs.aztec.network/concepts/foundation/accounts/keys#addresses-partial-addresses-and-public-keys | here}.
    */
   sendEmitContractDeploymentTx(
     l2BlockNum: number,
@@ -55,6 +67,12 @@ export interface L1PublisherTxSender {
    * @returns Undefined if the tx hasn't been mined yet, the receipt otherwise.
    */
   getTransactionReceipt(txHash: string): Promise<MinimalTransactionReceipt | undefined>;
+
+  /**
+   * Returns info on a tx by calling eth_getTransaction.
+   * @param txHash - Hash of the tx to look for.
+   */
+  getTransactionStats(txHash: string): Promise<TransactionStats | undefined>;
 }
 
 /**
@@ -122,7 +140,17 @@ export class L1Publisher implements L2BlockReceiver {
       if (!receipt) break;
 
       // Tx was mined successfully
-      if (receipt.status) return true;
+      if (receipt.status) {
+        const tx = await this.txSender.getTransactionStats(txHash);
+        const stats: L1PublishStats = {
+          ...pick(receipt, 'gasPrice', 'gasUsed', 'transactionHash'),
+          ...pick(tx!, 'calldataGas', 'calldataSize'),
+          ...l2BlockData.getStats(),
+          eventName: 'rollup-published-to-l1',
+        };
+        this.log.info(`Published L2 block to L1 rollup contract`, stats);
+        return true;
+      }
 
       // Check if someone else incremented the block number
       if (!(await this.checkNextL2BlockNum(l2BlockData.number))) {
@@ -185,13 +213,18 @@ export class L1Publisher implements L2BlockReceiver {
    * Calling `interrupt` will cause any in progress call to `publishRollup` to return `false` asap.
    * Be warned, the call may return false even if the tx subsequently gets successfully mined.
    * In practice this shouldn't matter, as we'll only ever be calling `interrupt` when we know it's going to fail.
-   * A call to `clearInterrupt` is required before you can continue publishing.
+   * A call to `restart` is required before you can continue publishing.
    */
   public interrupt() {
     this.interrupted = true;
     this.interruptableSleep.interrupt();
   }
 
+  /** Restarts the publisher after calling `interrupt`. */
+  public restart() {
+    this.interrupted = false;
+  }
+
   // TODO: Check fee distributor has at least 0.5 ETH.
   // Related to https://github.com/AztecProtocol/aztec-packages/issues/1588
   // eslint-disable-next-line require-await
@@ -210,7 +243,7 @@ export class L1Publisher implements L2BlockReceiver {
       try {
         return await this.txSender.sendProcessTx(encodedData);
       } catch (err) {
-        this.log(`ROLLUP PUBLISH FAILED`, err);
+        this.log.error(`Rollup publish failed`, err);
         return undefined;
       }
     }

package/src/publisher/viem-tx-sender.ts

@@ -13,13 +13,19 @@ import {
   createWalletClient,
   getAddress,
   getContract,
+  hexToBytes,
   http,
 } from 'viem';
 import { PrivateKeyAccount, privateKeyToAccount } from 'viem/accounts';
 import * as chains from 'viem/chains';
 
 import { TxSenderConfig } from './config.js';
-import { L1PublisherTxSender, MinimalTransactionReceipt, L1ProcessArgs as ProcessTxArgs } from './l1-publisher.js';
+import {
+  L1PublisherTxSender,
+  MinimalTransactionReceipt,
+  L1ProcessArgs as ProcessTxArgs,
+  TransactionStats,
+} from './l1-publisher.js';
 
 /**
  * Pushes transactions to the L1 rollup contract using viem.
@@ -41,13 +47,7 @@ export class ViemTxSender implements L1PublisherTxSender {
   private account: PrivateKeyAccount;
 
   constructor(config: TxSenderConfig) {
-    const {
-      rpcUrl,
-      apiKey,
-      publisherPrivateKey,
-      rollupContract: rollupContractAddress,
-      contractDeploymentEmitterContract: contractDeploymentEmitterContractAddress,
-    } = config;
+    const { rpcUrl, apiKey, publisherPrivateKey, l1Contracts } = config;
     const chain = createEthereumChain(rpcUrl, apiKey);
     this.account = privateKeyToAccount(publisherPrivateKey);
     const walletClient = createWalletClient({
@@ -62,19 +62,30 @@ export class ViemTxSender implements L1PublisherTxSender {
     });
 
     this.rollupContract = getContract({
-      address: getAddress(rollupContractAddress.toString()),
+      address: getAddress(l1Contracts.rollupAddress.toString()),
       abi: RollupAbi,
       publicClient: this.publicClient,
       walletClient,
     });
     this.contractDeploymentEmitterContract = getContract({
-      address: getAddress(contractDeploymentEmitterContractAddress.toString()),
+      address: getAddress(l1Contracts.contractDeploymentEmitterAddress.toString()),
       abi: ContractDeploymentEmitterAbi,
       publicClient: this.publicClient,
       walletClient,
     });
   }
 
+  async getTransactionStats(txHash: string): Promise<TransactionStats | undefined> {
+    const tx = await this.publicClient.getTransaction({ hash: txHash as Hex });
+    if (!tx) return undefined;
+    const calldata = hexToBytes(tx.input);
+    return {
+      transactionHash: tx.hash,
+      calldataSize: calldata.length,
+      calldataGas: getCalldataGasUsage(calldata),
+    };
+  }
+
   /**
    * Returns a tx receipt if the tx has been mined.
    * @param txHash - Hash of the tx to look for.
@@ -85,16 +96,16 @@ export class ViemTxSender implements L1PublisherTxSender {
       hash: txHash as Hex,
     });
 
-    // TODO: check for confirmations
-
     if (receipt) {
       return {
         status: receipt.status === 'success',
         transactionHash: txHash,
+        gasUsed: receipt.gasUsed,
+        gasPrice: receipt.effectiveGasPrice,
       };
     }
 
-    this.log('Receipt not found for tx hash', txHash);
+    this.log(`Receipt not found for tx hash ${txHash}`);
     return undefined;
   }
 
@@ -171,3 +182,12 @@ export class ViemTxSender implements L1PublisherTxSender {
     throw new Error(`Chain with id ${chainId} not found`);
   }
 }
+
+/**
+ * Returns cost of calldata usage in Ethereum.
+ * @param data - Calldata.
+ * @returns 4 for each zero byte, 16 for each nonzero.
+ */
+function getCalldataGasUsage(data: Uint8Array) {
+  return data.filter(byte => byte === 0).length * 4 + data.filter(byte => byte !== 0).length * 16;
+}

package/src/sequencer/public_processor.ts

@@ -47,7 +47,8 @@ import { MerkleTreeOperations } from '@aztec/world-state';
 import { getVerificationKeys } from '../index.js';
 import { EmptyPublicProver } from '../prover/empty.js';
 import { PublicProver } from '../prover/index.js';
-import { PublicKernelCircuitSimulator, getPublicExecutor } from '../simulator/index.js';
+import { PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { ContractsDataSourcePublicDB, getPublicExecutor } from '../simulator/public_executor.js';
 import { WasmPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
 import { FailedTx, ProcessedTx, makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
 import { getHistoricBlockData } from './utils.js';
@@ -66,6 +67,7 @@ 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.
+   * @param newContracts - Provides access to contract bytecode for public executions.
    * @returns A new instance of a PublicProcessor.
    */
   public async create(
@@ -73,14 +75,15 @@ export class PublicProcessorFactory {
     globalVariables: GlobalVariables,
   ): Promise<PublicProcessor> {
     const blockData = await getHistoricBlockData(this.merkleTree, prevGlobalVariables);
+    const publicContractsDB = new ContractsDataSourcePublicDB(this.contractDataSource);
     return new PublicProcessor(
       this.merkleTree,
-      getPublicExecutor(this.merkleTree, this.contractDataSource, this.l1Tol2MessagesDataSource, blockData),
+      getPublicExecutor(this.merkleTree, publicContractsDB, this.l1Tol2MessagesDataSource, blockData),
       new WasmPublicKernelCircuitSimulator(),
       new EmptyPublicProver(),
-      this.contractDataSource,
       globalVariables,
       blockData,
+      publicContractsDB,
     );
   }
 }
@@ -95,9 +98,9 @@ export class PublicProcessor {
     protected publicExecutor: PublicExecutor,
     protected publicKernel: PublicKernelCircuitSimulator,
     protected publicProver: PublicProver,
-    protected contractDataSource: ContractDataSource,
     protected globalVariables: GlobalVariables,
     protected blockData: HistoricBlockData,
+    protected publicContractsDB: ContractsDataSourcePublicDB,
 
     private log = createDebugLogger('aztec:sequencer:public-processor'),
   ) {}
@@ -116,6 +119,8 @@ export class PublicProcessor {
     for (const tx of txs) {
       this.log(`Processing tx ${await tx.getTxHash()}`);
       try {
+        // add new contracts to the contracts db so that their functions may be found and called
+        await this.publicContractsDB.addNewContracts(tx);
         result.push(await this.processTx(tx));
       } catch (err) {
         this.log.warn(`Error processing tx ${await tx.getTxHash()}: ${err}`);
@@ -123,8 +128,11 @@ export class PublicProcessor {
           tx,
           error: err instanceof Error ? err : new Error('Unknown error'),
         });
+        // remove contracts on failure
+        await this.publicContractsDB.removeNewContracts(tx);
       }
     }
+
     return [result, failed];
   }
 
@@ -405,6 +413,7 @@ export class PublicProcessor {
       PublicDataRead.empty(),
       MAX_PUBLIC_DATA_READS_PER_TX,
     );
+
     // Override kernel output
     publicInputs.end.publicDataUpdateRequests = padArrayEnd(
       [

package/src/sequencer/sequencer.ts

@@ -3,8 +3,8 @@ 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 { L1ToL2MessageSource, L2Block, L2BlockSource, MerkleTreeId, Tx } from '@aztec/types';
-import { WorldStateStatus, WorldStateSynchroniser } from '@aztec/world-state';
+import { ContractDataSource, L1ToL2MessageSource, L2Block, L2BlockSource, MerkleTreeId, Tx } from '@aztec/types';
+import { WorldStateStatus, WorldStateSynchronizer } from '@aztec/world-state';
 
 import times from 'lodash.times';
 
@@ -18,7 +18,7 @@ import { PublicProcessorFactory } from './public_processor.js';
 
 /**
  * Sequencer client
- * - Wins a period of time to become the sequencer (depending on finalised protocol).
+ * - Wins a period of time to become the sequencer (depending on finalized protocol).
  * - Chooses a set of txs from the tx pool to be in the rollup.
  * - Simulate the rollup of txs.
  * - Adds proof requests to the request pool (not for this milestone).
@@ -32,17 +32,16 @@ export class Sequencer {
   private minTxsPerBLock = 1;
   private lastPublishedBlock = 0;
   private state = SequencerState.STOPPED;
-  private chainId: Fr;
-  private version: Fr;
 
   constructor(
     private publisher: L1Publisher,
     private globalsBuilder: GlobalVariableBuilder,
     private p2pClient: P2P,
-    private worldState: WorldStateSynchroniser,
+    private worldState: WorldStateSynchronizer,
     private blockBuilder: BlockBuilder,
     private l2BlockSource: L2BlockSource,
     private l1ToL2MessageSource: L1ToL2MessageSource,
+    private contractDataSource: ContractDataSource,
     private publicProcessorFactory: PublicProcessorFactory,
     config: SequencerConfig,
     private log = createDebugLogger('aztec:sequencer'),
@@ -54,8 +53,7 @@ export class Sequencer {
     if (config.minTxsPerBlock) {
       this.minTxsPerBLock = config.minTxsPerBlock;
     }
-    this.chainId = new Fr(config.chainId);
-    this.version = new Fr(config.version);
+    this.log(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
   }
 
   /**
@@ -85,6 +83,7 @@ export class Sequencer {
    */
   public restart() {
     this.log('Restarting sequencer');
+    this.publisher.restart();
     this.runningPromise!.start();
     this.state = SequencerState.IDLE;
   }
@@ -122,16 +121,16 @@ export class Sequencer {
       // Get txs to build the new block
       const pendingTxs = await this.p2pClient.getTxs();
       if (pendingTxs.length < this.minTxsPerBLock) return;
+      this.log.info(`Retrieved ${pendingTxs.length} txs from P2P pool`);
 
       // Filter out invalid txs
+      // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here
       const validTxs = await this.takeValidTxs(pendingTxs);
-      if (validTxs.length < this.minTxsPerBLock) {
-        return;
-      }
+      if (validTxs.length < this.minTxsPerBLock) return;
 
       const blockNumber = (await this.l2BlockSource.getBlockNumber()) + 1;
 
-      this.log.info(`Building block ${blockNumber} with ${validTxs.length} transactions...`);
+      this.log.info(`Building block ${blockNumber} with ${validTxs.length} transactions`);
       this.state = SequencerState.CREATING_BLOCK;
 
       const newGlobalVariables = await this.globalsBuilder.buildGlobalVariables(new Fr(blockNumber));
@@ -147,9 +146,11 @@ export class Sequencer {
         await this.p2pClient.deleteTxs(await Tx.getHashes(failedTxData));
       }
 
-      // Only accept processed transactions that are not double-spends
-      // public functions emitting nullifiers would pass earlier check but fail here
-      const processedValidTxs = await this.takeValidProcessedTxs(processedTxs);
+      // Only accept processed transactions that are not double-spends,
+      // public functions emitting nullifiers would pass earlier check but fail here.
+      // Note that we're checking all nullifiers generated in the private execution twice,
+      // we could store the ones already checked and skip them here as an optimisation.
+      const processedValidTxs = await this.takeValidTxs(processedTxs);
 
       if (processedValidTxs.length === 0) {
         this.log('No txs processed correctly to build block. Exiting');
@@ -173,8 +174,7 @@ export class Sequencer {
       await this.publishL2Block(block);
       this.log.info(`Submitted rollup block ${block.number} with ${processedValidTxs.length} transactions`);
     } catch (err) {
-      this.log.error(err);
-      this.log.error(`Rolling back world state DB`);
+      this.log.error(`Rolling back world state DB due to error assembling block`, err);
       await this.worldState.getLatest().rollback();
     }
   }
@@ -224,25 +224,27 @@ export class Sequencer {
     }
   }
 
-  // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here
-  protected async takeValidTxs(txs: Tx[]) {
-    const validTxs = [];
+  protected async takeValidTxs<T extends Tx | ProcessedTx>(txs: T[]): Promise<T[]> {
+    const validTxs: T[] = [];
     const doubleSpendTxs = [];
+    const thisBlockNullifiers: Set<bigint> = new Set();
 
     // Process txs until we get to maxTxsPerBlock, rejecting double spends in the process
     for (const tx of txs) {
-      // TODO(AD) - eventually we should add a limit to how many transactions we
-      // skip in this manner and do something more DDOS-proof (like letting the transaction fail and pay a fee).
       if (await this.isTxDoubleSpend(tx)) {
-        this.log(`Deleting double spend tx ${await tx.getTxHash()}`);
+        this.log(`Deleting double spend tx ${await Tx.getHash(tx)}`);
         doubleSpendTxs.push(tx);
         continue;
+      } else if (this.isTxDoubleSpendSameBlock(tx, thisBlockNullifiers)) {
+        // We don't drop these txs from the p2p pool immediately since they become valid
+        // again if the current block fails to be published for some reason.
+        this.log(`Skipping tx with double-spend for this same block ${await Tx.getHash(tx)}`);
+        continue;
       }
 
+      tx.data.end.newNullifiers.forEach(n => thisBlockNullifiers.add(n.toBigInt()));
       validTxs.push(tx);
-      if (validTxs.length >= this.maxTxsPerBlock) {
-        break;
-      }
+      if (validTxs.length >= this.maxTxsPerBlock) break;
     }
 
     // Make sure we remove these from the tx pool so we do not consider it again
@@ -253,13 +255,6 @@ export class Sequencer {
     return validTxs;
   }
 
-  protected async takeValidProcessedTxs(txs: ProcessedTx[]) {
-    const isDoubleSpends = await Promise.all(txs.map(async tx => await this.isTxDoubleSpend(tx as unknown as Tx)));
-    const doubleSpends = txs.filter((tx, index) => isDoubleSpends[index]).map(tx => tx.hash);
-    await this.p2pClient.deleteTxs(doubleSpends);
-    return txs.filter((tx, index) => !isDoubleSpends[index]);
-  }
-
   /**
    * Returns whether the previous block sent has been mined, and all dependencies have caught up with it.
    * @returns Boolean indicating if our dependencies are synced to the latest block.
@@ -268,6 +263,8 @@ export class Sequencer {
     const syncedBlocks = await Promise.all([
       this.worldState.status().then((s: WorldStateStatus) => s.syncedToL2Block),
       this.p2pClient.getStatus().then(s => s.syncedToL2Block),
+      this.l2BlockSource.getBlockNumber(),
+      this.l1ToL2MessageSource.getBlockNumber(),
     ]);
     const min = Math.min(...syncedBlocks);
     return min >= this.lastPublishedBlock;
@@ -307,25 +304,42 @@ export class Sequencer {
     return await this.l1ToL2MessageSource.getPendingL1ToL2Messages();
   }
 
+  /**
+   * Returns true if one of the tx nullifiers exist on the block being built.
+   * @param tx - The tx to test.
+   * @param thisBlockNullifiers - The nullifiers added so far.
+   */
+  protected isTxDoubleSpendSameBlock(tx: Tx | ProcessedTx, thisBlockNullifiers: Set<bigint>): boolean {
+    // We only consider non-empty nullifiers
+    const newNullifiers = tx.data.end.newNullifiers.filter(n => !n.isZero());
+
+    for (const nullifier of newNullifiers) {
+      if (thisBlockNullifiers.has(nullifier.toBigInt())) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Returns true if one of the transaction nullifiers exist.
    * Nullifiers prevent double spends in a private context.
    * @param tx - The transaction.
    * @returns Whether this is a problematic double spend that the L1 contract would reject.
    */
-  protected async isTxDoubleSpend(tx: Tx): Promise<boolean> {
-    // eslint-disable-next-line @typescript-eslint/await-thenable
-    for (const nullifier of tx.data.end.newNullifiers) {
-      // Skip nullifier if it's empty
-      if (nullifier.isZero()) continue;
+  protected async isTxDoubleSpend(tx: Tx | ProcessedTx): Promise<boolean> {
+    // We only consider non-empty nullifiers
+    const newNullifiers = tx.data.end.newNullifiers.filter(n => !n.isZero());
+
+    // Ditch this tx if it has a repeated nullifiers
+    const uniqNullifiers = new Set(newNullifiers.map(n => n.toBigInt()));
+    if (uniqNullifiers.size !== newNullifiers.length) return true;
+
+    for (const nullifier of newNullifiers) {
       // TODO(AD): this is an exhaustive search currently
-      if (
-        (await this.worldState.getLatest().findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer())) !==
-        undefined
-      ) {
-        // Our nullifier tree has this nullifier already - this transaction is a double spend / not well-formed
-        return true;
-      }
+      const db = this.worldState.getLatest();
+      const indexInDb = await db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+      if (indexInDb !== undefined) return true;
     }
     return false;
   }

package/src/simulator/index.ts

@@ -8,8 +8,6 @@ import {
   RootRollupPublicInputs,
 } from '@aztec/circuits.js';
 
-export { getPublicExecutor } from './public_executor.js';
-
 /**
  * Circuit simulator for the rollup circuits.
  */

package/src/simulator/public_executor.ts

@@ -6,7 +6,7 @@ import {
   PublicStateDB,
 } from '@aztec/acir-simulator';
 import { AztecAddress, CircuitsWasm, EthAddress, Fr, FunctionSelector, HistoricBlockData } from '@aztec/circuits.js';
-import { ContractDataSource, L1ToL2MessageSource, MerkleTreeId } from '@aztec/types';
+import { ContractDataSource, ExtendedContractData, L1ToL2MessageSource, MerkleTreeId, Tx } from '@aztec/types';
 import { MerkleTreeOperations, computePublicDataTreeLeafIndex } from '@aztec/world-state';
 
 /**
@@ -17,13 +17,13 @@ import { MerkleTreeOperations, computePublicDataTreeLeafIndex } from '@aztec/wor
  */
 export function getPublicExecutor(
   merkleTree: MerkleTreeOperations,
-  contractDataSource: ContractDataSource,
+  publicContractsDB: PublicContractsDB,
   l1toL2MessageSource: L1ToL2MessageSource,
   blockData: HistoricBlockData,
 ) {
   return new PublicExecutor(
     new WorldStatePublicDB(merkleTree),
-    new ContractsDataSourcePublicDB(contractDataSource),
+    publicContractsDB,
     new WorldStateDB(merkleTree, l1toL2MessageSource),
     blockData,
   );
@@ -31,17 +31,63 @@ export function getPublicExecutor(
 
 /**
  * Implements the PublicContractsDB using a ContractDataSource.
+ * Progresively records contracts in transaction as they are processed in a block.
  */
-class ContractsDataSourcePublicDB implements PublicContractsDB {
+export class ContractsDataSourcePublicDB implements PublicContractsDB {
+  cache = new Map<string, ExtendedContractData>();
+
   constructor(private db: ContractDataSource) {}
+
+  /**
+   * Add new contracts from a transaction
+   * @param tx - The transaction to add contracts from.
+   */
+  public addNewContracts(tx: Tx): Promise<void> {
+    for (const contract of tx.newContracts) {
+      const contractAddress = contract.contractData.contractAddress;
+
+      if (contractAddress.isZero()) {
+        continue;
+      }
+
+      this.cache.set(contractAddress.toString(), contract);
+    }
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Removes new contracts added from transactions
+   * @param tx - The tx's contracts to be removed
+   */
+  public removeNewContracts(tx: Tx): Promise<void> {
+    for (const contract of tx.newContracts) {
+      const contractAddress = contract.contractData.contractAddress;
+
+      if (contractAddress.isZero()) {
+        continue;
+      }
+
+      this.cache.delete(contractAddress.toString());
+    }
+    return Promise.resolve();
+  }
+
   async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
-    return (await this.db.getPublicFunction(address, selector))?.bytecode;
+    const contract = await this.#getContract(address);
+    return contract?.getPublicFunction(selector)?.bytecode;
   }
   async getIsInternal(address: AztecAddress, selector: FunctionSelector): Promise<boolean | undefined> {
-    return (await this.db.getPublicFunction(address, selector))?.isInternal;
+    const contract = await this.#getContract(address);
+    return contract?.getPublicFunction(selector)?.isInternal;
   }
   async getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined> {
-    return (await this.db.getContractData(address))?.portalContractAddress;
+    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.db.getExtendedContractData(address));
   }
 }
 

package/src/simulator/public_kernel.ts

@@ -1,4 +1,6 @@
 import { PublicKernelInputs, PublicKernelPublicInputs, simulatePublicKernelCircuit } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { elapsed } from '@aztec/foundation/timer';
 
 import { PublicKernelCircuitSimulator } from './index.js';
 
@@ -6,14 +8,24 @@ import { PublicKernelCircuitSimulator } from './index.js';
  * Implements the PublicKernelCircuitSimulator by calling the wasm implementations of the circuits.
  */
 export class WasmPublicKernelCircuitSimulator implements PublicKernelCircuitSimulator {
+  private log = createDebugLogger('aztec:public-kernel-simulator');
+
   /**
    * Simulates the public kernel circuit (with a previous private kernel circuit run) from its inputs.
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
-  public publicKernelCircuitPrivateInput(input: PublicKernelInputs): Promise<PublicKernelPublicInputs> {
+  public async publicKernelCircuitPrivateInput(input: PublicKernelInputs): Promise<PublicKernelPublicInputs> {
     if (!input.previousKernel.publicInputs.isPrivate) throw new Error(`Expected private kernel previous inputs`);
-    return simulatePublicKernelCircuit(input);
+    const [time, result] = await elapsed(() => simulatePublicKernelCircuit(input));
+    this.log(`Simulated public kernel circuit with private input`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'public-kernel-private-input',
+      duration: time.ms(),
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    });
+    return result;
   }
 
   /**
@@ -21,8 +33,16 @@ export class WasmPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
-  publicKernelCircuitNonFirstIteration(input: PublicKernelInputs): Promise<PublicKernelPublicInputs> {
+  public async publicKernelCircuitNonFirstIteration(input: PublicKernelInputs): Promise<PublicKernelPublicInputs> {
     if (input.previousKernel.publicInputs.isPrivate) throw new Error(`Expected public kernel previous inputs`);
-    return simulatePublicKernelCircuit(input);
+    const [time, result] = await elapsed(() => simulatePublicKernelCircuit(input));
+    this.log(`Simulated public kernel circuit non-first iteration`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'public-kernel-non-first-iteration',
+      duration: time.ms(),
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    });
+    return result;
   }
 }