@aztec/sequencer-client 0.1.0-alpha11

package/src/block_builder/types.ts

@@ -0,0 +1,16 @@
+import { AppendOnlyTreeSnapshot, BaseOrMergeRollupPublicInputs, RootRollupPublicInputs } from '@aztec/circuits.js';
+
+/**
+ * Type to assert that only the correct trees are checked when validating rollup tree outputs.
+ */
+export type AllowedTreeNames<T extends BaseOrMergeRollupPublicInputs | RootRollupPublicInputs> =
+  T extends RootRollupPublicInputs
+    ? 'PrivateData' | 'Contract' | 'Nullifier' | 'L1ToL2Message'
+    : 'PrivateData' | 'Contract' | 'Nullifier';
+
+/**
+ * Type to assert the correct object field is indexed when validating rollup tree outputs.
+ */
+export type OutputWithTreeSnapshot<T extends BaseOrMergeRollupPublicInputs | RootRollupPublicInputs> = {
+  [K in `end${AllowedTreeNames<T>}TreeSnapshot`]: AppendOnlyTreeSnapshot;
+};

package/src/client/index.ts

@@ -0,0 +1 @@
+export * from './sequencer-client.js';

package/src/client/sequencer-client.ts

@@ -0,0 +1,79 @@
+import { P2P } from '@aztec/p2p';
+import { WorldStateSynchroniser } from '@aztec/world-state';
+
+import { ContractDataSource, L1ToL2MessageSource, L2BlockSource } from '@aztec/types';
+import { SoloBlockBuilder } from '../block_builder/solo_block_builder.js';
+import { SequencerClientConfig } from '../config.js';
+import { getL1Publisher, getVerificationKeys, Sequencer } from '../index.js';
+import { EmptyRollupProver } from '../prover/empty.js';
+import { PublicProcessorFactory } from '../sequencer/public_processor.js';
+import { WasmRollupCircuitSimulator } from '../simulator/rollup.js';
+import { getGlobalVariableBuilder } from '../global_variable_builder/index.js';
+
+/**
+ * Encapsulates the full sequencer and publisher.
+ */
+export class SequencerClient {
+  constructor(private sequencer: Sequencer) {}
+
+  /**
+   * Initializes and starts a new instance.
+   * @param config - Configuration for the sequencer, publisher, and L1 tx sender.
+   * @param p2pClient - P2P client that provides the txs to be sequenced.
+   * @param worldStateSynchroniser - Provides access to world state.
+   * @param contractDataSource - Provides access to contract bytecode for public executions.
+   * @param l2BlockSource - Provides information about the previously published blocks.
+   * @param l1ToL2MessageSource - Provides access to L1 to L2 messages.
+   * @returns A new running instance.
+   */
+  public static async new(
+    config: SequencerClientConfig,
+    p2pClient: P2P,
+    worldStateSynchroniser: WorldStateSynchroniser,
+    contractDataSource: ContractDataSource,
+    l2BlockSource: L2BlockSource,
+    l1ToL2MessageSource: L1ToL2MessageSource,
+  ) {
+    const publisher = getL1Publisher(config);
+    const globalsBuilder = getGlobalVariableBuilder(config);
+    const merkleTreeDb = worldStateSynchroniser.getLatest();
+
+    const blockBuilder = new SoloBlockBuilder(
+      merkleTreeDb,
+      getVerificationKeys(),
+      await WasmRollupCircuitSimulator.new(),
+      new EmptyRollupProver(),
+    );
+
+    const publicProcessorFactory = new PublicProcessorFactory(merkleTreeDb, contractDataSource, l1ToL2MessageSource);
+
+    const sequencer = new Sequencer(
+      publisher,
+      globalsBuilder,
+      p2pClient,
+      worldStateSynchroniser,
+      blockBuilder,
+      l2BlockSource,
+      l1ToL2MessageSource,
+      publicProcessorFactory,
+      config,
+    );
+
+    await sequencer.start();
+    return new SequencerClient(sequencer);
+  }
+
+  /**
+   * Stops the sequencer from processing new txs.
+   */
+  public async stop() {
+    await this.sequencer.stop();
+  }
+
+  /**
+   * Restarts the sequencer after being stopped.
+   */
+  public restart() {
+    this.sequencer.restart();
+  }
+}

