@aztec/p2p 0.0.1-commit.1142ef1 → 0.0.1-commit.1bea0213

package/src/msg_validators/clock_tolerance.ts

@@ -0,0 +1,51 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+
+/**
+ * Maximum clock disparity tolerance for P2P message validation (in milliseconds).
+ * Messages for the previous slot are accepted if we're within this many milliseconds
+ * of the current slot start. This prevents penalizing peers for messages that
+ * were valid when sent but arrived slightly late due to network latency.
+ *
+ * This follows Ethereum's MAXIMUM_GOSSIP_CLOCK_DISPARITY approach.
+ */
+export const MAXIMUM_GOSSIP_CLOCK_DISPARITY_MS = 500;
+
+/**
+ * Checks if a message for the previous slot should be accepted due to clock tolerance.
+ *
+ * @param messageSlot - The slot number from the received message
+ * @param currentSlot - The current slot number
+ * @param epochCache - EpochCache to get timing information
+ * @returns true if the message is for the previous slot AND we're within the clock tolerance window
+ */
+export function isWithinClockTolerance(
+  messageSlot: SlotNumber,
+  currentSlot: SlotNumber,
+  epochCache: EpochCacheInterface,
+): boolean {
+  // Guard against slot 0 edge case (genesis)
+  if (currentSlot === SlotNumber.ZERO) {
+    return false;
+  }
+
+  // Only apply tolerance to messages for the previous slot
+  const previousSlot = SlotNumber(currentSlot - 1);
+  if (messageSlot !== previousSlot) {
+    return false;
+  }
+
+  // Check how far we are into the current slot (in milliseconds)
+  const { ts: slotStartTs, nowMs, slot } = epochCache.getEpochAndSlotNow();
+
+  // Sanity check: ensure the epoch cache's current slot matches the expected current slot
+  if (slot !== currentSlot) {
+    return false;
+  }
+
+  // ts is in seconds, convert to ms; nowMs is already in milliseconds
+  const slotStartMs = slotStartTs * 1000n;
+  const elapsedMs = Number(nowMs - slotStartMs);
+
+  return elapsedMs < MAXIMUM_GOSSIP_CLOCK_DISPARITY_MS;
+}

package/src/msg_validators/proposal_validator/proposal_validator.ts

@@ -1,7 +1,9 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { BlockProposal, CheckpointProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { BlockProposal, CheckpointProposal, PeerErrorSeverity, type ValidationResult } from '@aztec/stdlib/p2p';
+
+import { isWithinClockTolerance } from '../clock_tolerance.js';
 
 export abstract class ProposalValidator<TProposal extends BlockProposal | CheckpointProposal> {
   protected epochCache: EpochCacheInterface;
@@ -14,13 +16,26 @@ export abstract class ProposalValidator<TProposal extends BlockProposal | Checkp
     this.logger = createLogger(loggerName);
   }
 
-  public async validate(proposal: TProposal): Promise<PeerErrorSeverity | undefined> {
+  public async validate(proposal: TProposal): Promise<ValidationResult> {
     try {
+      // Slot check
+      const { currentSlot, nextSlot } = this.epochCache.getCurrentAndNextSlot();
+      const slotNumber = proposal.slotNumber;
+      if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+        // Check if message is for previous slot and within clock tolerance
+        if (!isWithinClockTolerance(slotNumber, currentSlot, this.epochCache)) {
+          this.logger.debug(`Penalizing peer for invalid slot number ${slotNumber}`, { currentSlot, nextSlot });
+          return { result: 'reject', severity: PeerErrorSeverity.HighToleranceError };
+        }
+        this.logger.debug(`Ignoring proposal for previous slot ${slotNumber} within clock tolerance`);
+        return { result: 'ignore' };
+      }
+
       // Signature validity
       const proposer = proposal.getSender();
       if (!proposer) {
         this.logger.debug(`Penalizing peer for proposal with invalid signature`);
-        return PeerErrorSeverity.MidToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
       }
 
       // Transactions permitted check
@@ -29,7 +44,7 @@ export abstract class ProposalValidator<TProposal extends BlockProposal | Checkp
         this.logger.debug(
           `Penalizing peer for proposal with ${proposal.txHashes.length} transaction(s) when transactions are not permitted`,
         );
-        return PeerErrorSeverity.MidToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
       }
 
       // Embedded txs must be listed in txHashes
@@ -44,32 +59,17 @@ export abstract class ProposalValidator<TProposal extends BlockProposal | Checkp
           txHashesLength: proposal.txHashes.length,
           missingTxHashes,
         });
