@aztec/end-to-end 0.0.1-commit.9b94fc1 → 0.0.1-commit.9ee6fcc6

package/dest/shared/mock_state_view.d.ts

@@ -0,0 +1,86 @@
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import type { EthCheatCodes } from '@aztec/aztec/testing';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+/**
+ * Mock StateView contract for testing the Uniswap price oracle.
+ *
+ * Wraps a compiled Solidity contract that mimics the Uniswap V4 StateView's getSlot0 function.
+ * The mock allows setting return values dynamically for testing different price scenarios.
+ *
+ * Solidity source:
+ * ```solidity
+ * // SPDX-License-Identifier: Apache-2.0
+ * pragma solidity >=0.8.27;
+ *
+ * contract MockStateView {
+ *     uint160 public sqrtPriceX96;
+ *     int24 public tick;
+ *     uint24 public protocolFee;
+ *     uint24 public lpFee;
+ *
+ *     function setReturnValues(
+ *         uint160 _sqrtPriceX96,
+ *         int24 _tick,
+ *         uint24 _protocolFee,
+ *         uint24 _lpFee
+ *     ) external {
+ *         sqrtPriceX96 = _sqrtPriceX96;
+ *         tick = _tick;
+ *         protocolFee = _protocolFee;
+ *         lpFee = _lpFee;
+ *     }
+ *
+ *     function getSlot0(bytes32 poolId) external view returns (uint160, int24, uint24, uint24) {
+ *         return (sqrtPriceX96, tick, protocolFee, lpFee);
+ *     }
+ * }
+ * ```
+ */
+export declare class MockStateView {
+    private readonly address;
+    private readonly walletClient;
+    private readonly log;
+    private static readonly BYTECODE;
+    private static readonly ABI;
+    private constructor();
+    /**
+     * Deploys the mock StateView contract at the specified address using etch.
+     * @param ethCheatCodes - Cheat codes for etching bytecode
+     * @param walletClient - Wallet client for sending transactions
+     * @param address - Address to deploy the mock at (typically the real StateView address)
+     */
+    static deploy(ethCheatCodes: EthCheatCodes, walletClient: ExtendedViemWalletClient, address: EthAddress): Promise<MockStateView>;
+    /**
+     * Sets the price using the ethPerFeeAssetE12 format (same as rollup contract).
+     * Computes the corresponding sqrtPriceX96 internally.
+     *
+     * Math (from fee_asset_price_oracle.ts):
+     *   ethPerFeeAssetE12 = 1e12 * 2^192 / sqrtPriceX96^2
+     *
+     * Inverted:
+     *   sqrtPriceX96^2 = 1e12 * 2^192 / ethPerFeeAssetE12
+     *   sqrtPriceX96 = sqrt(1e12 * 2^192 / ethPerFeeAssetE12)
+     *
+     * @param ethPerFeeAssetE12 - The price in ETH per fee asset, scaled by 1e12
+     */
+    setEthPerFeeAsset(ethPerFeeAssetE12: bigint): Promise<import("viem").TransactionReceipt>;
+    /**
+     * Sets the sqrtPriceX96 value directly (Uniswap's price encoding).
+     * @param sqrtPriceX96 - The sqrtPriceX96 value
+     * @param tick - The tick value (default 10)
+     * @param protocolFee - The protocol fee (default 0)
+     * @param lpFee - The LP fee (default 500)
+     */
+    setSqrtPriceX96(sqrtPriceX96: bigint, tick?: number, protocolFee?: number, lpFee?: number): Promise<import("viem").TransactionReceipt>;
+    /**
+     * Converts ethPerFeeAssetE12 to sqrtPriceX96 (inverse of sqrtPriceX96ToEthPerFeeAssetE12).
+     *
+     * Math:
+     *   sqrtPriceX96 = sqrt(1e12 * 2^192 / ethPerFeeAssetE12)
+     */
+    ethPerFeeAssetE12ToSqrtPriceX96(ethPerFeeAssetE12: bigint): bigint;
+    /** Integer square root using Newton's method */
+    bigintSqrt(n: bigint): bigint;
+}
+export declare function diffInBps(a: bigint, b: bigint): bigint;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja19zdGF0ZV92aWV3LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2hhcmVkL21vY2tfc3RhdGVfdmlldy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFdkQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDMUQsT0FBTyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUl0RTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQWtDRztBQUNILHFCQUFhLGFBQWE7SUFxRHRCLE9BQU8sQ0FBQyxRQUFRLENBQUMsT0FBTztJQUN4QixPQUFPLENBQUMsUUFBUSxDQUFDLFlBQVk7SUFDN0IsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHO0lBdER0QixPQUFPLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQ20rRTtJQUNuZ0YsT0FBTyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQStDaEI7SUFFWCxPQUFPLGVBSUg7SUFFSjs7Ozs7T0FLRztJQUNILE9BQWEsTUFBTSxDQUNqQixhQUFhLEVBQUUsYUFBYSxFQUM1QixZQUFZLEVBQUUsd0JBQXdCLEVBQ3RDLE9BQU8sRUFBRSxVQUFVLEdBQ2xCLE9BQU8sQ0FBQyxhQUFhLENBQUMsQ0FHeEI7SUFFRDs7Ozs7Ozs7Ozs7O09BWUc7SUFDRyxpQkFBaUIsQ0FBQyxpQkFBaUIsRUFBRSxNQUFNLDhDQUdoRDtJQUVEOzs7Ozs7T0FNRztJQUNHLGVBQWUsQ0FBQyxZQUFZLEVBQUUsTUFBTSxFQUFFLElBQUksR0FBRSxNQUFXLEVBQUUsV0FBVyxHQUFFLE1BQVUsRUFBRSxLQUFLLEdBQUUsTUFBWSw4Q0FVMUc7SUFFRDs7Ozs7T0FLRztJQUNILCtCQUErQixDQUFDLGlCQUFpQixFQUFFLE1BQU0sR0FBRyxNQUFNLENBT2pFO0lBRUQsZ0RBQWdEO0lBQ2hELFVBQVUsQ0FBQyxDQUFDLEVBQUUsTUFBTSxHQUFHLE1BQU0sQ0FjNUI7Q0FDRjtBQUVELHdCQUFnQixTQUFTLENBQUMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxDQUFDLEVBQUUsTUFBTSxHQUFHLE1BQU0sQ0FFdEQifQ==

