@aztec/prover-client 0.72.1 → 0.74.0

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

@@ -136,7 +136,7 @@ export const buildBaseRollupHints = runInSpan(
 
     // Append new data to startSpongeBlob
     const inputSpongeBlob = startSpongeBlob.clone();
-    startSpongeBlob.absorb(tx.txEffect.toBlobFields());
+    await startSpongeBlob.absorb(tx.txEffect.toBlobFields());
 
     if (tx.avmProvingRequest) {
       // Build public base rollup hints
@@ -172,7 +172,7 @@ export const buildBaseRollupHints = runInSpan(
         ),
       });
 
-      const blockHash = tx.constants.historicalHeader.hash();
+      const blockHash = await tx.constants.historicalHeader.hash();
       const archiveRootMembershipWitness = await getMembershipWitnessFor(
         blockHash,
         MerkleTreeId.ARCHIVE,
@@ -198,7 +198,7 @@ export const buildBaseRollupHints = runInSpan(
 
       // 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 = computeFeePayerBalanceLeafSlot(tx.data.feePayer);
+      const leafSlot = await computeFeePayerBalanceLeafSlot(tx.data.feePayer);
       const feePayerFeeJuiceBalanceReadHint = tx.data.feePayer.isZero()
         ? PublicDataHint.empty()
         : await getPublicDataHint(db, leafSlot.toBigInt());
@@ -232,7 +232,7 @@ export const buildBaseRollupHints = runInSpan(
         feeWriteSiblingPath,
       });
 
-      const blockHash = tx.constants.historicalHeader.hash();
+      const blockHash = await tx.constants.historicalHeader.hash();
       const archiveRootMembershipWitness = await getMembershipWitnessFor(
         blockHash,
         MerkleTreeId.ARCHIVE,
@@ -275,9 +275,9 @@ export async function getPublicDataHint(db: MerkleTreeWriteOperations, leafSlot:
 export const buildBlobHints = runInSpan(
   'BlockBuilderHelpers',
   'buildBlobHints',
-  (_span: Span, txEffects: TxEffect[]) => {
+  async (_span: Span, txEffects: TxEffect[]) => {
     const blobFields = txEffects.flatMap(tx => tx.toBlobFields());
-    const blobs = Blob.getBlobs(blobFields);
+    const blobs = await Blob.getBlobs(blobFields);
     const blobCommitments = blobs.map(b => b.commitmentToFields());
     const blobsHash = new Fr(getBlobsHashFromBlobs(blobs));
     return { blobFields, blobCommitments, blobs, blobsHash };
@@ -287,7 +287,7 @@ export const buildBlobHints = runInSpan(
 export const buildHeaderFromCircuitOutputs = runInSpan(
   'BlockBuilderHelpers',
   'buildHeaderFromCircuitOutputs',
-  (
+  async (
     _span,
     previousRollupData: BaseOrMergeRollupPublicInputs[],
     parityPublicInputs: ParityPublicInputs,
@@ -326,7 +326,7 @@ export const buildHeaderFromCircuitOutputs = runInSpan(
       accumulatedFees,
       accumulatedManaUsed,
     );
-    if (!header.hash().equals(rootRollupOutputs.endBlockHash)) {
+    if (!(await header.hash()).equals(rootRollupOutputs.endBlockHash)) {
       logger?.error(
         `Block header mismatch when building header from circuit outputs.` +
           `\n\nHeader: ${inspect(header)}` +
@@ -375,12 +375,11 @@ export const buildHeaderAndBodyFromTxs = runInSpan(
           );
 
     l1ToL2Messages = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-    const hasher = (left: Buffer, right: Buffer) => sha256Trunc(Buffer.concat([left, right]));
+    const hasher = (left: Buffer, right: Buffer) => Promise.resolve(sha256Trunc(Buffer.concat([left, right])));
     const parityHeight = Math.ceil(Math.log2(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
-    const parityShaRoot = new MerkleTreeCalculator(parityHeight, Fr.ZERO.toBuffer(), hasher).computeTreeRoot(
-      l1ToL2Messages.map(msg => msg.toBuffer()),
-    );
-    const blobsHash = getBlobsHashFromBlobs(Blob.getBlobs(body.toBlobFields()));
+    const parityCalculator = await MerkleTreeCalculator.create(parityHeight, Fr.ZERO.toBuffer(), hasher);
+    const parityShaRoot = await parityCalculator.computeTreeRoot(l1ToL2Messages.map(msg => msg.toBuffer()));
+    const blobsHash = getBlobsHashFromBlobs(await Blob.getBlobs(body.toBlobFields()));
 
     const contentCommitment = new ContentCommitment(new Fr(numTxs), blobsHash, parityShaRoot, outHash);
 
@@ -442,7 +441,7 @@ export const getConstantRollupData = runInSpan(
   'getConstantRollupData',
   async (_span, globalVariables: GlobalVariables, db: MerkleTreeReadOperations): Promise<ConstantRollupData> => {
     return ConstantRollupData.from({
-      vkTreeRoot: getVKTreeRoot(),
+      vkTreeRoot: await getVKTreeRoot(),
       protocolContractTreeRoot,
       lastArchive: await getTreeSnapshot(MerkleTreeId.ARCHIVE, db),
       globalVariables,

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

@@ -164,16 +164,16 @@ export class BlockProvingState {
     return this.baseOrMergeProvingOutputs.getParentLocation(location);
   }
 
-  public getMergeRollupInputs(mergeLocation: TreeNodeLocation) {
+  public async getMergeRollupInputs(mergeLocation: TreeNodeLocation) {
     const [left, right] = this.baseOrMergeProvingOutputs.getChildren(mergeLocation);
     if (!left || !right) {
       throw new Error('At lease one child is not ready.');
     }
 
-    return new MergeRollupInputs([this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)]);
+    return new MergeRollupInputs([await this.#getPreviousRollupData(left), await this.#getPreviousRollupData(right)]);
   }
 
-  public getBlockRootRollupTypeAndInputs(proverId: Fr) {
+  public async getBlockRootRollupTypeAndInputs(proverId: Fr) {
     if (!this.rootParityProvingOutput) {
       throw new Error('Root parity is not ready.');
     }
@@ -184,13 +184,13 @@ export class BlockProvingState {
       throw new Error('At lease one child is not ready for the block root.');
     }
 
-    const data = this.#getBlockRootRollupData(proverId);
+    const data = await this.#getBlockRootRollupData(proverId);
 
     if (this.totalNumTxs === 0) {
       const constants = ConstantRollupData.from({
         lastArchive: this.lastArchiveSnapshot,
         globalVariables: this.globalVariables,
-        vkTreeRoot: getVKTreeRoot(),
+        vkTreeRoot: await getVKTreeRoot(),
         protocolContractTreeRoot,
       });
 
@@ -204,8 +204,8 @@ export class BlockProvingState {
       };
     }
 
-    const previousRollupData = nonEmptyProofs.map(p => this.#getPreviousRollupData(p!));
-    const blobData = this.#getBlockRootRollupBlobData();
+    const previousRollupData = await Promise.all(nonEmptyProofs.map(p => this.#getPreviousRollupData(p!)));
+    const blobData = await this.#getBlockRootRollupBlobData();
 
     if (previousRollupData.length === 1) {
       return {
@@ -224,17 +224,17 @@ export class BlockProvingState {
     }
   }
 
-  public getPaddingBlockRootInputs(proverId: Fr) {
+  public async getPaddingBlockRootInputs(proverId: Fr) {
     if (!this.rootParityProvingOutput) {
       throw new Error('Root parity is not ready.');
     }
 
     // Use the new block header and archive of the current block as the previous header and archiver of the next padding block.
-    const newBlockHeader = this.buildHeaderFromProvingOutputs();
+    const newBlockHeader = await this.buildHeaderFromProvingOutputs();
     const newArchive = this.blockRootProvingOutput!.inputs.newArchive;
 
     const data = BlockRootRollupData.from({
-      l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput!),
+      l1ToL2Roots: await this.#getRootParityData(this.rootParityProvingOutput!),
       l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
       newArchiveSiblingPath: this.newArchiveSiblingPath,
       previousBlockHeader: newBlockHeader,
@@ -244,7 +244,7 @@ export class BlockProvingState {
     const constants = ConstantRollupData.from({
       lastArchive: newArchive,
       globalVariables: this.globalVariables,
-      vkTreeRoot: getVKTreeRoot(),
+      vkTreeRoot: await getVKTreeRoot(),
       protocolContractTreeRoot,
     });
 
@@ -255,12 +255,12 @@ export class BlockProvingState {
     });
   }
 
-  public getRootParityInputs() {
+  public async getRootParityInputs() {
     if (!this.baseParityProvingOutputs.every(p => !!p)) {
       throw new Error('At lease one base parity is not ready.');
     }
 
-    const children = this.baseParityProvingOutputs.map(p => this.#getRootParityData(p!));
+    const children = await Promise.all(this.baseParityProvingOutputs.map(p => this.#getRootParityData(p!)));
     return new RootParityInputs(
       children as Tuple<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>, typeof NUM_BASE_PARITY_PER_ROOT_PARITY>,
     );
@@ -271,9 +271,11 @@ export class BlockProvingState {
     return this.txs[txIndex];
   }
 
-  public buildHeaderFromProvingOutputs(logger?: Logger) {
+  public async buildHeaderFromProvingOutputs(logger?: Logger) {
     const previousRollupData =
-      this.totalNumTxs === 0 ? [] : this.#getChildProofsForBlockRoot().map(p => this.#getPreviousRollupData(p!));
+      this.totalNumTxs === 0
+        ? []
+        : await Promise.all(this.#getChildProofsForBlockRoot().map(p => this.#getPreviousRollupData(p!)));
 
     let endPartialState = this.previousBlockHeader.state.partial;
     if (this.totalNumTxs !== 0) {
@@ -324,9 +326,9 @@ export class BlockProvingState {
     this.parentEpoch.reject(reason);
   }
 
-  #getBlockRootRollupData(proverId: Fr) {
+  async #getBlockRootRollupData(proverId: Fr) {
     return BlockRootRollupData.from({
-      l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput!),
+      l1ToL2Roots: await this.#getRootParityData(this.rootParityProvingOutput!),
       l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
       newArchiveSiblingPath: this.newArchiveSiblingPath,
       previousBlockHeader: this.previousBlockHeader,
@@ -334,9 +336,9 @@ export class BlockProvingState {
     });
   }
 
-  #getBlockRootRollupBlobData() {
+  async #getBlockRootRollupBlobData() {
     const txEffects = this.txs.map(txProvingState => txProvingState.processedTx.txEffect);
-    const { blobFields, blobCommitments, blobsHash } = buildBlobHints(txEffects);
+    const { blobFields, blobCommitments, blobsHash } = await buildBlobHints(txEffects);
     return BlockRootRollupBlobData.from({
       blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_BLOCK),
       blobCommitments: padArrayEnd(blobCommitments, [Fr.ZERO, Fr.ZERO], BLOBS_PER_BLOCK),
@@ -356,25 +358,25 @@ export class BlockProvingState {
       : this.baseOrMergeProvingOutputs.getChildren(rootLocation);
   }
 
-  #getPreviousRollupData({
+  async #getPreviousRollupData({
     inputs,
     proof,
     verificationKey,
   }: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>) {
-    const leafIndex = getVKIndex(verificationKey.keyAsFields);
+    const leafIndex = await getVKIndex(verificationKey.keyAsFields);
     return new PreviousRollupData(
       inputs,
       proof,
       verificationKey.keyAsFields,
-      new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)),
+      new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), await getVKSiblingPath(leafIndex)),
     );
   }
 
-  #getRootParityData({ inputs, proof, verificationKey }: PublicInputsAndRecursiveProof<ParityPublicInputs>) {
+  async #getRootParityData({ inputs, proof, verificationKey }: PublicInputsAndRecursiveProof<ParityPublicInputs>) {
     return new RootParityInput(
       proof,
       verificationKey.keyAsFields,
-      getVKSiblingPath(getVKIndex(verificationKey)),
+      await getVKSiblingPath(await getVKIndex(verificationKey)),
       inputs,
     );
   }

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

@@ -150,23 +150,26 @@ export class EpochProvingState {
     return this.blockRootOrMergeProvingOutputs.getParentLocation(location);
   }
 
-  public getBlockMergeRollupInputs(mergeLocation: TreeNodeLocation) {
+  public async getBlockMergeRollupInputs(mergeLocation: TreeNodeLocation) {
     const [left, right] = this.blockRootOrMergeProvingOutputs.getChildren(mergeLocation);
     if (!left || !right) {
       throw new Error('At lease one child is not ready.');
     }
 
-    return new BlockMergeRollupInputs([this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)]);
+    return new BlockMergeRollupInputs([
+      await this.#getPreviousRollupData(left),
+      await this.#getPreviousRollupData(right),
+    ]);
   }
 
-  public getRootRollupInputs(proverId: Fr) {
+  public async getRootRollupInputs(proverId: Fr) {
     const [left, right] = this.#getChildProofsForRoot();
     if (!left || !right) {
       throw new Error('At lease one child is not ready.');
     }
 
     return RootRollupInputs.from({
-      previousRollupData: [this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)],
+      previousRollupData: [await this.#getPreviousRollupData(left), await this.#getPreviousRollupData(right)],
       proverId,
     });
   }
@@ -238,7 +241,7 @@ export class EpochProvingState {
       : this.blockRootOrMergeProvingOutputs.getChildren(rootLocation);
   }
 
-  #getPreviousRollupData({
+  async #getPreviousRollupData({
     inputs,
     proof,
     verificationKey,
@@ -246,12 +249,12 @@ export class EpochProvingState {
     BlockRootOrBlockMergePublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >) {
-    const leafIndex = getVKIndex(verificationKey.keyAsFields);
+    const leafIndex = await getVKIndex(verificationKey.keyAsFields);
     return new PreviousRollupBlockData(
       inputs,
       proof,
       verificationKey.keyAsFields,
-      new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)),
+      new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), await getVKSiblingPath(leafIndex)),
     );
   }
 }