@aztec/prover-client 0.76.4 → 0.77.0-testnet-ignition.21

package/src/mocks/test_context.ts

@@ -1,42 +1,31 @@
-import { type BBProverConfig } from '@aztec/bb-prover';
-import {
-  type L2Block,
-  type ProcessedTx,
-  type PublicExecutionRequest,
-  type ServerCircuitProver,
-  type Tx,
-} from '@aztec/circuit-types';
-import { makeBloatedProcessedTx } from '@aztec/circuit-types/test';
-import {
-  type AppendOnlyTreeSnapshot,
-  type BlockHeader,
-  type Gas,
-  type GlobalVariables,
-  TreeSnapshots,
-} from '@aztec/circuits.js';
+import type { BBProverConfig } from '@aztec/bb-prover';
 import { times, timesParallel } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
-import { type Logger } from '@aztec/foundation/log';
+import type { Logger } from '@aztec/foundation/log';
 import { TestDateProvider } from '@aztec/foundation/timer';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
 import {
   PublicProcessor,
+  PublicTxSimulationTester,
   PublicTxSimulator,
-  type SimulationProvider,
-  WASMSimulatorWithBlobs,
-  type WorldStateDB,
+  SimpleContractDataSource,
+  WorldStateDB,
 } from '@aztec/simulator/server';
