@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

package/packages/jam/jamnp-s/protocol/ce-129-state-request.d.ts

@@ -0,0 +1,62 @@
+import type { HeaderHash } from "#@typeberry/block";
+import { Bytes, type BytesBlob } from "#@typeberry/bytes";
+import { type CodecRecord } from "#@typeberry/codec";
+import { type U32 } from "#@typeberry/numbers";
+import { TRUNCATED_KEY_BYTES, TrieNode } from "#@typeberry/trie/nodes.js";
+import { WithDebug } from "#@typeberry/utils";
+import { type StreamHandler, type StreamId, type StreamMessageSender } from "./stream.js";
+/**
+ * JAM-SNP CE-129 stream.
+ *
+ * https://github.com/zdave-parity/jam-np/blob/main/simple.md#ce-129-state-request
+ */
+export declare const STREAM_KIND: 129 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+export type Key = Bytes<TRUNCATED_KEY_BYTES>;
+export declare class KeyValuePair extends WithDebug {
+    readonly key: Key;
+    readonly value: BytesBlob;
+    static Codec: import("@typeberry/codec").Descriptor<KeyValuePair, import("@typeberry/codec").ViewOf<KeyValuePair, {
+        key: import("@typeberry/codec").Descriptor<Bytes<31>, Bytes<31>>;
+        value: import("@typeberry/codec").Descriptor<BytesBlob, BytesBlob>;
+    }>>;
+    static create({ key, value }: CodecRecord<KeyValuePair>): KeyValuePair;
+    constructor(key: Key, value: BytesBlob);
+}
+export declare class StateResponse extends WithDebug {
+    readonly keyValuePairs: KeyValuePair[];
+    static Codec: import("@typeberry/codec").Descriptor<StateResponse, import("@typeberry/codec").ViewOf<StateResponse, {
+        keyValuePairs: import("@typeberry/codec").Descriptor<KeyValuePair[], import("@typeberry/codec").SequenceView<KeyValuePair, import("@typeberry/codec").ViewOf<KeyValuePair, {
+            key: import("@typeberry/codec").Descriptor<Bytes<31>, Bytes<31>>;
+            value: import("@typeberry/codec").Descriptor<BytesBlob, BytesBlob>;
+        }>>>;
+    }>>;
+    static create({ keyValuePairs }: CodecRecord<StateResponse>): StateResponse;
+    private constructor();
+}
+export declare class StateRequest extends WithDebug {
+    readonly headerHash: HeaderHash;
+    readonly startKey: Key;
+    readonly endKey: Key;
+    readonly maximumSize: U32;
+    static Codec: import("@typeberry/codec").Descriptor<StateRequest, import("@typeberry/codec").ViewOf<StateRequest, {
+        headerHash: import("@typeberry/codec").Descriptor<Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, Bytes<32>>;
+        startKey: import("@typeberry/codec").Descriptor<Bytes<31>, Bytes<31>>;
+        endKey: import("@typeberry/codec").Descriptor<Bytes<31>, Bytes<31>>;
+        maximumSize: import("@typeberry/codec").Descriptor<U32, Bytes<4>>;
+    }>>;
+    static create({ headerHash, startKey, endKey, maximumSize }: CodecRecord<StateRequest>): StateRequest;
+    private constructor();
+}
+export declare class Handler implements StreamHandler<typeof STREAM_KIND> {
+    private readonly isServer;
+    private readonly getBoundaryNodes?;
+    private readonly getKeyValuePairs?;
+    kind: 129 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+    private readonly boundaryNodes;
+    private readonly onResponse;
+    constructor(isServer?: boolean, getBoundaryNodes?: ((hash: HeaderHash, startKey: Key, endKey: Key) => TrieNode[]) | undefined, getKeyValuePairs?: ((hash: HeaderHash, startKey: Key, endKey: Key) => KeyValuePair[]) | undefined);
+    onStreamMessage(sender: StreamMessageSender, message: BytesBlob): void;
+    onClose(streamId: StreamId): void;
+    getStateByKey(sender: StreamMessageSender, headerHash: HeaderHash, startKey: StateRequest["startKey"], onResponse: (state: StateResponse) => void): void;
+}
+//# sourceMappingURL=ce-129-state-request.d.ts.map