package/dest/shared/mock_state_view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock_state_view.d.ts","sourceRoot":"","sources":["../../src/shared/mock_state_view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAEvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAItE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,aAAa;IAqDtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG;IAtDtB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CACm+E;IACngF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CA+ChB;IAEX,OAAO,eAIH;IAEJ;;;;;OAKG;IACH,OAAa,MAAM,CACjB,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,wBAAwB,EACtC,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,aAAa,CAAC,CAGxB;IAED;;;;;;;;;;;;OAYG;IACG,iBAAiB,CAAC,iBAAiB,EAAE,MAAM,8CAGhD;IAED;;;;;;OAMG;IACG,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,GAAE,MAAW,EAAE,WAAW,GAAE,MAAU,EAAE,KAAK,GAAE,MAAY,8CAU1G;IAED;;;;;OAKG;IACH,+BAA+B,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAOjE;IAED,gDAAgD;IAChD,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAc5B;CACF;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtD"}

package/dest/shared/mock_state_view.js

@@ -0,0 +1,186 @@
+import { createLogger } from '@aztec/aztec.js/log';
+import { getContract } from 'viem';
+/**
+ * Mock StateView contract for testing the Uniswap price oracle.
+ *
+ * Wraps a compiled Solidity contract that mimics the Uniswap V4 StateView's getSlot0 function.
+ * The mock allows setting return values dynamically for testing different price scenarios.
+ *
+ * Solidity source:
+ * ```solidity
+ * // SPDX-License-Identifier: Apache-2.0
+ * pragma solidity >=0.8.27;
+ *
+ * contract MockStateView {
+ *     uint160 public sqrtPriceX96;
+ *     int24 public tick;
+ *     uint24 public protocolFee;
+ *     uint24 public lpFee;
+ *
+ *     function setReturnValues(
+ *         uint160 _sqrtPriceX96,
+ *         int24 _tick,
+ *         uint24 _protocolFee,
+ *         uint24 _lpFee
+ *     ) external {
+ *         sqrtPriceX96 = _sqrtPriceX96;
+ *         tick = _tick;
+ *         protocolFee = _protocolFee;
+ *         lpFee = _lpFee;
+ *     }
+ *
+ *     function getSlot0(bytes32 poolId) external view returns (uint160, int24, uint24, uint24) {
+ *         return (sqrtPriceX96, tick, protocolFee, lpFee);
+ *     }
+ * }
+ * ```
+ */ export class MockStateView {
+    address;
+    walletClient;
+    log;
+    static BYTECODE = '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';
+    static ABI = [
+        {
+            type: 'function',
+            name: 'setReturnValues',
+            inputs: [
+                {
+                    name: '_sqrtPriceX96',
+                    type: 'uint160'
+                },
+                {
+                    name: '_tick',
+                    type: 'int24'
+                },
+                {
+                    name: '_protocolFee',
+                    type: 'uint24'
+                },
+                {
+                    name: '_lpFee',
+                    type: 'uint24'
+                }
+            ],
+            outputs: [],
+            stateMutability: 'nonpayable'
+        },
+        {
+            inputs: [
+                {
+                    internalType: 'bytes32',
+                    name: 'poolId',
+                    type: 'bytes32'
+                }
+            ],
+            name: 'getSlot0',
+            outputs: [
+                {
+                    internalType: 'uint160',
+                    name: '',
+                    type: 'uint160'
+                },
+                {
+                    internalType: 'int24',
+                    name: '',
+                    type: 'int24'
+                },
+                {
+                    internalType: 'uint24',
+                    name: '',
+                    type: 'uint24'
+                },
+                {
+                    internalType: 'uint24',
+                    name: '',
+                    type: 'uint24'
+                }
+            ],
+            stateMutability: 'view',
+            type: 'function'
+        }
+    ];
+    constructor(address, walletClient, log = createLogger('mock-state-view')){
+        this.address = address;
+        this.walletClient = walletClient;
+        this.log = log;
+    }
+    /**
+   * Deploys the mock StateView contract at the specified address using etch.
+   * @param ethCheatCodes - Cheat codes for etching bytecode
+   * @param walletClient - Wallet client for sending transactions
+   * @param address - Address to deploy the mock at (typically the real StateView address)
+   */ static async deploy(ethCheatCodes, walletClient, address) {
+        await ethCheatCodes.etch(address, MockStateView.BYTECODE);
+        return new MockStateView(address, walletClient);
+    }
+    /**
+   * Sets the price using the ethPerFeeAssetE12 format (same as rollup contract).
+   * Computes the corresponding sqrtPriceX96 internally.
+   *
+   * Math (from fee_asset_price_oracle.ts):
+   *   ethPerFeeAssetE12 = 1e12 * 2^192 / sqrtPriceX96^2
+   *
+   * Inverted:
+   *   sqrtPriceX96^2 = 1e12 * 2^192 / ethPerFeeAssetE12
+   *   sqrtPriceX96 = sqrt(1e12 * 2^192 / ethPerFeeAssetE12)
+   *
+   * @param ethPerFeeAssetE12 - The price in ETH per fee asset, scaled by 1e12
+   */ async setEthPerFeeAsset(ethPerFeeAssetE12) {
+        const sqrtPriceX96 = this.ethPerFeeAssetE12ToSqrtPriceX96(ethPerFeeAssetE12);
+        return await this.setSqrtPriceX96(sqrtPriceX96);
+    }
+    /**
+   * Sets the sqrtPriceX96 value directly (Uniswap's price encoding).
+   * @param sqrtPriceX96 - The sqrtPriceX96 value
+   * @param tick - The tick value (default 10)
+   * @param protocolFee - The protocol fee (default 0)
+   * @param lpFee - The LP fee (default 500)
+   */ async setSqrtPriceX96(sqrtPriceX96, tick = 10, protocolFee = 0, lpFee = 500) {
+        const contract = getContract({
+            address: this.address.toString(),
+            abi: MockStateView.ABI,
+            client: this.walletClient
+        });
+        const hash = await contract.write.setReturnValues([
+            sqrtPriceX96,
+            tick,
+            protocolFee,
+            lpFee
+        ]);
+        this.log.info(`Set sqrtPriceX96 to ${sqrtPriceX96}`);
+        return await this.walletClient.waitForTransactionReceipt({
+            hash
+        });
+    }
+    /**
+   * Converts ethPerFeeAssetE12 to sqrtPriceX96 (inverse of sqrtPriceX96ToEthPerFeeAssetE12).
+   *
+   * Math:
+   *   sqrtPriceX96 = sqrt(1e12 * 2^192 / ethPerFeeAssetE12)
+   */ ethPerFeeAssetE12ToSqrtPriceX96(ethPerFeeAssetE12) {
+        if (ethPerFeeAssetE12 === 0n) {
+            throw new Error('Cannot convert zero ethPerFeeAssetE12');
+        }
+        const Q192 = 2n ** 192n;
+        const sqrtPriceSquared = 10n ** 12n * Q192 / ethPerFeeAssetE12;
+        return this.bigintSqrt(sqrtPriceSquared);
+    }
+    /** Integer square root using Newton's method */ bigintSqrt(n) {
+        if (n < 0n) {
+            throw new Error('Cannot compute sqrt of negative number');
+        }
+        if (n === 0n) {
+            return 0n;
+        }
+        let x = n;
+        let y = (x + 1n) / 2n;
+        while(y < x){
+            x = y;
+            y = (x + n / x) / 2n;
+        }
+        return x;
+    }
+}
+export function diffInBps(a, b) {
+    return (a - b) * 10000n / b;
+}

