@aztec/sequencer-client 0.0.1-commit.9ef841308 → 0.0.1-commit.a89ec08

package/src/publisher/config.ts

@@ -4,8 +4,6 @@ import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from '@aztec/ethereum/l
 import { type ConfigMappingsType, SecretValue, booleanConfigHelper } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
-import { parseEther } from 'viem';
-
 /** Configuration of the transaction publisher. */
 export type TxSenderConfig = L1ReaderConfig & {
   /** The private key to be used by the publisher. */
@@ -50,39 +48,13 @@ 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;
-    /** Min ETH balance below which a publisher gets funded. Undefined = funding disabled. */
-    publisherFundingThreshold?: bigint;
-    /** Amount of ETH to send when funding a publisher. Undefined = funding disabled. */
-    publisherFundingAmount?: bigint;
   };
 
-/** Shared config mappings for publisher funding, used by both sequencer and prover publisher configs. */
-const publisherFundingConfigMappings = {
-  publisherFundingThreshold: {
-    env: 'PUBLISHER_FUNDING_THRESHOLD' as const,
-    description:
-      'Min ETH balance below which a publisher gets funded. Specified in ether (e.g. 0.1). Unset = funding disabled.',
-    parseEnv: (val: string) => parseEther(val),
-  },
-  publisherFundingAmount: {
-    env: 'PUBLISHER_FUNDING_AMOUNT' as const,
-    description:
-      'Amount of ETH to send when funding a publisher. Specified in ether (e.g. 0.5). Unset = funding disabled.',
-    parseEnv: (val: string) => parseEther(val),
-  },
-};
-
 export type ProverPublisherConfig = L1TxUtilsConfig &
   BlobClientConfig & {
     fishermanMode?: boolean;
     proverPublisherAllowInvalidStates?: boolean;
     proverPublisherForwarderAddress?: EthAddress;
-    /** Min ETH balance below which a publisher gets funded. Undefined = funding disabled. */
-    publisherFundingThreshold?: bigint;
-    /** Amount of ETH to send when funding a publisher. Undefined = funding disabled. */
-    publisherFundingAmount?: bigint;
   };
 
 export type SequencerPublisherConfig = L1TxUtilsConfig &
@@ -90,12 +62,6 @@ export type SequencerPublisherConfig = L1TxUtilsConfig &
     fishermanMode?: boolean;
     sequencerPublisherAllowInvalidStates?: boolean;
     sequencerPublisherForwarderAddress?: EthAddress;
-    /** Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path */
-    l1TxFailedStore?: string;
-    /** Min ETH balance below which a publisher gets funded. Undefined = funding disabled. */
-    publisherFundingThreshold?: bigint;
-    /** Amount of ETH to send when funding a publisher. Undefined = funding disabled. */
-    publisherFundingAmount?: bigint;
   };
 
 export function getPublisherConfigFromProverConfig(config: ProverPublisherConfig): PublisherConfig {
@@ -111,7 +77,6 @@ export function getPublisherConfigFromSequencerConfig(config: SequencerPublisher
     ...config,
     publisherAllowInvalidStates: config.sequencerPublisherAllowInvalidStates,
     publisherForwarderAddress: config.sequencerPublisherForwarderAddress,
-    l1TxFailedStore: config.l1TxFailedStore,
   };
 }
 
@@ -168,11 +133,6 @@ export const sequencerPublisherConfigMappings: ConfigMappingsType<SequencerPubli
     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',
-  },
-  ...publisherFundingConfigMappings,
 };
 
 export const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherConfig & L1TxUtilsConfig> = {
@@ -194,5 +154,4 @@ export const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherCo
     description: 'Address of the forwarder contract to wrap all L1 transactions through (for testing purposes only)',
     parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
   },
-  ...publisherFundingConfigMappings,
 };

package/src/publisher/index.ts

@@ -3,6 +3,3 @@ 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/sequencer-publisher-factory.ts

