@typeberry/lib 0.5.1 → 0.5.2-03e1aed

package/packages/jam/jam-host-calls/utils.d.ts

@@ -0,0 +1,12 @@
+import { type ServiceId } from "#@typeberry/block";
+import { type U32, type U64 } from "#@typeberry/numbers";
+import type { HostCallRegisters } from "#@typeberry/pvm-host-calls";
+export declare const SERVICE_ID_BYTES = 4;
+export declare const CURRENT_SERVICE_ID: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">;
+export declare function getServiceIdOrCurrent(regNumber: number, regs: HostCallRegisters, currentServiceId: ServiceId): ServiceId | null;
+export declare function getServiceId(serviceId: U64): ServiceId | null;
+export declare function writeServiceIdAsLeBytes(serviceId: ServiceId, destination: Uint8Array): void;
+/** Clamp a U64 to the maximum value of a 32-bit unsigned integer. */
+export declare function clampU64ToU32(value: U64): U32;
+export declare function emptyRegistersBuffer(): Uint8Array;
+//# sourceMappingURL=utils.d.ts.map

package/packages/jam/jam-host-calls/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/jam-host-calls/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAkB,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAsB,KAAK,GAAG,EAAE,KAAK,GAAG,EAA8B,MAAM,oBAAoB,CAAC;AACxG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAMnE,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,kBAAkB,4HAA8B,CAAC;AAE9D,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,iBAAiB,EACvB,gBAAgB,EAAE,SAAS,GAC1B,SAAS,GAAG,IAAI,CAOlB;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,GAAG,GAAG,SAAS,GAAG,IAAI,CAQ7D;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,QAGpF;AAED,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAE7C;AAED,wBAAgB,oBAAoB,IAAI,UAAU,CAEjD"}

package/packages/jam/jam-host-calls/utils.js

@@ -0,0 +1,33 @@
+import { tryAsServiceId } from "#@typeberry/block";
+import { tryAsU32, tryAsU64, u32AsLeBytes, u64IntoParts } from "#@typeberry/numbers";
+import { NO_OF_REGISTERS, REGISTER_BYTE_SIZE } from "#@typeberry/pvm-interface";
+import { check, safeAllocUint8Array } from "#@typeberry/utils";
+const MAX_U32 = tryAsU32(2 ** 32 - 1);
+const MAX_U32_BIG_INT = tryAsU64(MAX_U32);
+export const SERVICE_ID_BYTES = 4;
+export const CURRENT_SERVICE_ID = tryAsServiceId(2 ** 32 - 1);
+export function getServiceIdOrCurrent(regNumber, regs, currentServiceId) {
+    const regValue = regs.get(regNumber);
+    if (regValue === 2n ** 64n - 1n) {
+        return currentServiceId;
+    }
+    return getServiceId(regValue);
+}
+export function getServiceId(serviceId) {
+    const { lower, upper } = u64IntoParts(serviceId);
+    if (upper === 0) {
+        return tryAsServiceId(lower);
+    }
+    return null;
+}
+export function writeServiceIdAsLeBytes(serviceId, destination) {
+    check `${destination.length >= SERVICE_ID_BYTES} Not enough space in the destination.`;
+    destination.set(u32AsLeBytes(serviceId));
+}
+/** Clamp a U64 to the maximum value of a 32-bit unsigned integer. */
+export function clampU64ToU32(value) {
+    return value > MAX_U32_BIG_INT ? MAX_U32 : tryAsU32(Number(value));
+}
+export function emptyRegistersBuffer() {
+    return safeAllocUint8Array(NO_OF_REGISTERS * REGISTER_BYTE_SIZE);
+}

package/packages/jam/jamnp-s/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./network.js";
+export * from "./peers.js";
+export * from "./protocol/index.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/jam/jamnp-s/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/jamnp-s/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC"}

package/packages/jam/jamnp-s/index.js

@@ -0,0 +1,3 @@
+export * from "./network.js";
+export * from "./peers.js";
+export * from "./protocol/index.js";

package/packages/jam/jamnp-s/network.d.ts

