@node-lightning/wire
Version:
Lightning Network Wire Protocol
85 lines (84 loc) • 3.42 kB
TypeScript
/// <reference types="node" />
import { ILogger } from "@node-lightning/logger";
import { IWireMessage } from "../messages/IWireMessage";
import { Peer } from "../Peer";
import { GossipFilter } from "../gossip/GossipFilter";
import { SyncState } from "../gossip/GossipManager";
import { GossipPeer } from "./GossipPeer";
import { IGossipFilterChainClient } from "../gossip/IGossipFilterChainClient";
import { IGossipRelay } from "./GossipRelay";
import { DnsPeerQuery } from "../gossip/DnsPeerQuery";
import { BitField, OutPoint, ShortChannelId } from "@node-lightning/core";
export declare class PeerGossipState {
gossipRelay: boolean;
}
/**
* GossipManager provides is a facade for many parts of gossip. It
* orchestrates for validating, storing, and emitting
* routing gossip traffic obtained by peers.
*/
export declare class GossipManager {
readonly gossipFilter: GossipFilter;
readonly chainClient?: IGossipFilterChainClient;
blockHeight: number;
started: boolean;
syncState: SyncState;
isSynchronizing: boolean;
gossipRelay: IGossipRelay;
dnsPeerQuery: DnsPeerQuery;
protected logger: ILogger;
protected peers: Map<string, GossipPeer>;
constructor(logger: ILogger, gossipFilter: GossipFilter, chainClient?: IGossipFilterChainClient);
/**
* Starts the gossip manager. This method will load information
* from the gossip store, determine when the last information
* was obtained, validate the existing messages (to see if any
* channels have closed), and finally emit all messages that
* exist in the system.
*/
start(): Promise<void>;
onPeerReady(peer: Peer): void;
/**
* Handles when a peer closes
* @param gossipPeer
*/
onPeerClose(peer: Peer): void;
/**
* TODO: Refactor this out of here. It should be part of the PeerManager!
* Uses a dns seed to discover and add peers to be managed by the GossipManager.
*/
bootstrapPeers(ls: Buffer, localFeatures: BitField<any>, localChains: Buffer[], logger: ILogger, dnsSeed: string): Promise<void>;
/**
* TODO: Refactor this. It should be event based, not imperative.
* Removes the channel from storage by the gossip manager. This
* will likely be called by a chain-monitoring service.
*/
removeChannel(scid: ShortChannelId): Promise<void>;
/**
* TODO: Refactor this. It should be event based, not imperative.
* Removes the channel from storage by the gossip manager. This will
* likely be called by a chain-monitoring service.
* @param outpoint
*/
removeChannelByOutpoint(outpoint: OutPoint): Promise<void>;
/**
* TODO: Refactor this. It should be event based, not imperative.
* Retrieves the valid chan_ann, chan_update, node_ann messages
* while making sure to not send duplicate node_ann messages.
*
* @remarks
* For now we are going to buffer messages into memory. We could
* return a stream and yield messages as they are streamed from
* the gossip_store.
*/
allMessages(): AsyncGenerator<IWireMessage, void, unknown>;
findPeer(peer: Peer): GossipPeer;
handlePeerMessage(peer: Peer, msg: IWireMessage): Promise<void>;
/**
* Synchronize the peer using the peer's synchronization mechanism.
* @param peer
*/
private _syncPeer;
private _restoreState;
private _validateUtxos;
}