@aztec/end-to-end 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/e2e_p2p/shared.ts

@@ -1,285 +0,0 @@
-import type { InitialAccountData } from '@aztec/accounts/testing';
-import type { AztecNodeService } from '@aztec/aztec-node';
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { type SentTx, getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
-import { Fr } from '@aztec/aztec.js/fields';
-import type { Logger } from '@aztec/aztec.js/log';
-import { Tx, TxStatus } from '@aztec/aztec.js/tx';
-import type { RollupCheatCodes } from '@aztec/aztec/testing';
-import type { EmpireSlashingProposerContract, RollupContract, TallySlashingProposerContract } from '@aztec/ethereum';
-import { EpochNumber } from '@aztec/foundation/branded-types';
-import { timesAsync, unique } from '@aztec/foundation/collection';
-import { retryUntil } from '@aztec/foundation/retry';
-import { pluralize } from '@aztec/foundation/string';
-import type { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
-import { TestContract, TestContractArtifact } from '@aztec/noir-test-contracts.js/Test';
-import { getPXEConfig, getPXEConfig as getRpcConfig } from '@aztec/pxe/server';
-import { getRoundForOffense } from '@aztec/slasher';
-import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
-import type { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
-import { TestWallet, proveInteraction } from '@aztec/test-wallet/server';
-
-import { submitTxsTo } from '../shared/submit-transactions.js';
-
-// submits a set of transactions to the provided Private eXecution Environment (PXE)
-export const submitComplexTxsTo = async (
-  logger: Logger,
-  from: AztecAddress,
-  spamContract: SpamContract,
-  numTxs: number,
-  opts: { callPublic?: boolean } = {},
-) => {
-  const txs: SentTx[] = [];
-
-  const seed = 1234n;
-  const spamCount = 15;
-  for (let i = 0; i < numTxs; i++) {
-    const tx = spamContract.methods.spam(seed + BigInt(i * spamCount), spamCount, !!opts.callPublic).send({ from });
-    const txHash = await tx.getTxHash();
-
-    logger.info(`Tx sent with hash ${txHash.toString()}`);
-    const receipt = await tx.getReceipt();
-    expect(receipt).toEqual(
-      expect.objectContaining({
-        status: TxStatus.PENDING,
-        error: '',
-      }),
-    );
-    logger.info(`Receipt received for ${txHash.toString()}`);
-    txs.push(tx);
-  }
-  return txs;
-};
-
-// creates a wallet and submit a given number of transactions through it.
-export const submitTransactions = async (
-  logger: Logger,
-  node: AztecNodeService,
-  numTxs: number,
-  fundedAccount: InitialAccountData,
-): Promise<SentTx[]> => {
-  const rpcConfig = getRpcConfig();
-  rpcConfig.proverEnabled = false;
-  const wallet = await TestWallet.create(node, { ...getPXEConfig(), proverEnabled: false }, { useLogSuffix: true });
-  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
-  return submitTxsTo(wallet, fundedAccountManager.address, numTxs, logger);
-};
-
-export async function prepareTransactions(
-  logger: Logger,
-  node: AztecNodeService,
-  numTxs: number,
-  fundedAccount: InitialAccountData,
-): Promise<Tx[]> {
-  const rpcConfig = getRpcConfig();
-  rpcConfig.proverEnabled = false;
-
-  const wallet = await TestWallet.create(node, { ...getPXEConfig(), proverEnabled: false }, { useLogSuffix: true });
-  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
-
-  const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {
-    salt: Fr.random(),
-  });
-  await wallet.registerContract(testContractInstance, TestContractArtifact);
-  const contract = TestContract.at(testContractInstance.address, wallet);
-
-  return timesAsync(numTxs, async () => {
-    const tx = await proveInteraction(wallet, contract.methods.emit_nullifier(Fr.random()), {
-      from: fundedAccountManager.address,
-    });
-    const txHash = tx.getTxHash();
-    logger.info(`Tx prepared with hash ${txHash}`);
-    return tx;
-  });
-}
-
-export function awaitProposalExecution(
-  slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract,
-  timeoutSeconds: number,
-  logger: Logger,
-): Promise<bigint> {
-  return new Promise<bigint>((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      logger.warn(`Timed out waiting for proposal execution`);
-      reject(new Error(`Timeout waiting for proposal execution after ${timeoutSeconds}s`));
-    }, timeoutSeconds * 1000);
-
-    if (slashingProposer.type === 'empire') {
-      const unwatch = slashingProposer.listenToPayloadSubmitted(args => {
-        logger.warn(`Proposal ${args.payload} from round ${args.round} executed`);
-        clearTimeout(timeout);
-        unwatch();
-        resolve(args.round);
-      });
-    } else if (slashingProposer.type === 'tally') {
-      const unwatch = slashingProposer.listenToRoundExecuted(args => {
-        logger.warn(`Slash from round ${args.round} executed`);
-        clearTimeout(timeout);
-        unwatch();
-        resolve(args.round);
-      });
-    } else {
-      clearTimeout(timeout);
-      reject(new Error(`Unknown slashing proposer type: ${(slashingProposer as any).type}`));
-    }
-  });
-}
-
-export async function awaitCommitteeExists({
-  rollup,
-  logger,
-}: {
-  rollup: RollupContract;
-  logger: Logger;
-}): Promise<readonly `0x${string}`[]> {
-  logger.info(`Waiting for committee to be set`);
-  let committee: readonly `0x${string}`[] | undefined;
-  await retryUntil(
-    async () => {
-      committee = await rollup.getCurrentEpochCommittee();
-      return committee && committee.length > 0;
-    },
-    'non-empty committee',
-    60,
-  );
-  return committee!;
-}
-
-export async function awaitOffenseDetected({
-  logger,
-  nodeAdmin,
-  slashingRoundSize,
-  epochDuration,
-  waitUntilOffenseCount,
-  timeoutSeconds = 120,
-}: {
-  nodeAdmin: AztecNodeAdmin;
-  logger: Logger;
-  slashingRoundSize: number;
-  epochDuration: number;
-  waitUntilOffenseCount?: number;
-  timeoutSeconds?: number;
-}) {
-  const targetOffenseCount = waitUntilOffenseCount ?? 1;
-  logger.warn(`Waiting for ${pluralize('offense', targetOffenseCount)} to be detected`);
-  const offenses = await retryUntil(
-    async () => {
-      const offenses = await nodeAdmin.getSlashOffenses('all');
-      if (offenses.length >= targetOffenseCount) {
-        return offenses;
-      }
-    },
-    'non-empty offenses',
-    timeoutSeconds,
-  );
-  logger.info(
-    `Hit ${offenses.length} offenses on rounds ${unique(offenses.map(o => getRoundForOffense(o, { slashingRoundSize, epochDuration })))}`,
-    { offenses },
-  );
-  return offenses;
-}
-
-/**
- * Await the committee to be slashed out of the validator set.
- * Currently assumes that the committee is the same size as the validator set.
- */
-export async function awaitCommitteeKicked({
-  rollup,
-  cheatCodes,
-  committee,
-  slashFactory,
-  slashingProposer,
-  slashingRoundSize,
-  aztecSlotDuration,
-  aztecEpochDuration,
-  logger,
-  offenseEpoch,
-}: {
-  rollup: RollupContract;
-  cheatCodes: RollupCheatCodes;
-  committee: readonly `0x${string}`[];
-  slashFactory: SlashFactoryContract;
-  slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
-  slashingRoundSize: number;
-  aztecSlotDuration: number;
-  aztecEpochDuration: number;
-  logger: Logger;
-  offenseEpoch: number;
-}) {
-  if (!slashingProposer) {
-    throw new Error('No slashing proposer configured. Cannot test slashing.');
-  }
-
-  await cheatCodes.debugRollup();
-
-  if (slashingProposer.type === 'empire') {
-    // Await for the slash payload to be created if empire (no payload is created on tally until execution time)
-    const targetEpoch = BigInt(await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1n;
-    logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-    await cheatCodes.advanceToEpoch(EpochNumber.fromBigInt(targetEpoch));
-
-    const slashPayloadEvents = await retryUntil(
-      async () => {
-        const events = await slashFactory.getSlashPayloadCreatedEvents();
-        return events.length > 0 ? events : undefined;
-      },
-      'slash payload created',
-      120,
-      1,
-    );
-    expect(slashPayloadEvents.length).toBe(1);
-    // The uniqueness check is needed since a validator may be slashed more than once on the same round (eg because they let two epochs be pruned)
-    expect(unique(slashPayloadEvents[0].slashes.map(slash => slash.validator.toString()))).toHaveLength(
-      committee.length,
-    );
-  } else {
-    // Use the slash offset to ensure we are in the right epoch for tally
-    const slashOffsetInRounds = await slashingProposer.getSlashOffsetInRounds();
-    const slashingRoundSizeInEpochs = slashingRoundSize / aztecEpochDuration;
-    const slashingOffsetInEpochs = Number(slashOffsetInRounds) * slashingRoundSizeInEpochs;
-    const firstEpochInOffenseRound = offenseEpoch - (offenseEpoch % slashingRoundSizeInEpochs);
-    const targetEpoch = firstEpochInOffenseRound + slashingOffsetInEpochs;
-    logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-    await cheatCodes.advanceToEpoch(EpochNumber(targetEpoch), { offset: -aztecSlotDuration / 2 });
-  }
-
-  const attestersPre = await rollup.getAttesters();
-  expect(attestersPre.length).toBe(committee.length);
-
-  for (const attester of attestersPre) {
-    const attesterInfo = await rollup.getAttesterView(attester);
-    expect(attesterInfo.status).toEqual(1); // Validating
-  }
-
-  const timeout = slashingRoundSize * 2 * aztecSlotDuration + 30;
-  logger.info(`Waiting for slash to be executed (timeout ${timeout}s)`);
-  await awaitProposalExecution(slashingProposer, timeout, logger);
-
-  // The attesters should still form the committee but they should be reduced to the "living" status
-  await cheatCodes.debugRollup();
-  const committeePostSlashing = await rollup.getCurrentEpochCommittee();
-  expect(committeePostSlashing?.length).toBe(attestersPre.length);
-
-  const attestersPostSlashing = await rollup.getAttesters();
-  expect(attestersPostSlashing.length).toBe(0);
-
-  for (const attester of attestersPre) {
-    const attesterInfo = await rollup.getAttesterView(attester);
-    expect(attesterInfo.status).toEqual(2); // Living
-  }
-
-  logger.info(`Advancing to check current committee`);
-  await cheatCodes.debugRollup();
-  await cheatCodes.advanceToEpoch(
-    EpochNumber.fromBigInt(BigInt(await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1n),
-  );
-  await cheatCodes.debugRollup();
-
-  const committeeNextEpoch = await rollup.getCurrentEpochCommittee();
-  // The committee should be undefined, since the validator set is empty
-  // and the tests currently using this helper always set a target committee size.
-  expect(committeeNextEpoch).toBeUndefined();
-
-  const attestersNextEpoch = await rollup.getAttesters();
-  expect(attestersNextEpoch.length).toBe(0);
-}

package/src/e2e_token_contract/token_contract_test.ts

@@ -1,167 +0,0 @@
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { type Logger, createLogger } from '@aztec/aztec.js/log';
-import type { AztecNode } from '@aztec/aztec.js/node';
-import { TokenContract } from '@aztec/noir-contracts.js/Token';
-import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
-import type { TestWallet } from '@aztec/test-wallet/server';
-
-import { jest } from '@jest/globals';
-
-import {
-  type ISnapshotManager,
-  type SubsystemsContext,
-  createSnapshotManager,
-  deployAccounts,
-  publicDeployAccounts,
-} from '../fixtures/snapshot_manager.js';
-import { mintTokensToPrivate } from '../fixtures/token_utils.js';
-import { TokenSimulator } from '../simulators/token_simulator.js';
-
-const { E2E_DATA_PATH: dataPath, METRICS_PORT: metricsPort } = process.env;
-
-export class TokenContractTest {
-  static TOKEN_NAME = 'USDC';
-  static TOKEN_SYMBOL = 'USD';
-  static TOKEN_DECIMALS = 18n;
-  private snapshotManager: ISnapshotManager;
-  logger: Logger;
-  asset!: TokenContract;
-  tokenSim!: TokenSimulator;
-  node!: AztecNode;
-
-  badAccount!: InvalidAccountContract;
-  wallet!: TestWallet;
-  adminAddress!: AztecAddress;
-  account1Address!: AztecAddress;
-  account2Address!: AztecAddress;
-
-  constructor(testName: string) {
-    this.logger = createLogger(`e2e:e2e_token_contract:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_token_contract/${testName}`, dataPath, {
-      metricsPort: metricsPort ? parseInt(metricsPort) : undefined,
-    });
-  }
-
-  /**
-   * Adds two state shifts to snapshot manager.
-   * 1. Add 3 accounts.
-   * 2. Publicly deploy accounts, deploy token contract and a "bad account".
-   */
-  async applyBaseSnapshots() {
-    // Adding a timeout of 2 minutes in here such that it is propagated to the underlying tests
-    jest.setTimeout(120_000);
-
-    await this.snapshotManager.snapshot(
-      '3_accounts',
-      deployAccounts(3, this.logger),
-      ({ deployedAccounts }, { wallet, aztecNode }) => {
-        this.node = aztecNode;
-        this.wallet = wallet;
-        [this.adminAddress, this.account1Address, this.account2Address] = deployedAccounts.map(acc => acc.address);
-        return Promise.resolve();
-      },
-    );
-
-    await this.snapshotManager.snapshot(
-      'e2e_token_contract',
-      async () => {
-        // Create the token contract state.
-        // Move this account thing to addAccounts above?
-        this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallet, [this.adminAddress, this.account1Address]);
-
-        this.logger.verbose(`Deploying TokenContract...`);
-        const asset = await TokenContract.deploy(
-          this.wallet,
-          this.adminAddress,
-          TokenContractTest.TOKEN_NAME,
-          TokenContractTest.TOKEN_SYMBOL,
-          TokenContractTest.TOKEN_DECIMALS,
-        )
-          .send({ from: this.adminAddress })
-          .deployed();
-        this.logger.verbose(`Token deployed to ${asset.address}`);
-
-        this.logger.verbose(`Deploying bad account...`);
-        this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress }).deployed();
-        this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
-
-        return { tokenContractAddress: asset.address, badAccountAddress: this.badAccount.address };
-      },
-      async ({ tokenContractAddress, badAccountAddress }) => {
-        // Restore the token contract state.
-        this.asset = TokenContract.at(tokenContractAddress, this.wallet);
-        this.logger.verbose(`Token contract address: ${this.asset.address}`);
-
-        this.tokenSim = new TokenSimulator(this.asset, this.wallet, this.adminAddress, this.logger, [
-          this.adminAddress,
-          this.account1Address,
-        ]);
-
-        this.badAccount = InvalidAccountContract.at(badAccountAddress, this.wallet);
-        this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
-
-        expect(await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).toBe(
-          this.adminAddress.toBigInt(),
-        );
-      },
-    );
-
-    // TokenContract.artifact.functions.forEach(fn => {
-    //   const sig = decodeFunctionSignature(fn.name, fn.parameters);
-    //   logger.verbose(`Function ${sig} and the selector: ${FunctionSelector.fromNameAndParameters(fn.name, fn.parameters)}`);
-    // });
-  }
-
-  async setup() {
-    await this.snapshotManager.setup();
-  }
-
-  snapshot = <T>(
-    name: string,
-    apply: (context: SubsystemsContext) => Promise<T>,
-    restore: (snapshotData: T, context: SubsystemsContext) => Promise<void> = () => Promise.resolve(),
-  ): Promise<void> => this.snapshotManager.snapshot(name, apply, restore);
-
-  async teardown() {
-    await this.snapshotManager.teardown();
-  }
-
-  async applyMintSnapshot() {
-    await this.snapshotManager.snapshot(
-      'mint',
-      async () => {
-        const { asset, adminAddress } = this;
-        const amount = 10000n;
-
-        this.logger.verbose(`Minting ${amount} publicly...`);
-        await asset.methods.mint_to_public(adminAddress, amount).send({ from: adminAddress }).wait();
-
-        this.logger.verbose(`Minting ${amount} privately...`);
-        await mintTokensToPrivate(asset, adminAddress, adminAddress, amount);
-        this.logger.verbose(`Minting complete.`);
-
-        return { amount };
-      },
-      async ({ amount }) => {
-        const { asset, adminAddress, tokenSim } = this;
-        tokenSim.mintPublic(adminAddress, amount);
-
-        const publicBalance = await asset.methods.balance_of_public(adminAddress).simulate({ from: adminAddress });
-        this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
-        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(adminAddress));
-
-        tokenSim.mintPrivate(adminAddress, amount);
-        const privateBalance = await asset.methods.balance_of_private(adminAddress).simulate({ from: adminAddress });
-        this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
-        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(adminAddress));
-
-        const totalSupply = await asset.methods.total_supply().simulate({ from: adminAddress });
-        this.logger.verbose(`Total supply: ${totalSupply}`);
-        expect(totalSupply).toEqual(tokenSim.totalSupply);
-
-        return Promise.resolve();
-      },
-    );
-  }
-}

package/src/fixtures/setup_l1_contracts.ts

@@ -1,26 +0,0 @@
-import type { Logger } from '@aztec/aztec.js/log';
-import { type DeployL1ContractsArgs, type L1ContractsConfig, deployL1Contracts } from '@aztec/ethereum';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractsHash } from '@aztec/protocol-contracts';
-
-import type { HDAccount, PrivateKeyAccount } from 'viem';
-import { foundry } from 'viem/chains';
-
-export { deployAndInitializeTokenAndBridgeContracts } from '../shared/cross_chain_test_harness.js';
-
-export const setupL1Contracts = async (
-  l1RpcUrl: string,
-  account: HDAccount | PrivateKeyAccount,
-  logger: Logger,
-  args: Pick<DeployL1ContractsArgs, 'genesisArchiveRoot' | 'initialValidators'> & L1ContractsConfig,
-) => {
-  const l1Data = await deployL1Contracts([l1RpcUrl], account, foundry, logger, {
-    vkTreeRoot: getVKTreeRoot(),
-    protocolContractsHash,
-    salt: undefined,
-    realVerifier: false,
-    ...args,
-  });
-
-  return l1Data;
-};