-        return PeerErrorSeverity.MidToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
       }
 
-      // Slot and proposer checks
-      const { currentProposer, nextProposer, currentSlot, nextSlot } =
-        await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
-      const slotNumber = proposal.slotNumber;
-      if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
-        this.logger.debug(`Penalizing peer for invalid slot number ${slotNumber}`, { currentSlot, nextSlot });
-        return PeerErrorSeverity.HighToleranceError;
-      }
-      if (slotNumber === currentSlot && currentProposer !== undefined && !proposer.equals(currentProposer)) {
+      // Proposer check
+      const expectedProposer = await this.epochCache.getProposerAttesterAddressInSlot(slotNumber);
+      if (expectedProposer !== undefined && !proposer.equals(expectedProposer)) {
         this.logger.debug(`Penalizing peer for invalid proposer for current slot ${slotNumber}`, {
-          currentProposer,
-          nextProposer,
-          proposer: proposer.toString(),
-        });
-        return PeerErrorSeverity.MidToleranceError;
-      }
-      if (slotNumber === nextSlot && nextProposer !== undefined && !proposer.equals(nextProposer)) {
-        this.logger.debug(`Penalizing peer for invalid proposer for next slot ${slotNumber}`, {
-          currentProposer,
-          nextProposer,
+          expectedProposer,
           proposer: proposer.toString(),
         });
-        return PeerErrorSeverity.MidToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
       }
 
       // Validate tx hashes for all txs embedded in the proposal
@@ -78,13 +78,13 @@ export abstract class ProposalValidator<TProposal extends BlockProposal | Checkp
           proposer,
           slotNumber,
         });
-        return PeerErrorSeverity.LowToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.LowToleranceError };
       }
 
-      return undefined;
+      return { result: 'accept' };
     } catch (e) {
       if (e instanceof NoCommitteeError) {
-        return PeerErrorSeverity.LowToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.LowToleranceError };
       }
       throw e;
     }

package/src/msg_validators/proposal_validator/proposal_validator_test_suite.ts

@@ -1,7 +1,12 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type BlockProposal, type CheckpointProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import {
+  type BlockProposal,
+  type CheckpointProposal,
+  PeerErrorSeverity,
+  type ValidationResult,
+} from '@aztec/stdlib/p2p';
 import type { TxHash } from '@aztec/stdlib/tx';
 
 import type { MockProxy } from 'jest-mock-extended';
@@ -10,7 +15,7 @@ export interface ProposalValidatorTestParams<TProposal extends BlockProposal | C
   validatorFactory: (
     epochCache: EpochCacheInterface,
     opts: { txsPermitted: boolean },
-  ) => { validate: (proposal: TProposal) => Promise<PeerErrorSeverity | undefined> };
+  ) => { validate: (proposal: TProposal) => Promise<ValidationResult> };
   makeProposal: (options?: any) => Promise<TProposal>;
   makeHeader: (epochNumber: number | bigint, slotNumber: number | bigint, blockNumber: number | bigint) => any;
   getSigner: () => Secp256k1Signer;
