@aztec/sequencer-client 0.0.0-test.0

package/src/config.ts

@@ -0,0 +1,179 @@
+import {
+  type L1ContractsConfig,
+  type L1ReaderConfig,
+  l1ContractsConfigMappings,
+  l1ReaderConfigMappings,
+} from '@aztec/ethereum';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+  pickConfigMappings,
+} from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type AllowedElement, type ChainConfig, type SequencerConfig, chainConfigMappings } from '@aztec/stdlib/config';
+
+import {
+  type PublisherConfig,
+  type TxSenderConfig,
+  getPublisherConfigMappings,
+  getTxSenderConfigMappings,
+} from './publisher/config.js';
+
+export * from './publisher/config.js';
+export type { SequencerConfig };
+
+/**
+ * Configuration settings for the SequencerClient.
+ */
+export type SequencerClientConfig = PublisherConfig &
+  TxSenderConfig &
+  SequencerConfig &
+  L1ReaderConfig &
+  ChainConfig &
+  Pick<L1ContractsConfig, 'ethereumSlotDuration' | 'aztecSlotDuration' | 'aztecEpochDuration'>;
+
+export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
+  transactionPollingIntervalMS: {
+    env: 'SEQ_TX_POLLING_INTERVAL_MS',
+    description: 'The number of ms to wait between polling for pending txs.',
+    ...numberConfigHelper(500),
+  },
+  maxTxsPerBlock: {
+    env: 'SEQ_MAX_TX_PER_BLOCK',
+    description: 'The maximum number of txs to include in a block.',
+    ...numberConfigHelper(32),
+  },
+  minTxsPerBlock: {
+    env: 'SEQ_MIN_TX_PER_BLOCK',
+    description: 'The minimum number of txs to include in a block.',
+    ...numberConfigHelper(1),
+  },
+  maxL2BlockGas: {
+    env: 'SEQ_MAX_L2_BLOCK_GAS',
+    description: 'The maximum L2 block gas.',
+    ...numberConfigHelper(10e9),
+  },
+  maxDABlockGas: {
+    env: 'SEQ_MAX_DA_BLOCK_GAS',
+    description: 'The maximum DA block gas.',
+    ...numberConfigHelper(10e9),
+  },
+  coinbase: {
+    env: 'COINBASE',
+    parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
+    description: 'Recipient of block reward.',
+  },
+  feeRecipient: {
+    env: 'FEE_RECIPIENT',
+    parseEnv: (val: string) => AztecAddress.fromString(val),
+    description: 'Address to receive fees.',
+  },
+  acvmWorkingDirectory: {
+    env: 'ACVM_WORKING_DIRECTORY',
+    description: 'The working directory to use for simulation/proving',
+  },
+  acvmBinaryPath: {
+    env: 'ACVM_BINARY_PATH',
+    description: 'The path to the ACVM binary',
+  },
+  allowedInSetup: {
+    env: 'SEQ_ALLOWED_SETUP_FN',
+    parseEnv: (val: string) => parseSequencerAllowList(val),
+    description: 'The list of functions calls allowed to run in setup',
+    printDefault: () =>
+      'AuthRegistry, FeeJuice.increase_public_balance, Token.increase_public_balance, FPC.prepare_fee',
+  },
+  maxBlockSizeInBytes: {
+    env: 'SEQ_MAX_BLOCK_SIZE_IN_BYTES',
+    description: 'Max block size',
+    ...numberConfigHelper(1024 * 1024),
+  },
+  enforceTimeTable: {
+    env: 'SEQ_ENFORCE_TIME_TABLE',
+    description: 'Whether to enforce the time table when building blocks',
+    ...booleanConfigHelper(),
+    defaultValue: false,
+  },
+  governanceProposerPayload: {
+    env: 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS',
+    description: 'The address of the payload for the governanceProposer',
+    parseEnv: (val: string) => EthAddress.fromString(val),
+    defaultValue: EthAddress.ZERO,
+  },
+  maxL1TxInclusionTimeIntoSlot: {
+    env: 'SEQ_MAX_L1_TX_INCLUSION_TIME_INTO_SLOT',
+    description: 'How many seconds into an L1 slot we can still send a tx and get it mined.',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+  },
+};
+
+export const sequencerClientConfigMappings: ConfigMappingsType<SequencerClientConfig> = {
+  ...sequencerConfigMappings,
+  ...l1ReaderConfigMappings,
+  ...getTxSenderConfigMappings('SEQ'),
+  ...getPublisherConfigMappings('SEQ'),
+  ...chainConfigMappings,
+  ...pickConfigMappings(l1ContractsConfigMappings, ['ethereumSlotDuration', 'aztecSlotDuration', 'aztecEpochDuration']),
+};
+
+/**
+ * Creates an instance of SequencerClientConfig out of environment variables using sensible defaults for integration testing if not set.
+ */
+export function getConfigEnvVars(): SequencerClientConfig {
+  return getConfigFromMappings<SequencerClientConfig>(sequencerClientConfigMappings);
+}
+
+/**
+ * Parses a string to a list of allowed elements.
+ * Each encoded is expected to be of one of the following formats
+ * `I:${address}`
+ * `I:${address}:${selector}`
+ * `C:${classId}`
+ * `C:${classId}:${selector}`
+ *
+ * @param value The string to parse
+ * @returns A list of allowed elements
+ */
+export function parseSequencerAllowList(value: string): AllowedElement[] {
+  const entries: AllowedElement[] = [];
+
+  if (!value) {
+    return entries;
+  }
+
+  for (const val of value.split(',')) {
+    const [typeString, identifierString, selectorString] = val.split(':');
+    const selector = selectorString !== undefined ? FunctionSelector.fromString(selectorString) : undefined;
+
+    if (typeString === 'I') {
+      if (selector) {
+        entries.push({
+          address: AztecAddress.fromString(identifierString),
+          selector,
+        });
+      } else {
+        entries.push({
+          address: AztecAddress.fromString(identifierString),
+        });
+      }
+    } else if (typeString === 'C') {
+      if (selector) {
+        entries.push({
+          classId: Fr.fromHexString(identifierString),
+          selector,
+        });
+      } else {
+        entries.push({
+          classId: Fr.fromHexString(identifierString),
+        });
+      }
+    }
+  }
+
+  return entries;
+}