package/dest/shared/submit-transactions.d.ts

@@ -1,6 +1,6 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import type { SentTx } from '@aztec/aztec.js/contracts';
 import type { Logger } from '@aztec/aztec.js/log';
-import type { TestWallet } from '@aztec/test-wallet/server';
-export declare const submitTxsTo: (wallet: TestWallet, submitter: AztecAddress, numTxs: number, logger: Logger) => Promise<SentTx[]>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3VibWl0LXRyYW5zYWN0aW9ucy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NoYXJlZC9zdWJtaXQtdHJhbnNhY3Rpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUV4RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUdsRCxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUc1RCxlQUFPLE1BQU0sV0FBVyxvR0EyQnZCLENBQUMifQ==
+import { TxHash } from '@aztec/aztec.js/tx';
+import type { TestWallet } from '../test-wallet/test_wallet.js';
+export declare const submitTxsTo: (wallet: TestWallet, submitter: AztecAddress, numTxs: number, logger: Logger) => Promise<TxHash[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3VibWl0LXRyYW5zYWN0aW9ucy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NoYXJlZC9zdWJtaXQtdHJhbnNhY3Rpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUd6RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEVBQUUsTUFBTSxFQUE0QixNQUFNLG9CQUFvQixDQUFDO0FBR3RFLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBR2hFLGVBQU8sTUFBTSxXQUFXLG9HQXFCdkIsQ0FBQyJ9

package/dest/shared/submit-transactions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"submit-transactions.d.ts","sourceRoot":"","sources":["../../src/shared/submit-transactions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGlD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D,eAAO,MAAM,WAAW,oGA2BvB,CAAC"}
+{"version":3,"file":"submit-transactions.d.ts","sourceRoot":"","sources":["../../src/shared/submit-transactions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,MAAM,EAA4B,MAAM,oBAAoB,CAAC;AAGtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,eAAO,MAAM,WAAW,oGAqBvB,CAAC"}

package/dest/shared/submit-transactions.js

@@ -1,24 +1,22 @@
+import { NO_WAIT } from '@aztec/aztec.js/contracts';
 import { Fr, GrumpkinScalar } from '@aztec/aztec.js/fields';
 import { TxStatus } from '@aztec/aztec.js/tx';
 import { times } from '@aztec/foundation/collection';
 // submits a set of transactions to the provided Wallet
 export const submitTxsTo = async (wallet, submitter, numTxs, logger)=>{
-    const txs = [];
+    const txHashes = [];
     await Promise.all(times(numTxs, async ()=>{
         const accountManager = await wallet.createSchnorrAccount(Fr.random(), Fr.random(), GrumpkinScalar.random());
         const deployMethod = await accountManager.getDeployMethod();
-        const tx = deployMethod.send({
-            from: submitter
+        const { txHash } = await deployMethod.send({
+            from: submitter,
+            wait: NO_WAIT
         });
-        const txHash = await tx.getTxHash();
         logger.info(`Tx sent with hash ${txHash}`);
-        const receipt = await tx.getReceipt();
-        expect(receipt).toEqual(expect.objectContaining({
-            status: TxStatus.PENDING,
-            error: ''
-        }));
+        const receipt = await wallet.getTxReceipt(txHash);
+        expect(receipt.status).toBe(TxStatus.PENDING);
         logger.info(`Receipt received for ${txHash}`);
-        txs.push(tx);
+        txHashes.push(txHash);
     }));
-    return txs;
+    return txHashes;
 };

package/dest/shared/uniswap_l1_l2.d.ts

@@ -1,27 +1,3 @@
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import type { Logger } from '@aztec/aztec.js/log';
-import type { AztecNode } from '@aztec/aztec.js/node';
-import { CheatCodes } from '@aztec/aztec/testing';
-import { type DeployL1ContractsReturnType, type ExtendedViemWalletClient } from '@aztec/ethereum';
-import type { TestWallet } from '@aztec/test-wallet/server';
-/** Objects to be returned by the uniswap setup function */
-export type UniswapSetupContext = {
-    /** Aztec Node instance */
-    aztecNode: AztecNode;
-    /** Logger instance named as the current test. */
-    logger: Logger;
-    /** The L1 wallet client, extended with public actions. */
-    l1Client: ExtendedViemWalletClient;
-    /** The wallet. */
-    wallet: TestWallet;
-    /** The owner address. */
-    ownerAddress: AztecAddress;
-    /** The sponsor wallet. */
-    sponsorAddress: AztecAddress;
-    /**  */
-    deployL1ContractsValues: DeployL1ContractsReturnType;
-    /** Cheat codes instance. */
-    cheatCodes: CheatCodes;
-};
-export declare const uniswapL1L2TestSuite: (setup: () => Promise<UniswapSetupContext>, cleanup: () => Promise<void>, expectedForkBlockNumber?: number) => void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pc3dhcF9sMV9sMi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NoYXJlZC91bmlzd2FwX2wxX2wyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQWMsTUFBTSwyQkFBMkIsQ0FBQztBQUlyRSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN0RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDbEQsT0FBTyxFQUNMLEtBQUssMkJBQTJCLEVBQ2hDLEtBQUssd0JBQXdCLEVBSTlCLE1BQU0saUJBQWlCLENBQUM7QUFNekIsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFpQjVELDJEQUEyRDtBQUMzRCxNQUFNLE1BQU0sbUJBQW1CLEdBQUc7SUFDaEMsMEJBQTBCO0lBQzFCLFNBQVMsRUFBRSxTQUFTLENBQUM7SUFDckIsaURBQWlEO0lBQ2pELE1BQU0sRUFBRSxNQUFNLENBQUM7SUFDZiwwREFBMEQ7SUFDMUQsUUFBUSxFQUFFLHdCQUF3QixDQUFDO0lBQ25DLGtCQUFrQjtJQUNsQixNQUFNLEVBQUUsVUFBVSxDQUFDO0lBQ25CLHlCQUF5QjtJQUN6QixZQUFZLEVBQUUsWUFBWSxDQUFDO0lBQzNCLDBCQUEwQjtJQUMxQixjQUFjLEVBQUUsWUFBWSxDQUFDO0lBQzdCLE9BQU87SUFDUCx1QkFBdUIsRUFBRSwyQkFBMkIsQ0FBQztJQUNyRCw0QkFBNEI7SUFDNUIsVUFBVSxFQUFFLFVBQVUsQ0FBQztDQUN4QixDQUFDO0FBRUYsZUFBTyxNQUFNLG9CQUFvQixxSEFtK0JoQyxDQUFDIn0=
+import { type EndToEndContext } from '../fixtures/utils.js';
+export declare const uniswapL1L2TestSuite: (setup: () => Promise<EndToEndContext>, cleanup: () => Promise<void>, expectedForkBlockNumber?: number) => void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pc3dhcF9sMV9sMi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NoYXJlZC91bmlzd2FwX2wxX2wyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXVCQSxPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQW1DLE1BQU0sc0JBQXNCLENBQUM7QUFhN0YsZUFBTyxNQUFNLG9CQUFvQixpSEF1K0JoQyxDQUFDIn0=

package/dest/shared/uniswap_l1_l2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uniswap_l1_l2.d.ts","sourceRoot":"","sources":["../../src/shared/uniswap_l1_l2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAc,MAAM,2BAA2B,CAAC;AAIrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAI9B,MAAM,iBAAiB,CAAC;AAMzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAiB5D,2DAA2D;AAC3D,MAAM,MAAM,mBAAmB,GAAG;IAChC,0BAA0B;IAC1B,SAAS,EAAE,SAAS,CAAC;IACrB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,QAAQ,EAAE,wBAAwB,CAAC;IACnC,kBAAkB;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,yBAAyB;IACzB,YAAY,EAAE,YAAY,CAAC;IAC3B,0BAA0B;IAC1B,cAAc,EAAE,YAAY,CAAC;IAC7B,OAAO;IACP,uBAAuB,EAAE,2BAA2B,CAAC;IACrD,4BAA4B;IAC5B,UAAU,EAAE,UAAU,CAAC;CACxB,CAAC;AAEF,eAAO,MAAM,oBAAoB,qHAm+BhC,CAAC"}
+{"version":3,"file":"uniswap_l1_l2.d.ts","sourceRoot":"","sources":["../../src/shared/uniswap_l1_l2.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,KAAK,eAAe,EAAmC,MAAM,sBAAsB,CAAC;AAa7F,eAAO,MAAM,oBAAoB,iHAu+BhC,CAAC"}

package/dest/shared/uniswap_l1_l2.js

@@ -1,9 +1,13 @@
 import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
 import { computeAuthWitMessageHash } from '@aztec/aztec.js/authorization';
+import { waitForProven } from '@aztec/aztec.js/contracts';
 import { generateClaimSecret } from '@aztec/aztec.js/ethereum';
 import { Fr } from '@aztec/aztec.js/fields';
-import { RollupContract, deployL1Contract, extractEvent } from '@aztec/ethereum';
-import { sha256ToField } from '@aztec/foundation/crypto';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
+import { extractEvent } from '@aztec/ethereum/utils';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { sha256ToField } from '@aztec/foundation/crypto/sha256';
 import { InboxAbi, UniswapPortalAbi, UniswapPortalBytecode } from '@aztec/l1-artifacts';
 import { UniswapContract } from '@aztec/noir-contracts.js/Uniswap';
 import { computeL2ToL1MessageHash } from '@aztec/stdlib/hash';
@@ -45,7 +49,10 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
         let cheatCodes;
         let version;
         beforeAll(async ()=>{
-            ({ aztecNode, logger, l1Client, wallet, ownerAddress, sponsorAddress, deployL1ContractsValues, cheatCodes } = await setup());
+            const t = await setup();
+            ({ aztecNode, logger, deployL1ContractsValues, cheatCodes, wallet, accounts: [ownerAddress, sponsorAddress] } = t);
+            l1Client = deployL1ContractsValues.l1Client;
+            t.watcher.setIsMarkingAsProven(false);
             if (Number(await l1Client.getBlockNumber()) < expectedForkBlockNumber) {
                 throw new Error('This test must be run on a fork of mainnet with the expected fork block');
             }
@@ -68,9 +75,9 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 client: l1Client
             });
             // deploy l2 uniswap contract and attach to portal
-            uniswapL2Contract = await UniswapContract.deploy(wallet, uniswapPortalAddress).send({
+            ({ contract: uniswapL2Contract } = await UniswapContract.deploy(wallet, uniswapPortalAddress).send({
                 from: ownerAddress
-            }).deployed();
+            }));
             const registryAddress = (await aztecNode.getNodeInfo()).l1ContractAddresses.registryAddress;
             await uniswapPortal.write.initialize([
                 registryAddress.toString(),
@@ -117,12 +124,12 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
             // 4. Swap on L1 - sends L2 to L1 message to withdraw WETH to L1 and another message to swap assets.
             logger.info('Withdrawing weth to L1 and sending message to swap to dai');
             const [secretForDepositingSwappedDai, secretHashForDepositingSwappedDai] = await generateClaimSecret();
-            const l2UniswapInteractionReceipt = await uniswapL2Contract.methods.swap_private(wethCrossChainHarness.l2Token.address, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferToPublicApproval, uniswapFeeTier, minimumOutputAmount, secretHashForDepositingSwappedDai, ownerEthAddress).send({
+            const { receipt: l2UniswapInteractionReceipt } = await uniswapL2Contract.methods.swap_private(wethCrossChainHarness.l2Token.address, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferToPublicApproval, uniswapFeeTier, minimumOutputAmount, secretHashForDepositingSwappedDai, ownerEthAddress).send({
                 from: ownerAddress,
                 authWitnesses: [
                     transferToPublicAuhtwit
                 ]
-            }).wait();
+            });
             const swapPrivateFunction = 'swap_private(address,uint256,uint24,address,uint256,bytes32,address)';
             const swapPrivateContent = sha256ToField([
                 Buffer.from(toFunctionSelector(swapPrivateFunction).substring(2), 'hex'),
@@ -158,24 +165,28 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
             await wethCrossChainHarness.expectPrivateBalanceOnL2(ownerAddress, wethL2BalanceBeforeSwap - wethAmountToBridge);
             // ensure that uniswap contract didn't eat the funds.
             await wethCrossChainHarness.expectPublicBalanceOnL2(uniswapL2Contract.address, 0n);
-            // Since the outbox is only consumable when the block is proven, we need to set the block to be proven
-            await cheatCodes.rollup.markAsProven(await rollup.getCheckpointNumber());
+            // Since the outbox is only consumable when the epoch is proven, we need to advance to the next epoch.
+            const swapResult = await computeL2ToL1MembershipWitness(aztecNode, swapPrivateLeaf, l2UniswapInteractionReceipt.txHash);
+            const { epochNumber: epoch } = swapResult;
+            await cheatCodes.rollup.advanceToEpoch(EpochNumber(epoch + 1));
+            await waitForProven(aztecNode, l2UniswapInteractionReceipt, {
+                provenTimeout: 300
+            });
             // 5. Consume L2 to L1 message by calling uniswapPortal.swap_private()
             logger.info('Execute withdraw and swap on the uniswapPortal!');
             const daiL1BalanceOfPortalBeforeSwap = await daiCrossChainHarness.getL1BalanceOf(daiCrossChainHarness.tokenPortalAddress);
-            const swapResult = await computeL2ToL1MembershipWitness(aztecNode, l2UniswapInteractionReceipt.blockNumber, swapPrivateLeaf);
-            const withdrawResult = await computeL2ToL1MembershipWitness(aztecNode, l2UniswapInteractionReceipt.blockNumber, withdrawLeaf);
+            const withdrawResult = await computeL2ToL1MembershipWitness(aztecNode, withdrawLeaf, l2UniswapInteractionReceipt.txHash);
             const swapPrivateL2MessageIndex = swapResult.leafIndex;
             const swapPrivateSiblingPath = swapResult.siblingPath;
             const withdrawL2MessageIndex = withdrawResult.leafIndex;
             const withdrawSiblingPath = withdrawResult.siblingPath;
             const withdrawMessageMetadata = {
-                _checkpointNumber: BigInt(l2UniswapInteractionReceipt.blockNumber),
+                _epoch: BigInt(epoch),
                 _leafIndex: BigInt(withdrawL2MessageIndex),
                 _path: withdrawSiblingPath.toBufferArray().map((buf)=>`0x${buf.toString('hex')}`)
             };
             const swapPrivateMessageMetadata = {
-                _checkpointNumber: BigInt(l2UniswapInteractionReceipt.blockNumber),
+                _epoch: BigInt(epoch),
                 _leafIndex: BigInt(swapPrivateL2MessageIndex),
                 _path: swapPrivateSiblingPath.toBufferArray().map((buf)=>`0x${buf.toString('hex')}`)
             };
@@ -302,9 +313,9 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
         //       ownerEthAddress,
         //       nonceForSwap,
         //     );
-        //   await ownerWallet.setPublicAuthWit({ caller: sponsorAddress, action }, true).send().wait();
+        //   await ownerWallet.setPublicAuthWit({ caller: sponsorAddress, action }, true).send();
         //   // 4.2 Call swap_public from user2 on behalf of owner
-        //   const uniswapL2Interaction = await action.send().wait();
+        //   const uniswapL2Interaction = await action.send();
         //   const swapPublicContent = sha256ToField([
         //     Buffer.from(
         //       toFunctionSelector('swap_public(address,uint256,uint24,address,uint256,bytes32,bytes32,address)').substring(
@@ -357,14 +368,14 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
         //     withdrawLeaf,
         //   );
         //   const withdrawMessageMetadata = {
-        //     _checkpointNumber: BigInt(uniswapL2Interaction.blockNumber!),
+        //     _epoch: epoch,
         //     _leafIndex: BigInt(withdrawL2MessageIndex),
         //     _path: withdrawSiblingPath
         //       .toBufferArray()
         //       .map((buf: Buffer) => `0x${buf.toString('hex')}`) as readonly `0x${string}`[],
         //   };
         //   const swapPrivateMessageMetadata = {
-        //     _checkpointNumber: BigInt(uniswapL2Interaction.blockNumber!),
+        //     _epoch: epoch,
         //     _leafIndex: BigInt(swapPrivateL2MessageIndex),
         //     _path: swapPrivateSiblingPath
         //       .toBufferArray()
@@ -461,7 +472,7 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 authWitnesses: [
                     transferToPublicAuthwith
                 ]
-            }).wait()).rejects.toThrow('Assertion failed: input_asset address is not the same as seen in the bridge contract');
+            })).rejects.toThrow('Assertion failed: input_asset address is not the same as seen in the bridge contract');
         });
         // edge cases for public flow:
         it("I don't need approval to call swap_public if I'm swapping on my own behalf", async ()=>{
@@ -473,12 +484,12 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 caller: uniswapL2Contract.address,
                 action: wethCrossChainHarness.l2Token.methods.transfer_in_public(ownerAddress, uniswapL2Contract.address, wethAmountToBridge, nonceForWETHTransferApproval)
             }, true);
-            await validateActionInteraction.send().wait();
+            await validateActionInteraction.send();
             // No approval to call `swap` but should work even without it:
             const [_, secretHashForDepositingSwappedDai] = await generateClaimSecret();
             await uniswapL2Contract.methods.swap_public(ownerAddress, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferApproval, uniswapFeeTier, minimumOutputAmount, ownerAddress, secretHashForDepositingSwappedDai, ownerEthAddress, Fr.ZERO).send({
                 from: ownerAddress
-            }).wait();
+            });
             // check weth balance of owner on L2 (we first bridged `wethAmountToBridge` into L2 and now withdrew it!)
             await wethCrossChainHarness.expectPublicBalanceOnL2(ownerAddress, 0n);
         });
