@peerbit/stream 1.0.19 → 2.0.1

package/lib/esm/index.d.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from "@libp2p/interface/events";
+import { TypedEventEmitter } from "@libp2p/interface";
 import Queue from "p-queue";
 import type { PeerId } from "@libp2p/interface/peer-id";
 import type { Connection } from "@libp2p/interface/connection";
@@ -6,19 +6,21 @@ import type { Pushable } from "it-pushable";
 import type { Stream } from "@libp2p/interface/connection";
 import { Uint8ArrayList } from "uint8arraylist";
 import { Routes } from "./routes.js";
-import { PeerMap } from "./peer-map.js";
 import type { IncomingStreamData, Registrar } from "@libp2p/interface-internal/registrar";
 import type { AddressManager } from "@libp2p/interface-internal/address-manager";
 import type { ConnectionManager } from "@libp2p/interface-internal/connection-manager";
 import { PeerStore } from "@libp2p/interface/peer-store";
 import { waitFor } from "@peerbit/time";
 import { PublicSignKey, SignatureWithKey } from "@peerbit/crypto";
+import { Components } from "libp2p/components";
+import type { TypedEventTarget } from "@libp2p/interface";
 export type SignaturePolicy = "StictSign" | "StrictNoSign";
 import { logger } from "./logger.js";
-import { Cache } from "@peerbit/cache";
 export { logger };
+import { Cache } from "@peerbit/cache";
 import type { Libp2pEvents } from "@libp2p/interface";
