@aztec/sequencer-client 0.23.0 → 0.26.1

package/src/block_builder/types.ts

@@ -0,0 +1,8 @@
+/**
+ * Type representing the names of the trees for the base rollup.
+ */
+type BaseTreeNames = 'NoteHashTree' | 'ContractTree' | 'NullifierTree' | 'PublicDataTree';
+/**
+ * Type representing the names of the trees.
+ */
+export type TreeNames = BaseTreeNames | 'L1ToL2MessageTree' | 'Archive';

package/src/client/index.ts

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

package/src/client/sequencer-client.ts

@@ -0,0 +1,97 @@
+import { ContractDataSource, L1ToL2MessageSource, L2BlockSource } from '@aztec/circuit-types';
+import { P2P } from '@aztec/p2p';
+import { WorldStateSynchronizer } from '@aztec/world-state';
+
+import { SoloBlockBuilder } from '../block_builder/solo_block_builder.js';
+import { SequencerClientConfig } from '../config.js';
+import { getGlobalVariableBuilder } from '../global_variable_builder/index.js';
+import { getVerificationKeys } from '../mocks/verification_keys.js';
+import { EmptyRollupProver } from '../prover/empty.js';
+import { getL1Publisher } from '../publisher/index.js';
+import { Sequencer, SequencerConfig } from '../sequencer/index.js';
+import { PublicProcessorFactory } from '../sequencer/public_processor.js';
+import { RealRollupCircuitSimulator } from '../simulator/rollup.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 worldStateSynchronizer - 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,
+    worldStateSynchronizer: WorldStateSynchronizer,
+    contractDataSource: ContractDataSource,
+    l2BlockSource: L2BlockSource,
+    l1ToL2MessageSource: L1ToL2MessageSource,
+  ) {
+    const publisher = getL1Publisher(config);
+    const globalsBuilder = getGlobalVariableBuilder(config);
+    const merkleTreeDb = worldStateSynchronizer.getLatest();
+
+    const blockBuilder = new SoloBlockBuilder(
+      merkleTreeDb,
+      getVerificationKeys(),
+      new RealRollupCircuitSimulator(),
+      new EmptyRollupProver(),
+    );
+
+    const publicProcessorFactory = new PublicProcessorFactory(merkleTreeDb, contractDataSource, l1ToL2MessageSource);
+
+    const sequencer = new Sequencer(
+      publisher,
+      globalsBuilder,
+      p2pClient,
+      worldStateSynchronizer,
+      blockBuilder,
+      l2BlockSource,
+      l1ToL2MessageSource,
+      publicProcessorFactory,
+      config,
+    );
+
+    await sequencer.start();
+    return new SequencerClient(sequencer);
+  }
+
+  /**
+   * Updates sequencer config.
+   * @param config - New parameters.
+   */
+  public updateSequencerConfig(config: SequencerConfig) {
+    this.sequencer.updateConfig(config);
+  }
+
+  /**
+   * 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();
+  }
+
+  get coinbase() {
+    return this.sequencer.coinbase;
+  }
+
+  get feeRecipient() {
+    return this.sequencer.feeRecipient;
+  }
+}

package/src/config.ts

@@ -0,0 +1,86 @@
+import { AztecAddress } from '@aztec/circuits.js';
+import { L1ContractAddresses, NULL_KEY } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+
+import { Hex } from 'viem';
+
+import { GlobalReaderConfig } from './global_variable_builder/index.js';
+import { PublisherConfig, TxSenderConfig } from './publisher/config.js';
+import { SequencerConfig } from './sequencer/config.js';
+
+/** Chain configuration. */
+type ChainConfig = {
+  /** The chain id of the ethereum host. */
+  chainId: number;
+  /** The version of the rollup. */
+  version: number;
+};
+
+/**
+ * Configuration settings for the SequencerClient.
+ */
+export type SequencerClientConfig = PublisherConfig &
+  TxSenderConfig &
+  SequencerConfig &
+  GlobalReaderConfig &
+  ChainConfig;
+
+/**
+ * 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_CONFIRMATIONS,
+    SEQ_PUBLISH_RETRY_INTERVAL_MS,
+    SEQ_TX_POLLING_INTERVAL_MS,
+    SEQ_MAX_TX_PER_BLOCK,
+    SEQ_MIN_TX_PER_BLOCK,
+    AVAILABILITY_ORACLE_CONTRACT_ADDRESS,
+    ROLLUP_CONTRACT_ADDRESS,
+    REGISTRY_CONTRACT_ADDRESS,
+    INBOX_CONTRACT_ADDRESS,
+    CONTRACT_DEPLOYMENT_EMITTER_ADDRESS,
+    OUTBOX_CONTRACT_ADDRESS,
+    COINBASE,
+    FEE_RECIPIENT,
+  } = process.env;
+
+  const publisherPrivateKey: Hex = SEQ_PUBLISHER_PRIVATE_KEY
+    ? `0x${SEQ_PUBLISHER_PRIVATE_KEY.replace('0x', '')}`
+    : NULL_KEY;
+  // Populate the relevant addresses for use by the sequencer
+  const addresses: L1ContractAddresses = {
+    availabilityOracleAddress: AVAILABILITY_ORACLE_CONTRACT_ADDRESS
+      ? EthAddress.fromString(AVAILABILITY_ORACLE_CONTRACT_ADDRESS)
+      : EthAddress.ZERO,
+    rollupAddress: ROLLUP_CONTRACT_ADDRESS ? EthAddress.fromString(ROLLUP_CONTRACT_ADDRESS) : EthAddress.ZERO,
+    registryAddress: REGISTRY_CONTRACT_ADDRESS ? EthAddress.fromString(REGISTRY_CONTRACT_ADDRESS) : EthAddress.ZERO,
+    inboxAddress: INBOX_CONTRACT_ADDRESS ? EthAddress.fromString(INBOX_CONTRACT_ADDRESS) : EthAddress.ZERO,
+    outboxAddress: OUTBOX_CONTRACT_ADDRESS ? EthAddress.fromString(OUTBOX_CONTRACT_ADDRESS) : EthAddress.ZERO,
+    contractDeploymentEmitterAddress: CONTRACT_DEPLOYMENT_EMITTER_ADDRESS
+      ? EthAddress.fromString(CONTRACT_DEPLOYMENT_EMITTER_ADDRESS)
+      : EthAddress.ZERO,
+  };
+
+  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_CONFIRMATIONS ? +SEQ_REQUIRED_CONFIRMATIONS : 1,
+    l1BlockPublishRetryIntervalMS: SEQ_PUBLISH_RETRY_INTERVAL_MS ? +SEQ_PUBLISH_RETRY_INTERVAL_MS : 1_000,
+    transactionPollingIntervalMS: SEQ_TX_POLLING_INTERVAL_MS ? +SEQ_TX_POLLING_INTERVAL_MS : 1_000,
+    l1Contracts: addresses,
+    publisherPrivateKey,
+    maxTxsPerBlock: SEQ_MAX_TX_PER_BLOCK ? +SEQ_MAX_TX_PER_BLOCK : 32,
+    minTxsPerBlock: SEQ_MIN_TX_PER_BLOCK ? +SEQ_MIN_TX_PER_BLOCK : 1,
+    // TODO: undefined should not be allowed for the following 2 values in PROD
+    coinbase: COINBASE ? EthAddress.fromString(COINBASE) : undefined,
+    feeRecipient: FEE_RECIPIENT ? AztecAddress.fromString(FEE_RECIPIENT) : undefined,
+  };
+}

package/src/global_variable_builder/config.ts

@@ -0,0 +1,20 @@
+import { L1ContractAddresses } from '@aztec/ethereum';
+
+/**
+ * Configuration of the L1GlobalReader.
+ */
+export interface GlobalReaderConfig {
+  /**
+   * The RPC Url of the ethereum host.
+   */
+  rpcUrl: string;
+  /**
+   * The API key of the ethereum host.
+   */
+  apiKey?: string;
+
+  /**
+   * The deployed l1 contract addresses
+   */
+  l1Contracts: L1ContractAddresses;
+}

