@aztec/sequencer-client 0.0.1-commit.b6e433891 → 0.0.1-commit.b8a057fa

package/src/global_variable_builder/global_builder.ts

@@ -1,13 +1,12 @@
-import { createEthereumChain } from '@aztec/ethereum/chain';
-import { makeL1HttpTransport } from '@aztec/ethereum/client';
-import type { L1ContractsConfig } from '@aztec/ethereum/config';
-import { RollupContract } from '@aztec/ethereum/contracts';
-import type { L1ReaderConfig } from '@aztec/ethereum/l1-reader';
+import {
+  RollupContract,
+  type SimulationOverridesPlan,
+  buildSimulationOverridesStateOverride,
+} from '@aztec/ethereum/contracts';
 import type { ViemPublicClient } from '@aztec/ethereum/types';
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-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 { 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';
@@ -15,21 +14,19 @@ import type {
   CheckpointGlobalVariables,
   GlobalVariableBuilder as GlobalVariableBuilderInterface,
 } from '@aztec/stdlib/tx';
-import { GlobalVariables } from '@aztec/stdlib/tx';
 
-import { createPublicClient } from 'viem';
+/** 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 currentMinFees: 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 readonly aztecSlotDuration: number;
   private readonly l1GenesisTime: bigint;
 
@@ -37,83 +34,16 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
   private version: Fr;
 
   constructor(
-    config: L1ReaderConfig &
-      Pick<L1ContractsConfig, 'ethereumSlotDuration'> &
-      Pick<L1RollupConstants, 'slotDuration' | 'l1GenesisTime'> & { rollupVersion: bigint },
+    private readonly publicClient: ViemPublicClient,
+    config: GlobalVariableBuilderConfig,
   ) {
-    const { l1RpcUrls, l1ChainId: chainId, l1Contracts } = config;
-
-    const chain = createEthereumChain(l1RpcUrls, chainId);
-
     this.version = new Fr(config.rollupVersion);
-    this.chainId = new Fr(chainId);
+    this.chainId = new Fr(this.publicClient.chain!.id);
 
-    this.ethereumSlotDuration = config.ethereumSlotDuration;
     this.aztecSlotDuration = config.slotDuration;
     this.l1GenesisTime = config.l1GenesisTime;
 
-    this.publicClient = createPublicClient({
-      chain: chain.chainInfo,
-      transport: makeL1HttpTransport(chain.rpcUrls, { timeout: config.l1HttpTimeoutMS }),
-      pollingInterval: config.viemPollingIntervalMS,
-    });
-
-    this.rollupContract = new RollupContract(this.publicClient, l1Contracts.rollupAddress);
-  }
-
-  /**
-   * Computes the "current" min fees, e.g., the price that you currently should pay to get include in the next block
-   * @returns Min fees for the next block
-   */
-  private async computeCurrentMinFees(): 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 lastCheckpoint = await this.rollupContract.getPendingCheckpoint();
-    const earliestTimestamp = await this.rollupContract.getTimestampForSlot(
-      SlotNumber.fromBigInt(BigInt(lastCheckpoint.slotNumber) + 1n),
-    );
-    const nextEthTimestamp = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
-    const timestamp = earliestTimestamp > nextEthTimestamp ? earliestTimestamp : nextEthTimestamp;
-
-    return new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
-  }
-
-  public async getCurrentMinFees(): 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 min fees
-    if (this.currentL1BlockNumber === undefined || blockNumber > this.currentL1BlockNumber) {
-      this.currentL1BlockNumber = blockNumber;
-      this.currentMinFees = this.currentMinFees.then(() => this.computeCurrentMinFees());
-    }
-    return this.currentMinFees;
-  }
-
-  /**
-   * Simple builder of 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.
-   * @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,
-    coinbase: EthAddress,
-    feeRecipient: AztecAddress,
-    maybeSlot?: SlotNumber,
-  ): Promise<GlobalVariables> {
-    const slot: SlotNumber =
-      maybeSlot ??
-      (await this.rollupContract.getSlotAt(
-        BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration)),
-      ));
-
-    const checkpointGlobalVariables = await this.buildCheckpointGlobalVariables(coinbase, feeRecipient, slot);
-    return GlobalVariables.from({ blockNumber, ...checkpointGlobalVariables });
+    this.rollupContract = new RollupContract(this.publicClient, config.rollupAddress);
   }
 
   /** Builds global variables that are constant throughout a checkpoint. */
@@ -121,6 +51,7 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
     slotNumber: SlotNumber,
+    simulationOverridesPlan?: SimulationOverridesPlan,
   ): Promise<CheckpointGlobalVariables> {
     const { chainId, version } = this;
 
@@ -129,9 +60,8 @@ export class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
       l1GenesisTime: this.l1GenesisTime,
     });
 
