@aztec/sequencer-client 0.0.1-commit.733c4a3 → 0.0.1-commit.7689c7f

package/src/sequencer/automine/README.md

@@ -0,0 +1,46 @@
+# AutomineSequencer
+
+A minimal, deterministic, queue-driven sequencer for e2e tests that do not exercise block-building or consensus mechanics (e.g. `e2e_token`, `e2e_amm`, `e2e_authwit`).
+
+## When to use it
+
+Use `AutomineSequencer` (via `AUTOMINE_E2E_OPTS`) for single-sequencer tests that care about contract logic, not about proposer selection, attestations, pipelining, or multi-validator coordination. It bypasses all of that machinery.
+
+Use the production `Sequencer` (via `PIPELINING_SETUP_OPTS` or the default) for tests that explicitly exercise consensus, validator rotation, P2P gossip, slashing, or multi-node behavior.
+
+**Requirement**: the deployed rollup must have `aztecTargetCommitteeSize == 0`. This causes `Rollup.verifyProposer` / `verifyAttestations` on L1 to short-circuit and accept an empty `CommitteeAttestationsAndSigners`, which is what `AutomineSequencer` always sends.
+
+## What it omits
+
+Compared to the production `Sequencer`:
+
+- No proposer-turn check (single sequencer, always proposes).
+- No sync check, no pipelining, no timetable enforcement.
+- No validator orchestration, attestation collection, or P2P proposal gossip.
+- No slashing, no governance votes, no `SequencerEvents`.
+
+Consumers (archiver, world-state, `EpochTestSettler`) observe L1 and the archiver tip directly rather than listening for sequencer events.
+
+## Serial-queue invariant
+
+Every operation — mempool-driven block builds, explicit empty-block builds, time warps, and reorgs — is serialized through a single `SerialQueue`. They never interleave.
+
+Public entry points:
+
+| Method | Description |
+| --- | --- |
+| `buildIfPending()` | Enqueues a mempool-driven build. Coalesces bursts into one job. |
+| `buildEmptyBlock()` | Enqueues a forced empty-block build. |
+| `warpTo(ts)` / `warpBy(delta)` | Advances L1 time to a slot boundary. |
+| `revertToCheckpoint(n)` | Rolls L1 back to the block that published checkpoint `n`, then resets archiver, world-state, and P2P pool. |
+| `syncPoint()` | Awaits the queue reaching idle. |
+
+## Entry points
+
+**Factory** — `createAutomineSequencer` in `automine_factory.ts` wires up all dependencies (publisher manager, keystore, cheat codes, etc.), starts the `PublisherManager`, and returns an unstarted `AutomineSequencer`. The caller (`AztecNodeService.createAndSync` in `aztec-node/src/aztec-node/server.ts`) invokes `AutomineSequencer.start()` separately. It is called by the full node when `aztecTargetCommitteeSize == 0`.
+
+**Test fixture** — `AUTOMINE_E2E_OPTS` in `end-to-end/src/fixtures/fixtures.ts` is the test-side entry point. Pass it to `setup()` to get a node + `AutomineSequencer` instead of the production sequencer stack.
+
+## Epoch proving caveat
+
+Epoch proving remains manual under `AUTOMINE_E2E_OPTS`. The e2e `setup()` fixture does NOT wire an `EpochTestSettler` — that observer is only attached in `local-network.ts`. Tests that cross epoch boundaries must therefore advance the proven anchor explicitly via `cheatCodes.rollup.markAsProven(...)`. See `e2e_lending_contract.test.ts` (which calls `progressSlots` in `simulators/lending_simulator.ts`) and `e2e_pruned_blocks.test.ts` for real examples.

package/src/sequencer/automine/automine_factory.ts