package/src/global_variable_builder/global_builder.ts

@@ -0,0 +1,108 @@
+import {
+  type L1ContractsConfig,
+  type L1ReaderConfig,
+  type ViemPublicClient,
+  createEthereumChain,
+} from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import type { GlobalVariableBuilder as GlobalVariableBuilderInterface } from '@aztec/stdlib/tx';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+
+import { type GetContractReturnType, createPublicClient, fallback, getAddress, getContract, http } from 'viem';
+
+/**
+ * Simple global variables builder.
+ */
+export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
+  private log = createLogger('sequencer:global_variable_builder');
+
+  private rollupContract: GetContractReturnType<typeof RollupAbi, ViemPublicClient>;
+  private publicClient: ViemPublicClient;
+  private ethereumSlotDuration: number;
+
+  constructor(config: L1ReaderConfig & Pick<L1ContractsConfig, 'ethereumSlotDuration'>) {
+    const { l1RpcUrls, l1ChainId: chainId, l1Contracts } = config;
+
+    const chain = createEthereumChain(l1RpcUrls, chainId);
+
+    this.ethereumSlotDuration = config.ethereumSlotDuration;
+
+    this.publicClient = createPublicClient({
+      chain: chain.chainInfo,
+      transport: fallback(chain.rpcUrls.map(url => http(url))),
+      pollingInterval: config.viemPollingIntervalMS,
+    });
+
+    this.rollupContract = getContract({
+      address: getAddress(l1Contracts.rollupAddress.toString()),
+      abi: RollupAbi,
+      client: this.publicClient,
+    });
+  }
+
+  /**
+   * Computes the "current" base fees, e.g., the price that you currently should pay to get include in the next block
+   * @returns Base fees for the expected next block
+   */
+  public async getCurrentBaseFees(): Promise<GasFees> {
+    // Since this might be called in the middle of a slot where a block might have been published,
+    // we need to fetch the last block written, and estimate the earliest timestamp for the next block.
+    // The timestamp of that last block will act as a lower bound for the next block.
+
+    const lastBlock = await this.rollupContract.read.getBlock([await this.rollupContract.read.getPendingBlockNumber()]);
+    const earliestTimestamp = await this.rollupContract.read.getTimestampForSlot([lastBlock.slotNumber + 1n]);
+    const nextEthTimestamp = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
+    const timestamp = earliestTimestamp > nextEthTimestamp ? earliestTimestamp : nextEthTimestamp;
+
+    return new GasFees(Fr.ZERO, new Fr(await this.rollupContract.read.getManaBaseFeeAt([timestamp, true])));
+  }
+
+  /**
+   * 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.
+   * @param slotNumber - The slot number to use for the global variables, if undefined it will be calculated.
+   * @returns The global variables for the given block number.
+   */
+  public async buildGlobalVariables(
+    blockNumber: Fr,
+    coinbase: EthAddress,
+    feeRecipient: AztecAddress,
+    slotNumber?: bigint,
+  ): Promise<GlobalVariables> {
+    const version = new Fr(await this.rollupContract.read.getVersion());
+    const chainId = new Fr(this.publicClient.chain.id);
+
+    if (slotNumber === undefined) {
+      const ts = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
+      slotNumber = await this.rollupContract.read.getSlotAt([ts]);
+    }
+
+    const timestamp = await this.rollupContract.read.getTimestampForSlot([slotNumber]);
+
+    const slotFr = new Fr(slotNumber);
+    const timestampFr = new Fr(timestamp);
+
+    // We can skip much of the logic in getCurrentBaseFees since it we already check that we are not within a slot elsewhere.
+    const gasFees = new GasFees(Fr.ZERO, new Fr(await this.rollupContract.read.getManaBaseFeeAt([timestamp, true])));
+
+    const globalVariables = new GlobalVariables(
+      chainId,
+      version,
+      blockNumber,
+      slotFr,
+      timestampFr,
+      coinbase,
+      feeRecipient,
+      gasFees,
+    );
+
+    return globalVariables;
+  }
+}