@@ -0,0 +1,18 @@
+import type { BlockView, HeaderHash } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import type { ed25519 } from "#@typeberry/crypto";
+import type { BlocksDb } from "#@typeberry/database";
+import { type Network, type Peer } from "#@typeberry/networking";
+import { type Bootnode } from "./peers.js";
+import { StreamManager } from "./stream-manager.js";
+import { SyncTask } from "./tasks/sync.js";
+export declare function setup(bind: {
+    host: string;
+    port: number;
+}, genesisHash: HeaderHash, key: ed25519.Ed25519Pair, bootnodes: Bootnode[], spec: ChainSpec, blocks: BlocksDb, onNewBlocks: (blocks: BlockView[]) => Promise<void>): Promise<{
+    network: import("@typeberry/networking/quic-network.js").QuicNetwork;
+    syncTask: SyncTask;
+    streamManager: StreamManager;
+}>;
+export declare function setupPeerListeners(syncTask: SyncTask, network: Network<Peer>, streamManager: StreamManager): void;
+//# sourceMappingURL=network.d.ts.map

package/packages/jam/jamnp-s/network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/jamnp-s/network.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,IAAI,EAAQ,MAAM,uBAAuB,CAAC;AAEtE,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,YAAY,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAK3C,wBAAsB,KAAK,CACzB,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACpC,WAAW,EAAE,UAAU,EACvB,GAAG,EAAE,OAAO,CAAC,WAAW,EACxB,SAAS,EAAE,QAAQ,EAAE,EACrB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,QAAQ,EAEhB,WAAW,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC;;;;GAuCpD;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,aAAa,QAmB1G"}

package/packages/jam/jamnp-s/network.js

@@ -0,0 +1,60 @@
+import { setTimeout } from "node:timers/promises";
+import { Blake2b } from "#@typeberry/hash";
+import { Logger } from "#@typeberry/logger";
+import { Quic } from "#@typeberry/networking";
+import { OK } from "#@typeberry/utils";
+import { Connections } from "./peers.js";
+import { StreamManager } from "./stream-manager.js";
+import { SyncTask } from "./tasks/sync.js";
+import { handleAsyncErrors } from "./utils.js";
+const logger = Logger.new(import.meta.filename, "jamnps");
+export async function setup(bind, genesisHash, key, bootnodes, spec, blocks, 
+// TODO [ToDr] handle back pressure?
+onNewBlocks) {
+    const blake2b = await Blake2b.createHasher();
+    const genesisFirstBytes = genesisHash.toString().substring(2, 10);
+    const network = await Quic.setup({
+        host: bind.host,
+        port: bind.port,
+        key,
+        protocols: [`jamnp-s/0/${genesisFirstBytes}`],
+    });
+    const connections = new Connections(network);
+    connections.addPersistentRetry(bootnodes);
+    const streamManager = new StreamManager();
+    // start the networking tasks
+    const syncTask = SyncTask.start(spec, blake2b, streamManager, connections, blocks, onNewBlocks);
+    setImmediate(async () => {
+        while (network.isRunning) {
+            await setTimeout(3000);
+            syncTask.maintainSync();
+        }
+    });
+    // TODO [ToDr] This design is a bit weird,
+    // however we don't want the sync task to handle that
+    // (since only parts of it are sync-related), but that
+    // should be a general behavior of the JAMNP-S.
+    // For now it's simply an external function that's exposed
+    // for tests as well.
+    setupPeerListeners(syncTask, network, streamManager);
+    return {
+        network,
+        syncTask,
+        streamManager,
+    };
+}
+export function setupPeerListeners(syncTask, network, streamManager) {
+    network.peers.onPeerConnected((peer) => {
+        // whenever the peer wants to open a stream with us, let's handle that.
+        peer.addOnIncomingStream((stream) => {
+            handleAsyncErrors(() => streamManager.onIncomingStream(peer, stream), (e) => {
+                logger.error `[${peer.id}:${stream.streamId}]🚰  Stream error: ${e}. Disconnecting peer.`;
+                peer.disconnect();
+            });
+            return OK;
+        });
+        // open UP0 stream with each new peer after the connection is fully estabilished.
+        syncTask.openUp0(peer);
+        return OK;
+    });
+}

package/packages/jam/jamnp-s/peers.d.ts

