@livedigital/client 3.48.0 → 3.49.1

package/src/engine/analyticsApiClient/index.ts

@@ -1,42 +0,0 @@
-import axios, { AxiosInstance } from 'axios';
-import qs from 'qs';
-import { injectable } from 'inversify';
-import { receiveClientTrackingId } from './helper';
-import LogApi from './LogApi';
-import MetricsApi from './MetricsApi';
-
-@injectable()
-export default class AnalyticsApiClient {
-  private readonly api: AxiosInstance;
-
-  private readonly logApi: LogApi;
-
-  private readonly metricsApi: MetricsApi;
-
-  constructor() {
-    this.api = axios.create({
-      baseURL: process.env.LIVEDIGITAL_APP_ANALYTICS_API_BASE_URL,
-      timeout: 10_000,
-      withCredentials: true,
-      paramsSerializer: (params) => qs.stringify(params),
-      headers: {
-        'x-cl-id': receiveClientTrackingId(),
-      },
-    });
-
-    this.api.defaults.headers.common['Cache-Control'] = 'no-cache';
-    this.api.defaults.headers.common.Pragma = 'no-cache';
-    this.api.defaults.headers.common.Expires = '0';
-
-    this.logApi = new LogApi(this.api);
-    this.metricsApi = new MetricsApi(this.api);
-  }
-
-  get log(): LogApi {
-    return this.logApi;
-  }
-
-  get metrics(): MetricsApi {
-    return this.metricsApi;
-  }
-}

package/src/engine/analyticsApiClient/types.ts

@@ -1,33 +0,0 @@
-import type { ClientMetaPayload } from '../../ClientMetaProvider';
-import type { LogToRemotePayload } from '../Logger';
-
-export interface BatchLogPayload {
-  logs: LogToRemotePayload[];
-  clientMeta: Record<string, unknown>;
-}
-
-export interface NetworkMetric {
-  jitter: number;
-  rtt: number;
-  packetLoss: number;
-  mos: number;
-  streams: number;
-  node: string;
-  direction: 'inbound' | 'outbound';
-  timestamp: string;
-  bitrate: number;
-}
-
-export interface NetworkMetricsBatch {
-  metrics: NetworkMetric[];
-  clientMeta: ClientMetaPayload & {
-    clientUniqueId: string;
-  };
-}
-
-export interface WIDMetricsBatch {
-  reasons: string[];
-  clientMeta: ClientMetaPayload & {
-    clientUniqueId: string;
-  };
-}

package/src/engine/handlers/ChannelAudioObserverEventHandler.ts