@@ -493,7 +504,7 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 caller: approvedUser,
                 action
             }, true);
-            await validateActionInteraction.send().wait();
+            await validateActionInteraction.send();
             await expect(action.simulate({
                 from: sponsorAddress
             })).rejects.toThrow(/unauthorized/);
@@ -505,7 +516,7 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 caller: uniswapL2Contract.address,
                 action: wethCrossChainHarness.l2Token.methods.transfer_in_public(ownerAddress, uniswapL2Contract.address, wethAmountToBridge, nonceForWETHTransferApproval)
             }, true);
-            await validateActionInteraction.send().wait();
+            await validateActionInteraction.send();
             await expect(uniswapL2Contract.methods.swap_public(ownerAddress, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, new Fr(420), uniswapFeeTier, minimumOutputAmount, ownerAddress, Fr.random(), ownerEthAddress, Fr.ZERO).simulate({
                 from: ownerAddress
             })).rejects.toThrow(/unauthorized/);
@@ -526,12 +537,12 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
             // Swap
             logger.info('Withdrawing weth to L1 and sending message to swap to dai');
             const [, secretHashForDepositingSwappedDai] = await generateClaimSecret();
-            const withdrawReceipt = await uniswapL2Contract.methods.swap_private(wethCrossChainHarness.l2Token.address, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferToPublicApproval, uniswapFeeTier, minimumOutputAmount, secretHashForDepositingSwappedDai, ownerEthAddress).send({
+            const { receipt: withdrawReceipt } = await uniswapL2Contract.methods.swap_private(wethCrossChainHarness.l2Token.address, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferToPublicApproval, uniswapFeeTier, minimumOutputAmount, secretHashForDepositingSwappedDai, ownerEthAddress).send({
                 from: ownerAddress,
                 authWitnesses: [
                     transferToPublicAuhtwit
                 ]
-            }).wait();
+            });
             const swapPrivateContent = sha256ToField([
                 Buffer.from(toFunctionSelector('swap_private(address,uint256,uint24,address,uint256,bytes32,address)').substring(2), 'hex'),
                 wethCrossChainHarness.tokenPortalAddress.toBuffer32(),
@@ -562,26 +573,30 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 rollupVersion: new Fr(version),
                 chainId: new Fr(l1Client.chain.id)
             });
