@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/p2p/block_attestation.ts

@@ -1,8 +1,8 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, recoverAddress } from '@aztec/foundation/crypto';
+import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
-import type { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
@@ -11,7 +11,7 @@ import type { ZodFor } from '../schemas/index.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from './signature_utils.js';
-import { TopicType, createTopicString } from './topic_type.js';
+import { TopicType } from './topic_type.js';
 
 export class BlockAttestationHash extends Buffer32 {
   constructor(hash: Buffer) {
@@ -26,9 +26,10 @@ export class BlockAttestationHash extends Buffer32 {
  * will produce a block attestation over the header of the block
  */
 export class BlockAttestation extends Gossipable {
-  static override p2pTopic = createTopicString(TopicType.block_attestation);
+  static override p2pTopic = TopicType.block_attestation;
 
   private sender: EthAddress | undefined;
+  private proposer: EthAddress | undefined;
 
   constructor(
     /** The payload of the message, and what the signature is over */
@@ -36,6 +37,9 @@ export class BlockAttestation extends Gossipable {
 
     /** The signature of the block attester */
     public readonly signature: Signature,
+
+    /** The signature from the block proposer */
+    public readonly proposerSignature: Signature,
   ) {
     super();
   }
@@ -45,11 +49,12 @@ export class BlockAttestation extends Gossipable {
       .object({
         payload: ConsensusPayload.schema,
         signature: Signature.schema,
+        proposerSignature: Signature.schema,
       })
-      .transform(obj => new BlockAttestation(obj.payload, obj.signature));
+      .transform(obj => new BlockAttestation(obj.payload, obj.signature, obj.proposerSignature));
   }
 
-  override p2pMessageIdentifier(): Promise<Buffer32> {
+  override generateP2PMessageIdentifier(): Promise<Buffer32> {
     return Promise.resolve(new BlockAttestationHash(keccak256(this.signature.toBuffer())));
   }
 
@@ -58,50 +63,73 @@ export class BlockAttestation extends Gossipable {
   }
 
   get slotNumber(): Fr {
-    return this.payload.header.globalVariables.slotNumber;
-  }
-
-  get blockNumber(): Fr {
-    return this.payload.header.globalVariables.blockNumber;
+    return this.payload.header.slotNumber;
   }
 
-  /**Get sender
-   *
-   * Lazily evaluate and cache the sender of the attestation
-   * @returns The sender of the attestation
+  /**
+   * Lazily evaluate and cache the signer of the attestation
+   * @returns The signer of the attestation, or undefined if signature recovery fails
    */
-  async getSender(): Promise<EthAddress> {
+  getSender(): EthAddress | undefined {
     if (!this.sender) {
       // Recover the sender from the attestation
-      const hashed = await getHashedSignaturePayloadEthSignedMessage(
-        this.payload,
-        SignatureDomainSeparator.blockAttestation,
-      );
+      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockAttestation);
       // Cache the sender for later use
-      this.sender = recoverAddress(hashed, this.signature);
+      this.sender = tryRecoverAddress(hashed, this.signature);
     }
 
     return this.sender;
   }
 
-  getPayload(): Promise<Buffer> {
+  /**
+   * Lazily evaluate and cache the proposer of the block
+   * @returns The proposer of the block
+   */
+  getProposer(): EthAddress | undefined {
+    if (!this.proposer) {
+      // Recover the proposer from the proposal signature
+      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockProposal);
+      // Cache the proposer for later use
+      this.proposer = tryRecoverAddress(hashed, this.proposerSignature);
+    }
+
+    return this.proposer;
+  }
+
+  getPayload(): Buffer {
     return this.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.payload, this.signature]);
+    return serializeToBuffer([this.payload, this.signature, this.proposerSignature]);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): BlockAttestation {
     const reader = BufferReader.asReader(buf);
-    return new BlockAttestation(reader.readObject(ConsensusPayload), reader.readObject(Signature));
+    return new BlockAttestation(
+      reader.readObject(ConsensusPayload),
+      reader.readObject(Signature),
+      reader.readObject(Signature),
+    );
   }
 
   static empty(): BlockAttestation {
-    return new BlockAttestation(ConsensusPayload.empty(), Signature.empty());
+    return new BlockAttestation(ConsensusPayload.empty(), Signature.empty(), Signature.empty());
+  }
+
+  static random(): BlockAttestation {
+    return new BlockAttestation(ConsensusPayload.random(), Signature.random(), Signature.random());
   }
 
   getSize(): number {
-    return this.payload.getSize() + this.signature.getSize();
+    return this.payload.getSize() + this.signature.getSize() + this.proposerSignature.getSize();
+  }
+
+  toInspect() {
+    return {
+      payload: this.payload.toInspect(),
+      signature: this.signature.toString(),
+      proposerSignature: this.proposerSignature.toString(),
+    };
   }
 }

package/src/p2p/block_proposal.ts

@@ -1,10 +1,13 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, recoverAddress } from '@aztec/foundation/crypto';
+import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
-import type { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import type { L2BlockInfo } from '../block/l2_block_info.js';
+import { TxHash } from '../tx/index.js';
+import { Tx } from '../tx/tx.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
 import {
@@ -12,7 +15,7 @@ import {
   getHashedSignaturePayload,
   getHashedSignaturePayloadEthSignedMessage,
 } from './signature_utils.js';
-import { TopicType, createTopicString } from './topic_type.js';
+import { TopicType } from './topic_type.js';
 
 export class BlockProposalHash extends Buffer32 {
   constructor(hash: Buffer) {
@@ -20,6 +23,10 @@ export class BlockProposalHash extends Buffer32 {
   }
 }
 
+export type BlockProposalOptions = {
+  publishFullTxs: boolean;
+};
+
 /**
  * BlockProposal
  *
@@ -27,7 +34,7 @@ export class BlockProposalHash extends Buffer32 {
  * be included in the head of the chain
  */
 export class BlockProposal extends Gossipable {
-  static override p2pTopic = createTopicString(TopicType.block_proposal);
+  static override p2pTopic = TopicType.block_proposal;
 
   private sender: EthAddress | undefined;
 
@@ -37,11 +44,18 @@ export class BlockProposal extends Gossipable {
 
     /** The signer of the BlockProposal over the header of the new block*/
     public readonly signature: Signature,
+
+    /** The sequence of transactions in the block */
+    public readonly txHashes: TxHash[],
+
+    // Note(md): this is placed after the txs payload in order to be backwards compatible with previous versions
+    /** The transactions in the block */
+    public readonly txs?: Tx[],
   ) {
     super();
   }
 
-  override p2pMessageIdentifier(): Promise<Buffer32> {
+  override generateP2PMessageIdentifier(): Promise<Buffer32> {
     return Promise.resolve(new BlockProposalHash(keccak256(this.signature.toBuffer())));
   }
 
@@ -50,34 +64,41 @@ export class BlockProposal extends Gossipable {
   }
 
   get slotNumber(): Fr {
-    return this.payload.header.globalVariables.slotNumber;
+    return this.payload.header.slotNumber;
   }
 
-  get blockNumber(): Fr {
-    return this.payload.header.globalVariables.blockNumber;
+  toBlockInfo(): Omit<L2BlockInfo, 'blockNumber'> {
+    return {
+      slotNumber: this.slotNumber.toNumber(),
+      lastArchive: this.payload.header.lastArchiveRoot,
+      timestamp: this.payload.header.timestamp,
+      archive: this.archive,
+      txCount: this.txHashes.length,
+    };
   }
 
   static async createProposalFromSigner(
     payload: ConsensusPayload,
+    txHashes: TxHash[],
+    // Note(md): Provided separately to tx hashes such that this function can be optional
+    txs: Tx[] | undefined,
     payloadSigner: (payload: Buffer32) => Promise<Signature>,
   ) {
-    const hashed = await getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
+    const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
     const sig = await payloadSigner(hashed);
 
-    return new BlockProposal(payload, sig);
+    return new BlockProposal(payload, sig, txHashes, txs);
   }
 
   /**Get Sender
    * Lazily evaluate the sender of the proposal; result is cached
+   * @returns The sender address, or undefined if signature recovery fails
    */
-  async getSender() {
+  getSender(): EthAddress | undefined {
     if (!this.sender) {
-      const hashed = await getHashedSignaturePayloadEthSignedMessage(
-        this.payload,
-        SignatureDomainSeparator.blockProposal,
-      );
+      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockProposal);
       // Cache the sender for later use
-      this.sender = recoverAddress(hashed, this.signature);
+      this.sender = tryRecoverAddress(hashed, this.signature);
     }
 
     return this.sender;
@@ -88,15 +109,36 @@ export class BlockProposal extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.payload, this.signature]);
+    const buffer: any[] = [this.payload, this.signature, this.txHashes.length, this.txHashes];
+    if (this.txs) {
+      buffer.push(this.txs.length);
+      buffer.push(this.txs);
+    }
+    return serializeToBuffer(buffer);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): BlockProposal {
     const reader = BufferReader.asReader(buf);
-    return new BlockProposal(reader.readObject(ConsensusPayload), reader.readObject(Signature));
+
+    const payload = reader.readObject(ConsensusPayload);
+    const sig = reader.readObject(Signature);
+    const txHashes = reader.readArray(reader.readNumber(), TxHash);
+
+    if (!reader.isEmpty()) {
+      const txs = reader.readArray(reader.readNumber(), Tx);
+      return new BlockProposal(payload, sig, txHashes, txs);
+    }
+
+    return new BlockProposal(payload, sig, txHashes);
   }
 
   getSize(): number {
-    return this.payload.getSize() + this.signature.getSize();
+    return (
+      this.payload.getSize() +
+      this.signature.getSize() +
+      4 /* txHashes.length */ +
+      this.txHashes.length * TxHash.SIZE +
+      (this.txs ? 4 /* txs.length */ + this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
+    );
   }
 }

package/src/p2p/consensus_payload.ts

@@ -7,74 +7,94 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
-import { BlockHeader } from '../tx/block_header.js';
-import { TxHash } from '../tx/tx_hash.js';
+import type { L2Block } from '../block/l2_block.js';
+import { ProposedBlockHeader, StateReference } from '../tx/index.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
 
 export class ConsensusPayload implements Signable {
   private size: number | undefined;
 
   constructor(
-    /** The block header the attestation is made over */
-    public readonly header: BlockHeader,
-    // TODO(https://github.com/AztecProtocol/aztec-packages/pull/7727#discussion_r1713670830): temporary
+    /** The proposed block header the attestation is made over */
+    public readonly header: ProposedBlockHeader,
+    /** The archive root after the block is added */
     public readonly archive: Fr,
-    /** The sequence of transactions in the block */
-    public readonly txHashes: TxHash[],
+    /** The state reference after the block is added */
+    public readonly stateReference: StateReference,
   ) {}
 
   static get schema() {
     return z
       .object({
-        header: BlockHeader.schema,
+        header: ProposedBlockHeader.schema,
         archive: schemas.Fr,
-        txHashes: z.array(TxHash.schema),
+        stateReference: StateReference.schema,
       })
-      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.txHashes));
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.stateReference));
   }
 
   static getFields(fields: FieldsOf<ConsensusPayload>) {
-    return [fields.header, fields.archive, fields.txHashes] as const;
+    return [fields.header, fields.archive, fields.stateReference] as const;
   }
 
-  async getPayloadToSign(domainSeparator: SignatureDomainSeparator): Promise<Buffer> {
-    const abi = parseAbiParameters('uint8, (bytes32, bytes32, (uint256), bytes, bytes32[])');
-    const txArray = this.txHashes.map(tx => tx.toString());
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    const abi = parseAbiParameters(
+      'uint8, ' + //domainSeperator
+        '(' +
+        'bytes32, ' + // archive
+        '((bytes32,uint32),((bytes32,uint32),(bytes32,uint32),(bytes32,uint32))), ' + // stateReference
+        '(int256), ' + // oracleInput
+        'bytes32' + // headerHash
+        ')',
+    );
+    const archiveRoot = this.archive.toString();
+    const stateReference = this.stateReference.toAbi();
+
+    const headerHash = this.header.hash().toString();
     const encodedData = encodeAbiParameters(abi, [
       domainSeparator,
-      [
-        this.archive.toString(),
-        (await this.header.hash()).toString(),
-        [0n] /* @todo See #9963 */,
-        this.header.toString(),
-        txArray,
-      ],
+      [archiveRoot, stateReference, [0n] /* @todo See #9963 */, headerHash],
     ] as const);
 
     return hexToBuffer(encodedData);
   }
 
   toBuffer(): Buffer {
-    const buffer = serializeToBuffer([this.header, this.archive, this.txHashes.length, this.txHashes]);
-    this.size = buffer.length;
-    return buffer;
+    return serializeToBuffer([this.header, this.archive, this.stateReference]);
+  }
+
+  public equals(other: ConsensusPayload): boolean {
+    return (
+      this.header.equals(other.header) &&
+      this.archive.equals(other.archive) &&
+      this.stateReference.equals(other.stateReference)
+    );
   }
 
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
-    return new ConsensusPayload(
-      reader.readObject(BlockHeader),
+    const payload = new ConsensusPayload(
+      reader.readObject(ProposedBlockHeader),
       reader.readObject(Fr),
-      reader.readArray(reader.readNumber(), TxHash),
+      reader.readObject(StateReference),
     );
+    return payload;
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
-    return new ConsensusPayload(fields.header, fields.archive, fields.txHashes);
+    return new ConsensusPayload(fields.header, fields.archive, fields.stateReference);
+  }
+
+  static fromBlock(block: L2Block): ConsensusPayload {
+    return new ConsensusPayload(block.header.toPropose(), block.archive.root, block.header.state);
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(BlockHeader.empty(), Fr.ZERO, []);
+    return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty());
+  }
+
+  static random(): ConsensusPayload {
+    return new ConsensusPayload(ProposedBlockHeader.random(), Fr.random(), StateReference.random());
   }
 
   /**
@@ -89,4 +109,16 @@ export class ConsensusPayload implements Signable {
     this.size = this.toBuffer().length;
     return this.size;
   }
+
+  toInspect() {
+    return {
+      header: this.header.toInspect(),
+      archive: this.archive.toString(),
+      stateReference: this.stateReference.toInspect(),
+    };
+  }
+
+  toString() {
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}`;
+  }
 }

package/src/p2p/gossipable.ts

@@ -1,4 +1,25 @@
-import type { Buffer32 } from '@aztec/foundation/buffer';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import type { TopicType } from './topic_type.js';
+
+export class P2PMessage {
+  constructor(public readonly payload: Buffer) {}
+
+  static fromGossipable(message: Gossipable): P2PMessage {
+    return new P2PMessage(message.toBuffer());
+  }
+
+  static fromMessageData(messageData: Buffer): P2PMessage {
+    const reader = new BufferReader(messageData);
+    const payload = reader.readBuffer();
+    return new P2PMessage(payload);
+  }
+
+  toMessageData(): Buffer {
+    return serializeToBuffer([serializeToBuffer(this.payload.length, this.payload)]);
+  }
+}
 
 /**
  * Gossipable
@@ -6,27 +27,32 @@ import type { Buffer32 } from '@aztec/foundation/buffer';
  * Any class which extends gossipable will be able to be Gossiped over the p2p network
  */
 export abstract class Gossipable {
-  /** p2p Topic
-   *
-   * - The p2p topic identifier, this determines how the message is handled
-   */
-  static p2pTopic: string;
+  private cachedId: Buffer32 | undefined;
+  /** The p2p topic identifier, this determines how the message is handled */
+  static p2pTopic: TopicType;
 
-  /** p2p Message Identifier
-   *
-   *  - A digest of the message information, this key is used for deduplication
+  /**
+   * A digest of the message information **used for logging only**.
+   * The identifier used for deduplication is `getMsgIdFn` as defined in `encoding.ts` which is a hash over topic and data.
    */
-  abstract p2pMessageIdentifier(): Promise<Buffer32>;
+  async p2pMessageIdentifier(): Promise<Buffer32> {
+    if (this.cachedId) {
+      return this.cachedId;
+    }
+    this.cachedId = await this.generateP2PMessageIdentifier();
+    return this.cachedId;
+  }
+
+  abstract generateP2PMessageIdentifier(): Promise<Buffer32>;
 
-  /** To Buffer
-   *
-   * - Serialization method
-   */
   abstract toBuffer(): Buffer;
 
+  toMessage(): Buffer {
+    return this.toBuffer();
+  }
+
   /**
    * Get the size of the gossipable object.
-   *
    * This is used for metrics recording.
    */
   abstract getSize(): number;

package/src/p2p/index.ts

@@ -1,3 +1,4 @@
+export * from './attestation_utils.js';
 export * from './block_attestation.js';
 export * from './block_proposal.js';
 export * from './consensus_payload.js';

package/src/p2p/interface.ts

@@ -1,28 +1,4 @@
-import { Tx } from '../tx/tx.js';
-import { BlockAttestation } from './block_attestation.js';
-import { BlockProposal } from './block_proposal.js';
-import type { Gossipable } from './gossipable.js';
-import { TopicType } from './topic_type.js';
-
 export interface RawGossipMessage {
   topic: string;
   data: Uint8Array;
 }
-
-// Force casts as we know that each field here extends Gossipable, and we just want types from Gossipable
-export const TopicTypeMap: Record<string, typeof Gossipable> = {
-  [TopicType.tx]: Tx as unknown as typeof Gossipable,
-  [TopicType.block_proposal]: BlockProposal as unknown as typeof Gossipable,
-  [TopicType.block_attestation]: BlockAttestation as unknown as typeof Gossipable,
-};
-
-/**
- * Map from topic to deserialiser
- *
- * Used in msgIdFn libp2p to get the p2pMessageIdentifier from a message
- */
-export const TopicToDeserializer = {
-  [Tx.p2pTopic]: Tx.fromBuffer,
-  [BlockProposal.p2pTopic]: BlockProposal.fromBuffer,
-  [BlockAttestation.p2pTopic]: BlockAttestation.fromBuffer,
-};

package/src/p2p/signature_utils.ts

@@ -4,10 +4,11 @@ import { keccak256, makeEthSignDigest } from '@aztec/foundation/crypto';
 export enum SignatureDomainSeparator {
   blockProposal = 0,
   blockAttestation = 1,
+  attestationsAndSigners = 2,
 }
 
 export interface Signable {
-  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Promise<Buffer>;
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer;
 }
 
 /**
@@ -15,11 +16,8 @@ export interface Signable {
  * @param s - The `Signable` to sign
  * @returns The hashed payload for the signature of the `Signable`
  */
-export async function getHashedSignaturePayload(
-  s: Signable,
-  domainSeparator: SignatureDomainSeparator,
-): Promise<Buffer32> {
-  return Buffer32.fromBuffer(keccak256(await s.getPayloadToSign(domainSeparator)));
+export function getHashedSignaturePayload(s: Signable, domainSeparator: SignatureDomainSeparator): Buffer32 {
+  return Buffer32.fromBuffer(keccak256(s.getPayloadToSign(domainSeparator)));
 }
 
 /**
@@ -27,10 +25,10 @@ export async function getHashedSignaturePayload(
  * @param s - the `Signable` to sign
  * @returns The hashed payload for the signature of the `Signable` as an Ethereum signed message
  */
-export async function getHashedSignaturePayloadEthSignedMessage(
+export function getHashedSignaturePayloadEthSignedMessage(
   s: Signable,
   domainSeparator: SignatureDomainSeparator,
-): Promise<Buffer32> {
-  const payload = await getHashedSignaturePayload(s, domainSeparator);
+): Buffer32 {
+  const payload = getHashedSignaturePayload(s, domainSeparator);
   return makeEthSignDigest(payload);
 }

package/src/p2p/topic_type.ts

@@ -1,18 +1,25 @@
 import { P2PClientType } from './client_type.js';
 
-/** Create Topic String
- *
- * The topic channel identifier
- * @param topicType
- * @returns
+/**
+ * Creates the topic channel identifier string from a given topic type
  */
-export function createTopicString(topicType: TopicType) {
-  return '/aztec/' + topicType + '/0.1.0';
+export function createTopicString(topicType: TopicType, protocolVersion: string) {
+  return `/aztec/${TopicType[topicType]}/${protocolVersion}`;
+}
+
+/** Extracts the topic type from a topic string */
+export function getTopicFromString(topicStr: string): TopicType | undefined {
+  const parts = topicStr.split('/');
+  if (parts.length < 4 || parts[1] !== 'aztec') {
+    return undefined;
+  }
+  const topic = parts[2];
+  if (Object.values(TopicType).includes(topic as TopicType)) {
+    return topic as TopicType;
+  }
+  return undefined;
 }
 
-/**
- *
- */
 export enum TopicType {
   tx = 'tx',
   block_proposal = 'block_proposal',
@@ -22,8 +29,20 @@ export enum TopicType {
 export function getTopicTypeForClientType(clientType: P2PClientType) {
   if (clientType === P2PClientType.Full) {
     return Object.values(TopicType);
+  } else if (clientType === P2PClientType.Prover) {
+    return [TopicType.tx, TopicType.block_proposal];
+  } else {
+    const _: never = clientType;
+    return [TopicType.tx];
+  }
+}
+
+export function getTopicsForClientAndConfig(clientType: P2PClientType, disableTransactions: boolean) {
+  const topics = getTopicTypeForClientType(clientType);
+  if (disableTransactions) {
+    return topics.filter(topic => topic !== TopicType.tx);
   }
-  return [TopicType.tx];
+  return topics;
 }
 
 /**
@@ -35,10 +54,10 @@ export function getTopicTypeForClientType(clientType: P2PClientType) {
  *  ...
  * }
  */
-export function metricsTopicStrToLabels() {
+export function metricsTopicStrToLabels(protocolVersion: string) {
   const topicStrToLabel = new Map<string, string>();
   for (const topic in TopicType) {
-    topicStrToLabel.set(createTopicString(TopicType[topic as keyof typeof TopicType]), topic);
+    topicStrToLabel.set(createTopicString(TopicType[topic as keyof typeof TopicType], protocolVersion), topic);
   }
 
   return topicStrToLabel;