@@ -1,177 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { serializeError } from 'serialize-error';
-import { CLIENT_EVENTS } from '../../constants/events';
-import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import InvalidPayloadError from '../../errors/InvalidPayloadError';
-import { TOKEN } from '../../inversify.tokens';
-import {
-  AudioObserverEvents,
-  ChannelAudioObserverEvents,
-  DominantSpeakerEvent,
-  PeersVolumesEvent,
-} from '../../types/channelAudioObserver';
-import { TrackLabel } from '../../types/common';
-import Logger from '../Logger';
-import Peer from '../Peer';
-import PeersStorage from '../PeersStorage';
-
-@injectable()
-class ChannelAudioObserverEventHandler {
-  readonly #logger: Logger;
-
-  #activePeerId?: Peer['id'];
-
-  #currentActiveSpeaker?: Peer;
-
-  #prevActiveSpeaker?: Peer;
-
-  constructor(
-    @inject(TOKEN.PeersStorage) private readonly peersStorage: PeersStorage,
-    @inject(TOKEN.ClientEventEmitter) private readonly clientEventEmitter: EnhancedEventEmitter,
-    @inject(TOKEN.LoggerFactory) loggerFactory: (namespace: string) => Logger,
-  ) {
-    this.#logger = loggerFactory('ChannelAudioObserverEventHandler');
-
-    this.watchPeersLeave();
-  }
-
-  public handle(data: string): void {
-    try {
-      const payload: AudioObserverEvents = JSON.parse(data);
-      ChannelAudioObserverEventHandler.validateEventPayload(payload);
-
-      switch (payload.event) {
-        case ChannelAudioObserverEvents.DominantSpeaker: {
-          this.handleDominantSpeaker(payload);
-          break;
-        }
-
-        case ChannelAudioObserverEvents.PeersVolumes: {
-          this.handlePeerVolumes(payload);
-          break;
-        }
-
-        case ChannelAudioObserverEvents.Silence: {
-          this.handleSilence();
-          break;
-        }
-        default:
-          break;
-      }
-    } catch (error) {
-      this.#logger.warn('Failed to handle audio observer event', {
-        error: serializeError(error),
-        eventData: data,
-      });
-    }
-  }
-
-  private handleDominantSpeaker(payload: DominantSpeakerEvent): void {
-    const { peerId } = payload.data;
-    const peer = this.peersStorage.get(peerId);
-    this.#currentActiveSpeaker = peer;
-    this.#prevActiveSpeaker = peer;
-    this.setActiveSpeaker(peer);
-  }
-
-  private handlePeerVolumes(payload: PeersVolumesEvent): void {
-    payload.volumes.forEach((item) => {
-      const { peerId, trackLabel, value } = item;
-      const peer = this.peersStorage.get(peerId);
-
-      if (!peer) {
-        return;
-      }
-
-      if (value > 0 && !this.#currentActiveSpeaker && peer.id === this.#prevActiveSpeaker?.id) {
-        this.#currentActiveSpeaker = peer;
-        this.setActiveSpeaker(peer);
-      }
-
-      const track = peer?.tracks.get(trackLabel);
-
-      if (!track) {
-        return;
-      }
-
-      track.setVolume(value);
-    });
-  }
-
-  private handleSilence(): void {
-    const tracks = this.peersStorage.all().flatMap((peer) => Array.from(peer.tracks.values()));
-    tracks.forEach((track) => track.setVolume(0));
-    this.#currentActiveSpeaker = undefined;
-    this.setActiveSpeaker(undefined);
-  }
-
-  private watchPeersLeave(): void {
-    this.clientEventEmitter.on(CLIENT_EVENTS.peerLeft, (peerId: Peer['id']): void => {
-      if (peerId === this.#currentActiveSpeaker?.id) {
-        this.setActiveSpeaker(undefined);
-      }
-    });
-  }
-
-  private setActiveSpeaker(peer?: Peer): void {
-    if (this.#activePeerId === peer?.id) {
-      return;
-    }
-
-    this.#activePeerId = peer?.id;
-    this.clientEventEmitter.safeEmit(CLIENT_EVENTS.activeSpeakerChanged, { peer });
-  }
-
-  private static validateEventPayload(payload: AudioObserverEvents): void {
-    switch (payload.event) {
-      case ChannelAudioObserverEvents.Silence: {
-        break;
-      }
-
-      case ChannelAudioObserverEvents.DominantSpeaker: {
-        if (!payload.data) {
-          ChannelAudioObserverEventHandler.throwInvalidPayload();
-        }
-
-        const { peerId, producerId, trackLabel } = payload.data;
-
-        if (typeof peerId !== 'string' || typeof producerId !== 'string' || trackLabel !== TrackLabel.Microphone) {
-          ChannelAudioObserverEventHandler.throwInvalidPayload();
-        }
-        break;
-      }
-
-      case ChannelAudioObserverEvents.PeersVolumes: {
-        if (!Array.isArray(payload.volumes)) {
-          ChannelAudioObserverEventHandler.throwInvalidPayload();
-        }
-
-        payload.volumes.forEach((item) => {
-          const {
-            peerId, producerId, value, trackLabel,
-          } = item;
-
-          if (
-            typeof peerId !== 'string'
-            || typeof producerId !== 'string'
-            || typeof value !== 'number'
-            || trackLabel !== TrackLabel.Microphone
-          ) {
-            ChannelAudioObserverEventHandler.throwInvalidPayload();
-          }
-        });
-        break;
-      }
-
-      default: {
-        ChannelAudioObserverEventHandler.throwInvalidPayload();
-      }
-    }
-  }
-
-  static throwInvalidPayload(): void {
-    throw new InvalidPayloadError('invalid_channel_audio_observer_payload');
-  }
-}
-
-export default ChannelAudioObserverEventHandler;

package/src/engine/handlers/ChannelEventHandler.ts