-import { type MerkleTreeAdminDatabase } from '@aztec/world-state';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import { makeBloatedProcessedTx } from '@aztec/stdlib/testing';
+import { type AppendOnlyTreeSnapshot, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { type BlockHeader, type GlobalVariables, type ProcessedTx, TreeSnapshots, type Tx } from '@aztec/stdlib/tx';
+import type { MerkleTreeAdminDatabase } from '@aztec/world-state';
 import { NativeWorldStateService } from '@aztec/world-state/native';
 
-import { jest } from '@jest/globals';
 import { promises as fs } from 'fs';
-import { mock } from 'jest-mock-extended';
 
 import { TestCircuitProver } from '../../../bb-prover/src/test/test_circuit_prover.js';
-import { AvmFinalizedCallResult } from '../../../simulator/src/avm/avm_contract_call_result.js';
-import { type AvmPersistableStateManager } from '../../../simulator/src/avm/journal/journal.js';
 import { buildBlock } from '../block_builder/light.js';
 import { ProvingOrchestrator } from '../orchestrator/index.js';
 import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
@@ -45,21 +34,26 @@ import { getEnvironmentConfig, getSimulationProvider, makeGlobals, updateExpecte
 
 export class TestContext {
   private headers: Map<number, BlockHeader> = new Map();
+  private feePayerBalance: Fr;
 
   constructor(
     public publicTxSimulator: PublicTxSimulator,
     public worldState: MerkleTreeAdminDatabase,
     public publicProcessor: PublicProcessor,
-    public simulationProvider: SimulationProvider,
     public globalVariables: GlobalVariables,
     public prover: ServerCircuitProver,
     public broker: TestBroker,
     public brokerProverFacade: BrokerCircuitProverFacade,
     public orchestrator: TestProvingOrchestrator,
     public blockNumber: number,
+    public feePayer: AztecAddress,
+    initialFeePayerBalance: Fr,
     public directoriesToCleanup: string[],
+    public tester: PublicTxSimulationTester,
     public logger: Logger,
-  ) {}
+  ) {
+    this.feePayerBalance = initialFeePayerBalance;
+  }
 
   public get epochProver() {
     return this.orchestrator;
@@ -68,20 +62,30 @@ export class TestContext {
   static async new(
     logger: Logger,
     proverCount = 4,
-    createProver: (bbConfig: BBProverConfig) => Promise<ServerCircuitProver> = _ =>
-      Promise.resolve(new TestCircuitProver(new WASMSimulatorWithBlobs())),
+    createProver: (bbConfig: BBProverConfig) => Promise<ServerCircuitProver> = async (bbConfig: BBProverConfig) =>
+      new TestCircuitProver(await getSimulationProvider(bbConfig, logger)),
     blockNumber = 1,
   ) {
     const directoriesToCleanup: string[] = [];
     const globalVariables = makeGlobals(blockNumber);
 
-    const worldStateDB = mock<WorldStateDB>();
+    const feePayer = AztecAddress.fromNumber(42222);
+    const initialFeePayerBalance = new Fr(10n ** 20n);
+    const feePayerSlot = await computeFeePayerBalanceLeafSlot(feePayer);
+    const prefilledPublicData = [new PublicDataTreeLeaf(feePayerSlot, initialFeePayerBalance)];
 
     // Separated dbs for public processor and prover - see public_processor for context
-    const ws = await NativeWorldStateService.tmp();
+    const ws = await NativeWorldStateService.tmp(
+      undefined /* rollupAddress */,
+      true /* cleanupTmpDir */,
+      prefilledPublicData,
+    );
     const publicDb = await ws.fork();
 
-    worldStateDB.getMerkleInterface.mockReturnValue(publicDb);
+    const contractDataSource = new SimpleContractDataSource();
+    const worldStateDB = new WorldStateDB(publicDb, contractDataSource);
+
+    const tester = new PublicTxSimulationTester(worldStateDB, contractDataSource, publicDb);
 
     const publicTxSimulator = new PublicTxSimulator(publicDb, worldStateDB, globalVariables, true);
     const processor = new PublicProcessor(
@@ -94,12 +98,8 @@ export class TestContext {
 
     let localProver: ServerCircuitProver;
     const config = await getEnvironmentConfig(logger);
-    const simulationProvider = await getSimulationProvider({
-      acvmWorkingDirectory: config?.acvmWorkingDirectory,
-      acvmBinaryPath: config?.expectedAcvmPath,
-    });
     if (!config) {
-      localProver = new TestCircuitProver(simulationProvider);
+      localProver = new TestCircuitProver();
     } else {
       const bbConfig: BBProverConfig = {
         acvmBinaryPath: config.expectedAcvmPath,
@@ -126,14 +126,16 @@ export class TestContext {
       publicTxSimulator,
       ws,
       processor,
-      simulationProvider,
       globalVariables,
       localProver,
       broker,
       facade,
       orchestrator,
       blockNumber,
+      feePayer,
+      initialFeePayerBalance,
       directoriesToCleanup,
+      tester,
       logger,
     );
   }
@@ -156,23 +158,36 @@ export class TestContext {
     await this.brokerProverFacade.stop();
     await this.broker.stop();
     for (const dir of this.directoriesToCleanup.filter(x => x !== '')) {
-      await fs.rm(dir, { recursive: true, force: true });
+      try {
+        await fs.rm(dir, { recursive: true, force: true, maxRetries: 3 });
+      } catch (err) {
+        this.logger.warn(`Failed to delete tmp directory $dir}: ${err}`);
+      }
     }
   }
 
-  public makeProcessedTx(opts?: Parameters<typeof makeBloatedProcessedTx>[0]): Promise<ProcessedTx>;
-  public makeProcessedTx(seed?: number): Promise<ProcessedTx>;
-  public makeProcessedTx(seedOrOpts?: Parameters<typeof makeBloatedProcessedTx>[0] | number): Promise<ProcessedTx> {
+  public async makeProcessedTx(opts?: Parameters<typeof makeBloatedProcessedTx>[0]): Promise<ProcessedTx>;
+  public async makeProcessedTx(seed?: number): Promise<ProcessedTx>;
+  public async makeProcessedTx(
+    seedOrOpts?: Parameters<typeof makeBloatedProcessedTx>[0] | number,
+  ): Promise<ProcessedTx> {
     const opts = typeof seedOrOpts === 'number' ? { seed: seedOrOpts } : seedOrOpts;
     const blockNum = (opts?.globalVariables ?? this.globalVariables).blockNumber.toNumber();
     const header = this.getBlockHeader(blockNum - 1);
-    return makeBloatedProcessedTx({
+    const tx = await makeBloatedProcessedTx({
       header,
       vkTreeRoot: getVKTreeRoot(),
       protocolContractTreeRoot,
       globalVariables: this.globalVariables,
+      feePayer: this.feePayer,
       ...opts,
     });
+    this.feePayerBalance = new Fr(this.feePayerBalance.toBigInt() - tx.txEffect.transactionFee.toBigInt());
+    if (opts?.privateOnly) {
+      const feePayerSlot = await computeFeePayerBalanceLeafSlot(this.feePayer);
+      tx.txEffect.publicDataWrites[0] = new PublicDataWrite(feePayerSlot, this.feePayerBalance);
+    }
+    return tx;
   }
 
   /** Creates a block with the given number of txs and adds it to world-state */
@@ -198,32 +213,7 @@ export class TestContext {
   }
 
   public async processPublicFunctions(txs: Tx[], maxTransactions: number) {
-    const defaultExecutorImplementation = (
-      _stateManager: AvmPersistableStateManager,
-      executionRequest: PublicExecutionRequest,
-      allocatedGas: Gas,
-      _transactionFee: Fr,
-      _fnName: string,
-    ) => {
-      for (const tx of txs) {
-        const allCalls = tx.publicTeardownFunctionCall.isEmpty()
-          ? tx.enqueuedPublicFunctionCalls
-          : [...tx.enqueuedPublicFunctionCalls, tx.publicTeardownFunctionCall];
-        for (const request of allCalls) {
-          if (executionRequest.callContext.equals(request.callContext)) {
-            return Promise.resolve(
-              new AvmFinalizedCallResult(/*reverted=*/ false, /*output=*/ [], /*gasLeft=*/ allocatedGas),
-            );
-          }
-        }
-      }
-      throw new Error(`Unexpected execution request: ${executionRequest}`);
-    };
-    return await this.processPublicFunctionsWithMockExecutorImplementation(
-      txs,
-      maxTransactions,
-      defaultExecutorImplementation,
-    );
+    return await this.publicProcessor.process(txs, { maxTransactions });
   }
 
   public async setTreeRoots(txs: ProcessedTx[]) {
@@ -248,38 +238,6 @@ export class TestContext {
       }
     }
   }
-
-  private async processPublicFunctionsWithMockExecutorImplementation(
-    txs: Tx[],
-    maxTransactions: number,
-    executorMock?: (
-      stateManager: AvmPersistableStateManager,
-      executionRequest: PublicExecutionRequest,
-      allocatedGas: Gas,
-      transactionFee: Fr,
-      fnName: string,
-    ) => Promise<AvmFinalizedCallResult>,
-  ) {
-    // Mock the internal private function. Borrowed from https://stackoverflow.com/a/71033167
-    const simulateInternal: jest.SpiedFunction<
-      (
-        stateManager: AvmPersistableStateManager,
-        executionResult: any,
-        allocatedGas: Gas,
-        transactionFee: any,
-        fnName: any,
-      ) => Promise<AvmFinalizedCallResult>
-    > = jest.spyOn(
-      this.publicTxSimulator as unknown as {
-        simulateEnqueuedCallInternal: PublicTxSimulator['simulateEnqueuedCallInternal'];
-      },
-      'simulateEnqueuedCallInternal',
-    );
-    if (executorMock) {
-      simulateInternal.mockImplementation(executorMock);
-    }
-    return await this.publicProcessor.process(txs, { maxTransactions });
-  }
 }
 
 class TestProvingOrchestrator extends ProvingOrchestrator {

package/src/orchestrator/block-building-helpers.ts

@@ -1,39 +1,32 @@
-import { Blob } from '@aztec/blob-lib';
-import {
-  Body,
-  MerkleTreeId,
-  type MerkleTreeWriteOperations,
-  type ProcessedTx,
-  TxEffect,
-  getTreeHeight,
-} from '@aztec/circuit-types';
+import { Blob, type SpongeBlob } from '@aztec/blob-lib';
 import {
   ARCHIVE_HEIGHT,
-  AppendOnlyTreeSnapshot,
-  BlockHeader,
-  ContentCommitment,
-  Fr,
-  type GlobalVariables,
+  MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
-  MembershipWitness,
-  MerkleTreeCalculator,
   NOTE_HASH_SUBTREE_HEIGHT,
   NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH,
   NULLIFIER_SUBTREE_HEIGHT,
   NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH,
   NULLIFIER_TREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-  NullifierLeafPreimage,
   PUBLIC_DATA_TREE_HEIGHT,
-  type ParityPublicInputs,
-  PartialStateReference,
-  PublicDataHint,
-  PublicDataTreeLeaf,
-  PublicDataTreeLeafPreimage,
-  StateReference,
-} from '@aztec/circuits.js';
-import { type SpongeBlob } from '@aztec/circuits.js/blobs';
+} from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { sha256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import { type Tuple, assertLength, serializeToBuffer, toFriendlyJSON } from '@aztec/foundation/serialize';
+import { MembershipWitness, MerkleTreeCalculator, computeUnbalancedMerkleRoot } from '@aztec/foundation/trees';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
+import { PublicDataHint } from '@aztec/stdlib/avm';
+import { Body } from '@aztec/stdlib/block';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { ContractClassLog } from '@aztec/stdlib/logs';
+import type { ParityPublicInputs } from '@aztec/stdlib/parity';
 import {
   type BaseOrMergeRollupPublicInputs,
   type BlockRootOrBlockMergePublicInputs,
@@ -41,18 +34,26 @@ import {
   PrivateBaseRollupHints,
   PrivateBaseStateDiffHints,
   PublicBaseRollupHints,
-} from '@aztec/circuits.js/rollup';
-import { makeTuple } from '@aztec/foundation/array';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { sha256Trunc } from '@aztec/foundation/crypto';
-import { type Logger } from '@aztec/foundation/log';
-import { type Tuple, assertLength, serializeToBuffer, toFriendlyJSON } from '@aztec/foundation/serialize';
-import { computeUnbalancedMerkleRoot } from '@aztec/foundation/trees';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { computeFeePayerBalanceLeafSlot } from '@aztec/simulator/server';
+} from '@aztec/stdlib/rollup';
+import {
+  AppendOnlyTreeSnapshot,
+  MerkleTreeId,
+  NullifierLeafPreimage,
+  PublicDataTreeLeaf,
+  PublicDataTreeLeafPreimage,
+  getTreeHeight,
+} from '@aztec/stdlib/trees';
+import {
+  BlockHeader,
+  ContentCommitment,
+  type GlobalVariables,
+  PartialStateReference,
+  type ProcessedTx,
+  StateReference,
+  TxEffect,
+} from '@aztec/stdlib/tx';
 import { Attributes, type Span, runInSpan } from '@aztec/telemetry-client';
-import { type MerkleTreeReadOperations } from '@aztec/world-state';
+import type { MerkleTreeReadOperations } from '@aztec/world-state';
 
 import { inspect } from 'util';
 
@@ -100,6 +101,10 @@ export const buildBaseRollupHints = runInSpan(
     const noteHashes = padArrayEnd(tx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX);
     await db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashes);
 
+    // Create data hint for reading fee payer initial balance in Fee Juice
+    const leafSlot = await computeFeePayerBalanceLeafSlot(tx.data.feePayer);
+    const feePayerFeeJuiceBalanceReadHint = await getPublicDataHint(db, leafSlot.toBigInt());
+
     // The read witnesses for a given TX should be generated before the writes of the same TX are applied.
     // All reads that refer to writes in the same tx are transient and can be simplified out.
     const txPublicDataUpdateRequestInfo = await processPublicDataUpdateRequests(tx, db);
@@ -136,6 +141,11 @@ export const buildBaseRollupHints = runInSpan(
     const inputSpongeBlob = startSpongeBlob.clone();
     await startSpongeBlob.absorb(tx.txEffect.toBlobFields());
 
+    const contractClassLogsPreimages = makeTuple(
+      MAX_CONTRACT_CLASS_LOGS_PER_TX,
+      i => tx.txEffect.contractClassLogs[i] || ContractClassLog.empty(),
+    );
+
     if (tx.avmProvingRequest) {
       const blockHash = await tx.constants.historicalHeader.hash();
       const archiveRootMembershipWitness = await getMembershipWitnessFor(
@@ -148,6 +158,7 @@ export const buildBaseRollupHints = runInSpan(
       return PublicBaseRollupHints.from({
         startSpongeBlob: inputSpongeBlob,
         archiveRootMembershipWitness,
+        contractClassLogsPreimages,
         constants,
       });
     } else {
@@ -159,13 +170,6 @@ export const buildBaseRollupHints = runInSpan(
         throw new Error(`More than one public data write in a private only tx`);
       }
 
-      // Create data hint for reading fee payer initial balance in Fee Juice
-      // If no fee payer is set, read hint should be empty
-      const leafSlot = await computeFeePayerBalanceLeafSlot(tx.data.feePayer);
-      const feePayerFeeJuiceBalanceReadHint = tx.data.feePayer.isZero()
-        ? PublicDataHint.empty()
-        : await getPublicDataHint(db, leafSlot.toBigInt());
-
       const feeWriteLowLeafPreimage =
         txPublicDataUpdateRequestInfo.lowPublicDataWritesPreimages[0] || PublicDataTreeLeafPreimage.empty();
       const feeWriteLowLeafMembershipWitness =
@@ -207,8 +211,9 @@ export const buildBaseRollupHints = runInSpan(
         start,
         startSpongeBlob: inputSpongeBlob,
         stateDiffHints,
-        feePayerFeeJuiceBalanceReadHint: feePayerFeeJuiceBalanceReadHint,
+        feePayerFeeJuiceBalanceReadHint,
         archiveRootMembershipWitness,
+        contractClassLogsPreimages,
         constants,
       });
     }
@@ -347,7 +352,7 @@ export const buildHeaderAndBodyFromTxs = runInSpan(
     const contentCommitment = new ContentCommitment(new Fr(numTxs), blobsHash, parityShaRoot, outHash);
 
     const fees = body.txEffects.reduce((acc, tx) => acc.add(tx.transactionFee), Fr.ZERO);
-    const manaUsed = txs.reduce((acc, tx) => acc.add(new Fr(tx.gasUsed.totalGas.l2Gas)), Fr.ZERO);
+    const manaUsed = txs.reduce((acc, tx) => acc.add(new Fr(tx.gasUsed.billedGas.l2Gas)), Fr.ZERO);
 
     const header = new BlockHeader(previousArchive, contentCommitment, stateReference, globalVariables, fees, manaUsed);
 

package/src/orchestrator/block-proving-state.ts

@@ -1,25 +1,24 @@
-import { type L2Block, type MerkleTreeId, type PublicInputsAndRecursiveProof } from '@aztec/circuit-types';
-import { type CircuitName } from '@aztec/circuit-types/stats';
+import { SpongeBlob } from '@aztec/blob-lib';
 import {
   type ARCHIVE_HEIGHT,
-  type AppendOnlyTreeSnapshot,
   BLOBS_PER_BLOCK,
-  type BlockHeader,
   FIELDS_PER_BLOB,
-  Fr,
-  type GlobalVariables,
   type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
-  MembershipWitness,
   type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
-  type ParityPublicInputs,
   type RECURSIVE_PROOF_LENGTH,
-  RootParityInput,
-  RootParityInputs,
-  StateReference,
   VK_TREE_HEIGHT,
-} from '@aztec/circuits.js';
-import { SpongeBlob } from '@aztec/circuits.js/blobs';
+} from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { MembershipWitness, type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import { type ParityPublicInputs, RootParityInput, RootParityInputs } from '@aztec/stdlib/parity';
 import {
   type BaseOrMergeRollupPublicInputs,
   type BlockRootOrBlockMergePublicInputs,
@@ -31,17 +30,14 @@ import {
   MergeRollupInputs,
   PreviousRollupData,
   SingleTxBlockRootRollupInputs,
-} from '@aztec/circuits.js/rollup';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { type Logger } from '@aztec/foundation/log';
-import { type Tuple } from '@aztec/foundation/serialize';
-import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
-import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+} from '@aztec/stdlib/rollup';
+import type { CircuitName } from '@aztec/stdlib/stats';
+import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { type BlockHeader, type GlobalVariables, StateReference } from '@aztec/stdlib/tx';
 
 import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-helpers.js';
-import { type EpochProvingState } from './epoch-proving-state.js';
-import { type TxProvingState } from './tx-proving-state.js';
+import type { EpochProvingState } from './epoch-proving-state.js';
+import type { TxProvingState } from './tx-proving-state.js';
 
 export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
 

package/src/orchestrator/epoch-proving-state.ts

@@ -1,30 +1,25 @@
-import {
-  type MerkleTreeId,
-  type ProofAndVerificationKey,
-  type PublicInputsAndRecursiveProof,
-} from '@aztec/circuit-types';
 import {
   type ARCHIVE_HEIGHT,
-  type AppendOnlyTreeSnapshot,
-  type BlockHeader,
-  type Fr,
-  type GlobalVariables,
   type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
-  MembershipWitness,
   type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   type TUBE_PROOF_LENGTH,
   VK_TREE_HEIGHT,
-} from '@aztec/circuits.js';
+} from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/fields';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { MembershipWitness, type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import type { Proof } from '@aztec/stdlib/proofs';
 import {
   BlockMergeRollupInputs,
   type BlockRootOrBlockMergePublicInputs,
   PreviousRollupBlockData,
   RootRollupInputs,
   type RootRollupPublicInputs,
-} from '@aztec/circuits.js/rollup';
-import { type Tuple } from '@aztec/foundation/serialize';
-import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
-import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vks';
+} from '@aztec/stdlib/rollup';
+import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import type { BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
 
 import { BlockProvingState } from './block-proving-state.js';
 
@@ -184,7 +179,7 @@ export class EpochProvingState {
     return this.blocks.find(block => block?.blockNumber === blockNumber);
   }
 
-  public getEpochProofResult() {
+  public getEpochProofResult(): { proof: Proof; publicInputs: RootRollupPublicInputs } {
     if (!this.rootRollupProvingOutput) {
       throw new Error('Unable to get epoch proof result. Root rollup is not ready.');
     }

package/src/orchestrator/orchestrator.ts

@@ -1,50 +1,43 @@
-import {
-  L2Block,
-  MerkleTreeId,
-  type ProcessedTx,
-  type ServerCircuitProver,
-  type Tx,
-  toNumBlobFields,
-} from '@aztec/circuit-types';
-import {
-  type EpochProver,
-  type ForkMerkleTreeOperations,
-  type MerkleTreeWriteOperations,
-  type ProofAndVerificationKey,
-} from '@aztec/circuit-types/interfaces';
-import { type CircuitName } from '@aztec/circuit-types/stats';
 import {
   AVM_PROOF_LENGTH_IN_FIELDS,
   AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
-  type AppendOnlyTreeSnapshot,
-  BaseParityInputs,
-  type BlockHeader,
-  Fr,
-  type GlobalVariables,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
   type TUBE_PROOF_LENGTH,
-  VerificationKeyData,
-  makeEmptyRecursiveProof,
-} from '@aztec/circuits.js';
-import {
-  type BaseRollupHints,
-  EmptyBlockRootRollupInputs,
-  PrivateBaseRollupInputs,
-  SingleTxBlockRootRollupInputs,
-  TubeInputs,
-} from '@aztec/circuits.js/rollup';
+} from '@aztec/constants';
 import { padArrayEnd, times } from '@aztec/foundation/collection';
 import { AbortError } from '@aztec/foundation/error';
+import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { elapsed } from '@aztec/foundation/timer';
-import { type TreeNodeLocation } from '@aztec/foundation/trees';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
+import type { TreeNodeLocation } from '@aztec/foundation/trees';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { L2Block } from '@aztec/stdlib/block';
+import type {
+  EpochProver,
+  ForkMerkleTreeOperations,
+  MerkleTreeWriteOperations,
+  ProofAndVerificationKey,
+  ServerCircuitProver,
+} from '@aztec/stdlib/interfaces/server';
+import { BaseParityInputs } from '@aztec/stdlib/parity';
+import { makeEmptyRecursiveProof } from '@aztec/stdlib/proofs';
+import {
+  type BaseRollupHints,
+  EmptyBlockRootRollupInputs,
+  PrivateBaseRollupInputs,
+  SingleTxBlockRootRollupInputs,
+  TubeInputs,
+} from '@aztec/stdlib/rollup';
+import type { CircuitName } from '@aztec/stdlib/stats';
+import { type AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { type BlockHeader, type GlobalVariables, type ProcessedTx, type Tx, toNumBlobFields } from '@aztec/stdlib/tx';
+import { VerificationKeyData } from '@aztec/stdlib/vks';
 import {
   Attributes,
   type TelemetryClient,
@@ -65,7 +58,7 @@ import {
   validatePartialState,
   validateTx,
 } from './block-building-helpers.js';
-import { type BlockProvingState } from './block-proving-state.js';
+import type { BlockProvingState } from './block-proving-state.js';
 import { EpochProvingState, type ProvingResult, type TreeSnapshots } from './epoch-proving-state.js';
 import { ProvingOrchestratorMetrics } from './orchestrator_metrics.js';
 import { TxProvingState } from './tx-proving-state.js';

package/src/orchestrator/tx-proving-state.ts

@@ -1,13 +1,7 @@
-import { type MerkleTreeId, type ProcessedTx, type ProofAndVerificationKey } from '@aztec/circuit-types';
-import { type CircuitName } from '@aztec/circuit-types/stats';
-import {
-  type AVM_PROOF_LENGTH_IN_FIELDS,
-  AVM_VK_INDEX,
-  type AppendOnlyTreeSnapshot,
-  type TUBE_PROOF_LENGTH,
-  TUBE_VK_INDEX,
-  VkWitnessData,
-} from '@aztec/circuits.js';
+import { type AVM_PROOF_LENGTH_IN_FIELDS, AVM_VK_INDEX, type TUBE_PROOF_LENGTH, TUBE_VK_INDEX } from '@aztec/constants';
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
+import type { ProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
 import {
   AvmProofData,
   type BaseRollupHints,
@@ -18,8 +12,11 @@ import {
   PublicBaseRollupInputs,
   PublicTubeData,
   TubeInputs,
-} from '@aztec/circuits.js/rollup';
-import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vks';
+} from '@aztec/stdlib/rollup';
+import type { CircuitName } from '@aztec/stdlib/stats';
+import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import type { ProcessedTx } from '@aztec/stdlib/tx';
+import { VkWitnessData } from '@aztec/stdlib/vks';
 
 /**
  * Helper class to manage the proving cycle of a transaction
@@ -48,7 +45,7 @@ export class TxProvingState {
     return new TubeInputs(this.processedTx.clientIvcProof);
   }
 
-  public getAvmInputs() {
+  public getAvmInputs(): AvmCircuitInputs {
     return this.processedTx.avmProvingRequest!.inputs;
   }