@aztec/sequencer-client 0.0.1-commit.d431d1c → 0.0.1-commit.dbf9cec

package/src/global_variable_builder/global_builder.ts

@@ -69,9 +69,9 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
     // 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.getPendingCheckpoint();
+    const lastCheckpoint = await this.rollupContract.getPendingCheckpoint();
     const earliestTimestamp = await this.rollupContract.getTimestampForSlot(
-      SlotNumber.fromBigInt(BigInt(lastBlock.slotNumber) + 1n),
+      SlotNumber.fromBigInt(BigInt(lastCheckpoint.slotNumber) + 1n),
     );
     const nextEthTimestamp = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
     const timestamp = earliestTimestamp > nextEthTimestamp ? earliestTimestamp : nextEthTimestamp;
@@ -120,7 +120,7 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
     slotNumber: SlotNumber,
-  ): Promise<CheckpointGlobalVariables & { timestamp: bigint }> {
+  ): Promise<CheckpointGlobalVariables> {
     const { chainId, version } = this;
 
     const timestamp = getTimestampForSlot(slotNumber, {

package/src/publisher/config.ts

@@ -1,32 +1,45 @@
 import { type BlobClientConfig, blobClientConfigMapping } from '@aztec/blob-client/client/config';
 import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
 import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from '@aztec/ethereum/l1-tx-utils/config';
-import {
-  type ConfigMappingsType,
-  SecretValue,
-  booleanConfigHelper,
-  getConfigFromMappings,
-} from '@aztec/foundation/config';
+import { type ConfigMappingsType, SecretValue, booleanConfigHelper } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
-/**
- * The configuration of the rollup transaction publisher.
- */
+/** Configuration of the transaction publisher. */
 export type TxSenderConfig = L1ReaderConfig & {
-  /**
-   * The private key to be used by the publisher.
-   */
+  /** The private key to be used by the publisher. */
   publisherPrivateKeys?: SecretValue<`0x${string}`>[];
 
-  /**
-   * Publisher addresses to be used with a remote signer
-   */
+  /** Publisher addresses to be used with a remote signer */
   publisherAddresses?: EthAddress[];
 };
 
-/**
- * Configuration of the L1Publisher.
- */
+export type ProverTxSenderConfig = L1ReaderConfig & {
+  proverPublisherPrivateKeys?: SecretValue<`0x${string}`>[];
+  proverPublisherAddresses?: EthAddress[];
+};
+
+export type SequencerTxSenderConfig = L1ReaderConfig & {
+  sequencerPublisherPrivateKeys?: SecretValue<`0x${string}`>[];
+  sequencerPublisherAddresses?: EthAddress[];
+};
+
+export function getTxSenderConfigFromProverConfig(config: ProverTxSenderConfig): TxSenderConfig {
+  return {
+    ...config,
+    publisherPrivateKeys: config.proverPublisherPrivateKeys,
+    publisherAddresses: config.proverPublisherAddresses,
+  };
+}
+
+export function getTxSenderConfigFromSequencerConfig(config: SequencerTxSenderConfig): TxSenderConfig {
+  return {
+    ...config,
+    publisherPrivateKeys: config.sequencerPublisherPrivateKeys,
+    publisherAddresses: config.sequencerPublisherAddresses,
+  };
+}
+
+/** Configuration of the L1Publisher. */
 export type PublisherConfig = L1TxUtilsConfig &
   BlobClientConfig & {
     /** True to use publishers in invalid states (timed out, cancelled, etc) if no other is available */
@@ -35,37 +48,83 @@ export type PublisherConfig = L1TxUtilsConfig &
     fishermanMode?: boolean;
     /** Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only) */
     publisherForwarderAddress?: EthAddress;
+    /** Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path */
+    l1TxFailedStore?: string;
+  };
+
+export type ProverPublisherConfig = L1TxUtilsConfig &
+  BlobClientConfig & {
+    fishermanMode?: boolean;
+    proverPublisherAllowInvalidStates?: boolean;
+    proverPublisherForwarderAddress?: EthAddress;
   };
 
-export const getTxSenderConfigMappings: (
-  scope: 'PROVER' | 'SEQ',
-) => ConfigMappingsType<Omit<TxSenderConfig, 'l1Contracts'>> = (scope: 'PROVER' | 'SEQ') => ({
+export type SequencerPublisherConfig = L1TxUtilsConfig &
+  BlobClientConfig & {
+    fishermanMode?: boolean;
+    sequencerPublisherAllowInvalidStates?: boolean;
+    sequencerPublisherForwarderAddress?: EthAddress;
+    /** Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path */
+    l1TxFailedStore?: string;
+  };
+
+export function getPublisherConfigFromProverConfig(config: ProverPublisherConfig): PublisherConfig {
+  return {
+    ...config,
+    publisherAllowInvalidStates: config.proverPublisherAllowInvalidStates,
+    publisherForwarderAddress: config.proverPublisherForwarderAddress,
+  };
+}
+
+export function getPublisherConfigFromSequencerConfig(config: SequencerPublisherConfig): PublisherConfig {
+  return {
+    ...config,
+    publisherAllowInvalidStates: config.sequencerPublisherAllowInvalidStates,
+    publisherForwarderAddress: config.sequencerPublisherForwarderAddress,
+    l1TxFailedStore: config.l1TxFailedStore,
+  };
+}
+
+export const proverTxSenderConfigMappings: ConfigMappingsType<Omit<ProverTxSenderConfig, 'l1Contracts'>> = {
   ...l1ReaderConfigMappings,
-  publisherPrivateKeys: {
-    env: scope === 'PROVER' ? `PROVER_PUBLISHER_PRIVATE_KEYS` : `SEQ_PUBLISHER_PRIVATE_KEYS`,
-    description: 'The private keys to be used by the publisher.',
+  proverPublisherPrivateKeys: {
+    env: `PROVER_PUBLISHER_PRIVATE_KEYS`,
+    description: 'The private keys to be used by the prover publisher.',
     parseEnv: (val: string) => val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}`)),
     defaultValue: [],
-    fallback: [scope === 'PROVER' ? `PROVER_PUBLISHER_PRIVATE_KEY` : `SEQ_PUBLISHER_PRIVATE_KEY`],
+    fallback: [`PROVER_PUBLISHER_PRIVATE_KEY`],
   },
-  publisherAddresses: {
-    env: scope === 'PROVER' ? `PROVER_PUBLISHER_ADDRESSES` : `SEQ_PUBLISHER_ADDRESSES`,
+  proverPublisherAddresses: {
+    env: `PROVER_PUBLISHER_ADDRESSES`,
     description: 'The addresses of the publishers to use with remote signers',
     parseEnv: (val: string) => val.split(',').map(address => EthAddress.fromString(address)),
     defaultValue: [],
   },
-});
+};
 
-export function getTxSenderConfigFromEnv(scope: 'PROVER' | 'SEQ'): Omit<TxSenderConfig, 'l1Contracts'> {
-  return getConfigFromMappings(getTxSenderConfigMappings(scope));
-}
+export const sequencerTxSenderConfigMappings: ConfigMappingsType<Omit<SequencerTxSenderConfig, 'l1Contracts'>> = {
+  ...l1ReaderConfigMappings,
+  sequencerPublisherPrivateKeys: {
+    env: `SEQ_PUBLISHER_PRIVATE_KEYS`,
+    description: 'The private keys to be used by the sequencer publisher.',
+    parseEnv: (val: string) => val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}`)),
+    defaultValue: [],
+    fallback: [`SEQ_PUBLISHER_PRIVATE_KEY`],
+  },
+  sequencerPublisherAddresses: {
+    env: `SEQ_PUBLISHER_ADDRESSES`,
+    description: 'The addresses of the publishers to use with remote signers',
+    parseEnv: (val: string) => val.split(',').map(address => EthAddress.fromString(address)),
+    defaultValue: [],
+  },
+};
 
-export const getPublisherConfigMappings: (
-  scope: 'PROVER' | 'SEQ',
-) => ConfigMappingsType<PublisherConfig & L1TxUtilsConfig> = scope => ({
-  publisherAllowInvalidStates: {
+export const sequencerPublisherConfigMappings: ConfigMappingsType<SequencerPublisherConfig & L1TxUtilsConfig> = {
+  ...l1TxUtilsConfigMappings,
+  ...blobClientConfigMapping,
+  sequencerPublisherAllowInvalidStates: {
+    env: `SEQ_PUBLISHER_ALLOW_INVALID_STATES`,
     description: 'True to use publishers in invalid states (timed out, cancelled, etc) if no other is available',
-    env: scope === `PROVER` ? `PROVER_PUBLISHER_ALLOW_INVALID_STATES` : `SEQ_PUBLISHER_ALLOW_INVALID_STATES`,
     ...booleanConfigHelper(true),
   },
   fishermanMode: {
@@ -74,15 +133,34 @@ export const getPublisherConfigMappings: (
       'Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1',
     ...booleanConfigHelper(false),
   },
-  publisherForwarderAddress: {
-    env: scope === `PROVER` ? `PROVER_PUBLISHER_FORWARDER_ADDRESS` : `SEQ_PUBLISHER_FORWARDER_ADDRESS`,
+  sequencerPublisherForwarderAddress: {
+    env: `SEQ_PUBLISHER_FORWARDER_ADDRESS`,
     description: 'Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only)',
     parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
   },
+  l1TxFailedStore: {
+    env: 'L1_TX_FAILED_STORE',
+    description: 'Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path',
+  },
+};
+
+export const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherConfig & L1TxUtilsConfig> = {
   ...l1TxUtilsConfigMappings,
   ...blobClientConfigMapping,
-});
-
-export function getPublisherConfigFromEnv(scope: 'PROVER' | 'SEQ'): PublisherConfig {
-  return getConfigFromMappings(getPublisherConfigMappings(scope));
-}
+  proverPublisherAllowInvalidStates: {
+    env: `PROVER_PUBLISHER_ALLOW_INVALID_STATES`,
+    description: 'True to use publishers in invalid states (timed out, cancelled, etc) if no other is available',
+    ...booleanConfigHelper(true),
+  },
+  fishermanMode: {
+    env: 'FISHERMAN_MODE',
+    description:
+      'Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1',
+    ...booleanConfigHelper(false),
+  },
+  proverPublisherForwarderAddress: {
+    env: `PROVER_PUBLISHER_FORWARDER_ADDRESS`,
+    description: 'Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only)',
+    parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
+  },
+};

package/src/publisher/index.ts

@@ -3,3 +3,6 @@ export { SequencerPublisherFactory } from './sequencer-publisher-factory.js';
 
 // Used for tests
 export { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
+
+// Failed L1 tx store (optional, for test networks)
+export { type FailedL1Tx, type FailedL1TxUri, type L1TxFailedStore } from './l1_tx_failed_store/index.js';

package/src/publisher/l1_tx_failed_store/factory.ts

@@ -0,0 +1,32 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { createFileStore } from '@aztec/stdlib/file-store';
+
+import type { L1TxFailedStore } from './failed_tx_store.js';
+import { FileStoreL1TxFailedStore } from './file_store_failed_tx_store.js';
+
+/**
+ * Creates an L1TxFailedStore from a config string.
+ * Supports any backend that FileStore supports (GCS, S3, R2, local filesystem).
+ * @param config - Config string (e.g., 'gs://bucket/path', 's3://bucket/path', 'file:///path'). If undefined, returns undefined.
+ * @param logger - Optional logger.
+ * @returns The store instance, or undefined if config is not provided.
+ */
+export async function createL1TxFailedStore(
+  config: string | undefined,
+  logger: Logger = createLogger('sequencer:l1-tx-failed-store'),
+): Promise<L1TxFailedStore | undefined> {
+  if (!config) {
+    return undefined;
+  }
+
+  const fileStore = await createFileStore(config, logger);
+  if (!fileStore) {
+    throw new Error(
+      `Failed to create file store from config: '${config}'. ` +
+        `Supported formats: 'gs://bucket/path', 's3://bucket/path', 'file:///path'.`,
+    );
+  }
+
+  logger.info(`Created L1 tx failed store`, { config });
+  return new FileStoreL1TxFailedStore(fileStore, logger);
+}

package/src/publisher/l1_tx_failed_store/failed_tx_store.ts

@@ -0,0 +1,55 @@
+import type { Hex } from 'viem';
+
+/** URI pointing to a stored failed L1 transaction. */
+export type FailedL1TxUri = string & { __brand: 'FailedL1TxUri' };
+
+/** A failed L1 transaction captured for debugging and replay. */
+export type FailedL1Tx = {
+  /** Tx hash (for reverts) or keccak256(request.data) (for simulation/send failures). */
+  id: Hex;
+  /** Unix timestamp (ms) when failure occurred. */
+  timestamp: number;
+  /** Whether the failure was during simulation or after sending. */
+  failureType: 'simulation' | 'revert' | 'send-error';
+  /** The actual L1 transaction for replay (multicall-encoded for bundled txs). */
+  request: {
+    to: Hex;
+    data: Hex;
+    value?: string; // bigint as string
+  };
+  /** Raw blob data as hex for replay. */
+  blobData?: Hex[];
+  /** L1 block number at time of failure (simulation target or receipt block). */
+  l1BlockNumber: string; // bigint as string
+  /** Receipt info (present only for on-chain reverts). */
+  receipt?: {
+    transactionHash: Hex;
+    blockNumber: string; // bigint as string
+    gasUsed: string; // bigint as string
+    status: 'reverted';
+  };
+  /** Error information. */
+  error: {
+    message: string;
+    /** Decoded error name (e.g., 'Rollup__InvalidProposer'). */
+    name?: string;
+  };
+  /** Context metadata. */
+  context: {
+    /** Actions involved (e.g., ['propose', 'governance-signal']). */
+    actions: string[];
+    /** Individual request data for each action (metadata, not used for replay). */
+    requests?: Array<{ action: string; to: Hex; data: Hex }>;
+    checkpointNumber?: number;
+    slot?: number;
+    sender: Hex;
+  };
+};
+
+/** Store for failed L1 transactions for debugging purposes. */
+export interface L1TxFailedStore {
+  /** Saves a failed transaction and returns its URI. */
+  saveFailedTx(tx: FailedL1Tx): Promise<FailedL1TxUri>;
+  /** Retrieves a failed transaction by its URI. */
+  getFailedTx(uri: FailedL1TxUri): Promise<FailedL1Tx>;
+}

package/src/publisher/l1_tx_failed_store/file_store_failed_tx_store.ts

@@ -0,0 +1,46 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { FileStore } from '@aztec/stdlib/file-store';
+
+import type { FailedL1Tx, FailedL1TxUri, L1TxFailedStore } from './failed_tx_store.js';
+
+/**
+ * L1TxFailedStore implementation using the FileStore abstraction.
+ * Supports any backend that FileStore supports (GCS, S3, R2, local filesystem).
+ */
+export class FileStoreL1TxFailedStore implements L1TxFailedStore {
+  private readonly log: Logger;
+
+  constructor(
+    private readonly fileStore: FileStore,
+    logger?: Logger,
+  ) {
+    this.log = logger ?? createLogger('sequencer:l1-tx-failed-store');
+  }
+
+  public async saveFailedTx(tx: FailedL1Tx): Promise<FailedL1TxUri> {
+    const prefix = tx.receipt ? 'tx' : 'data';
+    const path = `${tx.failureType}/${prefix}-${tx.id}.json`;
+    const json = JSON.stringify(tx, null, 2);
+
+    const uri = await this.fileStore.save(path, Buffer.from(json), {
+      metadata: {
+        'content-type': 'application/json',
+        actions: tx.context.actions.join(','),
+        'failure-type': tx.failureType,
+      },
+    });
+
+    this.log.info(`Saved failed L1 tx to ${uri}`, {
+      id: tx.id,
+      failureType: tx.failureType,
+      actions: tx.context.actions.join(','),
+    });
+
+    return uri as FailedL1TxUri;
+  }
+
+  public async getFailedTx(uri: FailedL1TxUri): Promise<FailedL1Tx> {
+    const data = await this.fileStore.read(uri);
+    return JSON.parse(data.toString()) as FailedL1Tx;
+  }
+}

package/src/publisher/l1_tx_failed_store/index.ts

@@ -0,0 +1,3 @@
+export { type FailedL1Tx, type FailedL1TxUri, type L1TxFailedStore } from './failed_tx_store.js';
+export { createL1TxFailedStore } from './factory.js';
+export { FileStoreL1TxFailedStore } from './file_store_failed_tx_store.js';

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

@@ -3,7 +3,7 @@ import { type Logger, createLogger } from '@aztec/aztec.js/log';
 import type { BlobClientInterface } from '@aztec/blob-client/client';
 import type { EpochCache } from '@aztec/epoch-cache';
 import type { GovernanceProposerContract, RollupContract } from '@aztec/ethereum/contracts';
-import type { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import type { PublisherFilter, PublisherManager } from '@aztec/ethereum/publisher-manager';
 import { SlotNumber } from '@aztec/foundation/branded-types';
 import type { DateProvider } from '@aztec/foundation/timer';
@@ -26,13 +26,15 @@ export class SequencerPublisherFactory {
   /** Stores the last slot in which every action was carried out by a publisher */
   private lastActions: Partial<Record<Action, SlotNumber>> = {};
 
+  private nodeKeyStore: NodeKeystoreAdapter;
+
   private logger: Logger;
 
   constructor(
     private sequencerConfig: SequencerClientConfig,
     private deps: {
       telemetry: TelemetryClient;
-      publisherManager: PublisherManager<L1TxUtilsWithBlobs>;
+      publisherManager: PublisherManager<L1TxUtils>;
       blobClient: BlobClientInterface;
       dateProvider: DateProvider;
       epochCache: EpochCache;
@@ -45,7 +47,17 @@ export class SequencerPublisherFactory {
   ) {
     this.publisherMetrics = new SequencerPublisherMetrics(deps.telemetry, 'SequencerPublisher');
     this.logger = deps.logger ?? createLogger('sequencer');
+    this.nodeKeyStore = this.deps.nodeKeyStore;
+  }
+
+  /**
+   * Updates the node keystore adapter used for publisher lookups.
+   * Called when the keystore is reloaded at runtime to reflect new validator-publisher mappings.
+   */
+  public updateNodeKeyStore(adapter: NodeKeystoreAdapter): void {
+    this.nodeKeyStore = adapter;
   }
+
   /**
    * Creates a new SequencerPublisher instance.
    * @param _validatorAddress - The address of the validator that will be using the publisher.
@@ -54,17 +66,17 @@ export class SequencerPublisherFactory {
   public async create(validatorAddress?: EthAddress): Promise<AttestorPublisherPair> {
     // If we have been given an attestor address we must only allow publishers permitted for that attestor
 
-    const allowedPublishers = !validatorAddress ? [] : this.deps.nodeKeyStore.getPublisherAddresses(validatorAddress);
-    const filter: PublisherFilter<L1TxUtilsWithBlobs> = !validatorAddress
+    const allowedPublishers = !validatorAddress ? [] : this.nodeKeyStore.getPublisherAddresses(validatorAddress);
+    const filter: PublisherFilter<L1TxUtils> = !validatorAddress
       ? () => true
-      : (utils: L1TxUtilsWithBlobs) => {
+      : (utils: L1TxUtils) => {
           const publisherAddress = utils.getSenderAddress();
           return allowedPublishers.some(allowedPublisher => allowedPublisher.equals(publisherAddress));
         };
 
     const l1Publisher = await this.deps.publisherManager.getAvailablePublisher(filter);
     const attestorAddress =
-      validatorAddress ?? this.deps.nodeKeyStore.getAttestorForPublisher(l1Publisher.getSenderAddress());
+      validatorAddress ?? this.nodeKeyStore.getAttestorForPublisher(l1Publisher.getSenderAddress());
 
     const rollup = this.deps.rollupContract;
     const slashingProposerContract = await rollup.getSlashingProposer();
@@ -89,4 +101,9 @@ export class SequencerPublisherFactory {
       publisher,
     };
   }
+
+  /** Interrupts all publishers managed by this factory. Used during sequencer shutdown. */
+  public interruptAll(): void {
+    this.deps.publisherManager.interrupt();
+  }
 }

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

@@ -7,6 +7,7 @@ import {
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 import { formatEther } from 'viem/utils';
@@ -41,7 +42,10 @@ export class SequencerPublisherMetrics {
 
     this.gasPrice = meter.createHistogram(Metrics.L1_PUBLISHER_GAS_PRICE);
 
-    this.txCount = meter.createUpDownCounter(Metrics.L1_PUBLISHER_TX_COUNT);
+    this.txCount = createUpDownCounterWithDefault(meter, Metrics.L1_PUBLISHER_TX_COUNT, {
+      [Attributes.L1_TX_TYPE]: ['process'],
+      [Attributes.OK]: [true, false],
+    });
 
     this.txDuration = meter.createHistogram(Metrics.L1_PUBLISHER_TX_DURATION);
 
@@ -59,9 +63,9 @@ export class SequencerPublisherMetrics {
 
     this.blobInclusionBlocksHistogram = meter.createHistogram(Metrics.L1_PUBLISHER_BLOB_INCLUSION_BLOCKS);
 
-    this.blobTxSuccessCounter = meter.createUpDownCounter(Metrics.L1_PUBLISHER_BLOB_TX_SUCCESS);
+    this.blobTxSuccessCounter = createUpDownCounterWithDefault(meter, Metrics.L1_PUBLISHER_BLOB_TX_SUCCESS);
 
-    this.blobTxFailureCounter = meter.createUpDownCounter(Metrics.L1_PUBLISHER_BLOB_TX_FAILURE);
+    this.blobTxFailureCounter = createUpDownCounterWithDefault(meter, Metrics.L1_PUBLISHER_BLOB_TX_FAILURE);
 
     this.txTotalFee = meter.createHistogram(Metrics.L1_PUBLISHER_TX_TOTAL_FEE);