@@ -1,268 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { CHANNEL_EVENTS, CLIENT_EVENTS } from '../../constants/events';
-import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import { logResponse } from '../../helpers/peer';
-import { TOKEN } from '../../inversify.tokens';
-import Logger from '../Logger';
-import { Peers } from '../Peers';
-import { serializeError } from 'serialize-error';
-import ChannelStateSyncEventHandler from './ChannelStateSyncEventHandler';
-import type { ChannelEvent } from '../../proto/generated/channel_message/channel_event';
-import { ChannelEventType } from '../../proto/generated/channel_message/channel_event';
-import ChannelStateSynchronizer from '../ChannelStateSynchronizer/ChannelStateSynchronizer';
-import {
-  convertChannelMessagePeerToPeerResponse,
-  convertChannelMessagePeerGroupsToPeerGroups,
-  convertPeerGroupsToChannelMessagePeerGroups,
-  convertChannelMessageProducerLabelsToTrackLabels,
-} from '../../helpers/channelMessageConverter';
-import { ActivityConfirmationRequiredPayload } from '../../types/common';
-
-@injectable()
-class ChannelEventHandler {
-  readonly #logger: Logger;
-
-  constructor(
-    @inject(TOKEN.Peers) private readonly peers: Peers,
-    @inject(TOKEN.ClientEventEmitter) private readonly clientEventEmitter: EnhancedEventEmitter,
-    @inject(TOKEN.LoggerFactory) loggerFactory: (namespace: string) => Logger,
-    @inject(TOKEN.ChannelStateSyncEventHandler)
-    private readonly channelStateSyncEventHandler: ChannelStateSyncEventHandler,
-    @inject(TOKEN.ChannelStateSynchronizer) private readonly channelStateSynchronizer: ChannelStateSynchronizer,
-  ) {
-    this.#logger = loggerFactory('ChannelEvents');
-  }
-
-  public async handleChannelEvent(event: ChannelEvent): Promise<void> {
-    switch (event.eventType) {
-      case ChannelEventType.CHANNEL_EVENT_TYPE_CHANNEL_STATE:
-        await this.handleChannelState(event);
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_CHANNEL_STATE_SHORT:
-        this.handleChannelStateShort(event);
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_CHANNEL_MANAGEMENT_EVENT:
-        this.handleChannelManagementEvent(event);
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_PEER_JOINED:
-        this.handlePeerJoined(event);
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_PEER_LEFT:
-        this.handlePeerLeft(event);
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_PEER_APP_DATA_CHANGED:
-        this.handlePeerAppDataChanged(event);
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_PEER_GROUP_CHANGED:
-        this.handlePeerGroupsChanged(event);
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_CHANNEL_ACTIVITY_CONFIRMATION_ACQUIRED:
-        this.handleChannelActivityConfirmationAcquired();
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_CHANNEL_ACTIVITY_CONFIRMATION_EXPIRED:
-        this.handleChannelActivityConfirmationExpired();
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_CHANNEL_ACTIVITY_CONFIRMATION_REQUIRED:
-        this.handleChannelActivityConfirmationRequired(event);
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_CHANNEL_PRODUCE_PERMISSIONS_CHANGED:
-        this.handleChannelProducePermissionsChanged(event);
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_PEER_PRODUCE_PERMISSIONS_CHANGED:
-        this.handlePeerProducePermissionsChanged(event);
-        break;
-
-      case ChannelEventType.CHANNEL_EVENT_TYPE_CHANNEL_PRODUCE_PERMISSIONS_DELETED:
-        this.handleChannelProducePermissionsDeleted(event);
-        break;
-
-      default:
-        throw new Error(`Unsupported event type: ${ event.eventType }`);
-    }
-  }
-
-  private handleChannelManagementEvent(event: ChannelEvent): void {
-    if (!event.channelManagementEvent) {
-      throw new Error('Missing channelManagementEvent in CHANNEL_MANAGEMENT_EVENT');
-    }
-
-    const channelManagementEvent = event.channelManagementEvent.event;
-    this.clientEventEmitter.safeEmit(CLIENT_EVENTS.channelEvent, channelManagementEvent);
-    this.#logger.debug('New channel event', { event: channelManagementEvent });
-  }
-
-  private handlePeerJoined(event: ChannelEvent): void {
-    if (!event.peer) {
-      throw new Error('Missing peer in PEER_APP_DATA_CHANGED event');
-    }
-
-    const peer = this.peers.add(convertChannelMessagePeerToPeerResponse(event.peer));
-    this.#logger.debug('Peer joined to the channel', { peer: logResponse(peer) });
-  }
-
-  private handlePeerLeft(event: ChannelEvent): void {
-    if (!event.peer) {
-      throw new Error('Missing peer in PEER_LEFT event');
-    }
-
-    this.peers.remove(event.peer.id).catch((error: unknown) => {
-      this.#logger.debug('Failed to remove peer', {
-        error: serializeError(error),
-      });
-    });
-
-    this.#logger.debug('Peer left the channel', { peerId: event.peer.id });
-  }
-
-  private async handleChannelState(event: ChannelEvent): Promise<void> {
-    if (!event.channelState) {
-      throw new Error('Missing channelState in CHANNEL_STATE event');
-    }
-
-    try {
-      await this.channelStateSynchronizer.handleChannelStateEvent(event.channelState);
-    } catch (error) {
-      this.#logger.error('Failed to restore channel state', {
-        case: 'restoreLocalState',
-        error: serializeError(error),
-      });
-    }
-  }
-
-  private handleChannelStateShort(event: ChannelEvent): void {
-    if (!event.channelStateShort) {
-      throw new Error('Missing channelStateShort in CHANNEL_STATE_SHORT event');
-    }
-
-    this.channelStateSyncEventHandler.handleChannelStateShort(event.channelStateShort).catch((error: unknown) => {
-      this.#logger.error('Failed to handle channel state short event', { error: serializeError(error) });
-    });
-  }
-
-  private handlePeerAppDataChanged(event: ChannelEvent): void {
-    if (!event.peer) {
-      throw new Error('Missing peer in PEER_APP_DATA_CHANGED event');
-    }
-
-    const peer = this.peers.get(event.peer.id);
-
-    if (peer) {
-      peer.observer.emit(CHANNEL_EVENTS.updatePeerAppData, event.peer.appData);
-    }
-  }
-
-  private handlePeerGroupsChanged(event: ChannelEvent): void {
-    if (!event.peer) {
-      throw new Error('Missing peer in PEER_GROUP_CHANGED event');
-    }
-
-    const peer = this.peers.get(event.peer.id);
-    peer?.handleGroupsChange(event.peer.groups.map(convertChannelMessagePeerGroupsToPeerGroups));
-  }
-
-  private handleChannelActivityConfirmationExpired(): void {
-    this.clientEventEmitter.safeEmit(CLIENT_EVENTS.activityConfirmationExpired);
-    this.#logger.info('Notify the channel that it has disconnected due to the activity confirmation expiring', {});
-  }
-
-  private handleChannelActivityConfirmationAcquired(): void {
-    this.clientEventEmitter.safeEmit(CLIENT_EVENTS.activityConfirmationAcquired);
-    this.#logger.info('Notify the channel that the activity has been acquired.', {});
-  }
-
-  private handleChannelActivityConfirmationRequired(event: ChannelEvent): void {
-    if (!event.channelActivityConfirmationTime) {
-      throw new Error('Missing channelActivityConfirmationTime in CHANNEL_ACTIVITY_CONFIRMATION_REQUIRED event');
-    }
-
-    const eventPayload = event.channelActivityConfirmationTime as ActivityConfirmationRequiredPayload;
-    this.clientEventEmitter.safeEmit(CLIENT_EVENTS.activityConfirmationRequired, eventPayload);
-    this.#logger.info('Notify the channel that activity confirmation is required', {
-      event: event.channelActivityConfirmationTime,
-    });
-  }
-
-  private handleChannelProducePermissionsChanged(event: ChannelEvent): void {
-    if (!event.channelProducePermissions) {
-      throw new Error('Missing channelProducePermissions in CHANNEL_PRODUCE_PERMISSIONS_CHANGED event');
-    }
-
-    const { groups } = event.channelProducePermissions;
-    const peers = this.peers.all().filter((peer) => peer
-      .groups
-      .some((group) => groups.includes(convertPeerGroupsToChannelMessagePeerGroups(group))));
-
-    const producePermissions = event
-      .channelProducePermissions
-      .producePermissions.map(convertChannelMessageProducerLabelsToTrackLabels);
-
-    const changedProducePermissions = event
-      .channelProducePermissions
-      .changedProducePermissions.map(convertChannelMessageProducerLabelsToTrackLabels);
-
-    peers.forEach((peer) => {
-      const newProducePermissions = Array.from(new Set([...peer.producePermissions, ...changedProducePermissions]))
-        .filter((label) => {
-          return (changedProducePermissions.includes(label) ? producePermissions.includes(label) : true);
-        });
-
-      peer.handleProducePermissionsChange(newProducePermissions);
-    });
-
-    this.#logger.info('Peers changed produce permissions', { groups, producePermissions });
-  }
-
-  private handlePeerProducePermissionsChanged(event: ChannelEvent): void {
-    if (!event.peer) {
-      throw new Error('Missing peer in PEER_PRODUCE_PERMISSIONS_CHANGED event');
-    }
-
-    const peer = this.peers.get(event.peer.id);
-
-    if (!peer) {
-      return;
-    }
-
-    const producePermissions = event.peer.producePermissions.map(convertChannelMessageProducerLabelsToTrackLabels);
-    peer.handleProducePermissionsChange(producePermissions);
-  }
-
-  private handleChannelProducePermissionsDeleted(event: ChannelEvent): void {
-    if (!event.channelProducePermissions) {
-      throw new Error('Missing channelProducePermissions in CHANNEL_PRODUCE_PERMISSIONS_DELETED event');
-    }
-
-    const { groups } = event.channelProducePermissions;
-    const peers = this.peers.all().filter((peer) => peer
-      .groups
-      .some((group) => groups.includes(convertPeerGroupsToChannelMessagePeerGroups(group))));
-
-    const producePermissions = event
-      .channelProducePermissions
-      .producePermissions
-      .map(convertChannelMessageProducerLabelsToTrackLabels);
-
-    peers.forEach((peer) => {
-      const newProducePermissions = peer
-        .producePermissions
-        .filter((permission) => !producePermissions.includes(permission));
-
-      peer.handleProducePermissionsChange(newProducePermissions);
-    });
-
-    this.#logger.info('Peers deleted produce permissions', { groups, producePermissions });
-  }
-}
-
-export default ChannelEventHandler;