package/packages/jam/jamnp-s/protocol/ce-129-state-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ce-129-state-request.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/protocol/ce-129-state-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,KAAK,WAAW,EAA2B,MAAM,kBAAkB,CAAC;AAG7E,OAAO,EAAY,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,mBAAmB,EAAmB,MAAM,aAAa,CAAC;AAE3G;;;;GAIG;AAEH,eAAO,MAAM,WAAW,+DAAuB,CAAC;AAGhD,MAAM,MAAM,GAAG,GAAG,KAAK,CAAC,mBAAmB,CAAC,CAAC;AAO7C,qBAAa,YAAa,SAAQ,SAAS;aAWvB,GAAG,EAAE,GAAG;aACR,KAAK,EAAE,SAAS;IAXlC,MAAM,CAAC,KAAK;;;QAGT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,WAAW,CAAC,YAAY,CAAC;gBAKrC,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,SAAS;CAInC;AAED,qBAAa,aAAc,SAAQ,SAAS;aASN,aAAa,EAAE,YAAY,EAAE;IARjE,MAAM,CAAC,KAAK;;;;;QAET;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,EAAE,WAAW,CAAC,aAAa,CAAC;IAI3D,OAAO;CAGR;AAED,qBAAa,YAAa,SAAQ,SAAS;aAavB,UAAU,EAAE,UAAU;aACtB,QAAQ,EAAE,GAAG;aACb,MAAM,EAAE,GAAG;aACX,WAAW,EAAE,GAAG;IAflC,MAAM,CAAC,KAAK;;;;;QAKT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,WAAW,CAAC,YAAY,CAAC;IAItF,OAAO;CAQR;AAID,qBAAa,OAAQ,YAAW,aAAa,CAAC,OAAO,WAAW,CAAC;IAO7D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IAClC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IARpC,IAAI,gEAAe;IAEnB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAwC;IACtE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA4D;gBAGpE,QAAQ,GAAE,OAAe,EACzB,gBAAgB,CAAC,GAAE,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,QAAQ,EAAE,aAAA,EAC/E,gBAAgB,CAAC,GAAE,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,YAAY,EAAE,aAAA;IAOtG,eAAe,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI;IA+BtE,OAAO,CAAC,QAAQ,EAAE,QAAQ;IAK1B,aAAa,CACX,MAAM,EAAE,mBAAmB,EAC3B,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,YAAY,CAAC,UAAU,CAAC,EAClC,UAAU,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI;CAc7C"}

package/packages/jam/jamnp-s/protocol/ce-129-state-request.js

@@ -0,0 +1,119 @@
+import { Bytes } from "#@typeberry/bytes";
+import { codec, Decoder, Encoder } from "#@typeberry/codec";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { Logger } from "#@typeberry/logger";
+import { tryAsU32 } from "#@typeberry/numbers";
+import { TRUNCATED_KEY_BYTES, TrieNode } from "#@typeberry/trie/nodes.js";
+import { WithDebug } from "#@typeberry/utils";
+import { tryAsStreamKind } from "./stream.js";
+/**
+ * JAM-SNP CE-129 stream.
+ *
+ * https://github.com/zdave-parity/jam-np/blob/main/simple.md#ce-129-state-request
+ */
+export const STREAM_KIND = tryAsStreamKind(129);
+const TRIE_NODE_BYTES = 64;
+const trieNodeCodec = codec.bytes(TRIE_NODE_BYTES).convert((i) => Bytes.fromBlob(i.raw, TRIE_NODE_BYTES), (i) => new TrieNode(i.raw));
+export class KeyValuePair extends WithDebug {
+    key;
+    value;
+    static Codec = codec.Class(KeyValuePair, {
+        key: codec.bytes(TRUNCATED_KEY_BYTES),
+        value: codec.blob,
+    });
+    static create({ key, value }) {
+        return new KeyValuePair(key, value);
+    }
+    constructor(key, value) {
+        super();
+        this.key = key;
+        this.value = value;
+    }
+}
+export class StateResponse extends WithDebug {
+    keyValuePairs;
+    static Codec = codec.Class(StateResponse, {
+        keyValuePairs: codec.sequenceVarLen(KeyValuePair.Codec),
+    });
+    static create({ keyValuePairs }) {
+        return new StateResponse(keyValuePairs);
+    }
+    constructor(keyValuePairs) {
+        super();
+        this.keyValuePairs = keyValuePairs;
+    }
+}
+export class StateRequest extends WithDebug {
+    headerHash;
+    startKey;
+    endKey;
+    maximumSize;
+    static Codec = codec.Class(StateRequest, {
+        headerHash: codec.bytes(HASH_SIZE).asOpaque(),
+        startKey: codec.bytes(TRUNCATED_KEY_BYTES),
+        endKey: codec.bytes(TRUNCATED_KEY_BYTES),
+        maximumSize: codec.u32,
+    });
+    static create({ headerHash, startKey, endKey, maximumSize }) {
+        return new StateRequest(headerHash, startKey, endKey, maximumSize);
+    }
+    constructor(headerHash, startKey, endKey, maximumSize) {
+        super();
+        this.headerHash = headerHash;
+        this.startKey = startKey;
+        this.endKey = endKey;
+        this.maximumSize = maximumSize;
+    }
+}
+const logger = Logger.new(import.meta.filename, "protocol/ce-129");
+export class Handler {
+    isServer;
+    getBoundaryNodes;
+    getKeyValuePairs;
+    kind = STREAM_KIND;
+    boundaryNodes = new Map();
+    onResponse = new Map();
+    constructor(isServer = false, getBoundaryNodes, getKeyValuePairs) {
+        this.isServer = isServer;
+        this.getBoundaryNodes = getBoundaryNodes;
+        this.getKeyValuePairs = getKeyValuePairs;
+        if (isServer && (getBoundaryNodes === undefined || getKeyValuePairs === undefined)) {
+            throw new Error("getBoundaryNodes and getKeyValuePairs are required in server mode.");
+        }
+    }
+    onStreamMessage(sender, message) {
+        if (this.isServer) {
+            logger.info `[${sender.streamId}][server]: Received request.`;
+            if (this.getBoundaryNodes === undefined || this.getKeyValuePairs === undefined) {
+                return;
+            }
+            const request = Decoder.decodeObject(StateRequest.Codec, message);
+            const boundaryNodes = this.getBoundaryNodes(request.headerHash, request.startKey, request.endKey);
+            const keyValuePairs = this.getKeyValuePairs(request.headerHash, request.startKey, request.endKey);
+            logger.info `[${sender.streamId}][server]: <-- responding with boundary nodes and key value pairs.`;
+            sender.bufferAndSend(Encoder.encodeObject(codec.sequenceVarLen(trieNodeCodec), boundaryNodes));
+            sender.bufferAndSend(Encoder.encodeObject(StateResponse.Codec, StateResponse.create({ keyValuePairs })));
+            sender.close();
+            return;
+        }
+        if (!this.boundaryNodes.has(sender.streamId)) {
+            this.boundaryNodes.set(sender.streamId, Decoder.decodeObject(codec.sequenceVarLen(trieNodeCodec), message));
+            logger.info `[${sender.streamId}][client]: Received boundary nodes.`;
+            return;
+        }
+        this.onResponse.get(sender.streamId)?.(Decoder.decodeObject(StateResponse.Codec, message));
+        logger.info `[${sender.streamId}][client]: Received state values.`;
+    }
+    onClose(streamId) {
+        this.boundaryNodes.delete(streamId);
+        this.onResponse.delete(streamId);
+    }
+    getStateByKey(sender, headerHash, startKey, onResponse) {
+        if (this.onResponse.has(sender.streamId)) {
+            throw new Error("It is disallowed to use the same stream for multiple requests.");
+        }
+        this.onResponse.set(sender.streamId, onResponse);
+        sender.bufferAndSend(Encoder.encodeObject(StateRequest.Codec, StateRequest.create({ headerHash, startKey, endKey: startKey, maximumSize: tryAsU32(4096) })));
+        sender.close();
+    }
+}

