@aztec/prover-client 0.43.0 → 0.45.0

package/src/orchestrator/orchestrator.ts

@@ -9,6 +9,7 @@ import {
   type TxEffect,
   makeEmptyProcessedTx,
   makePaddingProcessedTx,
+  mapPublicKernelToCircuitName,
   toTxEffect,
 } from '@aztec/circuit-types';
 import {
@@ -20,6 +21,7 @@ import {
   type PublicInputsAndRecursiveProof,
   type ServerCircuitProver,
 } from '@aztec/circuit-types/interfaces';
+import { type CircuitName } from '@aztec/circuit-types/stats';
 import {
   AGGREGATION_OBJECT_LENGTH,
   AvmCircuitInputs,
@@ -53,6 +55,7 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { BufferReader, type Tuple } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
+import { Attributes, type TelemetryClient, type Tracer, trackSpan, wrapCallbackInSpan } from '@aztec/telemetry-client';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
 import { inspect } from 'util';
@@ -91,7 +94,16 @@ export class ProvingOrchestrator {
   private pendingProvingJobs: AbortController[] = [];
   private paddingTx: PaddingProcessedTx | undefined = undefined;
 
-  constructor(private db: MerkleTreeOperations, private prover: ServerCircuitProver, private initialHeader?: Header) {}
+  public readonly tracer: Tracer;
+
+  constructor(
+    private db: MerkleTreeOperations,
+    private prover: ServerCircuitProver,
+    telemetryClient: TelemetryClient,
+    private initialHeader?: Header,
+  ) {
+    this.tracer = telemetryClient.getTracer('ProvingOrchestrator');
+  }
 
   /**
    * Resets the orchestrator's cached padding tx.
@@ -108,6 +120,10 @@ export class ProvingOrchestrator {
    * @param verificationKeys - The private kernel verification keys
    * @returns A proving ticket, containing a promise notifying of proving completion
    */
+  @trackSpan('ProvingOrchestrator.startNewBlock', (numTxs, globalVariables) => ({
+    [Attributes.BLOCK_SIZE]: numTxs,
+    [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber(),
+  }))
   public async startNewBlock(
     numTxs: number,
     globalVariables: GlobalVariables,
@@ -119,10 +135,8 @@ export class ProvingOrchestrator {
       this.initialHeader = await this.db.buildInitialHeader();
     }
 
-    // Check that the length of the array of txs is a power of two
-    // See https://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2
-    if (!Number.isInteger(numTxs) || numTxs < 2 || (numTxs & (numTxs - 1)) !== 0) {
-      throw new Error(`Length of txs for the block should be a power of two and at least two (got ${numTxs})`);
+    if (!Number.isInteger(numTxs) || numTxs < 2) {
+      throw new Error(`Length of txs for the block should be at least two (got ${numTxs})`);
     }
     // Cancel any currently proving block before starting a new one
     this.cancelBlock();
@@ -193,6 +207,9 @@ export class ProvingOrchestrator {
    * The interface to add a simulated transaction to the scheduler
    * @param tx - The transaction to be proven
    */
+  @trackSpan('ProvingOrchestrator.addNewTx', tx => ({
+    [Attributes.TX_HASH]: tx.hash.toString(),
+  }))
   public async addNewTx(tx: ProcessedTx): Promise<void> {
     if (!this.provingState) {
       throw new Error(`Invalid proving state, call startNewBlock before adding transactions`);
@@ -206,13 +223,29 @@ export class ProvingOrchestrator {
 
     logger.info(`Received transaction: ${tx.hash}`);
 
+    if (tx.isEmpty) {
+      logger.warn(`Ignoring empty transaction ${tx.hash} - it will not be added to this block`);
+      return;
+    }
+
     const [inputs, treeSnapshots] = await this.prepareTransaction(tx, this.provingState);
     this.enqueueFirstProof(inputs, treeSnapshots, tx, this.provingState);
   }
 
   /**
-   * Marks the block as full and pads it to the full power of 2 block size, no more transactions will be accepted.
+   * Marks the block as full and pads it if required, no more transactions will be accepted.
    */
+  @trackSpan('ProvingOrchestrator.setBlockCompleted', function () {
+    if (!this.provingState) {
+      return {};
+    }
+
+    return {
+      [Attributes.BLOCK_NUMBER]: this.provingState!.globalVariables.blockNumber.toNumber(),
+      [Attributes.BLOCK_SIZE]: this.provingState!.totalNumTxs,
+      [Attributes.BLOCK_TXS_COUNT]: this.provingState!.transactionsReceived,
+    };
+  })
   public async setBlockCompleted() {
     if (!this.provingState) {
       throw new Error(`Invalid proving state, call startNewBlock before adding transactions or completing the block`);
@@ -222,10 +255,15 @@ export class ProvingOrchestrator {
     const paddingTxCount = this.provingState.totalNumTxs - this.provingState.transactionsReceived;
     if (paddingTxCount === 0) {
       return;
+    } else if (this.provingState.totalNumTxs > 2) {
+      throw new Error(`Block not ready for completion: expecting ${paddingTxCount} more transactions.`);
     }
 
     logger.debug(`Padding rollup with ${paddingTxCount} empty transactions`);
     // Make an empty padding transaction
+    // Required for:
+    // 0 (when we want an empty block, largely for testing), or
+    // 1 (we need to pad with one tx as all rollup circuits require a pair of inputs) txs
     // Insert it into the tree the required number of times to get all of the
     // base rollup inputs
     // Then enqueue the proving of all the transactions
@@ -264,18 +302,26 @@ export class ProvingOrchestrator {
     logger.debug(`Enqueuing deferred proving for padding txs to enqueue ${txInputs.length} paddings`);
     this.deferredProving(
       provingState,
-      signal =>
-        this.prover.getEmptyPrivateKernelProof(
-          {
-            // Chain id and version should not change even if the proving state does, so it's safe to use them for the padding tx
-            // which gets cached across multiple runs of the orchestrator with different proving states. If they were to change,
-            // we'd have to clear out the paddingTx here and regenerate it when they do.
-            chainId: unprovenPaddingTx.data.constants.txContext.chainId,
-            version: unprovenPaddingTx.data.constants.txContext.version,
-            header: unprovenPaddingTx.data.constants.historicalHeader,
-          },
-          signal,
-        ),
+      wrapCallbackInSpan(
+        this.tracer,
+        'ProvingOrchestrator.prover.getEmptyPrivateKernelProof',
+        {
+          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'private-kernel-empty' as CircuitName,
+        },
+        signal =>
+          this.prover.getEmptyPrivateKernelProof(
+            {
+              // Chain id and version should not change even if the proving state does, so it's safe to use them for the padding tx
+              // which gets cached across multiple runs of the orchestrator with different proving states. If they were to change,
+              // we'd have to clear out the paddingTx here and regenerate it when they do.
+              chainId: unprovenPaddingTx.data.constants.txContext.chainId,
+              version: unprovenPaddingTx.data.constants.txContext.version,
+              header: unprovenPaddingTx.data.constants.historicalHeader,
+            },
+            signal,
+          ),
+      ),
       result => {
         logger.debug(`Completed proof for padding tx, now enqueuing ${txInputs.length} padding txs`);
         this.paddingTx = makePaddingProcessedTx(result);
@@ -319,6 +365,13 @@ export class ProvingOrchestrator {
    * Performs the final tree update for the block and returns the fully proven block.
    * @returns The fully proven block and proof.
    */
+  @trackSpan('ProvingOrchestrator.finaliseBlock', function () {
+    return {
+      [Attributes.BLOCK_NUMBER]: this.provingState!.globalVariables.blockNumber.toNumber(),
+      [Attributes.BLOCK_TXS_COUNT]: this.provingState!.transactionsReceived,
+      [Attributes.BLOCK_SIZE]: this.provingState!.totalNumTxs,
+    };
+  })
   public async finaliseBlock() {
     try {
       if (
@@ -496,6 +549,9 @@ export class ProvingOrchestrator {
   }
 
   // Updates the merkle trees for a transaction. The first enqueued job for a transaction
+  @trackSpan('ProvingOrchestrator.prepareBaseRollupInputs', (_, tx) => ({
+    [Attributes.TX_HASH]: tx.hash.toString(),
+  }))
   private async prepareBaseRollupInputs(
     provingState: ProvingState | undefined,
     tx: ProcessedTx,
@@ -531,13 +587,18 @@ export class ProvingOrchestrator {
       VerificationKeyAsFields,
     ],
   ) {
-    const mergeLevel = currentLevel - 1n;
-    const indexWithinMergeLevel = currentIndex >> 1n;
+    const [mergeLevel, indexWithinMergeLevel, indexWithinMerge] = provingState.findMergeLevel(
+      currentLevel,
+      currentIndex,
+    );
     const mergeIndex = 2n ** mergeLevel - 1n + indexWithinMergeLevel;
-    const subscript = Number(mergeIndex);
-    const indexWithinMerge = Number(currentIndex & 1n);
-    const ready = provingState.storeMergeInputs(mergeInputs, indexWithinMerge, subscript);
-    return { ready, indexWithinMergeLevel, mergeLevel, mergeInputData: provingState.getMergeInputs(subscript) };
+    const ready = provingState.storeMergeInputs(mergeInputs, Number(indexWithinMerge), Number(mergeIndex));
+    return {
+      ready,
+      indexWithinMergeLevel,
+      mergeLevel,
+      mergeInputData: provingState.getMergeInputs(Number(mergeIndex)),
+    };
   }
 
   // Executes the base rollup circuit and stored the output as intermediate state for the parent merge/root circuit
@@ -593,7 +654,16 @@ export class ProvingOrchestrator {
 
     this.deferredProving(
       provingState,
-      signal => this.prover.getBaseRollupProof(tx.baseRollupInputs, signal),
+      wrapCallbackInSpan(
+        this.tracer,
+        'ProvingOrchestrator.prover.getBaseRollupProof',
+        {
+          [Attributes.TX_HASH]: tx.processedTx.hash.toString(),
+          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-rollup' as CircuitName,
+        },
+        signal => this.prover.getBaseRollupProof(tx.baseRollupInputs, signal),
+      ),
       result => {
         logger.debug(`Completed proof for base rollup for tx ${tx.processedTx.hash.toString()}`);
         validatePartialState(result.inputs.end, tx.treeSnapshots);
@@ -622,7 +692,15 @@ export class ProvingOrchestrator {
 
     this.deferredProving(
       provingState,
-      signal => this.prover.getMergeRollupProof(inputs, signal),
+      wrapCallbackInSpan(
+        this.tracer,
+        'ProvingOrchestrator.prover.getMergeRollupProof',
+        {
+          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'merge-rollup' as CircuitName,
+        },
+        signal => this.prover.getMergeRollupProof(inputs, signal),
+      ),
       result => {
         this.storeAndExecuteNextMergeLevel(provingState, level, index, [
           result.inputs,
@@ -658,7 +736,15 @@ export class ProvingOrchestrator {
 
     this.deferredProving(
       provingState,
-      signal => this.prover.getRootRollupProof(inputs, signal),
+      wrapCallbackInSpan(
+        this.tracer,
+        'ProvingOrchestrator.prover.getRootRollupProof',
+        {
+          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-rollup' as CircuitName,
+        },
+        signal => this.prover.getRootRollupProof(inputs, signal),
+      ),
       result => {
         provingState.rootRollupPublicInputs = result.inputs;
         provingState.finalAggregationObject = extractAggregationObject(
@@ -680,7 +766,15 @@ export class ProvingOrchestrator {
   private enqueueBaseParityCircuit(provingState: ProvingState, inputs: BaseParityInputs, index: number) {
     this.deferredProving(
       provingState,
-      signal => this.prover.getBaseParityProof(inputs, signal),
+      wrapCallbackInSpan(
+        this.tracer,
+        'ProvingOrchestrator.prover.getBaseParityProof',
+        {
+          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-parity' as CircuitName,
+        },
+        signal => this.prover.getBaseParityProof(inputs, signal),
+      ),
       rootInput => {
         provingState.setRootParityInputs(rootInput, index);
         if (provingState.areRootParityInputsReady()) {
@@ -701,7 +795,15 @@ export class ProvingOrchestrator {
   private enqueueRootParityCircuit(provingState: ProvingState | undefined, inputs: RootParityInputs) {
     this.deferredProving(
       provingState,
-      signal => this.prover.getRootParityProof(inputs, signal),
+      wrapCallbackInSpan(
+        this.tracer,
+        'ProvingOrchestrator.prover.getRootParityProof',
+        {
+          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-parity' as CircuitName,
+        },
+        signal => this.prover.getRootParityProof(inputs, signal),
+      ),
       async rootInput => {
         provingState!.finalRootParityInput = rootInput;
         await this.checkAndEnqueueRootRollup(provingState);
@@ -770,25 +872,34 @@ export class ProvingOrchestrator {
     if (publicFunction.vmRequest) {
       // This function tries to do AVM proving. If there is a failure, it fakes the proof unless AVM_PROVING_STRICT is defined.
       // Nothing downstream depends on the AVM proof yet. So having this mode lets us incrementally build the AVM circuit.
-      const doAvmProving = async (signal: AbortSignal) => {
-        const inputs: AvmCircuitInputs = new AvmCircuitInputs(
-          publicFunction.vmRequest!.bytecode,
-          publicFunction.vmRequest!.calldata,
-          publicFunction.vmRequest!.kernelRequest.inputs.publicCall.callStackItem.publicInputs,
-          publicFunction.vmRequest!.avmHints,
-        );
-        try {
-          return await this.prover.getAvmProof(inputs, signal);
-        } catch (err) {
-          if (process.env.AVM_PROVING_STRICT) {
-            throw err;
-          } else {
-            logger.warn(`Error thrown when proving AVM circuit: ${err}`);
-            logger.warn(`AVM_PROVING_STRICT is off, faking AVM proof and carrying on...`);
-            return { proof: makeEmptyProof(), verificationKey: VerificationKeyData.makeFake() };
+      const doAvmProving = wrapCallbackInSpan(
+        this.tracer,
+        'ProvingOrchestrator.prover.getAvmProof',
+        {
+          [Attributes.TX_HASH]: txProvingState.processedTx.hash.toString(),
+          [Attributes.APP_CIRCUIT_NAME]: publicFunction.vmRequest!.functionName,
+        },
+        async (signal: AbortSignal) => {
+          const inputs: AvmCircuitInputs = new AvmCircuitInputs(
+            publicFunction.vmRequest!.functionName,
+            publicFunction.vmRequest!.bytecode,
+            publicFunction.vmRequest!.calldata,
+            publicFunction.vmRequest!.kernelRequest.inputs.publicCall.callStackItem.publicInputs,
+            publicFunction.vmRequest!.avmHints,
+          );
+          try {
+            return await this.prover.getAvmProof(inputs, signal);
+          } catch (err) {
+            if (process.env.AVM_PROVING_STRICT) {
+              throw err;
+            } else {
+              logger.warn(`Error thrown when proving AVM circuit: ${err}`);
+              logger.warn(`AVM_PROVING_STRICT is off, faking AVM proof and carrying on...`);
+              return { proof: makeEmptyProof(), verificationKey: VerificationKeyData.makeFake() };
+            }
           }
-        }
-      };
+        },
+      );
       this.deferredProving(provingState, doAvmProving, proofAndVk => {
         logger.debug(`Proven VM for function index ${functionIndex} of tx index ${txIndex}`);
         this.checkAndEnqueuePublicKernel(provingState, txIndex, functionIndex, proofAndVk.proof);
@@ -834,13 +945,25 @@ export class ProvingOrchestrator {
 
     this.deferredProving(
       provingState,
-      (signal): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs | PublicKernelCircuitPublicInputs>> => {
-        if (request.type === PublicKernelType.TAIL) {
-          return this.prover.getPublicTailProof(request, signal);
-        } else {
-          return this.prover.getPublicKernelProof(request, signal);
-        }
-      },
+      wrapCallbackInSpan(
+        this.tracer,
+        request.type === PublicKernelType.TAIL
+          ? 'ProvingOrchestrator.prover.getPublicTailProof'
+          : 'ProvingOrchestrator.prover.getPublicKernelProof',
+        {
+          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: mapPublicKernelToCircuitName(request.type),
+        },
+        (
+          signal,
+        ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs | PublicKernelCircuitPublicInputs>> => {
+          if (request.type === PublicKernelType.TAIL) {
+            return this.prover.getPublicTailProof(request, signal);
+          } else {
+            return this.prover.getPublicKernelProof(request, signal);
+          }
+        },
+      ),
       result => {
         const nextKernelRequest = txProvingState.getNextPublicKernelFromKernelProof(
           functionIndex,
@@ -879,5 +1002,9 @@ function extractAggregationObject(proof: Proof, numPublicInputs: number): Fr[] {
     Fr.SIZE_IN_BYTES * (numPublicInputs - AGGREGATION_OBJECT_LENGTH),
     Fr.SIZE_IN_BYTES * numPublicInputs,
   );
+  // TODO(#7159): Remove the following workaround
+  if (buffer.length === 0) {
+    return Array.from({ length: AGGREGATION_OBJECT_LENGTH }, () => Fr.ZERO);
+  }
   return BufferReader.asReader(buffer).readArray(AGGREGATION_OBJECT_LENGTH, Fr);
 }

package/src/orchestrator/proving-state.ts

@@ -71,6 +71,32 @@ export class ProvingState {
     return BigInt(Math.ceil(Math.log2(this.totalNumTxs)) - 1);
   }
 
+  // Calculates the index and level of the parent rollup circuit
+  // Based on tree implementation in unbalanced_tree.ts -> batchInsert()
+  public findMergeLevel(currentLevel: bigint, currentIndex: bigint) {
+    const moveUpMergeLevel = (levelSize: number, index: bigint, nodeToShift: boolean) => {
+      levelSize /= 2;
+      if (levelSize & 1) {
+        [levelSize, nodeToShift] = nodeToShift ? [levelSize + 1, false] : [levelSize - 1, true];
+      }
+      index >>= 1n;
+      return { thisLevelSize: levelSize, thisIndex: index, shiftUp: nodeToShift };
+    };
+    let [thisLevelSize, shiftUp] = this.totalNumTxs & 1 ? [this.totalNumTxs - 1, true] : [this.totalNumTxs, false];
+    const maxLevel = this.numMergeLevels + 1n;
+    let placeholder = currentIndex;
+    for (let i = 0; i < maxLevel - currentLevel; i++) {
+      ({ thisLevelSize, thisIndex: placeholder, shiftUp } = moveUpMergeLevel(thisLevelSize, placeholder, shiftUp));
+    }
+    let thisIndex = currentIndex;
+    let mergeLevel = currentLevel;
+    while (thisIndex >= thisLevelSize && mergeLevel != 0n) {
+      mergeLevel -= 1n;
+      ({ thisLevelSize, thisIndex, shiftUp } = moveUpMergeLevel(thisLevelSize, thisIndex, shiftUp));
+    }
+    return [mergeLevel - 1n, thisIndex >> 1n, thisIndex & 1n];
+  }
+
   // Adds a transaction to the proving state, returns it's index
   // Will update the proving life cycle if this is the last transaction
   public addNewTx(tx: TxProvingState) {

package/src/tx-prover/tx-prover.ts

@@ -9,6 +9,7 @@ import {
 } from '@aztec/circuit-types/interfaces';
 import { type Fr, type GlobalVariables, type Header, type VerificationKeys } from '@aztec/circuits.js';
 import { NativeACVMSimulator } from '@aztec/simulator';
+import { type TelemetryClient } from '@aztec/telemetry-client';
 import { type WorldStateSynchronizer } from '@aztec/world-state';
 
 import { type ProverClientConfig } from '../config.js';
@@ -28,11 +29,17 @@ export class TxProver implements ProverClient {
     private config: ProverClientConfig,
     private worldStateSynchronizer: WorldStateSynchronizer,
     private vks: VerificationKeys,
+    private telemetry: TelemetryClient,
     private agent?: ProverAgent,
     initialHeader?: Header,
   ) {
     this.queue = new MemoryProvingQueue(config.proverJobTimeoutMs, config.proverJobPollIntervalMs);
-    this.orchestrator = new ProvingOrchestrator(worldStateSynchronizer.getLatest(), this.queue, initialHeader);
+    this.orchestrator = new ProvingOrchestrator(
+      worldStateSynchronizer.getLatest(),
+      this.queue,
+      telemetry,
+      initialHeader,
+    );
   }
 
   async updateProverConfig(config: Partial<ProverClientConfig & { vks: VerificationKeys }>): Promise<void> {
@@ -43,7 +50,7 @@ export class TxProver implements ProverClient {
     }
 
     if (newConfig.realProofs !== this.config.realProofs && this.agent) {
-      const circuitProver = await TxProver.buildCircuitProver(newConfig);
+      const circuitProver = await TxProver.buildCircuitProver(newConfig, this.telemetry);
       this.agent.setCircuitProver(circuitProver);
     }
 
@@ -95,31 +102,35 @@ export class TxProver implements ProverClient {
     config: ProverClientConfig,
     vks: VerificationKeys,
     worldStateSynchronizer: WorldStateSynchronizer,
+    telemetry: TelemetryClient,
     initialHeader?: Header,
   ) {
     const agent = config.proverAgentEnabled
       ? new ProverAgent(
-          await TxProver.buildCircuitProver(config),
+          await TxProver.buildCircuitProver(config, telemetry),
           config.proverAgentConcurrency,
           config.proverAgentPollInterval,
         )
       : undefined;
 
-    const prover = new TxProver(config, worldStateSynchronizer, vks, agent, initialHeader);
+    const prover = new TxProver(config, worldStateSynchronizer, vks, telemetry, agent, initialHeader);
     await prover.start();
     return prover;
   }
 
-  private static async buildCircuitProver(config: ProverClientConfig): Promise<ServerCircuitProver> {
+  private static async buildCircuitProver(
+    config: ProverClientConfig,
+    telemetry: TelemetryClient,
+  ): Promise<ServerCircuitProver> {
     if (config.realProofs) {
-      return await BBNativeRollupProver.new(config);
+      return await BBNativeRollupProver.new(config, telemetry);
     }
 
     const simulationProvider = config.acvmBinaryPath
       ? new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath)
       : undefined;
 
-    return new TestCircuitProver(simulationProvider);
+    return new TestCircuitProver(telemetry, simulationProvider);
   }
 
   /**