@@ -0,0 +1,54 @@
+import type { Bootnode } from "#@typeberry/config";
+import type { Network, Peer, PeerAddress, PeerId } from "#@typeberry/networking";
+export { Bootnode } from "#@typeberry/config";
+type PeerInfo = {
+    peerId: PeerId;
+    address: PeerAddress;
+    /** If `Peer` is set, it means it's connected. */
+    peerRef: Peer | null;
+    lastConnected: number;
+    maxRetries: number;
+    currentRetry: number;
+    backgroundTask: AbortController;
+    aux: Map<AuxData<unknown>["id"], unknown>;
+};
+export type AuxData<T> = {
+    id: symbol;
+    unused?: T;
+};
+/**
+ * Manage current and past connections to peers.
+ *
+ * Note this collection is wider in scope than just `Peers`.
+ * We not only track info about currently connected peers, but we also
+ * have a record of peers that we were connected to earlier, to allow
+ * tracking their behavior (score) or reconnecting in the future.
+ */
+export declare class Connections {
+    private readonly network;
+    /** Info about peers that are currently connected or where connected in the past. */
+    private readonly peerInfo;
+    constructor(network: Network<Peer>);
+    /** Attach some external typed data to given peer. */
+    setAuxData<T>(peer: PeerId, id: AuxData<T>, data: T): void;
+    /** Read some externally-attached data about the peer. */
+    getAuxData<T>(peer: PeerId, id: AuxData<T>): T | undefined;
+    /** Read, act and update the aux data of some peer. */
+    withAuxData<T>(peer: PeerId, id: AuxData<T>, onAux: (aux: T | undefined) => T): void;
+    /** Return the number of currently connected peers. */
+    getPeerCount(): number;
+    /** Return peers that are currently connected. */
+    getConnectedPeers(): Generator<PeerInfo, void, unknown>;
+    /** Register metadata about newly connected peer. */
+    private updatePeer;
+    /** Attempt to scheduled a reconnect for a peer that just got disconnected. */
+    private scheduleReconnect;
+    /**
+     * Add a list of peers that we should keep a consistent connection.
+     *
+     * That means we are going to be dialing them indefinitely (with
+     * an exponential back-off though if they are unavailable).
+     */
+    addPersistentRetry(bootnodes: Bootnode[]): void;
+}
+//# sourceMappingURL=peers.d.ts.map

package/packages/jam/jamnp-s/peers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peers.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/jamnp-s/peers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGhF,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,WAAW,CAAC;IAErB,iDAAiD;IACjD,OAAO,EAAE,IAAI,GAAG,IAAI,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IAErB,cAAc,EAAE,eAAe,CAAC;IAEhC,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;CAC3C,CAAC;AAEF,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,CAAC,CAAC;CACZ,CAAC;AAWF;;;;;;;GAOG;AACH,qBAAa,WAAW;IAIV,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,oFAAoF;IACpF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;gBAEhC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC;IAWnD,qDAAqD;IACrD,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;IAInD,yDAAyD;IACzD,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS;IAI1D,sDAAsD;IACtD,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC;IAM7E,sDAAsD;IACtD,YAAY;IAIZ,iDAAiD;IAChD,iBAAiB;IAQlB,oDAAoD;IACpD,OAAO,CAAC,UAAU;IAyBlB,8EAA8E;YAChE,iBAAiB;IA0D/B;;;;;OAKG;IACH,kBAAkB,CAAC,SAAS,EAAE,QAAQ,EAAE;CAezC"}

package/packages/jam/jamnp-s/peers.js

