@aztec/sequencer-client 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/global_variable_builder/global_builder.ts

@@ -1,133 +1,68 @@
 import {
-  type L1ContractsConfig,
-  type L1ReaderConfig,
   RollupContract,
-  type ViemPublicClient,
-  createEthereumChain,
-} from '@aztec/ethereum';
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+  type SimulationOverridesPlan,
+  buildSimulationOverridesStateOverride,
+} from '@aztec/ethereum/contracts';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type L1RollupConstants, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { GasFees } from '@aztec/stdlib/gas';
-import type { GlobalVariableBuilder as GlobalVariableBuilderInterface } from '@aztec/stdlib/tx';
-import { GlobalVariables } from '@aztec/stdlib/tx';
-
-import { createPublicClient, fallback, http } from 'viem';
+import type {
+  CheckpointGlobalVariables,
+  GlobalVariableBuilder as GlobalVariableBuilderInterface,
+} from '@aztec/stdlib/tx';
+
+/** Configuration for the GlobalVariableBuilder (excludes L1 client config). */
+export type GlobalVariableBuilderConfig = {
+  rollupAddress: EthAddress;
+  ethereumSlotDuration: number;
+  rollupVersion: bigint;
+} & Pick<L1RollupConstants, 'slotDuration' | 'l1GenesisTime'>;
 
 /**
  * Simple global variables builder.
  */
 export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
-  private log = createLogger('sequencer:global_variable_builder');
-  private currentBaseFees: Promise<GasFees> = Promise.resolve(new GasFees(0, 0));
-  private currentL1BlockNumber: bigint | undefined = undefined;
-
   private readonly rollupContract: RollupContract;
-  private readonly publicClient: ViemPublicClient;
-  private readonly ethereumSlotDuration: number;
-
-  private chainId?: Fr;
-  private version?: Fr;
-
-  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 = new RollupContract(this.publicClient, l1Contracts.rollupAddress);
-  }
-
-  /**
-   * 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 next block
-   */
-  private async computeCurrentBaseFees(): 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.
+  private readonly aztecSlotDuration: number;
+  private readonly l1GenesisTime: bigint;
 
-    const lastBlock = await this.rollupContract.getCheckpoint(await this.rollupContract.getCheckpointNumber());
-    const earliestTimestamp = await this.rollupContract.getTimestampForSlot(
-      SlotNumber.fromBigInt(lastBlock.slotNumber + 1n),
-    );
-    const nextEthTimestamp = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
-    const timestamp = earliestTimestamp > nextEthTimestamp ? earliestTimestamp : nextEthTimestamp;
+  private chainId: Fr;
+  private version: Fr;
 
-    return new GasFees(0, await this.rollupContract.getManaBaseFeeAt(timestamp, true));
-  }
+  constructor(
+    private readonly publicClient: ViemPublicClient,
+    config: GlobalVariableBuilderConfig,
+  ) {
+    this.version = new Fr(config.rollupVersion);
+    this.chainId = new Fr(this.publicClient.chain!.id);
 
-  public async getCurrentBaseFees(): Promise<GasFees> {
-    // Get the current block number
-    const blockNumber = await this.publicClient.getBlockNumber();
-
-    // If the L1 block number has changed then chain a new promise to get the current base fees
-    if (this.currentL1BlockNumber === undefined || blockNumber > this.currentL1BlockNumber) {
-      this.currentL1BlockNumber = blockNumber;
-      this.currentBaseFees = this.currentBaseFees.then(() => this.computeCurrentBaseFees());
-    }
-    return this.currentBaseFees;
-  }
+    this.aztecSlotDuration = config.slotDuration;
+    this.l1GenesisTime = config.l1GenesisTime;
 
-  public async getGlobalConstantVariables(): Promise<Pick<GlobalVariables, 'chainId' | 'version'>> {
-    if (!this.chainId) {
-      this.chainId = new Fr(this.publicClient.chain.id);
-    }
-    if (!this.version) {
-      this.version = new Fr(await this.rollupContract.getVersion());
-    }
-    return { chainId: this.chainId, version: this.version };
+    this.rollupContract = new RollupContract(this.publicClient, config.rollupAddress);
   }
 
-  /**
-   * 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: BlockNumber,
+  /** Builds global variables that are constant throughout a checkpoint. */
+  public async buildCheckpointGlobalVariables(
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
-    slotNumber?: SlotNumber,
-  ): Promise<GlobalVariables> {
-    const { chainId, version } = await this.getGlobalConstantVariables();
-
-    let slot: SlotNumber;
-    if (slotNumber === undefined) {
-      const ts = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
-      slot = await this.rollupContract.getSlotAt(ts);
-    } else {
-      slot = slotNumber;
-    }
-
-    const timestamp = await this.rollupContract.getTimestampForSlot(slot);
-
-    // 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(0, await this.rollupContract.getManaBaseFeeAt(timestamp, true));
+    slotNumber: SlotNumber,
+    simulationOverridesPlan?: SimulationOverridesPlan,
+  ): Promise<CheckpointGlobalVariables> {
+    const { chainId, version } = this;
+
+    const timestamp = getTimestampForSlot(slotNumber, {
+      slotDuration: this.aztecSlotDuration,
+      l1GenesisTime: this.l1GenesisTime,
+    });
 
-    const globalVariables = new GlobalVariables(
-      chainId,
-      version,
-      blockNumber,
-      slot,
-      timestamp,
-      coinbase,
-      feeRecipient,
-      gasFees,
-    );
+    const stateOverride = await buildSimulationOverridesStateOverride(this.rollupContract, simulationOverridesPlan);
+    const gasFees = new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true, stateOverride));
 