package/packages/jam/jamnp-s/protocol/ce-129-state-request.test.d.ts

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

package/packages/jam/jamnp-s/protocol/ce-129-state-request.test.d.ts.map

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

package/packages/jam/jamnp-s/protocol/ce-129-state-request.test.js

@@ -0,0 +1,42 @@
+import assert from "node:assert";
+import { before, describe, it } from "node:test";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { Blake2b } from "#@typeberry/hash";
+import { TRUNCATED_KEY_BYTES } from "#@typeberry/trie/nodes.js";
+import { OK } from "#@typeberry/utils";
+import { Handler, KeyValuePair, STREAM_KIND } from "./ce-129-state-request.js";
+import { testClientServer } from "./test-utils.js";
+let HEADER_HASH;
+let KEY;
+before(async () => {
+    const blake2b = await Blake2b.createHasher();
+    HEADER_HASH = blake2b.hashString("0x7e1b07b8039cf840d51c4825362948c8ecb8fce1d290f705c269b6bcc7992731").asOpaque();
+    KEY = Bytes.fromBlob(blake2b.hashString("0x83bd3bde264a79a2e67c487696c1d7f0b549da89").raw.subarray(0, TRUNCATED_KEY_BYTES), TRUNCATED_KEY_BYTES);
+});
+const EXPECTED_VALUE = BytesBlob.blobFromNumbers([255, 255, 255, 0]);
+describe("CE 129: State Request", () => {
+    it("sends a state request and receives a response", async () => {
+        const handlers = testClientServer();
+        handlers.server.registerHandlers(new Handler(true, getBoundaryNodes, getKeyValuePairs));
+        handlers.client.registerHandlers(new Handler());
+        const receivedData = await new Promise((resolve) => {
+            handlers.client.withNewStream(STREAM_KIND, (handler, sender) => {
+                handler.getStateByKey(sender, HEADER_HASH, KEY, (response) => {
+                    resolve(response.keyValuePairs);
+                });
+                return OK;
+            });
+        });
+        assert.deepStrictEqual(receivedData, [new KeyValuePair(KEY, EXPECTED_VALUE)]);
+    });
+});
+const getBoundaryNodes = () => {
+    return [];
+};
+const getKeyValuePairs = (_hash, startKey) => {
+    let value = BytesBlob.blobFromNumbers([255, 255, 0, 0]);
+    if (KEY.isEqualTo(startKey)) {
+        value = EXPECTED_VALUE;
+    }
+    return [new KeyValuePair(startKey, value)];
+};

package/packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.d.ts

