@aztec/prover-client 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/dest/orchestrator/epoch-proving-state.d.ts

@@ -1,4 +1,6 @@
-import { type ARCHIVE_HEIGHT, type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { BatchedBlob, type FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import type { ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation } from '@aztec/foundation/trees';
@@ -26,30 +28,35 @@ export declare class EpochProvingState {
     readonly epochNumber: number;
     readonly firstBlockNumber: number;
     readonly totalNumBlocks: number;
+    readonly finalBlobBatchingChallenges: FinalBlobBatchingChallenges;
     private completionCallback;
     private rejectionCallback;
     private blockRootOrMergeProvingOutputs;
     private paddingBlockRootProvingOutput;
     private rootRollupProvingOutput;
+    private finalBatchedBlob;
     private provingStateLifecycle;
-    readonly cachedTubeProofs: Map<string, Promise<ProofAndVerificationKey<538>>>;
+    readonly cachedTubeProofs: Map<string, Promise<ProofAndVerificationKey<535>>>;
     blocks: (BlockProvingState | undefined)[];
-    constructor(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number, completionCallback: (result: ProvingResult) => void, rejectionCallback: (reason: string) => void);
-    startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[], l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot, lastArchiveSnapshot: AppendOnlyTreeSnapshot, newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, previousBlockHeader: BlockHeader): BlockProvingState;
+    constructor(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges, completionCallback: (result: ProvingResult) => void, rejectionCallback: (reason: string) => void);
+    startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[], l1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot, lastArchiveSnapshot: AppendOnlyTreeSnapshot, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, previousBlockHeader: BlockHeader, proverId: EthAddress): BlockProvingState;
     verifyState(): boolean;
     isAcceptingBlocks(): boolean;
     setBlockRootRollupProof(blockIndex: number, proof: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
     setBlockMergeRollupProof(location: TreeNodeLocation, proof: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
     setRootRollupProof(proof: PublicInputsAndRecursiveProof<RootRollupPublicInputs>): void;
     setPaddingBlockRootProof(proof: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    setFinalBatchedBlob(batchedBlob: BatchedBlob): void;
+    setBlobAccumulators(toBlock?: number): Promise<void>;
     getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
     getBlockMergeRollupInputs(mergeLocation: TreeNodeLocation): BlockMergeRollupInputs;
-    getRootRollupInputs(proverId: Fr): RootRollupInputs;
-    getPaddingBlockRootInputs(proverId: Fr): Promise<import("@aztec/stdlib/rollup").EmptyBlockRootRollupInputs>;
+    getRootRollupInputs(): RootRollupInputs;
+    getPaddingBlockRootInputs(): import("@aztec/stdlib/rollup").PaddingBlockRootRollupInputs;
     getBlockProvingStateByBlockNumber(blockNumber: number): BlockProvingState | undefined;
     getEpochProofResult(): {
         proof: Proof;
         publicInputs: RootRollupPublicInputs;
+        batchedBlobInputs: BatchedBlob;
     };
     isReadyForBlockMerge(location: TreeNodeLocation): boolean;
     isReadyForRootRollup(): boolean;

package/dest/orchestrator/epoch-proving-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"epoch-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/epoch-proving-state.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"epoch-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/epoch-proving-state.ts"],"names":[],"mappings":"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"}

package/dest/orchestrator/epoch-proving-state.js

@@ -1,7 +1,7 @@
-import { VK_TREE_HEIGHT } from '@aztec/constants';
-import { MembershipWitness, UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { UnbalancedTreeStore } from '@aztec/foundation/trees';
 import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { BlockMergeRollupInputs, PreviousRollupBlockData, RootRollupInputs } from '@aztec/stdlib/rollup';
+import { VkData } from '@aztec/stdlib/vks';
 import { BlockProvingState } from './block-proving-state.js';
 var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
     PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_CREATED"] = 0] = "PROVING_STATE_CREATED";
@@ -19,19 +19,22 @@ var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
     epochNumber;
     firstBlockNumber;
     totalNumBlocks;
+    finalBlobBatchingChallenges;
     completionCallback;
     rejectionCallback;
     blockRootOrMergeProvingOutputs;
     paddingBlockRootProvingOutput;
     rootRollupProvingOutput;
+    finalBatchedBlob;
     provingStateLifecycle;
     // Map from tx hash to tube proof promise. Used when kickstarting tube proofs before tx processing.
     cachedTubeProofs;
     blocks;
-    constructor(epochNumber, firstBlockNumber, totalNumBlocks, completionCallback, rejectionCallback){
+    constructor(epochNumber, firstBlockNumber, totalNumBlocks, finalBlobBatchingChallenges, completionCallback, rejectionCallback){
         this.epochNumber = epochNumber;
         this.firstBlockNumber = firstBlockNumber;
         this.totalNumBlocks = totalNumBlocks;
+        this.finalBlobBatchingChallenges = finalBlobBatchingChallenges;
         this.completionCallback = completionCallback;
         this.rejectionCallback = rejectionCallback;
         this.provingStateLifecycle = 0;
@@ -41,9 +44,9 @@ var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
     }
     // Adds a block to the proving state, returns its index
     // Will update the proving life cycle if this is the last block
-    startNewBlock(globalVariables, l1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, newArchiveSiblingPath, previousBlockHeader) {
-        const index = globalVariables.blockNumber.toNumber() - this.firstBlockNumber;
-        const block = new BlockProvingState(index, globalVariables, l1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, newArchiveSiblingPath, previousBlockHeader, this);
+    startNewBlock(globalVariables, l1ToL2Messages, l1ToL2MessageTreeSnapshot, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, lastArchiveSiblingPath, newArchiveSiblingPath, previousBlockHeader, proverId) {
+        const index = globalVariables.blockNumber - this.firstBlockNumber;
+        const block = new BlockProvingState(index, globalVariables, l1ToL2Messages, l1ToL2MessageTreeSnapshot, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, lastArchiveSiblingPath, newArchiveSiblingPath, previousBlockHeader, proverId, this);
         this.blocks[index] = block;
         if (this.blocks.filter((b)=>!!b).length === this.totalNumBlocks) {
             this.provingStateLifecycle = 1;
@@ -70,6 +73,28 @@ var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
     setPaddingBlockRootProof(proof) {
         this.paddingBlockRootProvingOutput = proof;
     }
+    setFinalBatchedBlob(batchedBlob) {
+        this.finalBatchedBlob = batchedBlob;
+    }
+    async setBlobAccumulators(toBlock) {
+        let previousAccumulator;
+        const end = toBlock ? toBlock - this.firstBlockNumber : this.blocks.length;
+        // Accumulate blobs as far as we can for this epoch.
+        for(let i = 0; i <= end; i++){
+            const block = this.blocks[i];
+            if (!block || !block.block) {
+                break;
+            }
+            if (!block.startBlobAccumulator) {
+                // startBlobAccumulator always exists for firstBlockNumber, so the below should never assign an undefined:
+                block.setStartBlobAccumulator(previousAccumulator);
+            }
+            if (block.startBlobAccumulator && !block.endBlobAccumulator) {
+                await block.accumulateBlobs();
+            }
+            previousAccumulator = block.endBlobAccumulator;
+        }
+    }
     getParentLocation(location) {
         return this.blockRootOrMergeProvingOutputs.getParentLocation(location);
     }
@@ -83,7 +108,7 @@ var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
             this.#getPreviousRollupData(right)
         ]);
     }
-    getRootRollupInputs(proverId) {
+    getRootRollupInputs() {
         const [left, right] = this.#getChildProofsForRoot();
         if (!left || !right) {
             throw new Error('At lease one child is not ready.');
@@ -92,27 +117,27 @@ var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
             previousRollupData: [
                 this.#getPreviousRollupData(left),
                 this.#getPreviousRollupData(right)
-            ],
-            proverId
+            ]
         });
     }
-    getPaddingBlockRootInputs(proverId) {
+    getPaddingBlockRootInputs() {
         if (!this.blocks[0]?.isComplete()) {
             throw new Error('Epoch needs one completed block in order to be padded.');
         }
-        return this.blocks[0].getPaddingBlockRootInputs(proverId);
+        return this.blocks[0].getPaddingBlockRootInputs();
     }
     // Returns a specific transaction proving state
     getBlockProvingStateByBlockNumber(blockNumber) {
         return this.blocks.find((block)=>block?.blockNumber === blockNumber);
     }
     getEpochProofResult() {
-        if (!this.rootRollupProvingOutput) {
+        if (!this.rootRollupProvingOutput || !this.finalBatchedBlob) {
             throw new Error('Unable to get epoch proof result. Root rollup is not ready.');
         }
         return {
             proof: this.rootRollupProvingOutput.proof.binaryProof,
-            publicInputs: this.rootRollupProvingOutput.inputs
+            publicInputs: this.rootRollupProvingOutput.inputs,
+            batchedBlobInputs: this.finalBatchedBlob
         };
     }
     isReadyForBlockMerge(location) {
@@ -158,6 +183,7 @@ var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
     }
     #getPreviousRollupData({ inputs, proof, verificationKey }) {
         const leafIndex = getVKIndex(verificationKey.keyAsFields);
-        return new PreviousRollupBlockData(inputs, proof, verificationKey.keyAsFields, new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)));
+        const vkData = new VkData(verificationKey, leafIndex, getVKSiblingPath(leafIndex));
+        return new PreviousRollupBlockData(inputs, proof, vkData);
     }
 }

package/dest/orchestrator/orchestrator.d.ts

@@ -1,5 +1,6 @@
+import { FinalBlobBatchingChallenges } from '@aztec/blob-lib';
 import { Fr } from '@aztec/foundation/fields';
-import { L2Block } from '@aztec/stdlib/block';
+import { EthAddress, L2Block } from '@aztec/stdlib/block';
 import type { EpochProver, ForkMerkleTreeOperations, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
 import { type AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import { type BlockHeader, type GlobalVariables, type ProcessedTx, type Tx } from '@aztec/stdlib/tx';
@@ -26,11 +27,11 @@ export declare class ProvingOrchestrator implements EpochProver {
     private provingPromise;
     private metrics;
     private dbs;
-    constructor(dbProvider: ForkMerkleTreeOperations, prover: ServerCircuitProver, proverId?: Fr, telemetryClient?: TelemetryClient);
+    constructor(dbProvider: ForkMerkleTreeOperations, prover: ServerCircuitProver, proverId: EthAddress, telemetryClient?: TelemetryClient);
     get tracer(): Tracer;
-    getProverId(): Fr;
+    getProverId(): EthAddress;
     stop(): Promise<void>;
-    startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number): void;
+    startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges): void;
     /**
      * Starts off a new block
      * @param globalVariables - The global variables for the block
@@ -64,9 +65,10 @@ export declare class ProvingOrchestrator implements EpochProver {
     /**
      * Returns the proof for the current epoch.
      */
-    finaliseEpoch(): Promise<{
+    finalizeEpoch(): Promise<{
         proof: import("@aztec/stdlib/proofs").Proof;
         publicInputs: import("@aztec/stdlib/rollup").RootRollupPublicInputs;
+        batchedBlobInputs: import("@aztec/blob-lib").BatchedBlob;
     }>;
     /**
      * Starts the proving process for the given transaction and adds it to our state

package/dest/orchestrator/orchestrator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAQ9C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,EACV,WAAW,EACX,wBAAwB,EAGxB,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAWzC,OAAO,EAAE,KAAK,sBAAsB,EAAgB,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,EAAE,EAAmB,MAAM,kBAAkB,CAAC;AAEtH,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,MAAM,EAIZ,MAAM,yBAAyB,CAAC;AAoBjC;;;;;;;;;GASG;AAEH;;GAEG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IASnD,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAV3B,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,kBAAkB,CAAyB;IAEnD,OAAO,CAAC,cAAc,CAAiD;IACvE,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,GAAG,CAAqD;gBAGtD,UAAU,EAAE,wBAAwB,EACpC,MAAM,EAAE,mBAAmB,EAClB,QAAQ,GAAE,EAAY,EACvC,eAAe,GAAE,eAAsC;IAKzD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAEM,WAAW,IAAI,EAAE;IAIjB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;IAW1F;;;;;OAKG;IAIU,aAAa,CAAC,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,EAAE,EAAE,EAAE,mBAAmB,EAAE,WAAW;IAyCnH;;;OAGG;IAIU,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiDtD;;;OAGG;IAEU,iBAAiB,CAAC,GAAG,EAAE,EAAE,EAAE;IAcxC;;;OAGG;IAIU,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAyBnG,oDAAoD;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;YAQzB,UAAU;cAqCR,kCAAkC,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,sBAAsB;IAWvG;;OAEG;IACI,MAAM;IAQb;;OAEG;IACU,aAAa;;;;IAoB1B;;;;OAIG;YACW,kBAAkB;IAShC;;;;;OAKG;IACH,OAAO,CAAC,eAAe;YAwDT,uBAAuB;YA+BvB,uBAAuB;IAmCrC,OAAO,CAAC,iBAAiB;IA+CzB,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,aAAa;IA6BrB,OAAO,CAAC,kBAAkB;YA2BZ,sBAAsB;IA2DpC,OAAO,CAAC,wBAAwB;IAwBhC,OAAO,CAAC,gCAAgC;IAUxC,OAAO,CAAC,wBAAwB;IA4BhC,OAAO,CAAC,uBAAuB;YA0BjB,mBAAmB;IA8BjC,OAAO,CAAC,iBAAiB;YA6BX,8BAA8B;YAa9B,8BAA8B;IAyB5C,OAAO,CAAC,mCAAmC;IAa3C,OAAO,CAAC,yBAAyB;IASjC;;;;;OAKG;IACH,OAAO,CAAC,SAAS;IA8CjB,OAAO,CAAC,4BAA4B;CAWrC"}
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAU3F,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAS9C,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EACV,WAAW,EACX,wBAAwB,EAGxB,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAUzC,OAAO,EAAE,KAAK,sBAAsB,EAAgB,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,EAAE,EAAmB,MAAM,kBAAkB,CAAC;AACtH,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,MAAM,EAIZ,MAAM,yBAAyB,CAAC;AAqBjC;;;;;;;;;GASG;AAEH;;GAEG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IASnD,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAV3B,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,kBAAkB,CAAyB;IAEnD,OAAO,CAAC,cAAc,CAAiD;IACvE,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,GAAG,CAAqD;gBAGtD,UAAU,EAAE,wBAAwB,EACpC,MAAM,EAAE,mBAAmB,EAClB,QAAQ,EAAE,UAAU,EACrC,eAAe,GAAE,eAAsC;IAKzD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAEM,WAAW,IAAI,UAAU;IAIzB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,aAAa,CAClB,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,2BAA2B,EAAE,2BAA2B;IAmB1D;;;;;OAKG;IAIU,aAAa,CAAC,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,EAAE,EAAE,EAAE,mBAAmB,EAAE,WAAW;IA+CnH;;;OAGG;IAIU,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiDtD;;;OAGG;IAEI,iBAAiB,CAAC,GAAG,EAAE,EAAE,EAAE;IAelC;;;OAGG;IAIU,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IA4BnG,oDAAoD;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;YAQzB,UAAU;cAqCR,kCAAkC,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,sBAAsB;IAWvG;;OAEG;IACI,MAAM;IAQb;;OAEG;IACU,aAAa;;;;;IA6B1B;;;;OAIG;YACW,kBAAkB;IAShC;;;;;OAKG;IACH,OAAO,CAAC,eAAe;YAwDT,uBAAuB;YAkCvB,uBAAuB;IAyCrC,OAAO,CAAC,iBAAiB;IA8CzB,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,aAAa;IA4BrB,OAAO,CAAC,kBAAkB;YA0BZ,sBAAsB;IAgFpC,OAAO,CAAC,wBAAwB;IAuBhC,OAAO,CAAC,gCAAgC;IAUxC,OAAO,CAAC,wBAAwB;IA2BhC,OAAO,CAAC,uBAAuB;IAwB/B,OAAO,CAAC,mBAAmB;IA6B3B,OAAO,CAAC,iBAAiB;YA4BX,8BAA8B;YAa9B,8BAA8B;IA2B5C,OAAO,CAAC,mCAAmC;IAa3C,OAAO,CAAC,yBAAyB;IASjC;;;;;OAKG;IACH,OAAO,CAAC,SAAS;IAoDjB,OAAO,CAAC,4BAA4B;CAWrC"}

package/dest/orchestrator/orchestrator.js

@@ -4,7 +4,8 @@ function _ts_decorate(decorators, target, key, desc) {
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-import { AVM_PROOF_LENGTH_IN_FIELDS, AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS, 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 } from '@aztec/constants';
+import { BlobAccumulatorPublicInputs } from '@aztec/blob-lib';
+import { 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 } from '@aztec/constants';
 import { padArrayEnd, times } from '@aztec/foundation/collection';
 import { AbortError } from '@aztec/foundation/error';
 import { Fr } from '@aztec/foundation/fields';
@@ -14,16 +15,15 @@ import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { elapsed } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { readAvmMinimalPublicTxInputsFromFile } from '@aztec/simulator/public/fixtures';
 import { L2Block } from '@aztec/stdlib/block';
 import { BaseParityInputs } from '@aztec/stdlib/parity';
-import { makeEmptyRecursiveProof } from '@aztec/stdlib/proofs';
 import { EmptyBlockRootRollupInputs, PrivateBaseRollupInputs, SingleTxBlockRootRollupInputs, TubeInputs } from '@aztec/stdlib/rollup';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { toNumBlobFields } from '@aztec/stdlib/tx';
-import { VerificationKeyData } from '@aztec/stdlib/vks';
 import { Attributes, getTelemetryClient, trackSpan, wrapCallbackInSpan } from '@aztec/telemetry-client';
 import { inspect } from 'util';
-import { buildBaseRollupHints, buildHeaderAndBodyFromTxs, getRootTreeSiblingPath, getSubtreeSiblingPath, getTreeSnapshot, validatePartialState, validateTx } from './block-building-helpers.js';
+import { buildHeaderAndBodyFromTxs, getLastSiblingPath, getRootTreeSiblingPath, getSubtreeSiblingPath, getTreeSnapshot, insertSideEffectsAndBuildBaseRollupHints, validatePartialState, validateTx } from './block-building-helpers.js';
 import { EpochProvingState } from './epoch-proving-state.js';
 import { ProvingOrchestratorMetrics } from './orchestrator_metrics.js';
 import { TxProvingState } from './tx-proving-state.js';
@@ -48,7 +48,7 @@ const logger = createLogger('prover-client:orchestrator');
     provingPromise;
     metrics;
     dbs;
-    constructor(dbProvider, prover, proverId = Fr.ZERO, telemetryClient = getTelemetryClient()){
+    constructor(dbProvider, prover, proverId, telemetryClient = getTelemetryClient()){
         this.dbProvider = dbProvider;
         this.prover = prover;
         this.proverId = proverId;
@@ -68,7 +68,7 @@ const logger = createLogger('prover-client:orchestrator');
         this.cancel();
         return Promise.resolve();
     }
-    startNewEpoch(epochNumber, firstBlockNumber, totalNumBlocks) {
+    startNewEpoch(epochNumber, firstBlockNumber, totalNumBlocks, finalBlobBatchingChallenges) {
         const { promise: _promise, resolve, reject } = promiseWithResolvers();
         const promise = _promise.catch((reason)=>({
                 status: 'failure',
@@ -78,7 +78,7 @@ const logger = createLogger('prover-client:orchestrator');
             throw new Error(`Invalid number of blocks for epoch (got ${totalNumBlocks})`);
         }
         logger.info(`Starting epoch ${epochNumber} with ${totalNumBlocks} blocks`);
-        this.provingState = new EpochProvingState(epochNumber, firstBlockNumber, totalNumBlocks, resolve, reject);
+        this.provingState = new EpochProvingState(epochNumber, firstBlockNumber, totalNumBlocks, finalBlobBatchingChallenges, resolve, reject);
         this.provingPromise = promise;
     }
     /**
@@ -93,16 +93,17 @@ const logger = createLogger('prover-client:orchestrator');
         if (!this.provingState?.isAcceptingBlocks()) {
             throw new Error(`Epoch not accepting further blocks`);
         }
-        logger.info(`Starting block ${globalVariables.blockNumber.toNumber()} for slot ${globalVariables.slotNumber.toNumber()}`);
+        logger.info(`Starting block ${globalVariables.blockNumber} for slot ${globalVariables.slotNumber.toNumber()}`);
         // Fork world state at the end of the immediately previous block
-        const db = await this.dbProvider.fork(globalVariables.blockNumber.toNumber() - 1);
-        this.dbs.set(globalVariables.blockNumber.toNumber(), db);
+        const db = await this.dbProvider.fork(globalVariables.blockNumber - 1);
+        this.dbs.set(globalVariables.blockNumber, db);
         // we start the block by enqueueing all of the base parity circuits
-        const { l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, baseParityInputs } = await this.prepareBaseParityInputs(l1ToL2Messages, db);
+        const { l1ToL2MessageTreeSnapshot, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, baseParityInputs } = await this.prepareBaseParityInputs(l1ToL2Messages, db);
         // Get archive snapshot before this block lands
         const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
+        const lastArchiveSiblingPath = await getLastSiblingPath(MerkleTreeId.ARCHIVE, db);
         const newArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
-        const blockProvingState = this.provingState.startNewBlock(globalVariables, l1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchive, newArchiveSiblingPath, previousBlockHeader);
+        const blockProvingState = this.provingState.startNewBlock(globalVariables, l1ToL2Messages, l1ToL2MessageTreeSnapshot, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchive, lastArchiveSiblingPath, newArchiveSiblingPath, previousBlockHeader, this.proverId);
         // Enqueue base parity circuits for the block
         for(let i = 0; i < baseParityInputs.length; i++){
             this.enqueueBaseParityCircuit(blockProvingState, baseParityInputs[i], i);
@@ -118,7 +119,7 @@ const logger = createLogger('prover-client:orchestrator');
             logger.warn(`Provided no txs to orchestrator addTxs.`);
             return;
         }
-        const blockNumber = txs[0].constants.globalVariables.blockNumber.toNumber();
+        const blockNumber = txs[0].globalVariables.blockNumber;
         const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber);
         if (!provingState) {
             throw new Error(`Block proving state for ${blockNumber} not found`);
@@ -154,18 +155,19 @@ const logger = createLogger('prover-client:orchestrator');
     /**
    * Kickstarts tube circuits for the specified txs. These will be used during epoch proving.
    * Note that if the tube circuits are not started this way, they will be started nontheless after processing.
-   */ async startTubeCircuits(txs) {
+   */ startTubeCircuits(txs) {
         if (!this.provingState?.verifyState()) {
             throw new Error(`Invalid proving state, call startNewEpoch before starting tube circuits`);
         }
         for (const tx of txs){
-            const txHash = (await tx.getTxHash()).toString();
-            const tubeInputs = new TubeInputs(tx.clientIvcProof);
+            const txHash = tx.getTxHash().toString();
+            const tubeInputs = new TubeInputs(!!tx.data.forPublic, tx.clientIvcProof);
             const tubeProof = promiseWithResolvers();
             logger.debug(`Starting tube circuit for tx ${txHash}`);
             this.doEnqueueTube(txHash, tubeInputs, (proof)=>tubeProof.resolve(proof));
             this.provingState?.cachedTubeProofs.set(txHash, tubeProof.promise);
         }
+        return Promise.resolve();
     }
     /**
    * Marks the block as completed.
@@ -176,7 +178,7 @@ const logger = createLogger('prover-client:orchestrator');
             throw new Error(`Block proving state for ${blockNumber} not found`);
         }
         if (!provingState.spongeBlobState) {
-            // If we are completing an empty block, initialise the provingState.
+            // If we are completing an empty block, initialize the provingState.
             // We will have 0 txs and no blob fields.
             provingState.startNewBlock(0, 0);
         }
@@ -186,6 +188,8 @@ const logger = createLogger('prover-client:orchestrator');
         // And build the block header
         logger.verbose(`Block ${blockNumber} completed. Assembling header.`);
         await this.buildBlock(provingState, expectedHeader);
+        logger.debug(`Accumulating blobs for ${blockNumber}`);
+        await this.provingState?.setBlobAccumulators(blockNumber);
         // If the proofs were faster than the block building, then we need to try the block root rollup again here
         await this.checkAndEnqueueBlockRootRollup(provingState);
         return provingState.block;
@@ -215,8 +219,8 @@ const logger = createLogger('prover-client:orchestrator');
         const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
         const l2Block = new L2Block(newArchive, header, body);
         await this.verifyBuiltBlockAgainstSyncedState(l2Block, newArchive);
-        logger.verbose(`Orchestrator finalised block ${l2Block.number}`);
-        provingState.block = l2Block;
+        logger.verbose(`Orchestrator finalized block ${l2Block.number}`);
+        provingState.setBlock(l2Block);
     }
     // Flagged as protected to disable in certain unit tests
     async verifyBuiltBlockAgainstSyncedState(l2Block, newArchive) {
@@ -235,14 +239,22 @@ const logger = createLogger('prover-client:orchestrator');
     }
     /**
    * Returns the proof for the current epoch.
-   */ async finaliseEpoch() {
+   */ async finalizeEpoch() {
         if (!this.provingState || !this.provingPromise) {
-            throw new Error(`Invalid proving state, an epoch must be proven before it can be finalised`);
+            throw new Error(`Invalid proving state, an epoch must be proven before it can be finalized`);
         }
         const result = await this.provingPromise;
         if (result.status === 'failure') {
             throw new Error(`Epoch proving failed: ${result.reason}`);
         }
+        // TODO(MW): Move this? Requires async and don't want to force root methods to be async
+        // TODO(MW): EpochProvingState uses this.blocks.filter(b => !!b).length as total blocks, use this below:
+        const finalBlock = this.provingState.blocks[this.provingState.totalNumBlocks - 1];
+        if (!finalBlock || !finalBlock.endBlobAccumulator) {
+            throw new Error(`Epoch's final block not ready for finalize`);
+        }
+        const finalBatchedBlob = await finalBlock.endBlobAccumulator.finalize();
+        this.provingState.setFinalBatchedBlob(finalBatchedBlob);
         const epochProofResult = this.provingState.getEpochProofResult();
         pushTestData('epochProofResult', {
             proof: epochProofResult.proof.toString(),
@@ -314,11 +326,13 @@ const logger = createLogger('prover-client:orchestrator');
     async prepareBaseParityInputs(l1ToL2Messages, db) {
         const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, 'Too many L1 to L2 messages');
         const baseParityInputs = times(NUM_BASE_PARITY_PER_ROOT_PARITY, (i)=>BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i, getVKTreeRoot()));
+        const l1ToL2MessageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
         const l1ToL2MessageSubtreeSiblingPath = assertLength(await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, db), L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH);
         // Update the local trees to include the new l1 to l2 messages
         await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
         const l1ToL2MessageTreeSnapshotAfterInsertion = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
         return {
+            l1ToL2MessageTreeSnapshot,
             l1ToL2MessageSubtreeSiblingPath,
             l1ToL2MessageTreeSnapshotAfterInsertion,
             baseParityInputs
@@ -333,7 +347,7 @@ const logger = createLogger('prover-client:orchestrator');
         const db = this.dbs.get(provingState.blockNumber);
         // We build the base rollup inputs using a mock proof and verification key.
         // These will be overwritten later once we have proven the tube circuit and any public kernels
-        const [ms, hints] = await elapsed(buildBaseRollupHints(tx, provingState.globalVariables, db, provingState.spongeBlobState));
+        const [ms, hints] = await elapsed(insertSideEffectsAndBuildBaseRollupHints(tx, provingState.globalVariables, provingState.l1ToL2MessageTreeSnapshotAfterInsertion, db, provingState.spongeBlobState));
         this.metrics.recordBaseRollupInputs(ms);
         const promises = [
             MerkleTreeId.NOTE_HASH_TREE,
@@ -371,7 +385,6 @@ const logger = createLogger('prover-client:orchestrator');
         logger.debug(`Enqueuing deferred proving base rollup for ${processedTx.hash.toString()}`);
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, `ProvingOrchestrator.prover.${inputs instanceof PrivateBaseRollupInputs ? 'getPrivateBaseRollupProof' : 'getPublicBaseRollupProof'}`, {
             [Attributes.TX_HASH]: processedTx.hash.toString(),
-            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
             [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType
         }, (signal)=>{
             if (inputs instanceof PrivateBaseRollupInputs) {
@@ -424,7 +437,6 @@ const logger = createLogger('prover-client:orchestrator');
         }
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getTubeProof', {
             [Attributes.TX_HASH]: txHash,
-            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
             [Attributes.PROTOCOL_CIRCUIT_NAME]: 'tube-circuit'
         }, (signal)=>this.prover.getTubeProof(inputs, signal, this.provingState.epochNumber)), handler);
     }
@@ -437,7 +449,6 @@ const logger = createLogger('prover-client:orchestrator');
         }
         const inputs = provingState.getMergeRollupInputs(location);
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getMergeRollupProof', {
-            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
             [Attributes.PROTOCOL_CIRCUIT_NAME]: 'merge-rollup'
         }, (signal)=>this.prover.getMergeRollupProof(inputs, signal, provingState.epochNumber)), async (result)=>{
             provingState.setMergeRollupProof(location, result);
@@ -451,10 +462,9 @@ const logger = createLogger('prover-client:orchestrator');
             return;
         }
         provingState.blockRootRollupStarted = true;
-        const { rollupType, inputs } = await provingState.getBlockRootRollupTypeAndInputs(this.proverId);
+        const { rollupType, inputs } = await provingState.getBlockRootRollupTypeAndInputs();
         logger.debug(`Enqueuing ${rollupType} for block ${provingState.blockNumber} with ${provingState.newL1ToL2Messages.length} l1 to l2 msgs.`);
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getBlockRootRollupProof', {
-            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
             [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType
         }, (signal)=>{
             if (inputs instanceof EmptyBlockRootRollupInputs) {
@@ -466,17 +476,29 @@ const logger = createLogger('prover-client:orchestrator');
             }
         }), async (result)=>{
             provingState.setBlockRootRollupProof(result);
-            const header = await provingState.buildHeaderFromProvingOutputs(logger);
+            const header = await provingState.buildHeaderFromProvingOutputs();
             if (!(await header.hash()).equals(await provingState.block.header.hash())) {
-                logger.error(`Block header mismatch\nCircuit:${inspect(header)}\nComputed:${inspect(provingState.block.header)}`);
-                provingState.reject(`Block header hash mismatch`);
+                logger.error(`Block header mismatch.\nCircuit: ${inspect(header)}\nComputed: ${inspect(provingState.block.header)}`);
+                provingState.reject(`Block header hash mismatch.`);
+            }
+            const dbArchiveRoot = provingState.block.archive.root;
+            const circuitArchiveRoot = result.inputs.newArchive.root;
+            if (!dbArchiveRoot.equals(circuitArchiveRoot)) {
+                logger.error(`New archive root mismatch.\nCircuit: ${result.inputs.newArchive.root}\nComputed: ${dbArchiveRoot}`);
+                provingState.reject(`New archive root mismatch.`);
+            }
+            const endBlobAccumulatorPublicInputs = BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(provingState.endBlobAccumulator);
+            const circuitEndBlobAccumulatorState = result.inputs.blobPublicInputs.endBlobAccumulator;
+            if (!circuitEndBlobAccumulatorState.equals(endBlobAccumulatorPublicInputs)) {
+                logger.error(`Blob accumulator state mismatch.\nCircuit: ${inspect(circuitEndBlobAccumulatorState)}\nComputed: ${inspect(endBlobAccumulatorPublicInputs)}`);
+                provingState.reject(`Blob accumulator state mismatch.`);
             }
             logger.debug(`Completed ${rollupType} proof for block ${provingState.block.number}`);
             // validatePartialState(result.inputs.end, tx.treeSnapshots); // TODO(palla/prover)
             const epochProvingState = this.provingState;
             const leafLocation = epochProvingState.setBlockRootRollupProof(provingState.index, result);
             if (epochProvingState.totalNumBlocks === 1) {
-                await this.enqueueEpochPadding(epochProvingState);
+                this.enqueueEpochPadding(epochProvingState);
             } else {
                 this.checkAndEnqueueNextBlockMergeRollup(epochProvingState, leafLocation);
             }
@@ -490,7 +512,6 @@ const logger = createLogger('prover-client:orchestrator');
             return;
         }
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getBaseParityProof', {
-            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
             [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-parity'
         }, (signal)=>this.prover.getBaseParityProof(inputs, signal, provingState.epochNumber)), (provingOutput)=>{
             provingState.setBaseParityProof(index, provingOutput);
@@ -512,7 +533,6 @@ const logger = createLogger('prover-client:orchestrator');
         }
         const inputs = provingState.getRootParityInputs();
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getRootParityProof', {
-            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
             [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-parity'
         }, (signal)=>this.prover.getRootParityProof(inputs, signal, provingState.epochNumber)), async (result)=>{
             provingState.setRootParityProof(result);
@@ -528,24 +548,22 @@ const logger = createLogger('prover-client:orchestrator');
         }
         const inputs = provingState.getBlockMergeRollupInputs(location);
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getBlockMergeRollupProof', {
-            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
             [Attributes.PROTOCOL_CIRCUIT_NAME]: 'block-merge-rollup'
         }, (signal)=>this.prover.getBlockMergeRollupProof(inputs, signal, provingState.epochNumber)), (result)=>{
             provingState.setBlockMergeRollupProof(location, result);
             this.checkAndEnqueueNextBlockMergeRollup(provingState, location);
         });
     }
