@aztec/p2p 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.76.0

package/src/bootstrap/bootstrap.ts

@@ -9,8 +9,8 @@ import type { PeerId } from '@libp2p/interface';
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
 
 import type { BootnodeConfig } from '../config.js';
-import { AZTEC_ENR_KEY, AZTEC_NET } from '../services/types.js';
 import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey, getPeerIdPrivateKey } from '../util.js';
+import { setAztecEnrKey } from '../versioning.js';
 
 /**
  * Encapsulates a 'Bootstrap' node, used for the purpose of assisting new joiners in acquiring peers.
@@ -46,7 +46,8 @@ export class BootstrapNode implements P2PBootstrapApi {
 
     const publicAddr = multiaddr(convertToMultiaddr(udpAnnounceAddress, 'udp'));
     enr.setLocationMultiaddr(publicAddr);
-    enr.set(AZTEC_ENR_KEY, Uint8Array.from([AZTEC_NET]));
+
+    const versions = setAztecEnrKey(enr, config);
 
     this.logger.debug(`Starting bootstrap node ${peerId} listening on ${listenAddrUdp.toString()}`);
 
@@ -72,7 +73,12 @@ export class BootstrapNode implements P2PBootstrapApi {
 
     try {
       await this.node.start();
-      this.logger.info('Bootstrap node started', { peerId, enr: enr.encodeTxt(), addr: listenAddrUdp.toString() });
+      this.logger.info('Bootstrap node started', {
+        peerId,
+        enr: enr.encodeTxt(),
+        addr: listenAddrUdp.toString(),
+        versions,
+      });
     } catch (e) {
       this.logger.error('Error starting Discv5', e);
     }

package/src/client/factory.ts

@@ -4,8 +4,8 @@ import {
   P2PClientType,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
-import { type EpochCache } from '@aztec/epoch-cache';
-import { createLogger } from '@aztec/foundation/log';
+import { type EpochCacheInterface } from '@aztec/epoch-cache';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type AztecAsyncKVStore } from '@aztec/kv-store';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
@@ -29,6 +29,7 @@ type P2PClientDeps<T extends P2PClientType> = {
   store?: AztecAsyncKVStore;
   attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
   epochProofQuotePool?: EpochProofQuotePool;
+  logger?: Logger;
 };
 
 export const createP2PClient = async <T extends P2PClientType>(
@@ -37,12 +38,12 @@ export const createP2PClient = async <T extends P2PClientType>(
   l2BlockSource: L2BlockSource,
   proofVerifier: ClientProtocolCircuitVerifier,
   worldStateSynchronizer: WorldStateSynchronizer,
-  epochCache: EpochCache,
+  epochCache: EpochCacheInterface,
   telemetry: TelemetryClient = getTelemetryClient(),
   deps: P2PClientDeps<T> = {},
 ) => {
   let config = { ..._config };
-  const logger = createLogger('p2p');
+  const logger = deps.logger ?? createLogger('p2p');
   const store = deps.store ?? (await createStore('p2p', config, createLogger('p2p:lmdb-v2')));
   const archive = await createStore('p2p-archive', config, createLogger('p2p-archive:lmdb-v2'));
 
@@ -66,7 +67,12 @@ export const createP2PClient = async <T extends P2PClientType>(
     // Create peer discovery service
     const peerIdPrivateKey = await getPeerIdPrivateKey(config, store);
     const peerId = await createLibP2PPeerIdFromPrivateKey(peerIdPrivateKey);
-    const discoveryService = new DiscV5Service(peerId, config, telemetry);
+    const discoveryService = new DiscV5Service(
+      peerId,
+      config,
+      telemetry,
+      createLogger(`${logger.module}:discv5_service`),
+    );
 
     p2pService = await LibP2PService.new<T>(
       clientType,
@@ -80,6 +86,7 @@ export const createP2PClient = async <T extends P2PClientType>(
       worldStateSynchronizer,
       store,
       telemetry,
+      createLogger(`${logger.module}:libp2p_service`),
     );
   } else {
     logger.verbose('P2P is disabled. Using dummy P2P service');

package/src/config.ts

@@ -1,3 +1,4 @@
+import { type ChainConfig, chainConfigMappings } from '@aztec/circuit-types/config';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
@@ -13,7 +14,7 @@ import { type P2PReqRespConfig, p2pReqRespConfigMappings } from './services/reqr
 /**
  * P2P client configuration values.
  */
