@aztec/prover-client 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/test/mock_prover.ts

@@ -1,44 +1,51 @@
 import {
-  AVM_PROOF_LENGTH_IN_FIELDS,
-  AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
-  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
 import { times } from '@aztec/foundation/collection';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
 import {
-  type ProofAndVerificationKey,
   type ProvingJob,
   type ProvingJobId,
   type ProvingJobProducer,
   type ProvingJobStatus,
   type PublicInputsAndRecursiveProof,
   type ServerCircuitProver,
-  makeProofAndVerificationKey,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/stdlib/interfaces/server';
-import type { BaseParityInputs, RootParityInputs } from '@aztec/stdlib/parity';
+import type { ParityBasePrivateInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
 import { makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
 import type {
-  BaseOrMergeRollupPublicInputs,
-  BlockMergeRollupInputs,
-  BlockRootOrBlockMergePublicInputs,
-  BlockRootRollupInputs,
-  EmptyBlockRootRollupInputs,
-  MergeRollupInputs,
-  PrivateBaseRollupInputs,
-  PublicBaseRollupInputs,
-  RootRollupInputs,
+  BlockMergeRollupPrivateInputs,
+  BlockRollupPublicInputs,
+  BlockRootEmptyTxFirstRollupPrivateInputs,
+  BlockRootFirstRollupPrivateInputs,
+  BlockRootRollupPrivateInputs,
+  BlockRootSingleTxFirstRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+  CheckpointMergeRollupPrivateInputs,
+  CheckpointPaddingRollupPrivateInputs,
+  CheckpointRollupPublicInputs,
+  CheckpointRootRollupPrivateInputs,
+  CheckpointRootSingleBlockRollupPrivateInputs,
+  PrivateTxBaseRollupPrivateInputs,
+  PublicChonkVerifierPrivateInputs,
+  PublicChonkVerifierPublicInputs,
+  PublicTxBaseRollupPrivateInputs,
+  RootRollupPrivateInputs,
   RootRollupPublicInputs,
-  SingleTxBlockRootRollupInputs,
+  TxMergeRollupPrivateInputs,
+  TxRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
 import {
-  makeBaseOrMergeRollupPublicInputs,
-  makeBlockRootOrBlockMergeRollupPublicInputs,
+  makeBlockRollupPublicInputs,
+  makeCheckpointRollupPublicInputs,
   makeParityPublicInputs,
+  makePublicChonkVerifierPublicInputs,
   makeRootRollupPublicInputs,
+  makeTxRollupPublicInputs,
 } from '@aztec/stdlib/testing';
 import { VerificationKeyData } from '@aztec/stdlib/vks';
 
@@ -97,15 +104,10 @@ export class MockProver implements ServerCircuitProver {
   constructor() {}
 
   getAvmProof(_inputs: AvmCircuitInputs, _signal?: AbortSignal, _epochNumber?: number) {
-    return Promise.resolve(
-      makeProofAndVerificationKey(
-        makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
-        VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS),
-      ),
-    );
+    return Promise.resolve(makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED));
   }
 
-  getBaseParityProof(_inputs: BaseParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getBaseParityProof(_inputs: ParityBasePrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeParityPublicInputs(),
@@ -115,7 +117,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getRootParityProof(_inputs: RootParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getRootParityProof(_inputs: ParityRootPrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeParityPublicInputs(),
@@ -125,114 +127,210 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getPrivateBaseRollupProof(
-    _baseRollupInput: PrivateBaseRollupInputs,
+  getPublicChonkVerifierProof(
+    _inputs: PublicChonkVerifierPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBaseOrMergeRollupPublicInputs(),
+        makePublicChonkVerifierPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getPublicBaseRollupProof(
-    _inputs: PublicBaseRollupInputs,
+  getPrivateTxBaseRollupProof(
+    _baseRollupInput: PrivateTxBaseRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBaseOrMergeRollupPublicInputs(),
+        makeTxRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getMergeRollupProof(
-    _input: MergeRollupInputs,
+  getPublicTxBaseRollupProof(
+    _inputs: PublicTxBaseRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeTxRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getTxMergeRollupProof(
+    _input: TxMergeRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeTxRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getBlockRootFirstRollupProof(
+    _input: BlockRootFirstRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBaseOrMergeRollupPublicInputs(),
+        makeBlockRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getBlockMergeRollupProof(_input: BlockMergeRollupInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getBlockRootSingleTxFirstRollupProof(
+    _input: BlockRootSingleTxFirstRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeHonk(),
+      ),
+    );
+  }
+
+  getBlockRootEmptyTxFirstRollupProof(
+    _input: BlockRootEmptyTxFirstRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeBlockRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getEmptyBlockRootRollupProof(
-    _input: EmptyBlockRootRollupInputs,
+  getBlockRootRollupProof(
+    _input: BlockRootRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getBlockRootSingleTxRollupProof(
+    _input: BlockRootSingleTxRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeHonk(),
+      ),
+    );
+  }
+
+  getBlockMergeRollupProof(_input: BlockMergeRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getCheckpointRootRollupProof(
+    _input: CheckpointRootRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeCheckpointRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getBlockRootRollupProof(
-    _input: BlockRootRollupInputs,
+  getCheckpointRootSingleBlockRollupProof(
+    _input: CheckpointRootSingleBlockRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeCheckpointRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getSingleTxBlockRootRollupProof(
-    _input: SingleTxBlockRootRollupInputs,
+  getCheckpointMergeRollupProof(
+    _input: CheckpointMergeRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeCheckpointRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-        VerificationKeyData.makeFakeHonk(),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getCheckpointPaddingRollupProof(
+    _input: CheckpointPaddingRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeCheckpointRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
   getRootRollupProof(
-    _input: RootRollupInputs,
+    _input: RootRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
@@ -244,10 +342,4 @@ export class MockProver implements ServerCircuitProver {
       ),
     );
   }
-
-  getTubeProof(): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
-    return Promise.resolve(
-      makeProofAndVerificationKey(makeRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()),
-    );
-  }
 }

package/dest/bin/get-proof-inputs.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=get-proof-inputs.d.ts.map

package/dest/bin/get-proof-inputs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-proof-inputs.d.ts","sourceRoot":"","sources":["../../src/bin/get-proof-inputs.ts"],"names":[],"mappings":""}

package/dest/bin/get-proof-inputs.js

@@ -1,51 +0,0 @@
-/* eslint-disable no-console */ import { AVM_INPUTS_FILENAME } from '@aztec/bb-prover';
-import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
-import { createLogger } from '@aztec/foundation/log';
-import { ProvingJobInputs } from '@aztec/stdlib/interfaces/server';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
-import { mkdirSync, writeFileSync } from 'fs';
-import { createProofStoreForUri } from '../proving_broker/index.js';
-const logger = createLogger('prover-client:get-proof-inputs');
-function printUsage() {
-    console.error('Usage: get-proof-inputs <proof-uri> [out-dir=.]');
-}
-async function main() {
-    if (process.argv[2] === '--help') {
-        printUsage();
-        return;
-    }
-    const uri = process.argv[2];
-    const outDir = process.argv[3] || '.';
-    if (!uri) {
-        printUsage();
-        throw new Error('Missing proof URI');
-    }
-    mkdirSync(outDir, {
-        recursive: true
-    });
-    const proofStore = createProofStoreForUri(uri);
-    logger.info(`Processing uri ${uri}`);
-    const input = await proofStore.getProofInput(uri);
-    logger.info(`Found inputs for ${ProvingRequestType[input.type]}`);
-    writeProofInputs(input, outDir);
-    console.log((await jsonParseWithSchema(jsonStringify(input), ProvingJobInputs)).inputs);
-}
-// This mimics the behavior of bb-prover/src/bb/execute.ts
-function writeProofInputs(input, outDir) {
-    switch(input.type){
-        case ProvingRequestType.PUBLIC_VM:
-            {
-                writeFileSync(`${outDir}/${AVM_INPUTS_FILENAME}`, input.inputs.serializeWithMessagePack());
-                logger.info(`Wrote AVM inputs to ${AVM_INPUTS_FILENAME}`);
-                break;
-            }
-        default:
-            {
-                throw new Error(`Unimplemented proving request type: ${ProvingRequestType[input.type]}`);
-            }
-    }
-}
-main().catch((err)=>{
-    console.error(err);
-    process.exit(1);
-});

package/dest/block_builder/index.d.ts

@@ -1,6 +0,0 @@
-import type { BlockBuilder, MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
-export * from './light.js';
-export interface BlockBuilderFactory {
-    create(db: MerkleTreeReadOperations): BlockBuilder;
-}
-//# sourceMappingURL=index.d.ts.map

package/dest/block_builder/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/block_builder/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAE9F,cAAc,YAAY,CAAC;AAC3B,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,EAAE,wBAAwB,GAAG,YAAY,CAAC;CACpD"}

package/dest/block_builder/index.js

@@ -1 +0,0 @@
-export * from './light.js';

package/dest/block_builder/light.d.ts

@@ -1,33 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { L2Block } from '@aztec/stdlib/block';
-import type { BlockBuilder, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
-import { type GlobalVariables, type ProcessedTx } from '@aztec/stdlib/tx';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-/**
- * Builds a block and its header from a set of processed tx without running any circuits.
- */
-export declare class LightweightBlockBuilder implements BlockBuilder {
-    private db;
-    private telemetry;
-    private spongeBlobState?;
-    private globalVariables?;
-    private l1ToL2Messages?;
-    private txs;
-    private readonly logger;
-    constructor(db: MerkleTreeWriteOperations, telemetry?: TelemetryClient);
-    startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void>;
-    addTxs(txs: ProcessedTx[]): Promise<void>;
-    setBlockCompleted(): Promise<L2Block>;
-    private buildBlock;
-}
-export declare class LightweightBlockBuilderFactory {
-    private telemetry;
-    constructor(telemetry?: TelemetryClient);
-    create(db: MerkleTreeWriteOperations): BlockBuilder;
-}
-/**
- * Creates a block builder under the hood with the given txs and messages and creates a block.
- * @param db - A db fork to use for block building.
- */
-export declare function buildBlock(txs: ProcessedTx[], globalVariables: GlobalVariables, l1ToL2Messages: Fr[], db: MerkleTreeWriteOperations, telemetry?: TelemetryClient): Promise<L2Block>;
-//# sourceMappingURL=light.d.ts.map

package/dest/block_builder/light.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"light.d.ts","sourceRoot":"","sources":["../../src/block_builder/light.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAE/F,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAmB,MAAM,kBAAkB,CAAC;AAC3F,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAQnF;;GAEG;AACH,qBAAa,uBAAwB,YAAW,YAAY;IAS9C,OAAO,CAAC,EAAE;IAA6B,OAAO,CAAC,SAAS;IARpE,OAAO,CAAC,eAAe,CAAC,CAAa;IACrC,OAAO,CAAC,eAAe,CAAC,CAAkB;IAC1C,OAAO,CAAC,cAAc,CAAC,CAAO;IAE9B,OAAO,CAAC,GAAG,CAAqB;IAEhC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+C;gBAElD,EAAE,EAAE,yBAAyB,EAAU,SAAS,GAAE,eAAsC;IAEtG,aAAa,CAAC,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAWpF,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/C,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;YAIvB,UAAU;CAoBzB;AAED,qBAAa,8BAA8B;IAC7B,OAAO,CAAC,SAAS;gBAAT,SAAS,GAAE,eAAsC;IAErE,MAAM,CAAC,EAAE,EAAE,yBAAyB,GAAG,YAAY;CAGpD;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,WAAW,EAAE,EAClB,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,EAAE,EAAE,EACpB,EAAE,EAAE,yBAAyB,EAC7B,SAAS,GAAE,eAAsC,oBAMlD"}

package/dest/block_builder/light.js

@@ -1,82 +0,0 @@
-import { SpongeBlob } from '@aztec/blob-lib';
-import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { L2Block } from '@aztec/stdlib/block';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { toNumBlobFields } from '@aztec/stdlib/tx';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import { buildBaseRollupHints, buildHeaderAndBodyFromTxs, getTreeSnapshot } from '../orchestrator/block-building-helpers.js';
-/**
- * Builds a block and its header from a set of processed tx without running any circuits.
- */ export class LightweightBlockBuilder {
-    db;
-    telemetry;
-    spongeBlobState;
-    globalVariables;
-    l1ToL2Messages;
-    txs;
-    logger;
-    constructor(db, telemetry = getTelemetryClient()){
-        this.db = db;
-        this.telemetry = telemetry;
-        this.txs = [];
-        this.logger = createLogger('prover-client:block_builder');
-    }
-    async startNewBlock(globalVariables, l1ToL2Messages) {
-        this.logger.debug('Starting new block', {
-            globalVariables: globalVariables.toInspect(),
-            l1ToL2Messages
-        });
-        this.globalVariables = globalVariables;
-        this.l1ToL2Messages = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-        this.txs = [];
-        this.spongeBlobState = undefined;
-        // Update L1 to L2 tree
-        await this.db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, this.l1ToL2Messages);
-    }
-    async addTxs(txs) {
-        this.spongeBlobState = SpongeBlob.init(toNumBlobFields(txs));
-        for (const tx of txs){
-            this.logger.debug('Adding new tx to block', {
-                txHash: tx.hash.toString()
-            });
-            this.txs.push(tx);
-            await buildBaseRollupHints(tx, this.globalVariables, this.db, this.spongeBlobState);
-        }
-    }
-    setBlockCompleted() {
-        return this.buildBlock();
-    }
-    async buildBlock() {
-        const { header, body } = await buildHeaderAndBodyFromTxs(this.txs, this.globalVariables, this.l1ToL2Messages, this.db);
-        await this.db.updateArchive(header);
-        const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
-        const block = new L2Block(newArchive, header, body);
-        this.logger.debug(`Built block ${block.number}`, {
-            globalVariables: this.globalVariables?.toInspect(),
-            archiveRoot: newArchive.root.toString(),
-            blockHash: block.hash.toString()
-        });
-        return block;
-    }
-}
-export class LightweightBlockBuilderFactory {
-    telemetry;
-    constructor(telemetry = getTelemetryClient()){
-        this.telemetry = telemetry;
-    }
-    create(db) {
-        return new LightweightBlockBuilder(db, this.telemetry);
-    }
-}
-/**
- * Creates a block builder under the hood with the given txs and messages and creates a block.
- * @param db - A db fork to use for block building.
- */ export async function buildBlock(txs, globalVariables, l1ToL2Messages, db, telemetry = getTelemetryClient()) {
-    const builder = new LightweightBlockBuilder(db, telemetry);
-    await builder.startNewBlock(globalVariables, l1ToL2Messages);
-    await builder.addTxs(txs);
-    return await builder.setBlockCompleted();
-}

package/dest/proving_broker/proving_agent_instrumentation.d.ts

@@ -1,8 +0,0 @@
-import type { Timer } from '@aztec/foundation/timer';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-export declare class ProvingAgentInstrumentation {
-    private idleTime;
-    constructor(client: TelemetryClient, name?: string);
-    recordIdleTime(msOrTimer: Timer | number): void;
-}
-//# sourceMappingURL=proving_agent_instrumentation.d.ts.map

package/dest/proving_broker/proving_agent_instrumentation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proving_agent_instrumentation.d.ts","sourceRoot":"","sources":["../../src/proving_broker/proving_agent_instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAA2B,KAAK,eAAe,EAAa,MAAM,yBAAyB,CAAC;AAEnG,qBAAa,2BAA2B;IACtC,OAAO,CAAC,QAAQ,CAAY;gBAEhB,MAAM,EAAE,eAAe,EAAE,IAAI,SAAiB;IAU1D,cAAc,CAAC,SAAS,EAAE,KAAK,GAAG,MAAM;CAIzC"}

package/dest/proving_broker/proving_agent_instrumentation.js

@@ -1,16 +0,0 @@
-import { Metrics, ValueType } from '@aztec/telemetry-client';
-export class ProvingAgentInstrumentation {
-    idleTime;
-    constructor(client, name = 'ProvingAgent'){
-        const meter = client.getMeter(name);
-        this.idleTime = meter.createHistogram(Metrics.PROVING_AGENT_IDLE, {
-            description: 'Records how long an agent was idle',
-            unit: 's',
-            valueType: ValueType.DOUBLE
-        });
-    }
-    recordIdleTime(msOrTimer) {
-        const duration = typeof msOrTimer === 'number' ? msOrTimer : msOrTimer.ms();
-        this.idleTime.record(duration / 1000);
-    }
-}

package/src/bin/get-proof-inputs.ts

@@ -1,59 +0,0 @@
-/* eslint-disable no-console */
-import { AVM_INPUTS_FILENAME } from '@aztec/bb-prover';
-import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
-import { createLogger } from '@aztec/foundation/log';
-import { type ProofUri, ProvingJobInputs } from '@aztec/stdlib/interfaces/server';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
-
-import { mkdirSync, writeFileSync } from 'fs';
-
-import { createProofStoreForUri } from '../proving_broker/index.js';
-
-const logger = createLogger('prover-client:get-proof-inputs');
-
-function printUsage() {
-  console.error('Usage: get-proof-inputs <proof-uri> [out-dir=.]');
-}
-
-async function main() {
-  if (process.argv[2] === '--help') {
-    printUsage();
-    return;
-  }
-
-  const uri = process.argv[2];
-  const outDir = process.argv[3] || '.';
-  if (!uri) {
-    printUsage();
-    throw new Error('Missing proof URI');
-  }
-
-  mkdirSync(outDir, { recursive: true });
-
-  const proofStore = createProofStoreForUri(uri);
-  logger.info(`Processing uri ${uri}`);
-  const input = await proofStore.getProofInput(uri as ProofUri);
-  logger.info(`Found inputs for ${ProvingRequestType[input.type]}`);
-  writeProofInputs(input, outDir);
-
-  console.log((await jsonParseWithSchema(jsonStringify(input), ProvingJobInputs)).inputs);
-}
-
-// This mimics the behavior of bb-prover/src/bb/execute.ts
-function writeProofInputs(input: ProvingJobInputs, outDir: string) {
-  switch (input.type) {
-    case ProvingRequestType.PUBLIC_VM: {
-      writeFileSync(`${outDir}/${AVM_INPUTS_FILENAME}`, input.inputs.serializeWithMessagePack());
-      logger.info(`Wrote AVM inputs to ${AVM_INPUTS_FILENAME}`);
-      break;
-    }
-    default: {
-      throw new Error(`Unimplemented proving request type: ${ProvingRequestType[input.type]}`);
-    }
-  }
-}
-
-main().catch(err => {
-  console.error(err);
-  process.exit(1);
-});

package/src/block_builder/index.ts

@@ -1,6 +0,0 @@
-import type { BlockBuilder, MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
-
-export * from './light.js';
-export interface BlockBuilderFactory {
-  create(db: MerkleTreeReadOperations): BlockBuilder;
-}