@@ -0,0 +1,160 @@
+import { setTimeout } from "node:timers/promises";
+import { Logger } from "#@typeberry/logger";
+import { OK } from "#@typeberry/utils";
+export { Bootnode } from "#@typeberry/config";
+const logger = Logger.new(import.meta.filename, "net:conn");
+/** Number of attempts to re-connect to non-bootnode peers. */
+const MAX_RETRIES = 5;
+/** Minimal reconnection time in seconds. */
+const MIN_RECONNECT_TIMEOUT_S = 3;
+/** Maximal reconnection time in seconds. */
+const MAX_RECONNECT_TIMEOUT_S = 3_600;
+/**
+ * Manage current and past connections to peers.
+ *
+ * Note this collection is wider in scope than just `Peers`.
+ * We not only track info about currently connected peers, but we also
+ * have a record of peers that we were connected to earlier, to allow
+ * tracking their behavior (score) or reconnecting in the future.
+ */
+export class Connections {
+    network;
+    /** Info about peers that are currently connected or where connected in the past. */
+    peerInfo = new Map();
+    constructor(network) {
+        this.network = network;
+        network.peers.onPeerConnected((peer) => {
+            this.updatePeer(peer);
+            return OK;
+        });
+        network.peers.onPeerDisconnected((peer) => {
+            this.scheduleReconnect(peer.id, true);
+            return OK;
+        });
+    }
+    /** Attach some external typed data to given peer. */
+    setAuxData(peer, id, data) {
+        this.peerInfo.get(peer)?.aux.set(id.id, data);
+    }
+    /** Read some externally-attached data about the peer. */
+    getAuxData(peer, id) {
+        return this.peerInfo.get(peer)?.aux.get(id.id);
+    }
+    /** Read, act and update the aux data of some peer. */
+    withAuxData(peer, id, onAux) {
+        const auxData = this.getAuxData(peer, id);
+        const newAuxData = onAux(auxData);
+        this.setAuxData(peer, id, newAuxData);
+    }
+    /** Return the number of currently connected peers. */
+    getPeerCount() {
+        return this.network.peers.noOfConnectedPeers();
+    }
+    /** Return peers that are currently connected. */
+    *getConnectedPeers() {
+        for (const peer of this.peerInfo.values()) {
+            if (peer.peerRef !== null) {
+                yield peer;
+            }
+        }
+    }
+    /** Register metadata about newly connected peer. */
+    updatePeer(peer) {
+        // let's check if we know something about that peer already.
+        const meta = this.peerInfo.get(peer.id);
+        if (meta === undefined) {
+            this.peerInfo.set(peer.id, {
+                peerId: peer.id,
+                address: peer.address,
+                peerRef: peer,
+                lastConnected: Date.now(),
+                maxRetries: MAX_RETRIES,
+                currentRetry: 0,
+                backgroundTask: new AbortController(),
+                aux: new Map(),
+            });
+            return;
+        }
+        // set the peer as connected just now
+        meta.peerRef = peer;
+        meta.lastConnected = Date.now();
+        meta.currentRetry = Math.floor(meta.currentRetry / 2);
+        // update it's address?
+        meta.address = peer.address;
+    }
+    /** Attempt to scheduled a reconnect for a peer that just got disconnected. */
+    async scheduleReconnect(id, markAsDisconnected = false) {
+        const meta = this.peerInfo.get(id);
+        // just ignore peers we don't know about.
+        if (meta === undefined) {
+            return;
+        }
+        if (markAsDisconnected) {
+            // mark the peer as disconnected
+            meta.peerRef = null;
+            meta.backgroundTask = new AbortController();
+        }
+        // abort signal
+        const signal = meta.backgroundTask.signal;
+        // now keep trying to connect
+        for (;;) {
+            // increase the reconnection counter
+            meta.currentRetry += 1;
+            if (meta.currentRetry > meta.maxRetries) {
+                // reached max retries for a peer, remove it from tracking.
+                this.peerInfo.delete(id);
+                logger.log `[${id}] max retries reached. Removing peer.`;
+                return;
+            }
+            // else attempt to connect to a node a bit later.
+            const timeoutSeconds = Math.min(MIN_RECONNECT_TIMEOUT_S * meta.currentRetry * meta.currentRetry, MAX_RECONNECT_TIMEOUT_S);
+            try {
+                await setTimeout(timeoutSeconds * 1000, undefined, { signal });
+            }
+            catch {
+                // ignoring errors here, since that's expected. We just wanted to
+                // abort the task.
+                return;
+            }
+            // seems we are already connected, bailing
+            if (meta.peerRef !== null) {
+                return;
+            }
+            // attempt to connect to the peer
+            try {
+                logger.trace `[${id}] Attempting to connect to peer at ${meta.address.host}:${meta.address.port}.`;
+                await this.network.dial(meta.address, { signal, verifyName: meta.peerId });
+                return;
+            }
+            catch (e) {
+                if (signal.aborted) {
+                    return;
+                }
+                // failing to connect, will retry.
+                logger.trace `[${id}] Failure reason: ${e}`;
+                logger.trace `[${id}] attempt failed. Will retry (${meta.currentRetry}/${meta.maxRetries})`;
+            }
+        }
+    }
+    /**
+     * Add a list of peers that we should keep a consistent connection.
+     *
+     * That means we are going to be dialing them indefinitely (with
+     * an exponential back-off though if they are unavailable).
+     */
+    addPersistentRetry(bootnodes) {
+        for (const node of bootnodes) {
+            this.peerInfo.set(node.id, {
+                peerId: node.id,
+                address: { host: node.host, port: node.port },
+                maxRetries: 2 ** 32,
+                currentRetry: 0,
+                peerRef: null,
+                lastConnected: 0,
+                backgroundTask: new AbortController(),
+                aux: new Map(),
+            });
+            this.scheduleReconnect(node.id);
+        }
+    }
+}