@@ -0,0 +1,45 @@
+import type { Epoch } from "#@typeberry/block";
+import { SignedTicket } from "#@typeberry/block/tickets.js";
+import type { BytesBlob } from "#@typeberry/bytes";
+import { type CodecRecord } from "#@typeberry/codec";
+import { WithDebug } from "#@typeberry/utils";
+import { type StreamHandler, type StreamMessageSender } from "./stream.js";
+/**
+ * JAM-SNP CE-131 and CE-132 streams.
+ *
+ * Safrole ticket distribution from generating validator to proxy validator (131) and from proxy validator to all validators (132).
+ *
+ * https://github.com/zdave-parity/jam-np/blob/main/simple.md#ce-131132-safrole-ticket-distribution
+ */
+export declare const STREAM_KIND_GENERATOR_TO_PROXY: 131 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+export declare const STREAM_KIND_PROXY_TO_ALL: 132 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+type STREAM_KIND = typeof STREAM_KIND_GENERATOR_TO_PROXY | typeof STREAM_KIND_PROXY_TO_ALL;
+export declare class TicketDistributionRequest extends WithDebug {
+    readonly epochIndex: Epoch;
+    readonly ticket: SignedTicket;
+    static Codec: import("@typeberry/codec").Descriptor<TicketDistributionRequest, import("@typeberry/codec").ViewOf<TicketDistributionRequest, {
+        epochIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"Epoch">, import("@typeberry/bytes").Bytes<4>>;
+        ticket: import("@typeberry/codec").Descriptor<SignedTicket, import("@typeberry/codec").ViewOf<SignedTicket, {
+            attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U8>;
+            signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<784> & import("@typeberry/utils").WithOpaque<"BandersnatchRingSignature">, import("@typeberry/bytes").Bytes<784>>;
+        }>>;
+    }>>;
+    static create({ epochIndex, ticket }: CodecRecord<TicketDistributionRequest>): TicketDistributionRequest;
+    private constructor();
+}
+export declare class ServerHandler<T extends STREAM_KIND> implements StreamHandler<T> {
+    readonly kind: T;
+    private readonly onTicketReceived;
+    constructor(kind: T, onTicketReceived: (epochIndex: Epoch, ticket: SignedTicket) => void);
+    onStreamMessage(sender: StreamMessageSender, message: BytesBlob): void;
+    onClose(): void;
+}
+export declare class ClientHandler<T extends STREAM_KIND> implements StreamHandler<T> {
+    readonly kind: T;
+    constructor(kind: T);
+    onStreamMessage(sender: StreamMessageSender): void;
+    onClose(): void;
+    sendTicket(sender: StreamMessageSender, epochIndex: Epoch, ticket: SignedTicket): void;
+}
+export {};
+//# sourceMappingURL=ce-131-ce-132-safrole-ticket-distribution.d.ts.map

package/packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ce-131-ce-132-safrole-ticket-distribution.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,KAAK,WAAW,EAA2B,MAAM,kBAAkB,CAAC;AAE7E,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,mBAAmB,EAAmB,MAAM,aAAa,CAAC;AAE5F;;;;;;GAMG;AAEH,eAAO,MAAM,8BAA8B,+DAAuB,CAAC;AACnE,eAAO,MAAM,wBAAwB,+DAAuB,CAAC;AAE7D,KAAK,WAAW,GAAG,OAAO,8BAA8B,GAAG,OAAO,wBAAwB,CAAC;AAE3F,qBAAa,yBAA0B,SAAQ,SAAS;aAWpC,UAAU,EAAE,KAAK;aACjB,MAAM,EAAE,YAAY;IAXtC,MAAM,CAAC,KAAK;;;;;;QAGT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,WAAW,CAAC,yBAAyB,CAAC;IAI5E,OAAO;CAMR;AAID,qBAAa,aAAa,CAAC,CAAC,SAAS,WAAW,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;aAEzD,IAAI,EAAE,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBADjB,IAAI,EAAE,CAAC,EACN,gBAAgB,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI;IAGtF,eAAe,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI;IAOtE,OAAO;CACR;AAED,qBAAa,aAAa,CAAC,CAAC,SAAS,WAAW,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;aAC/C,IAAI,EAAE,CAAC;gBAAP,IAAI,EAAE,CAAC;IAEnC,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI;IAKlD,OAAO;IAEP,UAAU,CAAC,MAAM,EAAE,mBAAmB,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY;CAKhF"}

package/packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.js