package/src/engine/handlers/ChannelStateSyncEventHandler/ChannelStateConsistencyCheckResult.ts

@@ -1,31 +0,0 @@
-import type { ChannelStateConsistencyCheckResultsParams } from './types';
-
-class ChannelStateConsistencyCheckResult {
-  readonly missingPeers: string[];
-
-  readonly missingProducers: string[];
-
-  readonly consumersWithInconsistentState: string[];
-
-  readonly producersWithInconsistentState: string[];
-
-  readonly peersWithInconsistentAppData: string[];
-
-  constructor(params: ChannelStateConsistencyCheckResultsParams) {
-    this.missingPeers = params.missingPeers;
-    this.missingProducers = params.missingProducers;
-    this.consumersWithInconsistentState = params.consumersWithInconsistentState;
-    this.producersWithInconsistentState = params.producersWithInconsistentState;
-    this.peersWithInconsistentAppData = params.peersWithInconsistentAppData;
-  }
-
-  hasInconsistencyCases(): boolean {
-    return this.missingPeers.length > 0
-      || this.missingProducers.length > 0
-      || this.consumersWithInconsistentState.length > 0
-      || this.producersWithInconsistentState.length > 0
-      || this.peersWithInconsistentAppData.length > 0;
-  }
-}
-
-export default ChannelStateConsistencyCheckResult;