-    return globalVariables;
+    return { chainId, version, slotNumber, timestamp, coinbase, feeRecipient, gasFees };
   }
 }

package/src/global_variable_builder/index.ts

@@ -1 +1,3 @@
-export { GlobalVariableBuilder } from './global_builder.js';
+export { FeeProviderImpl } from './fee_provider.js';
+export { GlobalVariableBuilder, type GlobalVariableBuilderConfig } from './global_builder.js';
+export { FeePredictor } from './fee_predictor.js';

package/src/index.ts

@@ -1,13 +1,7 @@
 export * from './client/index.js';
 export * from './config.js';
 export * from './publisher/index.js';
-export {
-  FullNodeBlockBuilder as BlockBuilder,
-  Sequencer,
-  SequencerState,
-  type SequencerEvents,
-} from './sequencer/index.js';
-export * from './tx_validator/tx_validator_factory.js';
+export { Sequencer, SequencerState, type SequencerEvents } from './sequencer/index.js';
 
 // Used by the node to simulate public parts of transactions. Should these be moved to a shared library?
 // ISSUE(#9832)

package/src/publisher/config.ts

@@ -1,73 +1,171 @@
-import { type BlobSinkConfig, blobSinkConfigMapping } from '@aztec/blob-sink/client';
-import {
-  type L1ReaderConfig,
-  type L1TxUtilsConfig,
-  l1ReaderConfigMappings,
-  l1TxUtilsConfigMappings,
-} from '@aztec/ethereum';
+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,
+  numberConfigHelper,
 } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
-/**
- * The configuration of the rollup transaction publisher.
- */
+import { parseEther } from 'viem';
+
+/** 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 &
-  BlobSinkConfig & {
+  BlobClientConfig & {
     /** True to use publishers in invalid states (timed out, cancelled, etc) if no other is available */
     publisherAllowInvalidStates?: boolean;
     /** Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1 */
     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;
   };
 
