@typeberry/lib 0.5.1 → 0.5.2-03e1aed

package/packages/jam/jamnp-s/protocol/test-utils.d.ts

@@ -0,0 +1,47 @@
+import type { BytesBlob } from "#@typeberry/bytes";
+import type { OK } from "#@typeberry/utils";
+import { type StreamHandler, type StreamId, type StreamKind, type StreamKindOf, type StreamMessageSender } from "./stream.js";
+export declare class TestStreamSender implements StreamMessageSender {
+    readonly streamId: StreamId;
+    readonly onSend: (data: BytesBlob) => void;
+    readonly onClose: () => void;
+    constructor(streamId: StreamId, { onSend, onClose, }: {
+        onSend: (data: BytesBlob) => void;
+        onClose?: () => void;
+    });
+    bufferAndSend(data: BytesBlob): boolean;
+    close(): void;
+}
+export declare class TestMessageHandler {
+    private readonly newStream;
+    private readonly persistentStreams;
+    private readonly registeredHandlers;
+    readonly openStreams: Map<StreamId, [StreamHandler, StreamMessageSender]>;
+    constructor(newStream: (id: StreamId, kind: StreamKind, onClose: () => void) => StreamMessageSender);
+    registerHandlers(...handlers: StreamHandler[]): void;
+    streamReceive(id: StreamId, data: BytesBlob): void;
+    withStreamOfKind<THandler extends StreamHandler>(streamKind: StreamKindOf<THandler>, work: (handler: THandler, sender: StreamMessageSender) => OK): void;
+    withNewStream<THandler extends StreamHandler>(streamKind: StreamKindOf<THandler>, work: (handler: THandler, sender: StreamMessageSender) => OK): void;
+    /**
+     * Open a receiving stream.
+     *
+     * This is meant to simulate newly incoming stream that is opened by the other party.
+     */
+    receiveStreamOpen(id: StreamId, kind: StreamKind): void;
+    /**
+     * Close a receiving stream.
+     *
+     * This is called when the other end wants to terminate the stream cleanly.
+     * Indicates that there is no more messages being sent on the stream.
+     *
+     * Otherwise if we close the stream on our end, it will be removed
+     * regardless of this method being called after `SIMULATED_STREAM_TIMEOUT_MS`.
+     */
+    receiveStreamClose(id: StreamId): void;
+    private createStreamIfNotPresent;
+}
+export declare function testClientServer(): {
+    client: TestMessageHandler;
+    server: TestMessageHandler;
+};
+//# sourceMappingURL=test-utils.d.ts.map

package/packages/jam/jamnp-s/protocol/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/protocol/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,mBAAmB,EAEzB,MAAM,aAAa,CAAC;AAErB,qBAAa,gBAAiB,YAAW,mBAAmB;aAKxC,QAAQ,EAAE,QAAQ;IAJpC,SAAgB,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;IAClD,SAAgB,OAAO,EAAE,MAAM,IAAI,CAAC;gBAGlB,QAAQ,EAAE,QAAQ,EAClC,EACE,MAAM,EACN,OAAkB,GACnB,EAAE;QACD,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;QAClC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;KACtB;IAMH,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IAOvC,KAAK,IAAI,IAAI;CAKd;AAKD,qBAAa,kBAAkB;IAO3B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAN5B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoE;IACtG,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA6C;IAEhF,SAAgB,WAAW,EAAE,GAAG,CAAC,QAAQ,EAAE,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAAC,CAAa;gBAG1E,SAAS,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,IAAI,KAAK,mBAAmB;IAG1G,gBAAgB,CAAC,GAAG,QAAQ,EAAE,aAAa,EAAE;IAM7C,aAAa,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IASlD,gBAAgB,CAAC,QAAQ,SAAS,aAAa,EAC7C,UAAU,EAAE,YAAY,CAAC,QAAQ,CAAC,EAClC,IAAI,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,mBAAmB,KAAK,EAAE,GAC3D,IAAI;IASP,aAAa,CAAC,QAAQ,SAAS,aAAa,EAC1C,UAAU,EAAE,YAAY,CAAC,QAAQ,CAAC,EAClC,IAAI,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,mBAAmB,KAAK,EAAE,GAC3D,IAAI;IAiBP;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU;IAMhD;;;;;;;;OAQG;IACH,kBAAkB,CAAC,EAAE,EAAE,QAAQ;IAS/B,OAAO,CAAC,wBAAwB;CAsBjC;AAED,wBAAgB,gBAAgB;;;EA6B/B"}