package/src/engine/handlers/ChannelStateSyncEventHandler/ChannelStateConsistencyChecker.ts

@@ -1,146 +0,0 @@
-import { FIVE_SECONDS_IN_MS } from '../../../constants/common';
-import type {
-  ChannelStateShort,
-} from '../../../proto/generated/channel/channel_state_short';
-import type {
-  LocalChannelState,
-  LocalChannelStatePeer,
-  LocalChannelStatePeerConsumer,
-  LocalChannelStatePeerProducer,
-} from '../../../types/channelStateSyncronizer';
-import ChannelStateConsistencyCheckResult from './ChannelStateConsistencyCheckResult';
-
-interface ChannelStateConsistencyCheckerParams {
-  localState: LocalChannelState;
-  remoteState: ChannelStateShort;
-}
-
-class ChannelStateConsistencyChecker {
-  private readonly localState: LocalChannelState;
-
-  private readonly remoteState: ChannelStateShort;
-
-  private missingPeers: string[] = [];
-
-  private missingProducers: string[] = [];
-
-  private consumersWithInconsistentState: string[] = [];
-
-  private producersWithInconsistentState: string[] = [];
-
-  private peersWithInconsistentAppData: string[] = [];
-
-  constructor(params: ChannelStateConsistencyCheckerParams) {
-    this.localState = params.localState;
-    this.remoteState = params.remoteState;
-  }
-
-  check(): ChannelStateConsistencyCheckResult {
-    this.resetPreviousCheckResults();
-    this.remoteState.peers.forEach((remotePeer) => {
-      const localPeer = this.findLocalPeerById(remotePeer.id);
-
-      if (!localPeer) {
-        this.missingPeers.push(remotePeer.id);
-
-        return;
-      }
-
-      const isDifferentAppData = localPeer.appDataHash !== remotePeer.appDataHash;
-
-      if (isDifferentAppData) {
-        this.peersWithInconsistentAppData.push(remotePeer.id);
-      }
-
-      remotePeer.producers.forEach((remoteProducer) => {
-        const localProducer = this.findLocalProducerById(localPeer, remoteProducer.id);
-
-        if (!localProducer) {
-          this.missingProducers.push(remoteProducer.id);
-
-          return;
-        }
-
-        if (this.isLocalProducerStateChangedRecently(localProducer)) {
-          return;
-        }
-
-        const isInconsistentState = localProducer.paused !== remoteProducer.paused;
-
-        if (isInconsistentState) {
-          this.producersWithInconsistentState.push(remoteProducer.id);
-
-          // don't check consumer state while producer state is inconsistent
-          return;
-        }
-
-        const localConsumer = this.findLocalConsumerByProducerId(localPeer, remoteProducer.id);
-
-        if (localConsumer && localConsumer.paused !== remoteProducer.paused) {
-          this.consumersWithInconsistentState.push(localConsumer.id);
-        }
-
-        if (!localProducer) {
-          this.missingProducers.push(remoteProducer.id);
-        }
-      });
-    });
-
-    return new ChannelStateConsistencyCheckResult({
-      missingPeers: this.missingPeers,
-      missingProducers: this.missingProducers,
-      consumersWithInconsistentState: this.consumersWithInconsistentState,
-      producersWithInconsistentState: this.producersWithInconsistentState,
-      peersWithInconsistentAppData: this.peersWithInconsistentAppData,
-    });
-  }
-
-  getMissingPeers(): string[] {
-    return this.missingPeers;
-  }
-
-  getMissingProducers(): string[] {
-    return this.missingProducers;
-  }
-
-  getConsumersWithInconsistentState(): string[] {
-    return this.consumersWithInconsistentState;
-  }
-
-  getProducersWithInconsistentState(): string[] {
-    return this.producersWithInconsistentState;
-  }
-
-  getPeersWithInconsistentAppData(): string[] {
-    return this.peersWithInconsistentAppData;
-  }
-
-  private findLocalPeerById(id: string): LocalChannelStatePeer | undefined {
-    return this.localState.peers.find((item) => item.id === id);
-  }
-
-  private findLocalConsumerByProducerId(
-    peer: LocalChannelStatePeer,
-    producerId: string,
-  ): LocalChannelStatePeerConsumer | undefined {
-    return peer.consumers?.find((item) => item.producerId === producerId);
-  }
-
-  private findLocalProducerById(peer: LocalChannelStatePeer, id: string): LocalChannelStatePeerProducer | undefined {
-    return peer.producers.find((item) => item.id === id);
-  }
-
-  private resetPreviousCheckResults(): void {
-    this.missingPeers = [];
-    this.missingProducers = [];
-    this.consumersWithInconsistentState = [];
-    this.producersWithInconsistentState = [];
-    this.peersWithInconsistentAppData = [];
-  }
-
-  private isLocalProducerStateChangedRecently(producer: LocalChannelStatePeerProducer): boolean {
-    return Date.now() - producer.stateChangedAt < FIVE_SECONDS_IN_MS;
-  }
-}
-
-export default ChannelStateConsistencyChecker;