@aztec/end-to-end 0.0.1-commit.b655e406 → 0.0.1-commit.c7c42ec

package/src/simulators/lending_simulator.ts

@@ -2,8 +2,9 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import { Fr } from '@aztec/aztec.js/fields';
 import { CheatCodes } from '@aztec/aztec/testing';
-import type { RollupContract } from '@aztec/ethereum';
-import { pedersenHash } from '@aztec/foundation/crypto';
+import type { RollupContract } from '@aztec/ethereum/contracts';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { pedersenHash } from '@aztec/foundation/crypto/pedersen';
 import type { TestDateProvider } from '@aztec/foundation/timer';
 import type { LendingContract } from '@aztec/noir-contracts.js/Lending';
 
@@ -103,7 +104,8 @@ export class LendingSimulator {
     }
 
     const slot = await this.rollup.getSlotAt(BigInt(await this.cc.eth.timestamp()));
-    const ts = Number(await this.rollup.getTimestampForSlot(slot + BigInt(diff)));
+    const targetSlot = SlotNumber(slot + diff);
+    const ts = Number(await this.rollup.getTimestampForSlot(targetSlot));
     const timeDiff = ts - this.time;
     this.time = ts;
 
@@ -112,7 +114,7 @@ export class LendingSimulator {
     if (dateProvider) {
       dateProvider.setTime(this.time * 1000);
     }
-    await this.cc.rollup.markAsProven(await this.rollup.getBlockNumber());
+    await this.cc.rollup.markAsProven(await this.rollup.getCheckpointNumber());
     this.accumulator = muldivDown(this.accumulator, computeMultiplier(this.rate, BigInt(timeDiff)), BASE);
   }
 

package/src/spartan/DEVELOP.md

@@ -61,10 +61,17 @@ The export is important there. The `AZTEC_DOCKER_IMAGE` env var is used as both:
 - the containers for the aztec infrastructure (validators, provers, etc)
 
 # Deploy Metrics
+
 ```bash
 ./spartan/bootstrap.sh metrics-kind
 ```
 
