@aztec/end-to-end 0.0.1-commit.d1f2d6c → 0.0.1-commit.d431d1c

package/src/fixtures/setup.ts

@@ -629,7 +629,7 @@ export async function setup(
         `${numberOfAccounts} accounts are being deployed. Reliably progressing past genesis by setting minTxsPerBlock to 1 and waiting for the accounts to be deployed`,
       );
       const accountsData = initialFundedAccounts.slice(0, numberOfAccounts);
-      const accountManagers = await deployFundedSchnorrAccounts(wallet, accountsData);
+      const accountManagers = await deployFundedSchnorrAccounts(wallet, aztecNodeService, accountsData);
       accounts = accountManagers.map(accountManager => accountManager.address);
     } else if (needsEmptyBlock) {
       logger.info('No accounts are being deployed, waiting for an empty block 1 to be mined');
@@ -921,11 +921,13 @@ export async function ensureAccountContractsPublished(wallet: Wallet, accountsTo
   ).map(contractMetadata => contractMetadata.instance);
   const contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
   if (!(await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
-    await (await publishContractClass(wallet, SchnorrAccountContractArtifact)).send({ from: accountsToDeploy[0] });
+    await (await publishContractClass(wallet, SchnorrAccountContractArtifact))
+      .send({ from: accountsToDeploy[0] })
+      .wait();
   }
   const requests = instances.map(instance => publishInstance(wallet, instance!));
   const batch = new BatchCall(wallet, requests);
-  await batch.send({ from: accountsToDeploy[0] });
+  await batch.send({ from: accountsToDeploy[0] }).wait();
 }
 
 /**
@@ -949,10 +951,12 @@ export const deployAccounts =
         deployedAccounts[i].signingKey,
       );
       const deployMethod = await accountManager.getDeployMethod();
-      await deployMethod.send({
-        from: AztecAddress.ZERO,
-        skipClassPublication: i !== 0, // Publish the contract class at most once.
-      });
+      await deployMethod
+        .send({
+          from: AztecAddress.ZERO,
+          skipClassPublication: i !== 0, // Publish the contract class at most once.
+        })
+        .wait();
     }
 
     return { deployedAccounts };
@@ -982,7 +986,7 @@ export async function publicDeployAccounts(
 
   const batch = new BatchCall(wallet, calls);
 
-  const txReceipt = await batch.send({ from: accountsToDeploy[0] });
+  const txReceipt = await batch.send({ from: accountsToDeploy[0] }).wait();
   if (waitUntilProven) {
     if (!node) {
       throw new Error('Need to provide an AztecNode to wait for proven.');

package/src/fixtures/token_utils.ts

@@ -6,10 +6,9 @@ import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger) {
   logger.info(`Deploying Token contract...`);
-  const { contract, instance } = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
-    from: admin,
-    wait: { returnReceipt: true },
-  });
+  const { contract, instance } = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18)
+    .send({ from: admin })
+    .wait();
 
   if (initialAdminBalance > 0n) {
     await mintTokensToPrivate(contract, admin, admin, initialAdminBalance);
@@ -26,7 +25,7 @@ export async function mintTokensToPrivate(
   recipient: AztecAddress,
   amount: bigint,
 ) {
-  await token.methods.mint_to_private(recipient, amount).send({ from: minter });
+  await token.methods.mint_to_private(recipient, amount).send({ from: minter }).wait();
 }
 
 export async function expectTokenBalance(
@@ -56,7 +55,7 @@ export async function mintNotes(
   for (let mintedNotes = 0; mintedNotes < noteAmounts.length; mintedNotes += notesPerIteration) {
     const toMint = noteAmounts.slice(mintedNotes, mintedNotes + notesPerIteration);
     const actions = toMint.map(amt => asset.methods.mint_to_private(recipient, amt));
-    await new BatchCall(wallet, actions).send({ from: minter });
+    await new BatchCall(wallet, actions).send({ from: minter }).wait();
   }
 
   return noteAmounts.reduce((prev, curr) => prev + curr, 0n);

package/src/shared/cross_chain_test_harness.ts

@@ -18,6 +18,7 @@ import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses'
 import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { EpochNumber } from '@aztec/foundation/branded-types';
 import { retryUntil } from '@aztec/foundation/retry';
+import type { FieldsOf } from '@aztec/foundation/types';
 import { TestERC20Abi, TokenPortalAbi, TokenPortalBytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
@@ -73,10 +74,14 @@ export async function deployAndInitializeTokenAndBridgeContracts(
   });
 
   // deploy l2 token
-  const token = await TokenContract.deploy(wallet, owner, 'TokenName', 'TokenSymbol', 18).send({ from: owner });
+  const token = await TokenContract.deploy(wallet, owner, 'TokenName', 'TokenSymbol', 18)
+    .send({ from: owner })
+    .deployed();
 
   // deploy l2 token bridge and attach to the portal
-  const bridge = await TokenBridgeContract.deploy(wallet, token.address, tokenPortalAddress).send({ from: owner });
+  const bridge = await TokenBridgeContract.deploy(wallet, token.address, tokenPortalAddress)
+    .send({ from: owner })
+    .deployed();
 
   if ((await token.methods.get_admin().simulate({ from: owner })) !== owner.toBigInt()) {
     throw new Error(`Token admin is not ${owner}`);
@@ -87,7 +92,7 @@ export async function deployAndInitializeTokenAndBridgeContracts(
   }
 
   // make the bridge a minter on the token:
-  await token.methods.set_minter(bridge.address, true).send({ from: owner });
+  await token.methods.set_minter(bridge.address, true).send({ from: owner }).wait();
   if ((await token.methods.is_minter(bridge.address).simulate({ from: owner })) === 1n) {
     throw new Error(`Bridge is not a minter`);
   }
@@ -230,7 +235,7 @@ export class CrossChainTestHarness {
 
   async mintTokensPublicOnL2(amount: bigint) {
     this.logger.info('Minting tokens on L2 publicly');
-    await this.l2Token.methods.mint_to_public(this.ownerAddress, amount).send({ from: this.ownerAddress });
+    await this.l2Token.methods.mint_to_public(this.ownerAddress, amount).send({ from: this.ownerAddress }).wait();
   }
 
   async mintTokensPrivateOnL2(amount: bigint) {
@@ -241,7 +246,8 @@ export class CrossChainTestHarness {
     // send a transfer tx to force through rollup with the message included
     await this.l2Token.methods
       .transfer_in_public(this.ownerAddress, receiverAddress, transferAmount, 0)
-      .send({ from: this.ownerAddress });
+      .send({ from: this.ownerAddress })
+      .wait();
   }
 
   async consumeMessageOnAztecAndMintPrivately(
@@ -251,7 +257,8 @@ export class CrossChainTestHarness {
     const { recipient, claimAmount, claimSecret: secretForL2MessageConsumption, messageLeafIndex } = claim;
     await this.l2Bridge.methods
       .claim_private(recipient, claimAmount, secretForL2MessageConsumption, messageLeafIndex)
-      .send({ from: this.ownerAddress });
+      .send({ from: this.ownerAddress })
+      .wait();
   }
 
   async consumeMessageOnAztecAndMintPublicly(
@@ -261,25 +268,28 @@ export class CrossChainTestHarness {
     const { claimAmount, claimSecret, messageLeafIndex } = claim;
     await this.l2Bridge.methods
       .claim_public(this.ownerAddress, claimAmount, claimSecret, messageLeafIndex)
-      .send({ from: this.ownerAddress });
+      .send({ from: this.ownerAddress })
+      .wait();
   }
 
   async withdrawPrivateFromAztecToL1(
     withdrawAmount: bigint,
     authwitNonce: Fr = Fr.ZERO,
     authWitness: AuthWitness,
-  ): Promise<TxReceipt> {
+  ): Promise<FieldsOf<TxReceipt>> {
     const withdrawReceipt = await this.l2Bridge.methods
       .exit_to_l1_private(this.l2Token.address, this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
-      .send({ authWitnesses: [authWitness], from: this.ownerAddress });
+      .send({ authWitnesses: [authWitness], from: this.ownerAddress })
+      .wait();
 
     return withdrawReceipt;
   }
 
-  async withdrawPublicFromAztecToL1(withdrawAmount: bigint, authwitNonce: Fr = Fr.ZERO): Promise<TxReceipt> {
+  async withdrawPublicFromAztecToL1(withdrawAmount: bigint, authwitNonce: Fr = Fr.ZERO): Promise<FieldsOf<TxReceipt>> {
     const withdrawReceipt = await this.l2Bridge.methods
       .exit_to_l1_public(this.ethAccount, withdrawAmount, EthAddress.ZERO, authwitNonce)
-      .send({ from: this.ownerAddress });
+      .send({ from: this.ownerAddress })
+      .wait();
 
     return withdrawReceipt;
   }
@@ -323,14 +333,18 @@ export class CrossChainTestHarness {
 
   async transferToPrivateOnL2(shieldAmount: bigint) {
     this.logger.info('Transferring to private on L2');
-    await this.l2Token.methods.transfer_to_private(this.ownerAddress, shieldAmount).send({ from: this.ownerAddress });
+    await this.l2Token.methods
+      .transfer_to_private(this.ownerAddress, shieldAmount)
+      .send({ from: this.ownerAddress })
+      .wait();
   }
 
   async transferToPublicOnL2(amount: bigint, authwitNonce = Fr.ZERO) {
     this.logger.info('Transferring tokens to public');
     await this.l2Token.methods
       .transfer_to_public(this.ownerAddress, this.ownerAddress, amount, authwitNonce)
-      .send({ from: this.ownerAddress });
+      .send({ from: this.ownerAddress })
+      .wait();
   }
 
   /**

package/src/shared/gas_portal_test_harness.ts

@@ -127,7 +127,7 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
   async consumeMessageOnAztecAndClaimPrivately(owner: AztecAddress, claimer: AztecAddress, claim: L2AmountClaim) {
     this.logger.info('Consuming messages on L2 Privately');
     const { claimAmount, claimSecret, messageLeafIndex } = claim;
-    await this.feeJuice.methods.claim(owner, claimAmount, claimSecret, messageLeafIndex).send({ from: claimer });
+    await this.feeJuice.methods.claim(owner, claimAmount, claimSecret, messageLeafIndex).send({ from: claimer }).wait();
   }
 
   async getL2PublicBalanceOf(owner: AztecAddress) {

package/src/shared/submit-transactions.ts

@@ -1,8 +1,8 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { NO_WAIT } from '@aztec/aztec.js/contracts';
+import type { SentTx } from '@aztec/aztec.js/contracts';
 import { Fr, GrumpkinScalar } from '@aztec/aztec.js/fields';
 import type { Logger } from '@aztec/aztec.js/log';
-import { TxHash, type TxReceipt, TxStatus } from '@aztec/aztec.js/tx';
+import { TxStatus } from '@aztec/aztec.js/tx';
 import { times } from '@aztec/foundation/collection';
 import type { TestWallet } from '@aztec/test-wallet/server';
 
@@ -12,20 +12,26 @@ export const submitTxsTo = async (
   submitter: AztecAddress,
   numTxs: number,
   logger: Logger,
-): Promise<TxHash[]> => {
-  const txHashes: TxHash[] = [];
+): Promise<SentTx[]> => {
+  const txs: SentTx[] = [];
   await Promise.all(
     times(numTxs, async () => {
       const accountManager = await wallet.createSchnorrAccount(Fr.random(), Fr.random(), GrumpkinScalar.random());
       const deployMethod = await accountManager.getDeployMethod();
-      const txHash = await deployMethod.send({ from: submitter, wait: NO_WAIT });
+      const tx = deployMethod.send({ from: submitter });
+      const txHash = await tx.getTxHash();
 
       logger.info(`Tx sent with hash ${txHash}`);
-      const receipt: TxReceipt = await wallet.getTxReceipt(txHash);
-      expect(receipt.status).toBe(TxStatus.PENDING);
+      const receipt = await tx.getReceipt();
+      expect(receipt).toEqual(
+        expect.objectContaining({
+          status: TxStatus.PENDING,
+          error: '',
+        }),
+      );
       logger.info(`Receipt received for ${txHash}`);
-      txHashes.push(txHash);
+      txs.push(tx);
     }),
   );
-  return txHashes;
+  return txs;
 };

package/src/shared/uniswap_l1_l2.ts

@@ -130,7 +130,9 @@ export const uniswapL1L2TestSuite = (
         client: l1Client,
       });
       // deploy l2 uniswap contract and attach to portal
-      uniswapL2Contract = await UniswapContract.deploy(wallet, uniswapPortalAddress).send({ from: ownerAddress });
+      uniswapL2Contract = await UniswapContract.deploy(wallet, uniswapPortalAddress)
+        .send({ from: ownerAddress })
+        .deployed();
 
       const registryAddress = (await aztecNode.getNodeInfo()).l1ContractAddresses.registryAddress;
 
@@ -207,7 +209,8 @@ export const uniswapL1L2TestSuite = (
           secretHashForDepositingSwappedDai,
           ownerEthAddress,
         )
-        .send({ from: ownerAddress, authWitnesses: [transferToPublicAuhtwit] });
+        .send({ from: ownerAddress, authWitnesses: [transferToPublicAuhtwit] })
+        .wait();
 
       const swapPrivateFunction = 'swap_private(address,uint256,uint24,address,uint256,bytes32,address)';
       const swapPrivateContent = sha256ToField([
@@ -425,10 +428,10 @@ export const uniswapL1L2TestSuite = (
     //       ownerEthAddress,
     //       nonceForSwap,
     //     );
-    //   await ownerWallet.setPublicAuthWit({ caller: sponsorAddress, action }, true).send();
+    //   await ownerWallet.setPublicAuthWit({ caller: sponsorAddress, action }, true).send().wait();
 
     //   // 4.2 Call swap_public from user2 on behalf of owner
-    //   const uniswapL2Interaction = await action.send();
+    //   const uniswapL2Interaction = await action.send().wait();
 
     //   const swapPublicContent = sha256ToField([
     //     Buffer.from(
@@ -646,7 +649,8 @@ export const uniswapL1L2TestSuite = (
             Fr.random(),
             ownerEthAddress,
           )
-          .send({ from: ownerAddress, authWitnesses: [transferToPublicAuthwith] }),
+          .send({ from: ownerAddress, authWitnesses: [transferToPublicAuthwith] })
+          .wait(),
       ).rejects.toThrow('Assertion failed: input_asset address is not the same as seen in the bridge contract');
     });
 
@@ -671,7 +675,7 @@ export const uniswapL1L2TestSuite = (
         },
         true,
       );
-      await validateActionInteraction.send();
+      await validateActionInteraction.send().wait();
 
       // No approval to call `swap` but should work even without it:
       const [_, secretHashForDepositingSwappedDai] = await generateClaimSecret();
@@ -690,7 +694,8 @@ export const uniswapL1L2TestSuite = (
           ownerEthAddress,
           Fr.ZERO, // nonce for swap -> doesn't matter
         )
-        .send({ from: ownerAddress });
+        .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);
     });
@@ -720,7 +725,7 @@ export const uniswapL1L2TestSuite = (
         { caller: approvedUser, action },
         true,
       );
-      await validateActionInteraction.send();
+      await validateActionInteraction.send().wait();
 
       await expect(action.simulate({ from: sponsorAddress })).rejects.toThrow(/unauthorized/);
     });
@@ -742,7 +747,7 @@ export const uniswapL1L2TestSuite = (
         },
         true,
       );
-      await validateActionInteraction.send();
+      await validateActionInteraction.send().wait();
 
       await expect(
         uniswapL2Contract.methods
@@ -799,7 +804,8 @@ export const uniswapL1L2TestSuite = (
           secretHashForDepositingSwappedDai,
           ownerEthAddress,
         )
-        .send({ from: ownerAddress, authWitnesses: [transferToPublicAuhtwit] });
+        .send({ from: ownerAddress, authWitnesses: [transferToPublicAuhtwit] })
+        .wait();
 
       const swapPrivateContent = sha256ToField([
         Buffer.from(
@@ -912,7 +918,7 @@ export const uniswapL1L2TestSuite = (
         },
         true,
       );
-      await validateActionInteraction.send();
+      await validateActionInteraction.send().wait();
 
       // Call swap_public on L2
       const secretHashForDepositingSwappedDai = Fr.random();
@@ -930,7 +936,8 @@ export const uniswapL1L2TestSuite = (
           ownerEthAddress,
           Fr.ZERO,
         )
-        .send({ from: ownerAddress });
+        .send({ from: ownerAddress })
+        .wait();
 
       const swapPublicContent = sha256ToField([
         Buffer.from(

package/src/simulators/lending_simulator.ts

@@ -4,7 +4,7 @@ import { Fr } from '@aztec/aztec.js/fields';
 import { CheatCodes } from '@aztec/aztec/testing';
 import type { RollupContract } from '@aztec/ethereum/contracts';
 import { SlotNumber } from '@aztec/foundation/branded-types';
-import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { pedersenHash } from '@aztec/foundation/crypto/pedersen';
 import type { TestDateProvider } from '@aztec/foundation/timer';
 import type { LendingContract } from '@aztec/noir-contracts.js/Lending';
 
@@ -29,7 +29,7 @@ export class LendingAccount {
    * @returns Key in public space
    */
   public key() {
-    return poseidon2Hash([this.address, this.secret]);
+    return pedersenHash([this.address, this.secret]);
   }
 }
 