@@ -0,0 +1,62 @@
+import { SignedTicket } from "#@typeberry/block/tickets.js";
+import { codec, Decoder, Encoder } from "#@typeberry/codec";
+import { Logger } from "#@typeberry/logger";
+import { WithDebug } from "#@typeberry/utils";
+import { tryAsStreamKind } from "./stream.js";
+/**
+ * JAM-SNP CE-131 and CE-132 streams.
+ *
+ * Safrole ticket distribution from generating validator to proxy validator (131) and from proxy validator to all validators (132).
+ *
+ * https://github.com/zdave-parity/jam-np/blob/main/simple.md#ce-131132-safrole-ticket-distribution
+ */
+export const STREAM_KIND_GENERATOR_TO_PROXY = tryAsStreamKind(131);
+export const STREAM_KIND_PROXY_TO_ALL = tryAsStreamKind(132);
+export class TicketDistributionRequest extends WithDebug {
+    epochIndex;
+    ticket;
+    static Codec = codec.Class(TicketDistributionRequest, {
+        epochIndex: codec.u32.asOpaque(),
+        ticket: SignedTicket.Codec,
+    });
+    static create({ epochIndex, ticket }) {
+        return new TicketDistributionRequest(epochIndex, ticket);
+    }
+    constructor(epochIndex, ticket) {
+        super();
+        this.epochIndex = epochIndex;
+        this.ticket = ticket;
+    }
+}
+const logger = Logger.new(import.meta.filename, "protocol/ce-131-ce-132");
+export class ServerHandler {
+    kind;
+    onTicketReceived;
+    constructor(kind, onTicketReceived) {
+        this.kind = kind;
+        this.onTicketReceived = onTicketReceived;
+    }
+    onStreamMessage(sender, message) {
+        const ticketDistribution = Decoder.decodeObject(TicketDistributionRequest.Codec, message);
+        logger.log `[${sender.streamId}][ce-${this.kind}] Received ticket for epoch ${ticketDistribution.epochIndex}`;
+        this.onTicketReceived(ticketDistribution.epochIndex, ticketDistribution.ticket);
+        sender.close();
+    }
+    onClose() { }
+}
+export class ClientHandler {
+    kind;
+    constructor(kind) {
+        this.kind = kind;
+    }
+    onStreamMessage(sender) {
+        logger.warn `[${sender.streamId}][ce-${this.kind}] Unexpected message received. Closing.`;
+        sender.close();
+    }
+    onClose() { }
+    sendTicket(sender, epochIndex, ticket) {
+        const request = TicketDistributionRequest.create({ epochIndex, ticket });
+        sender.bufferAndSend(Encoder.encodeObject(TicketDistributionRequest.Codec, request));
+        sender.close();
+    }
+}

package/packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ce-131-ce-132-safrole-ticket-distribution.test.d.ts.map

package/packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ce-131-ce-132-safrole-ticket-distribution.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.test.ts"],"names":[],"mappings":""}

package/packages/jam/jamnp-s/protocol/ce-131-ce-132-safrole-ticket-distribution.test.js

@@ -0,0 +1,31 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsEpoch } from "#@typeberry/block";
+import { SignedTicket, tryAsTicketAttempt } from "#@typeberry/block/tickets.js";
+import { Bytes } from "#@typeberry/bytes";
+import { BANDERSNATCH_PROOF_BYTES } from "#@typeberry/crypto";
+import { OK } from "#@typeberry/utils";
+import { ClientHandler, ServerHandler, STREAM_KIND_GENERATOR_TO_PROXY, } from "./ce-131-ce-132-safrole-ticket-distribution.js";
+import { testClientServer } from "./test-utils.js";
+const TEST_EPOCH = tryAsEpoch(1);
+const TEST_TICKET = SignedTicket.create({
+    attempt: tryAsTicketAttempt(0),
+    signature: Bytes.zero(BANDERSNATCH_PROOF_BYTES).asOpaque(),
+});
+describe("CE 131 and CE 132: Safrole Ticket Distribution", () => {
+    it("Client sends a ticket distribution request and the server receives it", async () => {
+        const handlers = testClientServer();
+        await new Promise((resolve) => {
+            handlers.server.registerHandlers(new ServerHandler(STREAM_KIND_GENERATOR_TO_PROXY, (epochIndex, ticket) => {
+                assert.strictEqual(epochIndex, TEST_EPOCH);
+                assert.deepStrictEqual(ticket, TEST_TICKET);
+                resolve(undefined);
+            }));
+            handlers.client.registerHandlers(new ClientHandler(STREAM_KIND_GENERATOR_TO_PROXY));
+            handlers.client.withNewStream(STREAM_KIND_GENERATOR_TO_PROXY, (handler, sender) => {
+                handler.sendTicket(sender, TEST_EPOCH, TEST_TICKET);
+                return OK;
+            });
+        });
+    });
+});

package/packages/jam/jamnp-s/protocol/ce-133-work-package-submission.d.ts