package/packages/jam/jamnp-s/protocol/test-utils.js

@@ -0,0 +1,142 @@
+import { tryAsStreamId, } from "./stream.js";
+export class TestStreamSender {
+    streamId;
+    onSend;
+    onClose;
+    constructor(streamId, { onSend, onClose = () => { }, }) {
+        this.streamId = streamId;
+        this.onSend = onSend;
+        this.onClose = onClose;
+    }
+    bufferAndSend(data) {
+        setImmediate(() => {
+            this.onSend(data);
+        });
+        return true;
+    }
+    close() {
+        setImmediate(() => {
+            this.onClose();
+        });
+    }
+}
+/** We keep it low for the tests to run fast. */
+const SIMULATED_STREAM_TIMEOUT_MS = 50;
+export class TestMessageHandler {
+    newStream;
+    persistentStreams = new Map();
+    registeredHandlers = new Map();
+    openStreams = new Map();
+    constructor(newStream) {
+        this.newStream = newStream;
+    }
+    registerHandlers(...handlers) {
+        for (const handler of handlers) {
+            this.registeredHandlers.set(handler.kind, handler);
+        }
+    }
+    streamReceive(id, data) {
+        const receiver = this.openStreams.get(id);
+        if (receiver === undefined) {
+            throw new Error(`Received data on a non-existent stream: ${id}. Data: ${data}.`);
+        }
+        receiver[0].onStreamMessage(receiver[1], data);
+    }
+    withStreamOfKind(streamKind, work) {
+        const handler = this.persistentStreams.get(streamKind);
+        if (handler === undefined) {
+            throw new Error(`Expected persistent stream not open! ${streamKind}`);
+        }
+        work(handler[0], handler[1]);
+    }
+    withNewStream(streamKind, work) {
+        const getRandomStreamId = () => tryAsStreamId(Math.floor(Math.random() * 2 ** 16));
+        const streams = this.openStreams;
+        const streamId = (function findStreamId() {
+            const s = getRandomStreamId();
+            if (!streams.has(s)) {
+                return s;
+            }
+            return findStreamId();
+        })();
+        // since we are picking a non-existing stream id, there is no way of
+        // conflicting here, so the `[handler, stream]` will be fresh.
+        const [handler, stream] = this.createStreamIfNotPresent(streamId, streamKind);
+        work(handler, stream);
+    }
+    /**
+     * Open a receiving stream.
+     *
+     * This is meant to simulate newly incoming stream that is opened by the other party.
+     */
+    receiveStreamOpen(id, kind) {
+        // NOTE this method can be called again even if the stream exists
+        // and it should be a no-op.
+        this.createStreamIfNotPresent(id, kind);
+    }
+    /**
+     * Close a receiving stream.
+     *
+     * This is called when the other end wants to terminate the stream cleanly.
+     * Indicates that there is no more messages being sent on the stream.
+     *
+     * Otherwise if we close the stream on our end, it will be removed
+     * regardless of this method being called after `SIMULATED_STREAM_TIMEOUT_MS`.
+     */
+    receiveStreamClose(id) {
+        const stream = this.openStreams.get(id);
+        if (stream === undefined) {
+            return;
+        }
+        this.openStreams.delete(id);
+        stream[0].onClose(id, false);
+    }
+    createStreamIfNotPresent(streamId, kind) {
+        const existing = this.openStreams.get(streamId);
+        if (existing !== undefined) {
+            // stream is already open, so we don't do anything.
+            return existing;
+        }
+        const handler = this.registeredHandlers.get(kind);
+        if (handler === undefined) {
+            throw new Error(`Attempting to open stream with unregistered handler: ${kind}`);
+        }
+        const stream = this.newStream(streamId, kind, () => {
+            setTimeout(() => {
+                this.openStreams.delete(streamId);
+                handler.onClose(streamId, false);
+            }, SIMULATED_STREAM_TIMEOUT_MS);
+        });
+        this.openStreams.set(streamId, [handler, stream]);
+        return [handler, stream];
+    }
+}
+export function testClientServer() {
+    const newStream = (other, id, onClose) => {
+        return new TestStreamSender(id, {
+            onSend: (data) => other.streamReceive(id, data),
+            onClose: () => {
+                // close the stream on our end
+                onClose();
+                // notify the other end about stream closing.
+                other.receiveStreamClose(id);
+            },
+        });
+    };
+    const client = new TestMessageHandler((id, kind, onClose) => {
+        setImmediate(() => {
+            server.receiveStreamOpen(id, kind);
+        });
+        return newStream(server, id, onClose);
+    });
+    const server = new TestMessageHandler((id, kind, onClose) => {
+        setImmediate(() => {
+            client.receiveStreamOpen(id, kind);
+        });
+        return newStream(client, id, onClose);
+    });
+    return {
+        client,
+        server,
+    };
+}