package/src/spartan/setup_test_wallets.ts

@@ -1,11 +1,10 @@
 import { generateSchnorrAccounts } from '@aztec/accounts/testing';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { NO_WAIT } from '@aztec/aztec.js/contracts';
 import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
 import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
 import { type FeePaymentMethod, SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee';
 import { Fr } from '@aztec/aztec.js/fields';
-import { type AztecNode, createAztecNodeClient, waitForTx } from '@aztec/aztec.js/node';
+import { type AztecNode, createAztecNodeClient } from '@aztec/aztec.js/node';
 import type { Wallet } from '@aztec/aztec.js/wallet';
 import { createEthereumChain } from '@aztec/ethereum/chain';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
@@ -85,11 +84,11 @@ export async function deploySponsoredTestAccountsWithTokens(
 
   const paymentMethod = new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
   const recipientDeployMethod = await recipientAccount.getDeployMethod();
-  await recipientDeployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod }, wait: { timeout: 2400 } });
+  await recipientDeployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod } }).wait({ timeout: 2400 });
   await Promise.all(
     fundedAccounts.map(async a => {
       const deployMethod = await a.getDeployMethod();
-      await deployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod }, wait: { timeout: 2400 } }); // increase timeout on purpose in order to account for two empty epochs
+      await deployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod } }).wait({ timeout: 2400 }); // increase timeout on purpose in order to account for two empty epochs
       logger.info(`Account deployed at ${a.address}`);
     }),
   );