@@ -29,24 +34,75 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
 
   describe('shared proposal validation logic', () => {
     let epochCache: MockProxy<EpochCacheInterface>;
-    let validator: { validate: (proposal: TProposal) => Promise<PeerErrorSeverity | undefined> };
+    let validator: { validate: (proposal: TProposal) => Promise<ValidationResult> };
+    const previousSlot = getSlot(99);
+    const currentSlot = getSlot(100);
+    const nextSlot = getSlot(101);
+
+    function mockGetProposer(currentProposer: EthAddress, nextProposer: EthAddress, previousProposer?: EthAddress) {
+      epochCache.getProposerAttesterAddressInSlot.mockImplementation(slot => {
+        if (slot === currentSlot) {
+          return Promise.resolve(currentProposer);
+        }
+        if (slot === nextSlot) {
+          return Promise.resolve(nextProposer);
+        }
+        if (slot === previousSlot && previousProposer) {
+          return Promise.resolve(previousProposer);
+        }
+        throw new Error('Unexpected argument');
+      });
+    }
 
     beforeEach(() => {
       epochCache = epochCacheMock();
       validator = validatorFactory(epochCache, { txsPermitted: true });
+      epochCache.getCurrentAndNextSlot.mockReturnValue({
+        currentSlot: currentSlot,
+        nextSlot: nextSlot,
+      });
     });
 
-    it('returns high tolerance error if slot number is not current or next slot', async () => {
-      const header = makeHeader(1, 97, 97);
+    it('returns high tolerance error if slot number is not current or next slot (outside clock tolerance)', async () => {
+      const header = makeHeader(1, 99, 99);
       const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(98),
-        nextSlot: getSlot(99),
-        currentProposer: getAddress(),
-        nextProposer: getAddress(),
+
+      // Mock getEpochAndSlotNow to return time OUTSIDE clock tolerance (1000ms elapsed)
+      epochCache.getEpochAndSlotNow.mockReturnValue({
+        epoch: 1 as any,
+        slot: currentSlot,
+        ts: 1000n, // slot started at 1000 seconds
+        nowMs: 1001000n, // 1000ms elapsed, outside 500ms tolerance
+      });
+
+      epochCache.getProposerAttesterAddressInSlot.mockResolvedValue(getAddress());
+      const result = await validator.validate(mockProposal);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.HighToleranceError });
+
+      // Should not try to resolve proposers if base validation fails
+      expect(epochCache.getProposerAttesterAddressInSlot).not.toHaveBeenCalled();
+    });
+
+    it('returns ignore if previous slot proposal is within clock tolerance', async () => {
+      const previousProposer = getSigner();
+      const header = makeHeader(1, 99, 99);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: previousProposer,
+      });
+
+      // Mock getEpochAndSlotNow to return time WITHIN clock tolerance (100ms elapsed)
+      epochCache.getEpochAndSlotNow.mockReturnValue({
+        epoch: 1 as any,
+        slot: currentSlot,
+        ts: 1000n, // slot started at 1000 seconds
+        nowMs: 1000100n, // 100ms elapsed, within 500ms tolerance
       });
+
+      mockGetProposer(getAddress(), getAddress(), getAddress(previousProposer));
       const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.HighToleranceError);
+      expect(result).toEqual({ result: 'ignore' });
     });
 
     it('returns mid tolerance error if proposer is not current proposer for current slot', async () => {
@@ -59,14 +115,10 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
         lastBlockHeader: header,
         signer: invalidProposer,
       });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(100),
-        nextSlot: getSlot(101),
-        currentProposer: getAddress(currentProposer),
-        nextProposer: getAddress(nextProposer),
-      });
+
+      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
       const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
     });
 
     it('returns mid tolerance error if proposer is not next proposer for next slot', async () => {
@@ -79,14 +131,10 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
         lastBlockHeader: header,
         signer: invalidProposer,
       });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(100),
-        nextSlot: getSlot(101),
-        currentProposer: getAddress(currentProposer),
-        nextProposer: getAddress(nextProposer),
-      });
+
+      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
       const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
     });
 
     it('returns mid tolerance error if proposer is current proposer but proposal is for next slot', async () => {
@@ -98,14 +146,10 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
         lastBlockHeader: header,
         signer: currentProposer,
       });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(100),