-            const swapResult = await computeL2ToL1MembershipWitness(aztecNode, withdrawReceipt.blockNumber, swapPrivateLeaf);
-            const withdrawResult = await computeL2ToL1MembershipWitness(aztecNode, withdrawReceipt.blockNumber, withdrawLeaf);
+            const swapResult = await computeL2ToL1MembershipWitness(aztecNode, swapPrivateLeaf, withdrawReceipt.txHash);
+            const { epochNumber: epoch } = swapResult;
+            const withdrawResult = await computeL2ToL1MembershipWitness(aztecNode, withdrawLeaf, withdrawReceipt.txHash);
             const swapPrivateL2MessageIndex = swapResult.leafIndex;
             const swapPrivateSiblingPath = swapResult.siblingPath;
             const withdrawL2MessageIndex = withdrawResult.leafIndex;
             const withdrawSiblingPath = withdrawResult.siblingPath;
             const withdrawMessageMetadata = {
-                _checkpointNumber: BigInt(withdrawReceipt.blockNumber),
+                _epoch: BigInt(epoch),
                 _leafIndex: BigInt(withdrawL2MessageIndex),
                 _path: withdrawSiblingPath.toBufferArray().map((buf)=>`0x${buf.toString('hex')}`)
             };
             const swapPrivateMessageMetadata = {
-                _checkpointNumber: BigInt(withdrawReceipt.blockNumber),
+                _epoch: BigInt(epoch),
                 _leafIndex: BigInt(swapPrivateL2MessageIndex),
                 _path: swapPrivateSiblingPath.toBufferArray().map((buf)=>`0x${buf.toString('hex')}`)
             };
             // ensure that user's funds were burnt
             await wethCrossChainHarness.expectPrivateBalanceOnL2(ownerAddress, wethL2BalanceBeforeSwap - wethAmountToBridge);
