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

package/dest/shared/uniswap_l1_l2.js

@@ -1,11 +1,20 @@
-import { AztecAddress, EthAddress, Fr, computeAuthWitMessageHash, generateClaimSecret } from '@aztec/aztec.js';
-import { deployL1Contract, extractEvent } from '@aztec/ethereum';
-import { sha256ToField } from '@aztec/foundation/crypto';
-import { InboxAbi, RollupAbi, UniswapPortalAbi, UniswapPortalBytecode } from '@aztec/l1-artifacts';
+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 } 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 { retryUntil } from '@aztec/foundation/retry';
+import { InboxAbi, UniswapPortalAbi, UniswapPortalBytecode } from '@aztec/l1-artifacts';
 import { UniswapContract } from '@aztec/noir-contracts.js/Uniswap';
+import { computeL2ToL1MessageHash } from '@aztec/stdlib/hash';
 import { jest } from '@jest/globals';
 import { getContract, parseEther, toFunctionSelector } from 'viem';
-import { ensureAccountsPubliclyDeployed } from '../fixtures/utils.js';
+import { ensureAccountContractsPublished, ensureAuthRegistryPublished } from '../fixtures/utils.js';
 import { CrossChainTestHarness } from './cross_chain_test_harness.js';
 // PSA: This tests works on forked mainnet. There is a dump of the data in `dumpedState` such that we
 // don't need to burn through RPC requests.
@@ -13,26 +22,20 @@ import { CrossChainTestHarness } from './cross_chain_test_harness.js';
 // To start an actual fork, use the command:
 // anvil --fork-url https://mainnet.infura.io/v3/9928b52099854248b3a096be07a6b23c --fork-block-number 17514288 --chain-id 31337
 // For CI, this is configured in `run_tests.sh` and `docker-compose-images.yml`