package/packages/jam/jamnp-s/protocol/ce-128-block-request.d.ts

@@ -0,0 +1,68 @@
+import { type BlockView, type HeaderHash } from "#@typeberry/block";
+import { BytesBlob } from "#@typeberry/bytes";
+import { type CodecRecord } from "#@typeberry/codec";
+import type { ChainSpec } from "#@typeberry/config";
+import type { BlocksDb } from "#@typeberry/database";
+import { type U32 } from "#@typeberry/numbers";
+import { Result, WithDebug } from "#@typeberry/utils";
+import { type StreamHandler, type StreamId, type StreamMessageSender } from "./stream.js";
+/**
+ * JAM-SNP CE-128 stream.
+ *
+ * https://github.com/zdave-parity/jam-np/blob/main/simple.md#ce-128-block-request
+ */
+export declare const STREAM_KIND: 128 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+export declare enum Direction {
+    /**
+     * Ascending exclusive.
+     *
+     * The sequence of blocks in the response should start with a child of the given block, followed by a grandchild, and so on.
+     */
+    AscExcl = 0,
+    /**
+     * Descending inclusive.
+     *
+     * The sequence of blocks in the response should start with the given block, followed by its parent, grandparent, and so on.
+     */
+    DescIncl = 1
+}
+export declare class BlockRequest extends WithDebug {
+    readonly headerHash: HeaderHash;
+    readonly direction: Direction;
+    readonly maxBlocks: U32;
+    static Codec: import("@typeberry/codec").Descriptor<BlockRequest, import("@typeberry/codec").ViewOf<BlockRequest, {
+        headerHash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+        direction: import("@typeberry/codec").Descriptor<Direction, import("@typeberry/numbers").U8>;
+        maxBlocks: import("@typeberry/codec").Descriptor<U32, import("@typeberry/bytes").Bytes<4>>;
+    }>>;
+    static create({ headerHash, direction, maxBlocks }: CodecRecord<BlockRequest>): BlockRequest;
+    private constructor();
+}
+export declare class ServerHandler implements StreamHandler<typeof STREAM_KIND> {
+    private readonly chainSpec;
+    private readonly getBlockSequence;
+    kind: 128 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+    constructor(chainSpec: ChainSpec, getBlockSequence: (streamId: StreamId, hash: HeaderHash, direction: Direction, maxBlocks: U32) => BlockView[]);
+    onStreamMessage(sender: StreamMessageSender, message: BytesBlob): void;
+    onClose(): void;
+}
+export declare class ClientHandler implements StreamHandler<typeof STREAM_KIND> {
+    private readonly chainSpec;
+    kind: 128 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+    private promiseResolvers;
+    private promiseRejectors;
+    constructor(chainSpec: ChainSpec);
+    onStreamMessage(sender: StreamMessageSender, message: BytesBlob): void;
+    onClose(streamId: StreamId): void;
+    requestBlockSequence(sender: StreamMessageSender, headerHash: HeaderHash, direction: Direction, maxBlocks: U32): Promise<BlockView[]>;
+}
+/** Error when querying blocks from DB. */
+export declare enum BlockSequenceError {
+    /** We don't have the start block in our db. */
+    NoStartBlock = 0,
+    /** When looking up the start block from the tip of the chain it wasn't found. */
+    BlockOnFork = 1
+}
+/** Handle request for block sequence by looking them up in the db. */
+export declare function handleGetBlockSequence(chainSpec: ChainSpec, blocks: BlocksDb, startHash: HeaderHash, direction: Direction, limit: U32): Result<BlockView[], BlockSequenceError>;
+//# sourceMappingURL=ce-128-block-request.d.ts.map

