@aztec/end-to-end 0.0.0-test.1 → 0.0.1-commit.0b941701

package/dest/fixtures/e2e_prover_test.js

@@ -0,0 +1,278 @@
+import { createArchiver } from '@aztec/archiver';
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { createLogger } from '@aztec/aztec.js/log';
+import { BBCircuitVerifier, QueuedIVCVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
+import { BackendType, Barretenberg } from '@aztec/bb.js';
+import { createBlobClientWithFileStores } from '@aztec/blob-client/client';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { SecretValue } from '@aztec/foundation/config';
+import { FeeAssetHandlerAbi } 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 { TokenSimulator } from '../simulators/token_simulator.js';
+import { getACVMConfig } from './get_acvm_config.js';
+import { getBBConfig } from './get_bb_config.js';
+import { deployAccounts, getPrivateKeyFromIndex, getSponsoredFPCAddress, publicDeployAccounts, setup, setupPXEAndGetWallet, teardown } from './setup.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 class FullProverTest {
+    static TOKEN_NAME = 'USDC';
+    static TOKEN_SYMBOL = 'USD';
+    static TOKEN_DECIMALS = 18n;
+    logger;
+    wallet;
+    provenWallet;
+    accounts = [];
+    deployedAccounts;
+    fakeProofsAsset;
+    fakeProofsAssetInstance;
+    tokenSim;
+    aztecNode;
+    aztecNodeAdmin;
+    cheatCodes;
+    provenComponents = [];
+    bbConfigCleanup;
+    acvmConfigCleanup;
+    circuitProofVerifier;
+    provenAsset;
+    context;
+    proverNode;
+    simulatedProverNode;
+    l1Contracts;
+    proverAddress;
+    minNumberOfTxsPerBlock;
+    coinbase;
+    realProofs;
+    constructor(testName, minNumberOfTxsPerBlock, coinbase, realProofs = true){
+        this.logger = createLogger(`e2e:full_prover_test:${testName}`);
+        this.minNumberOfTxsPerBlock = minNumberOfTxsPerBlock;
+        this.coinbase = coinbase;
+        this.realProofs = realProofs;
+    }
+    /**
+   * Applies base setup: deploys 2 accounts and token contract.
+   */ async applyBaseSetup() {
+        this.logger.info('Applying base setup: deploying accounts');
+        const { deployedAccounts } = await deployAccounts(2, this.logger)({
+            wallet: this.context.wallet,
+            initialFundedAccounts: this.context.initialFundedAccounts
+        });
+        this.deployedAccounts = deployedAccounts;
+        this.accounts = deployedAccounts.map((a)=>a.address);
+        this.wallet = this.context.wallet;
+        this.logger.info('Applying base setup: publicly deploying accounts');
+        await publicDeployAccounts(this.wallet, this.accounts.slice(0, 2));
+        this.logger.info('Applying base setup: deploying token contract');
+        const { contract: asset, instance } = await TokenContract.deploy(this.wallet, this.accounts[0], FullProverTest.TOKEN_NAME, FullProverTest.TOKEN_SYMBOL, FullProverTest.TOKEN_DECIMALS).send({
+            from: this.accounts[0],
+            wait: {
+                returnReceipt: true
+            }
+        });
+        this.logger.verbose(`Token deployed to ${asset.address}`);
+        this.fakeProofsAsset = asset;
+        this.fakeProofsAssetInstance = instance;
+        this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
+        this.tokenSim = new TokenSimulator(this.fakeProofsAsset, this.wallet, this.accounts[0], this.logger, this.accounts);
+        expect(await this.fakeProofsAsset.methods.get_admin().simulate({
+            from: this.accounts[0]
+        })).toBe(this.accounts[0].toBigInt());
+    }
+    async setup() {
+        this.logger.info('Setting up subsystems from fresh');
+        this.context = await setup(0, {
+            startProverNode: true,
+            coinbase: this.coinbase,
+            fundSponsoredFPC: true,
+            skipAccountDeployment: true,
+            l1ContractsArgs: {
+                realVerifier: this.realProofs
+            }
+        });
+        await this.applyBaseSetup();
+        await this.applyMint();
+        this.logger.info(`Enabling proving`, {
+            realProofs: this.realProofs
+        });
+        // 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;
+        ({ aztecNode: this.aztecNode, deployL1ContractsValues: this.l1Contracts, cheatCodes: this.cheatCodes } = this.context);
+        this.aztecNodeAdmin = this.context.aztecNodeService;
+        const config = this.context.aztecNodeConfig;
+        const blobClient = await createBlobClientWithFileStores(config, this.logger);
+        // 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;
+            await Barretenberg.initSingleton({
+                backend: BackendType.NativeUnixSocket
+            });
+            const verifier = await BBCircuitVerifier.new(bbConfig);
+            this.circuitProofVerifier = new QueuedIVCVerifier(bbConfig, verifier);
+            this.logger.debug(`Configuring the node for real proofs...`);
+            await this.aztecNodeAdmin.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.aztecNodeAdmin.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`);
+        const { wallet: provenWallet, teardown: provenTeardown } = await setupPXEAndGetWallet(this.aztecNode, {
+            proverEnabled: this.realProofs
+        }, undefined, true);
+        this.logger.debug(`Contract address ${this.fakeProofsAsset.address}`);
+        await provenWallet.registerContract(this.fakeProofsAssetInstance, TokenContract.artifact);
+        for(let i = 0; i < 2; i++){
+            await provenWallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
+            await this.wallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
+        }
+        const asset = TokenContract.at(this.fakeProofsAsset.address, provenWallet);
+        this.provenComponents.push({
+            wallet: provenWallet,
+            teardown: provenTeardown
+        });
+        this.provenAsset = asset;
+        this.provenWallet = provenWallet;
+        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
+        }, {
+            blobClient,
+            dateProvider: this.context.dateProvider
+        }, {
+            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.mintFeeJuice(proverNodeSenderAddress);
+        this.logger.verbose('Starting prover node');
+        const proverConfig = {
+            ...this.context.aztecNodeConfig,
+            txCollectionNodeRpcUrls: [],
+            dataDirectory: undefined,
+            proverId: this.proverAddress,
+            realProofs: this.realProofs,
+            proverAgentCount: 2,
+            publisherPrivateKeys: [
+                new SecretValue(`0x${proverNodePrivateKey.toString('hex')}`)
+            ],
+            proverNodeMaxPendingJobs: 100,
+            proverNodeMaxParallelBlocksPerEpoch: 32,
+            proverNodePollingIntervalMs: 100,
+            txGatheringIntervalMs: 1000,
+            txGatheringBatchSize: 10,
+            txGatheringMaxParallelRequestsPerNode: 100,
+            txGatheringTimeoutMs: 24_000,
+            proverNodeFailedEpochStore: undefined,
+            proverNodeEpochProvingDelayMs: undefined
+        };
+        const sponsoredFPCAddress = await getSponsoredFPCAddress();
+        const { prefilledPublicData } = await getGenesisValues(this.context.initialFundedAccounts.map((a)=>a.address).concat(sponsoredFPCAddress));
+        this.proverNode = await createProverNode(proverConfig, {
+            aztecNodeTxProvider: this.aztecNode,
+            archiver: archiver
+        }, {
+            prefilledPublicData
+        });
+        await this.proverNode.start();
+        this.logger.warn(`Proofs are now enabled`, {
+            realProofs: this.realProofs
+        });
+        return this;
+    }
+    async mintFeeJuice(recipient) {
+        const handlerAddress = this.context.deployL1ContractsValues.l1ContractAddresses.feeAssetHandlerAddress;
+        this.logger.verbose(`Minting fee juice to ${recipient} using handler at ${handlerAddress}`);
+        const client = this.context.deployL1ContractsValues.l1Client;
+        const handler = getContract({
+            abi: FeeAssetHandlerAbi,
+            address: handlerAddress.toString(),
+            client
+        });
+        const hash = await handler.write.mint([
+            recipient
+        ]);
+        await this.context.deployL1ContractsValues.l1Client.waitForTransactionReceipt({
+            hash
+        });
+    }
+    async 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 Barretenberg.destroySingleton();
+        await this.bbConfigCleanup?.();
+        await this.acvmConfigCleanup?.();
+        await teardown(this.context);
+    }
+    async applyMint() {
+        this.logger.info('Applying mint setup');
+        const { fakeProofsAsset: asset, accounts } = this;
+        const privateAmount = 10000n;
+        const publicAmount = 10000n;
+        this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
+        await asset.methods.mint_to_public(accounts[0], privateAmount + publicAmount).send({
+            from: accounts[0]
+        });
+        this.logger.verbose(`Transferring ${privateAmount} to private...`);
+        await asset.methods.transfer_to_private(accounts[0], privateAmount).send({
+            from: accounts[0]
+        });
+        this.logger.info(`Minting complete`);
+        const { fakeProofsAsset, accounts: [address], tokenSim } = this;
+        tokenSim.mintPublic(address, publicAmount);
+        const publicBalance = await fakeProofsAsset.methods.balance_of_public(address).simulate({
+            from: address
+        });
+        this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
+        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
+        tokenSim.mintPrivate(address, publicAmount);
+        const privateBalance = await fakeProofsAsset.methods.balance_of_private(address).simulate({
+            from: address
+        });
+        this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
+        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
+        const totalSupply = await fakeProofsAsset.methods.total_supply().simulate({
+            from: address
+        });
+        this.logger.verbose(`Total supply: ${totalSupply}`);
+        expect(totalSupply).toEqual(tokenSim.totalSupply);
+    }
+}

package/dest/fixtures/fixtures.d.ts

@@ -1,17 +1,15 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 export declare const METRICS_PORT = 4318;
 export declare const shouldCollectMetrics: () => 4318 | undefined;
 export declare const TEST_PEER_CHECK_INTERVAL_MS = 1000;
+export declare const TEST_MAX_PENDING_TX_POOL_COUNT = 10000;
 export declare const MNEMONIC = "test test test test test test test test test test test junk";
-export declare const privateKey: Buffer;
-export declare const privateKey2: Buffer;
-export declare const U128_UNDERFLOW_ERROR = "Assertion failed: attempt to subtract with overflow 'self - other'";
-export declare const U128_OVERFLOW_ERROR = "Assertion failed: attempt to add with overflow 'self + other'";
+export declare const privateKey: Buffer<ArrayBuffer>;
+export declare const privateKey2: Buffer<ArrayBuffer>;
+export declare const U128_UNDERFLOW_ERROR = "Assertion failed: attempt to subtract with overflow";
+export declare const U128_OVERFLOW_ERROR = "Assertion failed: attempt to add with overflow";
 export declare const BITSIZE_TOO_BIG_ERROR = "Assertion failed: call to assert_max_bit_size 'self.__assert_max_bit_size'";
 export declare const DUPLICATE_NULLIFIER_ERROR: RegExp;
 export declare const NO_L1_TO_L2_MSG_ERROR: RegExp;
 export declare const STATIC_CALL_STATE_MODIFICATION_ERROR: RegExp;
 export declare const STATIC_CONTEXT_ASSERTION_ERROR: RegExp;
-export declare const DEFAULT_BLOB_SINK_PORT = "5052";
-//# sourceMappingURL=fixtures.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maXh0dXJlcy9maXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxlQUFPLE1BQU0sWUFBWSxPQUFPLENBQUM7QUFFakMsZUFBTyxNQUFNLG9CQUFvQix3QkFLaEMsQ0FBQztBQUVGLGVBQU8sTUFBTSwyQkFBMkIsT0FBTyxDQUFDO0FBQ2hELGVBQU8sTUFBTSw4QkFBOEIsUUFBUyxDQUFDO0FBRXJELGVBQU8sTUFBTSxRQUFRLGdFQUFnRSxDQUFDO0FBQ3RGLGVBQU8sTUFBTSxVQUFVLHFCQUF5RixDQUFDO0FBQ2pILGVBQU8sTUFBTSxXQUFXLHFCQUF5RixDQUFDO0FBR2xILGVBQU8sTUFBTSxvQkFBb0Isd0RBQXdELENBQUM7QUFDMUYsZUFBTyxNQUFNLG1CQUFtQixtREFBbUQsQ0FBQztBQUNwRixlQUFPLE1BQU0scUJBQXFCLCtFQUErRSxDQUFDO0FBRWxILGVBQU8sTUFBTSx5QkFBeUIsUUFBZ0MsQ0FBQztBQUN2RSxlQUFPLE1BQU0scUJBQXFCLFFBQ3dFLENBQUM7QUFDM0csZUFBTyxNQUFNLG9DQUFvQyxRQUEwQyxDQUFDO0FBQzVGLGVBQU8sTUFBTSw4QkFBOEIsUUFBa0UsQ0FBQyJ9

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

@@ -1 +1 @@
-{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/fixtures/fixtures.ts"],"names":[],"mappings":";;AAAA,eAAO,MAAM,YAAY,OAAO,CAAC;AAEjC,eAAO,MAAM,oBAAoB,wBAKhC,CAAC;AAEF,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAEhD,eAAO,MAAM,QAAQ,gEAAgE,CAAC;AACtF,eAAO,MAAM,UAAU,QAAyF,CAAC;AACjH,eAAO,MAAM,WAAW,QAAyF,CAAC;AAGlH,eAAO,MAAM,oBAAoB,uEAAuE,CAAC;AACzG,eAAO,MAAM,mBAAmB,kEAAkE,CAAC;AACnG,eAAO,MAAM,qBAAqB,+EAA+E,CAAC;AAElH,eAAO,MAAM,yBAAyB,QAA6D,CAAC;AACpG,eAAO,MAAM,qBAAqB,QACwE,CAAC;AAC3G,eAAO,MAAM,oCAAoC,QAC+B,CAAC;AACjF,eAAO,MAAM,8BAA8B,QAAkE,CAAC;AAE9G,eAAO,MAAM,sBAAsB,SAAS,CAAC"}
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/fixtures/fixtures.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,OAAO,CAAC;AAEjC,eAAO,MAAM,oBAAoB,wBAKhC,CAAC;AAEF,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAChD,eAAO,MAAM,8BAA8B,QAAS,CAAC;AAErD,eAAO,MAAM,QAAQ,gEAAgE,CAAC;AACtF,eAAO,MAAM,UAAU,qBAAyF,CAAC;AACjH,eAAO,MAAM,WAAW,qBAAyF,CAAC;AAGlH,eAAO,MAAM,oBAAoB,wDAAwD,CAAC;AAC1F,eAAO,MAAM,mBAAmB,mDAAmD,CAAC;AACpF,eAAO,MAAM,qBAAqB,+EAA+E,CAAC;AAElH,eAAO,MAAM,yBAAyB,QAAgC,CAAC;AACvE,eAAO,MAAM,qBAAqB,QACwE,CAAC;AAC3G,eAAO,MAAM,oCAAoC,QAA0C,CAAC;AAC5F,eAAO,MAAM,8BAA8B,QAAkE,CAAC"}

package/dest/fixtures/fixtures.js

@@ -6,16 +6,16 @@ export const shouldCollectMetrics = ()=>{
     return undefined;
 };
 export const TEST_PEER_CHECK_INTERVAL_MS = 1000;
+export const TEST_MAX_PENDING_TX_POOL_COUNT = 10_000; // Number of max pending TXs ~ 1.56GB
 export const MNEMONIC = 'test test test test test test test test test test test junk';
 export const privateKey = Buffer.from('ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80', 'hex');
 export const privateKey2 = Buffer.from('59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d', 'hex');
 /// Common errors
-export const U128_UNDERFLOW_ERROR = "Assertion failed: attempt to subtract with overflow 'self - other'";
-export const U128_OVERFLOW_ERROR = "Assertion failed: attempt to add with overflow 'self + other'";
+export const U128_UNDERFLOW_ERROR = 'Assertion failed: attempt to subtract with overflow';
+export const U128_OVERFLOW_ERROR = 'Assertion failed: attempt to add with overflow';
 export const BITSIZE_TOO_BIG_ERROR = "Assertion failed: call to assert_max_bit_size 'self.__assert_max_bit_size'";
 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5818): Make these a fixed error after transition.
-export const DUPLICATE_NULLIFIER_ERROR = /dropped|duplicate nullifier|reverted|Nullifier collision/;
+export const DUPLICATE_NULLIFIER_ERROR = /dropped|nullifier|reverted/i;
 export const NO_L1_TO_L2_MSG_ERROR = /No non-nullified L1 to L2 message found for message hash|Tried to consume nonexistent L1-to-L2 message/;
-export const STATIC_CALL_STATE_MODIFICATION_ERROR = /Static call cannot update the state, emit L2->L1 messages or generate logs.*/;
+export const STATIC_CALL_STATE_MODIFICATION_ERROR = /Static call cannot update the state.*/;
 export const STATIC_CONTEXT_ASSERTION_ERROR = /Assertion failed: Function .* can only be called statically.*/;
-export const DEFAULT_BLOB_SINK_PORT = '5052';

package/dest/fixtures/get_acvm_config.d.ts

@@ -1,8 +1,8 @@
-import type { Logger } from '@aztec/aztec.js';
+import type { Logger } from '@aztec/aztec.js/log';
 export { deployAndInitializeTokenAndBridgeContracts } from '../shared/cross_chain_test_harness.js';
 export declare function getACVMConfig(logger: Logger): Promise<{
     acvmWorkingDirectory: string;
     acvmBinaryPath: string;
     cleanup: () => Promise<void>;
 } | undefined>;
-//# sourceMappingURL=get_acvm_config.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X2Fjdm1fY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZml4dHVyZXMvZ2V0X2Fjdm1fY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBT2xELE9BQU8sRUFBRSwwQ0FBMEMsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBV25HLHdCQUFzQixhQUFhLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQ3hEO0lBQ0Usb0JBQW9CLEVBQUUsTUFBTSxDQUFDO0lBQzdCLGNBQWMsRUFBRSxNQUFNLENBQUM7SUFDdkIsT0FBTyxFQUFFLE1BQU0sT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0NBQzlCLEdBQ0QsU0FBUyxDQUNaLENBeUJBIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"get_acvm_config.d.ts","sourceRoot":"","sources":["../../src/fixtures/get_acvm_config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAM9C,OAAO,EAAE,0CAA0C,EAAE,MAAM,uCAAuC,CAAC;AAWnG,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CACxD;IACE,oBAAoB,EAAE,MAAM,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,GACD,SAAS,CACZ,CAkCA"}
+{"version":3,"file":"get_acvm_config.d.ts","sourceRoot":"","sources":["../../src/fixtures/get_acvm_config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAOlD,OAAO,EAAE,0CAA0C,EAAE,MAAM,uCAAuC,CAAC;AAWnG,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CACxD;IACE,oBAAoB,EAAE,MAAM,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,GACD,SAAS,CACZ,CAyBA"}

package/dest/fixtures/get_acvm_config.js

@@ -1,5 +1,6 @@
 import { parseBooleanEnv } from '@aztec/foundation/config';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { tryRmDir } from '@aztec/foundation/fs';
 import { promises as fs } from 'fs';
 export { deployAndInitializeTokenAndBridgeContracts } from '../shared/cross_chain_test_harness.js';
 const { NOIR_RELEASE_DIR = 'noir-repo/target/release', TEMP_DIR = '/tmp', ACVM_BINARY_PATH = '', ACVM_WORKING_DIRECTORY = '', ACVM_FORCE_WASM = '' } = process.env;
@@ -18,20 +19,7 @@ export async function getACVMConfig(logger) {
         });
         logger.verbose(`Using native ACVM binary at ${acvmBinaryPath} with working directory ${acvmWorkingDirectory}`);
         const directoryToCleanup = ACVM_WORKING_DIRECTORY ? undefined : tempWorkingDirectory;
-        const cleanup = async ()=>{
-            if (directoryToCleanup) {
-                try {
-                    logger.info(`Cleaning up ACVM temp directory ${directoryToCleanup}`);
-                    await fs.rm(directoryToCleanup, {
-                        recursive: true,
-                        force: true,
-                        maxRetries: 3
-                    });
-                } catch (err) {
-                    logger.warn(`Failed to delete ACVM temp directory at ${directoryToCleanup}: ${err}`);
-                }
-            }
-        };
+        const cleanup = ()=>tryRmDir(directoryToCleanup, logger);
         return {
             acvmWorkingDirectory,
             acvmBinaryPath,

package/dest/fixtures/get_bb_config.d.ts

@@ -1,6 +1,6 @@
-import { type Logger } from '@aztec/aztec.js';
+import type { Logger } from '@aztec/aztec.js/log';
 import type { BBConfig } from '@aztec/bb-prover';
 export declare const getBBConfig: (logger: Logger) => Promise<(BBConfig & {
     cleanup: () => Promise<void>;
 }) | undefined>;
-//# sourceMappingURL=get_bb_config.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X2JiX2NvbmZpZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ZpeHR1cmVzL2dldF9iYl9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDbEQsT0FBTyxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFrQmpELGVBQU8sTUFBTSxXQUFXOztlQXVDdkIsQ0FBQyJ9

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

@@ -1 +1 @@
-{"version":3,"file":"get_bb_config.d.ts","sourceRoot":"","sources":["../../src/fixtures/get_bb_config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAiB,MAAM,iBAAiB,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAcjD,eAAO,MAAM,WAAW,WACd,MAAM,KACb,QAAQ,CAAC,QAAQ,GAAG;IAAE,OAAO,EAAE,MAAM,QAAQ,IAAI,CAAC,CAAA;CAAE,CAAC,GAAG,SAAS,CAoCnE,CAAC"}
+{"version":3,"file":"get_bb_config.d.ts","sourceRoot":"","sources":["../../src/fixtures/get_bb_config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAkBjD,eAAO,MAAM,WAAW;;eAuCvB,CAAC"}

package/dest/fixtures/get_bb_config.js

@@ -1,11 +1,12 @@
-import { fileURLToPath } from '@aztec/aztec.js';
+import { tryRmDir } from '@aztec/foundation/fs';
 import fs from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'path';
-const { BB_RELEASE_DIR = 'barretenberg/cpp/build/bin', BB_BINARY_PATH, BB_SKIP_CLEANUP = '', TEMP_DIR = tmpdir(), BB_WORKING_DIRECTORY = '' } = process.env;
+import { fileURLToPath } from 'url';
+const { BB_RELEASE_DIR = 'barretenberg/cpp/build/bin', BB_BINARY_PATH, BB_SKIP_CLEANUP = '', TEMP_DIR = tmpdir(), BB_WORKING_DIRECTORY = '', BB_NUM_IVC_VERIFIERS = '1', BB_IVC_CONCURRENCY = '1' } = process.env;
 export const getBBConfig = async (logger)=>{
     try {
-        const bbBinaryPath = BB_BINARY_PATH ?? path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../', BB_RELEASE_DIR, 'bb');
+        const bbBinaryPath = BB_BINARY_PATH ?? path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../', BB_RELEASE_DIR, 'bb-avm');
         await fs.access(bbBinaryPath, fs.constants.R_OK);
         let bbWorkingDirectory;
         let directoryToCleanup;
@@ -22,24 +23,16 @@ export const getBBConfig = async (logger)=>{
             '1',
             'true'
         ].includes(BB_SKIP_CLEANUP);
-        const cleanup = async ()=>{
-            if (directoryToCleanup && !bbSkipCleanup) {
-                try {
-                    await fs.rm(directoryToCleanup, {
-                        recursive: true,
-                        force: true,
-                        maxRetries: 3
-                    });
-                } catch (err) {
-                    logger.warn(`Failed to delete bb working directory at ${directoryToCleanup}: ${err}`);
-                }
-            }
-        };
+        const cleanup = bbSkipCleanup ? ()=>Promise.resolve() : ()=>tryRmDir(directoryToCleanup);
+        const numIvcVerifiers = Number(BB_NUM_IVC_VERIFIERS);
+        const ivcConcurrency = Number(BB_IVC_CONCURRENCY);
         return {
             bbSkipCleanup,
             bbBinaryPath,
             bbWorkingDirectory,
-            cleanup
+            cleanup,
+            numConcurrentIVCVerifiers: numIvcVerifiers,
+            bbIVCConcurrency: ivcConcurrency
         };
     } catch (err) {
         logger.error(`Native BB not available, error: ${err}`);

package/dest/fixtures/index.d.ts

@@ -3,4 +3,4 @@ export * from './logging.js';
 export * from './utils.js';
 export * from './token_utils.js';
 export * from './with_telemetry_utils.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maXh0dXJlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsMkJBQTJCLENBQUMifQ==

package/dest/fixtures/l1_to_l2_messaging.d.ts

@@ -1,13 +1,17 @@
-import type { L1ContractAddresses, ViemPublicClient, ViemWalletClient } from '@aztec/ethereum';
-import { Fr } from '@aztec/foundation/fields';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 export declare function sendL1ToL2Message(message: {
     recipient: AztecAddress;
     content: Fr;
     secretHash: Fr;
 }, ctx: {
-    walletClient: ViemWalletClient;
-    publicClient: ViemPublicClient;
-    l1ContractAddresses: Pick<L1ContractAddresses, 'inboxAddress'>;
-}): Promise<Fr[]>;
-//# sourceMappingURL=l1_to_l2_messaging.d.ts.map
+    l1Client: ExtendedViemWalletClient;
+    l1ContractAddresses: Pick<L1ContractAddresses, 'inboxAddress' | 'rollupAddress'>;
+}): Promise<{
+    msgHash: Fr;
+    globalLeafIndex: Fr;
+    txReceipt: import("viem").TransactionReceipt;
+}>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDFfdG9fbDJfbWVzc2FnaW5nLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZml4dHVyZXMvbDFfdG9fbDJfbWVzc2FnaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDakYsT0FBTyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN0RSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFHcEQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFNaEUsd0JBQXNCLGlCQUFpQixDQUNyQyxPQUFPLEVBQUU7SUFBRSxTQUFTLEVBQUUsWUFBWSxDQUFDO0lBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQztJQUFDLFVBQVUsRUFBRSxFQUFFLENBQUE7Q0FBRSxFQUNqRSxHQUFHLEVBQUU7SUFDSCxRQUFRLEVBQUUsd0JBQXdCLENBQUM7SUFDbkMsbUJBQW1CLEVBQUUsSUFBSSxDQUFDLG1CQUFtQixFQUFFLGNBQWMsR0FBRyxlQUFlLENBQUMsQ0FBQztDQUNsRjs7OztHQWdFRiJ9

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

@@ -1 +1 @@
-{"version":3,"file":"l1_to_l2_messaging.d.ts","sourceRoot":"","sources":["../../src/fixtures/l1_to_l2_messaging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAC/F,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAKhE,wBAAsB,iBAAiB,CACrC,OAAO,EAAE;IAAE,SAAS,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,EAAE,CAAC;IAAC,UAAU,EAAE,EAAE,CAAA;CAAE,EACjE,GAAG,EAAE;IACH,YAAY,EAAE,gBAAgB,CAAC;IAC/B,YAAY,EAAE,gBAAgB,CAAC;IAC/B,mBAAmB,EAAE,IAAI,CAAC,mBAAmB,EAAE,cAAc,CAAC,CAAC;CAChE,iBAmCF"}
+{"version":3,"file":"l1_to_l2_messaging.d.ts","sourceRoot":"","sources":["../../src/fixtures/l1_to_l2_messaging.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAGpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAMhE,wBAAsB,iBAAiB,CACrC,OAAO,EAAE;IAAE,SAAS,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,EAAE,CAAC;IAAC,UAAU,EAAE,EAAE,CAAA;CAAE,EACjE,GAAG,EAAE;IACH,QAAQ,EAAE,wBAAwB,CAAC;IACnC,mBAAmB,EAAE,IAAI,CAAC,mBAAmB,EAAE,cAAc,GAAG,eAAe,CAAC,CAAC;CAClF;;;;GAgEF"}

package/dest/fixtures/l1_to_l2_messaging.js

@@ -1,15 +1,18 @@
-import { Fr } from '@aztec/foundation/fields';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { tryJsonStringify } from '@aztec/foundation/json-rpc';
 import { InboxAbi } from '@aztec/l1-artifacts';
-import { expect } from '@jest/globals';
 import { decodeEventLog, getContract } from 'viem';
+import { getLogger } from './utils.js';
 export async function sendL1ToL2Message(message, ctx) {
+    const logger = getLogger();
     const inbox = getContract({
         address: ctx.l1ContractAddresses.inboxAddress.toString(),
         abi: InboxAbi,
-        client: ctx.walletClient
+        client: ctx.l1Client
     });
     const { recipient, content, secretHash } = message;
-    const version = 1;
+    const version = await new RollupContract(ctx.l1Client, ctx.l1ContractAddresses.rollupAddress.toString()).getVersion();
     // We inject the message to Inbox
     const txHash = await inbox.write.sendL2Message([
         {
@@ -18,24 +21,47 @@ export async function sendL1ToL2Message(message, ctx) {
         },
         content.toString(),
         secretHash.toString()
-    ]);
+    ], {
+        gas: 1_000_000n
+    });
+    logger.info(`L1 to L2 message sent in tx ${txHash}`);
     // We check that the message was correctly injected by checking the emitted event
-    const txReceipt = await ctx.publicClient.waitForTransactionReceipt({
+    const txReceipt = await ctx.l1Client.waitForTransactionReceipt({
         hash: txHash
     });
-    // Exactly 1 event should be emitted in the transaction
-    expect(txReceipt.logs.length).toBe(1);
-    // We decode the event and get leaf out of it
-    const messageSentLog = txReceipt.logs[0];
-    const topics = decodeEventLog({
-        abi: InboxAbi,
-        data: messageSentLog.data,
-        topics: messageSentLog.topics
-    });
+    if (txReceipt.status !== 'success') {
+        throw new Error(`L1 to L2 message failed to be sent in tx ${txHash}. Status: ${txReceipt.status}`);
+    }
+    logger.info(`L1 to L2 message receipt retrieved for tx ${txReceipt.transactionHash}`, txReceipt);
+    if (txReceipt.transactionHash !== txHash) {
+        throw new Error(`Receipt transaction hash mismatch: ${txReceipt.transactionHash} !== ${txHash}`);
+    }
+    // Filter for MessageSent events from the Inbox contract by trying to decode each log
+    const messageSentLogs = txReceipt.logs.filter((log)=>log.address.toLowerCase() === ctx.l1ContractAddresses.inboxAddress.toString().toLowerCase()).map((log)=>{
+        try {
+            const decoded = decodeEventLog({
+                abi: InboxAbi,
+                data: log.data,
+                topics: log.topics
+            });
+            return {
+                log,
+                decoded
+            };
+        } catch  {
+            return null; // Not a decodable event from this ABI
+        }
+    }).filter((item)=>item !== null && item.decoded.eventName === 'MessageSent');
+    if (messageSentLogs.length !== 1) {
+        throw new Error(`Wrong number of MessageSent logs found in ${txHash} transaction (got ${messageSentLogs.length} expected 1)\n${tryJsonStringify(messageSentLogs.map((item)=>item.log))}`);
+    }
+    // We already have the decoded event
+    const topics = messageSentLogs[0].decoded;
     const receivedMsgHash = topics.args.hash;
     const receivedGlobalLeafIndex = topics.args.index;
-    return [
-        Fr.fromHexString(receivedMsgHash),
-        new Fr(receivedGlobalLeafIndex)
-    ];
+    return {
+        msgHash: Fr.fromHexString(receivedMsgHash),
+        globalLeafIndex: new Fr(receivedGlobalLeafIndex),
+        txReceipt
+    };
 }

package/dest/fixtures/logging.d.ts

@@ -5,4 +5,4 @@ export declare function isMetricsLoggingRequested(): boolean;
  * Idempotent and automatically called by `setup` if CI or BENCHMARK env vars are set.
  */
 export declare function setupMetricsLogger(filename: string): void;
-//# sourceMappingURL=logging.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2luZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ZpeHR1cmVzL2xvZ2dpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0Esd0dBQXdHO0FBQ3hHLHdCQUFnQix5QkFBeUIsWUFFeEM7QUFFRDs7O0dBR0c7QUFDSCx3QkFBZ0Isa0JBQWtCLENBQUMsUUFBUSxFQUFFLE1BQU0sUUFPbEQifQ==