@waku/core 0.0.37-7a9850d.0 → 0.0.37-c7682ea.0

package/dist/lib/connection_manager/connection_manager.d.ts

@@ -1,119 +1,34 @@
-import { type Connection, type Peer, type PeerId, type Stream, TypedEventEmitter } from "@libp2p/interface";
+import { type Peer, type PeerId, type Stream } from "@libp2p/interface";
 import { MultiaddrInput } from "@multiformats/multiaddr";
-import { ConnectionManagerOptions, IConnectionManager, IConnectionStateEvents, IPeersByDiscoveryEvents, IRelay, PeersByDiscoveryResult, PubsubTopic } from "@waku/interfaces";
+import { ConnectionManagerOptions, IConnectionManager, IRelay, IWakuEventEmitter, NetworkConfig, PubsubTopic } from "@waku/interfaces";
 import { Libp2p } from "@waku/interfaces";
 type ConnectionManagerConstructorOptions = {
     libp2p: Libp2p;
+    events: IWakuEventEmitter;
     pubsubTopics: PubsubTopic[];
+    networkConfig: NetworkConfig;
     relay?: IRelay;
     config?: Partial<ConnectionManagerOptions>;
 };
-export declare class ConnectionManager extends TypedEventEmitter<IPeersByDiscoveryEvents & IConnectionStateEvents> implements IConnectionManager {
-    readonly pubsubTopics: PubsubTopic[];
-    private keepAliveManager;
+export declare class ConnectionManager implements IConnectionManager {
+    private readonly pubsubTopics;
+    private readonly keepAliveManager;
+    private readonly discoveryDialer;
+    private readonly dialer;
+    private readonly shardReader;
+    private readonly networkMonitor;
+    private readonly connectionLimiter;
     private options;
     private libp2p;
-    private dialAttemptsForPeer;
-    private dialErrorsForPeer;
-    private currentActiveParallelDialCount;
-    private pendingPeerDialQueue;
-    private isP2PNetworkConnected;
-    isConnected(): boolean;
-    stop(): void;
-    dropConnection(peerId: PeerId): Promise<void>;
-    getPeersByDiscovery(): Promise<PeersByDiscoveryResult>;
     constructor(options: ConnectionManagerConstructorOptions);
+    start(): void;
+    stop(): void;
+    isConnected(): boolean;
+    dial(peer: PeerId | MultiaddrInput, protocolCodecs: string[]): Promise<Stream>;
+    hangUp(peer: PeerId | MultiaddrInput): Promise<boolean>;
     getConnectedPeers(codec?: string): Promise<Peer[]>;
-    private dialPeerStorePeers;
-    private startEventListeners;
-    /**
-     * Attempts to establish a connection with a peer and set up specified protocols.
-     * The method handles both PeerId and Multiaddr inputs, manages connection attempts,
-     * and maintains the connection state.
-     *
-     * The dialing process includes:
-     * 1. Converting input to dialable peer info
-     * 2. Managing parallel dial attempts
-     * 3. Attempting to establish protocol-specific connections
-     * 4. Handling connection failures and retries
-     * 5. Updating the peer store and connection state
-     *
-     * @param {PeerId | MultiaddrInput} peer - The peer to connect to, either as a PeerId or multiaddr
-     * @param {string[]} [protocolCodecs] - Optional array of protocol-specific codec strings to establish
-     *                                      (e.g., for LightPush, Filter, Store protocols)
-     *
-     * @throws {Error} If the multiaddr is missing a peer ID
-     * @throws {Error} If the maximum dial attempts are reached and the peer cannot be dialed
-     * @throws {Error} If there's an error deleting an undialable peer from the peer store
-     *
-     * @example
-     * ```typescript
-     * // Dial using PeerId
-     * await connectionManager.dialPeer(peerId);
-     *
-     * // Dial using multiaddr with specific protocols
-     * await connectionManager.dialPeer(multiaddr, [
-     *   "/vac/waku/relay/2.0.0",
-     *   "/vac/waku/lightpush/2.0.0-beta1"
-     * ]);
-     * ```
-     *
-     * @remarks
-     * - The method implements exponential backoff through multiple dial attempts
-     * - Maintains a queue for parallel dial attempts (limited by maxParallelDials)
-     * - Integrates with the KeepAliveManager for connection maintenance
-     * - Updates the peer store and connection state after successful/failed attempts
-     * - If all dial attempts fail, triggers DNS discovery as a fallback
-     */
-    dialPeer(peer: PeerId | MultiaddrInput): Promise<Connection>;
-    /**
-     * Dial a peer with specific protocols.
-     * This method is a raw proxy to the libp2p dialProtocol method.
-     * @param peer - The peer to connect to, either as a PeerId or multiaddr
-     * @param protocolCodecs - Optional array of protocol-specific codec strings to establish
-     * @returns A stream to the peer
-     */
-    rawDialPeerWithProtocols(peer: PeerId | MultiaddrInput, protocolCodecs: string[]): Promise<Stream>;
-    /**
-     * Internal utility to extract a PeerId or Multiaddr from a peer input.
-     * This is used internally by the connection manager to handle different peer input formats.
-     * @internal
-     */
-    private getDialablePeerInfo;
-    private attemptDnsDiscovery;
-    private processDialQueue;
-    private startPeerDiscoveryListener;
-    private startPeerConnectionListener;
-    private startPeerDisconnectionListener;
-    attemptDial(peerId: PeerId): Promise<void>;
-    private onEventHandlers;
-    /**
-     * Checks if the peer should be dialed based on the following conditions:
-     * 1. If the peer is already connected, don't dial
-     * 2. If the peer is not part of any of the configured pubsub topics, don't dial
-     * 3. If the peer is not dialable based on bootstrap status, don't dial
-     * 4. If the peer is already has an active dial attempt, or has been dialed before, don't dial it
-     * @returns true if the peer should be dialed, false otherwise
-     */
-    private shouldDialPeer;
-    /**
-     * Checks if the peer is dialable based on the following conditions:
-     * 1. If the peer is a bootstrap peer, it is only dialable if the number of current bootstrap connections is less than the max allowed.
-     * 2. If the peer is not a bootstrap peer
-     */
-    private isPeerDialableBasedOnBootstrapStatus;
-    private dispatchDiscoveryEvent;
-    /**
-     * Fetches the tag names for a given peer
-     */
-    private getTagNamesForPeer;
-    isPeerOnSameShard(peerId: PeerId): Promise<boolean>;
-    isPeerOnPubsubTopic(peerId: PeerId, pubsubTopic: string): Promise<boolean>;
-    private getPeerShardInfo;
-    private startNetworkStatusListener;
-    private stopNetworkStatusListener;
-    private setP2PNetworkConnected;
-    private setP2PNetworkDisconnected;
-    private dispatchWakuConnectionEvent;
+    isTopicConfigured(pubsubTopic: PubsubTopic): boolean;
+    hasShardInfo(peerId: PeerId): Promise<boolean>;
+    isPeerOnTopic(peerId: PeerId, pubsubTopic: string): Promise<boolean>;
 }
 export {};