package/packages/jam/jamnp-s/protocol/ce-128-block-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ce-128-block-request.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/protocol/ce-128-block-request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,WAAW,EAA2B,MAAM,kBAAkB,CAAC;AAC7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,EAAW,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,mBAAmB,EAAmB,MAAM,aAAa,CAAC;AAE3G;;;;GAIG;AAEH,eAAO,MAAM,WAAW,+DAAuB,CAAC;AAEhD,oBAAY,SAAS;IACnB;;;;OAIG;IACH,OAAO,IAAI;IACX;;;;OAIG;IACH,QAAQ,IAAI;CACb;AAED,qBAAa,YAAa,SAAQ,SAAS;aAwBvB,UAAU,EAAE,UAAU;aACtB,SAAS,EAAE,SAAS;aACpB,SAAS,EAAE,GAAG;IAzBhC,MAAM,CAAC,KAAK;;;;QAgBT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,WAAW,CAAC,YAAY,CAAC;IAI7E,OAAO;CAOR;AAID,qBAAa,aAAc,YAAW,aAAa,CAAC,OAAO,WAAW,CAAC;IAInE,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAJnC,IAAI,gEAAe;gBAGA,SAAS,EAAE,SAAS,EACpB,gBAAgB,EAAE,CACjC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,GAAG,KACX,SAAS,EAAE;IAGlB,eAAe,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI;IAYtE,OAAO;CACR;AAED,qBAAa,aAAc,YAAW,aAAa,CAAC,OAAO,WAAW,CAAC;IAMzD,OAAO,CAAC,QAAQ,CAAC,SAAS;IALtC,IAAI,gEAAe;IAEnB,OAAO,CAAC,gBAAgB,CAA0D;IAClF,OAAO,CAAC,gBAAgB,CAAwD;gBAEnD,SAAS,EAAE,SAAS;IAEjD,eAAe,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI;IAUtE,OAAO,CAAC,QAAQ,EAAE,QAAQ;IAOpB,oBAAoB,CACxB,MAAM,EAAE,mBAAmB,EAC3B,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,GAAG,GACb,OAAO,CAAC,SAAS,EAAE,CAAC;CAexB;AAED,0CAA0C;AAC1C,oBAAY,kBAAkB;IAC5B,+CAA+C;IAC/C,YAAY,IAAI;IAChB,iFAAiF;IACjF,WAAW,IAAI;CAChB;AAED,sEAAsE;AACtE,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,QAAQ,EAChB,SAAS,EAAE,UAAU,EACrB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,GAAG,GACT,MAAM,CAAC,SAAS,EAAE,EAAE,kBAAkB,CAAC,CAmEzC"}

package/packages/jam/jamnp-s/protocol/ce-128-block-request.js