-    async enqueueEpochPadding(provingState) {
+    enqueueEpochPadding(provingState) {
         if (!provingState.verifyState()) {
             logger.debug('Not running epoch padding. State no longer valid.');
             return;
         }
-        logger.debug('Padding epoch proof with an empty block root proof.');
-        const inputs = await provingState.getPaddingBlockRootInputs(this.proverId);
-        this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getEmptyBlockRootRollupProof', {
-            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-            [Attributes.PROTOCOL_CIRCUIT_NAME]: 'empty-block-root-rollup'
-        }, (signal)=>this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber)), (result)=>{
+        logger.debug('Padding epoch proof with a padding block root proof.');
+        const inputs = provingState.getPaddingBlockRootInputs();
+        this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getPaddingBlockRootRollupProof', {
+            [Attributes.PROTOCOL_CIRCUIT_NAME]: 'padding-block-root-rollup'
+        }, (signal)=>this.prover.getPaddingBlockRootRollupProof(inputs, signal, provingState.epochNumber)), (result)=>{
             logger.debug('Completed proof for padding block root.');
             provingState.setPaddingBlockRootProof(result);
             this.checkAndEnqueueRootRollup(provingState);
@@ -558,9 +576,8 @@ const logger = createLogger('prover-client:orchestrator');
             return;
         }
         logger.debug(`Preparing root rollup`);