@@ -0,0 +1,145 @@
+import type { Archiver } from '@aztec/archiver';
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import type { EpochCache } from '@aztec/epoch-cache';
+import { GovernanceProposerContract, type RollupContract } from '@aztec/ethereum/contracts';
+import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
+import { PublisherManager } from '@aztec/ethereum/publisher-manager';
+import { EthCheatCodes } from '@aztec/ethereum/test';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
+import type { Logger } from '@aztec/foundation/log';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { KeystoreManager } from '@aztec/node-keystore';
+import type { P2PClient as ConcreteP2PClient, P2P } from '@aztec/p2p';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ChainConfig } from '@aztec/stdlib/config';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { TelemetryClient } from '@aztec/telemetry-client';
+import { type FullNodeCheckpointsBuilder, NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-client';
+
+import { type SequencerClientConfig, getPublisherConfigFromSequencerConfig } from '../../config.js';
+import type { GlobalVariableBuilder } from '../../global_variable_builder/global_builder.js';
+import { SequencerPublisherFactory } from '../../publisher/sequencer-publisher-factory.js';
+import { AutomineSequencer } from './automine_sequencer.js';
+
+/** Arguments for {@link createAutomineSequencer}. */
+export type CreateAutomineSequencerArgs = {
+  config: SequencerClientConfig & Pick<ChainConfig, 'l1ChainId' | 'rollupAddress'>;
+  l1TxUtils: L1TxUtils[];
+  funderL1TxUtils: L1TxUtils | undefined;
+  publicClient: ViemPublicClient;
+  rollupContract: RollupContract;
+  epochCache: EpochCache;
+  blobClient: BlobClientInterface | undefined;
+  telemetry: TelemetryClient;
+  dateProvider: DateProvider;
+  keyStoreManager: KeystoreManager;
+  validatorClient: ValidatorClient;
+  checkpointsBuilder: FullNodeCheckpointsBuilder;
+  globalVariableBuilder: GlobalVariableBuilder;
+  worldStateSynchronizer: WorldStateSynchronizer;
+  archiver: L2BlockSource &
+    L1ToL2MessageSource &
+    Pick<Archiver, 'rollbackTo' | 'addBlock' | 'addProposedCheckpoint' | 'syncImmediate'>;
+  p2pClient: P2P & Pick<ConcreteP2PClient, 'sync'>;
+  l1Constants: { l1GenesisTime: bigint; slotDuration: number; ethereumSlotDuration: number; rollupManaLimit: number };
+  log: Logger;
+};
+
+/**
+ * Builds an {@link AutomineSequencer} for use in single-sequencer e2e tests.
+ *
+ * Constructs the PublisherManager, GovernanceProposerContract, SequencerPublisherFactory,
+ * looks up the attestor/coinbase/feeRecipient from the keystore, wires EthCheatCodes,
+ * and starts the publisher manager before returning.
+ */
+export async function createAutomineSequencer({
+  config,
+  l1TxUtils,
+  funderL1TxUtils,
+  publicClient,
+  rollupContract,
+  epochCache,
+  blobClient,
+  telemetry,
+  dateProvider,
+  keyStoreManager,
+  validatorClient,
+  checkpointsBuilder,
+  globalVariableBuilder,
+  worldStateSynchronizer,
+  archiver,
+  p2pClient,
+  l1Constants,
+  log,
+}: CreateAutomineSequencerArgs): Promise<AutomineSequencer> {
+  const publisherManager = new PublisherManager(l1TxUtils, getPublisherConfigFromSequencerConfig(config), {
+    bindings: log.getBindings(),
+    funder: funderL1TxUtils,
+  });
+  const governanceProposerContract = new GovernanceProposerContract(
+    publicClient,
+    config.governanceProposerAddress.toString(),
+  );
+  const publisherFactory = new SequencerPublisherFactory(config, {
+    telemetry,
+    blobClient: blobClient!,
+    epochCache,
+    governanceProposerContract,
+    rollupContract,
+    dateProvider,
+    publisherManager,
+    nodeKeyStore: NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager),
+    logger: log,
+  });
+  const attestorAddresses = NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager).getAttesterAddresses();
+  const attestor = attestorAddresses[0];
+  if (!attestor) {
+    throw new Error('AutomineSequencer requires at least one attestor address in the keystore');
+  }
+  const coinbase = validatorClient.getCoinbaseForAttestor(attestor);
+  const feeRecipient = validatorClient.getFeeRecipientForAttestor(attestor);
+  const ethCheatCodes = new EthCheatCodes(config.l1RpcUrls, dateProvider, log.createChild('eth-cheat-codes'));
+
+  // Include the funder's L1TxUtils in the reorg reset list so funding-tx nonces don't
+  // go stale after L1 rollbacks. Dedupe by sender address in case the funder reuses a
+  // publisher's signer.
+  const reorgResetL1TxUtils = (() => {
+    if (!funderL1TxUtils) {
+      return l1TxUtils;
+    }
+    const funderAddress = funderL1TxUtils.getSenderAddress().toString();
+    const alreadyIncluded = l1TxUtils.some(utils => utils.getSenderAddress().toString() === funderAddress);
+    return alreadyIncluded ? l1TxUtils : [...l1TxUtils, funderL1TxUtils];
+  })();
+
+  const automineSequencer = new AutomineSequencer({
+    publisherFactory,
+    checkpointsBuilder,
+    globalsBuilder: globalVariableBuilder,
+    worldState: worldStateSynchronizer,
+    l2BlockSource: archiver,
+    l1ToL2MessageSource: archiver,
+    p2pClient,
+    ethCheatCodes,
+    dateProvider: dateProvider as any, // TestDateProvider; verified at construction in fixture
+    l1Constants: {
+      l1GenesisTime: l1Constants.l1GenesisTime,
+      slotDuration: l1Constants.slotDuration,
+      ethereumSlotDuration: l1Constants.ethereumSlotDuration,
+      rollupManaLimit: l1Constants.rollupManaLimit,
+      epochDuration: config.aztecEpochDuration,
+    },
+    coinbase,
+    feeRecipient,
+    signatureContext: { chainId: config.l1ChainId, rollupAddress: config.rollupAddress },
+    config,
+    archiver,
+    l1TxUtils: reorgResetL1TxUtils,
+    stopExtras: () => publisherManager.stop(),
+    log: log.createChild('automine-sequencer'),
+  });
+
+  await publisherManager.start();
+  return automineSequencer;
+}