-            // Since the outbox is only consumable when the block is proven, we need to set the block to be proven
-            await cheatCodes.rollup.markAsProven(await rollup.getCheckpointNumber());
+            // Since the outbox is only consumable when the epoch is proven, we need to advance to the next epoch.
+            await cheatCodes.rollup.advanceToEpoch(EpochNumber(epoch + 1));
+            await waitForProven(aztecNode, withdrawReceipt, {
+                provenTimeout: 300
+            });
             // On L1 call swap_public!
             logger.info('call swap_public on L1');
             const swapArgs = [
@@ -611,12 +626,12 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 caller: uniswapL2Contract.address,
                 action: wethCrossChainHarness.l2Token.methods.transfer_in_public(ownerAddress, uniswapL2Contract.address, wethAmountToBridge, nonceForWETHTransferApproval)
             }, true);
-            await validateActionInteraction.send().wait();
+            await validateActionInteraction.send();
             // Call swap_public on L2
             const secretHashForDepositingSwappedDai = Fr.random();
-            const withdrawReceipt = await uniswapL2Contract.methods.swap_public(ownerAddress, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferApproval, uniswapFeeTier, minimumOutputAmount, ownerAddress, secretHashForDepositingSwappedDai, ownerEthAddress, Fr.ZERO).send({
+            const { receipt: withdrawReceipt } = await uniswapL2Contract.methods.swap_public(ownerAddress, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferApproval, uniswapFeeTier, minimumOutputAmount, ownerAddress, secretHashForDepositingSwappedDai, ownerEthAddress, Fr.ZERO).send({
                 from: ownerAddress
-            }).wait();
+            });
             const swapPublicContent = sha256ToField([
                 Buffer.from(toFunctionSelector('swap_public(address,uint256,uint24,address,uint256,bytes32,bytes32,address)').substring(2), 'hex'),
                 wethCrossChainHarness.tokenPortalAddress.toBuffer32(),
@@ -648,26 +663,30 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 rollupVersion: new Fr(version),
                 chainId: new Fr(l1Client.chain.id)
             });