package/src/global_variable_builder/global_builder.ts

@@ -0,0 +1,95 @@
+import { AztecAddress, EthAddress, GlobalVariables } from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+/**
+ * Reads values from L1 state that is used for the global values.
+ */
+export interface L1GlobalReader {
+  /**
+   * Fetches the last timestamp that a block was processed by the contract.
+   * @returns The last timestamp that a block was processed by the contract.
+   */
+  getLastTimestamp(): Promise<bigint>;
+  /**
+   * Fetches the version of the rollup contract.
+   * @returns The version of the rollup contract.
+   */
+  getVersion(): Promise<bigint>;
+  /**
+   * Gets the chain id.
+   * @returns The chain id.
+   */
+  getChainId(): Promise<bigint>;
+
+  /**
+   * Gets the current L1 time.
+   * @returns The current L1 time.
+   */
+  getL1CurrentTime(): Promise<bigint>;
+
+  /**
+   * Gets the last time L2 was warped as tracked by the rollup contract.
+   * @returns The warped time.
+   */
+  getLastWarpedBlockTs(): Promise<bigint>;
+}
+
+/**
+ * Builds global variables from L1 state.
+ */
+export interface GlobalVariableBuilder {
+  /**
+   * Builds global variables.
+   * @param blockNumber - The block number to build global variables for.
+   * @param coinbase - The address to receive block reward.
+   * @param feeRecipient - The address to receive fees.
+   * @returns The global variables for the given block number.
+   */
+  buildGlobalVariables(blockNumber: Fr, coinbase: EthAddress, feeRecipient: AztecAddress): Promise<GlobalVariables>;
+}
+
+/**
+ * Simple test implementation of a builder that uses the minimum time possible for the global variables.
+ * Also uses a "hack" to make use of the warp cheatcode that manipulates time on Aztec.
+ */
+export class SimpleTestGlobalVariableBuilder implements GlobalVariableBuilder {
+  private log = createDebugLogger('aztec:sequencer:simple_test_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.
+   * @param coinbase - The address to receive block reward.
+   * @param feeRecipient - The address to receive fees.
+   * @returns The global variables for the given block number.
+   */
+  public async buildGlobalVariables(
+    blockNumber: Fr,
+    coinbase: EthAddress,
+    feeRecipient: AztecAddress,
+  ): Promise<GlobalVariables> {
+    let lastTimestamp = new Fr(await this.reader.getLastTimestamp());
+    const version = new Fr(await this.reader.getVersion());
+    const chainId = new Fr(await this.reader.getChainId());
+
+    // TODO(rahul) - fix #1614. By using the cheatcode warp to modify L2 time,
+    // txs in the next rollup would have same time as the txs in the current rollup (i.e. the rollup that was warped).
+    // So, for now you check if L2 time was warped and if so, serve warpedTime + 1 to txs in the new rollup.
+    // Check if L2 time was warped in the last rollup by checking if current L1 time is same as the warpedTime (stored on the rollup contract).
+    // more details at https://github.com/AztecProtocol/aztec-packages/issues/1614
+
+    const currTimestamp = await this.reader.getL1CurrentTime();
+    const rollupWarpTime = await this.reader.getLastWarpedBlockTs();
+    const isLastBlockWarped = rollupWarpTime === currTimestamp;
+    if (isLastBlockWarped) {
+      lastTimestamp = new Fr(lastTimestamp.value + 1n);
+    }
+
+    this.log(
+      `Built global variables for block ${blockNumber}: (${chainId}, ${version}, ${blockNumber}, ${lastTimestamp}, ${coinbase}, ${feeRecipient})`,
+    );
+
+    return new GlobalVariables(chainId, version, blockNumber, lastTimestamp, coinbase, feeRecipient);
+  }
+}

package/src/global_variable_builder/index.ts

@@ -0,0 +1,16 @@
+import { GlobalReaderConfig } from './config.js';
+import { GlobalVariableBuilder, SimpleTestGlobalVariableBuilder } from './global_builder.js';
+import { ViemReader } from './viem-reader.js';
+
+export { SimpleTestGlobalVariableBuilder as SimpleGlobalVariableBuilder } from './global_builder.js';
+export { GlobalReaderConfig } from './config.js';
+export { GlobalVariableBuilder } from './global_builder.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 SimpleTestGlobalVariableBuilder(new ViemReader(config));
+}