-        nextSlot: getSlot(101),
-        currentProposer: getAddress(currentProposer),
-        nextProposer: getAddress(nextProposer),
-      });
+
+      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
       const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
     });
 
     it('returns undefined if proposal is valid for current slot and proposer', async () => {
@@ -117,14 +161,10 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
         lastBlockHeader: header,
         signer: currentProposer,
       });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(100),
-        nextSlot: getSlot(101),
-        currentProposer: getAddress(currentProposer),
-        nextProposer: getAddress(nextProposer),
-      });
+
+      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
       const result = await validator.validate(mockProposal);
-      expect(result).toBeUndefined();
+      expect(result).toEqual({ result: 'accept' });
     });
 
     it('returns undefined if proposal is valid for next slot and proposer', async () => {
@@ -132,14 +172,10 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
       const nextProposer = getSigner();
       const header = makeHeader(1, 101, 101);
       const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header, signer: nextProposer });
-      epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-        currentSlot: getSlot(100),
-        nextSlot: getSlot(101),
-        currentProposer: getAddress(currentProposer),
-        nextProposer: getAddress(nextProposer),
-      });
+
+      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
       const result = await validator.validate(mockProposal);
-      expect(result).toBeUndefined();
+      expect(result).toEqual({ result: 'accept' });
     });
 
     describe('transaction permission validation', () => {
@@ -153,14 +189,10 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
           signer: currentProposer,
           txHashes: getTxHashes(2),
         });
-        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-          currentSlot: getSlot(100),
-          nextSlot: getSlot(101),
-          currentProposer: getAddress(currentProposer),
-          nextProposer: getAddress(),
-        });
+
+        mockGetProposer(getAddress(currentProposer), getAddress());
         const result = await validatorWithTxsDisabled.validate(mockProposal);
-        expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+        expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
       });
 
       it('returns undefined if txs not permitted but proposal has no txHashes', async () => {
@@ -173,14 +205,10 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
           signer: currentProposer,
           txHashes: getTxHashes(0),
         });
-        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-          currentSlot: getSlot(100),
-          nextSlot: getSlot(101),
-          currentProposer: getAddress(currentProposer),
-          nextProposer: getAddress(),
-        });
+
+        mockGetProposer(getAddress(currentProposer), getAddress());
         const result = await validatorWithTxsDisabled.validate(mockProposal);
-        expect(result).toBeUndefined();
+        expect(result).toEqual({ result: 'accept' });
       });
 
       it('returns undefined if txs permitted and proposal contains txHashes', async () => {
@@ -192,14 +220,10 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
           signer: currentProposer,
           txHashes: getTxHashes(2),
         });
-        epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
-          currentSlot: getSlot(100),
-          nextSlot: getSlot(101),
-          currentProposer: getAddress(currentProposer),
-          nextProposer: getAddress(),
-        });
+
+        mockGetProposer(getAddress(currentProposer), getAddress());
         const result = await validator.validate(mockProposal);