@@ -117,55 +116,6 @@ export async function deploySponsoredTestAccountsWithTokens(
   };
 }
 
-async function deployAccountWithDiagnostics(
-  account: { getDeployMethod: () => Promise<{ send: (opts: any) => any }>; address: any },
-  paymentMethod: SponsoredFeePaymentMethod,
-  aztecNode: AztecNode,
-  logger: Logger,
-  accountLabel: string,
-): Promise<void> {
-  const deployMethod = await account.getDeployMethod();
-  let txHash;
-  try {
-    txHash = await deployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod }, wait: NO_WAIT });
-    await waitForTx(aztecNode, txHash, { timeout: 2400 });
-    logger.info(`${accountLabel} deployed at ${account.address}`);
-  } catch (error) {
-    const blockNumber = await aztecNode.getBlockNumber();
-    let receipt;
-    try {
-      receipt = await aztecNode.getTxReceipt(txHash);
-    } catch {
-      receipt = 'unavailable';
-    }
-    logger.error(`${accountLabel} deployment failed`, {
-      txHash: txHash.toString(),
-      receipt: JSON.stringify(receipt),
-      currentBlockNumber: blockNumber,
-      error: String(error),
-    });
-    throw error;
-  }
-}
-
-async function deployAccountsInBatches(
-  accounts: { getDeployMethod: () => Promise<{ send: (opts: any) => any }>; address: any }[],
-  paymentMethod: SponsoredFeePaymentMethod,
-  aztecNode: AztecNode,
-  logger: Logger,
-  labelPrefix: string,
-  batchSize = 2,
-): Promise<void> {
-  for (let i = 0; i < accounts.length; i += batchSize) {
-    const batch = accounts.slice(i, i + batchSize);
-    await Promise.all(
-      batch.map((account, idx) =>
-        deployAccountWithDiagnostics(account, paymentMethod, aztecNode, logger, `${labelPrefix}${i + idx + 1}`),
-      ),
-    );
-  }
-}
-
 export async function deploySponsoredTestAccounts(
   wallet: TestWallet,
   aztecNode: AztecNode,
@@ -179,9 +129,15 @@ export async function deploySponsoredTestAccounts(
   await registerSponsoredFPC(wallet);
 
   const paymentMethod = new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
-
-  await deployAccountWithDiagnostics(recipientAccount, paymentMethod, aztecNode, logger, 'Recipient account');
-  await deployAccountsInBatches(fundedAccounts, paymentMethod, aztecNode, logger, 'Funded account ', 2);
+  const recipientDeployMethod = await recipientAccount.getDeployMethod();
+  await recipientDeployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod } }).wait({ timeout: 2400 });
+  await Promise.all(
+    fundedAccounts.map(async a => {
+      const deployMethod = await a.getDeployMethod();
+      await deployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod } }).wait({ timeout: 2400 }); // increase timeout on purpose in order to account for two empty epochs
+      logger.info(`Account deployed at ${a.address}`);
+    }),
+  );
 
   return {
     aztecNode,
@@ -219,7 +175,7 @@ export async function deployTestAccountsWithTokens(
     fundedAccounts.map(async (a, i) => {
       const paymentMethod = new FeeJuicePaymentMethodWithClaim(a.address, claims[i]);
       const deployMethod = await a.getDeployMethod();
-      await deployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod } });
+      await deployMethod.send({ from: AztecAddress.ZERO, fee: { paymentMethod } }).wait();
       logger.info(`Account deployed at ${a.address}`);
     }),
   );