@@ -81,23 +81,8 @@ export class SequencerPublisherFactory {
     const rollup = this.deps.rollupContract;
     const slashingProposerContract = await rollup.getSlashingProposer();
 
-    const getNextPublisher = async (excludeAddresses: EthAddress[]): Promise<L1TxUtils | undefined> => {
-      const exclusionFilter: PublisherFilter<L1TxUtils> = (utils: L1TxUtils) => {
-        if (excludeAddresses.some(addr => addr.equals(utils.getSenderAddress()))) {
-          return false;
-        }
-        return filter(utils);
-      };
-      try {
-        return await this.deps.publisherManager.getAvailablePublisher(exclusionFilter);
-      } catch {
-        return undefined;
-      }
-    };
-
     const publisher = new SequencerPublisher(this.sequencerConfig, {
       l1TxUtils: l1Publisher,
-      getNextPublisher,
       telemetry: this.deps.telemetry,
       blobClient: this.deps.blobClient,
       rollupContract: this.deps.rollupContract,
@@ -117,8 +102,8 @@ export class SequencerPublisherFactory {
     };
   }
 
-  /** Stops all publishers managed by this factory. Used during sequencer shutdown. */
-  public async stopAll(): Promise<void> {
-    await this.deps.publisherManager.stop();
+  /** Interrupts all publishers managed by this factory. Used during sequencer shutdown. */
+  public interruptAll(): void {
+    this.deps.publisherManager.interrupt();
   }
 }

package/src/publisher/sequencer-publisher.ts

@@ -31,7 +31,6 @@ import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { trimmedBytesLength } from '@aztec/foundation/buffer';
 import { pick } from '@aztec/foundation/collection';
 import type { Fr } from '@aztec/foundation/curves/bn254';
-import { TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature, type ViemSignature } from '@aztec/foundation/eth-signature';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -48,19 +47,9 @@ import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 import type { L1PublishCheckpointStats } from '@aztec/stdlib/stats';
 import { type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
-import {
-  type Hex,
-  type StateOverride,
-  type TransactionReceipt,
-  type TypedDataDefinition,
-  encodeFunctionData,
-  keccak256,
-  multicall3Abi,
-  toHex,
-} from 'viem';
+import { type StateOverride, type TransactionReceipt, type TypedDataDefinition, encodeFunctionData, toHex } from 'viem';
 
 import type { SequencerPublisherConfig } from './config.js';
-import { type FailedL1Tx, type L1TxFailedStore, createL1TxFailedStore } from './l1_tx_failed_store/index.js';
 import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
 
 /** Arguments to the process method of the rollup contract */
@@ -122,7 +111,6 @@ export class SequencerPublisher {
   private interrupted = false;
   private metrics: SequencerPublisherMetrics;
   public epochCache: EpochCache;
-  private failedTxStore?: Promise<L1TxFailedStore | undefined>;
 
   protected governanceLog = createLogger('sequencer:publisher:governance');
   protected slashingLog = createLogger('sequencer:publisher:slashing');
@@ -142,9 +130,6 @@ export class SequencerPublisher {
   /** Address to use for simulations in fisherman mode (actual proposer's address) */
   private proposerAddressForSimulation?: EthAddress;
 
-  /** Optional callback to obtain a replacement publisher when the current one fails to send. */
-  private getNextPublisher?: (excludeAddresses: EthAddress[]) => Promise<L1TxUtils | undefined>;
-
   /** L1 fee analyzer for fisherman mode */
   private l1FeeAnalyzer?: L1FeeAnalyzer;
 
@@ -168,7 +153,7 @@ export class SequencerPublisher {
   protected requests: RequestWithExpiry[] = [];
 
   constructor(
-    private config: Pick<SequencerPublisherConfig, 'fishermanMode' | 'l1TxFailedStore'> &
+    private config: Pick<SequencerPublisherConfig, 'fishermanMode'> &
       Pick<L1ContractsConfig, 'ethereumSlotDuration' | 'aztecSlotDuration'> & { l1ChainId: number },
     deps: {
       telemetry?: TelemetryClient;
@@ -183,7 +168,6 @@ export class SequencerPublisher {
       metrics: SequencerPublisherMetrics;
       lastActions: Partial<Record<Action, SlotNumber>>;
       log?: Logger;
-      getNextPublisher?: (excludeAddresses: EthAddress[]) => Promise<L1TxUtils | undefined>;
     },
   ) {
     this.log = deps.log ?? createLogger('sequencer:publisher');
@@ -199,7 +183,6 @@ export class SequencerPublisher {
     this.metrics = deps.metrics ?? new SequencerPublisherMetrics(telemetry, 'SequencerPublisher');
     this.tracer = telemetry.getTracer('SequencerPublisher');
     this.l1TxUtils = deps.l1TxUtils;
-    this.getNextPublisher = deps.getNextPublisher;
 
     this.rollupContract = deps.rollupContract;
 
@@ -228,31 +211,6 @@ export class SequencerPublisher {
       this.rollupContract,
       createLogger('sequencer:publisher:price-oracle'),
     );
-
-    // Initialize failed L1 tx store (optional, for test networks)
-    this.failedTxStore = createL1TxFailedStore(config.l1TxFailedStore, this.log);
-  }
-
-  /**
-   * Backs up a failed L1 transaction to the configured store for debugging.
-   * Does nothing if no store is configured.
-   */
-  private backupFailedTx(failedTx: Omit<FailedL1Tx, 'timestamp'>): void {
-    if (!this.failedTxStore) {
-      return;
-    }
-
-    const tx: FailedL1Tx = {
-      ...failedTx,
-      timestamp: Date.now(),
-    };
-
-    // Fire and forget - don't block on backup
-    void this.failedTxStore
-      .then(store => store?.saveFailedTx(tx))
-      .catch(err => {
-        this.log.warn(`Failed to backup failed L1 tx to store`, err);
-      });
   }
 
   public getRollupContract(): RollupContract {
@@ -291,7 +249,7 @@ export class SequencerPublisher {
   }
 
   public getCurrentL2Slot(): SlotNumber {
-    return this.epochCache.getSlotNow();
+    return this.epochCache.getEpochAndSlotNow().slot;
   }
 
   /**
@@ -434,36 +392,19 @@ export class SequencerPublisher {
     validRequests.sort((a, b) => compareActions(a.action, b.action));
 
     try {
-      // Capture context for failed tx backup before sending
-      const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-      const multicallData = encodeFunctionData({
-        abi: multicall3Abi,
-        functionName: 'aggregate3',
-        args: [
-          validRequests.map(r => ({
-            target: r.request.to!,
-            callData: r.request.data!,
-            allowFailure: true,
-          })),
-        ],
-      });
-      const blobDataHex = blobConfig?.blobs?.map(b => toHex(b)) as Hex[] | undefined;
-
-      const txContext = { multicallData, blobData: blobDataHex, l1BlockNumber };
-
       this.log.debug('Forwarding transactions', {
         validRequests: validRequests.map(request => request.action),
         txConfig,
       });
-      const result = await this.forwardWithPublisherRotation(validRequests, txConfig, blobConfig);
-      if (result === undefined) {
-        return undefined;
-      }
-      const { successfulActions = [], failedActions = [] } = this.callbackBundledTransactions(
-        validRequests,
-        result,
-        txContext,
+      const result = await Multicall3.forward(
+        validRequests.map(request => request.request),
+        this.l1TxUtils,
+        txConfig,
+        blobConfig,
+        this.rollupContract.address,
+        this.log,
       );
+      const { successfulActions = [], failedActions = [] } = this.callbackBundledTransactions(validRequests, result);
       return { result, expiredActions, sentActions: validActions, successfulActions, failedActions };
     } catch (err) {
       const viemError = formatViemError(err);
@@ -481,76 +422,13 @@ export class SequencerPublisher {
     }
   }
 
-  /**
-   * Forwards transactions via Multicall3, rotating to the next available publisher if a send
-   * failure occurs (i.e. the tx never reached the chain).
-   * On-chain reverts and simulation errors are returned as-is without rotation.
-   */
-  private async forwardWithPublisherRotation(
-    validRequests: RequestWithExpiry[],
-    txConfig: RequestWithExpiry['gasConfig'],
-    blobConfig: L1BlobInputs | undefined,
-  ) {
-    const triedAddresses: EthAddress[] = [];
-    let currentPublisher = this.l1TxUtils;
-
-    while (true) {
-      triedAddresses.push(currentPublisher.getSenderAddress());
-      try {
-        const result = await Multicall3.forward(
-          validRequests.map(r => r.request),
-          currentPublisher,
-          txConfig,
-          blobConfig,
-          this.rollupContract.address,
-          this.log,
-        );
-        this.l1TxUtils = currentPublisher;
-        return result;
-      } catch (err) {
-        if (err instanceof TimeoutError) {
-          throw err;
-        }
-        const viemError = formatViemError(err);
-        if (!this.getNextPublisher) {
-          this.log.error('Failed to publish bundled transactions', viemError);
-          return undefined;
-        }
-        this.log.warn(
-          `Publisher ${currentPublisher.getSenderAddress()} failed to send, rotating to next publisher`,
-          viemError,
-        );
-        const nextPublisher = await this.getNextPublisher([...triedAddresses]);
-        if (!nextPublisher) {
-          this.log.error('All available publishers exhausted, failed to publish bundled transactions');
-          return undefined;
-        }
-        currentPublisher = nextPublisher;
-      }
-    }
-  }
-
   private callbackBundledTransactions(
     requests: RequestWithExpiry[],
-    result: { receipt: TransactionReceipt; errorMsg?: string } | FormattedViemError | undefined,
-    txContext: { multicallData: Hex; blobData?: Hex[]; l1BlockNumber: bigint },
+    result?: { receipt: TransactionReceipt } | FormattedViemError,
   ) {
     const actionsListStr = requests.map(r => r.action).join(', ');
     if (result instanceof FormattedViemError) {
       this.log.error(`Failed to publish bundled transactions (${actionsListStr})`, result);
-      this.backupFailedTx({
-        id: keccak256(txContext.multicallData),
-        failureType: 'send-error',
-        request: { to: MULTI_CALL_3_ADDRESS, data: txContext.multicallData },
-        blobData: txContext.blobData,
-        l1BlockNumber: txContext.l1BlockNumber.toString(),
-        error: { message: result.message, name: result.name },
-        context: {
-          actions: requests.map(r => r.action),
-          requests: requests.map(r => ({ action: r.action, to: r.request.to! as Hex, data: r.request.data! })),
-          sender: this.getSenderAddress().toString(),
-        },
-      });
       return { failedActions: requests.map(r => r.action) };
     } else {
       this.log.verbose(`Published bundled transactions (${actionsListStr})`, {
@@ -572,30 +450,6 @@ export class SequencerPublisher {
           failedActions.push(request.action);
         }
       }
-      // Single backup for the whole reverted tx
-      if (failedActions.length > 0 && result?.receipt?.status === 'reverted') {
-        this.backupFailedTx({
-          id: result.receipt.transactionHash,
-          failureType: 'revert',
-          request: { to: MULTI_CALL_3_ADDRESS, data: txContext.multicallData },
-          blobData: txContext.blobData,
-          l1BlockNumber: result.receipt.blockNumber.toString(),
-          receipt: {
-            transactionHash: result.receipt.transactionHash,
-            blockNumber: result.receipt.blockNumber.toString(),
-            gasUsed: (result.receipt.gasUsed ?? 0n).toString(),
-            status: 'reverted',
-          },
-          error: { message: result.errorMsg ?? 'Transaction reverted' },
-          context: {
-            actions: failedActions,
-            requests: requests
-              .filter(r => failedActions.includes(r.action))
-              .map(r => ({ action: r.action, to: r.request.to! as Hex, data: r.request.data! })),
-            sender: this.getSenderAddress().toString(),
-          },
-        });
-      }
       return { successfulActions, failedActions };
     }
   }
@@ -613,7 +467,7 @@ export class SequencerPublisher {
     // TODO: #14291 - should loop through multiple keys to check if any of them can propose
     const ignoredErrors = ['SlotAlreadyInChain', 'InvalidProposer', 'InvalidArchive'];
 
-    const pipelined = opts.pipelined ?? this.epochCache.isProposerPipeliningEnabled();
+    const pipelined = opts.pipelined ?? false;
     const slotOffset = pipelined ? this.aztecSlotDuration : 0n;
     const nextL1SlotTs = this.getNextL1SlotTimestamp() + slotOffset;
 
@@ -632,7 +486,6 @@ export class SequencerPublisher {
         return undefined;
       });
   }
-
   /**
    * @notice  Will simulate `validateHeader` to make sure that the block header is valid
    * @dev     This is a convenience function that can be used by the sequencer to validate a "partial" header.
@@ -712,8 +565,6 @@ export class SequencerPublisher {
     const request = this.buildInvalidateCheckpointRequest(validationResult);
     this.log.debug(`Simulating invalidate checkpoint ${checkpointNumber}`, { ...logData, request });
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-
     try {
       const { gasUsed } = await this.l1TxUtils.simulate(
         request,
@@ -765,18 +616,6 @@ export class SequencerPublisher {
 
       // Otherwise, throw. We cannot build the next checkpoint if we cannot invalidate the previous one.
       this.log.error(`Simulation for invalidate checkpoint ${checkpointNumber} failed`, viemError, logData);
-      this.backupFailedTx({
-        id: keccak256(request.data!),
-        failureType: 'simulation',
-        request: { to: request.to!, data: request.data!, value: request.value?.toString() },
-        l1BlockNumber: l1BlockNumber.toString(),
-        error: { message: viemError.message, name: viemError.name },
-        context: {
-          actions: [`invalidate-${reason}`],
-          checkpointNumber,
-          sender: this.getSenderAddress().toString(),
-        },
-      });
       throw new Error(`Failed to simulate invalidate checkpoint ${checkpointNumber}`, { cause: viemError });
     }
   }
@@ -921,7 +760,6 @@ export class SequencerPublisher {
       lastValidL2Slot: slotNumber,
     });
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
     const timestamp = this.getSimulationTimestamp(slotNumber);
 
     try {
@@ -931,19 +769,6 @@ export class SequencerPublisher {
       const viemError = formatViemError(err);
       this.log.error(`Failed simulation for ${action} at slot ${slotNumber} (enqueuing the action anyway)`, viemError, {
         simulationTimestamp: timestamp,
-        l1BlockNumber,
-      });
-      this.backupFailedTx({
-        id: keccak256(request.data!),
-        failureType: 'simulation',
-        request: { to: request.to!, data: request.data!, value: request.value?.toString() },
-        l1BlockNumber: l1BlockNumber.toString(),
-        error: { message: viemError.message, name: viemError.name },
-        context: {
-          actions: [action],
-          slot: slotNumber,
-          sender: this.getSenderAddress().toString(),
-        },
       });
       // Yes, we enqueue the request anyway, in case there was a bug with the simulation itself
     }
@@ -1229,8 +1054,6 @@ export class SequencerPublisher {
 
     this.log.debug(`Simulating ${action} for slot ${slotNumber}`, logData);
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-
     let gasUsed: bigint;
     const simulateAbi = mergeAbis([request.abi ?? [], ErrorsAbi]);
 
@@ -1241,19 +1064,6 @@ export class SequencerPublisher {
       const viemError = formatViemError(err, simulateAbi);
       this.log.error(`Simulation for ${action} at ${slotNumber} failed`, viemError, logData);
 
-      this.backupFailedTx({
-        id: keccak256(request.data!),
-        failureType: 'simulation',
-        request: { to: request.to!, data: request.data!, value: request.value?.toString() },
-        l1BlockNumber: l1BlockNumber.toString(),
-        error: { message: viemError.message, name: viemError.name },
-        context: {
-          actions: [action],
-          slot: slotNumber,
-          sender: this.getSenderAddress().toString(),
-        },
-      });
-
       return false;
     }
 
@@ -1336,27 +1146,9 @@ export class SequencerPublisher {
             kzg,
           },
         )
-        .catch(async err => {
-          const viemError = formatViemError(err);
-          this.log.error(`Failed to validate blobs`, viemError.message, { metaMessages: viemError.metaMessages });
-          const validateBlobsData = encodeFunctionData({
-            abi: RollupAbi,
-            functionName: 'validateBlobs',
-            args: [blobInput],
-          });
-          const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
-          this.backupFailedTx({
-            id: keccak256(validateBlobsData),
-            failureType: 'simulation',
-            request: { to: this.rollupContract.address as Hex, data: validateBlobsData },
-            blobData: encodedData.blobs.map(b => toHex(b.data)) as Hex[],
-            l1BlockNumber: l1BlockNumber.toString(),
-            error: { message: viemError.message, name: viemError.name },
-            context: {
-              actions: ['validate-blobs'],
-              sender: this.getSenderAddress().toString(),
-            },
-          });
+        .catch(err => {
+          const { message, metaMessages } = formatViemError(err);
+          this.log.error(`Failed to validate blobs`, message, { metaMessages });
           throw new Error('Failed to validate blobs');
         });
     }
@@ -1433,7 +1225,6 @@ export class SequencerPublisher {
       });
     }
 
-    const l1BlockNumber = await this.l1TxUtils.getBlockNumber();
     const simTs = this.getSimulationTimestamp(SlotNumber.fromBigInt(args[0].header.slotNumber));
 
     const simulationResult = await this.l1TxUtils
@@ -1468,18 +1259,6 @@ export class SequencerPublisher {
           };
         }
         this.log.error(`Failed to simulate propose tx`, viemError, { simulationTimestamp: simTs });
-        this.backupFailedTx({
-          id: keccak256(rollupData),
-          failureType: 'simulation',
-          request: { to: this.rollupContract.address, data: rollupData },
-          l1BlockNumber: l1BlockNumber.toString(),
-          error: { message: viemError.message, name: viemError.name },
-          context: {
-            actions: ['propose'],
-            slot: Number(args[0].header.slotNumber),
-            sender: this.getSenderAddress().toString(),
-          },
-        });
         throw err;
       });