@aztec/end-to-end 0.0.1-commit.2f68f620 → 0.0.1-commit.321f6a9

package/src/automine/automine_test_context.ts

@@ -0,0 +1,153 @@
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { type ContractBase, getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { PublicKeys } from '@aztec/aztec.js/keys';
+import type { Logger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import type { CheatCodes } from '@aztec/aztec/testing';
+import { ChildContract } from '@aztec/noir-test-contracts.js/Child';
+import { ParentContract } from '@aztec/noir-test-contracts.js/Parent';
+import type { StatefulTestContract } from '@aztec/noir-test-contracts.js/StatefulTest';
+import type { PXEConfig } from '@aztec/pxe/config';
+import type { SequencerClient } from '@aztec/sequencer-client';
+import type { AztecNodeAdmin, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
+
+import { AUTOMINE_E2E_OPTS } from '../fixtures/fixtures.js';
+import { type EndToEndContext, type SetupOptions, setup, teardown } from '../fixtures/setup.js';
+import type { TestWallet } from '../test-wallet/test_wallet.js';
+
+export type AutomineTestOpts = Partial<SetupOptions> & {
+  /** Number of accounts to create and deploy during setup. */
+  numberOfAccounts?: number;
+  /** Options forwarded to PXE creation. */
+  pxeOpts?: Partial<PXEConfig>;
+};
+
+/**
+ * Base class for the automine-sequencer test topology: a single in-process node running the
+ * deterministic {@link AUTOMINE_E2E_OPTS} preset (one block per submitted tx, synchronous L1 publish,
+ * no committee, no prover, no validator client). Owns the environment (in-proc anvil in automine mode
+ * plus the L1 deploy) and exposes the handles every automine test uses (`wallet`, `aztecNode`,
+ * `cheatCodes`, `sequencer`, `accounts`, `logger`).
+ *
+ * The sibling of {@link SingleNodeTestContext}: both wrap the same underlying `fixtures/setup.ts:setup()`
+ * but fix opposite sequencer topologies. Making {@link AUTOMINE_E2E_OPTS} the base default removes the
+ * per-test-file spread every automine test would otherwise repeat.
+ *
+ * Domain harnesses (the token simulators) compose on top by extending this base and overriding
+ * {@link setup} to run their domain steps after `super.setup()`.
+ */
+export class AutomineTestContext {
+  public context!: EndToEndContext;
+  public logger!: Logger;
+  public wallet!: TestWallet;
+  public aztecNode!: AztecNode & AztecNodeDebug;
+  public aztecNodeAdmin!: AztecNodeAdmin;
+  public cheatCodes!: CheatCodes;
+  public sequencer!: SequencerClient;
+  public accounts!: AztecAddress[];
+  public defaultAccountAddress!: AztecAddress;
+
+  public parentContract!: ParentContract;
+  public childContract!: ChildContract;
+
+  public static async setup<T extends AutomineTestContext>(this: new () => T, opts: AutomineTestOpts = {}): Promise<T> {
+    const test = new this();
+    await test.setup(opts);
+    return test;
+  }
+
+  public async setup(opts: AutomineTestOpts = {}): Promise<void> {
+    const { numberOfAccounts = 1, pxeOpts, ...setupOpts } = opts;
+    const context = await setup(
+      numberOfAccounts,
+      {
+        ...AUTOMINE_E2E_OPTS,
+        fundSponsoredFPC: true,
+        ...setupOpts,
+      },
+      pxeOpts,
+    );
+    await this.hydrateFromContext(context);
+  }
+
+  /**
+   * Populates the context-derived handles from an already-built {@link EndToEndContext}. Split out of
+   * {@link setup} so domain harnesses that build the environment with their own bespoke `setup(...)`
+   * opts can still reuse the shared handle wiring.
+   */
+  protected hydrateFromContext(context: EndToEndContext): Promise<void> {
+    this.context = context;
+    this.logger = context.logger;
+    this.wallet = context.wallet;
+    this.aztecNode = context.aztecNodeService;
+    this.aztecNodeAdmin = context.aztecNodeService;
+    this.cheatCodes = context.cheatCodes;
+    this.sequencer = context.sequencer!;
+    this.accounts = context.accounts;
+    this.defaultAccountAddress = context.accounts[0];
+    return Promise.resolve();
+  }
+
+  public async teardown(): Promise<void> {
+    await teardown(this.context);
+  }
+
+  /**
+   * Marks the current pending checkpoints as proven, then warps the L2 clock forward by `seconds`.
+   *
+   * Under {@link AUTOMINE_E2E_OPTS} a long warp crosses many epochs with no proofs being submitted, so
+   * without a prior `markAsProven()` the rollup contract's pruning window resets the chain tip to genesis
+   * and the warp's own empty-checkpoint propose fails with `Rollup__InvalidArchive`. Marking proven before
+   * warping keeps the pending chain alive. Composes the existing `cheatCodes.rollup.markAsProven` and
+   * `warpL2TimeAtLeastBy` with that required ordering.
+   */
+  public async markProvenAndWarp(seconds: number | bigint): Promise<void> {
+    await this.cheatCodes.rollup.markAsProven();
+    await this.cheatCodes.warpL2TimeAtLeastBy(this.aztecNode, seconds);
+  }
+
+  /** Computes and registers a contract instance in the wallet without deploying it on-chain. */
+  public async registerContract<T extends ContractBase>(
+    wallet: Wallet,
+    contractArtifact: ContractArtifactClass<T>,
+    opts: {
+      salt?: Fr;
+      publicKeys?: PublicKeys;
+      initArgs?: any[];
+      constructorName?: string;
+      deployer?: AztecAddress;
+    } = {},
+  ): Promise<T> {
+    const { salt, publicKeys, initArgs, constructorName, deployer } = opts;
+    const instance = await getContractInstanceFromInstantiationParams(contractArtifact.artifact, {
+      constructorArgs: initArgs ?? [],
+      constructorArtifact: constructorName,
+      salt: salt ?? Fr.random(),
+      publicKeys,
+      deployer,
+    });
+    await wallet.registerContract(instance, contractArtifact.artifact);
+    return contractArtifact.at(instance.address, wallet);
+  }
+
+  /** Deploys a Parent and a Child contract from the default account for the nested-call tests. */
+  public async applyManualParentChild(): Promise<void> {
+    this.logger.info('Deploying parent and child contracts');
+    ({ contract: this.parentContract } = await ParentContract.deploy(this.wallet).send({
+      from: this.defaultAccountAddress,
+    }));
+    ({ contract: this.childContract } = await ChildContract.deploy(this.wallet).send({
+      from: this.defaultAccountAddress,
+    }));
+  }
+}
+
+export type StatefulContractCtorArgs = Parameters<StatefulTestContract['methods']['constructor']>;
+
+export type ContractArtifactClass<T extends ContractBase> = {
+  at(address: AztecAddress, wallet: Wallet): T;
+  artifact: ContractArtifact;
+};

package/src/automine/delivery/interactive_handshake_responder.ts

@@ -0,0 +1,125 @@
+import { AztecAddress, type CompleteAddress } from '@aztec/aztec.js/addresses';
+import { DomainSeparator } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Schnorr, type SchnorrSignature } from '@aztec/foundation/crypto/schnorr';
+import { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import type { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import type { CustomRequest } from '@aztec/pxe/config';
+import {
+  INTERACTIVE_HANDSHAKE_REQUEST_KIND,
+  STANDARD_HANDSHAKE_REGISTRY_ADDRESS,
+} from '@aztec/standard-contracts/handshake-registry/constants';
+import { type PublicKeys, derivePublicKeyFromSecretKey } from '@aztec/stdlib/keys';
+
+/**
+ * The decoded payload of the registry's interactive-handshake signature request. Note it never carries the sender,
+ * so the recipient authorizes the handshake without learning who initiated it.
+ */
+export type InteractiveHandshakeRequest = {
+  /** The account whose authorization is being requested. */
+  recipient: AztecAddress;
+  chainId: Fr;
+  version: Fr;
+  /** The x-coordinate of the handshake's ephemeral public key (its y-coordinate is positive by construction). */
+  ephPkX: Fr;
+};
+
+/**
+ * The recipient's signed authorization for an interactive handshake. Mirrors the registry contract's
+ * `RecipientSignature` struct field for field.
+ */
+export type RecipientSignature = {
+  /** The recipient's master public keys, bound in-circuit to the recipient's address via `partialAddress`. */
+  publicKeys: PublicKeys;
+  partialAddress: Fr;
+  /** The x-coordinate of the recipient's master message-signing public key. */
+  mspkX: Fr;
+  /** Whether that key's y-coordinate is positive, so the circuit can reconstruct the point from `mspkX`. */
+  mspkYIsPositive: boolean;
+  /** The schnorr signature over the handshake message. */
+  signature: SchnorrSignature;
+};
+
+/**
+ * Parses and validates the registry's interactive-handshake signature request.
+ *
+ * @throws If the request kind is not {@link INTERACTIVE_HANDSHAKE_REQUEST_KIND}, the issuing contract is not the
+ * standard HandshakeRegistry, or the payload does not have the expected shape.
+ */
+export function parseInteractiveHandshakeRequest(request: CustomRequest): InteractiveHandshakeRequest {
+  if (!request.kind.equals(INTERACTIVE_HANDSHAKE_REQUEST_KIND)) {
+    throw new Error(`Not an interactive-handshake signature request: unexpected kind ${request.kind}`);
+  }
+  if (!request.contractAddress.equals(STANDARD_HANDSHAKE_REGISTRY_ADDRESS)) {
+    throw new Error(
+      `Interactive-handshake signature request issued by ${request.contractAddress}, expected the standard HandshakeRegistry at ${STANDARD_HANDSHAKE_REGISTRY_ADDRESS}`,
+    );
+  }
+  if (request.payload.length !== 4) {
+    throw new Error(`Interactive-handshake signature request payload has ${request.payload.length} fields, expected 4`);
+  }
+
+  const [recipient, chainId, version, ephPkX] = request.payload;
+  return { recipient: new AztecAddress(recipient), chainId, version, ephPkX };
+}
+
+/**
+ * Produces the recipient's signed authorization for an interactive handshake, signing with the master
+ * message-signing secret key.
+ */
+export async function signInteractiveHandshake(
+  request: InteractiveHandshakeRequest,
+  completeAddress: CompleteAddress,
+  masterMessageSigningSecretKey: GrumpkinScalar,
+): Promise<RecipientSignature> {
+  const mspk = await derivePublicKeyFromSecretKey(masterMessageSigningSecretKey);
+  const [mspkX, mspkYIsPositive] = mspk.toXAndSign();
+
+  const message = await computeInteractiveHandshakeSignatureMessage({
+    chainId: request.chainId,
+    version: request.version,
+    registry: STANDARD_HANDSHAKE_REGISTRY_ADDRESS,
+    ephPkX: request.ephPkX,
+  });
+  const signature = await new Schnorr().constructSignature(message, masterMessageSigningSecretKey);
+
+  return {
+    publicKeys: completeAddress.publicKeys,
+    partialAddress: completeAddress.partialAddress,
+    mspkX,
+    mspkYIsPositive,
+    signature,
+  };
+}
+
+/** Serializes a {@link RecipientSignature} to the field layout the registry's in-circuit deserialization expects. */
+export function recipientSignatureToFields(recipientSignature: RecipientSignature): Fr[] {
+  const s = Fq.fromBuffer(recipientSignature.signature.s);
+  const e = Fq.fromBuffer(recipientSignature.signature.e);
+  return [
+    ...recipientSignature.publicKeys.toFields(),
+    recipientSignature.partialAddress,
+    recipientSignature.mspkX,
+    new Fr(recipientSignature.mspkYIsPositive),
+    s.lo,
+    s.hi,
+    e.lo,
+    e.hi,
+  ];
+}
+
+/**
+ * The message an interactive-handshake authorization signs: the handshake's ephemeral key and chain context under
+ * `DomainSeparator.INTERACTIVE_HANDSHAKE_SIGNATURE`, exactly as the registry recomputes it in-circuit.
+ */
+function computeInteractiveHandshakeSignatureMessage(args: {
+  chainId: Fr;
+  version: Fr;
+  registry: AztecAddress;
+  ephPkX: Fr;
+}): Promise<Fr> {
+  return poseidon2HashWithSeparator(
+    [args.chainId, args.version, args.registry, args.ephPkX],
+    DomainSeparator.INTERACTIVE_HANDSHAKE_SIGNATURE,
+  );
+}

package/src/automine/delivery/onchain_delivery_harness.ts

@@ -0,0 +1,213 @@
+import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
+import type { FieldLike } from '@aztec/aztec.js/abi';
+import { NO_FROM } from '@aztec/aztec.js/account';
+import type { AztecAddress, CompleteAddress } from '@aztec/aztec.js/addresses';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { AccountManager } from '@aztec/aztec.js/wallet';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { type DeliveryEvent, OnchainDeliveryTestContract } from '@aztec/noir-test-contracts.js/OnchainDeliveryTest';
+import type { CustomRequest, ResolveCustomRequest, ResolveTaggingSecretStrategy } from '@aztec/pxe/config';
+import type { AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
+
+import { jest } from '@jest/globals';
+
+import { AUTOMINE_E2E_OPTS } from '../../fixtures/fixtures.js';
+import { ensureHandshakeRegistryPublished, setup, setupPXEAndGetWallet } from '../../fixtures/setup.js';
+import { TestWallet } from '../../test-wallet/test_wallet.js';
+
+// Builds the hook serving custom requests issued during the sender's simulations. Installed on the sender PXE at
+// creation but built only once the recipient exists, since serving typically needs the recipient's wallet and keys.
+export type CustomRequestResponder = (
+  recipient: TestWallet,
+  recipientAccount: InitialAccountData,
+  recipientCompleteAddress: CompleteAddress,
+) => ResolveCustomRequest;
+
+export type Mode = 'constrained' | 'unconstrained';
+
+// A single mode applies to both the event and note sends; `{ events, notes }` sends each in its own mode, which
+// exercises cross-mode handshake reuse: bootstrap in one mode, deliver in the other on the same handshake.
+export type DeliveryMode = Mode | { events: Mode; notes: Mode };
+
+const formatMode = (mode: DeliveryMode): string => (typeof mode === 'string' ? mode : `${mode.events}->${mode.notes}`);
+
+// Onchain private delivery has two orthogonal axes: the delivery MODE (constrained = nullifier-chained sequence;
+// unconstrained = no nullifier, windowed scan) and the tagging-secret SOURCE, which the wallet's
+// `resolveTaggingSecretStrategy` hook selects. This harness exercises (strategy, mode) cells end to end across two
+// PXEs that share only a node: the sender PXE sends, the recipient PXE discovers purely from onchain logs plus the
+// HandshakeRegistry.
+//
+// Cross-PXE is the meaningful setup: the recipient PXE holds no sender state, so a cell only "discovers" a message if
+// the source truly reached it.
+export function buildMessageDeliveryTest(opts: {
+  // Names the tagging-secret source, e.g. 'non-interactive handshake' or 'arbitrary secret'. The describe title is
+  // derived as `${strategy} x ${mode}`.
+  strategy: string;
+  mode: DeliveryMode;
+  // Required: every cell states its source explicitly rather than leaning on the PXE default (covered by unit tests).
+  senderHook: ResolveTaggingSecretStrategy;
+  // Recipient-side setup the source requires (e.g. registering a raw arbitrary secret); runs once after deployment.
+  recipientRegistration?: (
+    recipient: TestWallet,
+    recipientAddress: AztecAddress,
+    sender: AztecAddress,
+  ) => Promise<void>;
+  // Serves the custom requests issued during the sender's simulations (e.g. the registry's interactive-handshake
+  // signature request).
+  customRequestResponder?: CustomRequestResponder;
+  // Extra `it()`s to register in this cell's suite, e.g. assertions against state a custom `senderHook` recorded.
+  // Called inside the same `describe`, after the two baseline assertions below, so it shares their `beforeAll`
+  // instead of depending on Jest's cross-`describe` execution order.
+  additionalTests?: () => void;
+}) {
+  const { strategy, mode, senderHook, recipientRegistration, customRequestResponder, additionalTests } = opts;
+  const description = `${strategy} x ${formatMode(mode)}`;
+
+  describe(description, () => {
+    jest.setTimeout(300_000);
+
+    const eventValues = [10n, 20n, 30n];
+    const noteValues = [40n, 50n, 60n];
+
+    let aztecNode: AztecNode & AztecNodeDebug;
+    let walletSender: TestWallet;
+    let walletRecipient: TestWallet;
+    let sender: AztecAddress;
+    let recipient: AztecAddress;
+    let contractSender: OnchainDeliveryTestContract;
+    let teardownSender: () => Promise<void>;
+    let teardownRecipient: () => Promise<void>;
+    // Discovery results captured in beforeAll, so the assertions in the actual tests below stay pure.
+    // A failure during delivery fails beforeAll loudly instead of being swallowed as an expected red.
+    let discoveredEvents: FieldLike[];
+    let readNotes: bigint[];
+
+    const { events: eventMode, notes: noteMode } = typeof mode === 'string' ? { events: mode, notes: mode } : mode;
+    const sendEvent = (value: bigint) =>
+      eventMode === 'constrained'
+        ? contractSender.methods.emit_event(recipient, value)
+        : contractSender.methods.emit_event_unconstrained(recipient, value);
+    const sendNote = (value: bigint) =>
+      noteMode === 'constrained'
+        ? contractSender.methods.emit_note(recipient, value)
+        : contractSender.methods.emit_note_unconstrained(recipient, value);
+
+    let additionallyFundedAccounts: InitialAccountData[];
+    let recipientAccount: AccountManager | undefined;
+    let customRequestCount = 0;
+
+    beforeAll(async () => {
+      // The sender PXE holds the sender and carries this cell's tagging-secret-strategy hook. The recipient is funded
+      // at genesis here but created and deployed on the isolated recipient PXE below, so it carries no sender state
+      // from other cells.
+      ({
+        aztecNode,
+        additionallyFundedAccounts,
+        wallet: walletSender,
+        accounts: [sender],
+        teardown: teardownSender,
+      } = await setup(1, {
+        ...AUTOMINE_E2E_OPTS,
+        additionallyFundedAccounts: await generateSchnorrAccounts(1, 'schnorr'),
+        pxeCreationOptions: {
+          hooks: {
+            resolveTaggingSecretStrategy: senderHook,
+            resolveCustomRequest: async (request: CustomRequest) => {
+              if (!customRequestResponder) {
+                throw new Error('A custom request arrived but this test cell has no customRequestResponder configured');
+              }
+              if (!recipientAccount) {
+                throw new Error('A custom request arrived before the recipient wallet was created');
+              }
+              customRequestCount++;
+              const respond = customRequestResponder(
+                walletRecipient,
+                additionallyFundedAccounts[0],
+                await recipientAccount.getCompleteAddress(),
+              );
+              return respond(request);
+            },
+          },
+        },
+      }));
+
+      ({ wallet: walletRecipient, teardown: teardownRecipient } = await setupPXEAndGetWallet(
+        aztecNode,
+        aztecNode,
+        {},
+        undefined,
+        'pxe-recipient',
+      ));
+      recipientAccount = await walletRecipient.createSchnorrAccount(
+        additionallyFundedAccounts[0].secret,
+        additionallyFundedAccounts[0].salt,
+        additionallyFundedAccounts[0].signingKey,
+      );
+      await (await recipientAccount.getDeployMethod()).send({ from: NO_FROM });
+      recipient = recipientAccount.address;
+
+      await ensureHandshakeRegistryPublished(walletSender, sender);
+      const { contract: deployed, instance } = await OnchainDeliveryTestContract.deploy(walletSender).send({
+        from: sender,
+      });
+      contractSender = deployed;
+
+      await ensureHandshakeRegistryPublished(walletRecipient, recipient);
+      await walletRecipient.registerContract(instance, OnchainDeliveryTestContract.artifact);
+
+      await recipientRegistration?.(walletRecipient, recipient, sender);
+
+      // Constrained sends to one pair are strictly ordered, so deliver one tx at a time. The first send bootstraps the
+      // handshake (when the source is a handshake); the rest reuse it.
+      const blockNumbers: number[] = [];
+      for (const value of eventValues) {
+        const { receipt } = await sendEvent(value).send({ from: sender });
+        blockNumbers.push(receipt.blockNumber!);
+      }
+      for (const value of noteValues) {
+        await sendNote(value).send({ from: sender });
+      }
+
+      await walletRecipient.sync();
+
+      const events = await walletRecipient.getPrivateEvents<DeliveryEvent>(
+        OnchainDeliveryTestContract.events.DeliveryEvent,
+        {
+          contractAddress: contractSender.address,
+          fromBlock: BlockNumber(Math.min(...blockNumbers)),
+          toBlock: BlockNumber(Math.max(...blockNumbers) + 1),
+          scopes: [recipient],
+        },
+      );
+      discoveredEvents = events.map(e => e.event.value);
+
+      const contractRecipient = OnchainDeliveryTestContract.at(contractSender.address, walletRecipient);
+      const { result } = await contractRecipient.methods.get_note_values(recipient).simulate({ from: recipient });
+      readNotes = result.storage.slice(0, Number(result.len));
+    });
+
+    afterAll(async () => {
+      await teardownRecipient();
+      await teardownSender();
+    });
+
+    it('the recipient PXE discovers the events delivered by the sender PXE', () => {
+      expect(discoveredEvents.length).toBe(eventValues.length);
+      for (const value of eventValues) {
+        expect(discoveredEvents).toContainEqual(value);
+      }
+    });
+
+    it('the recipient PXE reads back the notes delivered by the sender PXE', () => {
+      expect(readNotes).toEqual(noteValues);
+    });
+
+    if (customRequestResponder) {
+      it('the custom request hook fires exactly once, on the send that bootstraps the tagging secret', () => {
+        expect(customRequestCount).toBe(1);
+      });
+    }
+
+    additionalTests?.();
+  });
+}

package/src/{e2e_blacklist_token_contract → automine/token}/blacklist_token_contract_test.ts

@@ -1,30 +1,18 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import { computeSecretHash } from '@aztec/aztec.js/crypto';
 import { Fr } from '@aztec/aztec.js/fields';
-import { type Logger, createLogger } from '@aztec/aztec.js/log';
-import type { AztecNode } from '@aztec/aztec.js/node';
+import { createLogger } from '@aztec/aztec.js/log';
 import type { TxHash } from '@aztec/aztec.js/tx';
-import type { CheatCodes } from '@aztec/aztec/testing';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBlacklistContract } from '@aztec/noir-contracts.js/TokenBlacklist';
 import { GenericProxyContract } from '@aztec/noir-test-contracts.js/GenericProxy';
 import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
-import type { SequencerClient } from '@aztec/sequencer-client';
-import type { AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 import { jest } from '@jest/globals';
 
-import {
-  type EndToEndContext,
-  type SetupOptions,
-  deployAccounts,
-  ensureAuthRegistryPublished,
-  publicDeployAccounts,
-  setup,
-  teardown,
-} from '../fixtures/setup.js';
-import { TokenSimulator } from '../simulators/token_simulator.js';
-import type { TestWallet } from '../test-wallet/test_wallet.js';
+import { ensureAuthRegistryPublished } from '../../fixtures/setup.js';
+import { TokenSimulator } from '../../simulators/token_simulator.js';
+import { AutomineTestContext, type AutomineTestOpts } from '../automine_test_context.js';
 
 export class Role {
   private isAdmin = false;
@@ -53,37 +41,33 @@ export class Role {
   }
 }
 
-export class BlacklistTokenContractTest {
+/**
+ * TokenBlacklist-domain harness over the automine topology: extends {@link AutomineTestContext} with a
+ * {@link TokenSimulator}, the {@link Role} helper, the TokenBlacklist deploy plus a bad-account and
+ * authwit proxy, and the role-change-delay warp. Base setup and mint run in {@link setup}.
+ */
+export class BlacklistTokenContractTest extends AutomineTestContext {
   // This value MUST match the same value that we have in the contract
   static CHANGE_ROLES_DELAY = 86400;
 
-  context!: EndToEndContext;
-  logger: Logger;
-  wallet!: TestWallet;
   asset!: TokenBlacklistContract;
   tokenSim!: TokenSimulator;
   badAccount!: InvalidAccountContract;
   authwitProxy!: GenericProxyContract;
-  cheatCodes!: CheatCodes;
-  sequencer!: SequencerClient;
-  aztecNode!: AztecNode & AztecNodeDebug;
 
   adminAddress!: AztecAddress;
   otherAddress!: AztecAddress;
   blacklistedAddress!: AztecAddress;
 
+  private testName: string;
+
   constructor(testName: string) {
-    this.logger = createLogger(`e2e:e2e_blacklist_token_contract:${testName}`);
+    super();
+    this.testName = testName;
   }
 
   async crossTimestampOfChange() {
-    // Under AUTOMINE_E2E_OPTS, the 86400s warp crosses many epochs without any proofs being
-    // submitted. Mark current pending checkpoints as proven first so the rollup contract's
-    // pruning window doesn't reset the chain tip to genesis (which would make the warp's
-    // own empty-checkpoint propose fail with Rollup__InvalidArchive). See the AutomineSequencer
-    // README "Epoch proving caveat" and the equivalent pattern in lending_simulator.progressSlots.
-    await this.cheatCodes.rollup.markAsProven();
-    await this.cheatCodes.warpL2TimeAtLeastBy(this.aztecNode, BlacklistTokenContractTest.CHANGE_ROLES_DELAY);
+    await this.markProvenAndWarp(BlacklistTokenContractTest.CHANGE_ROLES_DELAY);
   }
 
   /**
@@ -96,28 +80,14 @@ export class BlacklistTokenContractTest {
     // proxy deploys exceed the original window.
     jest.setTimeout(600_000);
 
-    this.logger.info('Deploying 3 accounts');
-    const { deployedAccounts } = await deployAccounts(
-      3,
-      this.logger,
-    )({
-      wallet: this.context.wallet,
-      initialFundedAccounts: this.context.initialFundedAccounts,
-    });
-
     this.cheatCodes = this.context.cheatCodes;
     this.aztecNode = this.context.aztecNodeService;
     this.sequencer = this.context.sequencer!;
     this.wallet = this.context.wallet;
-    this.adminAddress = deployedAccounts[0].address;
-    this.otherAddress = deployedAccounts[1].address;
-    this.blacklistedAddress = deployedAccounts[2].address;
+    [this.adminAddress, this.otherAddress, this.blacklistedAddress] = this.context.accounts;
 
     this.logger.info('Setting up blacklist token contract');
     await ensureAuthRegistryPublished(this.wallet, this.adminAddress);
-    // Create the token contract state.
-    this.logger.verbose(`Public deploy accounts...`);
-    await publicDeployAccounts(this.wallet, [this.adminAddress, this.otherAddress, this.blacklistedAddress]);
 
     this.logger.verbose(`Deploying TokenContract...`);
     ({ contract: this.asset } = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress).send({
@@ -155,20 +125,13 @@ export class BlacklistTokenContractTest {
     ).toEqual(new Role().withAdmin().toNoirStruct());
   }
 
-  async setup(opts: Partial<SetupOptions> = {}) {
-    this.logger.info('Setting up fresh context');
-    this.context = await setup(0, {
-      ...opts,
-      fundSponsoredFPC: true,
-      skipAccountDeployment: true,
-    });
+  override async setup(opts: AutomineTestOpts = {}) {
+    await super.setup({ numberOfAccounts: 3, ...opts });
+    // hydrateFromContext repoints `this.logger` at the context logger; restore the harness-named one.
+    this.logger = createLogger(`e2e:automine:blacklist:${this.testName}`);
     await this.applyBaseSetup();
   }
 
-  async teardown() {
-    await teardown(this.context);
-  }
-
   async addPendingShieldNoteToPXE(
     contract: TokenBlacklistContract,
     recipient: AztecAddress,