@aztec/simulator 0.69.0 → 0.69.1-devnet

package/src/client/view_data_oracle.ts

@@ -2,7 +2,7 @@ import {
   type AuthWitness,
   type AztecNode,
   type CompleteAddress,
-  MerkleTreeId,
+  type MerkleTreeId,
   type NoteStatus,
   type NullifierMembershipWitness,
   type PublicDataWitness,
@@ -72,24 +72,8 @@ export class ViewDataOracle extends TypedOracle {
    * @param leafValue - The leaf value
    * @returns The index and sibling path concatenated [index, sibling_path]
    */
-  public override async getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
-    const index = await this.db.findLeafIndex(blockNumber, treeId, leafValue);
-    if (!index) {
-      throw new Error(`Leaf value: ${leafValue} not found in ${MerkleTreeId[treeId]}`);
-    }
-    const siblingPath = await this.db.getSiblingPath(blockNumber, treeId, index);
-    return [new Fr(index), ...siblingPath];
-  }
-
-  /**
-   * Fetches a sibling path at a given block and index from a tree specified by `treeId`.
-   * @param blockNumber - The block number at which to get the membership witness.
-   * @param treeId - Id of the tree to get the sibling path from.
-   * @param leafIndex - Index of the leaf to get sibling path for
-   * @returns The sibling path.
-   */
-  public override getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr): Promise<Fr[]> {
-    return this.db.getSiblingPath(blockNumber, treeId, leafIndex.toBigInt());
+  public override getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
+    return this.db.getMembershipWitness(blockNumber, treeId, leafValue);
   }
 
   /**
@@ -290,6 +274,10 @@ export class ViewDataOracle extends TypedOracle {
   }
 
   public override debugLog(message: string, fields: Fr[]): void {
+    // TODO(#10558) Remove this check once the debug log is fixed
+    if (message.startsWith('Context.note_hashes, after pushing new note hash:')) {
+      return;
+    }
     this.log.verbose(`${applyStringFormatting(message, fields)}`, { module: `${this.log.module}:debug_log` });
   }
 
@@ -321,4 +309,24 @@ export class ViewDataOracle extends TypedOracle {
 
     await this.db.removeNullifiedNotes(this.contractAddress);
   }
+
+  public override store(contract: AztecAddress, key: Fr, values: Fr[]): Promise<void> {
+    if (!contract.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check check that this.contractAddress is allowed to process notes for contract
+      throw new Error(
+        `Contract address ${contract} does not match the oracle's contract address ${this.contractAddress}`,
+      );
+    }
+    return this.db.store(this.contractAddress, key, values);
+  }
+
+  public override load(contract: AztecAddress, key: Fr): Promise<Fr[] | null> {
+    if (!contract.equals(this.contractAddress)) {
+      // TODO(#10727): instead of this check check that this.contractAddress is allowed to process notes for contract
+      throw new Error(
+        `Contract address ${contract} does not match the oracle's contract address ${this.contractAddress}`,
+      );
+    }
+    return this.db.load(this.contractAddress, key);
+  }
 }

package/src/providers/acvm_wasm_with_blobs.ts

@@ -1,4 +1,4 @@
-import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types';
+import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/server';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import { executeCircuit } from '@noir-lang/acvm_js';

package/src/public/fixtures/index.ts

@@ -324,7 +324,7 @@ export class MockedAvmTestContractDataSource implements ContractDataSource {
     return Promise.resolve(this.fnName);
   }
 
-  registerContractFunctionNames(_address: AztecAddress, _names: Record<string, string>): Promise<void> {
+  registerContractFunctionSignatures(_address: AztecAddress, _signatures: string[]): Promise<void> {
     return Promise.resolve();
   }
 }

package/src/public/public_processor.ts

@@ -136,29 +136,132 @@ export class PublicProcessor implements Traceable {
    * @returns The list of processed txs with their circuit simulation outputs.
    */
   public async process(
-    txs: Tx[],
-    maxTransactions = txs.length,
-    txValidator?: TxValidator<ProcessedTx>,
-    deadline?: Date,
+    txs: Iterable<Tx>,
+    limits: {
+      maxTransactions?: number;
+      maxBlockSize?: number;
+      maxBlockGas?: Gas;
+      deadline?: Date;
+    } = {},
+    validators: {
+      preprocessValidator?: TxValidator<Tx>;
+      postprocessValidator?: TxValidator<ProcessedTx>;
+      nullifierCache?: { addNullifiers: (nullifiers: Buffer[]) => void };
+    } = {},
   ): Promise<[ProcessedTx[], FailedTx[], NestedProcessReturnValues[]]> {
-    // The processor modifies the tx objects in place, so we need to clone them.
-    txs = txs.map(tx => Tx.clone(tx));
+    const { maxTransactions, maxBlockSize, deadline, maxBlockGas } = limits;
+    const { preprocessValidator, postprocessValidator, nullifierCache } = validators;
     const result: ProcessedTx[] = [];
     const failed: FailedTx[] = [];
-    let returns: NestedProcessReturnValues[] = [];
-    let totalGas = new Gas(0, 0);
     const timer = new Timer();
 
-    for (const tx of txs) {
-      // only process up to the limit of the block
-      if (result.length >= maxTransactions) {
+    let totalSizeInBytes = 0;
+    let returns: NestedProcessReturnValues[] = [];
+    let totalPublicGas = new Gas(0, 0);
+    let totalBlockGas = new Gas(0, 0);
+
+    for (const origTx of txs) {
+      // Only process up to the max tx limit
+      if (maxTransactions !== undefined && result.length >= maxTransactions) {
+        this.log.debug(`Stopping tx processing due to reaching the max tx limit.`);
         break;
       }
+
+      // Bail if we've hit the deadline
+      if (deadline && this.dateProvider.now() > +deadline) {
+        this.log.warn(`Stopping tx processing due to timeout.`);
+        break;
+      }
+
+      // Skip this tx if it'd exceed max block size
+      const txHash = origTx.getTxHash().toString();
+      const preTxSizeInBytes = origTx.getEstimatedPrivateTxEffectsSize();
+      if (maxBlockSize !== undefined && totalSizeInBytes + preTxSizeInBytes > maxBlockSize) {
+        this.log.warn(`Skipping processing of tx ${txHash} sized ${preTxSizeInBytes} bytes due to block size limit`, {
+          txHash,
+          sizeInBytes: preTxSizeInBytes,
+          totalSizeInBytes,
+          maxBlockSize,
+        });
+        continue;
+      }
+
+      // Skip this tx if its gas limit would exceed the block gas limit
+      const txGasLimit = origTx.data.constants.txContext.gasSettings.gasLimits;
+      if (maxBlockGas !== undefined && totalBlockGas.add(txGasLimit).gtAny(maxBlockGas)) {
+        this.log.warn(`Skipping processing of tx ${txHash} due to block gas limit`, {
+          txHash,
+          txGasLimit,
+          totalBlockGas,
+          maxBlockGas,
+        });
+        continue;
+      }
+
+      // The processor modifies the tx objects in place, so we need to clone them.
+      const tx = Tx.clone(origTx);
+
+      // We validate the tx before processing it, to avoid unnecessary work.
+      if (preprocessValidator) {
+        const result = await preprocessValidator.validateTx(tx);
+        if (result.result === 'invalid') {
+          const reason = result.reason.join(', ');
+          this.log.warn(`Rejecting tx ${tx.getTxHash().toString()} due to pre-process validation fail: ${reason}`);
+          failed.push({ tx, error: new Error(`Tx failed preprocess validation: ${reason}`) });
+          returns.push(new NestedProcessReturnValues([]));
+          continue;
+        } else if (result.result === 'skipped') {
+          const reason = result.reason.join(', ');
+          this.log.warn(`Skipping tx ${tx.getTxHash().toString()} due to pre-process validation: ${reason}`);
+          returns.push(new NestedProcessReturnValues([]));
+          continue;
+        } else {
+          this.log.trace(`Tx ${tx.getTxHash().toString()} is valid before processing.`);
+        }
+      }
+
       try {
-        const [processedTx, returnValues] = await this.processTx(tx, txValidator, deadline);
+        const [processedTx, returnValues] = await this.processTx(tx, deadline);
+
+        // If the actual size of this tx would exceed block size, skip it
+        const txSize = processedTx.txEffect.getDASize();
+        if (maxBlockSize !== undefined && totalSizeInBytes + txSize > maxBlockSize) {
+          this.log.warn(`Skipping processed tx ${txHash} sized ${txSize} due to max block size.`, {
+            txHash,
+            sizeInBytes: txSize,
+            totalSizeInBytes,
+            maxBlockSize,
+          });
+          continue;
+        }
+
+        // Re-validate the transaction
+        if (postprocessValidator) {
+          // 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 optimization.
+          // TODO(palla/txs): Can we get into this case? AVM validates this. We should be able to remove it.
+          const result = await postprocessValidator.validateTx(processedTx);
+          if (result.result !== 'valid') {
+            const reason = result.reason.join(', ');
+            this.log.error(`Rejecting tx ${processedTx.hash} after processing: ${reason}.`);
+            failed.push({ tx, error: new Error(`Tx failed post-process validation: ${reason}`) });
+            continue;
+          } else {
+            this.log.trace(`Tx ${tx.getTxHash().toString()} is valid post processing.`);
+          }
+        }
+
+        // Otherwise, commit tx state for the next tx to be processed
+        await this.commitTxState(processedTx);
+        nullifierCache?.addNullifiers(processedTx.txEffect.nullifiers.map(n => n.toBuffer()));
         result.push(processedTx);
         returns = returns.concat(returnValues);
-        totalGas = totalGas.add(processedTx.gasUsed.publicGas);
+
+        totalPublicGas = totalPublicGas.add(processedTx.gasUsed.publicGas);
+        totalBlockGas = totalBlockGas.add(processedTx.gasUsed.totalGas);
+        totalSizeInBytes += txSize;
       } catch (err: any) {
         if (err?.name === 'PublicProcessorTimeoutError') {
           this.log.warn(`Stopping tx processing due to timeout.`);
@@ -173,18 +276,22 @@ export class PublicProcessor implements Traceable {
     }
 
     const duration = timer.s();
-    const rate = duration > 0 ? totalGas.l2Gas / duration : 0;
-    this.metrics.recordAllTxs(totalGas, rate);
+    const rate = duration > 0 ? totalPublicGas.l2Gas / duration : 0;
+    this.metrics.recordAllTxs(totalPublicGas, rate);
+
+    this.log.info(`Processed ${result.length} succesful txs and ${failed.length} txs in ${duration}ms`, {
+      duration,
+      rate,
+      totalPublicGas,
+      totalBlockGas,
+      totalSizeInBytes,
+    });
 
     return [result, failed, returns];
   }
 
-  @trackSpan('PublicProcessor.processTx', tx => ({ [Attributes.TX_HASH]: tx.tryGetTxHash()?.toString() }))
-  private async processTx(
-    tx: Tx,
-    txValidator?: TxValidator<ProcessedTx>,
-    deadline?: Date,
-  ): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
+  @trackSpan('PublicProcessor.processTx', tx => ({ [Attributes.TX_HASH]: tx.getTxHash().toString() }))
+  private async processTx(tx: Tx, deadline?: Date): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     const [time, [processedTx, returnValues]] = await elapsed(() => this.processTxWithinDeadline(tx, deadline));
 
     this.log.verbose(
@@ -208,20 +315,14 @@ export class PublicProcessor implements Traceable {
       },
     );
 
+    return [processedTx, returnValues ?? []];
+  }
+
+  private async commitTxState(processedTx: ProcessedTx, txValidator?: TxValidator<ProcessedTx>): Promise<void> {
     // Commit the state updates from this transaction
+    // TODO(palla/txs): It seems like this doesn't do anything...?
     await this.worldStateDB.commit();
 
-    // Re-validate the transaction
-    if (txValidator) {
-      // 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 optimization.
-      const [_, invalid] = await txValidator.validateTxs([processedTx]);
-      if (invalid.length) {
-        throw new Error(`Transaction ${invalid[0].hash} invalid after processing public functions`);
-      }
-    }
     // Update the state so that the next tx in the loop has the correct .startState
     // NB: before this change, all .startStates were actually incorrect, but the issue was never caught because we either:
     // a) had only 1 tx with public calls per block, so this loop had len 1
@@ -255,8 +356,6 @@ export class PublicProcessor implements Traceable {
     );
     const treeInsertionEnd = process.hrtime.bigint();
     this.metrics.recordTreeInsertions(Number(treeInsertionEnd - treeInsertionStart) / 1_000);
-
-    return [processedTx, returnValues ?? []];
   }
 
   /** Processes the given tx within deadline. Returns timeout if deadline is hit. */

package/src/public/public_tx_context.ts

@@ -7,7 +7,7 @@ import {
   type SimulationError,
   type Tx,
   TxExecutionPhase,
-  TxHash,
+  type TxHash,
 } from '@aztec/circuit-types';
 import {
   AvmCircuitInputs,
@@ -61,6 +61,7 @@ export class PublicTxContext {
   public avmProvingRequest: AvmProvingRequest | undefined; // FIXME(dbanks12): remove
 
   constructor(
+    public readonly txHash: TxHash,
     public readonly state: PhaseStateManager,
     private readonly globalVariables: GlobalVariables,
     private readonly startStateReference: StateReference,
@@ -103,12 +104,14 @@ export class PublicTxContext {
       previousAccumulatedDataArrayLengths,
     );
 
+    const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
+
     // Transaction level state manager that will be forked for revertible phases.
     const txStateManager = await AvmPersistableStateManager.create(
       worldStateDB,
       enqueuedCallTrace,
       doMerkleOperations,
-      fetchTxHash(nonRevertibleAccumulatedDataFromPrivate),
+      firstNullifier,
     );
 
     const gasSettings = tx.data.constants.txContext.gasSettings;
@@ -117,6 +120,7 @@ export class PublicTxContext {
     const gasAllocatedToPublic = applyMaxToAvailableGas(gasSettings.gasLimits.sub(gasUsedByPrivate));
 
     return new PublicTxContext(
+      tx.getTxHash(),
       new PhaseStateManager(txStateManager),
       globalVariables,
       await db.getStateReference(),
@@ -188,14 +192,6 @@ export class PublicTxContext {
     return this.revertCode;
   }
 
-  /**
-   * Construct & return transaction hash.
-   * @returns The transaction's hash.
-   */
-  getTxHash(): TxHash {
-    return fetchTxHash(this.nonRevertibleAccumulatedDataFromPrivate);
-  }
-
   /**
    * Are there any call requests for the speciiied phase?
    */
@@ -452,12 +448,3 @@ function applyMaxToAvailableGas(availableGas: Gas) {
     /*l2Gas=*/ Math.min(availableGas.l2Gas, MAX_L2_GAS_PER_TX_PUBLIC_PORTION),
   );
 }
-
-function fetchTxHash(nonRevertibleAccumulatedData: PrivateToPublicAccumulatedData): TxHash {
-  // Private kernel functions are executed client side and for this reason tx hash is already set as first nullifier
-  const firstNullifier = nonRevertibleAccumulatedData.nullifiers[0];
-  if (!firstNullifier || firstNullifier.isZero()) {
-    throw new Error(`Cannot get tx hash since first nullifier is missing`);
-  }
-  return new TxHash(firstNullifier.toBuffer());
-}

package/src/public/public_tx_simulator.ts

@@ -219,8 +219,8 @@ export class PublicTxSimulator {
     const callRequests = context.getCallRequestsForPhase(phase);
     const executionRequests = context.getExecutionRequestsForPhase(phase);
 
-    this.log.debug(`Processing phase ${TxExecutionPhase[phase]} for tx ${context.getTxHash()}`, {
-      txHash: context.getTxHash().toString(),
+    this.log.debug(`Processing phase ${TxExecutionPhase[phase]} for tx ${context.txHash}`, {
+      txHash: context.txHash.toString(),
       phase: TxExecutionPhase[phase],
       callRequests: callRequests.length,
       executionRequests: executionRequests.length,
@@ -266,7 +266,7 @@ export class PublicTxSimulator {
    * @returns The result of execution.
    */
   @trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, _callRequest, executionRequest) => ({
-    [Attributes.TX_HASH]: context.getTxHash().toString(),
+    [Attributes.TX_HASH]: context.txHash.toString(),
     [Attributes.TARGET_ADDRESS]: executionRequest.callContext.contractAddress.toString(),
     [Attributes.SENDER_ADDRESS]: executionRequest.callContext.msgSender.toString(),
     [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString(),