package/src/config.ts

@@ -0,0 +1,48 @@
+import { SequencerConfig } from './sequencer/config.js';
+import { PublisherConfig, TxSenderConfig } from './publisher/config.js';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { GlobalReaderConfig } from './global_variable_builder/index.js';
+
+/**
+ * Configuration settings for the SequencerClient.
+ */
+export type SequencerClientConfig = PublisherConfig & TxSenderConfig & SequencerConfig & GlobalReaderConfig;
+
+/**
+ * Creates an instance of SequencerClientConfig out of environment variables using sensible defaults for integration testing if not set.
+ */
+export function getConfigEnvVars(): SequencerClientConfig {
+  const {
+    SEQ_PUBLISHER_PRIVATE_KEY,
+    ETHEREUM_HOST,
+    CHAIN_ID,
+    VERSION,
+    API_KEY,
+    SEQ_REQUIRED_CONFS,
+    SEQ_RETRY_INTERVAL,
+    SEQ_TX_POLLING_INTERVAL,
+    SEQ_MAX_TX_PER_BLOCK,
+    SEQ_MIN_TX_PER_BLOCK,
+    ROLLUP_CONTRACT_ADDRESS,
+    INBOX_CONTRACT_ADDRESS,
+    CONTRACT_DEPLOYMENT_EMITTER_ADDRESS,
+  } = process.env;
+
+  return {
+    rpcUrl: ETHEREUM_HOST ? ETHEREUM_HOST : '',
+    chainId: CHAIN_ID ? +CHAIN_ID : 31337, // 31337 is the default chain id for anvil
+    version: VERSION ? +VERSION : 1, // 1 is our default version
+    apiKey: API_KEY,
+    requiredConfirmations: SEQ_REQUIRED_CONFS ? +SEQ_REQUIRED_CONFS : 1,
+    retryIntervalMs: SEQ_RETRY_INTERVAL ? +SEQ_RETRY_INTERVAL : 1_000,
+    transactionPollingInterval: SEQ_TX_POLLING_INTERVAL ? +SEQ_TX_POLLING_INTERVAL : 1_000,
+    rollupContract: ROLLUP_CONTRACT_ADDRESS ? EthAddress.fromString(ROLLUP_CONTRACT_ADDRESS) : EthAddress.ZERO,
+    inboxContract: INBOX_CONTRACT_ADDRESS ? EthAddress.fromString(INBOX_CONTRACT_ADDRESS) : EthAddress.ZERO,
+    contractDeploymentEmitterContract: CONTRACT_DEPLOYMENT_EMITTER_ADDRESS
+      ? EthAddress.fromString(CONTRACT_DEPLOYMENT_EMITTER_ADDRESS)
+      : EthAddress.ZERO,
+    publisherPrivateKey: Buffer.from(SEQ_PUBLISHER_PRIVATE_KEY || '', 'hex'),
+    maxTxsPerBlock: SEQ_MAX_TX_PER_BLOCK ? +SEQ_MAX_TX_PER_BLOCK : 32,
+    minTxsPerBlock: SEQ_MIN_TX_PER_BLOCK ? +SEQ_MIN_TX_PER_BLOCK : 1,
+  };
+}

package/src/global_variable_builder/config.ts

@@ -0,0 +1,19 @@
+import { EthAddress } from '@aztec/circuits.js';
+
+/**
+ * Configuration of the L1GlobalReader.
+ */
+export interface GlobalReaderConfig {
+  /**
+   * Rollup contract address.
+   */
+  rollupContract: EthAddress;
+  /**
+   * The RPC Url of the ethereum host.
+   */
+  rpcUrl: string;
+  /**
+   * The API key of the ethereum host.
+   */
+  apiKey?: string;
+}

package/src/global_variable_builder/global_builder.ts