@@ -295,19 +251,14 @@ async function deployTokenAndMint(
   logger: Logger,
 ) {
   logger.verbose(`Deploying TokenContract...`);
-  const { contract: tokenContract } = await TokenContract.deploy(
-    wallet,
-    admin,
-    TOKEN_NAME,
-    TOKEN_SYMBOL,
-    TOKEN_DECIMALS,
-  ).send({
-    from: admin,
-    fee: {
-      paymentMethod,
-    },
-    wait: { timeout: 600, returnReceipt: true },
-  });
+  const tokenContract = await TokenContract.deploy(wallet, admin, TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS)
+    .send({
+      from: admin,
+      fee: {
+        paymentMethod,
+      },
+    })
+    .deployed({ timeout: 600 });
 
   const tokenAddress = tokenContract.address;
 
@@ -317,7 +268,8 @@ async function deployTokenAndMint(
     accounts.map(acc =>
       TokenContract.at(tokenAddress, wallet)
         .methods.mint_to_public(acc, mintAmount)
-        .send({ from: admin, fee: { paymentMethod }, wait: { timeout: 600 } }),
+        .send({ from: admin, fee: { paymentMethod } })
+        .wait({ timeout: 600 }),
     ),
   );
 
@@ -357,7 +309,7 @@ export async function performTransfers({
 
     const provenTxs = await Promise.all(txs);
 
-    await Promise.all(provenTxs.map(t => t.send({ wait: { timeout: 600 } })));
+    await Promise.all(provenTxs.map(t => t.send().wait({ timeout: 600 })));
 
     logger.info(`Completed round ${i + 1} / ${rounds}`);
   }

package/src/spartan/tx_metrics.ts

@@ -1,8 +1,7 @@
 import type { AztecNode } from '@aztec/aztec.js/node';
-import type { Logger } from '@aztec/foundation/log';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import type { TopicType } from '@aztec/stdlib/p2p';
-import { Tx, type TxReceipt } from '@aztec/stdlib/tx';
+import { Tx, type TxReceipt, TxStatus } from '@aztec/stdlib/tx';
 
 import { createHistogram } from 'perf_hooks';
 
@@ -21,7 +20,7 @@ export type TxInclusionData = {
 export class TxInclusionMetrics {
   private data = new Map<string, TxInclusionData>();
   private groups = new Set<string>();
-  private blocks = new Map<number, Promise<L2Block | undefined>>();
+  private blocks = new Map<number, Promise<L2BlockNew | undefined>>();
 
   private p2pGossipLatencyByTopic: Partial<Record<TopicType, { p50: number; p95: number }>> = {};
 
@@ -33,19 +32,12 @@ export class TxInclusionMetrics {
     | { txP50: number; txP95: number; attestationP50: number; attestationP95: number }
     | undefined;
 
-  constructor(
-    private aztecNode: AztecNode,
-    private logger?: Logger,
-  ) {}
+  constructor(private aztecNode: AztecNode) {}
 
   recordSentTx(tx: Tx, group: string): void {
     const txHash = tx.getTxHash().toString();
     const priorityFees = tx.getGasSettings().maxPriorityFeesPerGas;
 
-    if (this.data.has(txHash)) {
-      this.logger?.debug(`Overwriting tx inclusion data for ${txHash}`, { txHash, group });
-    }
-
     this.data.set(txHash, {
       txHash,
       sentAt: Math.trunc(Date.now() / 1000),
@@ -61,13 +53,8 @@ export class TxInclusionMetrics {
   }
 
   async recordMinedTx(txReceipt: TxReceipt): Promise<void> {
-    const { txHash, blockNumber } = txReceipt;
-    if (!txReceipt.isMined() || !txReceipt.hasExecutionSucceeded() || !blockNumber) {
-      this.logger?.debug('Skipping mined tx record due to receipt status', {
-        txHash: txHash.toString(),
-        status: txReceipt.status,
-        blockNumber,
-      });
+    const { status, txHash, blockNumber } = txReceipt;
+    if (status !== TxStatus.SUCCESS || !blockNumber) {
       return;
     }
 
@@ -77,15 +64,9 @@ export class TxInclusionMetrics {
 
     const block = await this.blocks.get(blockNumber)!;
     if (!block) {
-      this.logger?.warn('Failed to load block for mined tx receipt', { txHash: txHash.toString(), blockNumber });
       return;
     }
-    const data = this.data.get(txHash.toString());
-    if (!data) {
-      const message = `Missing sent tx record for mined tx ${txHash.toString()}`;
-      this.logger?.warn(message, { txHash: txHash.toString(), blockNumber });
-      throw new Error(message);
-    }
+    const data = this.data.get(txHash.toString())!;
     data.blocknumber = blockNumber;
     data.minedAt = Number(block.header.globalVariables.timestamp);
     data.attestedAt = -1;