@peerbit/stream-interface 1.0.10 → 2.0.0

package/lib/esm/index.d.ts

@@ -1,10 +1,19 @@
 import { PublicSignKey } from "@peerbit/crypto";
 import type { PeerId } from "@libp2p/interface/peer-id";
+import { DataMessage, Message } from "./messages.js";
 export interface PeerEvents {
     "peer:reachable": CustomEvent<PublicSignKey>;
     "peer:unreachable": CustomEvent<PublicSignKey>;
 }
+export interface MessageEvents {
+    message: CustomEvent<Message>;
+}
+export interface StreamEvents extends PeerEvents, MessageEvents {
+    data: CustomEvent<DataMessage>;
+}
 export * from "./messages.js";
 export interface WaitForPeer {
-    waitFor(peer: PeerId | PublicSignKey): Promise<void>;
+    waitFor(peer: PeerId | PublicSignKey, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
 }

package/lib/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAgBA,cAAc,eAAe,CAAC"}

package/lib/esm/messages.d.ts

@@ -1,133 +1,141 @@
 import { Uint8ArrayList } from "uint8arraylist";
 import { PublicSignKey, SignatureWithKey } from "@peerbit/crypto";
+import type { PeerId } from "@libp2p/interface/peer-id";
+export declare const ID_LENGTH = 32;
 /**
  * The default msgID implementation
  * Child class can override this.
  */
 export declare const getMsgId: (msg: Uint8ArrayList | Uint8Array) => Promise<string>;
-export declare const ID_LENGTH = 32;
-export declare class MessageHeader {
+export declare abstract class DeliveryMode {
+}
+/**
+ * when you just want to deliver at paths, but does not expect acknowledgement
+ */
+export declare class SilentDelivery extends DeliveryMode {
+    to: string[];
+    redundancy: number;
+    constructor(properties: {
+        to: (string | PublicSignKey | PeerId)[] | Set<string>;
+        redundancy: number;
+    });
+}
+/**
+ * Deliver and expect acknowledgement
+ */
+export declare class AcknowledgeDelivery extends DeliveryMode {
+    to: string[];
+    redundancy: number;
+    constructor(properties: {
+        to: (string | PublicSignKey | PeerId)[] | Set<string>;
+        redundancy: number;
+    });
+}
+/**
+ * Deliver but with greedy fanout so that we eventually reach our target
+ * Expect acknowledgement
+ */
+export declare class SeekDelivery extends DeliveryMode {
+    to?: string[];
+    redundancy: number;
+    constructor(properties: {
+        to?: (string | PublicSignKey | PeerId)[] | Set<string>;
+        redundancy: number;
+    });
+}
+export declare class TracedDelivery extends DeliveryMode {
+    trace: string[];
+    constructor(trace: string[]);
+}
+export declare class AnyWhere extends DeliveryMode {
+    constructor();
+}
+export declare class Signatures {
+    signatures: SignatureWithKey[];
+    constructor(signatures?: SignatureWithKey[]);
+    equals(other: Signatures): boolean;
+    get publicKeys(): PublicSignKey[];
+}
+declare abstract class PeerInfo {
+}
+export declare class MultiAddrinfo extends PeerInfo {
+    multiaddrs: string[];
+    constructor(multiaddrs: string[]);
+}
+export declare class MessageHeader<T extends DeliveryMode = DeliveryMode> {
     private _id;
     private _timestamp;
     private _expires;
-    constructor(properties?: {
+    private _origin?;
+    mode: T;
+    signatures: Signatures | undefined;
+    constructor(properties: {
+        origin?: MultiAddrinfo;
         expires?: bigint;
         id?: Uint8Array;
+        mode: T;
     });
     get id(): Uint8Array;
     get expires(): bigint;
     get timetamp(): bigint;
+    get origin(): MultiAddrinfo | undefined;
     equals(other: MessageHeader): boolean;
     verify(): boolean;
 }
-export declare class Signatures {
-    signatures: SignatureWithKey[];
-    constructor(signatures?: SignatureWithKey[]);
-    equals(other: Signatures): boolean;
-    get publicKeys(): PublicSignKey[];
-    hashPublicKeys(): Promise<string>;
-}
-export declare abstract class Message {
-    static from(bytes: Uint8ArrayList): DataMessage | Hello | Goodbye | PingPong;
+export declare abstract class Message<T extends DeliveryMode = DeliveryMode> {
+    static from(bytes: Uint8ArrayList): DataMessage<SilentDelivery | AcknowledgeDelivery | SeekDelivery | AnyWhere> | ACK | Hello | Goodbye;
+    abstract get header(): MessageHeader<T>;
+    sign(signer: (bytes: Uint8Array) => Promise<SignatureWithKey>): Promise<this>;
     abstract bytes(): Uint8ArrayList | Uint8Array;
-    abstract equals(other: Message): boolean;
-    abstract verify(expectSignatures: boolean): Promise<boolean>;
+    _verified: boolean;
+    verify(expectSignatures: boolean): Promise<boolean>;
 }
-export declare class DataMessage extends Message {
+export declare class DataMessage<T extends SilentDelivery | SeekDelivery | AcknowledgeDelivery | AnyWhere = SilentDelivery | SeekDelivery | AcknowledgeDelivery | AnyWhere> extends Message<T> {
     private _header;
-    private _to;
-    private _signatures;
-    private _data;
+    private _data?;
     constructor(properties: {
-        header?: MessageHeader;
-        to?: string[];
-        data: Uint8Array;
-        signatures?: Signatures;
+        header: MessageHeader<T>;
+        data?: Uint8Array;
     });
     get id(): Uint8Array;
-    get signatures(): Signatures;
-    get header(): MessageHeader;
-    get to(): string[];
-    set to(to: string[]);
-    get sender(): PublicSignKey;
-    get data(): Uint8Array;
-    _serialized: Uint8Array | undefined;
-    get serialized(): Uint8Array | undefined;
-    _prefix: Uint8Array | undefined;
-    get prefix(): Uint8Array;
-    createPrefix(): Promise<Uint8Array>;
-    getSuffix(iteration: number): Uint8Array;
-    sign(sign: (bytes: Uint8Array) => Promise<SignatureWithKey>): Promise<this>;
-    verify(expectSignatures: boolean): Promise<boolean>;
+    get header(): MessageHeader<T>;
+    get data(): Uint8Array | undefined;
     /** Manually ser/der for performance gains */
     bytes(): Uint8Array;
     static from(bytes: Uint8ArrayList): DataMessage;
-    equals(other: Message): boolean;
 }
-export declare class NetworkInfo {
-    pingLatencies: number[];
-    constructor(pingLatencies: number[]);
+export declare class ACK extends Message {
+    header: MessageHeader<TracedDelivery>;
+    messageIdToAcknowledge: Uint8Array;
+    seenCounter: number;
+    constructor(properties: {
+        messageIdToAcknowledge: Uint8Array;
+        seenCounter: number;
+        header: MessageHeader<TracedDelivery>;
+    });
+    get id(): Uint8Array;
+    bytes(): Uint8Array;
+    static from(bytes: Uint8ArrayList): ACK;
 }
 export declare class Hello extends Message {
     header: MessageHeader;
-    multiaddrs: string[];
-    data?: Uint8Array;
-    networkInfo: NetworkInfo;
-    signatures: Signatures;
-    constructor(options?: {
-        multiaddrs?: string[];
-        data?: Uint8Array;
+    joined: string[];
+    constructor(properties: {
+        joined: string[];
     });
-    get sender(): PublicSignKey;
+    get id(): Uint8Array;
     bytes(): Uint8Array;
     static from(bytes: Uint8ArrayList): Hello;
-    _prefix: Uint8Array | undefined;
-    get prefix(): Uint8Array;
-    createPrefix(): Promise<Uint8Array>;
-    getSuffix(iteration: number): Uint8Array[];
-    sign(sign: (bytes: Uint8Array) => Promise<SignatureWithKey>): Promise<this>;
-    verify(expectSignatures: boolean): Promise<boolean>;
-    equals(other: Message): boolean;
 }
 export declare class Goodbye extends Message {
-    header: MessageHeader;
-    early?: boolean;
-    data?: Uint8Array;
-    signatures: Signatures;
-    constructor(properties?: {
-        header?: MessageHeader;
-        data?: Uint8Array;
-        early?: boolean;
+    header: MessageHeader<SilentDelivery>;
+    leaving: string[];
+    constructor(properties: {
+        leaving: string[];
+        header: MessageHeader<SilentDelivery>;
     });
-    get sender(): PublicSignKey;
+    get id(): Uint8Array;
     bytes(): Uint8Array;
     static from(bytes: Uint8ArrayList): Goodbye;
-    _prefix: Uint8Array | undefined;
-    get prefix(): Uint8Array;
-    createPrefix(): Promise<Uint8Array>;
-    getSuffix(iteration: number): Uint8Array;
-    sign(sign: (bytes: Uint8Array) => Promise<SignatureWithKey>): Promise<this>;
-    verify(expectSignatures: boolean): Promise<boolean>;
-    equals(other: Message): boolean;
-}
-export declare abstract class PingPong extends Message {
-    static from(bytes: Uint8ArrayList): PingPong;
-    bytes(): Uint8ArrayList | Uint8Array;
-    verify(_expectSignatures: boolean): Promise<boolean>;
-    abstract get pingBytes(): Uint8Array;
-}
-export declare class Ping extends PingPong {
-    pingBytes: Uint8Array;
-    constructor();
-    equals(other: Message): boolean;
-}
-export declare class Pong extends PingPong {
-    pingBytes: Uint8Array;
-    constructor(pingBytes: Uint8Array);
-    equals(other: Message): boolean;
-}
-export declare class Connections {
-    connections: [string, string][];
-    constructor(connections: [string, string][]);
-    equals(other: Connections): boolean;
 }
+export {};