@aztec/p2p 0.0.1-commit.6d3c34e → 0.0.1-commit.7ac86ea28

package/src/msg_validators/tx_validator/data_validator.ts

@@ -1,5 +1,5 @@
 import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { computeCalldataHash } from '@aztec/stdlib/hash';
 import {
   TX_ERROR_CALLDATA_COUNT_MISMATCH,
@@ -16,7 +16,11 @@ import {
 } from '@aztec/stdlib/tx';
 
 export class DataTxValidator implements TxValidator<Tx> {
-  #log = createLogger('p2p:tx_validator:tx_data');
+  #log: Logger;
+
+  constructor(bindings?: LoggerBindings) {
+    this.#log = createLogger('p2p:tx_validator:tx_data', bindings);
+  }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
     const reason =

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -1,9 +1,8 @@
-import { createLogger } from '@aztec/foundation/log';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import {
-  type AnyTx,
   TX_ERROR_DUPLICATE_NULLIFIER_IN_TX,
   TX_ERROR_EXISTING_NULLIFIER,
-  Tx,
   type TxValidationResult,
   type TxValidator,
 } from '@aztec/stdlib/tx';
@@ -12,26 +11,33 @@ export interface NullifierSource {
   nullifiersExist: (nullifiers: Buffer[]) => Promise<boolean[]>;
 }
 
-export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:tx_double_spend');
+/** Structural interface for double-spend validation. */
+export interface HasNullifierData {
+  txHash: { toString(): string };
+  data: { getNonEmptyNullifiers(): Fr[] };
+}
+
+export class DoubleSpendTxValidator<T extends HasNullifierData> implements TxValidator<T> {
+  #log: Logger;
   #nullifierSource: NullifierSource;
 
-  constructor(nullifierSource: NullifierSource) {
+  constructor(nullifierSource: NullifierSource, bindings?: LoggerBindings) {
     this.#nullifierSource = nullifierSource;
+    this.#log = createLogger('p2p:tx_validator:tx_double_spend', bindings);
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {
-    const nullifiers = tx instanceof Tx ? tx.data.getNonEmptyNullifiers() : tx.txEffect.nullifiers;
+    const nullifiers = tx.data.getNonEmptyNullifiers();
 
     // Ditch this tx if it has repeated nullifiers
     const uniqueNullifiers = new Set(nullifiers.map(n => n.toBigInt()));
     if (uniqueNullifiers.size !== nullifiers.length) {
-      this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for emitting duplicate nullifiers`);
+      this.#log.verbose(`Rejecting tx ${tx.txHash} for emitting duplicate nullifiers`);
       return { result: 'invalid', reason: [TX_ERROR_DUPLICATE_NULLIFIER_IN_TX] };
     }
 
     if ((await this.#nullifierSource.nullifiersExist(nullifiers.map(n => n.toBuffer()))).some(Boolean)) {
-      this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for repeating a nullifier`);
+      this.#log.verbose(`Rejecting tx ${tx.txHash} for repeating a nullifier`);
       return { result: 'invalid', reason: [TX_ERROR_EXISTING_NULLIFIER] };
     }
 

package/src/msg_validators/tx_validator/factory.ts

@@ -1,7 +1,8 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import type { LoggerBindings } from '@aztec/foundation/log';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { ProtocolContractAddress, protocolContractsHash } from '@aztec/protocol-contracts';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { GasFees } from '@aztec/stdlib/gas';
 import type {
@@ -11,9 +12,10 @@ import type {
 } from '@aztec/stdlib/interfaces/server';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { DatabasePublicStateSource, MerkleTreeId } from '@aztec/stdlib/trees';
-import type { Tx, TxValidationResult } from '@aztec/stdlib/tx';
+import type { Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
+import { AggregateTxValidator } from './aggregate_tx_validator.js';
 import { ArchiveCache } from './archive_cache.js';
 import { BlockHeaderTxValidator } from './block_header_validator.js';
 import { DataTxValidator } from './data_validator.js';
@@ -21,6 +23,7 @@ import { DoubleSpendTxValidator } from './double_spend_validator.js';
 import { GasTxValidator } from './gas_validator.js';
 import { MetadataTxValidator } from './metadata_validator.js';
 import { PhasesTxValidator } from './phases_validator.js';
+import { SizeTxValidator } from './size_validator.js';
 import { TimestampTxValidator } from './timestamp_validator.js';
 import { TxPermittedValidator } from './tx_permitted_validator.js';
 import { TxProofValidator } from './tx_proof_validator.js';
@@ -44,43 +47,53 @@ export function createTxMessageValidators(
   proofVerifier: ClientProtocolCircuitVerifier,
   txsPermitted: boolean,
   allowedInSetup: AllowedElement[] = [],
+  bindings?: LoggerBindings,
 ): Record<string, MessageValidator>[] {
   const merkleTree = worldStateSynchronizer.getCommitted();
 
   return [
     {
       txsPermittedValidator: {
-        validator: new TxPermittedValidator(txsPermitted),
+        validator: new TxPermittedValidator(txsPermitted, bindings),
         severity: PeerErrorSeverity.MidToleranceError,
       },
       dataValidator: {
-        validator: new DataTxValidator(),
+        validator: new DataTxValidator(bindings),
         severity: PeerErrorSeverity.HighToleranceError,
       },
       metadataValidator: {
-        validator: new MetadataTxValidator({
-          l1ChainId: new Fr(l1ChainId),
-          rollupVersion: new Fr(rollupVersion),
-          protocolContractsHash,
-          vkTreeRoot: getVKTreeRoot(),
-        }),
+        validator: new MetadataTxValidator(
+          {
+            l1ChainId: new Fr(l1ChainId),
+            rollupVersion: new Fr(rollupVersion),
+            protocolContractsHash,
+            vkTreeRoot: getVKTreeRoot(),
+          },
+          bindings,
+        ),
         severity: PeerErrorSeverity.HighToleranceError,
       },
       timestampValidator: {
-        validator: new TimestampTxValidator<Tx>({
-          timestamp,
-          blockNumber,
-        }),
+        validator: new TimestampTxValidator<Tx>(
+          {
+            timestamp,
+            blockNumber,
+          },
+          bindings,
+        ),
         severity: PeerErrorSeverity.MidToleranceError,
       },
       doubleSpendValidator: {
-        validator: new DoubleSpendTxValidator({
-          nullifiersExist: async (nullifiers: Buffer[]) => {
-            const merkleTree = worldStateSynchronizer.getCommitted();
-            const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
-            return indices.map(index => index !== undefined);
+        validator: new DoubleSpendTxValidator(
+          {
+            nullifiersExist: async (nullifiers: Buffer[]) => {
+              const merkleTree = worldStateSynchronizer.getCommitted();
+              const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+              return indices.map(index => index !== undefined);
+            },
           },
-        }),
+          bindings,
+        ),
         severity: PeerErrorSeverity.HighToleranceError,
       },
       gasValidator: {
@@ -88,23 +101,51 @@ export function createTxMessageValidators(
           new DatabasePublicStateSource(merkleTree),
           ProtocolContractAddress.FeeJuice,
           gasFees,
+          bindings,
         ),
         severity: PeerErrorSeverity.HighToleranceError,
       },
       phasesValidator: {
-        validator: new PhasesTxValidator(contractDataSource, allowedInSetup, timestamp),
+        validator: new PhasesTxValidator(contractDataSource, allowedInSetup, timestamp, bindings),
         severity: PeerErrorSeverity.MidToleranceError,
       },
       blockHeaderValidator: {
-        validator: new BlockHeaderTxValidator(new ArchiveCache(merkleTree)),
+        validator: new BlockHeaderTxValidator(new ArchiveCache(merkleTree), bindings),
         severity: PeerErrorSeverity.HighToleranceError,
       },
     },
     {
       proofValidator: {
-        validator: new TxProofValidator(proofVerifier),
+        validator: new TxProofValidator(proofVerifier, bindings),
         severity: PeerErrorSeverity.MidToleranceError,
       },
     },
   ];
 }
+
+export function createTxReqRespValidator(
+  verifier: ClientProtocolCircuitVerifier,
+  {
+    l1ChainId,
+    rollupVersion,
+  }: {
+    l1ChainId: number;
+    rollupVersion: number;
+  },
+  bindings?: LoggerBindings,
+): TxValidator {
+  return new AggregateTxValidator(
+    new MetadataTxValidator(
+      {
+        l1ChainId: new Fr(l1ChainId),
+        rollupVersion: new Fr(rollupVersion),
+        protocolContractsHash,
+        vkTreeRoot: getVKTreeRoot(),
+      },
+      bindings,
+    ),
+    new SizeTxValidator(bindings),
+    new DataTxValidator(bindings),
+    new TxProofValidator(verifier, bindings),
+  );
+}

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 { type Logger, type LoggerBindings, 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,18 +10,25 @@ 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');
+  #log: Logger;
   #publicDataSource: PublicStateSource;
   #feeJuiceAddress: AztecAddress;
   #gasFees: GasFees;
 
-  constructor(publicDataSource: PublicStateSource, feeJuiceAddress: AztecAddress, gasFees: GasFees) {
+  constructor(
+    publicDataSource: PublicStateSource,
+    feeJuiceAddress: AztecAddress,
+    gasFees: GasFees,
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('sequencer:tx_validator:tx_gas', bindings);
     this.#publicDataSource = publicDataSource;
     this.#feeJuiceAddress = feeJuiceAddress;
     this.#gasFees = gasFees;
@@ -93,7 +98,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 +107,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/metadata_validator.ts

@@ -1,5 +1,5 @@
 import type { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import {
   type AnyTx,
   TX_ERROR_INCORRECT_L1_CHAIN_ID,
@@ -11,7 +11,7 @@ import {
 } from '@aztec/stdlib/tx';
 
 export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:tx_metadata');
+  #log: Logger;
 
   constructor(
     private values: {
@@ -20,7 +20,10 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
       vkTreeRoot: Fr;
       protocolContractsHash: Fr;
     },
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:tx_metadata', bindings);
+  }
 
   validateTx(tx: T): Promise<TxValidationResult> {
     const errors = [];

package/src/msg_validators/tx_validator/phases_validator.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { PublicContractsDB, getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
@@ -14,15 +14,17 @@ import {
 import type { UInt64 } from '@aztec/stdlib/types';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
-  #log = createLogger('sequencer:tx_validator:tx_phases');
+  #log: Logger;
   private contractsDB: PublicContractsDB;
 
   constructor(
     contracts: ContractDataSource,
     private setupAllowList: AllowedElement[],
     private timestamp: UInt64,
+    bindings?: LoggerBindings,
   ) {
-    this.contractsDB = new PublicContractsDB(contracts);
+    this.#log = createLogger('sequencer:tx_validator:tx_phases', bindings);
+    this.contractsDB = new PublicContractsDB(contracts, bindings);
   }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {

package/src/msg_validators/tx_validator/size_validator.ts

@@ -0,0 +1,22 @@
+import { type Logger, type LoggerBindings, 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: Logger;
+
+  constructor(bindings?: LoggerBindings) {
+    this.#log = createLogger('p2p:tx_validator:tx_size', bindings);
+  }
+
+  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/msg_validators/tx_validator/timestamp_validator.ts

@@ -1,16 +1,25 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { createLogger } from '@aztec/foundation/log';
-import {
-  type AnyTx,
-  TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP,
-  type TxValidationResult,
-  type TxValidator,
-  getTxHash,
-} from '@aztec/stdlib/tx';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { TX_ERROR_INVALID_EXPIRATION_TIMESTAMP, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
-export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:timestamp');
+/** Structural interface for timestamp validation. */
+export interface HasTimestampData {
+  txHash: { toString(): string };
+  data: {
+    expirationTimestamp: bigint;
+    constants: {
+      anchorBlockHeader: {
+        globalVariables: {
+          blockNumber: BlockNumber;
+        };
+      };
+    };
+  };
+}
+
+export class TimestampTxValidator<T extends HasTimestampData> implements TxValidator<T> {
+  #log: Logger;
 
   constructor(
     private values: {
@@ -20,28 +29,27 @@ export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
       // Block number in which the tx is considered to be included.
       blockNumber: BlockNumber;
     },
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:timestamp', bindings);
+  }
 
   validateTx(tx: T): Promise<TxValidationResult> {
-    const includeByTimestamp = tx.data.includeByTimestamp;
-    // If building block 1, we skip the expiration check. For details on why see the `validate_include_by_timestamp`
+    const expirationTimestamp = tx.data.expirationTimestamp;
+    // If building block 1, we skip the expiration check. For details on why see the `validate_expiration_timestamp`
     // function in `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/base/components/validation_requests.nr`.
     const buildingBlock1 = this.values.blockNumber === 1;
 
-    if (!buildingBlock1 && includeByTimestamp < this.values.timestamp) {
+    if (!buildingBlock1 && expirationTimestamp < this.values.timestamp) {
       if (tx.data.constants.anchorBlockHeader.globalVariables.blockNumber === 0) {
         this.#log.warn(
           `A tx built against a genesis block failed to be included in block 1 which is the only block in which txs built against a genesis block are allowed to be included.`,
         );
       }
       this.#log.verbose(
-        `Rejecting tx ${getTxHash(
-          tx,
-        )} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${
-          this.values.timestamp
-        }.`,
+        `Rejecting tx ${tx.txHash} for low expiration timestamp. Tx expiration timestamp: ${expirationTimestamp}, timestamp: ${this.values.timestamp}.`,
       );
-      return Promise.resolve({ result: 'invalid', reason: [TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP] });
+      return Promise.resolve({ result: 'invalid', reason: [TX_ERROR_INVALID_EXPIRATION_TIMESTAMP] });
     } else {
       return Promise.resolve({ result: 'valid' });
     }

package/src/msg_validators/tx_validator/tx_permitted_validator.ts

@@ -1,10 +1,15 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
 
 export class TxPermittedValidator implements TxValidator<Tx> {
-  #log = createLogger('p2p:tx_validator:tx_permitted');
+  #log: Logger;
 
-  constructor(private permitted: boolean) {}
+  constructor(
+    private permitted: boolean,
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:tx_permitted', bindings);
+  }
 
   validateTx(tx: Tx): Promise<TxValidationResult> {
     if (!this.permitted) {

package/src/msg_validators/tx_validator/tx_proof_validator.ts

@@ -1,11 +1,16 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
 import { TX_ERROR_INVALID_PROOF, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export class TxProofValidator implements TxValidator<Tx> {
-  #log = createLogger('p2p:tx_validator:private_proof');
+  #log: Logger;
 
-  constructor(private verifier: ClientProtocolCircuitVerifier) {}
+  constructor(
+    private verifier: ClientProtocolCircuitVerifier,
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:proof', bindings);
+  }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
     const result = await this.verifier.verifyProof(tx);

package/src/services/data_store.ts

@@ -24,6 +24,7 @@ class KeyNotFoundError extends Error {
 }
 
 export class AztecDatastore implements Datastore {
+  #db: AztecAsyncKVStore;
   #memoryDatastore: Map<string, MemoryItem>;
   #dbDatastore: AztecAsyncMap<string, Uint8Array>;
 
@@ -32,9 +33,9 @@ export class AztecDatastore implements Datastore {
   private maxMemoryItems: number;
 
   constructor(db: AztecAsyncKVStore, { maxMemoryItems } = { maxMemoryItems: 50 }) {
+    this.#db = db;
     this.#memoryDatastore = new Map();
     this.#dbDatastore = db.openMap('p2p_datastore');
-
     this.maxMemoryItems = maxMemoryItems;
   }
 
@@ -106,13 +107,15 @@ export class AztecDatastore implements Datastore {
         });
       },
       commit: async () => {
-        for (const op of this.#batchOps) {
-          if (op.type === 'put' && op.value) {
-            await this.put(op.key, op.value);
-          } else if (op.type === 'del') {
-            await this.delete(op.key);
+        await this.#db.transactionAsync(async () => {
+          for (const op of this.#batchOps) {
+            if (op.type === 'put' && op.value) {
+              await this.put(op.key, op.value);
+            } else if (op.type === 'del') {
+              await this.delete(op.key);
+            }
           }
-        }
+        });
         this.#batchOps = []; // Clear operations after commit
       },
     };

package/src/services/discv5/discV5_service.ts

@@ -87,7 +87,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       this.packageVersion,
     ));
 
-    const metricsRegistry = new OtelMetricsAdapter(telemetry);
+    const metricsRegistry = new OtelMetricsAdapter(telemetry, this.logger.getBindings());
     this.discv5 = Discv5.create({
       enr: this.enr,
       peerId,