-    // We can skip much of the logic in getCurrentMinFees since it we already check that we are not within a slot elsewhere.
-    // TODO(palla/mbps): Can we use a cached value here?
-    const gasFees = new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
+    const stateOverride = await buildSimulationOverridesStateOverride(this.rollupContract, simulationOverridesPlan);
+    const gasFees = new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true, stateOverride));
 
     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/publisher/config.ts

@@ -1,9 +1,16 @@
 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 } from '@aztec/foundation/config';
+import {
+  type ConfigMappingsType,
+  SecretValue,
+  booleanConfigHelper,
+  numberConfigHelper,
+} 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,13 +57,37 @@ export type PublisherConfig = L1TxUtilsConfig &
     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 &
@@ -64,8 +95,16 @@ export type SequencerPublisherConfig = L1TxUtilsConfig &
     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 {
@@ -85,12 +124,13 @@ export function getPublisherConfigFromSequencerConfig(config: SequencerPublisher
   };
 }
 
-export const proverTxSenderConfigMappings: ConfigMappingsType<Omit<ProverTxSenderConfig, 'l1Contracts'>> = {
+export const proverTxSenderConfigMappings: ConfigMappingsType<ProverTxSenderConfig> = {
   ...l1ReaderConfigMappings,
   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', '')}`)),
+    parseEnv: (val: string) =>
+      val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}` as `0x${string}`)),
     defaultValue: [],
     fallback: [`PROVER_PUBLISHER_PRIVATE_KEY`],
   },
@@ -102,12 +142,13 @@ export const proverTxSenderConfigMappings: ConfigMappingsType<Omit<ProverTxSende
   },
 };
 
-export const sequencerTxSenderConfigMappings: ConfigMappingsType<Omit<SequencerTxSenderConfig, 'l1Contracts'>> = {
+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', '')}`)),
+    parseEnv: (val: string) =>
+      val.split(',').map(key => new SecretValue(`0x${key.replace('0x', '')}` as `0x${string}`)),
     defaultValue: [],
     fallback: [`SEQ_PUBLISHER_PRIVATE_KEY`],
   },
@@ -136,12 +177,25 @@ export const sequencerPublisherConfigMappings: ConfigMappingsType<SequencerPubli
   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),
+    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 const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherConfig & L1TxUtilsConfig> = {
@@ -161,6 +215,7 @@ export const proverPublisherConfigMappings: ConfigMappingsType<ProverPublisherCo
   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),
+    parseEnv: (val: string) => EthAddress.fromString(val),
   },
+  ...publisherFundingConfigMappings,
 };

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/failed_tx_store.ts

@@ -1,31 +1,40 @@
+import type { WindowBlockFees } from '@aztec/ethereum/l1-fee-analysis';
+import type { GasPrice } from '@aztec/ethereum/l1-tx-utils';
+import type { Branded } from '@aztec/foundation/branded-types';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+
 import type { Hex } from 'viem';
+import { z } from 'zod';
 
 /** URI pointing to a stored failed L1 transaction. */
-export type FailedL1TxUri = string & { __brand: 'FailedL1TxUri' };
+export type FailedL1TxUri = Branded<string, 'FailedL1TxUri'>;
 
-/** A failed L1 transaction captured for debugging and replay. */
+/**
+ * A failed L1 transaction captured for debugging and replay. Serialized with jsonStringify (bigints
+ * become decimal strings on disk) and parsed back via FailedL1TxSchema.
+ */
 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';
+  /** How the failure occurred. */
+  failureType: 'simulation' | 'revert' | 'send-error' | 'timeout';
   /** The actual L1 transaction for replay (multicall-encoded for bundled txs). */
   request: {
     to: Hex;
     data: Hex;
-    value?: string; // bigint as string
+    value?: bigint;
   };
   /** 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
+  l1BlockNumber: bigint;
   /** Receipt info (present only for on-chain reverts). */
   receipt?: {
     transactionHash: Hex;
-    blockNumber: string; // bigint as string
-    gasUsed: string; // bigint as string
+    blockNumber: bigint;
+    gasUsed: bigint;
     status: 'reverted';
   };
   /** Error information. */
@@ -44,8 +53,108 @@ export type FailedL1Tx = {
     slot?: number;
     sender: Hex;
   };