@@ -0,0 +1,43 @@
+import { Fr, GlobalVariables } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+/**
+ * Reads values from L1 state that is used for the global values.
+ */
+export interface L1GlobalReader {
+  getLastTimestamp(): Promise<bigint>;
+  getVersion(): Promise<bigint>;
+  getChainId(): Promise<bigint>;
+}
+
+/**
+ * Builds global variables from L1 state.
+ */
+export interface GlobalVariableBuilder {
+  buildGlobalVariables(blockNumber: Fr): Promise<GlobalVariables>;
+}
+
+/**
+ * Simple implementation of a builder that uses the minimum time possible for the global variables.
+ */
+export class SimpleGlobalVariableBuilder implements GlobalVariableBuilder {
+  private log = createDebugLogger('aztec:sequencer:simple_global_variable_builder');
+  constructor(private readonly reader: L1GlobalReader) {}
+
+  /**
+   * Simple builder of global variables that use the minimum time possible.
+   * @param blockNumber - The block number to build global variables for.
+   * @returns The global variables for the given block number.
+   */
+  public async buildGlobalVariables(blockNumber: Fr): Promise<GlobalVariables> {
+    const lastTimestamp = new Fr(await this.reader.getLastTimestamp());
+    const version = new Fr(await this.reader.getVersion());
+    const chainId = new Fr(await this.reader.getChainId());
+
+    this.log(
+      `Built global variables for block ${blockNumber}: (${chainId}, ${version}, ${blockNumber}, ${lastTimestamp})`,
+    );
+
+    return new GlobalVariables(chainId, version, blockNumber, lastTimestamp);
+  }
+}

package/src/global_variable_builder/index.ts

@@ -0,0 +1,15 @@
+import { GlobalReaderConfig } from './config.js';
+import { GlobalVariableBuilder, SimpleGlobalVariableBuilder } from './global_builder.js';
+import { ViemReader } from './viem-reader.js';
+
+export { SimpleGlobalVariableBuilder } from './global_builder.js';
+export { GlobalReaderConfig } from './config.js';
+
+/**
+ * Returns a new instance of the global variable builder.
+ * @param config - Configuration to initialize the builder.
+ * @returns A new instance of the global variable builder.
+ */
+export function getGlobalVariableBuilder(config: GlobalReaderConfig): GlobalVariableBuilder {
+  return new SimpleGlobalVariableBuilder(new ViemReader(config));
+}

package/src/global_variable_builder/viem-reader.ts