package/packages/jam/jamnp-s/protocol/up-0-block-announcement.d.ts

@@ -0,0 +1,102 @@
+import { Header, type HeaderHash, type TimeSlot } from "#@typeberry/block";
+import type { BytesBlob } from "#@typeberry/bytes";
+import { type CodecRecord } from "#@typeberry/codec";
+import type { ChainSpec } from "#@typeberry/config";
+import { WithDebug } from "#@typeberry/utils";
+import { type StreamHandler, type StreamId, type StreamMessageSender } from "./stream.js";
+/**
+ * JAMNP-S UP 0 stream.
+ *
+ * Block annoucements.
+ *
+ * https://github.com/zdave-parity/jam-np/blob/main/simple.md#up-0-block-announcement
+ */
+export declare const STREAM_KIND: 0 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+export declare class HashAndSlot extends WithDebug {
+    readonly hash: HeaderHash;
+    readonly slot: TimeSlot;
+    static Codec: import("@typeberry/codec").Descriptor<HashAndSlot, import("@typeberry/codec").ViewOf<HashAndSlot, {
+        hash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+        slot: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">, import("@typeberry/bytes").Bytes<4>>;
+    }>>;
+    static create({ hash, slot }: CodecRecord<HashAndSlot>): HashAndSlot;
+    private constructor();
+}
+/**
+ * Both sides should begin by sending a handshake message containing all known leaves.
+ */
+export declare class Handshake {
+    /** Last finalized block. */
+    readonly final: HashAndSlot;
+    /** Descendants of the last finalized block with no known children. */
+    readonly leafs: HashAndSlot[];
+    static Codec: import("@typeberry/codec").Descriptor<Handshake, import("@typeberry/codec").ViewOf<Handshake, {
+        final: import("@typeberry/codec").Descriptor<HashAndSlot, import("@typeberry/codec").ViewOf<HashAndSlot, {
+            hash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+            slot: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">, import("@typeberry/bytes").Bytes<4>>;
+        }>>;
+        leafs: import("@typeberry/codec").Descriptor<HashAndSlot[], import("@typeberry/codec").SequenceView<HashAndSlot, import("@typeberry/codec").ViewOf<HashAndSlot, {
+            hash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+            slot: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">, import("@typeberry/bytes").Bytes<4>>;
+        }>>>;
+    }>>;
+    static create({ final, leafs }: CodecRecord<Handshake>): Handshake;
+    private constructor();
+}
+/**
+ * An announcement should be sent on the stream whenever a new,
+ * valid, block is produced or received.
+ */
+export declare class Announcement extends WithDebug {
+    /** New (previously unknown) descendant of `final`. */
+    readonly header: Header;
+    /** Final block and slot. */
+    readonly final: HashAndSlot;
+    static Codec: import("@typeberry/codec").Descriptor<Announcement, import("@typeberry/codec").ViewOf<Announcement, {
+        header: import("@typeberry/codec").Descriptor<Header & CodecRecord<Header>, import("@typeberry/codec").ViewOf<Header & CodecRecord<Header>, {
+            parentHeaderHash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+            priorStateRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"StateRootHash">, import("@typeberry/bytes").Bytes<32>>;
+            extrinsicHash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"ExtrinsicHash">, import("@typeberry/bytes").Bytes<32>>;
+            timeSlotIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">, import("@typeberry/bytes").Bytes<4>>;
+            epochMarker: import("@typeberry/codec").Descriptor<import("@typeberry/block").EpochMarker | null, import("@typeberry/codec").ViewOf<import("@typeberry/block").EpochMarker, {
+                entropy: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"EntropyHash">, import("@typeberry/bytes").Bytes<32>>;
+                ticketsEntropy: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"EntropyHash">, import("@typeberry/bytes").Bytes<32>>;
+                validators: import("@typeberry/codec").Descriptor<readonly import("@typeberry/block").ValidatorKeys[] & import("@typeberry/utils").WithOpaque<"ValidatorsCount">, import("@typeberry/codec").SequenceView<import("@typeberry/block").ValidatorKeys, import("@typeberry/codec").ViewOf<import("@typeberry/block").ValidatorKeys, {
+                    bandersnatch: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"BandersnatchKey">, import("@typeberry/bytes").Bytes<32>>;
+                    ed25519: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"Ed25519Key">, import("@typeberry/bytes").Bytes<32>>;
+                }>>>;
+            }> | null>;
+            ticketsMarker: import("@typeberry/codec").Descriptor<import("@typeberry/block").TicketsMarker | null, import("@typeberry/codec").ViewOf<import("@typeberry/block").TicketsMarker, {
+                tickets: import("@typeberry/codec").Descriptor<readonly import("@typeberry/block/tickets.js").Ticket[] & import("@typeberry/utils").WithOpaque<"EpochLength">, import("@typeberry/codec").SequenceView<import("@typeberry/block/tickets.js").Ticket, import("@typeberry/codec").ViewOf<import("@typeberry/block/tickets.js").Ticket, {
+                    id: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
+                    attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U8>;
+                }>>>;
+            }> | null>;
+            bandersnatchBlockAuthorIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"ValidatorIndex[u16]">, import("@typeberry/bytes").Bytes<2>>;
+            entropySource: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<96> & import("@typeberry/utils").WithOpaque<"BandersnatchVrfSignature">, import("@typeberry/bytes").Bytes<96>>;
+            offendersMarker: import("@typeberry/codec").Descriptor<(import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"Ed25519Key">)[], import("@typeberry/codec").SequenceView<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"Ed25519Key">, import("@typeberry/bytes").Bytes<32>>>;
+            seal: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<96> & import("@typeberry/utils").WithOpaque<"BandersnatchVrfSignature">, import("@typeberry/bytes").Bytes<96>>;
+        }>>;
+        final: import("@typeberry/codec").Descriptor<HashAndSlot, import("@typeberry/codec").ViewOf<HashAndSlot, {
+            hash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+            slot: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">, import("@typeberry/bytes").Bytes<4>>;
+        }>>;
+    }>>;
+    static create({ header, final }: CodecRecord<Announcement>): Announcement;
+    private constructor();
+}
+export declare class Handler implements StreamHandler<typeof STREAM_KIND> {
+    private readonly spec;
+    private readonly getHandshake;
+    private readonly onAnnouncement;
+    private readonly onHandshake;
+    kind: 0 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+    private readonly handshakes;
+    private readonly pendingHandshakes;
+    constructor(spec: ChainSpec, getHandshake: () => Handshake, onAnnouncement: (sender: StreamId, ann: Announcement) => void, onHandshake: (sender: StreamId, handshake: Handshake) => void);
+    onStreamMessage(sender: StreamMessageSender, message: BytesBlob): void;
+    onClose(streamId: StreamId): void;
+    sendHandshake(sender: StreamMessageSender): void;
+    sendAnnouncement(sender: StreamMessageSender, annoucement: Announcement): void;
+}
+//# sourceMappingURL=up-0-block-announcement.d.ts.map