@@ -0,0 +1,69 @@
+import type { CoreIndex } from "#@typeberry/block";
+import { type WorkItemExtrinsics } from "#@typeberry/block/work-item.js";
+import { WorkPackage } from "#@typeberry/block/work-package.js";
+import type { BytesBlob } from "#@typeberry/bytes";
+import { type CodecRecord } from "#@typeberry/codec";
+import { WithDebug } from "#@typeberry/utils";
+import { type StreamHandler, type StreamId, type StreamMessageSender } from "./stream.js";
+/**
+ * JAMNP-S CE 133 Stream
+ *
+ * Submission of a work-package from a builder to a guarantor.
+ *
+ * https://github.com/zdave-parity/jam-np/blob/main/simple.md#ce-133-work-package-submission
+ */
+export declare const STREAM_KIND: 133 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+export declare class CoreWorkPackage extends WithDebug {
+    readonly coreIndex: CoreIndex;
+    readonly workPackage: WorkPackage;
+    static Codec: import("@typeberry/codec").Descriptor<CoreWorkPackage, import("@typeberry/codec").ViewOf<CoreWorkPackage, {
+        coreIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"CoreIndex[u16]">, import("@typeberry/bytes").Bytes<2>>;
+        workPackage: import("@typeberry/codec").Descriptor<WorkPackage, import("@typeberry/codec").ViewOf<WorkPackage, {
+            authCodeHost: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">, import("@typeberry/bytes").Bytes<4>>;
+            authCodeHash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"CodeHash">, import("@typeberry/bytes").Bytes<32>>;
+            context: import("@typeberry/codec").Descriptor<import("@typeberry/block/refine-context.js").RefineContext, import("@typeberry/codec").ViewOf<import("@typeberry/block/refine-context.js").RefineContext, {
+                anchor: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+                stateRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"StateRootHash">, import("@typeberry/bytes").Bytes<32>>;
+                beefyRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"BeefyHash">, import("@typeberry/bytes").Bytes<32>>;
+                lookupAnchor: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+                lookupAnchorSlot: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">, import("@typeberry/bytes").Bytes<4>>;
+                prerequisites: import("@typeberry/codec").Descriptor<(import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"WorkPackageHash">)[], import("@typeberry/codec").SequenceView<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"WorkPackageHash">, import("@typeberry/bytes").Bytes<32>>>;
+            }>>;
+            authorization: import("@typeberry/codec").Descriptor<BytesBlob, BytesBlob>;
+            parametrization: import("@typeberry/codec").Descriptor<BytesBlob, BytesBlob>;
+            items: import("@typeberry/codec").Descriptor<import("@typeberry/collections").FixedSizeArray<import("@typeberry/block/work-item.js").WorkItem, import("@typeberry/numbers").U8>, import("@typeberry/codec").SequenceView<import("@typeberry/block/work-item.js").WorkItem, import("@typeberry/codec").ViewOf<import("@typeberry/block/work-item.js").WorkItem, {
+                service: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">, import("@typeberry/bytes").Bytes<4>>;
+                codeHash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"CodeHash">, import("@typeberry/bytes").Bytes<32>>;
+                refineGasLimit: import("@typeberry/codec").Descriptor<bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">, import("@typeberry/bytes").Bytes<8>>;
+                accumulateGasLimit: import("@typeberry/codec").Descriptor<bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">, import("@typeberry/bytes").Bytes<8>>;
+                exportCount: import("@typeberry/codec").Descriptor<import("@typeberry/numbers").U16, import("@typeberry/bytes").Bytes<2>>;
+                payload: import("@typeberry/codec").Descriptor<BytesBlob, BytesBlob>;
+                importSegments: import("@typeberry/codec").Descriptor<readonly import("@typeberry/block/work-item.js").ImportSpec[] & import("@typeberry/utils").WithOpaque<"Less than 2048">, import("@typeberry/codec").SequenceView<import("@typeberry/block/work-item.js").ImportSpec, import("@typeberry/codec").ViewOf<import("@typeberry/block/work-item.js").ImportSpec, {
+                    treeRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
+                    index: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"Segment Index [U16]">, import("@typeberry/bytes").Bytes<2>>;
+                }>>>;
+                extrinsic: import("@typeberry/codec").Descriptor<import("@typeberry/block/work-item.js").WorkItemExtrinsicSpec[], import("@typeberry/codec").SequenceView<import("@typeberry/block/work-item.js").WorkItemExtrinsicSpec, import("@typeberry/codec").ViewOf<import("@typeberry/block/work-item.js").WorkItemExtrinsicSpec, {
+                    hash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"ExtrinsicHash">, import("@typeberry/bytes").Bytes<32>>;
+                    len: import("@typeberry/codec").Descriptor<import("@typeberry/numbers").U32, import("@typeberry/bytes").Bytes<4>>;
+                }>>>;
+            }>>>;
+        }>>;
+    }>>;
+    static create({ coreIndex, workPackage }: CodecRecord<CoreWorkPackage>): CoreWorkPackage;
+    private constructor();
+}
+export declare class ServerHandler implements StreamHandler<typeof STREAM_KIND> {
+    private readonly onWorkPackage;
+    kind: 133 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+    constructor(onWorkPackage: (i: CoreIndex, w: WorkPackage, e: WorkItemExtrinsics) => void);
+    readonly workPackages: Map<import("@typeberry/numbers").U32, CoreWorkPackage>;
+    onStreamMessage(sender: StreamMessageSender, message: BytesBlob): void;
+    onClose(streamId: StreamId): void;
+}
+export declare class ClientHandler implements StreamHandler<typeof STREAM_KIND> {
+    kind: 133 & import("@typeberry/numbers").WithBytesRepresentation<1>;
+    onStreamMessage(sender: StreamMessageSender): void;
+    onClose(): void;
+    sendWorkPackage(sender: StreamMessageSender, coreIndex: CoreIndex, workPackage: WorkPackage, extrinsic: WorkItemExtrinsics): void;
+}
+//# sourceMappingURL=ce-133-work-package-submission.d.ts.map