@@ -0,0 +1,63 @@
+import { createEthereumChain } from '@aztec/ethereum';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import {
+  GetContractReturnType,
+  PublicClient,
+  HttpTransport,
+  createPublicClient,
+  http,
+  getContract,
+  getAddress,
+} from 'viem';
+import * as chains from 'viem/chains';
+import { GlobalReaderConfig } from './config.js';
+import { L1GlobalReader } from './global_builder.js';
+
+/**
+ * Reads values from L1 state using viem.
+ */
+export class ViemReader implements L1GlobalReader {
+  private rollupContract: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, chains.Chain>>;
+  private publicClient: PublicClient<HttpTransport, chains.Chain>;
+
+  constructor(config: GlobalReaderConfig) {
+    const { rpcUrl, apiKey, rollupContract: rollupContractAddress } = config;
+
+    const chain = createEthereumChain(rpcUrl, apiKey);
+
+    this.publicClient = createPublicClient({
+      chain: chain.chainInfo,
+      transport: http(chain.rpcUrl),
+    });
+
+    this.rollupContract = getContract({
+      address: getAddress(rollupContractAddress.toString()),
+      abi: RollupAbi,
+      publicClient: this.publicClient,
+    });
+  }
+
+  /**
+   * Fetches the last timestamp that a block was processed by the contract.
+   * @returns The last timestamp that a block was processed by the contract.
+   */
+  public async getLastTimestamp(): Promise<bigint> {
+    return BigInt(await this.rollupContract.read.lastBlockTs());
+  }
+
+  /**
+   * Fetches the version of the rollup contract.
+   * @returns The version of the rollup contract.
+   */
+  public async getVersion(): Promise<bigint> {
+    return BigInt(await this.rollupContract.read.VERSION());
+  }
+
+  /**
+   * Gets the chain id.
+   * @returns The chain id.
+   */
+  public async getChainId(): Promise<bigint> {
+    return await Promise.resolve(BigInt(this.publicClient.chain.id));
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+export * from './sequencer/index.js';
+export * from './config.js';
+export * from './publisher/index.js';
+export * from './client/index.js';
+export * from './mocks/tx.js';
+export * from './mocks/verification_keys.js';
+
+// Used by publisher test in e2e
+export { WasmRollupCircuitSimulator } from './simulator/rollup.js';
+export { EmptyRollupProver } from './prover/empty.js';
+export { SoloBlockBuilder } from './block_builder/solo_block_builder.js';
+export { makeProcessedTx, makeEmptyProcessedTx } from './sequencer/processed_tx.js';

package/src/mocks/tx.ts

@@ -0,0 +1,26 @@
+import { KERNEL_PUBLIC_CALL_STACK_LENGTH, makeEmptyProof } from '@aztec/circuits.js';
+import { makeKernelPublicInputs, makePublicCallRequest } from '@aztec/circuits.js/factories';
+import { FunctionL2Logs, Tx, TxL2Logs } from '@aztec/types';
+import times from 'lodash.times';
+
+/**
+ * Testing utility to create empty logs composed from a single empty log.
+ */
+export function makeEmptyLogs(): TxL2Logs {
+  const functionLogs = [new FunctionL2Logs([Buffer.alloc(0)])];
+  return new TxL2Logs(functionLogs);
+}
+
+/**
+ * Testing utility to create a tx with gibberish kernel circuit output, random logs, and an empty proof.
+ */
+export function makeTx(seed = 0) {
+  return new Tx(
+    makeKernelPublicInputs(seed),
+    makeEmptyProof(),
+    TxL2Logs.random(2, 3),
+    TxL2Logs.random(3, 0),
+    [],
+    times(KERNEL_PUBLIC_CALL_STACK_LENGTH, makePublicCallRequest),
+  );
+}

package/src/mocks/verification_keys.ts

@@ -0,0 +1,36 @@
+import { VerificationKey } from '@aztec/circuits.js';
+
+/**
+ * Well-known verification keys.
+ */
+export interface VerificationKeys {
+  /**
+   * Verification key for the default public kernel circuit.
+   */
+  publicKernelCircuit: VerificationKey;
+  /**
+   * Verification key for the default private kernel circuit.
+   */
+  privateKernelCircuit: VerificationKey;
+  /**
+   * Verification key for the default base rollup circuit.
+   */
+  baseRollupCircuit: VerificationKey;
+  /**
+   * Verification key for the default merge rollup circuit.
+   */
+  mergeRollupCircuit: VerificationKey;
+}
+
+/**
+ * Returns mock verification keys for each well known circuit.
+ * @returns A VerificationKeys object with fake values.
+ */
+export function getVerificationKeys(): VerificationKeys {
+  return {
+    privateKernelCircuit: VerificationKey.makeFake(),
+    baseRollupCircuit: VerificationKey.makeFake(),
+    mergeRollupCircuit: VerificationKey.makeFake(),
+    publicKernelCircuit: VerificationKey.makeFake(),
+  };
+}

package/src/prover/empty.ts

@@ -0,0 +1,73 @@
+/* eslint-disable require-await */
+import {
+  AggregationObject,
+  BaseOrMergeRollupPublicInputs,
+  BaseRollupInputs,
+  MergeRollupInputs,
+  Proof,
+  PublicCircuitPublicInputs,
+  PublicKernelPublicInputs,
+  RootRollupInputs,
+  RootRollupPublicInputs,
+} from '@aztec/circuits.js';
+import { PublicProver, RollupProver } from './index.js';
+
+const EMPTY_PROOF_SIZE = 42;
+
+// TODO: Silently modifying one of the inputs to inject the aggregation object is horrible.
+// We should rethink these interfaces.
+
+/**
+ * Prover implementation that returns empty proofs and overrides aggregation objects.
+ */
+export class EmptyRollupProver implements RollupProver {
+  /**
+   * Creates an empty proof for the given input.
+   * @param _input - Input to the circuit.
+   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
+   */
+  async getBaseRollupProof(_input: BaseRollupInputs, publicInputs: BaseOrMergeRollupPublicInputs): Promise<Proof> {
+    publicInputs.endAggregationObject = AggregationObject.makeFake();
+    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
+  }
+
+  /**
+   * Creates an empty proof for the given input.
+   * @param _input - Input to the circuit.
+   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
+   */
+  async getMergeRollupProof(_input: MergeRollupInputs, publicInputs: BaseOrMergeRollupPublicInputs): Promise<Proof> {
+    publicInputs.endAggregationObject = AggregationObject.makeFake();
+    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
+  }
+  /**
+   * Creates an empty proof for the given input.
+   * @param _input - Input to the circuit.
+   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
+   */
+  async getRootRollupProof(_input: RootRollupInputs, publicInputs: RootRollupPublicInputs): Promise<Proof> {
+    publicInputs.endAggregationObject = AggregationObject.makeFake();
+    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
+  }
+}
+
+/**
+ * Prover implementation that returns empty proofs.
+ */
+export class EmptyPublicProver implements PublicProver {
+  /**
+   * Creates an empty proof for the given input.
+   * @param _publicInputs - Public inputs obtained via simulation.
+   */
+  async getPublicCircuitProof(_publicInputs: PublicCircuitPublicInputs): Promise<Proof> {
+    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
+  }
+
+  /**
+   * Creates an empty proof for the given input.
+   * @param _publicInputs - Public inputs obtained via simulation.
+   */
+  async getPublicKernelCircuitProof(_publicInputs: PublicKernelPublicInputs): Promise<Proof> {
+    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
+  }
+}

package/src/prover/index.ts

@@ -0,0 +1,27 @@
+import {
+  BaseOrMergeRollupPublicInputs,
+  BaseRollupInputs,
+  MergeRollupInputs,
+  Proof,
+  PublicCircuitPublicInputs,
+  PublicKernelPublicInputs,
+  RootRollupInputs,
+  RootRollupPublicInputs,
+} from '@aztec/circuits.js';
+
+/**
+ * Generates proofs for the base, merge, and root rollup circuits.
+ */
+export interface RollupProver {
+  getBaseRollupProof(input: BaseRollupInputs, publicInputs: BaseOrMergeRollupPublicInputs): Promise<Proof>;
+  getMergeRollupProof(input: MergeRollupInputs, publicInputs: BaseOrMergeRollupPublicInputs): Promise<Proof>;
+  getRootRollupProof(input: RootRollupInputs, publicInputs: RootRollupPublicInputs): Promise<Proof>;
+}
+
+/**
+ * Generates proofs for the public and public kernel circuits.
+ */
+export interface PublicProver {
+  getPublicCircuitProof(publicInputs: PublicCircuitPublicInputs): Promise<Proof>;
+  getPublicKernelCircuitProof(publicInputs: PublicKernelPublicInputs): Promise<Proof>;
+}

package/src/publisher/config.ts

@@ -0,0 +1,36 @@
+import { L1Addresses } from '@aztec/types';
+
+/**
+ * The configuration of the rollup transaction publisher.
+ */
+export interface TxSenderConfig extends L1Addresses {
+  /**
+   * The private key to be used by the publisher.
+   */
+  publisherPrivateKey: Buffer;
+
+  /**
+   * The RPC Url of the ethereum host.
+   */
+  rpcUrl: string;
+
+  /**
+   * The API key of the ethereum host.
+   */
+  apiKey?: string;
+
+  /**
+   * The number of confirmations required.
+   */
+  requiredConfirmations: number;
+}
+
+/**
+ * Configuration of the L1Publisher.
+ */
+export interface PublisherConfig {
+  /**
+   * The interval to wait between publish retries.
+   */
+  retryIntervalMs: number;
+}

package/src/publisher/index.ts

@@ -0,0 +1,14 @@
+import { PublisherConfig, TxSenderConfig } from './config.js';
+import { L1Publisher } from './l1-publisher.js';
+import { ViemTxSender } from './viem-tx-sender.js';
+
+export { L1Publisher } from './l1-publisher.js';
+export { PublisherConfig } from './config.js';
+
+/**
+ * Returns a new instance of the L1Publisher.
+ * @param config - Configuration to initialize the new instance.
+ */
+export function getL1Publisher(config: PublisherConfig & TxSenderConfig): L1Publisher {
+  return new L1Publisher(new ViemTxSender(config), config);
+}

package/src/publisher/l1-publisher.test.ts

@@ -0,0 +1,77 @@
+import { L2Block } from '@aztec/types';
+import { mock, MockProxy } from 'jest-mock-extended';
+import { sleep } from '../utils.js';
+import { L1Publisher, L1PublisherTxSender, MinimalTransactionReceipt } from './l1-publisher.js';
+
+describe('L1Publisher', () => {
+  let txSender: MockProxy<L1PublisherTxSender>;
+  let txHash: string;
+  let txReceipt: MinimalTransactionReceipt;
+  let l2Block: L2Block;
+  let l2Inputs: Buffer;
+  let l2Proof: Buffer;
+  let publisher: L1Publisher;
+
+  beforeEach(() => {
+    l2Block = L2Block.random(42);
+    l2Inputs = l2Block.encode();
+    l2Proof = Buffer.alloc(0);
+
+    txSender = mock<L1PublisherTxSender>();
+    txHash = `0x${Buffer.from('txHash').toString('hex')}`; // random tx hash
+    txReceipt = { transactionHash: txHash, status: true };
+    txSender.sendProcessTx.mockResolvedValueOnce(txHash);
+    txSender.getTransactionReceipt.mockResolvedValueOnce(txReceipt);
+
+    publisher = new L1Publisher(txSender, { retryIntervalMs: 1 });
+  });
+
+  it('publishes l2 block to l1', async () => {
+    const result = await publisher.processL2Block(l2Block);
+
+    expect(result).toEqual(true);
+    expect(txSender.sendProcessTx).toHaveBeenCalledWith({ proof: l2Proof, inputs: l2Inputs });
+    expect(txSender.getTransactionReceipt).toHaveBeenCalledWith(txHash);
+  });
+
+  it('does not retry if sending a tx fails', async () => {
+    txSender.sendProcessTx.mockReset().mockRejectedValueOnce(new Error()).mockResolvedValueOnce(txHash);
+
+    const result = await publisher.processL2Block(l2Block);
+
+    expect(result).toEqual(false);
+    expect(txSender.sendProcessTx).toHaveBeenCalledTimes(1);
+  });
+
+  it('retries if fetching the receipt fails', async () => {
+    txSender.getTransactionReceipt.mockReset().mockRejectedValueOnce(new Error()).mockResolvedValueOnce(txReceipt);
+
+    const result = await publisher.processL2Block(l2Block);
+
+    expect(result).toEqual(true);
+    expect(txSender.getTransactionReceipt).toHaveBeenCalledTimes(2);
+  });
+
+  it('returns false if tx reverts', async () => {
+    txSender.getTransactionReceipt.mockReset().mockResolvedValueOnce({ ...txReceipt, status: false });
+
+    const result = await publisher.processL2Block(l2Block);
+
+    expect(result).toEqual(false);
+  });
+
+  it('returns false if interrupted', async () => {
+    txSender.sendProcessTx.mockReset().mockImplementationOnce(() => sleep(10, txHash));
+
+    const resultPromise = publisher.processL2Block(l2Block);
+    publisher.interrupt();
+    const result = await resultPromise;
+
+    expect(result).toEqual(false);
+    expect(txSender.getTransactionReceipt).not.toHaveBeenCalled();
+  });
+
+  it.skip('waits for fee distributor balance', () => {});
+
+  it.skip('fails if contract is changed underfoot', () => {});
+});