+# Install Chaos Mesh
+
+```bash
+./spartan/bootstrap.sh chaos-mesh
+```
+
 # Deploy stuff
 
 ```bash

package/src/spartan/setup_test_wallets.ts

@@ -6,12 +6,13 @@ import { type FeePaymentMethod, SponsoredFeePaymentMethod } from '@aztec/aztec.j
 import { Fr } from '@aztec/aztec.js/fields';
 import { type AztecNode, createAztecNodeClient } from '@aztec/aztec.js/node';
 import type { Wallet } from '@aztec/aztec.js/wallet';
-import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
 import type { Logger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
-import { TestWallet, proveInteraction, registerInitialSandboxAccountsInWallet } from '@aztec/test-wallet/server';
+import { TestWallet, proveInteraction, registerInitialLocalNetworkAccountsInWallet } from '@aztec/test-wallet/server';
 
 import { getACVMConfig } from '../fixtures/get_acvm_config.js';
 import { getBBConfig } from '../fixtures/get_bb_config.js';
@@ -28,6 +29,11 @@ export interface TestAccounts {
   tokenAddress: AztecAddress;
 }
 
+export type TestAccountsWithoutTokens = Omit<
+  TestAccounts,
+  'tokenAddress' | 'tokenContract' | 'tokenName' | 'tokenAdminAddress'
+>;
+
 const TOKEN_NAME = 'USDC';
 const TOKEN_SYMBOL = 'USD';
 const TOKEN_DECIMALS = 18n;
@@ -42,14 +48,14 @@ export async function setupTestAccountsWithTokens(
   const aztecNode = createAztecNodeClient(nodeUrl);
   const wallet = await TestWallet.create(aztecNode);
 
-  const [recipientAccount, ...accounts] = (await registerInitialSandboxAccountsInWallet(wallet)).slice(
+  const [recipientAccount, ...accounts] = (await registerInitialLocalNetworkAccountsInWallet(wallet)).slice(
     0,
     ACCOUNT_COUNT + 1,
   );
 
   const tokenAdmin = accounts[0];
   const tokenAddress = await deployTokenAndMint(wallet, accounts, tokenAdmin, mintAmount, undefined, logger);
-  const tokenContract = await TokenContract.at(tokenAddress, wallet);
+  const tokenContract = TokenContract.at(tokenAddress, wallet);
 
   return {
     aztecNode,
@@ -63,7 +69,7 @@ export async function setupTestAccountsWithTokens(
   };
 }
 
-export async function deploySponsoredTestAccounts(
+export async function deploySponsoredTestAccountsWithTokens(
   wallet: TestWallet,
   aztecNode: AztecNode,
   mintAmount: bigint,
@@ -96,7 +102,7 @@ export async function deploySponsoredTestAccounts(
     new SponsoredFeePaymentMethod(await getSponsoredFPCAddress()),
     logger,
   );
-  const tokenContract = await TokenContract.at(tokenAddress, wallet);
+  const tokenContract = TokenContract.at(tokenAddress, wallet);
 
   return {
     aztecNode,
@@ -110,6 +116,37 @@ export async function deploySponsoredTestAccounts(
   };
 }
 
+export async function deploySponsoredTestAccounts(
+  wallet: TestWallet,
+  aztecNode: AztecNode,
+  logger: Logger,
+  numberOfFundedWallets = 1,
+): Promise<TestAccountsWithoutTokens> {
+  const [recipient, ...funded] = await generateSchnorrAccounts(numberOfFundedWallets + 1);
+  const recipientAccount = await wallet.createSchnorrAccount(recipient.secret, recipient.salt);
+  const fundedAccounts = await Promise.all(funded.map(a => wallet.createSchnorrAccount(a.secret, a.salt)));
+
+  await registerSponsoredFPC(wallet);
+
+  const paymentMethod = new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
+  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,
+    wallet,
+    accounts: fundedAccounts.map(acc => acc.address),
+    recipientAddress: recipientAccount.address,
+  };
+}
+
 export async function deployTestAccountsWithTokens(
   nodeUrl: string,
   l1RpcUrls: string[],
@@ -152,7 +189,7 @@ export async function deployTestAccountsWithTokens(
     undefined,
     logger,
   );
-  const tokenContract = await TokenContract.at(tokenAddress, wallet);
+  const tokenContract = TokenContract.at(tokenAddress, wallet);
 
   return {
     aztecNode,
@@ -228,9 +265,9 @@ async function deployTokenAndMint(
   logger.verbose(`Minting ${mintAmount} public assets to the ${accounts.length} accounts...`);
 
   await Promise.all(
-    accounts.map(async acc =>
-      (await TokenContract.at(tokenAddress, wallet)).methods
-        .mint_to_public(acc, mintAmount)
+    accounts.map(acc =>
+      TokenContract.at(tokenAddress, wallet)
+        .methods.mint_to_public(acc, mintAmount)
         .send({ from: admin, fee: { paymentMethod } })
         .wait({ timeout: 600 }),
     ),
@@ -260,8 +297,8 @@ export async function performTransfers({
   // Default to sponsored fee payment if no fee method is provided
   const defaultFeePaymentMethod = feePaymentMethod || new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
   for (let i = 0; i < rounds; i++) {
-    const txs = testAccounts.accounts.map(async acc => {
-      const token = await TokenContract.at(testAccounts.tokenAddress, testAccounts.wallet);
+    const txs = testAccounts.accounts.map(acc => {
+      const token = TokenContract.at(testAccounts.tokenAddress, testAccounts.wallet);
       return proveInteraction(wallet, token.methods.transfer_in_public(acc, recipient, transferAmount, 0), {
         from: acc,
         fee: {

package/src/spartan/tx_metrics.ts

@@ -0,0 +1,130 @@
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { L2Block } from '@aztec/stdlib/block';
+import { Tx, type TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+
+import { createHistogram } from 'perf_hooks';
+
+export type TxInclusionData = {
+  txHash: string;
+  sentAt: number;
+  minedAt: number;
+  attestedAt: number;
+  blocknumber: number;
+  priorityFee: number;
+  totalFee: number;
+  positionInBlock: number;
+  group: string;
+};
+
+export class TxInclusionMetrics {
+  private data = new Map<string, TxInclusionData>();
+  private groups = new Set<string>();
+  private blocks = new Map<number, Promise<L2Block>>();
+
+  constructor(private aztecNode: AztecNode) {}
+
+  recordSentTx(tx: Tx, group: string): void {
+    const txHash = tx.getTxHash().toString();
+    const priorityFees = tx.getGasSettings().maxPriorityFeesPerGas;
+
+    this.data.set(txHash, {
+      txHash,
+      sentAt: Math.trunc(Date.now() / 1000),
+      minedAt: -1,
+      attestedAt: -1,
+      blocknumber: -1,
+      priorityFee: Number(priorityFees.feePerDaGas + priorityFees.feePerL2Gas),
+      totalFee: -1,
+      positionInBlock: -1,
+      group,
+    });
+    this.groups.add(group);
+  }
+
+  async recordMinedTx(txReceipt: TxReceipt): Promise<void> {
+    const { status, txHash, blockNumber } = txReceipt;
+    if (status !== TxStatus.SUCCESS || !blockNumber) {
+      return;
+    }
+
+    if (!this.blocks.has(blockNumber)) {
+      this.blocks.set(blockNumber, this.aztecNode.getBlock(blockNumber) as Promise<L2Block>);
+    }
+
+    const block = await this.blocks.get(blockNumber)!;
+    const data = this.data.get(txHash.toString())!;
+    data.blocknumber = blockNumber;
+    data.minedAt = Number(block.header.globalVariables.timestamp);
+    data.attestedAt = -1;
+    data.totalFee = Number(txReceipt.transactionFee ?? 0n);
+    data.positionInBlock = block.body.txEffects.findIndex(txEffect => txEffect.txHash.equals(txHash));
+  }
+
+  public inclusionTimeInSeconds(group: string): {
+    count: number;
+    group: string;
+    min: number;
+    mean: number;
+    max: number;
+    median: number;
+    p99: number;
+  } {
+    const histogram = createHistogram({});
+    for (const tx of this.data.values()) {
+      if (!tx.blocknumber || tx.group !== group) {
+        continue;
+      }
+
+      histogram.record(tx.minedAt - tx.sentAt);
+    }
+
+    if (histogram.count === 0) {
+      return {
+        group,
+        count: 0,
+        mean: 0,
+        max: 0,
+        median: 0,
+        min: 0,
+        p99: 0,
+      };
+    }
+
+    return {
+      group,
+      count: histogram.count,
+      mean: histogram.mean,
+      max: histogram.max,
+      median: histogram.percentile(50),
+      min: histogram.min,
+      p99: histogram.percentile(99),
+    };
+  }
+
+  toGithubActionBenchmarkJSON(): Array<{ name: string; unit: string; value: number; range?: number; extra?: string }> {
+    const data: Array<{ name: string; unit: string; value: number; range?: number; extra?: string }> = [];
+    for (const group of this.groups) {
+      const stats = this.inclusionTimeInSeconds(group);
+
+      data.push(
+        {
+          name: `${group}/avg_inclusion`,
+          unit: 's',
+          value: stats.mean,
+        },
+        {
+          name: `${group}/median_inclusion`,
+          unit: 's',
+          value: stats.median,
+        },
+        {
+          name: `${group}/p99_inclusion`,
+          unit: 's',
+          value: stats.p99,
+        },
+      );
+    }
+
+    return data;
+  }
+}