package/packages/jam/jamnp-s/protocol/up-0-block-announcement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"up-0-block-announcement.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/protocol/up-0-block-announcement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,KAAK,WAAW,EAA2B,MAAM,kBAAkB,CAAC;AAC7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGnD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,mBAAmB,EAAmB,MAAM,aAAa,CAAC;AAE3G;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,6DAAqB,CAAC;AAE9C,qBAAa,WAAY,SAAQ,SAAS;aAWtB,IAAI,EAAE,UAAU;aAChB,IAAI,EAAE,QAAQ;IAXhC,MAAM,CAAC,KAAK;;;QAGT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,WAAW,CAAC,WAAW,CAAC;IAItD,OAAO;CAMR;AAED;;GAEG;AACH,qBAAa,SAAS;IAWlB,4BAA4B;aACZ,KAAK,EAAE,WAAW;IAClC,sEAAsE;aACtD,KAAK,EAAE,WAAW,EAAE;IAbtC,MAAM,CAAC,KAAK;;;;;;;;;QAGT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,WAAW,CAAC,SAAS,CAAC;IAItD,OAAO;CAMR;AAED;;;GAGG;AACH,qBAAa,YAAa,SAAQ,SAAS;IAWvC,sDAAsD;aACtC,MAAM,EAAE,MAAM;IAC9B,4BAA4B;aACZ,KAAK,EAAE,WAAW;IAbpC,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAGT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,WAAW,CAAC,YAAY,CAAC;IAI1D,OAAO;CAQR;AAID,qBAAa,OAAQ,YAAW,aAAa,CAAC,OAAO,WAAW,CAAC;IAO7D,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAT9B,IAAI,8DAAe;IAEnB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAuC;IAClE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqC;gBAGpD,IAAI,EAAE,SAAS,EACf,YAAY,EAAE,MAAM,SAAS,EAC7B,cAAc,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,YAAY,KAAK,IAAI,EAC7D,WAAW,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,KAAK,IAAI;IAGhF,eAAe,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI;IAqBtE,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAKjC,aAAa,CAAC,MAAM,EAAE,mBAAmB;IAWzC,gBAAgB,CAAC,MAAM,EAAE,mBAAmB,EAAE,WAAW,EAAE,YAAY;CAUxE"}

