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

package/src/shared/wait_for_l1_to_l2_message.ts

@@ -0,0 +1,23 @@
+import type { Fr } from '@aztec/aztec.js/fields';
+import type { AztecNode } from '@aztec/aztec.js/node';
+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: Pick<AztecNode, 'getL1ToL2MessageCheckpoint'>,
+  l1ToL2MessageHash: Fr,
+  opts: { timeoutSeconds: number },
+) {
+  return retryUntil(
+    async () => (await node.getL1ToL2MessageCheckpoint(l1ToL2MessageHash)) !== undefined,
+    `L1 to L2 message ${l1ToL2MessageHash.toString()} seen`,
+    opts.timeoutSeconds,
+    1,
+  );
+}

package/src/simulators/lending_simulator.ts

@@ -1,12 +1,13 @@
 // Convenience struct to hold an account's address and secret that can easily be passed around.
-import { AztecAddress, type CheatCodes, Fr } from '@aztec/aztec.js';
-import { pedersenHash } from '@aztec/foundation/crypto';
+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/contracts';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
 import type { TestDateProvider } from '@aztec/foundation/timer';
-import type { RollupAbi } from '@aztec/l1-artifacts';
 import type { LendingContract } from '@aztec/noir-contracts.js/Lending';
-
-import type { Account, GetContractReturnType, HttpTransport, WalletClient } from 'viem';
-import type * as chains from 'viem/chains';
+import type { AztecNode, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 import type { TokenSimulator } from './token_simulator.js';
 
@@ -29,7 +30,7 @@ export class LendingAccount {
    * @returns Key in public space
    */
   public key() {
-    return pedersenHash([this.address, this.secret]);
+    return poseidon2Hash([this.address, this.secret]);
   }
 }
 
@@ -83,7 +84,7 @@ export class LendingSimulator {
     private rate: bigint,
     private ethereumSlotDuration: number,
     /** the rollup contract */
-    public rollup: GetContractReturnType<typeof RollupAbi, WalletClient<HttpTransport, chains.Chain, Account>>,
+    public rollup: RollupContract,
     /** the lending contract */
     public lendingContract: LendingContract,
     /** the collateral asset used in the lending contract */
@@ -92,31 +93,45 @@ export class LendingSimulator {
     public stableCoin: TokenSimulator,
   ) {}
 
-  async prepare() {
+  prepare() {
     this.accumulator = BASE;
-    const slot = await this.rollup.read.getSlotAt([
-      BigInt(await this.cc.eth.timestamp()) + BigInt(this.ethereumSlotDuration),
-    ]);
-    this.time = Number(await this.rollup.read.getTimestampForSlot([slot]));
+    this.time = 0;
+  }
+
+  /**
+   * Advances the simulator's accumulator and clock to match a block timestamp observed on chain.
+   * Call this BEFORE applying any accumulator-sensitive mutation (borrow/repay) so the mutation
+   * sees the same accumulator as the contract did during execution.
+   */
+  observeBlockTimestamp(ts: number) {
+    const diff = ts - this.time;
+    if (diff > 0) {
+      this.accumulator = muldivDown(this.accumulator, computeMultiplier(this.rate, BigInt(diff)), BASE);
+    }
+    this.time = ts;
   }
 
-  async progressSlots(diff: number, dateProvider?: TestDateProvider) {
+  async progressSlots(diff: number, _dateProvider?: TestDateProvider, node?: AztecNode & AztecNodeDebug) {
     if (diff <= 1) {
       return;
     }
 
-    const slot = await this.rollup.read.getSlotAt([BigInt(await this.cc.eth.timestamp())]);
-    const ts = Number(await this.rollup.read.getTimestampForSlot([slot + BigInt(diff)]));
-    const timeDiff = ts - this.time;
-    this.time = ts;
+    const slot = await this.rollup.getSlotAt(BigInt(await this.cc.eth.lastBlockTimestamp()));
+    const targetSlot = SlotNumber(slot + diff);
+    const ts = Number(await this.rollup.getTimestampForSlot(targetSlot));
 
-    // Mine ethereum blocks such that the next block will be in a new slot
-    await this.cc.eth.warp(this.time - this.ethereumSlotDuration);
-    if (dateProvider) {
-      dateProvider.setTime(this.time * 1000);
+    // Queue-aware warp under AutomineSequencer: atomic warp + mineBlock that advances L2 time to the
+    // target slot. The cheat code routes through the AutomineSequencer queue when one is installed,
+    // and otherwise falls back to a manual warp + mineBlock loop.
+    if (node) {
+      await this.cc.warpL2TimeAtLeastTo(node, ts);
+    } else {
+      await this.cc.eth.warp(ts - this.ethereumSlotDuration);
     }
-    await this.cc.rollup.markAsProven(await this.rollup.read.getPendingBlockNumber());
-    this.accumulator = muldivDown(this.accumulator, computeMultiplier(this.rate, BigInt(timeDiff)), BASE);
+
+    // Mark the latest checkpoint as proven so the rollup does not reorg pending checkpoints when
+    // time jumps far enough forward to cross an unproven epoch boundary.
+    await this.cc.rollup.markAsProven(await this.rollup.getCheckpointNumber());
   }
 
   depositPrivate(from: AztecAddress, onBehalfOf: Fr, amount: bigint) {
@@ -187,14 +202,16 @@ export class LendingSimulator {
 
     expect(this.borrowed).toEqual(this.stableCoin.totalSupply - this.mintedOutside);
 
-    const asset = await this.lendingContract.methods.get_asset(0).simulate();
+    const { result: asset } = await this.lendingContract.methods.get_asset(0).simulate({ from: this.account.address });
 
     const interestAccumulator = asset['interest_accumulator'];
     expect(interestAccumulator).toEqual(this.accumulator);
     expect(asset['last_updated_ts']).toEqual(BigInt(this.time));
 
     for (const key of [this.account.address, AztecAddress.fromField(await this.account.key())]) {
-      const privatePos = await this.lendingContract.methods.get_position(key).simulate();
+      const { result: privatePos } = await this.lendingContract.methods
+        .get_position(key)
+        .simulate({ from: this.account.address });
       expect(new Fr(privatePos['collateral'])).toEqual(this.collateral[key.toString()] ?? Fr.ZERO);
       expect(new Fr(privatePos['static_debt'])).toEqual(this.staticDebt[key.toString()] ?? Fr.ZERO);
       expect(privatePos['debt']).toEqual(

package/src/simulators/token_simulator.ts

@@ -1,5 +1,7 @@
-/* eslint-disable jsdoc/require-jsdoc */
-import { type AztecAddress, BatchCall, type Logger, type Wallet } from '@aztec/aztec.js';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { BatchCall } from '@aztec/aztec.js/contracts';
+import type { Logger } from '@aztec/aztec.js/log';
+import type { Wallet } from '@aztec/aztec.js/wallet';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 import chunk from 'lodash.chunk';
@@ -14,6 +16,7 @@ export class TokenSimulator {
   constructor(
     protected token: TokenContract,
     protected defaultWallet: Wallet,
+    protected defaultAddress: AztecAddress,
     protected logger: Logger,
     protected accounts: AztecAddress[],
   ) {}
@@ -97,14 +100,18 @@ export class TokenSimulator {
 
   async checkPublic() {
     // public calls
-    const calls = [await this.token.methods.total_supply().request()];
-    for (const address of this.accounts) {
-      calls.push(await this.token.methods.balance_of_public(address).request());
-    }
+    const calls = [
+      this.token.methods.total_supply(),
+      ...this.accounts.map(address => this.token.methods.balance_of_public(address)),
+    ];
 
     const results = (
-      await Promise.all(chunk(calls, 4).map(batch => new BatchCall(this.defaultWallet, batch).simulate()))
-    ).flat();
+      await Promise.all(
+        chunk(calls, 5).map(batch => new BatchCall(this.defaultWallet, batch).simulate({ from: this.defaultAddress })),
+      )
+    )
+      .flatMap(r => r.result)
+      .map(r => r.result);
     expect(results[0]).toEqual(this.totalSupply);
 
     // Check that all our balances match
@@ -114,36 +121,13 @@ export class TokenSimulator {
   }
 
   async checkPrivate() {
-    // Private calls
-    const defaultLookups = [];
-    const nonDefaultLookups = [];
-
     for (const address of this.accounts) {
-      if (this.lookupProvider.has(address.toString())) {
-        nonDefaultLookups.push(address);
-      } else {
-        defaultLookups.push(address);
-      }
-    }
-
-    const defaultCalls = [];
-    for (const address of defaultLookups) {
-      defaultCalls.push(await this.token.methods.balance_of_private(address).request());
-    }
-    const results = (
-      await Promise.all(chunk(defaultCalls, 4).map(batch => new BatchCall(this.defaultWallet, batch).simulate()))
-    ).flat();
-    for (let i = 0; i < defaultLookups.length; i++) {
-      expect(results[i]).toEqual(this.balanceOfPrivate(defaultLookups[i]));
-    }
-
-    // We are just running individual calls for the non-default lookups
-    // @todo We should also batch these
-    for (const address of nonDefaultLookups) {
       const wallet = this.lookupProvider.get(address.toString());
       const asset = wallet ? this.token.withWallet(wallet) : this.token;
 
-      const actualPrivateBalance = await asset.methods.balance_of_private({ address }).simulate();
+      const { result: actualPrivateBalance } = await asset.methods
+        .balance_of_private(address)
+        .simulate({ from: address });
       expect(actualPrivateBalance).toEqual(this.balanceOfPrivate(address));
     }
   }

package/src/spartan/DEVELOP.md

@@ -0,0 +1,128 @@
+The flow is as follows:
+
+1. Install/start KIND locally
+2. Bootstrap (to build an aztec image)
+3. Load image into kind
+4. Deploy networks
+5. Run tests in `yarn-project/end-to-end/src/spartan`
+
+# Setup KIND
+
+KIND is a kubernetes cluster that runs locally out of docker containers.
+
+You can just
+
+```bash
+spartan/bootstrap.sh kind
+```
+
+You only need to do that once. If you do it again, it will destroy the cluster and recreate it (which you almost never need to do).
+
+Now you’ll likely want some visibility into your cluster. You can
+
+```bash
+spartan/scripts/create_k8s_dashboard.sh
+```
+
+And after ~30 seconds or so you can
+
+```bash
+spartan/scripts/forward_k8s_dashboard.sh
+```
+
+That will run a port forward to your port `8443` . If you’re running in a remote environment (e.g. the mainframe), you’ll need to subsequently forward that back to your local machine. Cursor/VSCode have built in port forwarding (cmd/ctrl shift P, “forward”)
+
+Open the forwarded page, and copy/paste the token that was generated when you forwarded the dashboard.
+
+# Build an aztecprotocol:aztec image
+
+```bash
+./bootstrap.sh
+export AZTEC_DOCKER_IMAGE="aztecprotocol/aztec:$(docker images "aztecprotocol/aztec" --format json | \
+  jq -r 'select(.Tag != "latest") | .Tag' | \
+  head -1)"
+kind load docker-image $AZTEC_DOCKER_IMAGE
+```
+
+If you just changed typescript, you can (after the initial bootstrap)
+
+```bash
+./yarn-project/bootstrap.sh
+./release-image/bootstrap.sh
+export AZTEC_DOCKER_IMAGE="aztecprotocol/aztec:$(docker images "aztecprotocol/aztec" --format json | \
+  jq -r 'select(.Tag != "latest") | .Tag' | \
+  head -1)"
+kind load docker-image $AZTEC_DOCKER_IMAGE
+```
+
+The export is important there. The `AZTEC_DOCKER_IMAGE` env var is used as both:
+
+- the container that runs the rollup contract deployment
+- 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
+./spartan/bootstrap.sh network_deploy scenario.local
+```
+
+That will take 1-3 minutes. But at the end you should have everything you need.
+
+You can (`k` is just an alias over `kubectl`)
+
+```bash
+❯ k get pods -n scenario
+NAME                                              READY   STATUS    RESTARTS   AGE
+deploy-rollup-contracts-2025-08-31-1511-w2dlb   0/1     Completed   0          2m34s
+scenario-eth-beacon-0                           1/1     Running     0          39m
+scenario-eth-execution-0                        1/1     Running     0          39m
+scenario-eth-validator-0                        1/1     Running     0          39m
+scenario-p2p-bootstrap-node-5cbf9658b9-6vd9b    1/1     Running     0          20m
+scenario-prover-agent-59bd96899d-46k5s          1/1     Running     0          116s
+scenario-prover-agent-59bd96899d-vzvkd          1/1     Running     0          116s
+scenario-prover-broker-0                        1/1     Running     0          116s
+scenario-prover-node-0                          1/1     Running     0          116s
+scenario-rpc-aztec-node-0                       1/1     Running     0          116s
+scenario-validator-0                            1/1     Running     0          116s
+scenario-validator-1                            1/1     Running     0          116s
+scenario-validator-2                            1/1     Running     0          116s
+scenario-validator-3                            1/1     Running     0          116s
+```
+
+For example, you can forward back the ethereum node with
+
+```bash
+ k port-forward -n scenario services/eth-devnet-eth-execution 8545:8545
+```
+
+And then do whatever you like with it.
+
+# Run tests
+
+With the cluster running, you can now easily run tests.
+
+```bash
+# run one
+./spartan/bootstrap.sh single_test scenario.local spartan/smoke.test.ts
+
+# run all (serially)
+./spartan/bootstrap.sh network_tests scenario.local
+```
+
+Right now, I recommend running the smoke test first, always, as it waits for the committee to exist.
+
+# Teardown
+
+You can just `k delete namespace scenario`. That will destroy everything in your kind cluster. To destroy the associated terraform state that was stored locally, just `./spartan/terraform/purge_local_state.sh`.