@@ -0,0 +1,172 @@
+import { Block } from "#@typeberry/block";
+import { BytesBlob } from "#@typeberry/bytes";
+import { codec, Decoder, Encoder } from "#@typeberry/codec";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { Logger } from "#@typeberry/logger";
+import { tryAsU8 } from "#@typeberry/numbers";
+import { Result, WithDebug } from "#@typeberry/utils";
+import { tryAsStreamKind } from "./stream.js";
+/**
+ * JAM-SNP CE-128 stream.
+ *
+ * https://github.com/zdave-parity/jam-np/blob/main/simple.md#ce-128-block-request
+ */
+export const STREAM_KIND = tryAsStreamKind(128);
+export var Direction;
+(function (Direction) {
+    /**
+     * Ascending exclusive.
+     *
+     * The sequence of blocks in the response should start with a child of the given block, followed by a grandchild, and so on.
+     */
+    Direction[Direction["AscExcl"] = 0] = "AscExcl";
+    /**
+     * Descending inclusive.
+     *
+     * The sequence of blocks in the response should start with the given block, followed by its parent, grandparent, and so on.
+     */
+    Direction[Direction["DescIncl"] = 1] = "DescIncl";
+})(Direction || (Direction = {}));
+export class BlockRequest extends WithDebug {
+    headerHash;
+    direction;
+    maxBlocks;
+    static Codec = codec.Class(BlockRequest, {
+        headerHash: codec.bytes(HASH_SIZE).asOpaque(),
+        direction: codec.u8.convert((i) => tryAsU8(i), (i) => {
+            switch (i) {
+                case Direction.AscExcl:
+                    return Direction.AscExcl;
+                case Direction.DescIncl:
+                    return Direction.DescIncl;
+                default:
+                    throw new Error(`Invalid 'Direction' value: ${i}`);
+            }
+        }),
+        maxBlocks: codec.u32,
+    });
+    static create({ headerHash, direction, maxBlocks }) {
+        return new BlockRequest(headerHash, direction, maxBlocks);
+    }
+    constructor(headerHash, direction, maxBlocks) {
+        super();
+        this.headerHash = headerHash;
+        this.direction = direction;
+        this.maxBlocks = maxBlocks;
+    }
+}
+const logger = Logger.new(import.meta.filename, "protocol/ce-128");
+export class ServerHandler {
+    chainSpec;
+    getBlockSequence;
+    kind = STREAM_KIND;
+    constructor(chainSpec, getBlockSequence) {
+        this.chainSpec = chainSpec;
+        this.getBlockSequence = getBlockSequence;
+    }
+    onStreamMessage(sender, message) {
+        const request = Decoder.decodeObject(BlockRequest.Codec, message);
+        logger.log `[${sender.streamId}] Client has requested: ${request}`;
+        const blocks = this.getBlockSequence(sender.streamId, request.headerHash, request.direction, request.maxBlocks);
+        sender.bufferAndSend(Encoder.encodeObject(codec.sequenceFixLen(Block.Codec.View, blocks.length), blocks, this.chainSpec));
+        sender.close();
+    }
+    onClose() { }
+}
+export class ClientHandler {
+    chainSpec;
+    kind = STREAM_KIND;
+    promiseResolvers = new Map();
+    promiseRejectors = new Map();
+    constructor(chainSpec) {
+        this.chainSpec = chainSpec;
+    }
+    onStreamMessage(sender, message) {
+        if (!this.promiseResolvers.has(sender.streamId)) {
+            throw new Error("Received an unexpected message from the server.");
+        }
+        const blocks = Decoder.decodeSequence(Block.Codec.View, message, this.chainSpec);
+        logger.log `[${sender.streamId}] Server returned ${blocks.length} blocks in ${message.length} bytes of data.`;
+        this.promiseResolvers.get(sender.streamId)?.(blocks);
+        this.promiseResolvers.delete(sender.streamId);
+    }
+    onClose(streamId) {
+        this.promiseRejectors.get(streamId)?.("Stream closed.");
+        this.promiseResolvers.delete(streamId);
+        this.promiseRejectors.delete(streamId);
+    }
+    async requestBlockSequence(sender, headerHash, direction, maxBlocks) {
+        if (this.promiseResolvers.has(sender.streamId)) {
+            throw new Error("It is disallowed to use the same stream for multiple requests.");
+        }
+        return new Promise((resolve, reject) => {
+            this.promiseResolvers.set(sender.streamId, resolve);
+            this.promiseRejectors.set(sender.streamId, reject);
+            sender.bufferAndSend(Encoder.encodeObject(BlockRequest.Codec, BlockRequest.create({ headerHash, direction, maxBlocks })));
+            sender.close();
+        });
+    }
+}
+/** Error when querying blocks from DB. */
+export var BlockSequenceError;
+(function (BlockSequenceError) {
+    /** We don't have the start block in our db. */
+    BlockSequenceError[BlockSequenceError["NoStartBlock"] = 0] = "NoStartBlock";
+    /** When looking up the start block from the tip of the chain it wasn't found. */
+    BlockSequenceError[BlockSequenceError["BlockOnFork"] = 1] = "BlockOnFork";
+})(BlockSequenceError || (BlockSequenceError = {}));
+/** Handle request for block sequence by looking them up in the db. */
+export function handleGetBlockSequence(chainSpec, blocks, startHash, direction, limit) {
+    const getBlockView = (hash) => {
+        const header = blocks.getHeader(hash);
+        const extrinsic = blocks.getExtrinsic(hash);
+        if (header === null || extrinsic === null) {
+            return null;
+        }
+        const blockView = BytesBlob.blobFromParts(header.encoded().raw, extrinsic.encoded().raw);
+        return Decoder.decodeObject(Block.Codec.View, blockView, chainSpec);
+    };
+    const startBlock = getBlockView(startHash);
+    if (startBlock === null) {
+        return Result.error(BlockSequenceError.NoStartBlock, () => `Block sequence error: start block ${startHash} not found`);
+    }
+    if (direction === Direction.AscExcl) {
+        // Since we don't have an index of all blocks, we need to start from
+        // the last block and reach the `startBlock`.
+        const response = [];
+        const startIndex = startBlock.header.view().timeSlotIndex.materialize();
+        let currentHash = blocks.getBestHeaderHash();
+        for (;;) {
+            const currentHeader = blocks.getHeader(currentHash);
+            // some errornuous situation, we didn't really reach the block?
+            if (currentHeader === null || currentHeader.timeSlotIndex.materialize() < startIndex) {
+                return Result.error(BlockSequenceError.BlockOnFork, () => `Block sequence error: start block ${startHash} appears to be on a fork`);
+            }
+            // we have everything we need, let's return it now
+            if (startHash.isEqualTo(currentHash)) {
+                return Result.ok(response
+                    .reverse()
+                    .slice(0, limit)
+                    .flatMap((hash) => {
+                    const view = getBlockView(hash);
+                    return view === null ? [] : [view];
+                }));
+            }
+            // otherwise include current hash in potential response and move further down.
+            response.push(currentHash);
+            currentHash = currentHeader.parentHeaderHash.materialize();
+        }
+    }
+    const response = [startBlock];
+    let currentBlock = startBlock;
+    // now iterate a bit over ancestor blocks
+    for (let i = 0; i < limit; i++) {
+        const parent = getBlockView(currentBlock.header.view().parentHeaderHash.materialize());
+        if (parent === null) {
+            break;
+        }
+        response.push(parent);
+        currentBlock = parent;
+    }
+    return Result.ok(response);
+}