package/packages/jam/jamnp-s/protocol/up-0-block-announcement.js

@@ -0,0 +1,136 @@
+import { Header } from "#@typeberry/block";
+import { codec, Decoder, Encoder } from "#@typeberry/codec";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { Logger } from "#@typeberry/logger";
+import { WithDebug } from "#@typeberry/utils";
+import { tryAsStreamKind } from "./stream.js";
+/**
+ * JAMNP-S UP 0 stream.
+ *
+ * Block annoucements.
+ *
+ * https://github.com/zdave-parity/jam-np/blob/main/simple.md#up-0-block-announcement
+ */
+export const STREAM_KIND = tryAsStreamKind(0);
+export class HashAndSlot extends WithDebug {
+    hash;
+    slot;
+    static Codec = codec.Class(HashAndSlot, {
+        hash: codec.bytes(HASH_SIZE).asOpaque(),
+        slot: codec.u32.asOpaque(),
+    });
+    static create({ hash, slot }) {
+        return new HashAndSlot(hash, slot);
+    }
+    constructor(hash, slot) {
+        super();
+        this.hash = hash;
+        this.slot = slot;
+    }
+}
+/**
+ * Both sides should begin by sending a handshake message containing all known leaves.
+ */
+export class Handshake {
+    final;
+    leafs;
+    static Codec = codec.Class(Handshake, {
+        final: HashAndSlot.Codec,
+        leafs: codec.sequenceVarLen(HashAndSlot.Codec),
+    });
+    static create({ final, leafs }) {
+        return new Handshake(final, leafs);
+    }
+    constructor(
+    /** Last finalized block. */
+    final, 
+    /** Descendants of the last finalized block with no known children. */
+    leafs) {
+        this.final = final;
+        this.leafs = leafs;
+    }
+}
+/**
+ * An announcement should be sent on the stream whenever a new,
+ * valid, block is produced or received.
+ */
+export class Announcement extends WithDebug {
+    header;
+    final;
+    static Codec = codec.Class(Announcement, {
+        header: Header.Codec,
+        final: HashAndSlot.Codec,
+    });
+    static create({ header, final }) {
+        return new Announcement(header, final);
+    }
+    constructor(
+    /** New (previously unknown) descendant of `final`. */
+    header, 
+    /** Final block and slot. */
+    final) {
+        super();
+        this.header = header;
+        this.final = final;
+    }
+}
+const logger = Logger.new(import.meta.filename, "protocol/up-0");
+export class Handler {
+    spec;
+    getHandshake;
+    onAnnouncement;
+    onHandshake;
+    kind = STREAM_KIND;
+    handshakes = new Map();
+    pendingHandshakes = new Map();
+    constructor(spec, getHandshake, onAnnouncement, onHandshake) {
+        this.spec = spec;
+        this.getHandshake = getHandshake;
+        this.onAnnouncement = onAnnouncement;
+        this.onHandshake = onHandshake;
+    }
+    onStreamMessage(sender, message) {
+        const { streamId } = sender;
+        // we expect a handshake first
+        if (!this.handshakes.has(streamId)) {
+            const handshake = Decoder.decodeObject(Handshake.Codec, message);
+            this.handshakes.set(streamId, handshake);
+            // we didn't initiate this handshake, so let's respond
+            if (!this.pendingHandshakes.delete(streamId)) {
+                logger.log `[${streamId}] <-- responding with a handshake.`;
+                sender.bufferAndSend(Encoder.encodeObject(Handshake.Codec, this.getHandshake()));
+            }
+            this.onHandshake(streamId, handshake);
+            return;
+        }
+        // it's just an announcement
+        const annoucement = Decoder.decodeObject(Announcement.Codec, message, this.spec);
+        logger.log `[${streamId}] --> got blocks announcement: ${annoucement.final}`;
+        this.onAnnouncement(streamId, annoucement);
+    }
+    onClose(streamId) {
+        this.handshakes.delete(streamId);
+        this.pendingHandshakes.delete(streamId);
+    }
+    sendHandshake(sender) {
+        const { streamId } = sender;
+        if (this.handshakes.has(streamId) || this.pendingHandshakes.has(streamId)) {
+            return;
+        }
+        const handshake = this.getHandshake();
+        logger.trace `[${streamId}] <-- sending handshake`;
+        this.pendingHandshakes.set(sender.streamId, true);
+        sender.bufferAndSend(Encoder.encodeObject(Handshake.Codec, handshake));
+    }
+    sendAnnouncement(sender, annoucement) {
+        const { streamId } = sender;
+        // only send announcement if we've handshaken
+        if (this.handshakes.has(streamId)) {
+            logger.trace `[${streamId}] <-- sending block announcement: ${annoucement.final}`;
+            sender.bufferAndSend(Encoder.encodeObject(Announcement.Codec, annoucement, this.spec));
+        }
+        else {
+            logger.warn `[${streamId}] <-- no handshake yet, skipping announcement.`;
+        }
+    }
+}