-// docs:start:uniswap_l1_l2_test_setup_const
-const TIMEOUT = 360_000;
-// docs:end:uniswap_l1_l2_test_setup_const
+const TIMEOUT = 15 * 60 * 1000;
 export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 17514288)=>{
-    // docs:start:uniswap_l1_l2_test_beforeAll
     describe('uniswap_trade_on_l1_from_l2', ()=>{
         jest.setTimeout(TIMEOUT);
         const WETH9_ADDRESS = EthAddress.fromString('0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2');
         const DAI_ADDRESS = EthAddress.fromString('0x6B175474E89094C44Da98b954EedeAC495271d0F');
         let aztecNode;
-        let pxe;
         let logger;
-        let walletClient;
-        let publicClient;
-        let ownerWallet;
+        let l1Client;
+        let wallet;
         let ownerAddress;
         let ownerEthAddress;
         // does transactions on behalf of owner on Aztec:
-        let sponsorWallet;
-        // let sponsorAddress: AztecAddress;
+        let sponsorAddress;
         let daiCrossChainHarness;
         let wethCrossChainHarness;
         let deployL1ContractsValues;
@@ -44,58 +47,58 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
         const uniswapFeeTier = 3000n;
         const minimumOutputAmount = 0n;
         let cheatCodes;
+        let version;
         beforeAll(async ()=>{
-            ({ aztecNode, pxe, logger, publicClient, walletClient, ownerWallet, sponsorWallet, deployL1ContractsValues, cheatCodes } = await setup());
-            if (Number(await publicClient.getBlockNumber()) < expectedForkBlockNumber) {
+            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');
             }
-            rollup = getContract({
-                address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
-                abi: RollupAbi,
-                client: deployL1ContractsValues.walletClient
-            });
-            ownerAddress = ownerWallet.getAddress();
-            // sponsorAddress = sponsorWallet.getAddress();
-            ownerEthAddress = EthAddress.fromString((await walletClient.getAddresses())[0]);
-            await ensureAccountsPubliclyDeployed(ownerWallet, [
-                ownerWallet,
-                sponsorWallet
+            rollup = new RollupContract(deployL1ContractsValues.l1Client, deployL1ContractsValues.l1ContractAddresses.rollupAddress);
+            version = Number(await rollup.getVersion());
+            ownerEthAddress = EthAddress.fromString((await l1Client.getAddresses())[0]);
+            await ensureAccountContractsPublished(wallet, [
+                ownerAddress,
+                sponsorAddress
             ]);
+            await ensureAuthRegistryPublished(wallet, ownerAddress);
             logger.info('Deploying DAI Portal, initializing and deploying l2 contract...');
-            daiCrossChainHarness = await CrossChainTestHarness.new(aztecNode, pxe, publicClient, walletClient, ownerWallet, logger, DAI_ADDRESS);
+            daiCrossChainHarness = await CrossChainTestHarness.new(aztecNode, deployL1ContractsValues.l1Client, wallet, ownerAddress, logger, DAI_ADDRESS);
             logger.info('Deploying WETH Portal, initializing and deploying l2 contract...');
-            wethCrossChainHarness = await CrossChainTestHarness.new(aztecNode, pxe, publicClient, walletClient, ownerWallet, logger, WETH9_ADDRESS);
+            wethCrossChainHarness = await CrossChainTestHarness.new(aztecNode, l1Client, wallet, ownerAddress, logger, WETH9_ADDRESS);
             logger.info('Deploy Uniswap portal on L1 and L2...');
-            uniswapPortalAddress = await deployL1Contract(walletClient, publicClient, UniswapPortalAbi, UniswapPortalBytecode).then(({ address })=>address);
+            uniswapPortalAddress = await deployL1Contract(l1Client, UniswapPortalAbi, UniswapPortalBytecode).then(({ address })=>address);
             uniswapPortal = getContract({
                 address: uniswapPortalAddress.toString(),
                 abi: UniswapPortalAbi,
-                client: walletClient
+                client: l1Client
             });
             // deploy l2 uniswap contract and attach to portal
-            uniswapL2Contract = await UniswapContract.deploy(ownerWallet, uniswapPortalAddress).send().deployed();
-            const registryAddress = (await pxe.getNodeInfo()).l1ContractAddresses.registryAddress;
+            ({ contract: uniswapL2Contract } = await UniswapContract.deploy(wallet, uniswapPortalAddress).send({
+                from: ownerAddress
+            }));
+            const registryAddress = (await aztecNode.getNodeInfo()).l1ContractAddresses.registryAddress;
             await uniswapPortal.write.initialize([
                 registryAddress.toString(),
                 uniswapL2Contract.address.toString()
             ], {});
             // Give me some WETH so I can deposit to L2 and do the swap...
             logger.info('Getting some weth');
-            const hash = await walletClient.sendTransaction({
+            const hash = await l1Client.sendTransaction({
                 to: WETH9_ADDRESS.toString(),
                 value: parseEther('1000')
             });
-            await publicClient.waitForTransactionReceipt({
+            await l1Client.waitForTransactionReceipt({
                 hash
             });
             const wethBalance = await wethCrossChainHarness.getL1BalanceOf(ownerEthAddress);
             expect(wethBalance).toBe(parseEther('1000'));
         });
-        // docs:end:uniswap_l1_l2_test_beforeAll
         afterAll(async ()=>{
             await cleanup();
         });
-        // docs:start:uniswap_private
         it('should uniswap trade on L1 from L2 funds privately (swaps WETH -> DAI)', async ()=>{
             const wethL1BeforeBalance = await wethCrossChainHarness.getL1BalanceOf(ownerEthAddress);
             // 1. Approve and deposit weth to the portal and move to L2
@@ -114,14 +117,19 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
             // 3. Owner gives uniswap approval to transfer the funds to public to self on its behalf
             logger.info('Approving uniswap to transfer funds to public to self on my behalf');
             const nonceForWETHTransferToPublicApproval = new Fr(1n);
-            await ownerWallet.createAuthWit({
+            const transferToPublicAuhtwit = await wallet.createAuthWit(ownerAddress, {
                 caller: uniswapL2Contract.address,
                 action: wethCrossChainHarness.l2Token.methods.transfer_to_public(ownerAddress, uniswapL2Contract.address, wethAmountToBridge, nonceForWETHTransferToPublicApproval)
             });
             // 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().wait();
+            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
+                ]
+            });
             const swapPrivateFunction = 'swap_private(address,uint256,uint24,address,uint256,bytes32,address)';
             const swapPrivateContent = sha256ToField([
                 Buffer.from(toFunctionSelector(swapPrivateFunction).substring(2), 'hex'),
@@ -133,44 +141,59 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 secretHashForDepositingSwappedDai,
                 ownerEthAddress.toBuffer32()
             ]);
-            const swapPrivateLeaf = sha256ToField([
-                uniswapL2Contract.address,
-                new Fr(1),
-                EthAddress.fromString(uniswapPortal.address).toBuffer32(),
-                new Fr(publicClient.chain.id),
-                swapPrivateContent
-            ]);
+            const swapPrivateLeaf = computeL2ToL1MessageHash({
+                l2Sender: uniswapL2Contract.address,
+                l1Recipient: EthAddress.fromString(uniswapPortal.address),
+                content: swapPrivateContent,
+                rollupVersion: new Fr(version),
+                chainId: new Fr(l1Client.chain.id)
+            });
             const withdrawContent = sha256ToField([
                 Buffer.from(toFunctionSelector('withdraw(address,uint256,address)').substring(2), 'hex'),
                 uniswapPortalAddress.toBuffer32(),
                 new Fr(wethAmountToBridge),
                 uniswapPortalAddress.toBuffer32()
             ]);
-            const withdrawLeaf = sha256ToField([
-                wethCrossChainHarness.l2Bridge.address,
-                new Fr(1),
-                wethCrossChainHarness.tokenPortalAddress.toBuffer32(),
-                new Fr(publicClient.chain.id),
-                withdrawContent
-            ]);
+            const withdrawLeaf = computeL2ToL1MessageHash({
+                l2Sender: wethCrossChainHarness.l2Bridge.address,
+                l1Recipient: wethCrossChainHarness.tokenPortalAddress,
+                content: withdrawContent,
+                rollupVersion: new Fr(version),
+                chainId: new Fr(l1Client.chain.id)
+            });
             // ensure that user's funds were burnt
             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.read.getPendingBlockNumber());
+            // Since the outbox is only consumable when the epoch is proven, we need to advance to the next epoch
+            // before we can ask the witness helper for a covering root.
+            const minedReceipt = await aztecNode.getTxReceipt(l2UniswapInteractionReceipt.txHash);
+            if (minedReceipt.epochNumber === undefined) {
+                throw new Error('L2 Uniswap interaction tx is not yet in an epoch');
+            }
+            await cheatCodes.rollup.advanceToEpoch(EpochNumber(minedReceipt.epochNumber + 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 [swapPrivateL2MessageIndex, swapPrivateSiblingPath] = await aztecNode.getL2ToL1MessageMembershipWitness(l2UniswapInteractionReceipt.blockNumber, swapPrivateLeaf);
-            const [withdrawL2MessageIndex, withdrawSiblingPath] = await aztecNode.getL2ToL1MessageMembershipWitness(l2UniswapInteractionReceipt.blockNumber, withdrawLeaf);
+            const swapResult = await retryUntil(()=>aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, swapPrivateLeaf), 'swap private l2 to l1 witness', 60, 1);
+            const { epochNumber: epoch, numCheckpointsInEpoch } = swapResult;
+            const withdrawResult = await retryUntil(()=>aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, withdrawLeaf), 'withdraw l2 to l1 witness', 60, 1);
+            const swapPrivateL2MessageIndex = swapResult.leafIndex;
+            const swapPrivateSiblingPath = swapResult.siblingPath;
+            const withdrawL2MessageIndex = withdrawResult.leafIndex;
+            const withdrawSiblingPath = withdrawResult.siblingPath;
             const withdrawMessageMetadata = {
-                _l2BlockNumber: BigInt(l2UniswapInteractionReceipt.blockNumber),
+                _epoch: BigInt(epoch),
+                _numCheckpointsInEpoch: BigInt(withdrawResult.numCheckpointsInEpoch),
                 _leafIndex: BigInt(withdrawL2MessageIndex),
                 _path: withdrawSiblingPath.toBufferArray().map((buf)=>`0x${buf.toString('hex')}`)
             };
             const swapPrivateMessageMetadata = {
-                _l2BlockNumber: BigInt(l2UniswapInteractionReceipt.blockNumber),
+                _epoch: BigInt(epoch),
+                _numCheckpointsInEpoch: BigInt(numCheckpointsInEpoch),
                 _leafIndex: BigInt(swapPrivateL2MessageIndex),
                 _path: swapPrivateSiblingPath.toBufferArray().map((buf)=>`0x${buf.toString('hex')}`)
             };
@@ -188,7 +211,7 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 ]
             ];
             // this should also insert a message into the inbox.
-            const txReceipt = await daiCrossChainHarness.publicClient.waitForTransactionReceipt({
+            const txReceipt = await daiCrossChainHarness.l1Client.waitForTransactionReceipt({
                 hash: await uniswapPortal.write.swapPrivate(swapArgs)
             });
             // We get the msg leaf from event so that we can later wait for it to be available for consumption
@@ -219,9 +242,7 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
             logger.info('WETH balance after swap : ', wethL2BalanceAfterSwap.toString());
             logger.info('DAI balance after swap  : ', daiL2BalanceAfterSwap.toString());
         });
-        // docs:end:uniswap_private
         // TODO(#7463): reenable look into this failure https://github.com/AztecProtocol/aztec-packages/actions/runs/9912612912/job/27388320150?pr=7462
-        // // docs:start:uniswap_public
         // it('should uniswap trade on L1 from L2 funds publicly (swaps WETH -> DAI)', async () => {
         //   const wethL1BeforeBalance = await wethCrossChainHarness.getL1BalanceOf(ownerEthAddress);
         //   // 1. Approve and deposit weth to the portal and move to L2
@@ -297,9 +318,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(
@@ -352,14 +373,14 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
         //     withdrawLeaf,
         //   );
         //   const withdrawMessageMetadata = {
-        //     _l2BlockNumber: BigInt(uniswapL2Interaction.blockNumber!),
+        //     _epoch: epoch,
         //     _leafIndex: BigInt(withdrawL2MessageIndex),
         //     _path: withdrawSiblingPath
         //       .toBufferArray()
         //       .map((buf: Buffer) => `0x${buf.toString('hex')}`) as readonly `0x${string}`[],
         //   };
         //   const swapPrivateMessageMetadata = {
-        //     _l2BlockNumber: BigInt(uniswapL2Interaction.blockNumber!),
+        //     _epoch: epoch,
         //     _leafIndex: BigInt(swapPrivateL2MessageIndex),
         //     _path: swapPrivateSiblingPath
         //       .toBufferArray()
@@ -424,7 +445,6 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
         //   logger.info('WETH balance after swap : ', wethL2BalanceAfterSwap.toString());
         //   logger.info('DAI balance after swap  : ', daiL2BalanceAfterSwap.toString());
         // });
-        // // docs:end:uniswap_public
         // Edge cases for the private flow:
         // note - tests for uniswapPortal.sol and minting asset on L2 are covered in other tests.
         it('swap_private reverts without transfer to public approval', async ()=>{
@@ -432,12 +452,11 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
             const nonceForWETHTransferToPublicApproval = new Fr(2n);
             const expectedMessageHash = await computeAuthWitMessageHash({
                 caller: uniswapL2Contract.address,
-                action: wethCrossChainHarness.l2Token.methods.transfer_to_public(ownerAddress, uniswapL2Contract.address, wethAmountToBridge, nonceForWETHTransferToPublicApproval)
-            }, {
-                chainId: ownerWallet.getChainId(),
-                version: ownerWallet.getVersion()
-            });
-            await expect(uniswapL2Contract.methods.swap_private(wethCrossChainHarness.l2Token.address, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferToPublicApproval, uniswapFeeTier, minimumOutputAmount, Fr.random(), ownerEthAddress).prove()).rejects.toThrow(`Unknown auth witness for message hash ${expectedMessageHash.toString()}`);
+                call: await wethCrossChainHarness.l2Token.methods.transfer_to_public(ownerAddress, uniswapL2Contract.address, wethAmountToBridge, nonceForWETHTransferToPublicApproval).getFunctionCall()
+            }, await wallet.getChainInfo());
+            await expect(uniswapL2Contract.methods.swap_private(wethCrossChainHarness.l2Token.address, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferToPublicApproval, uniswapFeeTier, minimumOutputAmount, Fr.random(), ownerEthAddress).simulate({
+                from: ownerAddress
+            })).rejects.toThrow(`Unknown auth witness for message hash ${expectedMessageHash.toString()}`);
         });
         it("can't swap if user passes a token different to what the bridge tracks", async ()=>{
             // 1. give user private funds on L2:
@@ -446,13 +465,18 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
             // 2. owner gives uniswap approval to transfer the funds to public:
             logger.info('Approving uniswap to transfer funds to public to self on my behalf');
             const nonceForWETHTransferToPublicApproval = new Fr(3n);
-            await ownerWallet.createAuthWit({
+            const transferToPublicAuthwith = await wallet.createAuthWit(ownerAddress, {
                 caller: uniswapL2Contract.address,
                 action: wethCrossChainHarness.l2Token.methods.transfer_to_public(ownerAddress, uniswapL2Contract.address, wethAmountToBridge, nonceForWETHTransferToPublicApproval)
             });
             // 3. Swap but send the wrong token address
             logger.info('Swap but send the wrong token address');
-            await expect(uniswapL2Contract.methods.swap_private(wethCrossChainHarness.l2Token.address, daiCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferToPublicApproval, uniswapFeeTier, minimumOutputAmount, Fr.random(), ownerEthAddress).prove()).rejects.toThrow('Assertion failed: input_asset address is not the same as seen in the bridge contract');
+            await expect(uniswapL2Contract.methods.swap_private(wethCrossChainHarness.l2Token.address, daiCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferToPublicApproval, uniswapFeeTier, minimumOutputAmount, Fr.random(), ownerEthAddress).send({
+                from: ownerAddress,
+                authWitnesses: [
+                    transferToPublicAuthwith
+                ]
+            })).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 ()=>{
@@ -460,14 +484,16 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
             await wethCrossChainHarness.mintTokensPublicOnL2(wethAmountToBridge);
             // 2. Give approval to uniswap to transfer funds to itself
             const nonceForWETHTransferApproval = new Fr(2n);
-            const validateActionInteraction = await ownerWallet.setPublicAuthWit({
+            const validateActionInteraction = await wallet.setPublicAuthWit(ownerAddress, {
                 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().wait();
+            await uniswapL2Contract.methods.swap_public(ownerAddress, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferApproval, uniswapFeeTier, minimumOutputAmount, ownerAddress, secretHashForDepositingSwappedDai, ownerEthAddress, Fr.ZERO).send({
+                from: ownerAddress
+            });
             // check weth balance of owner on L2 (we first bridged `wethAmountToBridge` into L2 and now withdrew it!)
             await wethCrossChainHarness.expectPublicBalanceOnL2(ownerAddress, 0n);
         });
@@ -477,23 +503,27 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
             const nonceForWETHTransferApproval = new Fr(3n);
             const nonceForSwap = new Fr(3n);
             const secretHashForDepositingSwappedDai = new Fr(4n);
-            const action = uniswapL2Contract.withWallet(sponsorWallet).methods.swap_public(ownerAddress, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferApproval, uniswapFeeTier, minimumOutputAmount, ownerAddress, secretHashForDepositingSwappedDai, ownerEthAddress, nonceForSwap);
-            const validateActionInteraction = await ownerWallet.setPublicAuthWit({
+            const action = uniswapL2Contract.methods.swap_public(ownerAddress, wethCrossChainHarness.l2Bridge.address, wethAmountToBridge, daiCrossChainHarness.l2Bridge.address, nonceForWETHTransferApproval, uniswapFeeTier, minimumOutputAmount, ownerAddress, secretHashForDepositingSwappedDai, ownerEthAddress, nonceForSwap);
+            const validateActionInteraction = await wallet.setPublicAuthWit(ownerAddress, {
                 caller: approvedUser,
                 action
             }, true);
-            await validateActionInteraction.send().wait();
-            await expect(action.simulate()).rejects.toThrow(/unauthorized/);
+            await validateActionInteraction.send();
+            await expect(action.simulate({
+                from: sponsorAddress
+            })).rejects.toThrow(/unauthorized/);
         });
         it("uniswap can't pull funds without transfer approval", async ()=>{
             // swap should fail since no transfer approval to uniswap:
             const nonceForWETHTransferApproval = new Fr(4n);
-            const validateActionInteraction = await ownerWallet.setPublicAuthWit({
+            const validateActionInteraction = await wallet.setPublicAuthWit(ownerAddress, {
                 caller: uniswapL2Contract.address,
                 action: wethCrossChainHarness.l2Token.methods.transfer_in_public(ownerAddress, uniswapL2Contract.address, wethAmountToBridge, nonceForWETHTransferApproval)
             }, true);
-            await validateActionInteraction.send().wait();
-            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()).rejects.toThrow(/unauthorized/);
+            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/);
         });
         // tests when trying to mix private and public flows:
         it("can't call swap_public on L1 if called swap_private on L2", async ()=>{
@@ -503,7 +533,7 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
             // Owner gives uniswap approval to transfer the funds to public to self on its behalf
             logger.info('Approving uniswap to transfer the funds to public to self on my behalf');
             const nonceForWETHTransferToPublicApproval = new Fr(4n);
-            await ownerWallet.createAuthWit({
+            const transferToPublicAuhtwit = await wallet.createAuthWit(ownerAddress, {
                 caller: uniswapL2Contract.address,
                 action: wethCrossChainHarness.l2Token.methods.transfer_to_public(ownerAddress, uniswapL2Contract.address, wethAmountToBridge, nonceForWETHTransferToPublicApproval)
             });
@@ -511,7 +541,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().wait();
+            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
+                ]
+            });
             const swapPrivateContent = sha256ToField([
                 Buffer.from(toFunctionSelector('swap_private(address,uint256,uint24,address,uint256,bytes32,address)').substring(2), 'hex'),
                 wethCrossChainHarness.tokenPortalAddress.toBuffer32(),
@@ -522,42 +557,57 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 secretHashForDepositingSwappedDai,
                 ownerEthAddress.toBuffer32()
             ]);
-            const swapPrivateLeaf = sha256ToField([
-                uniswapL2Contract.address,
-                new Fr(1),
-                EthAddress.fromString(uniswapPortal.address).toBuffer32(),
-                new Fr(publicClient.chain.id),
-                swapPrivateContent
-            ]);
+            const swapPrivateLeaf = computeL2ToL1MessageHash({
+                l2Sender: uniswapL2Contract.address,
+                l1Recipient: EthAddress.fromString(uniswapPortal.address),
+                content: swapPrivateContent,
+                rollupVersion: new Fr(version),
+                chainId: new Fr(l1Client.chain.id)
+            });
             const withdrawContent = sha256ToField([
                 Buffer.from(toFunctionSelector('withdraw(address,uint256,address)').substring(2), 'hex'),
                 uniswapPortalAddress.toBuffer32(),
                 new Fr(wethAmountToBridge),
                 uniswapPortalAddress.toBuffer32()
             ]);
-            const withdrawLeaf = sha256ToField([
-                wethCrossChainHarness.l2Bridge.address,
-                new Fr(1),
-                wethCrossChainHarness.tokenPortalAddress.toBuffer32(),
-                new Fr(publicClient.chain.id),
-                withdrawContent
-            ]);
-            const [swapPrivateL2MessageIndex, swapPrivateSiblingPath] = await aztecNode.getL2ToL1MessageMembershipWitness(withdrawReceipt.blockNumber, swapPrivateLeaf);
-            const [withdrawL2MessageIndex, withdrawSiblingPath] = await aztecNode.getL2ToL1MessageMembershipWitness(withdrawReceipt.blockNumber, withdrawLeaf);
+            const withdrawLeaf = computeL2ToL1MessageHash({
+                l2Sender: wethCrossChainHarness.l2Bridge.address,
+                l1Recipient: wethCrossChainHarness.tokenPortalAddress,
+                content: withdrawContent,
+                rollupVersion: new Fr(version),
+                chainId: new Fr(l1Client.chain.id)
+            });
+            // ensure that user's funds were burnt
+            await wethCrossChainHarness.expectPrivateBalanceOnL2(ownerAddress, wethL2BalanceBeforeSwap - wethAmountToBridge);
+            // Since the outbox is only consumable when the epoch is proven, we need to advance to the next epoch
+            // before we can ask the witness helper for a covering root.
+            const minedReceipt = await aztecNode.getTxReceipt(withdrawReceipt.txHash);
+            if (minedReceipt.epochNumber === undefined) {
+                throw new Error('Withdraw tx is not yet in an epoch');
+            }
+            await cheatCodes.rollup.advanceToEpoch(EpochNumber(minedReceipt.epochNumber + 1));
+            await waitForProven(aztecNode, withdrawReceipt, {
+                provenTimeout: 300
+            });
+            const swapResult = await retryUntil(()=>aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, swapPrivateLeaf), 'swap private l2 to l1 witness', 60, 1);
+            const { epochNumber: epoch, numCheckpointsInEpoch } = swapResult;
+            const withdrawResult = await retryUntil(()=>aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, withdrawLeaf), 'withdraw l2 to l1 witness', 60, 1);
+            const swapPrivateL2MessageIndex = swapResult.leafIndex;
+            const swapPrivateSiblingPath = swapResult.siblingPath;
+            const withdrawL2MessageIndex = withdrawResult.leafIndex;
+            const withdrawSiblingPath = withdrawResult.siblingPath;
             const withdrawMessageMetadata = {
-                _l2BlockNumber: BigInt(withdrawReceipt.blockNumber),
+                _epoch: BigInt(epoch),
+                _numCheckpointsInEpoch: BigInt(withdrawResult.numCheckpointsInEpoch),
                 _leafIndex: BigInt(withdrawL2MessageIndex),
                 _path: withdrawSiblingPath.toBufferArray().map((buf)=>`0x${buf.toString('hex')}`)
             };
             const swapPrivateMessageMetadata = {
-                _l2BlockNumber: BigInt(withdrawReceipt.blockNumber),
+                _epoch: BigInt(epoch),
+                _numCheckpointsInEpoch: BigInt(numCheckpointsInEpoch),
                 _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.read.getPendingBlockNumber());
             // On L1 call swap_public!
             logger.info('call swap_public on L1');
             const swapArgs = [
@@ -583,14 +633,16 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
             await wethCrossChainHarness.mintTokensPublicOnL2(wethAmountToBridge);
             // Owner gives uniswap approval to transfer funds on its behalf
             const nonceForWETHTransferApproval = new Fr(5n);
-            const validateActionInteraction = await ownerWallet.setPublicAuthWit({
+            const validateActionInteraction = await wallet.setPublicAuthWit(ownerAddress, {
                 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().wait();
+            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
+            });
             const swapPublicContent = sha256ToField([
                 Buffer.from(toFunctionSelector('swap_public(address,uint256,uint24,address,uint256,bytes32,bytes32,address)').substring(2), 'hex'),
                 wethCrossChainHarness.tokenPortalAddress.toBuffer32(),
@@ -602,42 +654,57 @@ export const uniswapL1L2TestSuite = (setup, cleanup, expectedForkBlockNumber = 1
                 secretHashForDepositingSwappedDai,
                 ownerEthAddress.toBuffer32()
             ]);
-            const swapPublicLeaf = sha256ToField([
-                uniswapL2Contract.address,
-                new Fr(1),
-                EthAddress.fromString(uniswapPortal.address).toBuffer32(),
-                new Fr(publicClient.chain.id),
-                swapPublicContent
-            ]);
+            const swapPublicLeaf = computeL2ToL1MessageHash({
+                l2Sender: uniswapL2Contract.address,
+                l1Recipient: EthAddress.fromString(uniswapPortal.address),
+                content: swapPublicContent,
+                rollupVersion: new Fr(version),
+                chainId: new Fr(l1Client.chain.id)
+            });
             const withdrawContent = sha256ToField([
                 Buffer.from(toFunctionSelector('withdraw(address,uint256,address)').substring(2), 'hex'),
                 uniswapPortalAddress.toBuffer32(),
                 new Fr(wethAmountToBridge),
                 uniswapPortalAddress.toBuffer32()
             ]);
-            const withdrawLeaf = sha256ToField([
-                wethCrossChainHarness.l2Bridge.address,
-                new Fr(1),
-                wethCrossChainHarness.tokenPortalAddress.toBuffer32(),
-                new Fr(publicClient.chain.id),
-                withdrawContent
-            ]);
-            const [swapPublicL2MessageIndex, swapPublicSiblingPath] = await aztecNode.getL2ToL1MessageMembershipWitness(withdrawReceipt.blockNumber, swapPublicLeaf);
-            const [withdrawL2MessageIndex, withdrawSiblingPath] = await aztecNode.getL2ToL1MessageMembershipWitness(withdrawReceipt.blockNumber, withdrawLeaf);
+            const withdrawLeaf = computeL2ToL1MessageHash({
+                l2Sender: wethCrossChainHarness.l2Bridge.address,
+                l1Recipient: wethCrossChainHarness.tokenPortalAddress,
+                content: withdrawContent,
+                rollupVersion: new Fr(version),
+                chainId: new Fr(l1Client.chain.id)
+            });
+            // 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 epoch is proven, we need to advance to the next epoch
+            // before we can ask the witness helper for a covering root.
+            const minedReceipt = await aztecNode.getTxReceipt(withdrawReceipt.txHash);
+            if (minedReceipt.epochNumber === undefined) {
+                throw new Error('Withdraw tx is not yet in an epoch');
+            }
+            await cheatCodes.rollup.advanceToEpoch(EpochNumber(minedReceipt.epochNumber + 1));
+            await waitForProven(aztecNode, withdrawReceipt, {
+                provenTimeout: 300
+            });
+            const swapResult = await retryUntil(()=>aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, swapPublicLeaf), 'swap public l2 to l1 witness', 60, 1);
+            const { epochNumber: epoch, numCheckpointsInEpoch } = swapResult;
+            const withdrawResult = await retryUntil(()=>aztecNode.getL2ToL1MembershipWitness(minedReceipt.txHash, withdrawLeaf), 'withdraw l2 to l1 witness', 60, 1);
+            const swapPublicL2MessageIndex = swapResult.leafIndex;
+            const swapPublicSiblingPath = swapResult.siblingPath;
+            const withdrawL2MessageIndex = withdrawResult.leafIndex;
+            const withdrawSiblingPath = withdrawResult.siblingPath;
             const withdrawMessageMetadata = {
-                _l2BlockNumber: BigInt(withdrawReceipt.blockNumber),
+                _epoch: BigInt(epoch),
+                _numCheckpointsInEpoch: BigInt(withdrawResult.numCheckpointsInEpoch),
                 _leafIndex: BigInt(withdrawL2MessageIndex),
                 _path: withdrawSiblingPath.toBufferArray().map((buf)=>`0x${buf.toString('hex')}`)
             };
             const swapPublicMessageMetadata = {
-                _l2BlockNumber: BigInt(withdrawReceipt.blockNumber),
+                _epoch: BigInt(epoch),
+                _numCheckpointsInEpoch: BigInt(numCheckpointsInEpoch),
                 _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.read.getPendingBlockNumber());
             // Call swap_private on L1
             logger.info('Execute withdraw and swap on the uniswapPortal!');
             const swapArgs = [

package/dest/shared/wait_for_l1_to_l2_message.d.ts

@@ -0,0 +1,13 @@
+import type { Fr } from '@aztec/aztec.js/fields';
+import type { AztecNode } from '@aztec/aztec.js/node';
+/**
+ * Waits until the archiver has seen the L1 to L2 message and indexed it. Unlike
+ * {@link waitForL1ToL2MessageReady} from `@aztec/aztec.js/messaging`, this does not
+ * require the L2 chain to have advanced to the message's checkpoint — it only confirms
+ * the message has been picked up from L1. Use this in tests that explicitly produce L2
+ * blocks afterwards to make the message consumable.
+ */
+export declare function waitForL1ToL2MessageSeen(node: Pick<AztecNode, 'getL1ToL2MessageCheckpoint'>, l1ToL2MessageHash: Fr, opts: {
+    timeoutSeconds: number;
+}): Promise<boolean>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2FpdF9mb3JfbDFfdG9fbDJfbWVzc2FnZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NoYXJlZC93YWl0X2Zvcl9sMV90b19sMl9tZXNzYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ2pELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBR3REOzs7Ozs7R0FNRztBQUNILHdCQUFnQix3QkFBd0IsQ0FDdEMsSUFBSSxFQUFFLElBQUksQ0FBQyxTQUFTLEVBQUUsNEJBQTRCLENBQUMsRUFDbkQsaUJBQWlCLEVBQUUsRUFBRSxFQUNyQixJQUFJLEVBQUU7SUFBRSxjQUFjLEVBQUUsTUFBTSxDQUFBO0NBQUUsb0JBUWpDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"wait_for_l1_to_l2_message.d.ts","sourceRoot":"","sources":["../../src/shared/wait_for_l1_to_l2_message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGtD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,4BAA4B,CAAC,EACnD,iBAAiB,EAAE,EAAE,EACrB,IAAI,EAAE;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,oBAQjC"}

package/dest/shared/wait_for_l1_to_l2_message.js

@@ -0,0 +1,10 @@
+import { retryUntil } from '@aztec/foundation/retry';
+/**
+ * Waits until the archiver has seen the L1 to L2 message and indexed it. Unlike
+ * {@link waitForL1ToL2MessageReady} from `@aztec/aztec.js/messaging`, this does not
+ * require the L2 chain to have advanced to the message's checkpoint — it only confirms
+ * the message has been picked up from L1. Use this in tests that explicitly produce L2
+ * blocks afterwards to make the message consumable.
+ */ export function waitForL1ToL2MessageSeen(node, l1ToL2MessageHash, opts) {
+    return retryUntil(async ()=>await node.getL1ToL2MessageCheckpoint(l1ToL2MessageHash) !== undefined, `L1 to L2 message ${l1ToL2MessageHash.toString()} seen`, opts.timeoutSeconds, 1);
+}