@aztec/end-to-end 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/test-wallet/worker_wallet.ts

@@ -0,0 +1,218 @@
+import type { CallIntent, IntentInnerHash } from '@aztec/aztec.js/authorization';
+import type { InteractionWaitOptions, SendReturn } from '@aztec/aztec.js/contracts';
+import type {
+  Aliased,
+  AppCapabilities,
+  BatchResults,
+  BatchedMethod,
+  ContractClassMetadata,
+  ContractMetadata,
+  ExecuteUtilityOptions,
+  PrivateEvent,
+  PrivateEventFilter,
+  ProfileOptions,
+  SendOptions,
+  SimulateOptions,
+  TxSimulationResultWithAppOffset,
+  Wallet,
+  WalletCapabilities,
+} from '@aztec/aztec.js/wallet';
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { type ApiSchema, getSchemaReturnType } from '@aztec/foundation/schemas';
+import { sleep } from '@aztec/foundation/sleep';
+import { NodeConnector, TransportClient } from '@aztec/foundation/transport';
+import type { PXEConfig } from '@aztec/pxe/config';
+import type { ContractArtifact, EventMetadataDefinition, FunctionCall } from '@aztec/stdlib/abi';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { ExecutionPayload, TxProfileResult, UtilityExecutionResult } from '@aztec/stdlib/tx';
+import { Tx } from '@aztec/stdlib/tx';
+
+import { Worker } from 'worker_threads';
+
+import { WorkerWalletSchema } from './worker_wallet_schema.js';
+
+type WorkerMsg = { fn: string; args: string };
+
+const log = createLogger('e2e:test-wallet:worker-wallet');
+
+const WORKER_READY_TIMEOUT_MS = 120_000;
+
+/**
+ * Wallet implementation that offloads all work to a worker thread.
+ * Implements the Wallet interface by proxying calls over a transport layer
+ * using JSON serialization with Zod schema parsing on both ends.
+ */
+export class WorkerWallet implements Wallet {
+  private constructor(
+    private worker: Worker,
+    private client: TransportClient<WorkerMsg>,
+  ) {}
+
+  /**
+   * Creates a WorkerWallet by spawning a worker thread that creates a TestWallet internally.
+   * @param nodeUrl - URL of the Aztec node to connect to.
+   * @param pxeConfig - Optional PXE configuration overrides.
+   * @returns A WorkerWallet ready to use.
+   */
+  static async create(nodeUrl: string, pxeConfig?: Partial<PXEConfig>): Promise<WorkerWallet> {
+    // replace stc/ with dest/ so the wallet works in Jest tests
+    const workerUrl = new URL('./wallet_worker_script.js', import.meta.url);
+    workerUrl.pathname = workerUrl.pathname.replace('/src/', '/dest/');
+    // remove JEST_WORKER_ID so the worker uses pino-pretty transport instead of Jest's raw output.
+    const { JEST_WORKER_ID: _, ...parentEnv } = process.env;
+    const worker = new Worker(workerUrl, {
+      workerData: { nodeUrl, pxeConfig },
+      env: {
+        ...parentEnv,
+        ...(process.stderr.isTTY || process.env.FORCE_COLOR ? { FORCE_COLOR: '1' } : {}),
+        LOG_LEVEL: process.env.WORKER_LOG_LEVEL ?? 'info',
+      },
+    });
+
+    const connector = new NodeConnector(worker);
+    const client = new TransportClient<WorkerMsg>(connector);
+    await client.open();
+
+    const wallet = new WorkerWallet(worker, client);
+
+    const { promise: workerDied, reject: rejectWorkerDied } = promiseWithResolvers<void>();
+    // reject if the worker exits or errors before the warmup completes.
+    const onError = (err: Error): void => {
+      worker.off('exit', onExit!);
+      rejectWorkerDied(new Error(`Worker wallet thread error: ${err.message}`));
+    };
+
+    const onExit = (code: number): void => {
+      worker.off('error', onError!);
+      rejectWorkerDied(new Error(`Worker wallet thread exited with code ${code} before becoming ready`));
+    };
+
+    worker.once('error', onError);
+    worker.once('exit', onExit);
+
+    const timeout = sleep(WORKER_READY_TIMEOUT_MS).then(() => {
+      throw new Error(`Worker wallet creation timed out after ${WORKER_READY_TIMEOUT_MS / 1000}s`);
+    });
+
+    try {
+      // wait for worker wallet to start
+      await Promise.race([wallet.getChainInfo(), workerDied, timeout]);
+    } catch (err) {
+      log.error('Worker wallet creation failed, cleaning up', { error: String(err) });
+      client.close();
+      await worker.terminate();
+      throw err;
+    } finally {
+      worker.off('error', onError);
+      worker.off('exit', onExit);
+    }
+
+    return wallet;
+  }
+
+  private async callRaw(fn: string, ...args: any[]): Promise<string> {
+    const argsJson = jsonStringify(args);
+    return (await this.client.request({ fn, args: argsJson })) as string;
+  }
+
+  private async call(fn: string, ...args: any[]): Promise<any> {
+    const resultJson = await this.callRaw(fn, ...args);
+    const methodSchema = (WorkerWalletSchema as ApiSchema)[fn];
+    return getSchemaReturnType(methodSchema).parseAsync(JSON.parse(resultJson));
+  }
+
+  getChainInfo(): Promise<ChainInfo> {
+    return this.call('getChainInfo');
+  }
+
+  getContractMetadata(address: AztecAddress): Promise<ContractMetadata> {
+    return this.call('getContractMetadata', address);
+  }
+
+  getContractClassMetadata(id: Fr): Promise<ContractClassMetadata> {
+    return this.call('getContractClassMetadata', id);
+  }
+
+  getPrivateEvents<T>(
+    eventMetadata: EventMetadataDefinition,
+    eventFilter: PrivateEventFilter,
+  ): Promise<PrivateEvent<T>[]> {
+    return this.call('getPrivateEvents', eventMetadata, eventFilter);
+  }
+
+  registerSender(address: AztecAddress, alias?: string): Promise<AztecAddress> {
+    return this.call('registerSender', address, alias);
+  }
+
+  getAddressBook(): Promise<Aliased<AztecAddress>[]> {
+    return this.call('getAddressBook');
+  }
+
+  getAccounts(): Promise<Aliased<AztecAddress>[]> {
+    return this.call('getAccounts');
+  }
+
+  registerContract(
+    instance: ContractInstanceWithAddress,
+    artifact?: ContractArtifact,
+    secretKey?: Fr,
+  ): Promise<ContractInstanceWithAddress> {
+    return this.call('registerContract', instance, artifact, secretKey);
+  }
+
+  registerContractClass(artifact: ContractArtifact): Promise<void> {
+    return this.call('registerContractClass', artifact);
+  }
+
+  simulateTx(exec: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResultWithAppOffset> {
+    return this.call('simulateTx', exec, opts);
+  }
+
+  executeUtility(call: FunctionCall, opts: ExecuteUtilityOptions): Promise<UtilityExecutionResult> {
+    return this.call('executeUtility', call, opts);
+  }
+
+  profileTx(exec: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult> {
+    return this.call('profileTx', exec, opts);
+  }
+
+  sendTx<W extends InteractionWaitOptions = undefined>(
+    exec: ExecutionPayload,
+    opts: SendOptions<W>,
+  ): Promise<SendReturn<W>> {
+    return this.call('sendTx', exec, opts);
+  }
+
+  proveTx(exec: ExecutionPayload, opts: Omit<SendOptions, 'wait'>): Promise<Tx> {
+    return this.call('proveTx', exec, opts);
+  }
+
+  /** Registers an account inside the worker's TestWallet, populating its accounts map. */
+  registerAccount(secret: Fr, salt: Fr): Promise<AztecAddress> {
+    return this.call('registerAccount', secret, salt);
+  }
+
+  createAuthWit(from: AztecAddress, messageHashOrIntent: IntentInnerHash | CallIntent): Promise<AuthWitness> {
+    return this.call('createAuthWit', from, messageHashOrIntent);
+  }
+
+  requestCapabilities(manifest: AppCapabilities): Promise<WalletCapabilities> {
+    return this.call('requestCapabilities', manifest);
+  }
+
+  batch<const T extends readonly BatchedMethod[]>(methods: T): Promise<BatchResults<T>> {
+    return this.call('batch', methods);
+  }
+
+  /** Shuts down the worker thread and closes the transport. */
+  async stop(): Promise<void> {
+    this.client.close();
+    await this.worker.terminate();
+  }
+}

package/src/test-wallet/worker_wallet_schema.ts

@@ -0,0 +1,13 @@
+import { ExecutionPayloadSchema, SendOptionsSchema, WalletSchema } from '@aztec/aztec.js/wallet';
+import { schemas } from '@aztec/foundation/schemas';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Tx } from '@aztec/stdlib/tx';
+
+import { z } from 'zod';
+
+/** Schema for the WorkerWallet API — extends WalletSchema with proveTx and registerAccount. */
+export const WorkerWalletSchema = {
+  ...WalletSchema,
+  proveTx: z.function({ input: z.tuple([ExecutionPayloadSchema, SendOptionsSchema]), output: Tx.schema }),
+  registerAccount: z.function({ input: z.tuple([schemas.Fr, schemas.Fr]), output: AztecAddress.schema }),
+};

package/dest/e2e_prover/e2e_prover_test.d.ts

@@ -1,56 +0,0 @@
-import type { InitialAccountData } from '@aztec/accounts/testing';
-import { type AccountWalletWithSecretKey, type AztecNode, type CheatCodes, type CompleteAddress, type DeployL1ContractsReturnType, EthAddress, type Logger } from '@aztec/aztec.js';
-import { type ClientProtocolCircuitVerifier } from '@aztec/bb-prover';
-import type { BlobSinkServer } from '@aztec/blob-sink/server';
-import { TokenContract } from '@aztec/noir-contracts.js/Token';
-import type { PXEService } from '@aztec/pxe/server';
-import { type SubsystemsContext } from '../fixtures/snapshot_manager.js';
-import { TokenSimulator } from '../simulators/token_simulator.js';
-/**
- * Largely taken from the e2e_token_contract test file. We deploy 2 accounts and a token contract.
- * However, we then setup a second PXE with a full prover instance.
- * We configure this instance with all of the accounts and contracts.
- * We then prove and verify transactions created via this full prover PXE.
- */
-export declare class FullProverTest {
-    private minNumberOfTxsPerBlock;
-    private realProofs;
-    static TOKEN_NAME: string;
-    static TOKEN_SYMBOL: string;
-    static TOKEN_DECIMALS: bigint;
-    private snapshotManager;
-    logger: Logger;
-    deployedAccounts: InitialAccountData[];
-    wallets: AccountWalletWithSecretKey[];
-    accounts: CompleteAddress[];
-    fakeProofsAsset: TokenContract;
-    tokenSim: TokenSimulator;
-    aztecNode: AztecNode;
-    pxe: PXEService;
-    cheatCodes: CheatCodes;
-    blobSink: BlobSinkServer;
-    private provenComponents;
-    private bbConfigCleanup?;
-    private acvmConfigCleanup?;
-    circuitProofVerifier?: ClientProtocolCircuitVerifier;
-    provenAssets: TokenContract[];
-    private context;
-    private proverNode;
-    private simulatedProverNode;
-    l1Contracts: DeployL1ContractsReturnType;
-    proverAddress: EthAddress;
-    constructor(testName: string, minNumberOfTxsPerBlock: number, coinbase: EthAddress, realProofs?: boolean);
-    /**
-     * Adds two state shifts to snapshot manager.
-     * 1. Add 2 accounts.
-     * 2. Publicly deploy accounts, deploy token contract
-     */
-    applyBaseSnapshots(): Promise<void>;
-    setup(): Promise<this>;
-    private mintL1ERC20;
-    snapshot: <T>(name: string, apply: (context: SubsystemsContext) => Promise<T>, restore?: (snapshotData: T, context: SubsystemsContext) => Promise<void>) => Promise<void>;
-    teardown(): Promise<void>;
-    applyMintSnapshot(): Promise<void>;
-    deployVerifier(): Promise<void>;
-}
-//# sourceMappingURL=e2e_prover_test.d.ts.map

package/dest/e2e_prover/e2e_prover_test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"e2e_prover_test.d.ts","sourceRoot":"","sources":["../../src/e2e_prover/e2e_prover_test.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,2BAA2B,EAChC,UAAU,EACV,KAAK,MAAM,EAIZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAqB,KAAK,6BAA6B,EAAuB,MAAM,kBAAkB,CAAC;AAE9G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAG9D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAQpD,OAAO,EAEL,KAAK,iBAAiB,EAIvB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AASlE;;;;;GAKG;AAEH,qBAAa,cAAc;IA4BvB,OAAO,CAAC,sBAAsB;IAE9B,OAAO,CAAC,UAAU;IA7BpB,MAAM,CAAC,UAAU,SAAU;IAC3B,MAAM,CAAC,YAAY,SAAS;IAC5B,MAAM,CAAC,cAAc,SAAO;IAC5B,OAAO,CAAC,eAAe,CAAmB;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,kBAAkB,EAAE,CAAM;IAC5C,OAAO,EAAE,0BAA0B,EAAE,CAAM;IAC3C,QAAQ,EAAE,eAAe,EAAE,CAAM;IACjC,eAAe,EAAG,aAAa,CAAC;IAChC,QAAQ,EAAG,cAAc,CAAC;IAC1B,SAAS,EAAG,SAAS,CAAC;IACtB,GAAG,EAAG,UAAU,CAAC;IACjB,UAAU,EAAG,UAAU,CAAC;IACxB,QAAQ,EAAG,cAAc,CAAC;IAC1B,OAAO,CAAC,gBAAgB,CAAqB;IAC7C,OAAO,CAAC,eAAe,CAAC,CAAsB;IAC9C,OAAO,CAAC,iBAAiB,CAAC,CAAsB;IAChD,oBAAoB,CAAC,EAAE,6BAA6B,CAAC;IACrD,YAAY,EAAE,aAAa,EAAE,CAAM;IACnC,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,mBAAmB,CAAc;IAClC,WAAW,EAAG,2BAA2B,CAAC;IAC1C,aAAa,EAAG,UAAU,CAAC;gBAGhC,QAAQ,EAAE,MAAM,EACR,sBAAsB,EAAE,MAAM,EACtC,QAAQ,EAAE,UAAU,EACZ,UAAU,UAAO;IAW3B;;;;OAIG;IACG,kBAAkB;IAqDlB,KAAK;YA0JG,WAAW;IAQzB,QAAQ,YACA,MAAM,SACL,CAAC,OAAO,EAAE,iBAAiB,KAAK,QAAQ,CAAC,CAAC,YACxC,CAAC,YAAY,EAAE,CAAC,EAAE,OAAO,EAAE,iBAAiB,KAAK,QAAQ,IAAI,CAAC,KACtE,QAAQ,IAAI,CAAC,CAAwD;IAElE,QAAQ;IAeR,iBAAiB;IAiDjB,cAAc;CA4BrB"}

package/dest/e2e_prover/e2e_prover_test.js

@@ -1,291 +0,0 @@
-import { SchnorrAccountContractArtifact, getSchnorrAccount, getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
-import { createArchiver } from '@aztec/archiver';
-import { EthAddress, createLogger, deployL1Contract } from '@aztec/aztec.js';
-import { BBCircuitVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
-import { createBlobSinkClient } from '@aztec/blob-sink/client';
-import { Buffer32 } from '@aztec/foundation/buffer';
-import { HonkVerifierAbi, HonkVerifierBytecode, RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
-import { TokenContract } from '@aztec/noir-contracts.js/Token';
-import { createProverNode } from '@aztec/prover-node';
-import { getGenesisValues } from '@aztec/world-state/testing';
-import { getContract } from 'viem';
-import { privateKeyToAddress } from 'viem/accounts';
-import { getACVMConfig } from '../fixtures/get_acvm_config.js';
-import { getBBConfig } from '../fixtures/get_bb_config.js';
-import { createSnapshotManager, deployAccounts, publicDeployAccounts } from '../fixtures/snapshot_manager.js';
-import { getPrivateKeyFromIndex, setupPXEService } from '../fixtures/utils.js';
-import { TokenSimulator } from '../simulators/token_simulator.js';
-const { E2E_DATA_PATH: dataPath } = process.env;
-/**
- * Largely taken from the e2e_token_contract test file. We deploy 2 accounts and a token contract.
- * However, we then setup a second PXE with a full prover instance.
- * We configure this instance with all of the accounts and contracts.
- * We then prove and verify transactions created via this full prover PXE.
- */ export class FullProverTest {
-    minNumberOfTxsPerBlock;
-    realProofs;
-    static TOKEN_NAME = 'USDC';
-    static TOKEN_SYMBOL = 'USD';
-    static TOKEN_DECIMALS = 18n;
-    snapshotManager;
-    logger;
-    deployedAccounts;
-    wallets;
-    accounts;
-    fakeProofsAsset;
-    tokenSim;
-    aztecNode;
-    pxe;
-    cheatCodes;
-    blobSink;
-    provenComponents;
-    bbConfigCleanup;
-    acvmConfigCleanup;
-    circuitProofVerifier;
-    provenAssets;
-    context;
-    proverNode;
-    simulatedProverNode;
-    l1Contracts;
-    proverAddress;
-    constructor(testName, minNumberOfTxsPerBlock, coinbase, realProofs = true){
-        this.minNumberOfTxsPerBlock = minNumberOfTxsPerBlock;
-        this.realProofs = realProofs;
-        this.deployedAccounts = [];
-        this.wallets = [];
-        this.accounts = [];
-        this.provenComponents = [];
-        this.provenAssets = [];
-        this.snapshot = (name, apply, restore = ()=>Promise.resolve())=>this.snapshotManager.snapshot(name, apply, restore);
-        this.logger = createLogger(`e2e:full_prover_test:${testName}`);
-        this.snapshotManager = createSnapshotManager(`full_prover_integration/${testName}`, dataPath, {
-            startProverNode: true,
-            fundRewardDistributor: true,
-            coinbase
-        }, {});
-    }
-    /**
-   * Adds two state shifts to snapshot manager.
-   * 1. Add 2 accounts.
-   * 2. Publicly deploy accounts, deploy token contract
-   */ async applyBaseSnapshots() {
-        await this.snapshotManager.snapshot('2_accounts', deployAccounts(2, this.logger), async ({ deployedAccounts }, { pxe })=>{
-            this.deployedAccounts = deployedAccounts;
-            this.wallets = await Promise.all(deployedAccounts.map((a)=>getSchnorrWalletWithSecretKey(pxe, a.secret, a.signingKey, a.salt)));
-            this.accounts = this.wallets.map((w)=>w.getCompleteAddress());
-            this.wallets.forEach((w, i)=>this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
-        });
-        await this.snapshotManager.snapshot('client_prover_integration', async ()=>{
-            // Create the token contract state.
-            // Move this account thing to addAccounts above?
-            this.logger.verbose(`Public deploy accounts...`);
-            await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 2), false);
-            this.logger.verbose(`Deploying TokenContract...`);
-            const asset = await TokenContract.deploy(this.wallets[0], this.accounts[0], FullProverTest.TOKEN_NAME, FullProverTest.TOKEN_SYMBOL, FullProverTest.TOKEN_DECIMALS).send().deployed();
-            this.logger.verbose(`Token deployed to ${asset.address}`);
-            return {
-                tokenContractAddress: asset.address
-            };
-        }, async ({ tokenContractAddress })=>{
-            // Restore the token contract state.
-            this.fakeProofsAsset = await TokenContract.at(tokenContractAddress, this.wallets[0]);
-            this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
-            this.tokenSim = new TokenSimulator(this.fakeProofsAsset, this.wallets[0], this.logger, this.accounts.map((a)=>a.address));
-            expect(await this.fakeProofsAsset.methods.get_admin().simulate()).toBe(this.accounts[0].address.toBigInt());
-        });
-    }
-    async setup() {
-        this.context = await this.snapshotManager.setup();
-        // We don't wish to mark as proven automatically, so we set the flag to false
-        this.context.watcher.setIsMarkingAsProven(false);
-        this.simulatedProverNode = this.context.proverNode;
-        ({ pxe: this.pxe, aztecNode: this.aztecNode, deployL1ContractsValues: this.l1Contracts, cheatCodes: this.cheatCodes, blobSink: this.blobSink } = this.context);
-        const blobSinkClient = createBlobSinkClient({
-            blobSinkUrl: `http://localhost:${this.blobSink.port}`
-        });
-        // Configure a full prover PXE
-        let acvmConfig;
-        let bbConfig;
-        if (this.realProofs) {
-            [acvmConfig, bbConfig] = await Promise.all([
-                getACVMConfig(this.logger),
-                getBBConfig(this.logger)
-            ]);
-            if (!acvmConfig || !bbConfig) {
-                throw new Error('Missing ACVM or BB config');
-            }
-            this.acvmConfigCleanup = acvmConfig.cleanup;
-            this.bbConfigCleanup = bbConfig.cleanup;
-            if (!bbConfig?.bbWorkingDirectory || !bbConfig?.bbBinaryPath) {
-                throw new Error(`Test must be run with BB native configuration`);
-            }
-            this.circuitProofVerifier = await BBCircuitVerifier.new(bbConfig);
-            this.logger.debug(`Configuring the node for real proofs...`);
-            await this.aztecNode.setConfig({
-                realProofs: true,
-                minTxsPerBlock: this.minNumberOfTxsPerBlock
-            });
-        } else {
-            this.logger.debug(`Configuring the node min txs per block ${this.minNumberOfTxsPerBlock}...`);
-            this.circuitProofVerifier = new TestCircuitVerifier();
-            await this.aztecNode.setConfig({
-                minTxsPerBlock: this.minNumberOfTxsPerBlock
-            });
-        }
-        this.logger.verbose(`Move to a clean epoch`);
-        await this.context.cheatCodes.rollup.advanceToNextEpoch();
-        this.logger.verbose(`Marking current block as proven`);
-        await this.context.cheatCodes.rollup.markAsProven();
-        this.logger.verbose(`Main setup completed, initializing full prover PXE, Node, and Prover Node`);
-        for(let i = 0; i < 2; i++){
-            const result = await setupPXEService(this.aztecNode, {
-                proverEnabled: this.realProofs,
-                bbBinaryPath: bbConfig?.bbBinaryPath,
-                bbWorkingDirectory: bbConfig?.bbWorkingDirectory
-            }, undefined, true);
-            this.logger.debug(`Contract address ${this.fakeProofsAsset.address}`);
-            await result.pxe.registerContract(this.fakeProofsAsset);
-            for(let i = 0; i < 2; i++){
-                await result.pxe.registerAccount(this.deployedAccounts[i].secret, this.wallets[i].getCompleteAddress().partialAddress);
-                await this.pxe.registerAccount(this.deployedAccounts[i].secret, this.wallets[i].getCompleteAddress().partialAddress);
-            }
-            const account = await getSchnorrAccount(result.pxe, this.deployedAccounts[0].secret, this.deployedAccounts[0].signingKey, this.deployedAccounts[0].salt);
-            await result.pxe.registerContract({
-                instance: account.getInstance(),
-                artifact: SchnorrAccountContractArtifact
-            });
-            const provenWallet = await account.getWallet();
-            const asset = await TokenContract.at(this.fakeProofsAsset.address, provenWallet);
-            this.provenComponents.push({
-                pxe: result.pxe,
-                teardown: result.teardown
-            });
-            this.provenAssets.push(asset);
-        }
-        this.logger.info(`Full prover PXE started`);
-        // Shutdown the current, simulated prover node
-        this.logger.verbose('Shutting down simulated prover node');
-        await this.simulatedProverNode.stop();
-        // Creating temp store and archiver for fully proven prover node
-        this.logger.verbose('Starting archiver for new prover node');
-        const archiver = await createArchiver({
-            ...this.context.aztecNodeConfig,
-            dataDirectory: undefined
-        }, blobSinkClient, {
-            blockUntilSync: true
-        });
-        // The simulated prover node (now shutdown) used private key index 2
-        const proverNodePrivateKey = getPrivateKeyFromIndex(2);
-        const proverNodeSenderAddress = privateKeyToAddress(new Buffer32(proverNodePrivateKey).toString());
-        this.proverAddress = EthAddress.fromString(proverNodeSenderAddress);
-        this.logger.verbose(`Funding prover node at ${proverNodeSenderAddress}`);
-        await this.mintL1ERC20(proverNodeSenderAddress, 100_000_000n);
-        this.logger.verbose('Starting prover node');
-        const proverConfig = {
-            ...this.context.aztecNodeConfig,
-            proverCoordinationNodeUrl: undefined,
-            dataDirectory: undefined,
-            proverId: this.proverAddress.toField(),
-            realProofs: this.realProofs,
-            proverAgentCount: 2,
-            publisherPrivateKey: `0x${proverNodePrivateKey.toString('hex')}`,
-            proverNodeMaxPendingJobs: 100,
-            proverNodeMaxParallelBlocksPerEpoch: 32,
-            proverNodePollingIntervalMs: 100,
-            txGatheringTimeoutMs: 60000,
-            txGatheringIntervalMs: 1000,
-            txGatheringMaxParallelRequests: 100
-        };
-        const { prefilledPublicData } = await getGenesisValues(this.context.initialFundedAccounts.map((a)=>a.address));
-        this.proverNode = await createProverNode(proverConfig, {
-            aztecNodeTxProvider: this.aztecNode,
-            archiver: archiver,
-            blobSinkClient
-        }, {
-            prefilledPublicData
-        });
-        this.proverNode.start();
-        this.logger.warn(`Proofs are now enabled`);
-        return this;
-    }
-    async mintL1ERC20(recipient, amount) {
-        const erc20Address = this.context.deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress;
-        const client = this.context.deployL1ContractsValues.walletClient;
-        const erc20 = getContract({
-            abi: TestERC20Abi,
-            address: erc20Address.toString(),
-            client
-        });
-        const hash = await erc20.write.mint([
-            recipient,
-            amount
-        ]);
-        await this.context.deployL1ContractsValues.publicClient.waitForTransactionReceipt({
-            hash
-        });
-    }
-    snapshot;
-    async teardown() {
-        await this.snapshotManager.teardown();
-        // Cleanup related to the full prover PXEs
-        for(let i = 0; i < this.provenComponents.length; i++){
-            await this.provenComponents[i].teardown();
-        }
-        // clean up the full prover node
-        await this.proverNode.stop();
-        await this.bbConfigCleanup?.();
-        await this.acvmConfigCleanup?.();
-    }
-    async applyMintSnapshot() {
-        await this.snapshotManager.snapshot('mint', async ()=>{
-            const { fakeProofsAsset: asset, accounts } = this;
-            const privateAmount = 10000n;
-            const publicAmount = 10000n;
-            const waitOpts = {
-                proven: false
-            };
-            this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
-            await asset.methods.mint_to_public(accounts[0].address, privateAmount + publicAmount).send().wait(waitOpts);
-            this.logger.verbose(`Transferring ${privateAmount} to private...`);
-            await asset.methods.transfer_to_private(accounts[0].address, privateAmount).send().wait(waitOpts);
-            this.logger.verbose(`Minting complete.`);
-            return {
-                amount: publicAmount
-            };
-        }, async ({ amount })=>{
-            const { fakeProofsAsset: asset, accounts: [{ address }], tokenSim } = this;
-            tokenSim.mintPublic(address, amount);
-            const publicBalance = await asset.methods.balance_of_public(address).simulate();
-            this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
-            expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
-            tokenSim.mintPrivate(address, amount);
-            const privateBalance = await asset.methods.balance_of_private(address).simulate();
-            this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
-            expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
-            const totalSupply = await asset.methods.total_supply().simulate();
-            this.logger.verbose(`Total supply: ${totalSupply}`);
-            expect(totalSupply).toEqual(tokenSim.totalSupply);
-            return Promise.resolve();
-        });
-    }
-    async deployVerifier() {
-        if (!this.realProofs) {
-            return;
-        }
-        if (!this.circuitProofVerifier) {
-            throw new Error('No verifier');
-        }
-        const { walletClient, publicClient, l1ContractAddresses } = this.context.deployL1ContractsValues;
-        const rollup = getContract({
-            abi: RollupAbi,
-            address: l1ContractAddresses.rollupAddress.toString(),
-            client: walletClient
-        });
-        const { address: verifierAddress } = await deployL1Contract(walletClient, publicClient, HonkVerifierAbi, HonkVerifierBytecode);
-        this.logger.info(`Deployed honk verifier at ${verifierAddress}`);
-        await rollup.write.setEpochVerifier([
-            verifierAddress.toString()
-        ]);
-        this.logger.info('Rollup only accepts valid proofs now');
-    }
-}

package/dest/fixtures/setup_l1_contracts.d.ts

@@ -1,6 +0,0 @@
-import { type Logger } from '@aztec/aztec.js';
-import type { DeployL1ContractsArgs, L1ContractsConfig } from '@aztec/ethereum';
-import type { HDAccount, PrivateKeyAccount } from 'viem';
-export { deployAndInitializeTokenAndBridgeContracts } from '../shared/cross_chain_test_harness.js';
-export declare const setupL1Contracts: (l1RpcUrl: string, account: HDAccount | PrivateKeyAccount, logger: Logger, args: Pick<DeployL1ContractsArgs, 'genesisArchiveRoot' | 'genesisBlockHash' | 'initialValidators'> & L1ContractsConfig) => Promise<import("@aztec/aztec.js").DeployL1ContractsReturnType>;
-//# sourceMappingURL=setup_l1_contracts.d.ts.map

package/dest/fixtures/setup_l1_contracts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup_l1_contracts.d.ts","sourceRoot":"","sources":["../../src/fixtures/setup_l1_contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAqB,MAAM,iBAAiB,CAAC;AACjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAIhF,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAGzD,OAAO,EAAE,0CAA0C,EAAE,MAAM,uCAAuC,CAAC;AAEnG,eAAO,MAAM,gBAAgB,aACjB,MAAM,WACP,SAAS,GAAG,iBAAiB,UAC9B,MAAM,QACR,KAAK,qBAAqB,EAAE,oBAAoB,GAAG,kBAAkB,GAAG,mBAAmB,CAAC,GAChG,iBAAiB,mEAWpB,CAAC"}

package/dest/fixtures/setup_l1_contracts.js

@@ -1,17 +0,0 @@
-import { deployL1Contracts } from '@aztec/aztec.js';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { foundry } from 'viem/chains';
-export { deployAndInitializeTokenAndBridgeContracts } from '../shared/cross_chain_test_harness.js';
-export const setupL1Contracts = async (l1RpcUrl, account, logger, args)=>{
-    const l1Data = await deployL1Contracts([
-        l1RpcUrl
-    ], account, foundry, logger, {
-        l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice.toField(),
-        vkTreeRoot: getVKTreeRoot(),
-        protocolContractTreeRoot,
-        salt: undefined,
-        ...args
-    });
-    return l1Data;
-};