+  /** Gas pricing info at time of failure for underpricing diagnosis. */
+  gasInfo?: {
+    /** Gas prices the tx was sent with (present for revert/send-error/timeout, not simulation). */
+    sentGasPrice?: GasPrice;
+    /** Gas limit used or estimated. */
+    gasLimit?: bigint;
+    /** Nonce used for the sent tx. */
+    nonce?: number;
+    /**
+     * For timeouts: the escalating gas prices used across the initial send and each speed-up retry,
+     * in order. Compare against windowBlocks[].minIncludedPriorityFee to see if any attempt cleared the bar.
+     */
+    sentGasPriceLadder?: GasPrice[];
+    /** Number of send attempts (initial send + speed-ups). */
+    attempts?: number;
+    /**
+     * Per-block fee data for the L1 blocks the tx could have been included in (the target L2 slot's
+     * inclusion window), in chronological order. Compare sentGasPrice against these to see whether
+     * the tx was underpriced for each block it competed for. May be a partial or empty list if the
+     * window was not yet mined when the failure was recorded (e.g. an early send failure).
+     */
+    windowBlocks?: WindowBlockFees[];
+  };
+  /** Timing info relative to the L2 slot. */
+  timing?: {
+    /** The target L2 slot this tx was for. */
+    targetL2Slot?: number;
+    /** Unix timestamp (seconds) when the target slot ends. */
+    slotDeadlineTimestampS?: bigint;
+    /** Milliseconds remaining until the slot deadline. Negative = past deadline. */
+    msUntilSlotDeadline?: number;
+  };
 };
 
+const hexSchema = schemas.HexStringWith0x;
+
+const gasPriceSchema = z.object({
+  maxFeePerGas: schemas.BigInt,
+  maxPriorityFeePerGas: schemas.BigInt,
+  maxFeePerBlobGas: schemas.BigInt.optional(),
+}) satisfies ZodFor<GasPrice>;
+
+const windowBlockFeesSchema = z.object({
+  blockNumber: schemas.BigInt,
+  timestamp: schemas.BigInt,
+  baseFeePerGas: schemas.BigInt,
+  p75PriorityFee: schemas.BigInt,
+  minIncludedPriorityFee: schemas.BigInt,
+  blockBlobsFull: z.boolean(),
+  includedBlobCount: z.number(),
+}) satisfies ZodFor<WindowBlockFees>;
+
+/** Parses a stored failed-tx record, coercing the on-disk decimal strings back to bigints. */
+export const FailedL1TxSchema: ZodFor<FailedL1Tx> = z.object({
+  id: hexSchema,
+  timestamp: z.number(),
+  failureType: z.enum(['simulation', 'revert', 'send-error', 'timeout']),
+  request: z.object({
+    to: hexSchema,
+    data: hexSchema,
+    value: schemas.BigInt.optional(),
+  }),
+  blobData: z.array(hexSchema).optional(),
+  l1BlockNumber: schemas.BigInt,
+  receipt: z
+    .object({
+      transactionHash: hexSchema,
+      blockNumber: schemas.BigInt,
+      gasUsed: schemas.BigInt,
+      status: z.literal('reverted'),
+    })
+    .optional(),
+  error: z.object({
+    message: z.string(),
+    name: z.string().optional(),
+  }),
+  context: z.object({
+    actions: z.array(z.string()),
+    requests: z.array(z.object({ action: z.string(), to: hexSchema, data: hexSchema })).optional(),
+    checkpointNumber: z.number().optional(),
+    slot: z.number().optional(),
+    sender: hexSchema,
+  }),
+  gasInfo: z
+    .object({
+      sentGasPrice: gasPriceSchema.optional(),
+      gasLimit: schemas.BigInt.optional(),
+      nonce: z.number().optional(),
+      sentGasPriceLadder: z.array(gasPriceSchema).optional(),
+      attempts: z.number().optional(),
+      windowBlocks: z.array(windowBlockFeesSchema).optional(),
+    })
+    .optional(),
+  timing: z
+    .object({
+      targetL2Slot: z.number().optional(),
+      slotDeadlineTimestampS: schemas.BigInt.optional(),
+      msUntilSlotDeadline: z.number().optional(),
+    })
+    .optional(),
+});
+
 /** Store for failed L1 transactions for debugging purposes. */
 export interface L1TxFailedStore {
   /** Saves a failed transaction and returns its URI. */

package/src/publisher/l1_tx_failed_store/file_store_failed_tx_store.ts

@@ -1,7 +1,8 @@
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
 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';
+import { type FailedL1Tx, FailedL1TxSchema, type FailedL1TxUri, type L1TxFailedStore } from './failed_tx_store.js';
 
 /**
  * L1TxFailedStore implementation using the FileStore abstraction.
@@ -20,7 +21,7 @@ export class FileStoreL1TxFailedStore implements L1TxFailedStore {
   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 json = jsonStringify(tx, true);
 
     const uri = await this.fileStore.save(path, Buffer.from(json), {
       metadata: {
@@ -41,6 +42,6 @@ export class FileStoreL1TxFailedStore implements L1TxFailedStore {
 
   public async getFailedTx(uri: FailedL1TxUri): Promise<FailedL1Tx> {
     const data = await this.fileStore.read(uri);
-    return JSON.parse(data.toString()) as FailedL1Tx;
+    return jsonParseWithSchema(data.toString(), FailedL1TxSchema);
   }
 }

package/src/publisher/l1_tx_failed_store/index.ts

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