package/packages/jam/jamnp-s/protocol/ce-133-work-package-submission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ce-133-work-package-submission.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jamnp-s/protocol/ce-133-work-package-submission.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,KAAK,kBAAkB,EAA2B,MAAM,+BAA+B,CAAC;AACjG,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,KAAK,WAAW,EAA2B,MAAM,kBAAkB,CAAC;AAE7E,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,+DAAuB,CAAC;AAEhD,qBAAa,eAAgB,SAAQ,SAAS;aAW1B,SAAS,EAAE,SAAS;aACpB,WAAW,EAAE,WAAW;IAX1C,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAGT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,EAAE,WAAW,CAAC,eAAe,CAAC;IAItE,OAAO;CAMR;AAID,qBAAa,aAAc,YAAW,aAAa,CAAC,OAAO,WAAW,CAAC;IAGzD,OAAO,CAAC,QAAQ,CAAC,aAAa;IAF1C,IAAI,gEAAe;gBAEU,aAAa,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,kBAAkB,KAAK,IAAI;IAEzG,SAAgB,YAAY,yDAAwC;IAEpE,eAAe,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI;IAiBtE,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;CAGlC;AAED,qBAAa,aAAc,YAAW,aAAa,CAAC,OAAO,WAAW,CAAC;IACrE,IAAI,gEAAe;IAEnB,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI;IAKlD,OAAO,IAAI,IAAI;IAEf,eAAe,CACb,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,kBAAkB;CAUhC"}

package/packages/jam/jamnp-s/protocol/ce-133-work-package-submission.js

@@ -0,0 +1,75 @@
+import { workItemExtrinsicsCodec } from "#@typeberry/block/work-item.js";
+import { WorkPackage } from "#@typeberry/block/work-package.js";
+import { codec, Decoder, Encoder } from "#@typeberry/codec";
+import { Logger } from "#@typeberry/logger";
+import { WithDebug } from "#@typeberry/utils";
+import { tryAsStreamKind } from "./stream.js";
+/**
+ * JAMNP-S CE 133 Stream
+ *
+ * Submission of a work-package from a builder to a guarantor.
+ *
+ * https://github.com/zdave-parity/jam-np/blob/main/simple.md#ce-133-work-package-submission
+ */
+export const STREAM_KIND = tryAsStreamKind(133);
+export class CoreWorkPackage extends WithDebug {
+    coreIndex;
+    workPackage;
+    static Codec = codec.Class(CoreWorkPackage, {
+        coreIndex: codec.u16.asOpaque(),
+        workPackage: WorkPackage.Codec,
+    });
+    static create({ coreIndex, workPackage }) {
+        return new CoreWorkPackage(coreIndex, workPackage);
+    }
+    constructor(coreIndex, workPackage) {
+        super();
+        this.coreIndex = coreIndex;
+        this.workPackage = workPackage;
+    }
+}
+const logger = Logger.new(import.meta.filename, "protocol/ce-133");
+export class ServerHandler {
+    onWorkPackage;
+    kind = STREAM_KIND;
+    constructor(onWorkPackage) {
+        this.onWorkPackage = onWorkPackage;
+    }
+    workPackages = new Map();
+    onStreamMessage(sender, message) {
+        const streamId = sender.streamId;
+        // initially we expect the `CoreWorkPackage`
+        const workPackage = this.workPackages.get(streamId);
+        if (workPackage === undefined) {
+            const coreWorkPackage = Decoder.decodeObject(CoreWorkPackage.Codec, message);
+            this.workPackages.set(streamId, coreWorkPackage);
+            return;
+        }
+        // next we expect extrinsics
+        const codec = workItemExtrinsicsCodec(workPackage.workPackage.items);
+        const extrinsics = Decoder.decodeObject(codec, message);
+        this.onWorkPackage(workPackage.coreIndex, workPackage.workPackage, extrinsics);
+        // finally we close the connection.
+        sender.close();
+    }
+    onClose(streamId) {
+        this.workPackages.delete(streamId);
+    }
+}
+export class ClientHandler {
+    kind = STREAM_KIND;
+    onStreamMessage(sender) {
+        logger.warn `[${sender.streamId}] Got unexpected message on CE-133 stream. Closing.`;
+        sender.close();
+    }
+    onClose() { }
+    sendWorkPackage(sender, coreIndex, workPackage, extrinsic) {
+        const corePack = CoreWorkPackage.create({ coreIndex, workPackage });
+        logger.trace `[${sender.streamId}] Sending work package: ${corePack}`;
+        sender.bufferAndSend(Encoder.encodeObject(CoreWorkPackage.Codec, corePack));
+        logger.trace `[${sender.streamId}] Sending extrinsics: ${workPackage.items}`;
+        sender.bufferAndSend(Encoder.encodeObject(workItemExtrinsicsCodec(workPackage.items), extrinsic));
+        // now close the connection
+        sender.close();
+    }
+}