package/src/global_variable_builder/viem-reader.ts

@@ -0,0 +1,61 @@
+import { createEthereumChain } from '@aztec/ethereum';
+import { RollupAbi } from '@aztec/l1-artifacts';
+
+import {
+  GetContractReturnType,
+  HttpTransport,
+  PublicClient,
+  createPublicClient,
+  getAddress,
+  getContract,
+  http,
+} 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, l1Contracts } = config;
+
+    const chain = createEthereumChain(rpcUrl, apiKey);
+
+    this.publicClient = createPublicClient({
+      chain: chain.chainInfo,
+      transport: http(chain.rpcUrl),
+    });
+
+    this.rollupContract = getContract({
+      address: getAddress(l1Contracts.rollupAddress.toString()),
+      abi: RollupAbi,
+      client: this.publicClient,
+    });
+  }
+
+  public async getLastTimestamp(): Promise<bigint> {
+    return BigInt(await this.rollupContract.read.lastBlockTs());
+  }
+
+  public async getVersion(): Promise<bigint> {
+    return BigInt(await this.rollupContract.read.VERSION());
+  }
+
+  public async getChainId(): Promise<bigint> {
+    return await Promise.resolve(BigInt(this.publicClient.chain.id));
+  }
+
+  public async getL1CurrentTime(): Promise<bigint> {
+    return await Promise.resolve((await this.publicClient.getBlock()).timestamp);
+  }
+
+  public async getLastWarpedBlockTs(): Promise<bigint> {
+    return BigInt(await this.rollupContract.read.lastWarpedBlockTs());
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export * from './sequencer/index.js';
+export * from './config.js';
+export * from './publisher/index.js';
+export * from './client/index.js';
+export * from './mocks/verification_keys.js';
+
+// Used by the node to simulate public parts of transactions. Should these be moved to a shared library?
+export * from './sequencer/public_processor.js';
+export * from './global_variable_builder/index.js';
+
+// Used by publisher test in e2e
+export { RealRollupCircuitSimulator } 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/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,74 @@
+/* eslint-disable require-await */
+import {
+  AggregationObject,
+  BaseOrMergeRollupPublicInputs,
+  BaseRollupInputs,
+  MergeRollupInputs,
+  Proof,
+  PublicCircuitPublicInputs,
+  PublicKernelCircuitPublicInputs,
+  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.aggregationObject = 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.aggregationObject = 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.aggregationObject = 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: PublicKernelCircuitPublicInputs): Promise<Proof> {
+    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
+  }
+}