-        const inputs = provingState.getRootRollupInputs(this.proverId);
+        const inputs = provingState.getRootRollupInputs();
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getRootRollupProof', {
-            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
             [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-rollup'
         }, (signal)=>this.prover.getRootRollupProof(inputs, signal, provingState.epochNumber)), (result)=>{
             logger.verbose(`Orchestrator completed root rollup for epoch ${provingState.epochNumber}`);
@@ -582,15 +599,17 @@ const logger = createLogger('prover-client:orchestrator');
         }
     }
     async checkAndEnqueueBlockRootRollup(provingState) {
+        const blockNumber = provingState.blockNumber;
+        // Accumulate as far as we can, in case blocks came in out of order and we are behind:
+        await this.provingState?.setBlobAccumulators(blockNumber);
         if (!provingState.isReadyForBlockRootRollup()) {
-            logger.debug('Not ready for root rollup');
+            logger.debug('Not ready for block root rollup');
             return;
         }
         if (provingState.blockRootRollupStarted) {
             logger.debug('Block root rollup already started');
             return;
         }
-        const blockNumber = provingState.blockNumber;
         // TODO(palla/prover): This closes the fork only on the happy path. If this epoch orchestrator
         // is aborted and never reaches this point, it will leak the fork. We need to add a global cleanup,
         // but have to make sure it only runs once all operations are completed, otherwise some function here
@@ -635,17 +654,24 @@ const logger = createLogger('prover-client:orchestrator');
         }, async (signal)=>{
             const inputs = txProvingState.getAvmInputs();
             try {
-                return await this.prover.getAvmProof(inputs, signal, provingState.epochNumber);
+                // TODO(#14234)[Unconditional PIs validation]: Remove the whole try-catch logic and
+                // just keep the next line but removing the second argument (false).
+                return await this.prover.getAvmProof(inputs, false, signal, provingState.epochNumber);
             } catch (err) {
                 if (process.env.AVM_PROVING_STRICT) {
                     logger.error(`Error thrown when proving AVM circuit with AVM_PROVING_STRICT on`, err);
                     throw err;
                 } else {
-                    logger.warn(`Error thrown when proving AVM circuit but AVM_PROVING_STRICT is off. Faking AVM proof and carrying on. ${inspect(err)}.`);
-                    return {
-                        proof: makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
-                        verificationKey: VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS)
-                    };
+                    logger.warn(`Error thrown when proving AVM circuit but AVM_PROVING_STRICT is off. Use snapshotted
+               AVM inputs and carrying on. ${inspect(err)}.`);
+                    try {
+                        this.metrics.incAvmFallback();
+                        const snapshotAvmPrivateInputs = readAvmMinimalPublicTxInputsFromFile();
+                        return await this.prover.getAvmProof(snapshotAvmPrivateInputs, true, signal, provingState.epochNumber);
+                    } catch (err) {
+                        logger.error(`Error thrown when proving snapshotted AVM inputs.`, err);
+                        throw err;
+                    }
                 }
             }
         });