package/src/global_variable_builder/index.ts

@@ -0,0 +1 @@
+export { GlobalVariableBuilder } from './global_builder.js';

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './client/index.js';
+export * from './config.js';
+export * from './publisher/index.js';
+export * from './tx_validator/tx_validator_factory.js';
+export * from './slasher/index.js';
+export { Sequencer, SequencerState, getDefaultAllowedSetupFunctions } from './sequencer/index.js';
+
+// Used by the node to simulate public parts of transactions. Should these be moved to a shared library?
+// ISSUE(#9832)
+export * from './global_variable_builder/index.js';

package/src/publisher/config.ts

@@ -0,0 +1,75 @@
+import { type BlobSinkConfig, blobSinkConfigMapping } from '@aztec/blob-sink/client';
+import {
+  type L1ReaderConfig,
+  type L1TxUtilsConfig,
+  NULL_KEY,
+  l1ReaderConfigMappings,
+  l1TxUtilsConfigMappings,
+} from '@aztec/ethereum';
+import { type ConfigMappingsType, getConfigFromMappings } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+
+/**
+ * The configuration of the rollup transaction publisher.
+ */
+export type TxSenderConfig = L1ReaderConfig & {
+  /**
+   * The private key to be used by the publisher.
+   */
+  publisherPrivateKey: `0x${string}`;
+
+  /**
+   * The address of the custom forwarder contract.
+   */
+  customForwarderContractAddress: EthAddress;
+};
+
+/**
+ * Configuration of the L1Publisher.
+ */
+export type PublisherConfig = L1TxUtilsConfig &
+  BlobSinkConfig & {
+    /**
+     * The interval to wait between publish retries.
+     */
+    l1PublishRetryIntervalMS: number;
+  };
+
+export const getTxSenderConfigMappings: (
+  scope: 'PROVER' | 'SEQ',
+) => ConfigMappingsType<Omit<TxSenderConfig, 'l1Contracts'>> = (scope: 'PROVER' | 'SEQ') => ({
+  ...l1ReaderConfigMappings,
+  customForwarderContractAddress: {
+    env: `CUSTOM_FORWARDER_CONTRACT_ADDRESS`,
+    parseEnv: (val: string) => EthAddress.fromString(val),
+    description: 'The address of the custom forwarder contract.',
+    defaultValue: EthAddress.ZERO,
+  },
+  publisherPrivateKey: {
+    env: scope === 'PROVER' ? `PROVER_PUBLISHER_PRIVATE_KEY` : `SEQ_PUBLISHER_PRIVATE_KEY`,
+    description: 'The private key to be used by the publisher.',
+    parseEnv: (val: string) => (val ? `0x${val.replace('0x', '')}` : NULL_KEY),
+    defaultValue: NULL_KEY,
+  },
+});
+
+export function getTxSenderConfigFromEnv(scope: 'PROVER' | 'SEQ'): Omit<TxSenderConfig, 'l1Contracts'> {
+  return getConfigFromMappings(getTxSenderConfigMappings(scope));
+}
+
+export const getPublisherConfigMappings: (
+  scope: 'PROVER' | 'SEQ',
+) => ConfigMappingsType<PublisherConfig & L1TxUtilsConfig> = scope => ({
+  l1PublishRetryIntervalMS: {
+    env: scope === `PROVER` ? `PROVER_PUBLISH_RETRY_INTERVAL_MS` : `SEQ_PUBLISH_RETRY_INTERVAL_MS`,
+    parseEnv: (val: string) => +val,
+    defaultValue: 1000,
+    description: 'The interval to wait between publish retries.',
+  },
+  ...l1TxUtilsConfigMappings,
+  ...blobSinkConfigMapping,
+});
+
+export function getPublisherConfigFromEnv(scope: 'PROVER' | 'SEQ'): PublisherConfig {
+  return getConfigFromMappings(getPublisherConfigMappings(scope));
+}