package/packages/jam/jamnp-s/stream-manager.d.ts

@@ -0,0 +1,49 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import { type Peer, type PeerId, type Stream, type StreamErrorCallback } from "#@typeberry/networking";
+import type { OK } from "#@typeberry/utils";
+import { type StreamHandler, type StreamId, type StreamKindOf, type StreamMessageSender } from "./protocol/stream.js";
+export declare class StreamManager {
+    /** A map of handlers for incoming stream kinds. */
+    private readonly incomingHandlers;
+    /** A map of handlers for outgoing stream kinds. */
+    private readonly outgoingHandlers;
+    /** A collection of open streams, peers and their handlers. */
+    private readonly streams;
+    /** Promises for stream background tasks (reading data). */
+    private readonly backgroundTasks;
+    /** Add supported incoming handlers. */
+    registerIncomingHandlers(...handlers: StreamHandler[]): void;
+    /** Add supported outgoing handlers. */
+    registerOutgoingHandlers(...handlers: StreamHandler[]): void;
+    /** Get peer associated with a stream. */
+    getPeer(streamId: StreamId): Peer | null;
+    /** Wait until all of the streams are closed. */
+    waitForFinish(): Promise<void>;
+    /** Attempt to find an already open stream of given kind. */
+    withStreamOfKind<THandler extends StreamHandler>(peerId: PeerId, kind: StreamKindOf<THandler>, work: (handler: THandler, sender: QuicStreamSender) => OK): void;
+    /** Open a new stream of given kind, with the peer given. */
+    withNewStream<THandler extends StreamHandler>(peer: Peer, kind: StreamKindOf<THandler>, work: (handler: THandler, sender: QuicStreamSender) => OK): void;
+    /** Handle an incoming stream. */
+    onIncomingStream(peer: Peer, stream: Stream): Promise<void>;
+    private registerStream;
+}
+declare class QuicStreamSender implements StreamMessageSender {
+    readonly streamId: StreamId;
+    private readonly internal;
+    private readonly onError;
+    private bufferedLength;
+    private bufferedData;
+    private currentWriterPromise;
+    constructor(streamId: StreamId, internal: Stream, onError: StreamErrorCallback);
+    /** Send given piece of data to the other end. */
+    bufferAndSend(data: BytesBlob, prefixWithLength?: boolean): boolean;
+    close(): void;
+    /**
+     * Wait for the data to finish writing.
+     *
+     * Usually should not be used, but may be useful for tests sometimes.
+     */
+    flush(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=stream-manager.d.ts.map

package/packages/jam/jamnp-s/stream-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-manager.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/jamnp-s/stream-manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAGL,KAAK,IAAI,EACT,KAAK,MAAM,EACX,KAAK,MAAM,EACX,KAAK,mBAAmB,EAEzB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,QAAQ,EAEb,KAAK,YAAY,EACjB,KAAK,mBAAmB,EAGzB,MAAM,sBAAsB,CAAC;AAK9B,qBAAa,aAAa;IACxB,mDAAmD;IACnD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA6C;IAC9E,mDAAmD;IACnD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA6C;IAE9E,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAOV;IAEd,2DAA2D;IAC3D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA2C;IAE3E,uCAAuC;IACvC,wBAAwB,CAAC,GAAG,QAAQ,EAAE,aAAa,EAAE;IAMrD,uCAAuC;IACvC,wBAAwB,CAAC,GAAG,QAAQ,EAAE,aAAa,EAAE;IAMrD,yCAAyC;IACzC,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI;IAIxC,gDAAgD;IAC1C,aAAa;IAMnB,4DAA4D;IAC5D,gBAAgB,CAAC,QAAQ,SAAS,aAAa,EAC7C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC,EAC5B,IAAI,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,gBAAgB,KAAK,EAAE,GACxD,IAAI;IAWP,4DAA4D;IAC5D,aAAa,CAAC,QAAQ,SAAS,aAAa,EAC1C,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC,EAC5B,IAAI,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,gBAAgB,KAAK,EAAE,GACxD,IAAI;IAcP,iCAAiC;IAC3B,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM;IA8BjD,OAAO,CAAC,cAAc;CA6CvB;AA4CD,cAAM,gBAAiB,YAAW,mBAAmB;aAMjC,QAAQ,EAAE,QAAQ;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,YAAY,CAAiD;IACrE,OAAO,CAAC,oBAAoB,CAA8B;gBAGxC,QAAQ,EAAE,QAAQ,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,mBAAmB;IAG/C,iDAAiD;IACjD,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,gBAAgB,UAAO,GAAG,OAAO;IAsChE,KAAK,IAAI,IAAI;IAab;;;;OAIG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAGvB"}