-            const swapResult = await computeL2ToL1MembershipWitness(aztecNode, withdrawReceipt.blockNumber, swapPublicLeaf);
-            const withdrawResult = await computeL2ToL1MembershipWitness(aztecNode, withdrawReceipt.blockNumber, withdrawLeaf);
+            const swapResult = await computeL2ToL1MembershipWitness(aztecNode, swapPublicLeaf, withdrawReceipt.txHash);
+            const { epochNumber: epoch } = swapResult;
+            const withdrawResult = await computeL2ToL1MembershipWitness(aztecNode, withdrawLeaf, withdrawReceipt.txHash);
             const swapPublicL2MessageIndex = swapResult.leafIndex;
             const swapPublicSiblingPath = swapResult.siblingPath;
             const withdrawL2MessageIndex = withdrawResult.leafIndex;
             const withdrawSiblingPath = withdrawResult.siblingPath;
             const withdrawMessageMetadata = {
-                _checkpointNumber: BigInt(withdrawReceipt.blockNumber),
+                _epoch: BigInt(epoch),
                 _leafIndex: BigInt(withdrawL2MessageIndex),
                 _path: withdrawSiblingPath.toBufferArray().map((buf)=>`0x${buf.toString('hex')}`)
             };
             const swapPublicMessageMetadata = {
-                _checkpointNumber: BigInt(withdrawReceipt.blockNumber),
+                _epoch: BigInt(epoch),
                 _leafIndex: BigInt(swapPublicL2MessageIndex),
                 _path: swapPublicSiblingPath.toBufferArray().map((buf)=>`0x${buf.toString('hex')}`)
             };
             // check weth balance of owner on L2 (we first bridged `wethAmountToBridge` into L2 and now withdrew it!)
             await wethCrossChainHarness.expectPublicBalanceOnL2(ownerAddress, 0n);
-            // Since the outbox is only consumable when the block is proven, we need to set the block to be proven
-            await cheatCodes.rollup.markAsProven(await rollup.getCheckpointNumber());
+            // Since the outbox is only consumable when the epoch is proven, we need to advance to the next epoch.
+            await cheatCodes.rollup.advanceToEpoch(EpochNumber(epoch + 1));
+            await waitForProven(aztecNode, withdrawReceipt, {
+                provenTimeout: 300
+            });
             // Call swap_private on L1
             logger.info('Execute withdraw and swap on the uniswapPortal!');
             const swapArgs = [