package/src/publisher/index.ts

@@ -0,0 +1 @@
+export { SequencerPublisher } from './sequencer-publisher.js';

package/src/publisher/sequencer-publisher-metrics.ts

@@ -0,0 +1,176 @@
+import { createLogger } from '@aztec/aztec.js';
+import type { L1PublishBlockStats, L1PublishStats } from '@aztec/stdlib/stats';
+import {
+  Attributes,
+  type Gauge,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+import { formatEther } from 'viem/utils';
+
+export type L1TxType = 'process';
+
+export class SequencerPublisherMetrics {
+  private gasPrice: Histogram;
+
+  private txCount: UpDownCounter;
+  private txDuration: Histogram;
+  private txGas: Histogram;
+  private txCalldataSize: Histogram;
+  private txCalldataGas: Histogram;
+  private txBlobDataGasUsed: Histogram;
+  private txBlobDataGasCost: Histogram;
+
+  private readonly blobCountHistogram: Histogram;
+  private readonly blobInclusionBlocksHistogram: Histogram;
+  private readonly blobTxSuccessCounter: UpDownCounter;
+  private readonly blobTxFailureCounter: UpDownCounter;
+
+  private senderBalance: Gauge;
+
+  constructor(
+    client: TelemetryClient,
+    name = 'SequencerPublisher',
+    private logger = createLogger('sequencer:publisher:metrics'),
+  ) {
+    const meter = client.getMeter(name);
+
+    this.gasPrice = meter.createHistogram(Metrics.L1_PUBLISHER_GAS_PRICE, {
+      description: 'The gas price used for transactions',
+      unit: 'gwei',
+      valueType: ValueType.DOUBLE,
+    });
+
+    this.txCount = meter.createUpDownCounter(Metrics.L1_PUBLISHER_TX_COUNT, {
+      description: 'The number of transactions processed',
+    });
+
+    this.txDuration = meter.createHistogram(Metrics.L1_PUBLISHER_TX_DURATION, {
+      description: 'The duration of transaction processing',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+
+    this.txGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_GAS, {
+      description: 'The gas consumed by transactions',
+      unit: 'gas',
+      valueType: ValueType.INT,
+    });
+
+    this.txCalldataSize = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_SIZE, {
+      description: 'The size of the calldata in transactions',
+      unit: 'By',
+      valueType: ValueType.INT,
+    });
+
+    this.txCalldataGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_GAS, {
+      description: 'The gas consumed by the calldata in transactions',
+      unit: 'gas',
+      valueType: ValueType.INT,
+    });
+
+    this.txBlobDataGasUsed = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_USED, {
+      description: 'The amount of blob gas used in transactions',
+      unit: 'gas',
+      valueType: ValueType.INT,
+    });
+
+    this.txBlobDataGasCost = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_COST, {
+      description: 'The gas cost of blobs in transactions',
+      unit: 'gwei',
+      valueType: ValueType.INT,
+    });
+
+    this.blobCountHistogram = meter.createHistogram(Metrics.L1_PUBLISHER_BLOB_COUNT, {
+      description: 'Number of blobs in L1 transactions',
+      unit: 'blobs',
+      valueType: ValueType.INT,
+    });
+
+    this.blobInclusionBlocksHistogram = meter.createHistogram(Metrics.L1_PUBLISHER_BLOB_INCLUSION_BLOCKS, {
+      description: 'Number of L1 blocks between blob tx submission and inclusion',
+      unit: 'blocks',
+      valueType: ValueType.INT,
+    });
+
+    this.blobTxSuccessCounter = meter.createUpDownCounter(Metrics.L1_PUBLISHER_BLOB_TX_SUCCESS, {
+      description: 'Number of successful L1 transactions with blobs',
+    });
+
+    this.blobTxFailureCounter = meter.createUpDownCounter(Metrics.L1_PUBLISHER_BLOB_TX_FAILURE, {
+      description: 'Number of failed L1 transactions with blobs',
+    });
+
+    this.senderBalance = meter.createGauge(Metrics.L1_PUBLISHER_BALANCE, {
+      unit: 'eth',
+      description: 'The balance of the sender address',
+      valueType: ValueType.DOUBLE,
+    });
+  }
+
+  recordFailedTx(txType: L1TxType) {
+    this.txCount.add(1, {
+      [Attributes.L1_TX_TYPE]: txType,
+      [Attributes.OK]: false,
+    });
+
+    if (txType === 'process') {
+      this.blobTxFailureCounter.add(1);
+    }
+  }
+
+  recordProcessBlockTx(durationMs: number, stats: L1PublishBlockStats) {
+    this.recordTx('process', durationMs, stats);
+
+    if (stats.blobCount && stats.blobCount > 0) {
+      this.blobCountHistogram.record(stats.blobCount);
+
+      if (stats.inclusionBlocks !== undefined) {
+        this.blobInclusionBlocksHistogram.record(stats.inclusionBlocks);
+      }
+
+      this.blobTxSuccessCounter.add(1);
+    }
+  }
+
+  recordSenderBalance(wei: bigint, senderAddress: string) {
+    const eth = parseFloat(formatEther(wei, 'wei'));
+    this.senderBalance.record(eth, {
+      [Attributes.SENDER_ADDRESS]: senderAddress,
+    });
+  }
+
+  private recordTx(txType: L1TxType, durationMs: number, stats: L1PublishStats) {
+    const attributes = {
+      [Attributes.L1_TX_TYPE]: txType,
+      [Attributes.L1_SENDER]: stats.sender,
+    } as const;
+
+    this.txCount.add(1, {
+      ...attributes,
+      [Attributes.OK]: true,
+    });
+
+    this.txDuration.record(Math.ceil(durationMs), attributes);
+    this.txGas.record(
+      // safe to downcast - total block limit is 30M gas which fits in a JS number
+      Number(stats.gasUsed),
+      attributes,
+    );
+    this.txCalldataGas.record(stats.calldataGas, attributes);
+    this.txCalldataSize.record(stats.calldataSize, attributes);
+
+    this.txBlobDataGasCost.record(Number(stats.blobDataGas), attributes);
+    this.txBlobDataGasUsed.record(Number(stats.blobGasUsed), attributes);
+
+    try {
+      this.gasPrice.record(parseInt(formatEther(stats.gasPrice, 'gwei'), 10));
+    } catch (e) {
+      // ignore
+    }
+  }
+}