-import { PeerEvents, Message as Message, Goodbye, Hello, DataMessage, PingPong, WaitForPeer } from "@peerbit/stream-interface";
+import { Message as Message, DataMessage, WaitForPeer, ACK, SeekDelivery, AcknowledgeDelivery, SilentDelivery, Goodbye, StreamEvents, AnyWhere } from "@peerbit/stream-interface";
+import { MultiAddrinfo } from "@peerbit/stream-interface";
 export interface PeerStreamsInit {
     peerId: PeerId;
     publicKey: PublicSignKey;
@@ -30,10 +32,16 @@ export interface PeerStreamEvents {
     "stream:outbound": CustomEvent<never>;
     close: CustomEvent<never>;
 }
+type WithTo = {
+    to?: (string | PublicSignKey | PeerId)[] | Set<string>;
+};
+type WithMode = {
+    mode?: SilentDelivery | SeekDelivery | AcknowledgeDelivery | AnyWhere;
+};
 /**
  * Thin wrapper around a peer's inbound / outbound pubsub streams
  */
-export declare class PeerStreams extends EventEmitter<PeerStreamEvents> {
+export declare class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
     counter: number;
     readonly peerId: PeerId;
     readonly publicKey: PublicSignKey;
@@ -41,7 +49,7 @@ export declare class PeerStreams extends EventEmitter<PeerStreamEvents> {
     /**
      * Write stream - it's preferable to use the write method
      */
-    outboundStream?: Pushable<Uint8ArrayList>;
+    outboundStream?: Pushable<Uint8Array>;
     /**
      * Read stream
      */
@@ -59,12 +67,9 @@ export declare class PeerStreams extends EventEmitter<PeerStreamEvents> {
      */
     private readonly inboundAbortController;
     private closed;
-    pingJob: {
-        resolve: () => void;
-        abort: () => void;
-    };
-    pingLatency: number | undefined;
     connId: string;
+    seekedOnce: boolean;
+    private usedBandWidthTracker;
     constructor(init: PeerStreamsInit);
     /**
      * Do we have a connection to read from?
@@ -74,6 +79,7 @@ export declare class PeerStreams extends EventEmitter<PeerStreamEvents> {
      * Do we have a connection to write on?
      */
     get isWritable(): boolean;
+    get usedBandwidth(): number;
     /**
      * Send a message to this peer.
      * Throws if there is no `stream` to write to available.
@@ -87,47 +93,55 @@ export declare class PeerStreams extends EventEmitter<PeerStreamEvents> {
     /**
      * Attach a raw outbound stream and setup a write stream
      */
-    attachOutboundStream(stream: Stream): Promise<Pushable<Uint8ArrayList, void, unknown>>;
+    attachOutboundStream(stream: Stream): Promise<Pushable<Uint8Array, void, unknown>>;
     /**
      * Closes the open connection to peer
      */
     close(): Promise<void>;
 }
-export interface MessageEvents {
-    message: CustomEvent<Message>;
-}
-export interface StreamEvents extends PeerEvents, MessageEvents {
-    data: CustomEvent<DataMessage>;
-}
-export type ConnectionManagerOptions = {
-    autoDial?: boolean;
-    retryDelay?: number;
+type DialerOptions = {
+    retryDelay: number;
+};
+type PrunerOptions = {
+    interval: number;
+    bandwidth?: number;
+    maxBuffer?: number;
+    connectionTimeout: number;
+};
+type ConnectionManagerOptions = {
+    minConnections: number;
+    maxConnections: number;
+    dialer?: DialerOptions;
+    pruner?: PrunerOptions;
 };
 export type DirectStreamOptions = {
     canRelayMessage?: boolean;
-    emitSelf?: boolean;
     messageProcessingConcurrency?: number;
     maxInboundStreams?: number;
     maxOutboundStreams?: number;
     signaturePolicy?: SignaturePolicy;
-    pingInterval?: number | null;
-    connectionManager?: ConnectionManagerOptions;
+    connectionManager?: ConnectionManagerArguments;
+    routeSeekInterval?: number;
+    seekTimeout?: number;
 };
-import { Components } from "libp2p/components";
 export interface DirectStreamComponents extends Components {
     peerId: PeerId;
     addressManager: AddressManager;
     registrar: Registrar;
     connectionManager: ConnectionManager;
     peerStore: PeerStore;
-    events: EventEmitter<Libp2pEvents>;
+    events: TypedEventTarget<Libp2pEvents>;
 }
+export type ConnectionManagerArguments = (Partial<Pick<ConnectionManagerOptions, "minConnections">> & Partial<Pick<ConnectionManagerOptions, "maxConnections">> & {
+    pruner?: Partial<PrunerOptions> | false;
+} & {
+    dialer?: Partial<DialerOptions> | false;
+}) | false;
 export declare abstract class DirectStream<Events extends {
     [s: string]: any;
-} = StreamEvents> extends EventEmitter<Events> implements WaitForPeer {
+} = StreamEvents> extends TypedEventEmitter<Events> implements WaitForPeer {
     readonly components: DirectStreamComponents;
     peerId: PeerId;
-    peerIdStr: string;
     publicKey: PublicSignKey;
     publicKeyHash: string;
     sign: (bytes: Uint8Array) => Promise<SignatureWithKey>;
@@ -135,9 +149,8 @@ export declare abstract class DirectStream<Events extends {
     /**
      * Map of peer streams
      */
-    peers: PeerMap<PeerStreams>;
+    peers: Map<string, PeerStreams>;
     peerKeyHashToPublicKey: Map<string, PublicSignKey>;
-    peerIdToPublicKey: Map<string, PublicSignKey>;
     routes: Routes;
     /**
      * If router can relay received messages, even if not subscribed
@@ -147,22 +160,21 @@ export declare abstract class DirectStream<Events extends {
      * if publish should emit to self, if subscribed
      */
     signaturePolicy: SignaturePolicy;
-    emitSelf: boolean;
     queue: Queue;
     multicodecs: string[];
-    seenCache: Cache;
-    earlyGoodbyes: Map<string, Goodbye>;
-    helloMap: Map<string, Map<string, Hello>>;
-    multiaddrsMap: Map<string, string[]>;
+    seenCache: Cache<number>;
     private _registrarTopologyIds;
     private readonly maxInboundStreams?;
     private readonly maxOutboundStreams?;
-    private topology;
-    private pingJobPromise;
-    private pingJob;
-    private pingInterval;
-    private connectionManagerOptions;
-    private recentDials;
+    connectionManagerOptions: ConnectionManagerOptions;
+    private recentDials?;
+    private healthChecks;
+    private pruneConnectionsTimeout;
+    private prunedConnectionsCache?;
+    routeSeekInterval: number;
+    seekTimeout: number;
+    closeController: AbortController;
+    private _ackCallbacks;
     constructor(components: DirectStreamComponents, multicodecs: string[], options?: DirectStreamOptions);
     start(): Promise<void>;
     /**
@@ -177,15 +189,13 @@ export declare abstract class DirectStream<Events extends {
     /**
      * Registrar notifies an established connection with protocol
      */
-    onPeerConnected(peerId: PeerId, conn: Connection, properties?: {
-        fromExisting?: boolean;
-    }): Promise<any[] | undefined>;
-    private addRouteConnection;
-    removeRouteConnection(from: PublicSignKey, to: PublicSignKey): void;
+    onPeerConnected(peerId: PeerId, connection: Connection): Promise<void>;
     /**
      * Registrar notifies a closing connection with pubsub protocol
      */
     protected onPeerDisconnected(peerId: PeerId, conn?: Connection): Promise<void>;
+    removeRouteConnection(hash: string, neigbour: boolean): void;
+    addRouteConnection(from: string, neighbour: string, target: PublicSignKey, distance: number, session: number, pending?: boolean): void;
     /**
      * invoked when a new peer becomes reachable
      * @param publicKeyHash
@@ -195,7 +205,7 @@ export declare abstract class DirectStream<Events extends {
      * invoked when a new peer becomes unreachable
      * @param publicKeyHash
      */
-    onPeerUnreachable(publicKey: PublicSignKey): void;
+    onPeerUnreachable(hash: string): void;
     /**
      * Notifies the router that a peer has been connected
      */
@@ -207,39 +217,40 @@ export declare abstract class DirectStream<Events extends {
     /**
      * Responsible for processing each RPC message received by other peers.
      */
-    processMessages(peerId: PeerId, stream: AsyncIterable<Uint8ArrayList>, peerStreams: PeerStreams): Promise<void>;
+    processMessages(peerId: PublicSignKey, stream: AsyncIterable<Uint8ArrayList>, peerStreams: PeerStreams): Promise<void>;
     /**
      * Handles an rpc request from a peer
      */
-    processRpc(from: PeerId, peerStreams: PeerStreams, message: Uint8ArrayList): Promise<boolean>;
+    processRpc(from: PublicSignKey, peerStreams: PeerStreams, message: Uint8ArrayList): Promise<boolean>;
+    private modifySeenCache;
     /**
      * Handles a message from a peer
      */
-    processMessage(from: PeerId, peerStream: PeerStreams, msg: Uint8ArrayList): Promise<void>;
-    onDataMessage(from: PeerId, peerStream: PeerStreams, message: DataMessage): Promise<boolean>;
-    onHello(from: PeerId, peerStream: PeerStreams, message: Hello): Promise<boolean>;
-    onGoodbye(from: PeerId, peerStream: PeerStreams, message: Goodbye): Promise<boolean>;
-    onPing(from: PeerId, peerStream: PeerStreams, message: PingPong): Promise<void>;
-    ping(stream: PeerStreams): Promise<number | undefined>;
-    /**
-     * Whether to accept a message from a peer
-     * Override to create a graylist
-     */
-    acceptFrom(id: PeerId): boolean;
-    createMessage(data: Uint8Array | Uint8ArrayList, options?: {
-        to?: (string | PublicSignKey | PeerId)[] | Set<string>;
-    }): Promise<DataMessage>;
+    processMessage(from: PublicSignKey, peerStream: PeerStreams, msg: Uint8ArrayList): Promise<void>;
+    shouldIgnore(message: DataMessage, seenBefore: number): boolean;
+    onDataMessage(from: PublicSignKey, peerStream: PeerStreams, message: DataMessage, seenBefore: number): Promise<boolean | undefined>;
+    maybeVerifyMessage(message: DataMessage): Promise<boolean>;
+    acknowledgeMessage(peerStream: PeerStreams, message: DataMessage, seenBefore: number): Promise<void>;
+    private _onDataMessage;
+    onAck(publicKey: PublicSignKey, peerStream: PeerStreams, messageBytes: Uint8ArrayList | Uint8Array, message: ACK): Promise<false | undefined>;
+    onGoodBye(publicKey: PublicSignKey, peerStream: PeerStreams, messageBytes: Uint8ArrayList | Uint8Array, message: Goodbye): Promise<false | undefined>;
+    createMessage(data: Uint8Array | Uint8ArrayList | undefined, options: WithTo | WithMode): Promise<DataMessage<SilentDelivery | SeekDelivery | AcknowledgeDelivery | AnyWhere>>;
     /**
      * Publishes messages to all peers
      */
-    publish(data: Uint8Array | Uint8ArrayList, options?: {
-        to?: (string | PublicSignKey | PeerId)[] | Set<string>;
-    }): Promise<Uint8Array>;
-    hello(data?: Uint8Array): Promise<void>;
-    relayMessage(from: PeerId, message: Message, to?: PeerStreams[] | PeerMap<PeerStreams>): Promise<void>;
-    publishMessage(from: PeerId, message: Message, to?: PeerStreams[] | PeerMap<PeerStreams>, relayed?: boolean): Promise<void>;
-    maybeConnectDirectly(path: string[]): Promise<void>;
-    waitFor(peer: PeerId | PublicSignKey): Promise<void>;
+    publish(data: Uint8Array | Uint8ArrayList | undefined, options?: WithMode | WithTo): Promise<Uint8Array>;
+    relayMessage(from: PublicSignKey, message: Message, to?: PeerStreams[] | Map<string, PeerStreams>): Promise<void>;
+    private createDeliveryPromise;
+    publishMessage(from: PublicSignKey, message: Message, to?: PeerStreams[] | Map<string, PeerStreams>, relayed?: boolean): Promise<void>;
+    maybeConnectDirectly(toHash: string, origin: MultiAddrinfo): Promise<void>;
+    waitFor(peer: PeerId | PublicSignKey, options?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    get pending(): boolean;
+    lastQueuedBytes: number;
+    maybePruneConnections(): Promise<void>;
+    pruneConnections(): Promise<void>;
+    getQueuedBytes(): number;
 }
 export declare const waitForPeers: (...libs: {
     waitFor: (peer: PeerId | PublicSignKey) => Promise<void>;