-export const getTxSenderConfigMappings: (
-  scope: 'PROVER' | 'SEQ',
-) => ConfigMappingsType<Omit<TxSenderConfig, 'l1Contracts'>> = (scope: 'PROVER' | 'SEQ') => ({
+/** 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 &
+  BlobClientConfig & {
+    fishermanMode?: boolean;
+    sequencerPublisherAllowInvalidStates?: boolean;
+    sequencerPublisherForwarderAddress?: EthAddress;
+    /** How long to wait for the previous L1 block before sending scheduled publisher txs anyway. */
+    sequencerPublisherPreviousL1BlockWaitTimeoutMs: number;
+    /** Poll interval while waiting for the previous L1 block before scheduled publisher txs. */
+    sequencerPublisherPreviousL1BlockWaitPollIntervalMs: number;
+    /** 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 {
+  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<ProverTxSenderConfig> = {
   ...l1ReaderConfigMappings,
-  publisherPrivateKeys: {
-    env: scope === 'PROVER' ? `PROVER_PUBLISHER_PRIVATE_KEYS` : `SEQ_PUBLISHER_PRIVATE_KEYS`,
-    description: 'The private keys to be used by the publisher.',
-    parseEnv: (val: string) => val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}`)),
+  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', '')}` as `0x${string}`)),
     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<SequencerTxSenderConfig> = {
+  ...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', '')}` as `0x${string}`)),
+    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: {
@@ -76,10 +174,48 @@ export const getPublisherConfigMappings: (
       'Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1',
     ...booleanConfigHelper(false),
   },
-  ...l1TxUtilsConfigMappings,
-  ...blobSinkConfigMapping,
-});
+  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) => EthAddress.fromString(val),
+  },
+  sequencerPublisherPreviousL1BlockWaitTimeoutMs: {
+    env: `SEQ_PUBLISHER_PREVIOUS_L1_BLOCK_WAIT_TIMEOUT_MS`,
+    description:
+      'How long to wait for the previous L1 block before sending scheduled publisher txs anyway, in milliseconds.',
+    ...numberConfigHelper(8_000),
+  },
+  sequencerPublisherPreviousL1BlockWaitPollIntervalMs: {
+    env: `SEQ_PUBLISHER_PREVIOUS_L1_BLOCK_WAIT_POLL_INTERVAL_MS`,
+    description:
+      'Poll interval while waiting for the previous L1 block before scheduled publisher txs, in milliseconds.',
+    ...numberConfigHelper(500),
+  },
+  l1TxFailedStore: {
+    env: 'L1_TX_FAILED_STORE',
+    description: 'Store for failed L1 transaction inputs (test networks only). Format: gs://bucket/path',
+  },
+  ...publisherFundingConfigMappings,
+};
 
-export function getPublisherConfigFromEnv(scope: 'PROVER' | 'SEQ'): PublisherConfig {
-  return getConfigFromMappings(getPublisherConfigMappings(scope));
-}
+export const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherConfig & L1TxUtilsConfig> = {
+  ...l1TxUtilsConfigMappings,
+  ...blobClientConfigMapping,
+  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) => EthAddress.fromString(val),
+  },
+  ...publisherFundingConfigMappings,
+};

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_to_l2_messaging.ts

@@ -0,0 +1,85 @@
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { tryJsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import { InboxAbi } from '@aztec/l1-artifacts';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import { decodeEventLog, getContract } from 'viem';
+
+/**
+ * Sends an L1-to-L2 message via the Inbox contract and returns its hash and global leaf index.
+ * Test helper copied from the end-to-end fixtures so this integration test can live in sequencer-client.
+ */
+export async function sendL1ToL2Message(
+  message: { recipient: AztecAddress; content: Fr; secretHash: Fr },
+  ctx: {
+    l1Client: ExtendedViemWalletClient;
+    l1ContractAddresses: Pick<L1ContractAddresses, 'inboxAddress' | 'rollupAddress'>;
+  },
+) {
+  const logger = createLogger('sequencer-client:l1_to_l2_messaging');
+  const inbox = getContract({
+    address: ctx.l1ContractAddresses.inboxAddress.toString(),
+    abi: InboxAbi,
+    client: ctx.l1Client,
+  });
+
+  const { recipient, content, secretHash } = message;
+
+  const version = await new RollupContract(ctx.l1Client, ctx.l1ContractAddresses.rollupAddress.toString()).getVersion();
+
+  // We inject the message to Inbox
+  const txHash = await inbox.write.sendL2Message(
+    [{ actor: recipient.toString(), version: BigInt(version) }, content.toString(), secretHash.toString()],
+    {
+      gas: 1_000_000n,
+    },
+  );
+  logger.info(`L1 to L2 message sent in tx ${txHash}`);
+
+  // We check that the message was correctly injected by checking the emitted event
+  const txReceipt = await ctx.l1Client.waitForTransactionReceipt({ hash: txHash });
+
+  if (txReceipt.status !== 'success') {
+    throw new Error(`L1 to L2 message failed to be sent in tx ${txHash}. Status: ${txReceipt.status}`);
+  }
+
+  logger.info(`L1 to L2 message receipt retrieved for tx ${txReceipt.transactionHash}`, txReceipt);
+
+  if (txReceipt.transactionHash !== txHash) {
+    throw new Error(`Receipt transaction hash mismatch: ${txReceipt.transactionHash} !== ${txHash}`);
+  }
+
+  // Filter for MessageSent events from the Inbox contract by trying to decode each log
+  const messageSentLogs = txReceipt.logs
+    .filter(log => log.address.toLowerCase() === ctx.l1ContractAddresses.inboxAddress.toString().toLowerCase())
+    .map(log => {
+      try {
+        const decoded = decodeEventLog({
+          abi: InboxAbi,
+          data: log.data,
+          topics: log.topics,
+        });
+        return { log, decoded };
+      } catch {
+        return null; // Not a decodable event from this ABI
+      }
+    })
+    .filter((item): item is { log: any; decoded: any } => item !== null && item.decoded.eventName === 'MessageSent');
+
+  if (messageSentLogs.length !== 1) {
+    throw new Error(
+      `Wrong number of MessageSent logs found in ${txHash} transaction (got ${messageSentLogs.length} expected 1)\n${tryJsonStringify(messageSentLogs.map(item => item.log))}`,
+    );
+  }
+
+  // We already have the decoded event
+  const topics = messageSentLogs[0].decoded;
+  const receivedMsgHash = topics.args.hash;
+  const receivedGlobalLeafIndex = topics.args.index;
+
+  return { msgHash: Fr.fromHexString(receivedMsgHash), globalLeafIndex: new Fr(receivedGlobalLeafIndex), txReceipt };
+}

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);
+}