package/packages/jam/jamnp-s/protocol/ce-128-block-request.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ce-128-block-request.test.d.ts.map

package/packages/jam/jamnp-s/protocol/ce-128-block-request.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ce-128-block-request.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/protocol/ce-128-block-request.test.ts"],"names":[],"mappings":""}

package/packages/jam/jamnp-s/protocol/ce-128-block-request.test.js

@@ -0,0 +1,36 @@
+import assert from "node:assert";
+import { before, describe, it } from "node:test";
+import { testBlockView } from "#@typeberry/block/test-helpers.js";
+import { tinyChainSpec } from "#@typeberry/config";
+import { Blake2b } from "#@typeberry/hash";
+import { tryAsU32 } from "#@typeberry/numbers";
+import { OK } from "#@typeberry/utils";
+import { ClientHandler, Direction, ServerHandler, STREAM_KIND } from "./ce-128-block-request.js";
+import { testClientServer } from "./test-utils.js";
+let HEADER_HASH;
+before(async () => {
+    const blake2b = await Blake2b.createHasher();
+    HEADER_HASH = blake2b.hashString("0x7e1b07b8039cf840d51c4825362948c8ecb8fce1d290f705c269b6bcc7992731").asOpaque();
+});
+const MAX_BLOCKS = tryAsU32(10);
+const TEST_BLOCK_VIEW = testBlockView();
+describe("CE 128: Block Request", () => {
+    it("sends a block request and receives a sequence of blocks", async () => {
+        const handlers = testClientServer();
+        handlers.server.registerHandlers(new ServerHandler(tinyChainSpec, getBlockSequence));
+        handlers.client.registerHandlers(new ClientHandler(tinyChainSpec));
+        const receivedData = await new Promise((resolve) => {
+            handlers.client.withNewStream(STREAM_KIND, (handler, sender) => {
+                (async () => {
+                    const blocks = await handler.requestBlockSequence(sender, HEADER_HASH, Direction.DescIncl, MAX_BLOCKS);
+                    resolve(blocks);
+                })();
+                return OK;
+            });
+        });
+        assert.deepStrictEqual(`${receivedData.map((x) => x.encoded())}`, `${[TEST_BLOCK_VIEW, TEST_BLOCK_VIEW].map((x) => x.encoded())}`);
+    });
+});
+const getBlockSequence = (_streamId, _hash, _direction, _maxBlocks) => {
+    return [TEST_BLOCK_VIEW, TEST_BLOCK_VIEW];
+};