-        expect(result).toBeUndefined();
+        expect(result).toEqual({ result: 'accept' });
       });
     });
   });

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -15,7 +15,9 @@ export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {
-    const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.anchorBlockHeader.hash()]);
+    const [index] = await this.#archiveSource.getArchiveIndices([
+      (await tx.data.constants.anchorBlockHeader.hash()).toField(),
+    ]);
     if (index === undefined) {
       this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for referencing an unknown block header`);
       return { result: 'invalid', reason: [TX_ERROR_BLOCK_HEADER] };

package/src/msg_validators/tx_validator/fee_payer_balance.ts

@@ -0,0 +1,40 @@
+import { getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+
+export type FeePayerBalanceDelta = {
+  feeLimit: bigint;
+  claimAmount: bigint;
+};
+
+const increasePublicBalanceSelectorPromise = FunctionSelector.fromSignature('_increase_public_balance((Field),u128)');
+
+export function getTxFeeLimit(tx: Tx): bigint {
+  return tx.data.constants.txContext.gasSettings.getFeeLimit().toBigInt();
+}
+
+export async function getFeePayerClaimAmount(tx: Tx, feeJuiceAddress: AztecAddress): Promise<bigint> {
+  const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
+  const increasePublicBalanceSelector = await increasePublicBalanceSelectorPromise;
+  const feePayer = tx.data.feePayer;
+
+  const claimFunctionCall = setupFns.find(
+    fn =>
+      fn.request.contractAddress.equals(feeJuiceAddress) &&
+      fn.request.msgSender.equals(feeJuiceAddress) &&
+      fn.calldata.length > 2 &&
+      fn.functionSelector.equals(increasePublicBalanceSelector) &&
+      fn.args[0].equals(feePayer.toField()) &&
+      !fn.request.isStaticCall,
+  );
+
+  return claimFunctionCall ? claimFunctionCall.args[1].toBigInt() : 0n;
+}
+
+export async function getFeePayerBalanceDelta(tx: Tx, feeJuiceAddress: AztecAddress): Promise<FeePayerBalanceDelta> {
+  return {
+    feeLimit: getTxFeeLimit(tx),
+    claimAmount: await getFeePayerClaimAmount(tx, feeJuiceAddress),
+  };
+}

package/src/msg_validators/tx_validator/gas_validator.ts

@@ -1,8 +1,6 @@
 import { AVM_MAX_PROCESSABLE_L2_GAS, FIXED_DA_GAS, FIXED_L2_GAS } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
-import { getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
-import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { Gas, GasFees } from '@aztec/stdlib/gas';
 import type { PublicStateSource } from '@aztec/stdlib/trees';
@@ -12,11 +10,12 @@ import {
   TX_ERROR_INSUFFICIENT_FEE_PER_GAS,
   TX_ERROR_INSUFFICIENT_GAS_LIMIT,
   type Tx,
-  TxExecutionPhase,
   type TxValidationResult,
   type TxValidator,
 } from '@aztec/stdlib/tx';
 
+import { getFeePayerClaimAmount, getTxFeeLimit } from './fee_payer_balance.js';
+
 export class GasTxValidator implements TxValidator<Tx> {
   #log = createLogger('sequencer:tx_validator:tx_gas');
   #publicDataSource: PublicStateSource;
@@ -93,7 +92,7 @@ export class GasTxValidator implements TxValidator<Tx> {
     const feePayer = tx.data.feePayer;
 
     // Compute the maximum fee that this tx may pay, based on its gasLimits and maxFeePerGas
-    const feeLimit = tx.data.constants.txContext.gasSettings.getFeeLimit();
+    const feeLimit = getTxFeeLimit(tx);
 
     // Read current balance of the feePayer
     const initialBalance = await this.#publicDataSource.storageRead(
@@ -102,30 +101,14 @@ export class GasTxValidator implements TxValidator<Tx> {
     );
 
     // If there is a claim in this tx that increases the fee payer balance in Fee Juice, add it to balance
-    const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
-    const increasePublicBalanceSelector = await FunctionSelector.fromSignature(
-      '_increase_public_balance((Field),u128)',
-    );
-
-    // Arguments of the claim function call:
-    // - args[0]: Amount recipient.
-    // - args[1]: Amount being claimed.
-    const claimFunctionCall = setupFns.find(
-      fn =>
-        fn.request.contractAddress.equals(this.#feeJuiceAddress) &&
-        fn.request.msgSender.equals(this.#feeJuiceAddress) &&
-        fn.calldata.length > 2 &&
-        fn.functionSelector.equals(increasePublicBalanceSelector) &&
-        fn.args[0].equals(feePayer.toField()) &&
-        !fn.request.isStaticCall,
-    );
+    const claimAmount = await getFeePayerClaimAmount(tx, this.#feeJuiceAddress);
+    const balance = initialBalance.toBigInt() + claimAmount;
 
-    const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[1]) : initialBalance;
-    if (balance.lt(feeLimit)) {
+    if (balance < feeLimit) {
       this.#log.verbose(`Rejecting transaction due to not enough fee payer balance`, {
         feePayer,
-        balance: balance.toBigInt(),
-        feeLimit: feeLimit.toBigInt(),
+        balance,
+        feeLimit,
       });
       return { result: 'invalid', reason: [TX_ERROR_INSUFFICIENT_FEE_PAYER_BALANCE] };
     }

package/src/msg_validators/tx_validator/index.ts

@@ -11,3 +11,4 @@ export * from './allowed_public_setup.js';
 export * from './archive_cache.js';
 export * from './tx_permitted_validator.js';
 export * from './timestamp_validator.js';
+export * from './size_validator.js';

package/src/msg_validators/tx_validator/size_validator.ts

@@ -0,0 +1,18 @@
+import { createLogger } from '@aztec/foundation/log';
+import { MAX_TX_SIZE_KB } from '@aztec/stdlib/p2p';
+import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+
+export class SizeTxValidator implements TxValidator<Tx> {
+  #log = createLogger('sequencer:tx_validator:tx_size');
+
+  validateTx(tx: Tx): Promise<TxValidationResult> {
+    const txSize = tx.getSize();
+    if (txSize > MAX_TX_SIZE_KB * 1024) {
+      this.#log.verbose(
+        `Rejecting transaction ${tx.getTxHash().toString()}. Reason: size above size limit. ${txSize}bytes > ${MAX_TX_SIZE_KB}Kb`,
+      );
+      return Promise.resolve({ result: 'invalid', reason: ['Transaction size above size limit'] });
+    }
+    return Promise.resolve({ result: 'valid' });
+  }
+}

package/src/services/encoding.ts

@@ -1,7 +1,7 @@
 // Taken from lodestar: https://github.com/ChainSafe/lodestar
 import { sha256 } from '@aztec/foundation/crypto/sha256';
 import { createLogger } from '@aztec/foundation/log';
-import { TopicType, getTopicFromString } from '@aztec/stdlib/p2p';
+import { MAX_TX_SIZE_KB, TopicType, getTopicFromString } from '@aztec/stdlib/p2p';
 
 import type { RPC } from '@chainsafe/libp2p-gossipsub/message';
 import type { DataTransform } from '@chainsafe/libp2p-gossipsub/types';
@@ -52,8 +52,7 @@ export function getMsgIdFn(message: Message) {
 }
 
 const DefaultMaxSizesKb: Record<TopicType, number> = {
-  // Tx effects should not exceed 128kb, so 512kb for the full tx obj should be sufficient
-  [TopicType.tx]: 512,
+  [TopicType.tx]: MAX_TX_SIZE_KB,
   // An attestation has roughly 30 fields, which is 1kb, so 5x is plenty
   [TopicType.checkpoint_attestation]: 5,
   // Proposals may carry some tx objects, so we allow a larger size capped at 10mb

package/src/services/libp2p/instrumentation.ts

@@ -102,11 +102,11 @@ export class P2PInstrumentation {
           continue;
         }
 
-        res.observe(metrics.avg, histogram.mean, { [Attributes.TOPIC_NAME]: topicName });
-        res.observe(metrics.max, histogram.max, { [Attributes.TOPIC_NAME]: topicName });
-        res.observe(metrics.min, histogram.min, { [Attributes.TOPIC_NAME]: topicName });
-        res.observe(metrics.p50, histogram.percentile(50), { [Attributes.TOPIC_NAME]: topicName });
-        res.observe(metrics.p90, histogram.percentile(90), { [Attributes.TOPIC_NAME]: topicName });
+        res.observe(metrics.avg, Math.ceil(histogram.mean), { [Attributes.TOPIC_NAME]: topicName });
+        res.observe(metrics.max, Math.ceil(histogram.max), { [Attributes.TOPIC_NAME]: topicName });
+        res.observe(metrics.min, Math.ceil(histogram.min), { [Attributes.TOPIC_NAME]: topicName });
+        res.observe(metrics.p50, Math.ceil(histogram.percentile(50)), { [Attributes.TOPIC_NAME]: topicName });
+        res.observe(metrics.p90, Math.ceil(histogram.percentile(90)), { [Attributes.TOPIC_NAME]: topicName });
       }
     }
   };