package/packages/jam/jamnp-s/protocol/ce-133-work-package-submission.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ce-133-work-package-submission.test.d.ts.map

package/packages/jam/jamnp-s/protocol/ce-133-work-package-submission.test.d.ts.map

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

package/packages/jam/jamnp-s/protocol/ce-133-work-package-submission.test.js

@@ -0,0 +1,47 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsCoreIndex } from "#@typeberry/block";
+import { WorkPackage } from "#@typeberry/block/work-package.js";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { Decoder } from "#@typeberry/codec";
+import { asKnownSize } from "#@typeberry/collections";
+import { tryAsU32 } from "#@typeberry/numbers";
+import { OK } from "#@typeberry/utils";
+import { ClientHandler, ServerHandler, STREAM_KIND } from "./ce-133-work-package-submission.js";
+import { testClientServer } from "./test-utils.js";
+describe("CE133", () => {
+    it("should send a work package", async () => {
+        const handlers = testClientServer();
+        let receivedData = {};
+        const server = new ServerHandler((coreIndex, workPackage, extrinsic) => {
+            receivedData = { coreIndex, workPackage, extrinsic };
+        });
+        const client = new ClientHandler();
+        handlers.server.registerHandlers(server);
+        handlers.client.registerHandlers(client);
+        // when
+        handlers.client.withNewStream(STREAM_KIND, (handler, sender) => {
+            const workPackage = Decoder.decodeObject(WorkPackage.Codec, BytesBlob.parseBlob(testWorkPackage));
+            const extrinsic = testExtrinsicData();
+            handler.sendWorkPackage(sender, tryAsCoreIndex(0), workPackage, extrinsic);
+            return OK;
+        });
+        await new Promise((resolve) => {
+            setImmediate(() => {
+                // then
+                assert.deepStrictEqual(receivedData.coreIndex, tryAsCoreIndex(0));
+                assert.deepStrictEqual(receivedData.workPackage, Decoder.decodeObject(WorkPackage.Codec, BytesBlob.parseBlob(testWorkPackage)));
+                assert.deepStrictEqual(receivedData.extrinsic, testExtrinsicData());
+                resolve(null);
+            });
+        });
+    });
+});
+const testWorkPackage = "0x78563412022e5e165cc8bd586404257f5cd6f5a31177b5c951eb076c7c10174f90006eefc0564c5e0de0942589df4343ad1956da66797240e2a2f2d6f8116b5047768986f6967658df626fa39cbfb6014b50196d23bc2cfbfa71a7591ca7715472dd2b489329de635d4bbb8c47cdccbbc1285e48bf9dbad365af44b205343e99dea298f360751ab5b251361fbfd3ad5b0e84f051ccece6b00830aed31a5354e00b20b9ed21000000000501020304050a00010203040506070809020403020170a50829851e8f6a8c80f92806ae0e95eb7c06ad064e311cc39107b3219e532e2a000000000000002a00000000000000040005010203040503461236a7eb29dcffc1dd282ce1de0e0ed691fc80e91e02276fe8f778f088a1b80000e7cb536522c1c1b41fff8021055b774e929530941ea12c10f1213c56455f29ad0100b0a487a4adf6a0eda5d69ddd2f8b241cf44204f0ff793e993e5e553b7862a1dc020002381a0e351c5593018bbc87dd6694695caa1c0c1ddb24e70995da878d89495bf1100000006c437d85cd8327f42a35d427ede1b5871347d3aae7442f2df1ff80f834acf17a1100000008070605fcfc857dab216daf41f409c2012685846e4d34aedfeacaf84d9adfebda73fae64d000000000000004d00000000000000070003030201023e5d0bea78537414bd1cfdaeb0f22d743bcaba5dbffacbabce8457f4cd78f69b0000b7f8dffa65971832ec9e19719debc04b1ccd9ad27187a4943807ca756962481b01000380b628780612e8928705018d1ced53b2f76607ad026a86e4f36c99ac0491f8eb2000000047f142b4488bbd34e59afc60a0daedc6020e8be52a3cedecbd75e93ee9908adf21000000cc2f47030ff8a9fe8d02e8eb87e86d4db05b57258d30f9d81acb3b280d04e87722000000";
+const testExtrinsicData = () => {
+    // this is coming from work items in the `testWorkPackage`;
+    const lengths = [16, 17, 32, 33, 34];
+    return asKnownSize(lengths.map((len, idx) => {
+        return Bytes.fill(tryAsU32(len), idx);
+    }));
+};