@@ -667,7 +693,7 @@ const logger = createLogger('prover-client:orchestrator');
 }
 _ts_decorate([
     trackSpan('ProvingOrchestrator.startNewBlock', (globalVariables)=>({
-            [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber()
+            [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber
         }))
 ], ProvingOrchestrator.prototype, "startNewBlock", null);
 _ts_decorate([

package/dest/orchestrator/orchestrator_metrics.d.ts

@@ -2,7 +2,9 @@ import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
 export declare class ProvingOrchestratorMetrics {
     readonly tracer: Tracer;
     private baseRollupInputsDuration;
+    private avmFallbackCount;
     constructor(client: TelemetryClient, name?: string);
     recordBaseRollupInputs(durationMs: number): void;
+    incAvmFallback(): void;
 }
 //# sourceMappingURL=orchestrator_metrics.d.ts.map

package/dest/orchestrator/orchestrator_metrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrator_metrics.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator_metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,eAAe,EAAE,KAAK,MAAM,EAAa,MAAM,yBAAyB,CAAC;AAEhH,qBAAa,0BAA0B;IACrC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,wBAAwB,CAAY;gBAEhC,MAAM,EAAE,eAAe,EAAE,IAAI,SAAwB;IAWjE,sBAAsB,CAAC,UAAU,EAAE,MAAM;CAG1C"}
+{"version":3,"file":"orchestrator_metrics.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator_metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,0BAA0B;IACrC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,wBAAwB,CAAY;IAC5C,OAAO,CAAC,gBAAgB,CAAgB;gBAE5B,MAAM,EAAE,eAAe,EAAE,IAAI,SAAwB;IAkBjE,sBAAsB,CAAC,UAAU,EAAE,MAAM;IAIzC,cAAc;CAGf"}