-export interface P2PConfig extends P2PReqRespConfig {
+export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
   /**
    * A flag dictating whether the P2P subsystem should be enabled.
    */
@@ -29,6 +30,16 @@ export interface P2PConfig extends P2PReqRespConfig {
    */
   blockRequestBatchSize: number;
 
+  /**
+   * DEBUG: Disable message validation - for testing purposes only
+   */
+  debugDisableMessageValidation: boolean;
+
+  /**
+   * DEBUG: Disable colocation penalty - for testing purposes only
+   */
+  debugDisableColocationPenalty: boolean;
+
   /**
    * The frequency in which to check for new peers.
    */
@@ -69,16 +80,14 @@ export interface P2PConfig extends P2PReqRespConfig {
    */
   bootstrapNodes: string[];
 
+  /** Whether to execute the version check in the bootstrap node ENR. */
+  bootstrapNodeEnrVersionCheck: boolean;
+
   /**
    * Protocol identifier for transaction gossiping.
    */
   transactionProtocol: string;
 
-  /**
-   * The minimum number of peers (a peer count below this will cause the node to look for more peers)
-   */
-  minPeerCount: number;
-
   /**
    * The maximum number of peers (a peer count above this will cause the node to refuse connection attempts)
    */
@@ -115,6 +124,16 @@ export interface P2PConfig extends P2PReqRespConfig {
    */
   gossipsubDhi: number;
 
+  /**
+   * The Dlazy parameter for the gossipsub protocol.
+   */
+  gossipsubDLazy: number;
+
+  /**
+   * Whether to flood publish messages. - For testing purposes only
+   */
+  gossipsubFloodPublish: boolean;
+
   /**
    * The number of gossipsub interval message cache windows to keep.
    */
@@ -150,11 +169,6 @@ export interface P2PConfig extends P2PReqRespConfig {
    */
   peerPenaltyValues: number[];
 
-  /**
-   * The chain id of the L1 chain.
-   */
-  l1ChainId: number;
-
   /** Limit of transactions to archive in the tx pool. Once the archived tx limit is reached, the oldest archived txs will be purged. */
   archivedTxLimit: number;
 }
@@ -170,6 +184,16 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'The frequency in which to check for new L2 blocks.',
     ...numberConfigHelper(100),
   },
+  debugDisableMessageValidation: {
+    env: 'DEBUG_P2P_DISABLE_MESSAGE_VALIDATION',
+    description: 'DEBUG: Disable message validation - NEVER set to true in production',
+    ...booleanConfigHelper(false),
+  },
+  debugDisableColocationPenalty: {
+    env: 'DEBUG_P2P_DISABLE_COLOCATION_PENALTY',
+    description: 'DEBUG: Disable colocation penalty - NEVER set to true in production',
+    ...booleanConfigHelper(false),
+  },
   peerCheckIntervalMS: {
     env: 'P2P_PEER_CHECK_INTERVAL_MS',
     description: 'The frequency in which to check for new peers.',
@@ -209,16 +233,16 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     parseEnv: (val: string) => val.split(','),
     description: 'A list of bootstrap peer ENRs to connect to. Separated by commas.',
   },
+  bootstrapNodeEnrVersionCheck: {
+    env: 'P2P_BOOTSTRAP_NODE_ENR_VERSION_CHECK',
+    description: 'Whether to check the version of the bootstrap node ENR.',
+    ...booleanConfigHelper(),
+  },
   transactionProtocol: {
     env: 'P2P_TX_PROTOCOL',
     description: 'Protocol identifier for transaction gossiping.',
     defaultValue: '/aztec/0.1.0',
   },
-  minPeerCount: {
-    env: 'P2P_MIN_PEERS',
-    description: 'The minimum number of peers to connect to.',
-    ...numberConfigHelper(10),
-  },
   maxPeerCount: {
     env: 'P2P_MAX_PEERS',
     description: 'The maximum number of peers to connect to.',
@@ -244,7 +268,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   gossipsubInterval: {
     env: 'P2P_GOSSIPSUB_INTERVAL_MS',
     description: 'The interval of the gossipsub heartbeat to perform maintenance tasks.',
-    ...numberConfigHelper(1_000),
+    ...numberConfigHelper(700),
   },
   gossipsubD: {
     env: 'P2P_GOSSIPSUB_D',
@@ -261,10 +285,20 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'The Dhi parameter for the gossipsub protocol.',
     ...numberConfigHelper(12),
   },
+  gossipsubDLazy: {
+    env: 'P2P_GOSSIPSUB_DLAZY',
+    description: 'The Dlazy parameter for the gossipsub protocol.',
+    ...numberConfigHelper(6),
+  },
+  gossipsubFloodPublish: {
+    env: 'P2P_GOSSIPSUB_FLOOD_PUBLISH',
+    description: 'Whether to flood publish messages. - For testing purposes only',
+    ...booleanConfigHelper(true),
+  },
   gossipsubMcacheLength: {
     env: 'P2P_GOSSIPSUB_MCACHE_LENGTH',
     description: 'The number of gossipsub interval message cache windows to keep.',
-    ...numberConfigHelper(5),
+    ...numberConfigHelper(6),
   },
   gossipsubMcacheGossip: {
     env: 'P2P_GOSSIPSUB_MCACHE_GOSSIP',
@@ -298,11 +332,6 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'The "age" (in L2 blocks) of a tx after which we heavily penalize a peer for sending it.',
     ...numberConfigHelper(30),
   },
-  l1ChainId: {
-    env: 'L1_CHAIN_ID',
-    description: 'The chain id of the L1 chain.',
-    ...numberConfigHelper(31337),
-  },
   blockRequestBatchSize: {
     env: 'P2P_BLOCK_REQUEST_BATCH_SIZE',
     description: 'The number of blocks to fetch in a single batch.',
@@ -315,6 +344,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     ...numberConfigHelper(0),
   },
   ...p2pReqRespConfigMappings,
+  ...chainConfigMappings,
 };
 
 /**
@@ -332,17 +362,14 @@ export function getP2PDefaultConfig(): P2PConfig {
 /**
  * Required P2P config values for a bootstrap node.
  */
-export type BootnodeConfig = Pick<
-  P2PConfig,
-  'udpAnnounceAddress' | 'peerIdPrivateKey' | 'minPeerCount' | 'maxPeerCount'
-> &
+export type BootnodeConfig = Pick<P2PConfig, 'udpAnnounceAddress' | 'peerIdPrivateKey' | 'maxPeerCount'> &
   Required<Pick<P2PConfig, 'udpListenAddress'>> &
-  Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKB'>;
+  Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKB'> &
+  ChainConfig;
 
 const bootnodeConfigKeys: (keyof BootnodeConfig)[] = [
   'udpAnnounceAddress',
   'peerIdPrivateKey',
-  'minPeerCount',
   'maxPeerCount',
   'udpListenAddress',
   'dataDirectory',

package/src/mem_pools/index.ts

@@ -1,4 +1,4 @@
-export type { TxPool } from './tx_pool/tx_pool.js';
-export type { AttestationPool } from './attestation_pool/attestation_pool.js';
-export type { EpochProofQuotePool } from './epoch_proof_quote_pool/epoch_proof_quote_pool.js';
+export { TxPool } from './tx_pool/tx_pool.js';
+export { AttestationPool } from './attestation_pool/attestation_pool.js';
+export { EpochProofQuotePool } from './epoch_proof_quote_pool/epoch_proof_quote_pool.js';
 export { type MemPools } from './interface.js';

package/src/mem_pools/instrumentation.ts

@@ -5,7 +5,6 @@ import {
   LmdbMetrics,
   type LmdbStatsCallback,
   Metrics,
-  type MetricsType,
   type TelemetryClient,
   type UpDownCounter,
 } from '@aztec/telemetry-client';
@@ -17,8 +16,8 @@ export enum PoolName {
 }
 
 type MetricsLabels = {
-  objectInMempool: MetricsType;
-  objectSize: MetricsType;
+  objectInMempool: Metrics;
+  objectSize: Metrics;
 };
 
 /**

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -1,10 +1,10 @@
 import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/circuit-types';
-import { type EpochCache } from '@aztec/epoch-cache';
+import { type EpochCacheInterface } from '@aztec/epoch-cache';
 
 export class AttestationValidator implements P2PValidator<BlockAttestation> {
-  private epochCache: EpochCache;
+  private epochCache: EpochCacheInterface;
 
-  constructor(epochCache: EpochCache) {
+  constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
   }
 

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -1,10 +1,10 @@
 import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/circuit-types';
-import { type EpochCache } from '@aztec/epoch-cache';
+import { type EpochCacheInterface } from '@aztec/epoch-cache';
 
 export class BlockProposalValidator implements P2PValidator<BlockProposal> {
-  private epochCache: EpochCache;
+  private epochCache: EpochCacheInterface;
 
-  constructor(epochCache: EpochCache) {
+  constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
   }
 

package/src/msg_validators/epoch_proof_quote_validator/epoch_proof_quote_validator.ts

@@ -1,10 +1,10 @@
 import { type EpochProofQuote, type P2PValidator, PeerErrorSeverity } from '@aztec/circuit-types';
-import { type EpochCache } from '@aztec/epoch-cache';
+import { type EpochCacheInterface } from '@aztec/epoch-cache';
 
 export class EpochProofQuoteValidator implements P2PValidator<EpochProofQuote> {
-  private epochCache: EpochCache;
+  private epochCache: EpochCacheInterface;
 
-  constructor(epochCache: EpochCache) {
+  constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
   }
 

package/src/services/discv5/discV5_service.ts

@@ -1,3 +1,4 @@
+import { type ComponentsVersions, checkCompressedComponentVersion } from '@aztec/circuit-types';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { OtelMetricsAdapter, type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
@@ -10,8 +11,9 @@ import EventEmitter from 'events';
 
 import type { P2PConfig } from '../../config.js';
 import { convertToMultiaddr } from '../../util.js';
+import { setAztecEnrKey } from '../../versioning.js';
 import { type PeerDiscoveryService, PeerDiscoveryState } from '../service.js';
-import { AZTEC_ENR_KEY, AZTEC_NET, Discv5Event, PeerEvent } from '../types.js';
+import { AZTEC_ENR_KEY, Discv5Event, PeerEvent } from '../types.js';
 
 const delayBeforeStart = 2000; // 2sec
 
@@ -25,29 +27,32 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   /** This instance's ENR */
   private enr: SignableENR;
 
+  /** Version identifiers. */
+  private versions: ComponentsVersions;
+
   /** UDP listen addr */
   private listenMultiAddrUdp: Multiaddr;
 
   private currentState = PeerDiscoveryState.STOPPED;
 
-  private bootstrapNodes: string[];
+  public readonly bootstrapNodes: string[] = [];
   private bootstrapNodePeerIds: PeerId[] = [];
 
   private startTime = 0;
 
   constructor(
     private peerId: PeerId,
-    config: P2PConfig,
+    private config: P2PConfig,
     telemetry: TelemetryClient = getTelemetryClient(),
     private logger = createLogger('p2p:discv5_service'),
   ) {
     super();
     const { tcpAnnounceAddress, udpAnnounceAddress, udpListenAddress, bootstrapNodes } = config;
-    this.bootstrapNodes = bootstrapNodes;
+    this.bootstrapNodes = bootstrapNodes ?? [];
     // create ENR from PeerId
     this.enr = SignableENR.createFromPeerId(peerId);
     // Add aztec identification to ENR
-    this.enr.set(AZTEC_ENR_KEY, Uint8Array.from([AZTEC_NET]));
+    this.versions = setAztecEnrKey(this.enr, config);
 
     if (!tcpAnnounceAddress) {
       throw new Error('You need to provide at least a TCP announce address.');
@@ -78,6 +83,20 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       metricsRegistry,
     });
 
+    // Hook onto the onEstablished method to check the peer's version from the ENR,
+    // so we don't add it to our dht if it doesn't have the correct version.
+    // In addition, we'll hook onto onDiscovered to to repeat the same check there,
+    // just in case. Note that not adding the peer to the dht could lead to it
+    // being "readded" constantly, we'll need to keep an eye on whether this
+    // turns out to be a problem or not.
+    const origOnEstablished = this.discv5.onEstablished.bind(this.discv5);
+    this.discv5.onEstablished = (...args: unknown[]) => {
+      const enr = args[1] as ENR;
+      if (this.validateEnr(enr)) {
+        return origOnEstablished(...args);
+      }
+    };
+
     this.discv5.on(Discv5Event.DISCOVERED, this.onDiscovered.bind(this));
     this.discv5.on(Discv5Event.ENR_ADDED, this.onEnrAdded.bind(this));
   }
@@ -95,20 +114,29 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       peerId: this.peerId,
       enrUdp: await this.enr.getFullMultiaddr('udp'),
       enrTcp: await this.enr.getFullMultiaddr('tcp'),
+      versions: this.versions,
     });
     this.currentState = PeerDiscoveryState.RUNNING;
 
     // Add bootnode ENR if provided
     if (this.bootstrapNodes?.length) {
       // Do this conversion once since it involves an async function call
-      this.bootstrapNodePeerIds = await Promise.all(this.bootstrapNodes.map(enr => ENR.decodeTxt(enr).peerId()));
-      this.logger.info(`Adding bootstrap nodes ENRs: ${this.bootstrapNodes.join(', ')}`);
-      try {
-        this.bootstrapNodes.forEach(enr => {
+      const bootstrapNodesEnrs = this.bootstrapNodes.map(enr => ENR.decodeTxt(enr));
+      this.bootstrapNodePeerIds = await Promise.all(bootstrapNodesEnrs.map(enr => enr.peerId()));
+      this.logger.info(`Adding ${this.bootstrapNodes} bootstrap nodes ENRs: ${this.bootstrapNodes.join(', ')}`);
+      for (const enr of bootstrapNodesEnrs) {
+        try {
+          if (this.config.bootstrapNodeEnrVersionCheck) {
+            const value = enr.kvs.get(AZTEC_ENR_KEY);
+            if (!value) {
+              throw new Error('ENR does not contain aztec key');
+            }
+            checkCompressedComponentVersion(Buffer.from(value).toString(), this.versions);
+          }
           this.discv5.addEnr(enr);
-        });
-      } catch (e) {
-        this.logger.error(`Error adding bootnode ENRs: ${e}`);
+        } catch (e) {
+          this.logger.error(`Error adding bootratrap node ${enr.encodeTxt()}`, e);
+        }
       }
     }
   }
@@ -169,14 +197,35 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   }
 
   private onDiscovered(enr: ENR) {
-    // check the peer is an aztec peer
+    if (this.validateEnr(enr)) {
+      this.emit(PeerEvent.DISCOVERED, enr);
+    }
+  }
+
+  private validateEnr(enr: ENR): boolean {
+    // Check the peer is an aztec peer
     const value = enr.kvs.get(AZTEC_ENR_KEY);
-    if (value) {
-      const network = value[0];
-      // check if the peer is on the same network
-      if (network === AZTEC_NET) {
-        this.emit(PeerEvent.DISCOVERED, enr);
+    if (!value) {
+      this.logger.warn(`Peer ${enr.nodeId} does not have aztec key in ENR`);
+      return false;
+    }
+
+    let compressedVersion;
+    try {
+      // And check it has the correct version
+      compressedVersion = Buffer.from(value).toString();
+      checkCompressedComponentVersion(compressedVersion, this.versions);
+      return true;
+    } catch (err: any) {
+      if (err.name === 'ComponentsVersionsError') {
+        this.logger.warn(`Peer ${enr.nodeId} has incorrect version: ${err.message}`, {
+          compressedVersion,
+          expected: this.versions,
+        });
+      } else {
+        this.logger.error(`Error checking peer version`, err);
       }
     }
+    return false;
   }
 }

package/src/services/dummy_service.ts

@@ -88,6 +88,8 @@ export class DummyP2PService implements P2PService {
  */
 export class DummyPeerDiscoveryService extends EventEmitter implements PeerDiscoveryService {
   private currentState = PeerDiscoveryState.STOPPED;
+  public bootstrapNodes: string[] = [];
+
   /**
    * Starts the dummy implementation.
    * @returns A resolved promise.

package/src/services/libp2p/libp2p_logger.ts

@@ -0,0 +1,78 @@
+import { createLogger } from '@aztec/foundation/log';
+
+import { type ComponentLogger, type Logger } from '@libp2p/interface';
+
+/**
+ * Creates a libp2p compatible logger that wraps our pino logger.
+ * This adapter implements the ComponentLogger interface required by libp2p.
+ */
+export function createLibp2pComponentLogger(namespace: string, fixedTerms = {}): ComponentLogger {
+  return {
+    forComponent: (component: string) => createLibp2pLogger(`${namespace}:${component}`, fixedTerms),
+  };
+}
+
+function createLibp2pLogger(component: string, fixedTerms = {}): Logger {
+  const logger = createLogger(component, fixedTerms);
+
+  // Default log level is trace as this is super super noisy
+  const logFn = (formatter: any, ...args: any[]) => {
+    // Handle %p format specifier by manually replacing with args
+    if (typeof formatter === 'string' && args.length > 0) {
+      // Handle %p, %a, %s and %d format specifiers
+      const parts = formatter.split(/(%p|%a|%s|%d)/);
+      let result = parts[0];
+      let argIndex = 0;
+
+      for (let i = 1; i < parts.length; i += 2) {
+        if (argIndex < args.length) {
+          result += String(args[argIndex]) + (parts[i + 1] || '');
+          argIndex++;
+        }
+      }
+
+      formatter = result;
+      // Only keep non-format args as data
+      args = args.slice(argIndex);
+    }
+
+    // Handle object args by spreading them, but only if they weren't used in formatting
+    if (args.length === 1 && typeof args[0] === 'object') {
+      logger.trace(formatter, args[0]);
+    } else if (args.length > 0) {
+      // If we have remaining args after formatting, pass them as data
+      logger.trace(formatter, { _args: args });
+    } else {
+      logger.trace(formatter);
+    }
+  };
+
+  return Object.assign(logFn, {
+    enabled: logger.isLevelEnabled('debug'),
+
+    error(...args: any[]) {
+      const [msg, ...rest] = args;
+      logger.error(msg as string, ...rest);
+    },
+
+    debug(...args: any[]) {
+      const [msg, ...rest] = args;
+      logger.debug(msg as string, ...rest);
+    },
+
+    info(...args: any[]) {
+      const [msg, ...rest] = args;
+      logger.info(msg as string, ...rest);
+    },
+
+    warn(...args: any[]) {
+      const [msg, ...rest] = args;
+      logger.warn(msg as string, ...rest);
+    },
+
+    trace(...args: any[]) {
+      const [msg, ...rest] = args;
+      logger.trace(msg as string, ...rest);
+    },
+  });
+}