package/src/prover/index.ts

@@ -0,0 +1,53 @@
+import {
+  BaseOrMergeRollupPublicInputs,
+  BaseRollupInputs,
+  MergeRollupInputs,
+  Proof,
+  PublicCircuitPublicInputs,
+  PublicKernelCircuitPublicInputs,
+  RootRollupInputs,
+  RootRollupPublicInputs,
+} from '@aztec/circuits.js';
+
+/**
+ * Generates proofs for the base, merge, and root rollup circuits.
+ */
+export interface RollupProver {
+  /**
+   * Creates a 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.
+   */
+  getBaseRollupProof(input: BaseRollupInputs, publicInputs: BaseOrMergeRollupPublicInputs): Promise<Proof>;
+
+  /**
+   * Creates a 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.
+   */
+  getMergeRollupProof(input: MergeRollupInputs, publicInputs: BaseOrMergeRollupPublicInputs): Promise<Proof>;
+
+  /**
+   * Creates a 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.
+   */
+  getRootRollupProof(input: RootRollupInputs, publicInputs: RootRollupPublicInputs): Promise<Proof>;
+}
+
+/**
+ * Generates proofs for the public and public kernel circuits.
+ */
+export interface PublicProver {
+  /**
+   * Creates a proof for the given input.
+   * @param publicInputs - Public inputs obtained via simulation.
+   */
+  getPublicCircuitProof(publicInputs: PublicCircuitPublicInputs): Promise<Proof>;
+
+  /**
+   * Creates a proof for the given input.
+   * @param publicInputs - Public inputs obtained via simulation.
+   */
+  getPublicKernelCircuitProof(publicInputs: PublicKernelCircuitPublicInputs): Promise<Proof>;
+}

package/src/publisher/config.ts

@@ -0,0 +1,41 @@
+import { L1ContractAddresses } from '@aztec/ethereum';
+
+/**
+ * The configuration of the rollup transaction publisher.
+ */
+export interface TxSenderConfig {
+  /**
+   * The private key to be used by the publisher.
+   */
+  publisherPrivateKey: `0x${string}`;
+
+  /**
+   * 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;
+
+  /**
+   * The deployed l1 contract addresses
+   */
+  l1Contracts: L1ContractAddresses;
+}
+
+/**
+ * Configuration of the L1Publisher.
+ */
+export interface PublisherConfig {
+  /**
+   * The interval to wait between publish retries.
+   */
+  l1BlockPublishRetryIntervalMS: 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);
+}